/*

* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

package java.beans;

import com.sun.beans.TypeResolver;

import com.sun.beans.WeakCache;

import com.sun.beans.finder.ClassFinder;

import java.awt.Component;

import java.lang.ref.Reference;

import java.lang.ref.SoftReference;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.lang.reflect.Type;

import java.util.Map;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.EventListener;

import java.util.EventObject;

import java.util.List;

import java.util.TreeMap;

import sun.reflect.misc.ReflectUtil;

/**

* The Introspector class provides a standard way for tools to learn about

* the properties, events, and methods supported by a target Java Bean.

* <p>

* For each of those three kinds of information, the Introspector will

* separately analyze the bean's class and superclasses looking for

* either explicit or implicit information and use that information to

* build a BeanInfo object that comprehensively describes the target bean.

* <p>

* For each class "Foo", explicit information may be available if there exists

* a corresponding "FooBeanInfo" class that provides a non-null value when

* queried for the information. We first look for the BeanInfo class by

* taking the full package-qualified name of the target bean class and

* appending "BeanInfo" to form a new class name. If this fails, then

* we take the final classname component of this name, and look for that

* class in each of the packages specified in the BeanInfo package search

* path.

* <p>

* Thus for a class such as "sun.xyz.OurButton" we would first look for a

* BeanInfo class called "sun.xyz.OurButtonBeanInfo" and if that failed we'd

* look in each package in the BeanInfo search path for an OurButtonBeanInfo

* class. With the default search path, this would mean looking for

* "sun.beans.infos.OurButtonBeanInfo".

* <p>

* If a class provides explicit BeanInfo about itself then we add that to

* the BeanInfo information we obtained from analyzing any derived classes,

* but we regard the explicit information as being definitive for the current

* class and its base classes, and do not proceed any further up the superclass

* chain.

* <p>

* If we don't find explicit BeanInfo on a class, we use low-level

* reflection to study the methods of the class and apply standard design

* patterns to identify property accessors, event sources, or public

* methods. We then proceed to analyze the class's superclass and add

* in the information from it (and possibly on up the superclass chain).

* <p>

* For more information about introspection and design patterns, please

* consult the

* <a href="http://java.sun.com/products/javabeans/docs/index.html">JavaBeans&trade; specification</a>.

*/

