/*
 * 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.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;


Implementation of DynaClass for DynaBeans that wrap
standard JavaBean instances.

It is suggested that this class should not usually need to be used directly
to create new WrapDynaBean instances.
It's usually better to call the WrapDynaBean constructor directly.
For example:
  Object javaBean = ...;
  DynaBean wrapper = new WrapDynaBean(javaBean);


Version:
$Id$/**
 * <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>
 *
 * @version $Id$
 */

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 createDynaClass(Class) method.
Params:
beanClass – JavaBean class to be introspected around
propUtils – the PropertyUtilsBean associated with this class/**
     * 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
     * @param propUtils the {@code PropertyUtilsBean} associated with this class
     */
    private WrapDynaClass(final Class<?> beanClass, final PropertyUtilsBean propUtils) {

        this.beanClassRef = new SoftReference<Class<?>>(beanClass);
        this.beanClassName = beanClass.getName();
        propertyUtilsBean = propUtils;
        introspect();

    }


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

    
Name of the JavaBean class represented by this WrapDynaClass.
/**
     * Name of the JavaBean class represented by this WrapDynaClass.
     */
    private String beanClassName = null;

    
Reference to the JavaBean class represented by this WrapDynaClass.
/**
     * Reference to the JavaBean class represented by this WrapDynaClass.
     */
    private Reference<Class<?>> beanClassRef = null;

    
Stores the associated PropertyUtilsBean instance. /** Stores the associated {@code PropertyUtilsBean} instance. */
    private final PropertyUtilsBean propertyUtilsBean;

    
The JavaBean Class which is represented by this
WrapDynaClass.
Deprecated:
No longer initialized, use getBeanClass() method instead/**
     * The JavaBean <code>Class</code> which is represented by this
     * <code>WrapDynaClass</code>.
     *
     * @deprecated No longer initialized, use getBeanClass() method instead
     */
    @Deprecated
    protected Class<?> beanClass = null;


    
The set of PropertyDescriptors for this bean class.
/**
     * 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 descriptors list.
/**
     * 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<String, PropertyDescriptor> descriptorsMap = new HashMap<String, PropertyDescriptor>();


    
The set of dynamic properties that are part of this DynaClass.
/**
     * 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 properties list.
/**
     * 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<String, DynaProperty> propertiesMap = new HashMap<String, DynaProperty>();


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


    private static final ContextClassLoaderLocal<Map<CacheKey, WrapDynaClass>> CLASSLOADER_CACHE =
        new ContextClassLoaderLocal<Map<CacheKey, WrapDynaClass>>() {
            @Override
            protected Map<CacheKey, WrapDynaClass> initialValue() {
                return new WeakHashMap<CacheKey, WrapDynaClass>();
        }
    };

    
Get the wrap dyna classes cache. Note: This method only exists to satisfy the deprecated dynaClasses hash map. /**
     * Get the wrap dyna classes cache. Note: This method only exists to
     * satisfy the deprecated {@code dynaClasses} hash map.
     */
    @SuppressWarnings("unchecked")
    private static Map<Object, Object> getDynaClassesMap() {
        @SuppressWarnings("rawtypes")
        final
        Map cache = CLASSLOADER_CACHE.get();
        return cache;
    }

    
Returns the cache for the already created class instances. For each combination of bean class and PropertyUtilsBean instance an entry is created in the cache. 
Returns:
the cache for already created WrapDynaClass instances/**
     * Returns the cache for the already created class instances. For each
     * combination of bean class and {@code PropertyUtilsBean} instance an
     * entry is created in the cache.
     * @return the cache for already created {@code WrapDynaClass} instances
     */
    private static Map<CacheKey, WrapDynaClass> getClassesCache() {
        return CLASSLOADER_CACHE.get();
    }

    
