Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. How to make Spring accept fluent (non-void) setters?
I have an API which I am turning into an internal DSL. As such, most methods in my PoJos return a reference to this so that I can chain methods together declaratively as such (syntactic sugar). myComponent .setID("MyId") .setProperty("One") .setProperty2("Two") .setAssociation(anotherComponent) .execute(); My API does not depend on Spring but I wish to make it 'Spring-Fri...
2. Where is the JavaBean property naming convention defined?
The Spring Framework API doc says: The convention used is to return the uncapitalized short name of the Class, according to JavaBeans property naming rules: So, com.myapp.Product becomes product; com.myapp.MyProduct becomes myProduct; com.myapp.UKProduct becomes UKProduct. I looked at Suns website to find a definition, but didn't find one. I wonder about a rule for names with more than o...
3. Java Reflection - Get all instance variable names of a class
I'm writing an android app that requires binding a JSON object into a domain entity with the keys from the JSON as instance variables. Since there are several domain entities, each with different instance variables that the JSON needs to bind to in the app, i'd like to write a method such as ths following: Loop through all the instance variables from the domain if a key exists in the JSON wit...
4. GetDeclaredField(String) vs. getMethod(String) for private fields in a bean
I have a bean whose properties I want to access via reflection. I receive the property names in String form. The beans have getter methods for their private fields. I am currently getting the field using getDeclaredField(fieldName), making it accessible by using setAccessible(true) and then retrieving its value using get. Another way to go about it would be to capitalize the field name and ad...
5. Convert single char in String to lower case
I like to 'guess' attribute names from getter methods. So 'getSomeAttribute' shall be converted to 'someAttribute'. Usually I do something like String attributeName = Character.toLowerCase(methodName.indexOf(3)) + methodName.substring(4); Pretty ugly, right? I usually hide it in a method, but does anybody know a better solution?
6. Java Prevent code duplication when getting a list of a property in each Object from a list of Objects
I have several objects that look like this: class PhoneNumber { String getNumber(); String getExtension(); DateTime getLastCalled(); } class Address { String getCity(); string getState(); int getZip(); } I'd like to be able to take a List of any one of those objects and get a list of a particular property. This is a trivial operation if I were to write a function fo...
7. Can I use the builder design pattern together with hibernate?
Assuming I have this class: public class MyEntity { private int id; private String name; private MyEntity(int id, String name) {this.id= id; this.name = name;} public static class MyEntityBuilder { private int id; private String name; private MyEntityBuilder setId(int id) {this.id = id;} private MyEntityBuilder setName(String name) {this.name = name;} private MyEnti...
8. JavaBean class rules
What are the correct rules to write a JavaBean class? I'm confused because some books use MUST while other user SHOULD or COULD to describe the writing rule: i.e. a bean class MUST implements Serializable or SHOULD? the instance variables MUST be private or SHOULD BE?
9. How to copy properties from one Java bean to another?
I have a simple Java POJO that I would copy properties to another instance of same POJO class. I know I can do that with BeanUtils.copyProperties() but I would like to avoid use of a third-party library. So, how to do that simply, the proper and safer way ? By the way, I'm using Java 6.
10. Howto handle a POJO like a bean?
How can I access a simple java object as a bean? For example: class Simple { private String foo; String getFoo() { return foo; } private void setFoo( String foo ) { this.foo = foo; } } Now I want to use this object like this: Simple simple = new Simple(); simple.setFoo( "hello" ); checkSettings( simple ); So I'm looking for the implementation of the m...
11. Get bean property getter or setter by reflection?
Suppose I have a handle on an object of type , and I'm told by configuration that it has a bean property of type int with the name age. How can I retrieve the getter for this document? Is there a better way than prepending "get" and capitalizing the "a" in age, and looking for a method of that name via reflection?
12. Java generic methods cast to parameter type at runtime, is it possible?
I have a method that looks like this public static <T extends MyClass, X extends AnotherClass> List<T> (Class<T> aParameter, X anotherParameter) Now if AnotherClass is an abstract class that does NOT Have getId defined, but every single class that extends this interface does. (Don't ask me why it is designed this why, I did not design the abstract class, and I am not allo...
13. Java "events" - nothing more than Interfaces. Why pretend it is Events when it is just a normal Interface and classes that im...
I am mainly developing in .NET C# and I love the Events in C#. Im now doing som Android stuff and thus must deal with Java. When porting some code from C# to Java I ran into the problem of Events; Java does not have anything that corresponds to C# Events. So, when reading up on how Java handles "events", the only thing I can conclude is that it doesnt. There is no such thing as "events" in Ja...
14. Java Reflection Beans Property API
Is there any standard way to access Java Bean Property like class A { private String name; public void setName(String name){ this.name = name; } public String getName(){ return this.name; } } So can I access this java bean property name using Reflection API so that when I change the value of property the methods of getName and setName are called automatically ...
15. Am I misunderstanding the JavaBean method naming convention or is this an anomoly?
I have mysterious happenings in my code. Here's the snippet from the bean: public List<HelpContentsFrag> getCFrags() { return cFrags; } public void setCFrags(List<HelpContentsFrag> frags) { cFrags = frags; } Here's the snippet from my view code (tag file) cFrags:[${topic.cFrags}] where topic is an object of the bean type. Here's the error: javax.el.PropertyNotFoundE...
16. Update persistent object with transient object using Hibernate
On a daily basis, data is imported via a webservice. I create a new (transient) instance of a pojo which i have mapped in hibernate via JPA annotations. I populate the data from the webservice into the transient instance I load the persistient object from the database that I want to update with the data in my transient instance. I somehow merge this transient instance with the persistent one....
17. Java Reflection Property String name ->Class Datatype
Is there a way to specify the String name of a property in a particular bean and return the class that the getter corresponds to?
18. How to set the fields of an object given a map of key/values?
I want to implement something similar to the JobDetailBean in spring http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/scheduling.html#scheduling-quartz-jobdetail where a map of properties can be applied to an object to set its fields. I looked through the spring source code but couldn't see how they do it. Does anybody have any ideas on how to do this ?
19. In java i have a bean object(type unknown) i want to put the members of it into one hashmap
In java i have a bean object(type unknown) i want to put the values of members of that bean into one HashMap with class members as key.Without using reflection can i do that if so how ? otherwise tell me a good way to do it using reflection beanObject = { name="raja",age="20"} to haspMapObj = {name="raja",age="20"} As peoples you said i tried introspector: thank you for your answer and advise ...
20. One-way synchronization: how to block on one particular method?
Greetings, fellow SO users. I am currently in the process of writing a class of which instances will serve as a cache of JavaBean PropertyDescriptors. You can call a method getPropertyDescriptor(Class clazz, String propertyName) which will return the appropriate PropertyDescriptor. If it wasn't retrieved previously, the BeanInfo instance for the class is obtained and the right descriptor locat...
21. Invalid property exception in spring
I am using spring in my application , When i am loading the springApplicationContext to get the beans i am getting the errors Caused by: org.springframework.beans.InvalidPropertyException: Invalid property "abc" Even though there is a property abc and the setter for that property in the bean. This is a weird error i know , but i can't figure out where is the problem. Any pointers w... 
1
   /*
2
    * Copyright 1996-2006 Sun Microsystems, Inc.  All Rights Reserved.
3
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
    *
5
    * This code is free software; you can redistribute it and/or modify it
6
    * under the terms of the GNU General Public License version 2 only, as
7
    * published by the Free Software Foundation.  Sun designates this
8
    * particular file as subject to the "Classpath" exception as provided
9
    * by Sun in the LICENSE file that accompanied this code.
10
   *
11
   * This code is distributed in the hope that it will be useful, but WITHOUT
12
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
   * version 2 for more details (a copy is included in the LICENSE file that
15
   * accompanied this code).
16
   *
17
   * You should have received a copy of the GNU General Public License version
18
   * 2 along with this work; if not, write to the Free Software Foundation,
19
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
   *
21
   * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
   * CA 95054 USA or visit www.sun.com if you need additional information or
23
   * have any questions.
24
   */
25
  
26
  package java.beans;
27
  
29
  
32
  
35
  
38
  
40
  import java.util.Map;
42
  import java.util.HashMap;
45
  import java.util.List;
47
  import java.util.TreeMap;
The Introspector class provides a standard way for tools to learn about the properties, events, and methods supported by a target Java Bean.

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.

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.

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".

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.

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).

Because the Introspector caches BeanInfo classes for better performance, take care if you use it in an application that uses multiple class loaders. In general, when you destroy a ClassLoader that has been used to introspect classes, you should use the Introspector.flushCaches or Introspector.flushFromCaches method to flush all of the introspected classes out of the cache.

For more information about introspection and design patterns, please consult the JavaBeans specification. 

102
 
103
 
104
 public class Introspector {
105
 
106
     // Flags that can be used to control getBeanInfo:
107
     public final static int USE_ALL_BEANINFO           = 1;
108
     public final static int IGNORE_IMMEDIATE_BEANINFO  = 2;
109
     public final static int IGNORE_ALL_BEANINFO        = 3;
110
 
111
     // Static Caches to speed up introspection.
112
     private static Map declaredMethodCache =
113
         Collections.synchronizedMap(new WeakHashMap());
114
     private static Map beanInfoCache =
115
         Collections.synchronizedMap(new WeakHashMap());
116
 
117
     private Class beanClass;
118
     private BeanInfo explicitBeanInfo;
119
     private BeanInfo superBeanInfo;
120
     private BeanInfo additionalBeanInfo[];
121
 
122
     private boolean propertyChangeSource = false;
123
     private static Class eventListenerType = EventListener.class;
124
 
125
     // These should be removed.
126
     private String defaultEventName;
127
     private String defaultPropertyName;
128
     private int defaultEventIndex = -1;
129
     private int defaultPropertyIndex = -1;
130
 
131
     // Methods maps from Method objects to MethodDescriptors
132
     private Map methods;
133
 
134
     // properties maps from String names to PropertyDescriptors
135
     private Map properties;
136
 
137
     // events maps from String names to EventSetDescriptors
138
     private Map events;
139
 
140
     private final static String DEFAULT_INFO_PATH = "sun.beans.infos";
141
 
142
     private static String[] searchPath = {  };
143
 
144
     private final static EventSetDescriptor[] EMPTY_EVENTSETDESCRIPTORS = new EventSetDescriptor[0];
145
 
146
     static final String ADD_PREFIX = "add";
147
     static final String REMOVE_PREFIX = "remove";
148
     static final String GET_PREFIX = "get";
149
     static final String SET_PREFIX = "set";
150
     static final String IS_PREFIX = "is";
151
 
152
     private static final String BEANINFO_SUFFIX = "BeanInfo";
153
 
154
     //======================================================================
155
     //                          Public methods
156
     //======================================================================
157
 
    
Introspect on a Java Bean and learn about all its properties, exposed methods, and events.

If the BeanInfo class for a Java Bean has been previously Introspected then the BeanInfo class is retrieved from the BeanInfo cache.

Parameters:
beanClass The bean class to be analyzed.
Returns:
A BeanInfo object describing the target bean.
Throws:
IntrospectionException if an exception occurs during introspection.
See also:
flushCaches()
flushFromCaches(java.lang.Class)
171
 
172
     public static BeanInfo getBeanInfo(Class<?> beanClass)
173
         throws IntrospectionException
174
     {
175
         if (!ReflectUtil.isPackageAccessible(beanClass)) {
176
             return (new Introspector(beanClass, null, )).getBeanInfo();
177
         }
178
         BeanInfo bi = (BeanInfo).get(beanClass);
179
         if (bi == null) {
180
             bi = (new Introspector(beanClass, null, )).getBeanInfo();
181
             .put(beanClass, bi);
182
         }
183
         return bi;
184
     }

    
Introspect on a Java bean and learn about all its properties, exposed methods, and events, subject to some control flags.

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.

Parameters:
beanClass The bean class to be analyzed.
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.
Returns:
A BeanInfo object describing the target bean.
Throws:
IntrospectionException if an exception occurs during introspection.
206
 
207
     public static BeanInfo getBeanInfo(Class<?> beanClass, int flags)
208
                                                 throws IntrospectionException {
209
         return getBeanInfo(beanClass, null, flags);
210
     }

    
Introspect on a Java bean and learn all about its properties, exposed methods, below a given "stop" point.

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.

Parameters:
beanClass The bean class to be analyzed.
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.
Throws:
IntrospectionException if an exception occurs during introspection.
226
 
227
     public static BeanInfo getBeanInfo(Class<?> beanClass, Class<?> stopClass)
228
                                                 throws IntrospectionException {
229
         return getBeanInfo(beanClass, stopClass, );
230
     }

    
Only called from the public getBeanInfo methods. This method caches the Introspected BeanInfo based on the arguments. 
235
 
236
     private static BeanInfo getBeanInfo(Class beanClass, Class stopClass,
237
                                         int flags) throws IntrospectionException {
238
         BeanInfo bi;
239
         if (stopClass == null && flags == ) {
240
             // Same parameters to take advantage of caching.
241
             bi = getBeanInfo(beanClass);
242
         } else {
243
             bi = (new Introspector(beanClass, stopClass, flags)).getBeanInfo();
244
         }
245
         return bi;
246
 
247
         // Old behaviour: Make an independent copy of the BeanInfo.
248
         //return new GenericBeanInfo(bi);
249
     }


    
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.

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

Parameters:
name The string to be decapitalized.
Returns:
The decapitalized version of the string.
264
 
265
     public static String decapitalize(String name) {
266
         if (name == null || name.length() == 0) {
267
             return name;
268
         }
269
         if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
270
                         Character.isUpperCase(name.charAt(0))){
271
             return name;
272
         }
273
         char chars[] = name.toCharArray();
274
         chars[0] = Character.toLowerCase(chars[0]);
275
         return new String(chars);
276
     }

    
Gets the list of package names that will be used for finding BeanInfo classes.

Returns:
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"}.
286
 
287
 
288
     public static synchronized String[] getBeanInfoSearchPath() {
289
         // Return a copy of the searchPath.
290
         String result[] = new String[.];
291
         for (int i = 0; i < .; i++) {
292
             result[i] = [i];
293
         }
294
         return result;
295
     }

    
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.

First, if there is a security manager, its checkPropertiesAccess method is called. This could result in a SecurityException.

Parameters:
path Array of package names.
Throws:
java.lang.SecurityException if a security manager exists and its checkPropertiesAccess method doesn't allow setting of system properties.
See also:
java.lang.SecurityManager.checkPropertiesAccess()
311
 
312
 
313
     public static synchronized void setBeanInfoSearchPath(String path[]) {
314
         SecurityManager sm = System.getSecurityManager();
315
         if (sm != null) {
316
             sm.checkPropertiesAccess();
317
         }
318
          = path;
319
     }


    
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. 
327
 
328
 
329
     public static void flushCaches() {
330
         .clear();
331
         .clear();
332
     }

    
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.

Parameters:
clz Class object to be flushed.
Throws:
java.lang.NullPointerException If the Class object is null.
348
 
349
     public static void flushFromCaches(Class<?> clz) {
350
         if (clz == null) {
351
             throw new NullPointerException();
352
         }
353
         .remove(clz);
354
         .remove(clz);
355
     }
356
 
357
     //======================================================================
358
     //                  Private implementation methods
359
     //======================================================================
360
 
361
     private Introspector(Class beanClass, Class stopClass, int flags)
362
                                             throws IntrospectionException {
363
         this. = beanClass;
364
 
365
         // Check stopClass is a superClass of startClass.
366
         if (stopClass != null) {
367
             boolean isSuper = false;
368
             for (Class c = beanClass.getSuperclass(); c != null; c = c.getSuperclass()) {
369
                 if (c == stopClass) {
370
                     isSuper = true;
371
                 }
372
             }
373
             if (!isSuper) {
374
                 throw new IntrospectionException(stopClass.getName() + " not superclass of " +
375
                                         beanClass.getName());
376
             }
377
         }
378
 
379
         if (flags == ) {
380
              = findExplicitBeanInfo(beanClass);
381
         }
382
 
383
         Class superClass = beanClass.getSuperclass();
384
         if (superClass != stopClass) {
385
             int newFlags = flags;
386
             if (newFlags == ) {
387
                 newFlags = ;
388
             }
389
              = getBeanInfo(superClass, stopClass, newFlags);
390
         }
391
         if ( != null) {
393
         }
394
         if ( == null) {
395
              = new BeanInfo[0];
396
         }
397
     }

    
Constructs a GenericBeanInfo class from the state of the Introspector 
401
 
402
     private BeanInfo getBeanInfo() throws IntrospectionException {
403
 
404
         // the evaluation order here is import, as we evaluate the
405
         // event sets and locate PropertyChangeListeners before we
406
         // look for properties.
407
         BeanDescriptor bd = getTargetBeanDescriptor();
408
         MethodDescriptor mds[] = getTargetMethodInfo();
409
         EventSetDescriptor esds[] = getTargetEventInfo();
410
         PropertyDescriptor pds[] = getTargetPropertyInfo();
411
 
412
         int defaultEvent = getTargetDefaultEventIndex();
413
         int defaultProperty = getTargetDefaultPropertyIndex();
414
 
415
         return new GenericBeanInfo(bd, esds, defaultEvent, pds,
416
                         defaultProperty, mds, );
417
 
418
     }

    
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.

Returns:
Instance of an explicit BeanInfo class or null if one isn't found.
427
 
428
     private static synchronized BeanInfo findExplicitBeanInfo(Class beanClass) {
429
         String name = beanClass.getName() + ;
430
         try {
431
             return (java.beans.BeanInfo)instantiate(beanClass, name);
432
         } catch (Exception ex) {
433
             // Just drop through
434
 
435
         }
436
         // Now try checking if the bean is its own BeanInfo.
437
         try {
438
             if (isSubclass(beanClass, java.beans.BeanInfo.class)) {
439
                 return (java.beans.BeanInfo)beanClass.newInstance();
440
             }
441
         } catch (Exception ex) {
442
             // Just drop through
443
         }
444
         // Now try looking for <searchPath>.fooBeanInfo
445
         name = name.substring(name.lastIndexOf('.')+1);
446
 
447
         for (int i = 0; i < .; i++) {
448
             // This optimization will only use the BeanInfo search path if is has changed
449
             // from the original or trying to get the ComponentBeanInfo.
450
             if (!.equals([i]) ||
451
                 .equals([i]) && "ComponentBeanInfo".equals(name)) {
452
                 try {
453
                     String fullName = [i] + "." + name;
454
                     java.beans.BeanInfo bi = (java.beans.BeanInfo)instantiate(beanClass, fullName);
455
 
456
                     // Make sure that the returned BeanInfo matches the class.
457
                     if (bi.getBeanDescriptor() != null) {
458
                         if (bi.getBeanDescriptor().getBeanClass() == beanClass) {
459
                             return bi;
460
                         }
461
                     } else if (bi.getPropertyDescriptors() != null) {
462
                         PropertyDescriptor[] pds = bi.getPropertyDescriptors();
463
                         for (int j = 0; j < pds.length; j++) {
464
                             Method method = pds[j].getReadMethod();
465
                             if (method == null) {
466
                                 method = pds[j].getWriteMethod();
467
                             }
468
                             if (method != null && method.getDeclaringClass() == beanClass) {
469
                                 return bi;
470
                             }
471
                         }
472
                     } else if (bi.getMethodDescriptors() != null) {
473
                         MethodDescriptor[] mds = bi.getMethodDescriptors();
474
                         for (int j = 0; j < mds.length; j++) {
475
                             Method method = mds[j].getMethod();
476
                             if (method != null && method.getDeclaringClass() == beanClass) {
477
                                 return bi;
478
                             }
479
                         }
480
                     }
481
                 } catch (Exception ex) {
482
                     // Silently ignore any errors.
483
                 }
484
             }
485
         }
486
         return null;
487
     }

    

Returns:
An array of PropertyDescriptors describing the editable properties supported by the target bean.
492
 
493
 
494
     private PropertyDescriptor[] getTargetPropertyInfo() {
495
 
496
         // Check if the bean has its own BeanInfo that will provide
497
         // explicit information.
498
         PropertyDescriptor[] explicitProperties = null;
499
         if ( != null) {
500
             explicitProperties = getPropertyDescriptors(this.);
501
         }
502
 
503
         if (explicitProperties == null &&  != null) {
504
             // We have no explicit BeanInfo properties.  Check with our parent.
506
         }
507
 
508
         for (int i = 0; i < .; i++) {
510
         }
511
 
512
         if (explicitProperties != null) {
513
             // Add the explicit BeanInfo data to our results.
514
             addPropertyDescriptors(explicitProperties);
515
 
516
         } else {
517
 
518
             // Apply some reflection to the current class.
519
 
520
             // First get an array of all the public methods at this level
521
             Method methodList[] = getPublicDeclaredMethods();
522
 
523
             // Now analyze each method.
524
             for (int i = 0; i < methodList.length; i++) {
525
                 Method method = methodList[i];
526
                 if (method == null || method.isSynthetic()) {
527
                     continue;
528
                 }
529
                 // skip static methods.
530
                 int mods = method.getModifiers();
531
                 if (Modifier.isStatic(mods)) {
532
                     continue;
533
                 }
534
                 String name = method.getName();
535
                 Class argTypes[] = method.getParameterTypes();
536
                 Class resultType = method.getReturnType();
537
                 int argCount = argTypes.length;
538
                 PropertyDescriptor pd = null;
539
 
540
                 if (name.length() <= 3 && !name.startsWith()) {
541
                     // Optimization. Don't bother with invalid propertyNames.
542
                     continue;
543
                 }
544
 
545
                 try {
546
 
547
                     if (argCount == 0) {
548
                         if (name.startsWith()) {
549
                             // Simple getter
550
                             pd = new PropertyDescriptor(this., name.substring(3), method, null);
551
                         } else if (resultType == boolean.class && name.startsWith()) {
552
                             // Boolean getter
553
                             pd = new PropertyDescriptor(this., name.substring(2), method, null);
554
                         }
555
                     } else if (argCount == 1) {
556
                         if (argTypes[0] == int.class && name.startsWith()) {
557
                             pd = new IndexedPropertyDescriptor(this., name.substring(3), null, null, method, null);
558
                         } else if (resultType == void.class && name.startsWith()) {
559
                             // Simple setter
560
                             pd = new PropertyDescriptor(this., name.substring(3), null, method);
561
                             if (throwsException(method, PropertyVetoException.class)) {
562
                                 pd.setConstrained(true);
563
                             }
564
                         }
565
                     } else if (argCount == 2) {
566
                             if (argTypes[0] == int.class && name.startsWith()) {
567
                             pd = new IndexedPropertyDescriptor(this., name.substring(3), null, null, null, method);
568
                             if (throwsException(method, PropertyVetoException.class)) {
569
                                 pd.setConstrained(true);
570
                             }
571
                         }
572
                     }
573
                 } catch (IntrospectionException ex) {
574
                     // This happens if a PropertyDescriptor or IndexedPropertyDescriptor
575
                     // constructor fins that the method violates details of the deisgn
576
                     // pattern, e.g. by having an empty name, or a getter returning
577
                     // void , or whatever.
578
                     pd = null;
579
                 }
580
 
581
                 if (pd != null) {
582
                     // If this class or one of its base classes is a PropertyChange
583
                     // source, then we assume that any properties we discover are "bound".
584
                     if () {
585
                         pd.setBound(true);
586
                     }
587
                     addPropertyDescriptor(pd);
588
                 }
589
             }
590
         }
591
         processPropertyDescriptors();
592
 
593
         // Allocate and populate the result array.
594
         PropertyDescriptor result[] = new PropertyDescriptor[.size()];
595
         result = (PropertyDescriptor[]).values().toArray(result);
596
 
597
         // Set the default index.
598
         if ( != null) {
599
             for (int i = 0; i < result.length; i++) {
600
                 if (.equals(result[i].getName())) {
601
                      = i;
602
                 }
603
             }
604
         }
605
 
606
         return result;
607
     }
608
 
609
     private HashMap pdStore = new HashMap();

    
Adds the property descriptor to the list store. 
613
 
614
     private void addPropertyDescriptor(PropertyDescriptor pd) {
615
         String propName = pd.getName();
616
         List list = (List).get(propName);
617
         if (list == null) {
618
             list = new ArrayList();
619
             .put(propName, list);
620
         }
621
         if (this. != pd.getClass0()) {
622
             // replace existing property descriptor
623
             // only if we have types to resolve
624
             // in the context of this.beanClass
625
             try {
626
                 String name = pd.getName();
627
                 Method read = pd.getReadMethod();
628
                 Method write = pd.getWriteMethod();
629
                 boolean cls = true;
630
                 if (read != null) cls = cls && read.getGenericReturnType() instanceof Class;
631
                 if (write != null) cls = cls && write.getGenericParameterTypes()[0] instanceof Class;
632
                 if (pd instanceof IndexedPropertyDescriptor) {
633
                     IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor)pd;
634
                     Method readI = ipd.getIndexedReadMethod();
635
                     Method writeI = ipd.getIndexedWriteMethod();
636
                     if (readI != null) cls = cls && readI.getGenericReturnType() instanceof Class;
637
                     if (writeI != null) cls = cls && writeI.getGenericParameterTypes()[1] instanceof Class;
638
                     if (!cls) {
639
                         pd = new IndexedPropertyDescriptor(this., name, read, write, readI, writeI);
640
                     }
641
                 } else if (!cls) {
642
                     pd = new PropertyDescriptor(this., name, read, write);
643
                 }
644
             } catch ( IntrospectionException e ) {
645
             }
646
         }
647
         list.add(pd);
648
     }
649
 
650
     private void addPropertyDescriptors(PropertyDescriptor[] descriptors) {
651
         if (descriptors != null) {
652
             for (PropertyDescriptor descriptor : descriptors) {
653
                 addPropertyDescriptor(descriptor);
654
             }
655
         }
656
     }
657
 
658
     private PropertyDescriptor[] getPropertyDescriptors(BeanInfo info) {
659
         PropertyDescriptor[] descriptors = info.getPropertyDescriptors();
660
         int index = info.getDefaultPropertyIndex();
661
         if ((0 <= index) && (index < descriptors.length)) {
662
             this. = descriptors[index].getName();
663
         }
664
         return descriptors;
665
     }

    
Populates the property descriptor table by merging the lists of Property descriptors. 
670
 
671
     private void processPropertyDescriptors() {
672
         if ( == null) {
673
              = new TreeMap();
674
         }
675
 
676
         List list;
677
 
678
         PropertyDescriptor pd, gpd, spd;
679
         IndexedPropertyDescriptor ipd, igpd, ispd;
680
 
681
         Iterator it = .values().iterator();
682
         while (it.hasNext()) {
683
             pd = null; gpd = null; spd = null;
684
             ipd = null; igpd = null; ispd = null;
685
 
686
             list = (List)it.next();
687
 
688
             // First pass. Find the latest getter method. Merge properties
689
             // of previous getter methods.
690
             for (int i = 0; i < list.size(); i++) {
691
                 pd = (PropertyDescriptor)list.get(i);
692
                 if (pd instanceof IndexedPropertyDescriptor) {
693
                     ipd = (IndexedPropertyDescriptor)pd;
694
                     if (ipd.getIndexedReadMethod() != null) {
695
                         if (igpd != null) {
696
                             igpd = new IndexedPropertyDescriptor(igpd, ipd);
697
                         } else {
698
                             igpd = ipd;
699
                         }
700
                     }
701
                 } else {
702
                     if (pd.getReadMethod() != null) {
703
                         if (gpd != null) {
704
                             // Don't replace the existing read
705
                             // method if it starts with "is"
706
                             Method method = gpd.getReadMethod();
707
                             if (!method.getName().startsWith()) {
708
                                 gpd = new PropertyDescriptor(gpd, pd);
709
                             }
710
                         } else {
711
                             gpd = pd;
712
                         }
713
                     }
714
                 }
715
             }
716
 
717
             // Second pass. Find the latest setter method which
718
             // has the same type as the getter method.
719
             for (int i = 0; i < list.size(); i++) {
720
                 pd = (PropertyDescriptor)list.get(i);
721
                 if (pd instanceof IndexedPropertyDescriptor) {
722
                     ipd = (IndexedPropertyDescriptor)pd;
723
                     if (ipd.getIndexedWriteMethod() != null) {
724
                         if (igpd != null) {
725
                             if (igpd.getIndexedPropertyType()
726
                                 == ipd.getIndexedPropertyType()) {
727
                                 if (ispd != null) {
728
                                     ispd = new IndexedPropertyDescriptor(ispd, ipd);
729
                                 } else {
730
                                     ispd = ipd;
731
                                 }
732
                             }
733
                         } else {
734
                             if (ispd != null) {
735
                                 ispd = new IndexedPropertyDescriptor(ispd, ipd);
736
                             } else {
737
                                 ispd = ipd;
738
                             }
739
                         }
740
                     }
741
                 } else {
742
                     if (pd.getWriteMethod() != null) {
743
                         if (gpd != null) {
744
                             if (gpd.getPropertyType() == pd.getPropertyType()) {
745
                                 if (spd != null) {
746
                                     spd = new PropertyDescriptor(spd, pd);
747
                                 } else {
748
                                     spd = pd;
749
                                 }
750
                             }
751
                         } else {
752
                             if (spd != null) {
753
                                 spd = new PropertyDescriptor(spd, pd);
754
                             } else {
755
                                 spd = pd;
756
                             }
757
                         }
758
                     }
759
                 }
760
             }
761
 
762
             // At this stage we should have either PDs or IPDs for the
763
             // representative getters and setters. The order at which the
764
             // property descriptors are determined represent the
765
             // precedence of the property ordering.
766
             pd = null; ipd = null;
767
 
768
             if (igpd != null && ispd != null) {
769
                 // Complete indexed properties set
770
                 // Merge any classic property descriptors
771
                 if (gpd != null) {
772
                     PropertyDescriptor tpd = mergePropertyDescriptor(igpd, gpd);
773
                     if (tpd instanceof IndexedPropertyDescriptor) {
774
                         igpd = (IndexedPropertyDescriptor)tpd;
775
                     }
776
                 }
777
                 if (spd != null) {
778
                     PropertyDescriptor tpd = mergePropertyDescriptor(ispd, spd);
779
                     if (tpd instanceof IndexedPropertyDescriptor) {
780
                         ispd = (IndexedPropertyDescriptor)tpd;
781
                     }
782
                 }
783
                 if (igpd == ispd) {
784
                     pd = igpd;
785
                 } else {
786
                     pd = mergePropertyDescriptor(igpd, ispd);
787
                 }
788
             } else if (gpd != null && spd != null) {
789
                 // Complete simple properties set
790
                 if (gpd == spd) {
791
                     pd = gpd;
792
                 } else {
793
                     pd = mergePropertyDescriptor(gpd, spd);
794
                 }
795
             } else if (ispd != null) {
796
                 // indexed setter
797
                 pd = ispd;
798
                 // Merge any classic property descriptors
799
                 if (spd != null) {
800
                     pd = mergePropertyDescriptor(ispd, spd);
801
                 }
802
                 if (gpd != null) {
803
                     pd = mergePropertyDescriptor(ispd, gpd);
804
                 }
805
             } else if (igpd != null) {
806
                 // indexed getter
807
                 pd = igpd;
808
                 // Merge any classic property descriptors
809
                 if (gpd != null) {
810
                     pd = mergePropertyDescriptor(igpd, gpd);
811
                 }
812
                 if (spd != null) {
813
                     pd = mergePropertyDescriptor(igpd, spd);
814
                 }
815
             } else if (spd != null) {
816
                 // simple setter
817
                 pd = spd;
818
             } else if (gpd != null) {
819
                 // simple getter
820
                 pd = gpd;
821
             }
822
 
823
             // Very special case to ensure that an IndexedPropertyDescriptor
824
             // doesn't contain less information than the enclosed
825
             // PropertyDescriptor. If it does, then recreate as a
826
             // PropertyDescriptor. See 4168833
827
             if (pd instanceof IndexedPropertyDescriptor) {
828
                 ipd = (IndexedPropertyDescriptor)pd;
829
                 if (ipd.getIndexedReadMethod() == null && ipd.getIndexedWriteMethod() == null) {
830
                     pd = new PropertyDescriptor(ipd);
831
                 }
832
             }
833
 
834
             // Find the first property descriptor
835
             // which does not have getter and setter methods.
836
             // See regression bug 4984912.
837
             if ( (pd == null) && (list.size() > 0) ) {
838
                 pd = (PropertyDescriptor) list.get(0);
839
             }
840
 
841
             if (pd != null) {
842
                 .put(pd.getName(), pd);
843
             }
844
         }
845
     }

    
Adds the property descriptor to the indexedproperty descriptor only if the types are the same. The most specific property descriptor will take precedence. 
852
 
854
                                                        PropertyDescriptor pd) {
855
         PropertyDescriptor result = null;
856
 
857
         Class propType = pd.getPropertyType();
858
         Class ipropType = ipd.getIndexedPropertyType();
859
 
860
         if (propType.isArray() && propType.getComponentType() == ipropType) {
861
             if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
862
                 result = new IndexedPropertyDescriptor(pd, ipd);
863
             } else {
864
                 result = new IndexedPropertyDescriptor(ipd, pd);
865
             }
866
         } else {
867
             // Cannot merge the pd because of type mismatch
868
             // Return the most specific pd
869
             if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
870
                 result = ipd;
871
             } else {
872
                 result = pd;
873
                 // Try to add methods which may have been lost in the type change
874
                 // See 4168833
875
                 Method write = result.getWriteMethod();
876
                 Method read = result.getReadMethod();
877
 
878
                 if (read == null && write != null) {
879
                     read = findMethod(result.getClass0(),
880
                                        + NameGenerator.capitalize(result.getName()), 0);
881
                     if (read != null) {
882
                         try {
883
                             result.setReadMethod(read);
884
                         } catch (IntrospectionException ex) {
885
                             // no consequences for failure.
886
                         }
887
                     }
888
                 }
889
                 if (write == null && read != null) {
890
                     write = findMethod(result.getClass0(),
891
                                         + NameGenerator.capitalize(result.getName()), 1,
892
                                        new Class[] { FeatureDescriptor.getReturnType(result.getClass0(), read) });
893
                     if (write != null) {
894
                         try {
895
                             result.setWriteMethod(write);
896
                         } catch (IntrospectionException ex) {
897
                             // no consequences for failure.
898
                         }
899
                     }
900
                 }
901
             }