public class Introspector {

// Flags that can be used to control getBeanInfo:

public final static int USE_ALL_BEANINFO = 1;

public final static int IGNORE_IMMEDIATE_BEANINFO = 2;

public final static int IGNORE_ALL_BEANINFO = 3;

// Static Caches to speed up introspection.

private static final WeakCache<Class<?>, Method[]> declaredMethodCache = new WeakCache<>();

private Class beanClass;

private BeanInfo explicitBeanInfo;

private BeanInfo superBeanInfo;

private BeanInfo additionalBeanInfo[];

private boolean propertyChangeSource = false;

private static Class eventListenerType = EventListener.class;

// These should be removed.

private String defaultEventName;

private String defaultPropertyName;

private int defaultEventIndex = -1;

private int defaultPropertyIndex = -1;

// Methods maps from Method objects to MethodDescriptors

private Map methods;

// properties maps from String names to PropertyDescriptors

private Map properties;

// events maps from String names to EventSetDescriptors

private Map events;

private final static EventSetDescriptor[] EMPTY_EVENTSETDESCRIPTORS = new EventSetDescriptor[0];

static final String ADD_PREFIX = "add";

static final String REMOVE_PREFIX = "remove";

static final String GET_PREFIX = "get";

static final String SET_PREFIX = "set";

static final String IS_PREFIX = "is";

//======================================================================

// Public methods

//======================================================================

/**

* Introspect on a Java Bean and learn about all its properties, exposed

* methods, and events.

* <p>

* If the BeanInfo class for a Java Bean has been previously Introspected

* then the BeanInfo class is retrieved from the BeanInfo cache.

*

* @param beanClass The bean class to be analyzed.

* @return A BeanInfo object describing the target bean.

* @exception IntrospectionException if an exception occurs during

* introspection.

* @see #flushCaches

* @see #flushFromCaches

*/

public static BeanInfo getBeanInfo(Class<?> beanClass)

throws IntrospectionException

{

if (!ReflectUtil.isPackageAccessible(beanClass)) {

return (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo();

}

ThreadGroupContext context = ThreadGroupContext.getContext();

BeanInfo beanInfo;

synchronized (declaredMethodCache) {

beanInfo = context.getBeanInfo(beanClass);

}

if (beanInfo == null) {

beanInfo = new Introspector(beanClass, null, USE_ALL_BEANINFO).getBeanInfo();

synchronized (declaredMethodCache) {

context.putBeanInfo(beanClass, beanInfo);

}

}

return beanInfo;

}

/**

* Introspect on a Java bean and learn about all its properties, exposed

* methods, and events, subject to some control flags.

* <p>

* If the BeanInfo class for a Java Bean has been previously Introspected

* based on the same arguments then the BeanInfo class is retrieved

* from the BeanInfo cache.

*

* @param beanClass The bean class to be analyzed.

* @param flags Flags to control the introspection.

* If flags == USE_ALL_BEANINFO then we use all of the BeanInfo

* classes we can discover.

* If flags == IGNORE_IMMEDIATE_BEANINFO then we ignore any

* BeanInfo associated with the specified beanClass.

* If flags == IGNORE_ALL_BEANINFO then we ignore all BeanInfo

* associated with the specified beanClass or any of its

* parent classes.

* @return A BeanInfo object describing the target bean.

* @exception IntrospectionException if an exception occurs during

* introspection.

*/

public static BeanInfo getBeanInfo(Class<?> beanClass, int flags)

throws IntrospectionException {

return getBeanInfo(beanClass, null, flags);

}

/**

* Introspect on a Java bean and learn all about its properties, exposed

* methods, below a given "stop" point.

* <p>

* If the BeanInfo class for a Java Bean has been previously Introspected

* based on the same arguments, then the BeanInfo class is retrieved

* from the BeanInfo cache.

*

* @param beanClass The bean class to be analyzed.

* @param stopClass The baseclass at which to stop the analysis. Any

* methods/properties/events in the stopClass or in its baseclasses

* will be ignored in the analysis.

* @exception IntrospectionException if an exception occurs during

* introspection.

*/

public static BeanInfo getBeanInfo(Class<?> beanClass, Class<?> stopClass)

throws IntrospectionException {

return getBeanInfo(beanClass, stopClass, USE_ALL_BEANINFO);

}

/**

* Introspect on a Java Bean and learn about all its properties,

* exposed methods and events, below a given {@code stopClass} point

* subject to some control {@code flags}.

* <dl>

* <dt>USE_ALL_BEANINFO</dt>

* <dd>Any BeanInfo that can be discovered will be used.</dd>

* <dt>IGNORE_IMMEDIATE_BEANINFO</dt>

* <dd>Any BeanInfo associated with the specified {@code beanClass} will be ignored.</dd>

* <dt>IGNORE_ALL_BEANINFO</dt>

* <dd>Any BeanInfo associated with the specified {@code beanClass}

* or any of its parent classes will be ignored.</dd>

* </dl>

* Any methods/properties/events in the {@code stopClass}

* or in its parent classes will be ignored in the analysis.

* <p>

* If the BeanInfo class for a Java Bean has been

* previously introspected based on the same arguments then

* the BeanInfo class is retrieved from the BeanInfo cache.

*

* @param beanClass the bean class to be analyzed

* @param stopClass the parent class at which to stop the analysis

* @param flags flags to control the introspection

* @return a BeanInfo object describing the target bean

* @exception IntrospectionException if an exception occurs during introspection

*

* @since 1.7

*/

public static BeanInfo getBeanInfo(Class<?> beanClass, Class<?> stopClass,

int flags) throws IntrospectionException {

BeanInfo bi;

if (stopClass == null && flags == USE_ALL_BEANINFO) {

// Same parameters to take advantage of caching.

bi = getBeanInfo(beanClass);

} else {

bi = (new Introspector(beanClass, stopClass, flags)).getBeanInfo();

}

return bi;

// Old behaviour: Make an independent copy of the BeanInfo.

//return new GenericBeanInfo(bi);

}

/**

* Utility method to take a string and convert it to normal Java variable

* name capitalization. This normally means converting the first

* character from upper case to lower case, but in the (unusual) special

* case when there is more than one character and both the first and

* second characters are upper case, we leave it alone.

* <p>

* Thus "FooBah" becomes "fooBah" and "X" becomes "x", but "URL" stays

* as "URL".

*

* @param name The string to be decapitalized.

* @return The decapitalized version of the string.

*/

public static String decapitalize(String name) {

if (name == null || name.length() == 0) {

return name;

}

if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&

Character.isUpperCase(name.charAt(0))){

return name;

}

char chars[] = name.toCharArray();

chars[0] = Character.toLowerCase(chars[0]);

return new String(chars);

}

/**

* Gets the list of package names that will be used for

* finding BeanInfo classes.

*

* @return The array of package names that will be searched in

* order to find BeanInfo classes. The default value

* for this array is implementation-dependent; e.g.

* Sun implementation initially sets to {"sun.beans.infos"}.

*/

public static String[] getBeanInfoSearchPath() {

return ThreadGroupContext.getContext().getBeanInfoFinder().getPackages();

}

/**

* Change the list of package names that will be used for

* finding BeanInfo classes. The behaviour of

* this method is undefined if parameter path

* is null.

*

* <p>First, if there is a security manager, its <code>checkPropertiesAccess</code>

* method is called. This could result in a SecurityException.

*

* @param path Array of package names.

* @exception SecurityException if a security manager exists and its

* <code>checkPropertiesAccess</code> method doesn't allow setting

* of system properties.

* @see SecurityManager#checkPropertiesAccess

*/

public static void setBeanInfoSearchPath(String[] path) {

SecurityManager sm = System.getSecurityManager();

if (sm != null) {

sm.checkPropertiesAccess();

}

ThreadGroupContext.getContext().getBeanInfoFinder().setPackages(path);

}

/**

* Flush all of the Introspector's internal caches. This method is

* not normally required. It is normally only needed by advanced

* tools that update existing "Class" objects in-place and need

* to make the Introspector re-analyze existing Class objects.

*/

public static void flushCaches() {

synchronized (declaredMethodCache) {

ThreadGroupContext.getContext().clearBeanInfoCache();

declaredMethodCache.clear();

}

}

/**

* Flush the Introspector's internal cached information for a given class.

* This method is not normally required. It is normally only needed

* by advanced tools that update existing "Class" objects in-place

* and need to make the Introspector re-analyze an existing Class object.

*

* Note that only the direct state associated with the target Class

* object is flushed. We do not flush state for other Class objects

* with the same name, nor do we flush state for any related Class

* objects (such as subclasses), even though their state may include

* information indirectly obtained from the target Class object.

*

* @param clz Class object to be flushed.

* @throws NullPointerException If the Class object is null.

*/

public static void flushFromCaches(Class<?> clz) {

if (clz == null) {

throw new NullPointerException();

}

synchronized (declaredMethodCache) {

ThreadGroupContext.getContext().removeBeanInfo(clz);

declaredMethodCache.put(clz, null);

}

}

//======================================================================

// Private implementation methods

//======================================================================

private Introspector(Class beanClass, Class stopClass, int flags)

throws IntrospectionException {

this.beanClass = beanClass;

// Check stopClass is a superClass of startClass.

if (stopClass != null) {

boolean isSuper = false;

for (Class c = beanClass.getSuperclass(); c != null; c = c.getSuperclass()) {

if (c == stopClass) {

isSuper = true;

}

}

if (!isSuper) {

throw new IntrospectionException(stopClass.getName() + " not superclass of " +

beanClass.getName());

}

}

if (flags == USE_ALL_BEANINFO) {

explicitBeanInfo = findExplicitBeanInfo(beanClass);

}

Class superClass = beanClass.getSuperclass();

if (superClass != stopClass) {

int newFlags = flags;

if (newFlags == IGNORE_IMMEDIATE_BEANINFO) {

newFlags = USE_ALL_BEANINFO;

}

superBeanInfo = getBeanInfo(superClass, stopClass, newFlags);

}

if (explicitBeanInfo != null) {

additionalBeanInfo = explicitBeanInfo.getAdditionalBeanInfo();

}

if (additionalBeanInfo == null) {

additionalBeanInfo = new BeanInfo[0];

}

}

/**

* Constructs a GenericBeanInfo class from the state of the Introspector

*/

private BeanInfo getBeanInfo() throws IntrospectionException {

// the evaluation order here is import, as we evaluate the

// event sets and locate PropertyChangeListeners before we

// look for properties.

BeanDescriptor bd = getTargetBeanDescriptor();

MethodDescriptor mds[] = getTargetMethodInfo();

EventSetDescriptor esds[] = getTargetEventInfo();

PropertyDescriptor pds[] = getTargetPropertyInfo();

int defaultEvent = getTargetDefaultEventIndex();

int defaultProperty = getTargetDefaultPropertyIndex();

return new GenericBeanInfo(bd, esds, defaultEvent, pds,

defaultProperty, mds, explicitBeanInfo);

}

/**

* Looks for an explicit BeanInfo class that corresponds to the Class.

* First it looks in the existing package that the Class is defined in,

* then it checks to see if the class is its own BeanInfo. Finally,

* the BeanInfo search path is prepended to the class and searched.

*

* @param beanClass the class type of the bean

* @return Instance of an explicit BeanInfo class or null if one isn't found.

*/

private static BeanInfo findExplicitBeanInfo(Class beanClass) {

return ThreadGroupContext.getContext().getBeanInfoFinder().find(beanClass);

}

/**

* @return An array of PropertyDescriptors describing the editable

* properties supported by the target bean.

*/

private PropertyDescriptor[] getTargetPropertyInfo() {

// Check if the bean has its own BeanInfo that will provide

// explicit information.

PropertyDescriptor[] explicitProperties = null;

if (explicitBeanInfo != null) {

explicitProperties = getPropertyDescriptors(this.explicitBeanInfo);

}

if (explicitProperties == null && superBeanInfo != null) {

// We have no explicit BeanInfo properties. Check with our parent.

addPropertyDescriptors(getPropertyDescriptors(this.superBeanInfo));

}

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

addPropertyDescriptors(additionalBeanInfo[i].getPropertyDescriptors());

}

if (explicitProperties != null) {

// Add the explicit BeanInfo data to our results.

addPropertyDescriptors(explicitProperties);

} else {

// Apply some reflection to the current class.

// First get an array of all the public methods at this level

Method methodList[] = getPublicDeclaredMethods(beanClass);

// Now analyze each method.

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

Method method = methodList[i];

if (method == null) {

continue;

}

// skip static methods.

int mods = method.getModifiers();

if (Modifier.isStatic(mods)) {

continue;

}

String name = method.getName();

Class argTypes[] = method.getParameterTypes();

Class resultType = method.getReturnType();

int argCount = argTypes.length;

PropertyDescriptor pd = null;

if (name.length() <= 3 && !name.startsWith(IS_PREFIX)) {

// Optimization. Don't bother with invalid propertyNames.

continue;

}

try {

if (argCount == 0) {

if (name.startsWith(GET_PREFIX)) {

// Simple getter

pd = new PropertyDescriptor(this.beanClass, name.substring(3), method, null);

} else if (resultType == boolean.class && name.startsWith(IS_PREFIX)) {

// Boolean getter

pd = new PropertyDescriptor(this.beanClass, name.substring(2), method, null);

}

} else if (argCount == 1) {

if (int.class.equals(argTypes[0]) && name.startsWith(GET_PREFIX)) {

pd = new IndexedPropertyDescriptor(this.beanClass, name.substring(3), null, null, method, null);

} else if (void.class.equals(resultType) && name.startsWith(SET_PREFIX)) {

// Simple setter

pd = new PropertyDescriptor(this.beanClass, name.substring(3), null, method);

if (throwsException(method, PropertyVetoException.class)) {

pd.setConstrained(true);

}

}

} else if (argCount == 2) {

if (void.class.equals(resultType) && int.class.equals(argTypes[0]) && name.startsWith(SET_PREFIX)) {

pd = new IndexedPropertyDescriptor(this.beanClass, name.substring(3), null, null, null, method);

if (throwsException(method, PropertyVetoException.class)) {

pd.setConstrained(true);

}

}

}

} catch (IntrospectionException ex) {

// This happens if a PropertyDescriptor or IndexedPropertyDescriptor

// constructor fins that the method violates details of the deisgn

// pattern, e.g. by having an empty name, or a getter returning

// void , or whatever.

pd = null;

}

if (pd != null) {

// If this class or one of its base classes is a PropertyChange

// source, then we assume that any properties we discover are "bound".

if (propertyChangeSource) {

pd.setBound(true);

}

addPropertyDescriptor(pd);

}

}

}

