jdk-sandbox: comparison jdk/src/share/classes/java/beans/Introspector.java

equal deleted inserted replaced

-:457cc3968455
+:f93045767e5d
 public final static int IGNORE_ALL_BEANINFO        = 3;
 // Static Caches to speed up introspection.
 private static final WeakCache<Class<?>, Method[]> declaredMethodCache = new WeakCache<>();
-private Class beanClass;
+private Class<?> beanClass;
 private BeanInfo explicitBeanInfo;
 private BeanInfo superBeanInfo;
 private BeanInfo additionalBeanInfo[];
 private boolean propertyChangeSource = false;
-private static Class eventListenerType = EventListener.class;
+private static Class<EventListener> eventListenerType = EventListener.class;
 // These should be removed.
 private String defaultEventName;
 private String defaultPropertyName;
 private int defaultEventIndex = -1;
 private int defaultPropertyIndex = -1;
-// Methods maps from Method objects to MethodDescriptors
+// Methods maps from Method names to MethodDescriptors
-private Map methods;
+private Map<String, MethodDescriptor> methods;
 // properties maps from String names to PropertyDescriptors
-private Map properties;
+private Map<String, PropertyDescriptor> properties;
 // events maps from String names to EventSetDescriptors
-private Map events;
+private Map<String, EventSetDescriptor> events;
 private final static EventSetDescriptor[] EMPTY_EVENTSETDESCRIPTORS = new EventSetDescriptor[0];
 static final String ADD_PREFIX = "add";
 static final String REMOVE_PREFIX = "remove";
 //======================================================================
 //                  Private implementation methods
 //======================================================================