902
         }
903
         return result;
904
     }
905
 
906
     // Handle regular pd merge
908
                                                        PropertyDescriptor pd2) {
909
         if (pd1.getClass0().isAssignableFrom(pd2.getClass0())) {
910
             return new PropertyDescriptor(pd1, pd2);
911
         } else {
912
             return new PropertyDescriptor(pd2, pd1);
913
         }
914
     }
915
 
916
     // Handle regular ipd merge
918
                                                        IndexedPropertyDescriptor ipd2) {
919
         if (ipd1.getClass0().isAssignableFrom(ipd2.getClass0())) {
920
             return new IndexedPropertyDescriptor(ipd1, ipd2);
921
         } else {
922
             return new IndexedPropertyDescriptor(ipd2, ipd1);
923
         }
924
     }

    

Returns:
An array of EventSetDescriptors describing the kinds of events fired by the target bean.
929
 
931
         if ( == null) {
932
              = new HashMap();
933
         }
934
 
935
         // Check if the bean has its own BeanInfo that will provide
936
         // explicit information.
937
         EventSetDescriptor[] explicitEvents = null;
938
         if ( != null) {
939
             explicitEvents = .getEventSetDescriptors();
940
             int ix = .getDefaultEventIndex();
941
             if (ix >= 0 && ix < explicitEvents.length) {
942
                  = explicitEvents[ix].getName();
943
             }
944
         }