processPropertyDescriptors();

// Allocate and populate the result array.

PropertyDescriptor result[] = new PropertyDescriptor[properties.size()];

result = (PropertyDescriptor[])properties.values().toArray(result);

// Set the default index.

if (defaultPropertyName != null) {

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

if (defaultPropertyName.equals(result[i].getName())) {

defaultPropertyIndex = i;

}

}

}

return result;

}

private HashMap pdStore = new HashMap();

/**

* Adds the property descriptor to the list store.

*/

private void addPropertyDescriptor(PropertyDescriptor pd) {

String propName = pd.getName();

List list = (List)pdStore.get(propName);

if (list == null) {

list = new ArrayList();

pdStore.put(propName, list);

}

if (this.beanClass != pd.getClass0()) {

// replace existing property descriptor

// only if we have types to resolve

// in the context of this.beanClass

Method read = pd.getReadMethod();

Method write = pd.getWriteMethod();

boolean cls = true;

if (read != null) cls = cls && read.getGenericReturnType() instanceof Class;

if (write != null) cls = cls && write.getGenericParameterTypes()[0] instanceof Class;

if (pd instanceof IndexedPropertyDescriptor) {

IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;

Method readI = ipd.getIndexedReadMethod();

Method writeI = ipd.getIndexedWriteMethod();

if (readI != null) cls = cls && readI.getGenericReturnType() instanceof Class;

if (writeI != null) cls = cls && writeI.getGenericParameterTypes()[1] instanceof Class;

if (!cls) {

pd = new IndexedPropertyDescriptor(ipd);

pd.updateGenericsFor(this.beanClass);

}

}

else if (!cls) {

pd = new PropertyDescriptor(pd);

pd.updateGenericsFor(this.beanClass);

}

}

list.add(pd);

}