The set of WrapDynaClass 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.

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.

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/**
     * 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
     */
    @Deprecated
    protected static HashMap<Object, Object> dynaClasses = new HashMap<Object, Object>() {
        @Override
        public void clear() {
            getDynaClassesMap().clear();
        }
        @Override
        public boolean containsKey(final Object key) {
            return getDynaClassesMap().containsKey(key);
        }
        @Override
        public boolean containsValue(final Object value) {
            return getDynaClassesMap().containsValue(value);
        }
        @Override
        public Set<Map.Entry<Object, Object>> entrySet() {
            return getDynaClassesMap().entrySet();
        }
        @Override
        public boolean equals(final Object o) {
            return getDynaClassesMap().equals(o);
        }
        @Override
        public Object get(final Object key) {
            return getDynaClassesMap().get(key);
        }
        @Override
        public int hashCode() {
            return getDynaClassesMap().hashCode();
        }
        @Override
        public boolean isEmpty() {
            return getDynaClassesMap().isEmpty();
        }
        @Override
        public Set<Object> keySet() {
            // extract the classes from the key to stay backwards compatible
            final Set<Object> result = new HashSet<Object>();
            for (final CacheKey k : getClassesCache().keySet()) {
                result.add(k.beanClass);
            }
            return result;
        }
        @Override
        public Object put(final Object key, final Object value) {
            return getClassesCache().put(
                    new CacheKey((Class<?>) key, PropertyUtilsBean.getInstance()),
                    (WrapDynaClass) value);
        }
        @Override
        public void putAll(final Map<? extends Object, ? extends Object> m) {
            for (final Map.Entry<? extends Object, ? extends Object> e : m.entrySet()) {
                put(e.getKey(), e.getValue());
            }
        }
        @Override
        public Object remove(final Object key) {
            return getDynaClassesMap().remove(key);
        }
        @Override
        public int size() {
            return getDynaClassesMap().size();
        }
        @Override
        public Collection<Object> values() {
            return getDynaClassesMap().values();
        }
    };


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

    
Return the class of the underlying wrapped bean.
Returns:
the class of the underlying wrapped bean
Since:
1.8.0/**
     * Return the class of the underlying wrapped bean.
     *
     * @return the class of the underlying wrapped bean
     * @since 1.8.0
     */
    protected Class<?> getBeanClass() {
        return beanClassRef.get();
    }

    