945
 
946
         if (explicitEvents == null &&  != null) {
947
             // We have no explicit BeanInfo events.  Check with our parent.
948
             EventSetDescriptor supers[] = .getEventSetDescriptors();
949
             for (int i = 0 ; i < supers.length; i++) {
950
                 addEvent(supers[i]);
951
             }
952
             int ix = .getDefaultEventIndex();
953
             if (ix >= 0 && ix < supers.length) {
954
                  = supers[ix].getName();
955
             }
956
         }
957
 
958
         for (int i = 0; i < .; i++) {
959
             EventSetDescriptor additional[] = [i].getEventSetDescriptors();
960
             if (additional != null) {
961
                 for (int j = 0 ; j < additional.length; j++) {
962
                     addEvent(additional[j]);
963
                 }
964
             }
965
         }
966
 
967
         if (explicitEvents != null) {
968
             // Add the explicit explicitBeanInfo data to our results.
969
             for (int i = 0 ; i < explicitEvents.length; i++) {
970
                 addEvent(explicitEvents[i]);
971
             }
972
 
973
         } else {
974
 
975
             // Apply some reflection to the current class.
976
 
977
             // Get an array of all the public beans methods at this level
978
             Method methodList[] = getPublicDeclaredMethods();
979
 
980
             // Find all suitable "add", "remove" and "get" Listener methods
981
             // The name of the listener type is the key for these hashtables
982
             // i.e, ActionListener
983
             Map adds = null;
984
             Map removes = null;
985
             Map gets = null;
986
 
987
             for (int i = 0; i < methodList.length; i++) {
988
                 Method method = methodList[i];
989
                 if (method == null) {
990
                     continue;
991
                 }
992
                 // skip static methods.
993
                 int mods = method.getModifiers();
994
                 if (Modifier.isStatic(mods)) {
995
                     continue;
996
                 }
997
                 String name = method.getName();
998
                 // Optimization avoid getParameterTypes
999
                 if (!name.startsWith() && !name.startsWith()
1000
                    && !name.startsWith()) {
1001
                    continue;
1002
                }
1004
                Class argTypes[] = FeatureDescriptor.getParameterTypes(, method);
1005
                Class resultType = FeatureDescriptor.getReturnType(, method);
1007
                if (name.startsWith() && argTypes.length == 1 &&
1008
                    resultType == . &&
1009
                    Introspector.isSubclass(argTypes[0], )) {
1010
                    String listenerName = name.substring(3);
1011
                    if (listenerName.length() > 0 &&
1012
                        argTypes[0].getName().endsWith(listenerName)) {
1013
                        if (adds == null) {
1014
                            adds = new HashMap();
1015
                        }
1016
                        adds.put(listenerName, method);
1017
                    }
1018
                }
1019
                else if (name.startsWith() && argTypes.length == 1 &&
1020
                         resultType == . &&
1021
                         Introspector.isSubclass(argTypes[0], )) {
1022
                    String listenerName = name.substring(6);
1023
                    if (listenerName.length() > 0 &&
1024
                        argTypes[0].getName().endsWith(listenerName)) {
1025
                        if (removes == null) {
1026
                            removes = new HashMap();
1027
                        }
1028
                        removes.put(listenerName, method);
1029
                    }
1030
                }
1031
                else if (name.startsWith() && argTypes.length == 0 &&
1032
                         resultType.isArray() &&
1033
                         Introspector.isSubclass(resultType.getComponentType(),
1034
                                                 )) {
1035
                    String listenerName  = name.substring(3, name.length() - 1);
1036
                    if (listenerName.length() > 0 &&
1037
                        resultType.getComponentType().getName().endsWith(listenerName)) {
1038
                        if (gets == null) {
1039
                            gets = new HashMap();
1040
                        }
1041
                        gets.put(listenerName, method);
1042
                    }
1043
                }
1044
            }
1046
            if (adds != null && removes != null) {
1047
                // Now look for matching addFooListener+removeFooListener pairs.
1048
                // Bonus if there is a matching getFooListeners method as well.
1049
                Iterator keys = adds.keySet().iterator();
1050
                while (keys.hasNext()) {
1051
                    String listenerName = (String) keys.next();
1052
                    // Skip any "add" which doesn't have a matching "remove" or
1053
                    // a listener name that doesn't end with Listener
1054
                    if (removes.get(listenerName) == null || !listenerName.endsWith("Listener")) {
1055
                        continue;
1056
                    }
1057
                    String eventName = decapitalize(listenerName.substring(0, listenerName.length()-8));
1058
                    Method addMethod = (Method)adds.get(listenerName);
1059
                    Method removeMethod = (Method)removes.get(listenerName);
1060
                    Method getMethod = null;
1061
                    if (gets != null) {
1062
                        getMethod = (Method)gets.get(listenerName);
1063
                    }
1064
                    Class argType = FeatureDescriptor.getParameterTypes(, addMethod)[0];
1066
                    // generate a list of Method objects for each of the target methods:
1067
                    Method allMethods[] = getPublicDeclaredMethods(argType);
1068
                    List validMethods = new ArrayList(allMethods.length);
1069
                    for (int i = 0; i < allMethods.length; i++) {
1070
                        if (allMethods[i] == null) {
1071
                            continue;
1072
                        }
1074
                        if (isEventHandler(allMethods[i])) {
1075
                            validMethods.add(allMethods[i]);
1076
                        }
1077
                    }
1078
                    Method[] methods = (Method[])validMethods.toArray(new Method[validMethods.size()]);
1080
                    EventSetDescriptor esd = new EventSetDescriptor(eventName, argType,
1081
                                                                    methods, addMethod,
1082
                                                                    removeMethod,
1083
                                                                    getMethod);
1085
                    // If the adder method throws the TooManyListenersException then it
1086
                    // is a Unicast event source.
1087
                    if (throwsException(addMethod,
1088
                                        java.util.TooManyListenersException.class)) {
1089
                        esd.setUnicast(true);
1090
                    }
1091
                    addEvent(esd);
1092
                }
1093
            } // if (adds != null ...
1094
        }