private void addPropertyDescriptors(PropertyDescriptor[] descriptors) {

if (descriptors != null) {

for (PropertyDescriptor descriptor : descriptors) {

addPropertyDescriptor(descriptor);

}

}

}

private PropertyDescriptor[] getPropertyDescriptors(BeanInfo info) {

PropertyDescriptor[] descriptors = info.getPropertyDescriptors();

int index = info.getDefaultPropertyIndex();

if ((0 <= index) && (index < descriptors.length)) {

this.defaultPropertyName = descriptors[index].getName();

}

return descriptors;

}

/**

* Populates the property descriptor table by merging the

* lists of Property descriptors.

*/

private void processPropertyDescriptors() {

if (properties == null) {

properties = new TreeMap();

}

List list;

PropertyDescriptor pd, gpd, spd;

IndexedPropertyDescriptor ipd, igpd, ispd;

Iterator it = pdStore.values().iterator();

while (it.hasNext()) {

pd = null; gpd = null; spd = null;

ipd = null; igpd = null; ispd = null;

list = (List)it.next();

// First pass. Find the latest getter method. Merge properties

// of previous getter methods.

for (int i = 0; i < list.size(); i++) {

pd = (PropertyDescriptor)list.get(i);

if (pd instanceof IndexedPropertyDescriptor) {

ipd = (IndexedPropertyDescriptor)pd;

if (ipd.getIndexedReadMethod() != null) {

if (igpd != null) {

igpd = new IndexedPropertyDescriptor(igpd, ipd);

} else {

igpd = ipd;

}

}

} else {

if (pd.getReadMethod() != null) {

if (gpd != null) {

// Don't replace the existing read

// method if it starts with "is"

Method method = gpd.getReadMethod();

if (!method.getName().startsWith(IS_PREFIX)) {

gpd = new PropertyDescriptor(gpd, pd);

}

} else {

gpd = pd;

}

}

}

}

// Second pass. Find the latest setter method which

// has the same type as the getter method.

for (int i = 0; i < list.size(); i++) {

pd = (PropertyDescriptor)list.get(i);

if (pd instanceof IndexedPropertyDescriptor) {

ipd = (IndexedPropertyDescriptor)pd;

if (ipd.getIndexedWriteMethod() != null) {

if (igpd != null) {

if (igpd.getIndexedPropertyType()

== ipd.getIndexedPropertyType()) {

if (ispd != null) {

ispd = new IndexedPropertyDescriptor(ispd, ipd);

} else {

ispd = ipd;

}

}

} else {

if (ispd != null) {

ispd = new IndexedPropertyDescriptor(ispd, ipd);

} else {

ispd = ipd;

}

}

}

} else {

if (pd.getWriteMethod() != null) {

if (gpd != null) {

if (gpd.getPropertyType() == pd.getPropertyType()) {

if (spd != null) {

spd = new PropertyDescriptor(spd, pd);

} else {

spd = pd;

}

}

} else {

if (spd != null) {

spd = new PropertyDescriptor(spd, pd);

} else {

spd = pd;

}

}

}

}

}

// At this stage we should have either PDs or IPDs for the

// representative getters and setters. The order at which the

// property descriptors are determined represent the

// precedence of the property ordering.

pd = null; ipd = null;

if (igpd != null && ispd != null) {

// Complete indexed properties set

// Merge any classic property descriptors

if (gpd != null) {

PropertyDescriptor tpd = mergePropertyDescriptor(igpd, gpd);

if (tpd instanceof IndexedPropertyDescriptor) {

igpd = (IndexedPropertyDescriptor)tpd;

}

}

if (spd != null) {

PropertyDescriptor tpd = mergePropertyDescriptor(ispd, spd);

if (tpd instanceof IndexedPropertyDescriptor) {

ispd = (IndexedPropertyDescriptor)tpd;

}

}

if (igpd == ispd) {

pd = igpd;

} else {

pd = mergePropertyDescriptor(igpd, ispd);

}

} else if (gpd != null && spd != null) {

// Complete simple properties set

if (gpd == spd) {

pd = gpd;

} else {

pd = mergePropertyDescriptor(gpd, spd);

}

} else if (ispd != null) {

// indexed setter

pd = ispd;

// Merge any classic property descriptors

if (spd != null) {

pd = mergePropertyDescriptor(ispd, spd);

}

if (gpd != null) {

pd = mergePropertyDescriptor(ispd, gpd);

}

} else if (igpd != null) {

// indexed getter

pd = igpd;

// Merge any classic property descriptors

if (gpd != null) {

pd = mergePropertyDescriptor(igpd, gpd);

}

if (spd != null) {

pd = mergePropertyDescriptor(igpd, spd);

}

} else if (spd != null) {

// simple setter

pd = spd;

} else if (gpd != null) {

// simple getter

pd = gpd;

}

// Very special case to ensure that an IndexedPropertyDescriptor

// doesn't contain less information than the enclosed

// PropertyDescriptor. If it does, then recreate as a

// PropertyDescriptor. See 4168833

if (pd instanceof IndexedPropertyDescriptor) {

ipd = (IndexedPropertyDescriptor)pd;

if (ipd.getIndexedReadMethod() == null && ipd.getIndexedWriteMethod() == null) {

pd = new PropertyDescriptor(ipd);

}

}

// Find the first property descriptor

// which does not have getter and setter methods.

// See regression bug 4984912.

if ( (pd == null) && (list.size() > 0) ) {

pd = (PropertyDescriptor) list.get(0);

}

if (pd != null) {

properties.put(pd.getName(), pd);

}

}

}