Return the name of this DynaClass (analogous to the
getName() method of java.lang.ClassDynaClass implementation class to support
different dynamic classes, with different sets of properties.
Returns:
the name of the DynaClass/**
     * 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 null.
Params:
name – Name of the dynamic property for which a descriptor
 is requested
Throws:
IllegalArgumentException – if no property name is specified
Returns:
The descriptor for the specified property/**
     * 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
     *
     * @throws IllegalArgumentException if no property name is specified
     */
    public DynaProperty getDynaProperty(final String name) {

        if (name == null) {
            throw new IllegalArgumentException
                    ("No property name specified");
        }
        return (propertiesMap.get(name));

    }


    
Return an array of ProperyDescriptors for the properties
currently defined in this DynaClass.  If no properties are defined, a
zero-length array will be returned.
FIXME - Should we really be implementing
getBeanInfo() instead, which returns property descriptors
and a bunch of other stuff?
Returns:
the set of properties for this DynaClass/**
     * <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);

    }


    
Instantiates a new standard JavaBean instance associated with
this DynaClass and return it wrapped in a new WrapDynaBean
instance. NOTE the JavaBean should have a
no argument constructor.
NOTE - Most common use cases should not need to use
this method. It is usually better to create new
WrapDynaBean instances by calling its constructor.
For example:

  Object javaBean = ...;
  DynaBean wrapper = new WrapDynaBean(javaBean);


(This method is needed for some kinds of DynaBean framework.)

Throws:
IllegalAccessException – if the Class or the appropriate
 constructor is not accessible
InstantiationException – if this Class represents an abstract
 class, an array class, a primitive type, or void; or if instantiation
 fails for some other reason
Returns:
A new DynaBean instance/**
     * <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
     * @throws IllegalAccessException if the Class or the appropriate
     *  constructor is not accessible
     * @throws 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 null.
Params:
name – Name of the property to be retrieved
Returns:
The descriptor for the specified property/**
     * 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(final String name) {

        return (descriptorsMap.get(name));

    }


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


    
Clear our cache of WrapDynaClass instances.
/**
     * Clear our cache of WrapDynaClass instances.
     */
    public static void clear() {

        getClassesCache().clear();

    }


    
Create (if necessary) and return a new WrapDynaClass
instance for the specified bean class.
Params:
beanClass – Bean class for which a WrapDynaClass is requested
Returns:
A new Wrap DynaClass/**
     * 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(final Class<?> beanClass) {

        return createDynaClass(beanClass, null);

    }


    
Create (if necessary) and return a new WrapDynaClass instance for the specified bean class using the given PropertyUtilsBean instance for introspection. Using this method a specially configured PropertyUtilsBean instance can be hooked into the introspection mechanism of the managed bean. The argument is optional; if no PropertyUtilsBean object is provided, the default instance is used. 
Params:
beanClass – Bean class for which a WrapDynaClass is requested
pu – the optional PropertyUtilsBean to be used for introspection
Returns:
A new Wrap DynaClass
Since:
1.9/**
     * Create (if necessary) and return a new {@code WrapDynaClass} instance
     * for the specified bean class using the given {@code PropertyUtilsBean}
     * instance for introspection. Using this method a specially configured
     * {@code PropertyUtilsBean} instance can be hooked into the introspection
     * mechanism of the managed bean. The argument is optional; if no
     * {@code PropertyUtilsBean} object is provided, the default instance is used.
     * @param beanClass Bean class for which a WrapDynaClass is requested
     * @param pu the optional {@code PropertyUtilsBean} to be used for introspection
     * @return A new <i>Wrap</i> {@link DynaClass}
     * @since 1.9
     */
    public static WrapDynaClass createDynaClass(final Class<?> beanClass, final PropertyUtilsBean pu) {

        final PropertyUtilsBean propUtils = (pu != null) ? pu : PropertyUtilsBean.getInstance();
        final CacheKey key = new CacheKey(beanClass, propUtils);
        WrapDynaClass dynaClass = getClassesCache().get(key);
        if (dynaClass == null) {
            dynaClass = new WrapDynaClass(beanClass, propUtils);
            getClassesCache().put(key, dynaClass);
        }
        return (dynaClass);

    }


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

    
Returns the PropertyUtilsBean instance associated with this class. This bean is used for introspection. 
Returns:
the associated PropertyUtilsBean instance
Since:
1.9/**
     * Returns the {@code PropertyUtilsBean} instance associated with this class. This
     * bean is used for introspection.
     *
     * @return the associated {@code PropertyUtilsBean} instance
     * @since 1.9
     */
    protected PropertyUtilsBean getPropertyUtilsBean() {
        return propertyUtilsBean;
    }

    
Introspect our bean class to identify the supported properties.
/**
     * Introspect our bean class to identify the supported properties.
     */
    protected void introspect() {

        // Look up the property descriptors for this bean class
        final Class<?> beanClass = getBeanClass();
        PropertyDescriptor[] regulars =
                getPropertyUtilsBean().getPropertyDescriptors(beanClass);
        if (regulars == null) {
            regulars = new PropertyDescriptor[0];
        }
        @SuppressWarnings("deprecation")
        Map<?, ?> mappeds =
                PropertyUtils.getMappedPropertyDescriptors(beanClass);
        if (mappeds == null) {
            mappeds = new HashMap<Object, Object>();
        }

        // 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;
        final Iterator<?> names = mappeds.keySet().iterator();
        while (names.hasNext()) {
            final String name = (String) names.next();
            final PropertyDescriptor descriptor =
                    (PropertyDescriptor) mappeds.get(name);
            properties[j] =
                    new DynaProperty(descriptor.getName(),
                            Map.class);
            propertiesMap.put(properties[j].getName(),
                    properties[j]);
            j++;
        }

    }

    
A class representing the combined key for the cache of WrapDynaClass instances. A single key consists of a bean class and an instance of PropertyUtilsBean. Instances are immutable. /**
     * A class representing the combined key for the cache of {@code WrapDynaClass}
     * instances. A single key consists of a bean class and an instance of
     * {@code PropertyUtilsBean}. Instances are immutable.
     */
    private static class CacheKey {
        
The bean class. /** The bean class. */
        private final Class<?> beanClass;

        
The instance of PropertyUtilsBean. /** The instance of PropertyUtilsBean. */
        private final PropertyUtilsBean propUtils;

        
Creates a new instance of CacheKey. 
Params:
beanCls – the bean class
pu – the instance of PropertyUtilsBean/**
         * Creates a new instance of {@code CacheKey}.
         *
         * @param beanCls the bean class
         * @param pu the instance of {@code PropertyUtilsBean}
         */
        public CacheKey(final Class<?> beanCls, final PropertyUtilsBean pu) {
            beanClass = beanCls;
            propUtils = pu;
        }

        @Override
        public int hashCode() {
            final int factor = 31;
            int result = 17;
            result = factor * beanClass.hashCode() + result;
            result = factor * propUtils.hashCode() + result;
            return result;
        }

        @Override
        public boolean equals(final Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof CacheKey)) {
                return false;
            }

            final CacheKey c = (CacheKey) obj;
            return beanClass.equals(c.beanClass) && propUtils.equals(c.propUtils);
        }
    }
}