1095
        EventSetDescriptor[] result;
1096
        if (.size() == 0) {
1097
            result = ;
1098
        } else {
1099
            // Allocate and populate the result array.
1100
            result = new EventSetDescriptor[.size()];
1101
            result = (EventSetDescriptor[]).values().toArray(result);
1103
            // Set the default index.
1104
            if ( != null) {
1105
                for (int i = 0; i < result.length; i++) {
1106
                    if (.equals(result[i].getName())) {
1107
                         = i;
1108
                    }
1109
                }
1110
            }
1111
        }
1112
        return result;
1113
    }
1115
    private void addEvent(EventSetDescriptor esd) {
1116
        String key = esd.getName();
1117
        if (esd.getName().equals("propertyChange")) {
1118
             = true;
1119
        }
1120
        EventSetDescriptor old = (EventSetDescriptor).get(key);
1121
        if (old == null) {
1122
            .put(key, esd);
1123
            return;
1124
        }
1125
        EventSetDescriptor composite = new EventSetDescriptor(old, esd);
1126
        .put(key, composite);
1127
    }

    

Returns:
An array of MethodDescriptors describing the private methods supported by the target bean.
1133
    private MethodDescriptor[] getTargetMethodInfo() {
1134
        if ( == null) {
1135
             = new HashMap(100);
1136
        }
1138
        // Check if the bean has its own BeanInfo that will provide
1139
        // explicit information.
1140
        MethodDescriptor[] explicitMethods = null;
1141
        if ( != null) {
1142
            explicitMethods = .getMethodDescriptors();
1143
        }
1145
        if (explicitMethods == null &&  != null) {
1146
            // We have no explicit BeanInfo methods.  Check with our parent.
1147
            MethodDescriptor supers[] = .getMethodDescriptors();
1148
            for (int i = 0 ; i < supers.length; i++) {
1149
                addMethod(supers[i]);
1150
            }
1151
        }
1153
        for (int i = 0; i < .; i++) {
1154
            MethodDescriptor additional[] = [i].getMethodDescriptors();
1155
            if (additional != null) {
1156
                for (int j = 0 ; j < additional.length; j++) {
1157
                    addMethod(additional[j]);
1158
                }
1159
            }
1160
        }
1162
        if (explicitMethods != null) {
1163
            // Add the explicit explicitBeanInfo data to our results.
1164
            for (int i = 0 ; i < explicitMethods.length; i++) {
1165
                addMethod(explicitMethods[i]);
1166
            }
1168
        } else {
1170
            // Apply some reflection to the current class.
1172
            // First get an array of all the beans methods at this level
1173
            Method methodList[] = getPublicDeclaredMethods();
1175
            // Now analyze each method.
1176
            for (int i = 0; i < methodList.length; i++) {
1177
                Method method = methodList[i];
1178
                if (method == null) {
1179
                    continue;
1180
                }
1181
                MethodDescriptor md = new MethodDescriptor(method);
1182
                addMethod(md);
1183
            }
1184
        }
1186
        // Allocate and populate the result array.
1187
        MethodDescriptor result[] = new MethodDescriptor[.size()];
1188
        result = (MethodDescriptor[]).values().toArray(result);
1190
        return result;
1191
    }