/**

* Adds the property descriptor to the indexedproperty descriptor only if the

* types are the same.

*

* The most specific property descriptor will take precedence.

*/

private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd,

PropertyDescriptor pd) {

PropertyDescriptor result = null;

Class propType = pd.getPropertyType();

Class ipropType = ipd.getIndexedPropertyType();

if (propType.isArray() && propType.getComponentType() == ipropType) {

if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {

result = new IndexedPropertyDescriptor(pd, ipd);

} else {

result = new IndexedPropertyDescriptor(ipd, pd);

}

} else {

// Cannot merge the pd because of type mismatch

// Return the most specific pd

if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {

result = ipd;

} else {

result = pd;

// Try to add methods which may have been lost in the type change

// See 4168833

Method write = result.getWriteMethod();

Method read = result.getReadMethod();

if (read == null && write != null) {

read = findMethod(result.getClass0(),

GET_PREFIX + NameGenerator.capitalize(result.getName()), 0);

if (read != null) {

try {

result.setReadMethod(read);

} catch (IntrospectionException ex) {

// no consequences for failure.

}

}

}

if (write == null && read != null) {

write = findMethod(result.getClass0(),

SET_PREFIX + NameGenerator.capitalize(result.getName()), 1,

new Class[] { FeatureDescriptor.getReturnType(result.getClass0(), read) });

if (write != null) {

try {

result.setWriteMethod(write);

} catch (IntrospectionException ex) {

// no consequences for failure.

}

}

}

}

}

return result;

}

