home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 July & August / Pcwk78a98.iso / Internet / Javadraw / DATA.Z / Introspector.java < prev    next >
Text File  |  1997-08-30  |  30KB  |  937 lines
  1. /*
  2.  * @(#)Introspector.java    1.71 97/06/05  
  3.  * 
  4.  * Copyright (c) 1996 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  * CopyrightVersion bdk_beta
  20.  * 
  21.  */
  22.  
  23. package java.beans;
  24.  
  25. import java.lang.reflect.*;
  26.  
  27. /**
  28.  * The Introspector class provides a standard way for tools to learn about
  29.  * the properties, events, and methods supported by a target Java Bean.
  30.  * <p>
  31.  * For each of those three kinds of information, the Introspector will
  32.  * separately analyze the bean's class and superclasses looking for
  33.  * either explicit or implicit information and use that information to
  34.  * build a BeanInfo object that comprehensively describes the target bean.
  35.  * <p>
  36.  * For each class "Foo", explicit information may be available if there exists
  37.  * a corresponding "FooBeanInfo" class that provides a non-null value when
  38.  * queried for the information.   We first look for the BeanInfo class by
  39.  * taking the full package-qualified name of the target bean class and
  40.  * appending "BeanInfo" to form a new class name.  If this fails, then
  41.  * we take the final classname component of this name, and look for that
  42.  * class in each of the packages specified in the BeanInfo package search
  43.  * path.
  44.  * <p>
  45.  * Thus for a class such as "sun.xyz.OurButton" we would first look for a
  46.  * BeanInfo class called "sun.xyz.OurButtonBeanInfo" and if that failed we'd
  47.  * look in each package in the BeanInfo search path for an OurButtonBeanInfo
  48.  * class.  With the default search path, this would mean looking for
  49.  * "sun.beans.infos.OurButtonBeanInfo".
  50.  * <p>
  51.  * If a class provides explicit BeanInfo about itself then we add that to
  52.  * the BeanInfo information we obtained from analyzing any derived classes,
  53.  * but we regard the explicit information as being definitive for the current
  54.  * class and its base classes, and do not proceed any further up the superclass
  55.  * chain.
  56.  * <p>
  57.  * If we don't find explicit BeanInfo on a class, we use low-level
  58.  * reflection to study the methods of the class and apply standard design
  59.  * patterns to identify property accessors, event sources, or public
  60.  * methods.  We then proceed to analyze the class's superclass and add
  61.  * in the information from it (and possibly on up the superclass chain).
  62.  */
  63.  
  64. public class Introspector {
  65.  
  66.     //======================================================================
  67.     //                 Public methods
  68.     //======================================================================
  69.  
  70.  
  71.     /**
  72.      * Introspect on a Java bean and learn about all its properties, exposed
  73.      * methods, and events.
  74.      *
  75.      * @param beanClass  The bean class to be analyzed.
  76.      * @return  A BeanInfo object describing the target bean.
  77.      * @exception IntrospectionException if an exception occurs during
  78.      *              introspection.
  79.      */
  80.     public static BeanInfo getBeanInfo(Class beanClass) throws IntrospectionException {
  81.     BeanInfo bi = (BeanInfo)beanInfoCache.get(beanClass);
  82.     if (bi == null) {
  83.         bi = (new Introspector(beanClass, null)).getBeanInfo();
  84.         beanInfoCache.put(beanClass, bi);
  85.     }
  86.     return bi;
  87.     }
  88.  
  89.     /**
  90.      * Introspect on a Java bean and learn all about its properties, exposed
  91.      * methods, below a given "stop" point.
  92.      *
  93.      * @param bean The bean class to be analyzed.
  94.      * @param stopClass The baseclass at which to stop the analysis.  Any
  95.      *    methods/properties/events in the stopClass or in its baseclasses
  96.      *    will be ignored in the analysis.
  97.      * @exception IntrospectionException if an exception occurs during
  98.      *              introspection.
  99.      */
  100.     public static BeanInfo getBeanInfo(Class beanClass,    Class stopClass)
  101.                         throws IntrospectionException {
  102.     return (new Introspector(beanClass, stopClass)).getBeanInfo();
  103.     }
  104.  
  105.     /**
  106.      * Utility method to take a string and convert it to normal Java variable
  107.      * name capitalization.  This normally means converting the first
  108.      * character from upper case to lower case, but in the (unusual) special
  109.      * case when there is more than one character and both the first and
  110.      * second characters are upper case, we leave it alone.
  111.      * <p>
  112.      * Thus "FooBah" becomes "fooBah" and "X" becomes "x", but "URL" stays
  113.      * as "URL".
  114.      *
  115.      * @param  name The string to be decapitalized.
  116.      * @return  The decapitalized version of the string.
  117.      */
  118.     public static String decapitalize(String name) {
  119.     if (name == null || name.length() == 0) {
  120.         return name;
  121.     }
  122.     if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
  123.             Character.isUpperCase(name.charAt(0))){
  124.         return name;
  125.     }
  126.     char chars[] = name.toCharArray();
  127.     chars[0] = Character.toLowerCase(chars[0]);
  128.     return new String(chars);
  129.     }
  130.  
  131.     /**
  132.      * @return  The array of package names that will be searched in
  133.      *        order to find BeanInfo classes.
  134.      * <p>     This is initially set to {"sun.beans.infos"}.
  135.      */
  136.  
  137.     public static String[] getBeanInfoSearchPath() {
  138.     return searchPath;
  139.     }
  140.  
  141.     /**
  142.      * Change the list of package names that will be used for
  143.      *        finding BeanInfo classes.
  144.      * @param path  Array of package names.
  145.      */
  146.  
  147.     public static void setBeanInfoSearchPath(String path[]) {
  148.     searchPath = path;
  149.     }
  150.  
  151.  
  152.     //======================================================================
  153.     //             Private implementation methods
  154.     //======================================================================
  155.  
  156.     private Introspector(Class beanClass, Class stopClass)
  157.                         throws IntrospectionException {
  158.     this.beanClass = beanClass;
  159.  
  160.     // Check stopClass is a superClass of startClass.
  161.     if (stopClass != null) {
  162.         boolean isSuper = false;
  163.         for (Class c = beanClass.getSuperclass(); c != null; c = c.getSuperclass()) {
  164.             if (c == stopClass) {
  165.             isSuper = true;
  166.             }
  167.         }
  168.         if (!isSuper) {
  169.             throw new IntrospectionException(stopClass.getName() + " not superclass of " + 
  170.                     beanClass.getName());
  171.         }
  172.     }
  173.  
  174.     informant = findInformant(beanClass);
  175.  
  176.     if (beanClass.getSuperclass() != stopClass) {
  177.         if (stopClass == null) {
  178.             superBeanInfo = Introspector.getBeanInfo(
  179.                 beanClass.getSuperclass());
  180.         } else {
  181.             superBeanInfo = Introspector.getBeanInfo(
  182.                 beanClass.getSuperclass(), stopClass);
  183.         }
  184.     }
  185.     if (informant != null) {
  186.         additionalBeanInfo = informant.getAdditionalBeanInfo();
  187.     } 
  188.     if (additionalBeanInfo == null) {
  189.         additionalBeanInfo = new BeanInfo[0];
  190.     }
  191.     }
  192.  
  193.    
  194.     private BeanInfo getBeanInfo() throws IntrospectionException {
  195.  
  196.     // the evaluation order here is import, as we evaluate the
  197.     // event sets and locate PropertyChangeListeners before we
  198.     // look for properties.
  199.     BeanDescriptor bd = getTargetBeanDescriptor();
  200.     EventSetDescriptor esds[] = getTargetEventInfo();
  201.     int defaultEvent = getTargetDefaultEventIndex();
  202.     PropertyDescriptor pds[] = getTargetPropertyInfo();
  203.     int defaultProperty = getTargetDefaultPropertyIndex();
  204.     MethodDescriptor mds[] = getTargetMethodInfo();
  205.  
  206.         return new GenericBeanInfo(bd, esds, defaultEvent, pds,
  207.             defaultProperty, mds, informant);
  208.     
  209.     }
  210.  
  211.     private BeanInfo findInformant(Class beanClass) {
  212.     String name = beanClass.getName() + "BeanInfo";
  213.         try {
  214.         return (java.beans.BeanInfo)instantiate(beanClass, name);
  215.     } catch (Exception ex) {
  216.         // Just drop through
  217.         }
  218.     // Now try looking for <searchPath>.fooBeanInfo
  219.        while (name.indexOf('.') > 0) {
  220.         name = name.substring(name.indexOf('.')+1);
  221.     }
  222.     for (int i = 0; i < searchPath.length; i++) {
  223.         try {
  224.         String fullName = searchPath[i] + "." + name;
  225.             return (java.beans.BeanInfo)instantiate(beanClass, fullName);
  226.         } catch (Exception ex) {
  227.            // Silently ignore any errors.
  228.         }
  229.     }
  230.     return null;
  231.     }
  232.  
  233.     /**
  234.      * @return An array of PropertyDescriptors describing the editable
  235.      * properties supported by the target bean.
  236.      */
  237.  
  238.     private PropertyDescriptor[] getTargetPropertyInfo() throws IntrospectionException {
  239.  
  240.     // Check if the bean has its own BeanInfo that will provide
  241.     // explicit information.
  242.         PropertyDescriptor[] explicit = null;
  243.     if (informant != null) {
  244.         explicit = informant.getPropertyDescriptors();
  245.         int ix = informant.getDefaultPropertyIndex();
  246.         if (ix >= 0 && ix < explicit.length) {
  247.         defaultPropertyName = explicit[ix].getName();
  248.         }
  249.         }
  250.  
  251.     if (explicit == null && superBeanInfo != null) {
  252.         // We have no explicit BeanInfo properties.  Check with our parent.
  253.         PropertyDescriptor supers[] = superBeanInfo.getPropertyDescriptors();
  254.         for (int i = 0 ; i < supers.length; i++) {
  255.         addProperty(supers[i]);
  256.         }
  257.         int ix = superBeanInfo.getDefaultPropertyIndex();
  258.         if (ix >= 0 && ix < supers.length) {
  259.         defaultPropertyName = supers[ix].getName();
  260.         }
  261.     }
  262.  
  263.     for (int i = 0; i < additionalBeanInfo.length; i++) {
  264.         PropertyDescriptor additional[] = additionalBeanInfo[i].getPropertyDescriptors();
  265.         if (additional != null) {
  266.             for (int j = 0 ; j < additional.length; j++) {
  267.             addProperty(additional[j]);
  268.             }
  269.         }
  270.     }
  271.  
  272.     if (explicit != null) {
  273.         // Add the explicit informant data to our results.
  274.         for (int i = 0 ; i < explicit.length; i++) {
  275.         addProperty(explicit[i]);
  276.         }
  277.  
  278.     } else {
  279.  
  280.         // Apply some reflection to the current class.
  281.  
  282.         // First get an array of all the beans methods at this level
  283.         Method methodList[] = getDeclaredMethods(beanClass);
  284.  
  285.         // Now analyze each method.
  286.         for (int i = 0; i < methodList.length; i++) {
  287.             Method method = methodList[i];
  288.             // skip static and non-public methods.
  289.         int mods = method.getModifiers();
  290.         if (Modifier.isStatic(mods) || !Modifier.isPublic(mods)) {
  291.             continue;
  292.         }
  293.             String name = method.getName();
  294.             Class argTypes[] = method.getParameterTypes();
  295.             Class resultType = method.getReturnType();
  296.         int argCount = argTypes.length;
  297.         PropertyDescriptor pd = null;
  298.  
  299.         try {
  300.  
  301.                 if (argCount == 0) {
  302.                 if (name.startsWith("get")) {
  303.                     // Simple getter
  304.                         pd = new PropertyDescriptor(decapitalize(name.substring(3)),
  305.                         method, null);
  306.                     } else if (resultType == boolean.class && name.startsWith("is")) {
  307.                     // Boolean getter
  308.                         pd = new PropertyDescriptor(decapitalize(name.substring(2)),
  309.                         method, null);
  310.                 }
  311.                 } else if (argCount == 1) {
  312.                 if (argTypes[0] == int.class && name.startsWith("get")) {
  313.                     pd = new IndexedPropertyDescriptor(
  314.                     decapitalize(name.substring(3)),
  315.                     null, null,
  316.                     method,    null);
  317.                 } else if (resultType == void.class && name.startsWith("set")) {
  318.                     // Simple setter
  319.                         pd = new PropertyDescriptor(decapitalize(name.substring(3)),
  320.                         null, method);
  321.                     if (throwsException(method, PropertyVetoException.class)) {
  322.                     pd.setConstrained(true);
  323.                 }            
  324.                 }
  325.                 } else if (argCount == 2) {
  326.                 if (argTypes[0] == int.class && name.startsWith("set")) {
  327.                         pd = new IndexedPropertyDescriptor(
  328.                         decapitalize(name.substring(3)),
  329.                         null, null,
  330.                         null, method);
  331.                     if (throwsException(method, PropertyVetoException.class)) {
  332.                     pd.setConstrained(true);            
  333.                 }
  334.             }
  335.             }
  336.         } catch (IntrospectionException ex) {
  337.             // This happens if a PropertyDescriptor or IndexedPropertyDescriptor
  338.                 // constructor fins that the method violates details of the deisgn
  339.             // pattern, e.g. by having an empty name, or a getter returning
  340.             // void , or whatever.
  341.             pd = null;
  342.         }
  343.  
  344.         if (pd != null) {
  345.             // If this class or one of its base classes is a PropertyChange
  346.             // source, then we assume that any properties we discover are "bound".
  347.             if (propertyChangeSource) {
  348.             pd.setBound(true);
  349.             }
  350.             addProperty(pd);
  351.         }
  352.         }
  353.     }
  354.  
  355.     // Allocate and populate the result array.
  356.     PropertyDescriptor result[] = new PropertyDescriptor[properties.size()];
  357.     java.util.Enumeration elements = properties.elements();
  358.     for (int i = 0; i < result.length; i++) {
  359.         result[i] = (PropertyDescriptor)elements.nextElement();
  360.         if (defaultPropertyName != null
  361.              && defaultPropertyName.equals(result[i].getName())) {
  362.         defaultPropertyIndex = i;
  363.         }
  364.     }
  365.  
  366.     return result;
  367.     }
  368.  
  369.     void addProperty(PropertyDescriptor pd) {
  370.     String name = pd.getName();
  371.     PropertyDescriptor old = (PropertyDescriptor)properties.get(name);
  372.     if (old == null) {
  373.         properties.put(name, pd);
  374.         return;
  375.     }
  376.     // If the property type has changed, use the new descriptor.
  377.     Class opd = old.getPropertyType();
  378.     Class npd = pd.getPropertyType();
  379.     if (opd != null && npd != null && opd != npd) {
  380.         properties.put(name, pd);
  381.         return;
  382.     }
  383.  
  384.     PropertyDescriptor composite;
  385.     if (old instanceof IndexedPropertyDescriptor ||
  386.                 pd instanceof IndexedPropertyDescriptor) {
  387.         composite = new IndexedPropertyDescriptor(old, pd);
  388.     } else {
  389.         composite = new PropertyDescriptor(old, pd);
  390.     }
  391.     properties.put(name, composite);
  392.     }
  393.  
  394.  
  395.     /**
  396.      * @return An array of EventSetDescriptors describing the kinds of 
  397.      * events fired by the target bean.
  398.      */
  399.     private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {
  400.  
  401.     // Check if the bean has its own BeanInfo that will provide
  402.     // explicit information.
  403.         EventSetDescriptor[] explicit = null;
  404.     if (informant != null) {
  405.         explicit = informant.getEventSetDescriptors();
  406.         int ix = informant.getDefaultEventIndex();
  407.         if (ix >= 0 && ix < explicit.length) {
  408.         defaultEventName = explicit[ix].getName();
  409.         }
  410.     }
  411.  
  412.     if (explicit == null && superBeanInfo != null) {
  413.         // We have no explicit BeanInfo events.  Check with our parent.
  414.         EventSetDescriptor supers[] = superBeanInfo.getEventSetDescriptors();
  415.         for (int i = 0 ; i < supers.length; i++) {
  416.         addEvent(supers[i]);
  417.         }
  418.         int ix = superBeanInfo.getDefaultEventIndex();
  419.         if (ix >= 0 && ix < supers.length) {
  420.         defaultEventName = supers[ix].getName();
  421.         }
  422.     }
  423.  
  424.     for (int i = 0; i < additionalBeanInfo.length; i++) {
  425.         EventSetDescriptor additional[] = additionalBeanInfo[i].getEventSetDescriptors();
  426.         if (additional != null) {
  427.             for (int j = 0 ; j < additional.length; j++) {
  428.             addEvent(additional[j]);
  429.             }
  430.         }
  431.     }
  432.  
  433.     if (explicit != null) {
  434.         // Add the explicit informant data to our results.
  435.         for (int i = 0 ; i < explicit.length; i++) {
  436.         addEvent(explicit[i]);
  437.         }
  438.  
  439.     } else {
  440.  
  441.         // Apply some reflection to the current class.
  442.  
  443.         // Get an array of all the beans methods at this level
  444.         Method methodList[] = getDeclaredMethods(beanClass);
  445.  
  446.         // Find all suitable "add" and "remove" methods.
  447.         java.util.Hashtable adds = new java.util.Hashtable();
  448.         java.util.Hashtable removes = new java.util.Hashtable();
  449.         for (int i = 0; i < methodList.length; i++) {
  450.             Method method = methodList[i];
  451.             // skip static and non-public methods.
  452.         int mods = method.getModifiers();
  453.         if (Modifier.isStatic(mods) || !Modifier.isPublic(mods)) {
  454.             continue;
  455.         }
  456.             String name = method.getName();
  457.  
  458.             Class argTypes[] = method.getParameterTypes();
  459.             Class resultType = method.getReturnType();
  460.  
  461.             if (name.startsWith("add") && argTypes.length == 1 &&
  462.                     resultType == Void.TYPE) {
  463.             String compound = name.substring(3) + ":" + argTypes[0];
  464.             adds.put(compound, method);
  465.             } else if (name.startsWith("remove") && argTypes.length == 1 &&
  466.                     resultType == Void.TYPE) {
  467.             String compound = name.substring(6) + ":" + argTypes[0];
  468.             removes.put(compound, method);
  469.             }
  470.         }
  471.  
  472.            // Now look for matching addFooListener+removeFooListener pairs.
  473.           java.util.Enumeration keys = adds.keys();
  474.         String beanClassName = beanClass.getName();
  475.         while (keys.hasMoreElements()) {
  476.             String compound = (String) keys.nextElement();
  477.             // Skip any "add" which doesn't have a matching "remove".
  478.             if (removes.get(compound) == null) {
  479.             continue;
  480.             } 
  481.             // Method name has to end in "Listener"
  482.             if (compound.indexOf("Listener:") <= 0) {
  483.             continue;
  484.             }
  485.  
  486.             String listenerName = compound.substring(0, compound.indexOf(':'));
  487.             String eventName = decapitalize(listenerName.substring(0, listenerName.length()-8));
  488.             Method addMethod = (Method)adds.get(compound);
  489.             Method removeMethod = (Method)removes.get(compound);
  490.             Class argType = addMethod.getParameterTypes()[0];
  491.  
  492.             // Check if the argument type is a subtype of EventListener
  493.             if (!Introspector.isSubclass(argType, eventListenerType)) {
  494.                 continue;
  495.             }
  496.  
  497.                 // generate a list of Method objects for each of the target methods:
  498.             Method allMethods[] = argType.getMethods();
  499.             int count = 0;
  500.             for (int i = 0; i < allMethods.length; i++) {
  501.                 if (isEventHandler(allMethods[i])) {
  502.                 count++;
  503.                 } else {
  504.                 allMethods[i] = null;
  505.                 }
  506.             }
  507.             Method methods[] = new Method[count];
  508.             int j = 0;
  509.             for (int i = 0; i < allMethods.length; i++) {
  510.                 if (allMethods[i] != null) {
  511.                 methods[j++] = allMethods[i];
  512.                 }
  513.              }
  514.  
  515.               EventSetDescriptor esd = new EventSetDescriptor(eventName, argType,
  516.                         methods, addMethod, removeMethod);
  517.  
  518.         // If the adder method throws the TooManyListenersException then it
  519.         // is a Unicast event source.
  520.         if (throwsException(addMethod,
  521.             java.util.TooManyListenersException.class)) {
  522.             esd.setUnicast(true);
  523.         }
  524.  
  525.         addEvent(esd);
  526.         }
  527.     }
  528.  
  529.     // Allocate and populate the result array.
  530.     EventSetDescriptor result[] = new EventSetDescriptor[events.size()];
  531.     java.util.Enumeration elements = events.elements();
  532.     for (int i = 0; i < result.length; i++) {
  533.         result[i] = (EventSetDescriptor)elements.nextElement();
  534.         if (defaultEventName != null 
  535.                 && defaultEventName.equals(result[i].getName())) {
  536.         defaultEventIndex = i;
  537.         }
  538.     }
  539.  
  540.     return result;
  541.     }
  542.  
  543.     void addEvent(EventSetDescriptor esd) {
  544.     String key = esd.getName();
  545.     if (key.equals("propertyChange")) {
  546.         propertyChangeSource = true;
  547.     }
  548.     EventSetDescriptor old = (EventSetDescriptor)events.get(key);
  549.     if (old == null) {
  550.         events.put(key, esd);
  551.         return;
  552.     }
  553.     EventSetDescriptor composite = new EventSetDescriptor(old, esd);
  554.     events.put(key, composite);
  555.     }
  556.  
  557.     /**
  558.      * @return An array of MethodDescriptors describing the private
  559.      * methods supported by the target bean.
  560.      */
  561.     private MethodDescriptor[] getTargetMethodInfo() throws IntrospectionException {
  562.  
  563.     // Check if the bean has its own BeanInfo that will provide
  564.     // explicit information.
  565.         MethodDescriptor[] explicit = null;
  566.     if (informant != null) {
  567.         explicit = informant.getMethodDescriptors();
  568.     }
  569.  
  570.     if (explicit == null && superBeanInfo != null) {
  571.         // We have no explicit BeanInfo methods.  Check with our parent.
  572.         MethodDescriptor supers[] = superBeanInfo.getMethodDescriptors();
  573.         for (int i = 0 ; i < supers.length; i++) {
  574.         addMethod(supers[i]);
  575.         }
  576.     }
  577.  
  578.     for (int i = 0; i < additionalBeanInfo.length; i++) {
  579.         MethodDescriptor additional[] = additionalBeanInfo[i].getMethodDescriptors();
  580.         if (additional != null) {
  581.             for (int j = 0 ; j < additional.length; j++) {
  582.             addMethod(additional[j]);
  583.             }
  584.         }
  585.     }
  586.  
  587.     if (explicit != null) {
  588.         // Add the explicit informant data to our results.
  589.         for (int i = 0 ; i < explicit.length; i++) {
  590.         addMethod(explicit[i]);
  591.         }
  592.  
  593.     } else {
  594.  
  595.         // Apply some reflection to the current class.
  596.  
  597.         // First get an array of all the beans methods at this level
  598.         Method methodList[] = getDeclaredMethods(beanClass);
  599.  
  600.         // Now analyze each method.
  601.         for (int i = 0; i < methodList.length; i++) {
  602.             Method method = methodList[i];
  603.             // skip non-public methods.
  604.         if (!Modifier.isPublic(method.getModifiers())) {
  605.             continue;
  606.         }
  607.         MethodDescriptor md = new MethodDescriptor(method);
  608.         addMethod(md);
  609.         }
  610.     }
  611.  
  612.     // Allocate and populate the result array.
  613.     MethodDescriptor result[] = new MethodDescriptor[methods.size()];
  614.     java.util.Enumeration elements = methods.elements();
  615.     for (int i = 0; i < result.length; i++) {
  616.         result[i] = (MethodDescriptor)elements.nextElement();
  617.     }
  618.  
  619.     return result;
  620.     }
  621.  
  622.     private void addMethod(MethodDescriptor md) {
  623.     // We have to be careful here to distinguish method by both name
  624.     // and argument lists.
  625.     // This method gets called a *lot, so we try to be efficient.
  626.  
  627.     String name = md.getMethod().getName();
  628.  
  629.     MethodDescriptor old = (MethodDescriptor)methods.get(name);
  630.     if (old == null) {
  631.         // This is the common case.
  632.         methods.put(name, md);
  633.         return;
  634.     }    
  635.  
  636.     // We have a collision on method names.  This is rare.
  637.  
  638.     // Check if old and md have the same type.
  639.     Class p1[] = md.getMethod().getParameterTypes();    
  640.     Class p2[] = old.getMethod().getParameterTypes();    
  641.     boolean match = false;
  642.     if (p1.length == p2.length) {
  643.         match = true;
  644.         for (int i = 0; i < p1.length; i++) {
  645.         if (p1[i] != p2[i]) {
  646.             match = false;
  647.             break;
  648.         }
  649.         }
  650.     }
  651.     if (match) {
  652.         MethodDescriptor composite = new MethodDescriptor(old, md);
  653.         methods.put(name, composite);
  654.         return;
  655.     }
  656.  
  657.     // We have a collision on method names with different type signatures.
  658.     // This is very rare.
  659.  
  660.     String longKey = makeQualifiedMethodName(md);
  661.     old = (MethodDescriptor)methods.get(longKey);
  662.     if (old == null) {
  663.         methods.put(longKey, md);
  664.         return;
  665.     }    
  666.     MethodDescriptor composite = new MethodDescriptor(old, md);
  667.     methods.put(longKey, composite);
  668.     }
  669.  
  670.     private String makeQualifiedMethodName(MethodDescriptor md) {
  671.     Method m = md.getMethod();
  672.     StringBuffer sb = new StringBuffer();
  673.     sb.append(m.getName());
  674.     sb.append("=");
  675.     Class params[] = m.getParameterTypes();
  676.     for (int i = 0; i < params.length; i++) {
  677.         sb.append(":");
  678.         sb.append(params[i].getName());
  679.     }
  680.     return sb.toString();
  681.     }
  682.  
  683.     private int getTargetDefaultEventIndex() {
  684.     return defaultEventIndex;
  685.     }
  686.  
  687.     private int getTargetDefaultPropertyIndex() {
  688.     return defaultPropertyIndex;
  689.     }
  690.  
  691.     private BeanDescriptor getTargetBeanDescriptor() throws IntrospectionException {
  692.     // Use explicit info, if available,
  693.     if (informant != null) {
  694.         BeanDescriptor bd = informant.getBeanDescriptor();
  695.         if (bd != null) {
  696.         return (bd);
  697.         }
  698.     }
  699.     // OK, fabricate a default BeanDescriptor.
  700.     return (new BeanDescriptor(beanClass));
  701.     }
  702.  
  703.     private boolean isEventHandler(Method m) throws IntrospectionException {
  704.     // Right now we assume that a method is an event handler if it
  705.     // has a single argument, whose type name includes the word
  706.     // "Event".  The real answer is that the argument type should
  707.     // inherit from java.util.Event or somesuch, but we're not quite
  708.     // there yet.
  709.     try {
  710.         Class argTypes[] = m.getParameterTypes();
  711.         if (argTypes.length != 1) {
  712.         return (false);
  713.         }
  714.         String type = "" + argTypes[0];
  715.         if (type.indexOf("Event") >= 0) {
  716.         return (true);
  717.         } else {
  718.         return (false);
  719.         }
  720.         
  721.     } catch (Exception ex) {
  722.         throw new IntrospectionException("Unexpected reflection exception: " + ex);
  723.     }
  724.     }
  725.  
  726.     private static synchronized Method[] getDeclaredMethods(Class clz) {
  727.     // Looking up Class.getDeclaredMethods is realtively expensive,
  728.     // so we cache the results.
  729.     if (declaredMethodCache == null) {
  730.        declaredMethodCache = new java.util.Hashtable();
  731.     }
  732.     Method[] result = (Method[])declaredMethodCache.get(clz);
  733.     if (result == null) {
  734.         result = clz.getDeclaredMethods();
  735.         declaredMethodCache.put(clz, result);
  736.     }
  737.     return result;
  738.     }
  739.  
  740.     //======================================================================
  741.     // Package private support methods.
  742.     //======================================================================
  743.  
  744.     /**
  745.      * Find a target methodName on a given class.
  746.      */
  747.  
  748.     static Method findMethod(Class cls, String methodName, int argCount) 
  749.             throws IntrospectionException {
  750.     if (methodName == null) {
  751.         return null;
  752.     }
  753.  
  754.     // For overriden methods we need to find the most derived version.
  755.     // So we start with the given cls and walk up the superclass chain.
  756.     while (cls != null) {
  757.             Method methods[] = getDeclaredMethods(cls);
  758.         for (int i = 0; i < methods.length; i++) {
  759.             Method method = methods[i];
  760.             // skip static and non-public methods.
  761.         int mods = method.getModifiers();
  762.         if (Modifier.isStatic(mods) || !Modifier.isPublic(mods)) {
  763.             continue;
  764.         }
  765.             if (method.getName().equals(methodName) &&
  766.             method.getParameterTypes().length == argCount) {
  767.                 return method;
  768.              }
  769.         }
  770.         cls = cls.getSuperclass();
  771.     }
  772.  
  773.     // We failed to find a suitable method
  774.     throw new IntrospectionException("No method \"" + methodName + 
  775.                     "\" with " + argCount + " arg(s)");
  776.     }
  777.  
  778.     /**
  779.      * Return true if class a is either equivalent to class b, or
  780.      * if class a is a subclass of class b.
  781.      * Note tht either or both "Class" objects may represent interfaces.
  782.      */
  783.     static  boolean isSubclass(Class a, Class b) {
  784.     // We rely on the fact that for any given java class or
  785.         // primtitive type there is a unqiue Class object, so
  786.     // we can use object equivalence in the comparisons.
  787.     if (a == b) {
  788.         return true;
  789.     }
  790.     if (a == null || b == null) {
  791.         return false;
  792.     }
  793.     for (Class x = a; x != null; x = x.getSuperclass()) {
  794.         if (x == b) {    
  795.         return true;
  796.         }
  797.         if (b.isInterface()) {
  798.         Class interfaces[] = x.getInterfaces();
  799.         for (int i = 0; i < interfaces.length; i++) {
  800.             if (isSubclass(interfaces[i], b)) {
  801.             return true;
  802.             }
  803.         }
  804.         }
  805.     }
  806.     return false;
  807.     }
  808.  
  809.     /**
  810.      * Return true iff the given method throws the given exception.
  811.      */
  812.     private boolean throwsException(Method method, Class exception) {
  813.     Class exs[] = method.getExceptionTypes();
  814.     for (int i = 0; i < exs.length; i++) {
  815.         if (exs[i] == exception) {
  816.         return true;
  817.         }
  818.     }
  819.     return false;
  820.     }
  821.  
  822.     /**
  823.      * Try to create an instance of a named class.
  824.      * First try the classloader of "sibling", then try the system
  825.      * classloader.
  826.      */
  827.  
  828.     static Object instantiate(Class sibling, String className)
  829.          throws InstantiationException, IllegalAccessException,
  830.                         ClassNotFoundException {
  831.     // First check with sibling's classloader (if any). 
  832.     ClassLoader cl = sibling.getClassLoader();
  833.     if (cl != null) {
  834.         try {
  835.             Class cls = cl.loadClass(className);
  836.         return cls.newInstance();
  837.         } catch (Exception ex) {
  838.             // Just drop through and try the system classloader.
  839.         }
  840.         }
  841.     // Now try the system classloader.
  842.     Class cls = Class.forName(className);
  843.     return cls.newInstance();
  844.     }
  845.  
  846.     //======================================================================
  847.  
  848.     private BeanInfo informant;
  849.     private boolean propertyChangeSource = false;
  850.     private Class beanClass;
  851.     private BeanInfo superBeanInfo;
  852.     private BeanInfo additionalBeanInfo[];
  853.     private static java.util.Hashtable beanInfoCache = new java.util.Hashtable();
  854.     private static Class eventListenerType = java.util.EventListener.class;
  855.     private String defaultEventName;
  856.     private String defaultPropertyName;
  857.     private int defaultEventIndex = -1;
  858.     private int defaultPropertyIndex = -1;
  859.  
  860.     // Methods maps from Method objects to MethodDescriptors
  861.     private java.util.Hashtable methods = new java.util.Hashtable();
  862.  
  863.     // Cache of Class.getDeclaredMethods:
  864.     private static java.util.Hashtable declaredMethodCache;
  865.  
  866.     // properties maps from String names to PropertyDescriptors
  867.     private java.util.Hashtable properties = new java.util.Hashtable();
  868.  
  869.     // events maps from String names to EventSetDescriptors
  870.     private java.util.Hashtable events = new java.util.Hashtable();
  871.  
  872.     private static String[] searchPath = { "sun.beans.infos" };
  873.  
  874. }
  875.  
  876. //===========================================================================
  877.  
  878. /**
  879.  * Package private implementation support class for Introspector's
  880.  * internal use.
  881.  */
  882.  
  883. class GenericBeanInfo extends SimpleBeanInfo {
  884.  
  885.     public GenericBeanInfo(BeanDescriptor beanDescriptor,
  886.         EventSetDescriptor[] events, int defaultEvent,
  887.         PropertyDescriptor[] properties, int defaultProperty,
  888.         MethodDescriptor[] methods, BeanInfo targetBeanInfo) {
  889.     this.beanDescriptor = beanDescriptor;
  890.     this.events = events;
  891.     this.defaultEvent = defaultEvent;
  892.     this.properties = properties;
  893.     this.defaultProperty = defaultProperty;
  894.     this.methods = methods;
  895.     this.targetBeanInfo = targetBeanInfo;
  896.     }
  897.  
  898.     public PropertyDescriptor[] getPropertyDescriptors() {
  899.     return properties;
  900.     }
  901.  
  902.     public int getDefaultPropertyIndex() {
  903.     return defaultProperty;
  904.     }
  905.  
  906.     public EventSetDescriptor[] getEventSetDescriptors() {
  907.     return events;
  908.     }
  909.  
  910.     public int getDefaultEventIndex() {
  911.     return defaultEvent;
  912.     }
  913.  
  914.     public MethodDescriptor[] getMethodDescriptors() {
  915.     return methods;
  916.     }
  917.  
  918.     public BeanDescriptor getBeanDescriptor() {
  919.     return beanDescriptor;
  920.     }
  921.  
  922.     public java.awt.Image getIcon(int iconKind) {
  923.     if (targetBeanInfo != null) {
  924.         return targetBeanInfo.getIcon(iconKind);
  925.     }
  926.     return super.getIcon(iconKind);
  927.     }
  928.  
  929.     private BeanDescriptor beanDescriptor;
  930.     private EventSetDescriptor[] events;
  931.     private int defaultEvent;
  932.     private PropertyDescriptor[] properties;
  933.     private int defaultProperty;
  934.     private MethodDescriptor[] methods;
  935.     private BeanInfo targetBeanInfo;
  936. }
  937.