1193
    private void addMethod(MethodDescriptor md) {
1194
        // We have to be careful here to distinguish method by both name
1195
        // and argument lists.
1196
        // This method gets called a *lot, so we try to be efficient.
1197
        String name = md.getName();
1199
        MethodDescriptor old = (MethodDescriptor).get(name);
1200
        if (old == null) {
1201
            // This is the common case.
1202
            .put(name, md);
1203
            return;
1204
        }
1206
        // We have a collision on method names.  This is rare.
1208
        // Check if old and md have the same type.
1209
        String[] p1 = md.getParamNames();
1210
        String[] p2 = old.getParamNames();
1212
        boolean match = false;
1213
        if (p1.length == p2.length) {
1214
            match = true;
1215
            for (int i = 0; i < p1.length; i++) {
1216
                if (p1[i] != p2[i]) {
1217
                    match = false;
1218
                    break;
1219
                }
1220
            }
1221
        }
1222
        if (match) {
1223
            MethodDescriptor composite = new MethodDescriptor(old, md);
1224
            .put(name, composite);
1225
            return;
1226
        }
1228
        // We have a collision on method names with different type signatures.
1229
        // This is very rare.
1231
        String longKey = makeQualifiedMethodName(name, p1);
1232
        old = (MethodDescriptor).get(longKey);
1233
        if (old == null) {
1234
            .put(longKey, md);
1235
            return;
1236
        }
1237
        MethodDescriptor composite = new MethodDescriptor(old, md);
1238
        .put(longKey, composite);
1239
    }

    