// Handle regular pd merge

private PropertyDescriptor mergePropertyDescriptor(PropertyDescriptor pd1,

PropertyDescriptor pd2) {

if (pd1.getClass0().isAssignableFrom(pd2.getClass0())) {

return new PropertyDescriptor(pd1, pd2);

} else {

return new PropertyDescriptor(pd2, pd1);

}

}

// Handle regular ipd merge

private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd1,

IndexedPropertyDescriptor ipd2) {

if (ipd1.getClass0().isAssignableFrom(ipd2.getClass0())) {

return new IndexedPropertyDescriptor(ipd1, ipd2);

} else {

return new IndexedPropertyDescriptor(ipd2, ipd1);

}

}

/**

* @return An array of EventSetDescriptors describing the kinds of

* events fired by the target bean.

*/

private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {

if (events == null) {

events = new HashMap();

}

// Check if the bean has its own BeanInfo that will provide

// explicit information.

EventSetDescriptor[] explicitEvents = null;

if (explicitBeanInfo != null) {

explicitEvents = explicitBeanInfo.getEventSetDescriptors();

int ix = explicitBeanInfo.getDefaultEventIndex();

if (ix >= 0 && ix < explicitEvents.length) {

defaultEventName = explicitEvents[ix].getName();

}

}

if (explicitEvents == null && superBeanInfo != null) {

// We have no explicit BeanInfo events. Check with our parent.

EventSetDescriptor supers[] = superBeanInfo.getEventSetDescriptors();

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

addEvent(supers[i]);

}

int ix = superBeanInfo.getDefaultEventIndex();

if (ix >= 0 && ix < supers.length) {

defaultEventName = supers[ix].getName();

}

}

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

