/*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to You under the Apache License, Version 2.0

  * (the "License"); you may not use this file except in compliance with

  * the License.  You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.commons.beanutils;

 import java.beans.PropertyDescriptor;

 import java.lang.ref.Reference;

 import java.lang.ref.SoftReference;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.Set;

 import java.util.WeakHashMap;

 /**

  * <p>Implementation of <code>DynaClass</code> for DynaBeans that wrap

  * standard JavaBean instances.</p>

  *

  * <p>

  * It is suggested that this class should not usually need to be used directly

  * to create new <code>WrapDynaBean</code> instances. 

  * It's usually better to call the <code>WrapDynaBean</code> constructor directly.

  * For example:</p>

  * <code><pre>

  *   Object javaBean = ...;

  *   DynaBean wrapper = new WrapDynaBean(javaBean);

  * </pre></code>

  * <p>

  *

  * @author Craig McClanahan

  * @version $Revision: 690380 $ $Date: 2008-08-29 16:04:38 -0400 (Fri, 29 Aug 2008) $

  */

 public class WrapDynaClass implements DynaClass {

     // ----------------------------------------------------------- Constructors

     /**

      * Construct a new WrapDynaClass for the specified JavaBean class.  This

      * constructor is private; WrapDynaClass instances will be created as

      * needed via calls to the <code>createDynaClass(Class)</code> method.

      *

      * @param beanClass JavaBean class to be introspected around

      */

     private WrapDynaClass(Class beanClass) {

         this.beanClassRef = new SoftReference(beanClass);

         this.beanClassName = beanClass.getName();

         introspect();

     }

     // ----------------------------------------------------- Instance Variables

     /**

      * Name of the JavaBean class represented by this WrapDynaClass.

      */

     private String beanClassName = null;

     /**

      * Reference to the JavaBean class represented by this WrapDynaClass.

      */

     private Reference beanClassRef = null;

     /**

      * The JavaBean <code>Class</code> which is represented by this

      * <code>WrapDynaClass</code>.

      *

      * @deprecated No longer initialized, use getBeanClass() method instead

      */

     protected Class beanClass = null;

     /**

      * The set of PropertyDescriptors for this bean class.

      */

     protected PropertyDescriptor[] descriptors = null;

     /**

      * The set of PropertyDescriptors for this bean class, keyed by the

      * property name.  Individual descriptor instances will be the same

      * instances as those in the <code>descriptors</code> list.

      */

     protected HashMap descriptorsMap = new HashMap();

     /**

      * The set of dynamic properties that are part of this DynaClass.

      */

     protected DynaProperty[] properties = null;

     /**

      * The set of dynamic properties that are part of this DynaClass,

      * keyed by the property name.  Individual descriptor instances will

      * be the same instances as those in the <code>properties</code> list.

      */

     protected HashMap propertiesMap = new HashMap();

     // ------------------------------------------------------- Static Variables

     private static final ContextClassLoaderLocal CLASSLOADER_CACHE = 

         new ContextClassLoaderLocal() {

             protected Object initialValue() {

                 return new WeakHashMap();

         }

     };

     /**

      * Get the wrap dyna classes cache

      */

     private static Map getDynaClassesMap() {

         return (Map)CLASSLOADER_CACHE.get();

     }

     /**

      * The set of <code>WrapDynaClass</code> instances that have ever been

      * created, keyed by the underlying bean Class. The keys to this map

      * are Class objects, and the values are corresponding WrapDynaClass

      * objects.

      * <p>

      * This static variable is safe even when this code is deployed via a

      * shared classloader because it is keyed via a Class object. The same

      * class loaded via two different classloaders will result in different

      * entries in this map.

      * <p>

      * Note, however, that this HashMap can result in a memory leak. When

      * this class is in a shared classloader it will retain references to

      * classes loaded via a webapp classloader even after the webapp has been

      * undeployed. That will prevent the entire classloader and all the classes

      * it refers to and all their static members from being freed.

      *

      ************* !!!!!!!!!!!! PLEASE NOTE !!!!!!!!!!!! *************

      *

      * THE FOLLOWING IS A NASTY HACK TO SO THAT BEANUTILS REMAINS BINARY

      *              COMPATIBLE WITH PREVIOUS RELEASES.

      *

      * There are two issues here:

      * 

      * 1) Memory Issues: The static HashMap caused memory problems (See BEANUTILS-59)

      *    to resolve this it has been moved into a ContextClassLoaderLocal instance

      *    (named CLASSLOADER_CACHE above) which holds one copy per

      *    ClassLoader in a WeakHashMap.

      * 

      * 2) Binary Compatibility: As the "dynaClasses" static HashMap is "protected"

      *    removing it breaks BeanUtils binary compatibility with previous versions.

      *    To resolve this all the methods have been overriden to delegate to the

      *    Map for the ClassLoader in the ContextClassLoaderLocal.

      *

      * @deprecated The dynaClasses Map will be removed in a subsequent release

      */

     protected static HashMap dynaClasses = new HashMap() {

         public void clear() {

             getDynaClassesMap().clear();

         }

         public boolean containsKey(Object key) {

             return getDynaClassesMap().containsKey(key);

         }

         public boolean containsValue(Object value) {

             return getDynaClassesMap().containsValue(value);

         }

         public Set entrySet() {

             return getDynaClassesMap().entrySet();

         }

         public boolean equals(Object o) {

             return getDynaClassesMap().equals(o);

         }

         public Object get(Object key) {

             return getDynaClassesMap().get(key);

         }

         public int hashCode() {

             return getDynaClassesMap().hashCode();

         }

         public boolean isEmpty() {

             return getDynaClassesMap().isEmpty();

         }

         public Set keySet() {

             return getDynaClassesMap().keySet();

         }

         public Object put(Object key, Object value) {

             return getDynaClassesMap().put(key, value);

         }

         public void putAll(Map m) {

             getDynaClassesMap().putAll(m);

         }

         public Object remove(Object key) {

             return getDynaClassesMap().remove(key);

         }

         public int size() {

             return getDynaClassesMap().size();

         }

         public Collection values() {

             return getDynaClassesMap().values();

         }

     };

     // ------------------------------------------------------ DynaClass Methods

     /**

      * Return the class of the underlying wrapped bean.

      *

      * @return the class of the underlying wrapped bean

      * @since 1.8.0

      */

     protected Class getBeanClass() {

         return (Class)beanClassRef.get();

     }

     /**

      * Return the name of this DynaClass (analogous to the

      * <code>getName()</code> method of <code>java.lang.Class</code), which

      * allows the same <code>DynaClass</code> implementation class to support

      * different dynamic classes, with different sets of properties.

      *

      * @return the name of the DynaClass

      */

     public String getName() {

         return beanClassName;

     }

     /**

      * Return a property descriptor for the specified property, if it exists;

      * otherwise, return <code>null</code>.

      *

      * @param name Name of the dynamic property for which a descriptor

      *  is requested

      * @return The descriptor for the specified property

      *

      * @exception IllegalArgumentException if no property name is specified

      */

     public DynaProperty getDynaProperty(String name) {

         if (name == null) {

             throw new IllegalArgumentException

                     ("No property name specified");

         }

         return ((DynaProperty) propertiesMap.get(name));

     }

     /**

      * <p>Return an array of <code>ProperyDescriptors</code> for the properties

      * currently defined in this DynaClass.  If no properties are defined, a

      * zero-length array will be returned.</p>

      *

      * <p><strong>FIXME</strong> - Should we really be implementing

      * <code>getBeanInfo()</code> instead, which returns property descriptors

      * and a bunch of other stuff?</p>

      *

      * @return the set of properties for this DynaClass

      */

     public DynaProperty[] getDynaProperties() {

         return (properties);

     }

     /**

      * <p>Instantiates a new standard JavaBean instance associated with

      * this DynaClass and return it wrapped in a new WrapDynaBean   

      * instance. <strong>NOTE</strong> the JavaBean should have a 

      * no argument constructor.</p>

      *

      * <strong>NOTE</strong> - Most common use cases should not need to use

      * this method. It is usually better to create new

      * <code>WrapDynaBean</code> instances by calling its constructor.

      * For example:</p>

      * <code><pre>

      *   Object javaBean = ...;

      *   DynaBean wrapper = new WrapDynaBean(javaBean);

      * </pre></code>

      * <p>

      * (This method is needed for some kinds of <code>DynaBean</code> framework.)

      * </p>

      *

      * @return A new <code>DynaBean</code> instance

      * @exception IllegalAccessException if the Class or the appropriate

      *  constructor is not accessible

      * @exception InstantiationException if this Class represents an abstract

      *  class, an array class, a primitive type, or void; or if instantiation

      *  fails for some other reason

      */

     public DynaBean newInstance()

             throws IllegalAccessException, InstantiationException {

         return new WrapDynaBean(getBeanClass().newInstance());

     }

     // --------------------------------------------------------- Public Methods

     /**

      * Return the PropertyDescriptor for the specified property name, if any;

      * otherwise return <code>null</code>.

      *

      * @param name Name of the property to be retrieved

      * @return The descriptor for the specified property

      */

     public PropertyDescriptor getPropertyDescriptor(String name) {

         return ((PropertyDescriptor) descriptorsMap.get(name));

     }

     // --------------------------------------------------------- Static Methods

     /**

      * Clear our cache of WrapDynaClass instances.

      */

     public static void clear() {

         getDynaClassesMap().clear();

     }

     /**

      * Create (if necessary) and return a new <code>WrapDynaClass</code>

      * instance for the specified bean class.

      *

      * @param beanClass Bean class for which a WrapDynaClass is requested

      * @return A new <i>Wrap</i> {@link DynaClass}

      */

     public static WrapDynaClass createDynaClass(Class beanClass) {

             WrapDynaClass dynaClass =

                     (WrapDynaClass) getDynaClassesMap().get(beanClass);

             if (dynaClass == null) {

                 dynaClass = new WrapDynaClass(beanClass);

                 getDynaClassesMap().put(beanClass, dynaClass);

             }

             return (dynaClass);

     }

     // ------------------------------------------------------ Protected Methods

     /**

      * Introspect our bean class to identify the supported properties.

      */

     protected void introspect() {

         // Look up the property descriptors for this bean class

         Class beanClass = getBeanClass();

         PropertyDescriptor[] regulars =

                 PropertyUtils.getPropertyDescriptors(beanClass);

         if (regulars == null) {

             regulars = new PropertyDescriptor[0];

         }

         Map mappeds =

                 PropertyUtils.getMappedPropertyDescriptors(beanClass);

         if (mappeds == null) {

             mappeds = new HashMap();

         }

         // Construct corresponding DynaProperty information

         properties = new DynaProperty[regulars.length + mappeds.size()];

         for (int i = 0; i < regulars.length; i++) {

             descriptorsMap.put(regulars[i].getName(),

                     regulars[i]);

             properties[i] =

                     new DynaProperty(regulars[i].getName(),

                             regulars[i].getPropertyType());

             propertiesMap.put(properties[i].getName(),

                     properties[i]);

         }

         int j = regulars.length;

         Iterator names = mappeds.keySet().iterator();

         while (names.hasNext()) {

             String name = (String) names.next();

             PropertyDescriptor descriptor =

                     (PropertyDescriptor) mappeds.get(name);

             properties[j] =

                     new DynaProperty(descriptor.getName(),

                             Map.class);

             propertiesMap.put(properties[j].getName(),

                     properties[j]);

             j++;

         }

     }

 }