Creates a key for a method in a method cache. 
1244
    private static String makeQualifiedMethodName(String name, String[] params) {
1245
        StringBuffer sb = new StringBuffer(name);
1246
        sb.append('=');
1247
        for (int i = 0; i < params.length; i++) {
1248
            sb.append(':');
1249
            sb.append(params[i]);
1250
        }
1251
        return sb.toString();
1252
    }
1254
    private int getTargetDefaultEventIndex() {
1255
        return ;
1256
    }
1258
    private int getTargetDefaultPropertyIndex() {
1259
        return ;
1260
    }
1263
        // Use explicit info, if available,
1264
        if ( != null) {
1265
            BeanDescriptor bd = .getBeanDescriptor();
1266
            if (bd != null) {
1267
                return (bd);
1268
            }
1269
        }
1270
        // OK, fabricate a default BeanDescriptor.
1271
        return (new BeanDescriptor());
1272
    }
1274
    private boolean isEventHandler(Method m) {
1275
        // We assume that a method is an event handler if it has a single
1276
        // argument, whose type inherit from java.util.Event.
1277
        Class argTypes[] = FeatureDescriptor.getParameterTypes(, m);
1278
        if (argTypes.length != 1) {
1279
            return false;
1280
        }
1281
        if (isSubclass(argTypes[0], java.util.EventObject.class)) {
1282
            return true;
1283
        }
1284
        return false;
1285
    }