EventSetDescriptor additional[] = additionalBeanInfo[i].getEventSetDescriptors();

if (additional != null) {

for (int j = 0 ; j < additional.length; j++) {

addEvent(additional[j]);

}

}

}

if (explicitEvents != null) {

// Add the explicit explicitBeanInfo data to our results.

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

addEvent(explicitEvents[i]);

}

} else {

// Apply some reflection to the current class.

// Get an array of all the public beans methods at this level

Method methodList[] = getPublicDeclaredMethods(beanClass);

// Find all suitable "add", "remove" and "get" Listener methods

// The name of the listener type is the key for these hashtables

// i.e, ActionListener

Map adds = null;

Map removes = null;

Map gets = null;

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

Method method = methodList[i];

if (method == null) {

continue;

}

// skip static methods.

int mods = method.getModifiers();

if (Modifier.isStatic(mods)) {

continue;

}

String name = method.getName();

// Optimization avoid getParameterTypes

if (!name.startsWith(ADD_PREFIX) && !name.startsWith(REMOVE_PREFIX)

&& !name.startsWith(GET_PREFIX)) {

continue;

}

if (name.startsWith(ADD_PREFIX)) {

Class<?> returnType = method.getReturnType();

if (returnType == void.class) {

Type[] parameterTypes = method.getGenericParameterTypes();

if (parameterTypes.length == 1) {

Class<?> type = TypeResolver.erase(TypeResolver.resolveInClass(beanClass, parameterTypes[0]));

if (Introspector.isSubclass(type, eventListenerType)) {

String listenerName = name.substring(3);

if (listenerName.length() > 0 &&

type.getName().endsWith(listenerName)) {

if (adds == null) {

adds = new HashMap();

}

adds.put(listenerName, method);

}

}

}

}

}

else if (name.startsWith(REMOVE_PREFIX)) {

Class<?> returnType = method.getReturnType();

if (returnType == void.class) {

Type[] parameterTypes = method.getGenericParameterTypes();

if (parameterTypes.length == 1) {

Class<?> type = TypeResolver.erase(TypeResolver.resolveInClass(beanClass, parameterTypes[0]));

if (Introspector.isSubclass(type, eventListenerType)) {

String listenerName = name.substring(6);

if (listenerName.length() > 0 &&

type.getName().endsWith(listenerName)) {

if (removes == null) {

removes = new HashMap();

}

removes.put(listenerName, method);

}

}

}

}

}

else if (name.startsWith(GET_PREFIX)) {

Class<?>[] parameterTypes = method.getParameterTypes();

if (parameterTypes.length == 0) {

Class<?> returnType = FeatureDescriptor.getReturnType(beanClass, method);

if (returnType.isArray()) {

Class<?> type = returnType.getComponentType();

if (Introspector.isSubclass(type, eventListenerType)) {

String listenerName = name.substring(3, name.length() - 1);