-private Introspector(Class beanClass, Class stopClass, int flags)
+private Introspector(Class<?> beanClass, Class<?> stopClass, int flags)
 throws IntrospectionException {
 this.beanClass = beanClass;
 // Check stopClass is a superClass of startClass.
 if (stopClass != null) {
 boolean isSuper = false;
-for (Class c = beanClass.getSuperclass(); c != null; c = c.getSuperclass()) {
+for (Class<?> c = beanClass.getSuperclass(); c != null; c = c.getSuperclass()) {
 if (c == stopClass) {
 isSuper = true;
 }
 }
 if (!isSuper) {
 if (flags == USE_ALL_BEANINFO) {
 explicitBeanInfo = findExplicitBeanInfo(beanClass);
 }
-Class superClass = beanClass.getSuperclass();
+Class<?> superClass = beanClass.getSuperclass();
 if (superClass != stopClass) {
 int newFlags = flags;
 if (newFlags == IGNORE_IMMEDIATE_BEANINFO) {
 newFlags = USE_ALL_BEANINFO;
 }
 * the BeanInfo search path is prepended to the class and searched.
 *
 * @param beanClass  the class type of the bean
 * @return Instance of an explicit BeanInfo class or null if one isn't found.
 */
-private static BeanInfo findExplicitBeanInfo(Class beanClass) {
+private static BeanInfo findExplicitBeanInfo(Class<?> beanClass) {
 return ThreadGroupContext.getContext().getBeanInfoFinder().find(beanClass);
 }
 /**
 * @return An array of PropertyDescriptors describing the editable
 int mods = method.getModifiers();
 if (Modifier.isStatic(mods)) {
 continue;
 }
 String name = method.getName();
-Class argTypes[] = method.getParameterTypes();
+Class<?>[] argTypes = method.getParameterTypes();
-Class resultType = method.getReturnType();
+Class<?> resultType = method.getReturnType();
 int argCount = argTypes.length;
 PropertyDescriptor pd = null;
 if (name.length() <= 3 && !name.startsWith(IS_PREFIX)) {
 // Optimization. Don't bother with invalid propertyNames.
 }
 }
 processPropertyDescriptors();
 // Allocate and populate the result array.
-PropertyDescriptor result[] = new PropertyDescriptor[properties.size()];
+PropertyDescriptor result[] =
-result = (PropertyDescriptor[])properties.values().toArray(result);
+properties.values().toArray(new PropertyDescriptor[properties.size()]);
 // Set the default index.
 if (defaultPropertyName != null) {
 for (int i = 0; i < result.length; i++) {
 if (defaultPropertyName.equals(result[i].getName())) {
 }
 return result;
 }
-private HashMap pdStore = new HashMap();
+private HashMap<String, List<PropertyDescriptor>> pdStore = new HashMap<>();
 /**
 * Adds the property descriptor to the list store.
 */
 private void addPropertyDescriptor(PropertyDescriptor pd) {
 String propName = pd.getName();
-List list = (List)pdStore.get(propName);
+List<PropertyDescriptor> list = pdStore.get(propName);
 if (list == null) {
-list = new ArrayList();
+list = new ArrayList<>();
 pdStore.put(propName, list);
 }
 if (this.beanClass != pd.getClass0()) {
 // replace existing property descriptor
 // only if we have types to resolve
 * Populates the property descriptor table by merging the
 * lists of Property descriptors.
 */
 private void processPropertyDescriptors() {
 if (properties == null) {
-properties = new TreeMap();
+properties = new TreeMap<>();
 }
-List list;
+List<PropertyDescriptor> list;
 PropertyDescriptor pd, gpd, spd;
 IndexedPropertyDescriptor ipd, igpd, ispd;
-Iterator it = pdStore.values().iterator();
+Iterator<List<PropertyDescriptor>> it = pdStore.values().iterator();
 while (it.hasNext()) {
 pd = null; gpd = null; spd = null;
 ipd = null; igpd = null; ispd = null;
-list = (List)it.next();
+list = it.next();
 // First pass. Find the latest getter method. Merge properties
 // of previous getter methods.
 for (int i = 0; i < list.size(); i++) {
-pd = (PropertyDescriptor)list.get(i);
+pd = list.get(i);
 if (pd instanceof IndexedPropertyDescriptor) {
 ipd = (IndexedPropertyDescriptor)pd;
 if (ipd.getIndexedReadMethod() != null) {
 if (igpd != null) {
 igpd = new IndexedPropertyDescriptor(igpd, ipd);
 }
 // Second pass. Find the latest setter method which
 // has the same type as the getter method.
 for (int i = 0; i < list.size(); i++) {
-pd = (PropertyDescriptor)list.get(i);
+pd = list.get(i);
 if (pd instanceof IndexedPropertyDescriptor) {
 ipd = (IndexedPropertyDescriptor)pd;
 if (ipd.getIndexedWriteMethod() != null) {
 if (igpd != null) {
 if (igpd.getIndexedPropertyType()
 // Find the first property descriptor
 // which does not have getter and setter methods.
 // See regression bug 4984912.
 if ( (pd == null) && (list.size() > 0) ) {
-pd = (PropertyDescriptor) list.get(0);
+pd = list.get(0);
 }
 if (pd != null) {
 properties.put(pd.getName(), pd);
 }
 */
 private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd,
 PropertyDescriptor pd) {
 PropertyDescriptor result = null;
-Class propType = pd.getPropertyType();
+Class<?> propType = pd.getPropertyType();
-Class ipropType = ipd.getIndexedPropertyType();
+Class<?> ipropType = ipd.getIndexedPropertyType();
 if (propType.isArray() && propType.getComponentType() == ipropType) {
 if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
 result = new IndexedPropertyDescriptor(pd, ipd);
 } else {
 }
 }
 if (write == null && read != null) {
 write = findMethod(result.getClass0(),
 SET_PREFIX + NameGenerator.capitalize(result.getName()), 1,
-new Class[] { FeatureDescriptor.getReturnType(result.getClass0(), read) });
+new Class<?>[] { FeatureDescriptor.getReturnType(result.getClass0(), read) });
 if (write != null) {
 try {
 result.setWriteMethod(write);
 } catch (IntrospectionException ex) {
 // no consequences for failure.
 * @return An array of EventSetDescriptors describing the kinds of
 * events fired by the target bean.
 */
 private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {
 if (events == null) {
-events = new HashMap();
+events = new HashMap<>();
 }
 // Check if the bean has its own BeanInfo that will provide
 // explicit information.
 EventSetDescriptor[] explicitEvents = null;
 Method methodList[] = getPublicDeclaredMethods(beanClass);
 // Find all suitable "add", "remove" and "get" Listener methods
 // The name of the listener type is the key for these hashtables
 // i.e, ActionListener
-Map adds = null;
+Map<String, Method> adds = null;
-Map removes = null;
+Map<String, Method> removes = null;
-Map gets = null;
+Map<String, Method> gets = null;
 for (int i = 0; i < methodList.length; i++) {
 Method method = methodList[i];
 if (method == null) {
 continue;
 if (!name.startsWith(ADD_PREFIX) && !name.startsWith(REMOVE_PREFIX)
 && !name.startsWith(GET_PREFIX)) {
 continue;
 }
-Class argTypes[] = FeatureDescriptor.getParameterTypes(beanClass, method);
+Class<?>[] argTypes = FeatureDescriptor.getParameterTypes(beanClass, method);
-Class resultType = FeatureDescriptor.getReturnType(beanClass, method);
+Class<?> resultType = FeatureDescriptor.getReturnType(beanClass, method);
 if (name.startsWith(ADD_PREFIX) && argTypes.length == 1 &&
 resultType == Void.TYPE &&
 Introspector.isSubclass(argTypes[0], eventListenerType)) {
 String listenerName = name.substring(3);
 if (listenerName.length() > 0 &&
 argTypes[0].getName().endsWith(listenerName)) {
 if (adds == null) {
-adds = new HashMap();
+adds = new HashMap<>();
 }
 adds.put(listenerName, method);
 }
 }
 else if (name.startsWith(REMOVE_PREFIX) && argTypes.length == 1 &&
 Introspector.isSubclass(argTypes[0], eventListenerType)) {
 String listenerName = name.substring(6);
 if (listenerName.length() > 0 &&
 argTypes[0].getName().endsWith(listenerName)) {
 if (removes == null) {
-removes = new HashMap();
+removes = new HashMap<>();
 }
 removes.put(listenerName, method);
 }
 }
 else if (name.startsWith(GET_PREFIX) && argTypes.length == 0 &&
 eventListenerType)) {
 String listenerName  = name.substring(3, name.length() - 1);
 if (listenerName.length() > 0 &&
 resultType.getComponentType().getName().endsWith(listenerName)) {
 if (gets == null) {
-gets = new HashMap();
+gets = new HashMap<>();
 }
 gets.put(listenerName, method);
 }
 }
 }
 if (adds != null && removes != null) {
 // Now look for matching addFooListener+removeFooListener pairs.
 // Bonus if there is a matching getFooListeners method as well.
-Iterator keys = adds.keySet().iterator();
+Iterator<String> keys = adds.keySet().iterator();
 while (keys.hasNext()) {
-String listenerName = (String) keys.next();
+String listenerName = keys.next();
 // Skip any "add" which doesn't have a matching "remove" or
 // a listener name that doesn't end with Listener
 if (removes.get(listenerName) == null || !listenerName.endsWith("Listener")) {
 continue;
 }
 String eventName = decapitalize(listenerName.substring(0, listenerName.length()-8));
-Method addMethod = (Method)adds.get(listenerName);
+Method addMethod = adds.get(listenerName);
-Method removeMethod = (Method)removes.get(listenerName);
+Method removeMethod = removes.get(listenerName);
 Method getMethod = null;
 if (gets != null) {
-getMethod = (Method)gets.get(listenerName);
+getMethod = gets.get(listenerName);
 }
-Class argType = FeatureDescriptor.getParameterTypes(beanClass, addMethod)[0];
+Class<?> argType = FeatureDescriptor.getParameterTypes(beanClass, addMethod)[0];
 // generate a list of Method objects for each of the target methods:
 Method allMethods[] = getPublicDeclaredMethods(argType);
-List validMethods = new ArrayList(allMethods.length);
+List<Method> validMethods = new ArrayList<>(allMethods.length);
 for (int i = 0; i < allMethods.length; i++) {
 if (allMethods[i] == null) {
 continue;
 }
 if (isEventHandler(allMethods[i])) {
 validMethods.add(allMethods[i]);
 }
 }
-Method[] methods = (Method[])validMethods.toArray(new Method[validMethods.size()]);
+Method[] methods = validMethods.toArray(new Method[validMethods.size()]);
 EventSetDescriptor esd = new EventSetDescriptor(eventName, argType,
 methods, addMethod,
 removeMethod,
 getMethod);
 if (events.size() == 0) {
 result = EMPTY_EVENTSETDESCRIPTORS;
 } else {
 // Allocate and populate the result array.
 result = new EventSetDescriptor[events.size()];
-result = (EventSetDescriptor[])events.values().toArray(result);
+result = events.values().toArray(result);
 // Set the default index.
 if (defaultEventName != null) {
 for (int i = 0; i < result.length; i++) {
 if (defaultEventName.equals(result[i].getName())) {
 private void addEvent(EventSetDescriptor esd) {
 String key = esd.getName();
 if (esd.getName().equals("propertyChange")) {
 propertyChangeSource = true;
 }
-EventSetDescriptor old = (EventSetDescriptor)events.get(key);
+EventSetDescriptor old = events.get(key);
 if (old == null) {
 events.put(key, esd);
 return;
 }
 EventSetDescriptor composite = new EventSetDescriptor(old, esd);
 * @return An array of MethodDescriptors describing the private
 * methods supported by the target bean.
 */
 private MethodDescriptor[] getTargetMethodInfo() {
 if (methods == null) {
-methods = new HashMap(100);
+methods = new HashMap<>(100);
 }
 // Check if the bean has its own BeanInfo that will provide
 // explicit information.
 MethodDescriptor[] explicitMethods = null;
 }
 }
 // Allocate and populate the result array.
 MethodDescriptor result[] = new MethodDescriptor[methods.size()];
-result = (MethodDescriptor[])methods.values().toArray(result);
+result = methods.values().toArray(result);
 return result;
 }
 private void addMethod(MethodDescriptor md) {
 // We have to be careful here to distinguish method by both name
 // and argument lists.
 // This method gets called a *lot, so we try to be efficient.
 String name = md.getName();
-MethodDescriptor old = (MethodDescriptor)methods.get(name);
+MethodDescriptor old = methods.get(name);
 if (old == null) {
 // This is the common case.
 methods.put(name, md);
 return;
 }
 // We have a collision on method names with different type signatures.
 // This is very rare.
 String longKey = makeQualifiedMethodName(name, p1);
-old = (MethodDescriptor)methods.get(longKey);
+old = methods.get(longKey);
 if (old == null) {
 methods.put(longKey, md);
 return;
 }
 MethodDescriptor composite = new MethodDescriptor(old, md);
 }
 /*
 * Internal method to return *public* methods within a class.
 */
-private static Method[] getPublicDeclaredMethods(Class clz) {
+private static Method[] getPublicDeclaredMethods(Class<?> clz) {
 // Looking up Class.getDeclaredMethods is relatively expensive,
 // so we cache the results.
 if (!ReflectUtil.isPackageAccessible(clz)) {
 return new Method[0];
 }
 /**
 * Internal support for finding a target methodName with a given
 * parameter list on a given class.
 */
-private static Method internalFindMethod(Class start, String methodName,
+private static Method internalFindMethod(Class<?> start, String methodName,
 int argCount, Class args[]) {
 // For overriden methods we need to find the most derived version.
 // So we start with the given class and walk up the superclass chain.
 Method method = null;
-for (Class cl = start; cl != null; cl = cl.getSuperclass()) {
+for (Class<?> cl = start; cl != null; cl = cl.getSuperclass()) {
 Method methods[] = getPublicDeclaredMethods(cl);
 for (int i = 0; i < methods.length; i++) {
 method = methods[i];
 if (method == null) {
 continue;
 }
 /**
 * Find a target methodName on a given class.
 */
-static Method findMethod(Class cls, String methodName, int argCount) {
+static Method findMethod(Class<?> cls, String methodName, int argCount) {
 return findMethod(cls, methodName, argCount, null);
 }
 /**
 * Find a target methodName with specific parameter list on a given class.
 * @param methodName Name of the method.
 * @param argCount Number of arguments for the desired method.
 * @param args Array of argument types for the method.
 * @return the method or null if not found
 */
-static Method findMethod(Class cls, String methodName, int argCount,
+static Method findMethod(Class<?> cls, String methodName, int argCount,
 Class args[]) {
 if (methodName == null) {
 return null;
 }
 return internalFindMethod(cls, methodName, argCount, args);
 * 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.
 */
-static  boolean isSubclass(Class a, Class b) {
+static  boolean isSubclass(Class<?> a, Class<?> b) {
 // We rely on the fact that for any given java class or
 // primtitive type there is a unqiue Class object, so
 // we can use object equivalence in the comparisons.
 if (a == b) {
 return true;
 }
 if (a == null || b == null) {
 return false;
 }
-for (Class x = a; x != null; x = x.getSuperclass()) {
+for (Class<?> x = a; x != null; x = x.getSuperclass()) {
 if (x == b) {
 return true;
 }
 if (b.isInterface()) {
-Class interfaces[] = x.getInterfaces();
+Class<?>[] interfaces = x.getInterfaces();
 for (int i = 0; i < interfaces.length; i++) {
 if (isSubclass(interfaces[i], b)) {
 return true;
 }
 }
 }
 /**
 * Return true iff the given method throws the given exception.
 */
-private boolean throwsException(Method method, Class exception) {
+private boolean throwsException(Method method, Class<?> exception) {
 Class exs[] = method.getExceptionTypes();
 for (int i = 0; i < exs.length; i++) {
 if (exs[i] == exception) {
 return true;
 }
 /**
 * 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.
 */
-static Object instantiate(Class sibling, String className)
+static Object instantiate(Class<?> sibling, String className)
 throws InstantiationException, IllegalAccessException,
 ClassNotFoundException {
 // First check with sibling's classloader (if any).
 ClassLoader cl = sibling.getClassLoader();
-Class cls = ClassFinder.findClass(className, cl);
+Class<?> cls = ClassFinder.findClass(className, cl);
 return cls.newInstance();
 }
 } // end class Introspector
 this.events = events;
 this.defaultEvent = defaultEvent;
 this.properties = properties;
 this.defaultProperty = defaultProperty;
 this.methods = methods;
-this.targetBeanInfoRef = new SoftReference<BeanInfo>(targetBeanInfo);
+this.targetBeanInfoRef = new SoftReference<>(targetBeanInfo);
 }
 /**
 * Package-private dup constructor
 * This must isolate the new object from any changes to the old object.

changeset 11140	f93045767e5d
parent 11086	09b1d6383d0b
parent 11120	f8576c769572
child 11668	138b661e3841