1287
    /*
1288
     * Internal method to return *public* methods within a class.
1289
     */
1290
    private static synchronized Method[] getPublicDeclaredMethods(Class clz) {
1291
        // Looking up Class.getDeclaredMethods is relatively expensive,
1292
        // so we cache the results.
1293
        Method[] result = null;
1294
        if (!ReflectUtil.isPackageAccessible(clz)) {
1295
            return new Method[0];
1296
        }
1297
        final Class fclz = clz;
1298
        Reference ref = (Reference).get(fclz);
1299
        if (ref != null) {
1300
            result = (Method[])ref.get();
1301
            if (result != null) {
1302
                return result;
1303
            }
1304
        }
1306
        // We have to raise privilege for getDeclaredMethods
1307
        result = (Method[]) AccessController.doPrivileged(new PrivilegedAction() {
1308
                public Object run() {
1309
                    return fclz.getDeclaredMethods();
1310
                }
1311
            });
1314
        // Null out any non-public methods.
1315
        for (int i = 0; i < result.length; i++) {
1316
            Method method = result[i];
1317
            int mods = method.getModifiers();
1318
            if (!Modifier.isPublic(mods)) {
1319
                result[i] = null;
1320
            }
1321
        }
1322
        // Add it to the cache.
1323
        .put(fclz, new SoftReference(result));
1324
        return result;
1325
    }
1327
    //======================================================================
1328
    // Package private support methods.
1329
    //======================================================================
1330

    
Internal support for finding a target methodName with a given parameter list on a given class. 
1335
    private static Method internalFindMethod(Class start, String methodName,
1336
                                                 int argCount, Class args[]) {
1337
        // For overriden methods we need to find the most derived version.
1338
        // So we start with the given class and walk up the superclass chain.
1340
        Method method = null;
1342
        for (Class cl = start; cl != null; cl = cl.getSuperclass()) {
1343
            Method methods[] = getPublicDeclaredMethods(cl);
1344
            for (int i = 0; i < methods.length; i++) {
1345
                method = methods[i];
1346
                if (method == null) {
1347
                    continue;
1348
                }
1350
                // make sure method signature matches.
1351
                Class params[] = FeatureDescriptor.getParameterTypes(start, method);
1352
                if (method.getName().equals(methodName) &&
1353
                    params.length == argCount) {
1354
                    if (args != null) {
1355
                        boolean different = false;
1356
                        if (argCount > 0) {
1357
                            for (int j = 0; j < argCount; j++) {
1358
                                if (params[j] != args[j]) {
1359
                                    different = true;
1360
                                    continue;
1361
                                }
1362
                            }
1363
                            if (different) {
1364
                                continue;
1365
                            }
1366
                        }
1367
                    }
1368
                    return method;
1369
                }
1370
            }
1371
        }
1372
        method = null;
1374
        // Now check any inherited interfaces.  This is necessary both when
1375
        // the argument class is itself an interface, and when the argument
1376
        // class is an abstract class.
1377
        Class ifcs[] = start.getInterfaces();
1378
        for (int i = 0 ; i < ifcs.length; i++) {
1379
            // Note: The original implementation had both methods calling
1380
            // the 3 arg method. This is preserved but perhaps it should
1381
            // pass the args array instead of null.
1382
            method = internalFindMethod(ifcs[i], methodName, argCount, null);
1383
            if (method != null) {
1384
                break;
1385
            }
1386
        }
1387
        return method;
1388
    }

    
Find a target methodName on a given class. 
1393
    static Method findMethod(Class cls, String methodName, int argCount) {
1394
        return findMethod(cls, methodName, argCount, null);
1395
    }

    
Find a target methodName with specific parameter list on a given class.

Used in the contructors of the EventSetDescriptor, PropertyDescriptor and the IndexedPropertyDescriptor.

Parameters:
cls The Class object on which to retrieve the method.
methodName Name of the method.
argCount Number of arguments for the desired method.
args Array of argument types for the method.
Returns:
the method or null if not found
1409
    static Method findMethod(Class cls, String methodName, int argCount,
1410
                             Class args[]) {
1411
        if (methodName == null) {
1412
            return null;
1413
        }
1414
        return internalFindMethod(cls, methodName, argCount, args);
1415
    }

    
Return true if class a is either equivalent to class b, or if class a is a subclass of class b, i.e. if a either "extends" or "implements" b. Note tht either or both "Class" objects may represent interfaces. 
1423
    static  boolean isSubclass(Class a, Class b) {
1424
        // We rely on the fact that for any given java class or
1425
        // primtitive type there is a unqiue Class object, so
1426
        // we can use object equivalence in the comparisons.
1427
        if (a == b) {
1428
            return true;
1429
        }
1430
        if (a == null || b == null) {
1431
            return false;
1432
        }
1433
        for (Class x = a; x != null; x = x.getSuperclass()) {
1434
            if (x == b) {
1435
                return true;
1436
            }
1437
            if (b.isInterface()) {
1438
                Class interfaces[] = x.getInterfaces();
1439
                for (int i = 0; i < interfaces.length; i++) {
1440
                    if (isSubclass(interfaces[i], b)) {
1441
                        return true;
1442
                    }
1443
                }
1444
            }
1445
        }
1446
        return false;
1447
    }

    
Return true iff the given method throws the given exception. 
1452
    private boolean throwsException(Method method, Class exception) {
1453
        Class exs[] = method.getExceptionTypes();
1454
        for (int i = 0; i < exs.length; i++) {
1455
            if (exs[i] == exception) {
1456
                return true;
1457
            }
1458
        }
1459
        return false;
1460
    }


    
Try to create an instance of a named class. First try the classloader of "sibling", then try the system classloader then the class loader of the current Thread. 
1468
    static Object instantiate(Class sibling, String className)
1469
                 throws InstantiationException, IllegalAccessException,
1470
                                                ClassNotFoundException {
1471
        // First check with sibling's classloader (if any).
1472
        ClassLoader cl = sibling.getClassLoader();
1473
        Class cls = ClassFinder.findClass(className, cl);
1474
        return cls.newInstance();
1475
    }
1477
} // end class Introspector
1479
//===========================================================================
Package private implementation support class for Introspector's internal use.

Mostly this is used as a placeholder for the descriptors. 

1491
    private EventSetDescriptor[] events;
1492
    private int defaultEvent;
1493
    private PropertyDescriptor[] properties;
1494
    private int defaultProperty;
1495
    private MethodDescriptor[] methods;
1496
    private BeanInfo targetBeanInfo;
1498
    public GenericBeanInfo(BeanDescriptor beanDescriptor,
1499
                EventSetDescriptor[] events, int defaultEvent,
1500
                PropertyDescriptor[] properties, int defaultProperty,
1501
                MethodDescriptor[] methods, BeanInfo targetBeanInfo) {
1502
        this. = beanDescriptor;
1503
        this. = events;
1504
        this. = defaultEvent;
1505
        this. = properties;
1506
        this. = defaultProperty;
1507
        this. = methods;
1508
        this. = targetBeanInfo;
1509
    }

    
Package-private dup constructor This must isolate the new object from any changes to the old object. 
1517
         = new BeanDescriptor(old.beanDescriptor);
1518
        if (old.events != null) {
1519
            int len = old.events.length;
1520
             = new EventSetDescriptor[len];
1521
            for (int i = 0; i < len; i++) {
1522
                [i] = new EventSetDescriptor(old.events[i]);
1523
            }
1524
        }
1525
         = old.defaultEvent;
1526
        if (old.properties != null) {
1527
            int len = old.properties.length;
1528
             = new PropertyDescriptor[len];
1529
            for (int i = 0; i < len; i++) {
1530
                PropertyDescriptor oldp = old.properties[i];
1531
                if (oldp instanceof IndexedPropertyDescriptor) {
1532
                    [i] = new IndexedPropertyDescriptor(
1533
                                        (IndexedPropertyDescriptor) oldp);
1534
                } else {
1535
                    [i] = new PropertyDescriptor(oldp);
1536
                }
1537
            }
1538
        }
1539
         = old.defaultProperty;
1540
        if (old.methods != null) {
1541
            int len = old.methods.length;
1542
             = new MethodDescriptor[len];
1543
            for (int i = 0; i < len; i++) {
1544
                [i] = new MethodDescriptor(old.methods[i]);
1545
            }
1546
        }
1547
         = old.targetBeanInfo;
1548
    }
1551
        return ;
1552
    }
1554
    public int getDefaultPropertyIndex() {
1555
        return ;
1556
    }
1559
        return ;
1560
    }
1562
    public int getDefaultEventIndex() {
1563
        return ;
1564
    }
1567
        return ;
1568
    }
1571
        return ;
1572
    }
1574
    public java.awt.Image getIcon(int iconKind) {
1575
        if ( != null) {
1576
            return .getIcon(iconKind);
1577
        }
1578
        return super.getIcon(iconKind);
1579
    }
New to GrepCode? Check out our FAQ X