PC Pro 1999 April/DPPCPRO0499.ISO/April/Notes/50b2wic.exe/DATA1.CAB/NotesProgramFilesJavaSupport/rt.jar/java/beans/Introspector.class

Java Class File | 1998-04-23 | 12.4 KB | 620 lines

package java.beans;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Enumeration;
import java.util.Hashtable;

public class Introspector {
   private BeanInfo informant;
   private boolean propertyChangeSource = false;
   private Class beanClass;
   private BeanInfo superBeanInfo;
   private BeanInfo[] additionalBeanInfo;
   private static Hashtable beanInfoCache = new Hashtable();
   private static Class eventListenerType;
   private String defaultEventName;
   private String defaultPropertyName;
   private int defaultEventIndex = -1;
   private int defaultPropertyIndex = -1;
   private Hashtable methods = new Hashtable();
   private static Hashtable declaredMethodCache;
   private Hashtable properties = new Hashtable();
   private Hashtable events = new Hashtable();
   private static String[] searchPath;
   // $FF: synthetic field
   static Class class$java$util$EventListener;
   // $FF: synthetic field
   static Class class$java$beans$PropertyVetoException;
   // $FF: synthetic field
   static Class class$java$util$TooManyListenersException;

   public static BeanInfo getBeanInfo(Class var0) throws IntrospectionException {
      BeanInfo var1 = (BeanInfo)beanInfoCache.get(var0);
      if (var1 == null) {
         var1 = (new Introspector(var0, (Class)null)).getBeanInfo();
         beanInfoCache.put(var0, var1);
      }

      return var1;
   }

   public static BeanInfo getBeanInfo(Class var0, Class var1) throws IntrospectionException {
      return (new Introspector(var0, var1)).getBeanInfo();
   }

   public static String decapitalize(String var0) {
      if (var0 != null && var0.length() != 0) {
         if (var0.length() > 1 && Character.isUpperCase(var0.charAt(1)) && Character.isUpperCase(var0.charAt(0))) {
            return var0;
         } else {
            char[] var1 = var0.toCharArray();
            var1[0] = Character.toLowerCase(var1[0]);
            return new String(var1);
         }
      } else {
         return var0;
      }
   }

   public static String[] getBeanInfoSearchPath() {
      return searchPath;
   }

   public static void setBeanInfoSearchPath(String[] var0) {
      searchPath = var0;
   }

   private Introspector(Class var1, Class var2) throws IntrospectionException {
      this.beanClass = var1;
      if (var2 != null) {
         boolean var3 = false;

         for(Class var4 = var1.getSuperclass(); var4 != null; var4 = var4.getSuperclass()) {
            if (var4 == var2) {
               var3 = true;
            }
         }

         if (!var3) {
            throw new IntrospectionException(var2.getName() + " not superclass of " + var1.getName());
         }
      }

      this.informant = this.findInformant(var1);
      if (var1.getSuperclass() != var2) {
         if (var2 == null) {
            this.superBeanInfo = getBeanInfo(var1.getSuperclass());
         } else {
            this.superBeanInfo = getBeanInfo(var1.getSuperclass(), var2);
         }
      }

      if (this.informant != null) {
         this.additionalBeanInfo = this.informant.getAdditionalBeanInfo();
      }

      if (this.additionalBeanInfo == null) {
         this.additionalBeanInfo = new BeanInfo[0];
      }

   }

   private BeanInfo getBeanInfo() throws IntrospectionException {
      BeanDescriptor var1 = this.getTargetBeanDescriptor();
      EventSetDescriptor[] var2 = this.getTargetEventInfo();
      int var3 = this.getTargetDefaultEventIndex();
      PropertyDescriptor[] var4 = this.getTargetPropertyInfo();
      int var5 = this.getTargetDefaultPropertyIndex();
      MethodDescriptor[] var6 = this.getTargetMethodInfo();
      return new GenericBeanInfo(var1, var2, var3, var4, var5, var6, this.informant);
   }

   private BeanInfo findInformant(Class var1) {
      String var2 = var1.getName() + "BeanInfo";

      try {
         return (BeanInfo)instantiate(var1, var2);
      } catch (Exception var6) {
         while(var2.indexOf(46) > 0) {
            var2 = var2.substring(var2.indexOf(46) + 1);
         }

         for(int var3 = 0; var3 < searchPath.length; ++var3) {
            try {
               String var4 = searchPath[var3] + "." + var2;
               return (BeanInfo)instantiate(var1, var4);
            }
         }

         return null;
      }
   }

   private PropertyDescriptor[] getTargetPropertyInfo() throws IntrospectionException {
      PropertyDescriptor[] var1 = null;
      if (this.informant != null) {
         var1 = this.informant.getPropertyDescriptors();
         int var2 = this.informant.getDefaultPropertyIndex();
         if (var2 >= 0 && var2 < var1.length) {
            this.defaultPropertyName = var1[var2].getName();
         }
      }

      if (var1 == null && this.superBeanInfo != null) {
         PropertyDescriptor[] var13 = this.superBeanInfo.getPropertyDescriptors();

         for(int var3 = 0; var3 < var13.length; ++var3) {
            this.addProperty(var13[var3]);
         }

         int var4 = this.superBeanInfo.getDefaultPropertyIndex();
         if (var4 >= 0 && var4 < var13.length) {
            this.defaultPropertyName = var13[var4].getName();
         }
      }

      for(int var14 = 0; var14 < this.additionalBeanInfo.length; ++var14) {
         PropertyDescriptor[] var15 = this.additionalBeanInfo[var14].getPropertyDescriptors();
         if (var15 != null) {
            for(int var19 = 0; var19 < var15.length; ++var19) {
               this.addProperty(var15[var19]);
            }
         }
      }

      if (var1 != null) {
         for(int var16 = 0; var16 < var1.length; ++var16) {
            this.addProperty(var1[var16]);
         }
      } else {
         Method[] var17 = getDeclaredMethods(this.beanClass);

         for(int var20 = 0; var20 < var17.length; ++var20) {
            Method var5 = var17[var20];
            int var6 = var5.getModifiers();
            if (!Modifier.isStatic(var6) && Modifier.isPublic(var6)) {
               String var7 = var5.getName();
               Class[] var8 = var5.getParameterTypes();
               Class var9 = var5.getReturnType();
               int var10 = var8.length;
               Object var11 = null;

               try {
                  if (var10 == 0) {
                     if (var7.startsWith("get")) {
                        var11 = new PropertyDescriptor(decapitalize(var7.substring(3)), var5, (Method)null);
                     } else if (var9 == Boolean.TYPE && var7.startsWith("is")) {
                        var11 = new PropertyDescriptor(decapitalize(var7.substring(2)), var5, (Method)null);
                     }
                  } else if (var10 == 1) {
                     if (var8[0] == Integer.TYPE && var7.startsWith("get")) {
                        var11 = new IndexedPropertyDescriptor(decapitalize(var7.substring(3)), (Method)null, (Method)null, var5, (Method)null);
                     } else if (var9 == Void.TYPE && var7.startsWith("set")) {
                        var11 = new PropertyDescriptor(decapitalize(var7.substring(3)), (Method)null, var5);
                        if (this.throwsException(var5, class$java$beans$PropertyVetoException != null ? class$java$beans$PropertyVetoException : (class$java$beans$PropertyVetoException = class$("java.beans.PropertyVetoException")))) {
                           ((PropertyDescriptor)var11).setConstrained(true);
                        }
                     }
                  } else if (var10 == 2 && var8[0] == Integer.TYPE && var7.startsWith("set")) {
                     var11 = new IndexedPropertyDescriptor(decapitalize(var7.substring(3)), (Method)null, (Method)null, (Method)null, var5);
                     if (this.throwsException(var5, class$java$beans$PropertyVetoException != null ? class$java$beans$PropertyVetoException : (class$java$beans$PropertyVetoException = class$("java.beans.PropertyVetoException")))) {
                        ((PropertyDescriptor)var11).setConstrained(true);
                     }
                  }
               } catch (IntrospectionException var12) {
                  var11 = null;
               }

               if (var11 != null) {
                  if (this.propertyChangeSource) {
                     ((PropertyDescriptor)var11).setBound(true);
                  }

                  this.addProperty((PropertyDescriptor)var11);
               }
            }
         }
      }

      PropertyDescriptor[] var18 = new PropertyDescriptor[this.properties.size()];
      Enumeration var21 = this.properties.elements();

      for(int var22 = 0; var22 < var18.length; ++var22) {
         var18[var22] = (PropertyDescriptor)var21.nextElement();
         if (this.defaultPropertyName != null && this.defaultPropertyName.equals(var18[var22].getName())) {
            this.defaultPropertyIndex = var22;
         }
      }

      return var18;
   }

   void addProperty(PropertyDescriptor var1) {
      String var2 = ((FeatureDescriptor)var1).getName();
      PropertyDescriptor var3 = (PropertyDescriptor)this.properties.get(var2);
      if (var3 == null) {
         this.properties.put(var2, var1);
      } else {
         Class var4 = var3.getPropertyType();
         Class var5 = var1.getPropertyType();
         if (var4 != null && var5 != null && var4 != var5) {
            this.properties.put(var2, var1);
         } else {
            Object var6;
            if (!(var3 instanceof IndexedPropertyDescriptor) && !(var1 instanceof IndexedPropertyDescriptor)) {
               var6 = new PropertyDescriptor(var3, var1);
            } else {
               var6 = new IndexedPropertyDescriptor(var3, var1);
            }

            this.properties.put(var2, var6);
         }
      }
   }

   private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {
      EventSetDescriptor[] var1 = null;
      if (this.informant != null) {
         var1 = this.informant.getEventSetDescriptors();
         int var2 = this.informant.getDefaultEventIndex();
         if (var2 >= 0 && var2 < var1.length) {
            this.defaultEventName = var1[var2].getName();
         }
      }

      if (var1 == null && this.superBeanInfo != null) {
         EventSetDescriptor[] var21 = this.superBeanInfo.getEventSetDescriptors();

         for(int var3 = 0; var3 < var21.length; ++var3) {
            this.addEvent(var21[var3]);
         }

         int var4 = this.superBeanInfo.getDefaultEventIndex();
         if (var4 >= 0 && var4 < var21.length) {
            this.defaultEventName = var21[var4].getName();
         }
      }

      for(int var22 = 0; var22 < this.additionalBeanInfo.length; ++var22) {
         EventSetDescriptor[] var23 = this.additionalBeanInfo[var22].getEventSetDescriptors();
         if (var23 != null) {
            for(int var27 = 0; var27 < var23.length; ++var27) {
               this.addEvent(var23[var27]);
            }
         }
      }

      if (var1 != null) {
         for(int var24 = 0; var24 < var1.length; ++var24) {
            this.addEvent(var1[var24]);
         }
      } else {
         Method[] var25 = getDeclaredMethods(this.beanClass);
         Hashtable var28 = new Hashtable();
         Hashtable var5 = new Hashtable();

         for(int var6 = 0; var6 < var25.length; ++var6) {
            Method var7 = var25[var6];
            int var8 = var7.getModifiers();
            if (!Modifier.isStatic(var8) && Modifier.isPublic(var8)) {
               String var9 = var7.getName();
               Class[] var10 = var7.getParameterTypes();
               Class var11 = var7.getReturnType();
               if (var9.startsWith("add") && var10.length == 1 && var11 == Void.TYPE) {
                  String var36 = var9.substring(3) + ":" + var10[0];
                  var28.put(var36, var7);
               } else if (var9.startsWith("remove") && var10.length == 1 && var11 == Void.TYPE) {
                  String var12 = var9.substring(6) + ":" + var10[0];
                  var5.put(var12, var7);
               }
            }
         }

         Enumeration var31 = var28.keys();
         this.beanClass.getName();

         while(var31.hasMoreElements()) {
            String var32 = (String)var31.nextElement();
            if (var5.get(var32) != null && var32.indexOf("Listener:") > 0) {
               String var33 = var32.substring(0, var32.indexOf(58));
               String var34 = decapitalize(var33.substring(0, var33.length() - 8));
               Method var35 = (Method)var28.get(var32);
               Method var37 = (Method)var5.get(var32);
               Class var13 = var35.getParameterTypes()[0];
               if (isSubclass(var13, eventListenerType)) {
                  Method[] var14 = var13.getMethods();
                  int var15 = 0;

                  for(int var16 = 0; var16 < var14.length; ++var16) {
                     if (this.isEventHandler(var14[var16])) {
                        ++var15;
                     } else {
                        var14[var16] = null;
                     }
                  }

                  Method[] var17 = new Method[var15];
                  int var18 = 0;

                  for(int var19 = 0; var19 < var14.length; ++var19) {
                     if (var14[var19] != null) {
                        var17[var18++] = var14[var19];
                     }
                  }

                  EventSetDescriptor var20 = new EventSetDescriptor(var34, var13, var17, var35, var37);
                  if (this.throwsException(var35, class$java$util$TooManyListenersException != null ? class$java$util$TooManyListenersException : (class$java$util$TooManyListenersException = class$("java.util.TooManyListenersException")))) {
                     var20.setUnicast(true);
                  }

                  this.addEvent(var20);
               }
            }
         }
      }

      EventSetDescriptor[] var26 = new EventSetDescriptor[this.events.size()];
      Enumeration var29 = this.events.elements();

      for(int var30 = 0; var30 < var26.length; ++var30) {
         var26[var30] = (EventSetDescriptor)var29.nextElement();
         if (this.defaultEventName != null && this.defaultEventName.equals(var26[var30].getName())) {
            this.defaultEventIndex = var30;
         }
      }

      return var26;
   }

   void addEvent(EventSetDescriptor var1) {
      String var2 = ((FeatureDescriptor)var1).getName();
      if (var2.equals("propertyChange")) {
         this.propertyChangeSource = true;
      }

      EventSetDescriptor var3 = (EventSetDescriptor)this.events.get(var2);
      if (var3 == null) {
         this.events.put(var2, var1);
      } else {
         EventSetDescriptor var4 = new EventSetDescriptor(var3, var1);
         this.events.put(var2, var4);
      }
   }

   private MethodDescriptor[] getTargetMethodInfo() throws IntrospectionException {
      MethodDescriptor[] var1 = null;
      if (this.informant != null) {
         var1 = this.informant.getMethodDescriptors();
      }

      if (var1 == null && this.superBeanInfo != null) {
         MethodDescriptor[] var2 = this.superBeanInfo.getMethodDescriptors();

         for(int var3 = 0; var3 < var2.length; ++var3) {
            this.addMethod(var2[var3]);
         }
      }

      for(int var7 = 0; var7 < this.additionalBeanInfo.length; ++var7) {
         MethodDescriptor[] var8 = this.additionalBeanInfo[var7].getMethodDescriptors();
         if (var8 != null) {
            for(int var4 = 0; var4 < var8.length; ++var4) {
               this.addMethod(var8[var4]);
            }
         }
      }

      if (var1 != null) {
         for(int var9 = 0; var9 < var1.length; ++var9) {
            this.addMethod(var1[var9]);
         }
      } else {
         Method[] var10 = getDeclaredMethods(this.beanClass);

         for(int var12 = 0; var12 < var10.length; ++var12) {
            Method var5 = var10[var12];
            if (Modifier.isPublic(var5.getModifiers())) {
               MethodDescriptor var6 = new MethodDescriptor(var5);
               this.addMethod(var6);
            }
         }
      }

      MethodDescriptor[] var11 = new MethodDescriptor[this.methods.size()];
      Enumeration var13 = this.methods.elements();

      for(int var14 = 0; var14 < var11.length; ++var14) {
         var11[var14] = (MethodDescriptor)var13.nextElement();
      }

      return var11;
   }

   private void addMethod(MethodDescriptor var1) {
      String var2 = var1.getMethod().getName();
      MethodDescriptor var3 = (MethodDescriptor)this.methods.get(var2);
      if (var3 == null) {
         this.methods.put(var2, var1);
      } else {
         Class[] var4 = var1.getMethod().getParameterTypes();
         Class[] var5 = var3.getMethod().getParameterTypes();
         boolean var6 = false;
         if (var4.length == var5.length) {
            var6 = true;

            for(int var7 = 0; var7 < var4.length; ++var7) {
               if (var4[var7] != var5[var7]) {
                  var6 = false;
                  break;
               }
            }
         }

         if (var6) {
            MethodDescriptor var11 = new MethodDescriptor(var3, var1);
            this.methods.put(var2, var11);
         } else {
            String var10 = this.makeQualifiedMethodName(var1);
            var3 = (MethodDescriptor)this.methods.get(var10);
            if (var3 == null) {
               this.methods.put(var10, var1);
            } else {
               MethodDescriptor var8 = new MethodDescriptor(var3, var1);
               this.methods.put(var10, var8);
            }
         }
      }
   }

   private String makeQualifiedMethodName(MethodDescriptor var1) {
      Method var2 = var1.getMethod();
      StringBuffer var3 = new StringBuffer();
      var3.append(var2.getName());
      var3.append("=");
      Class[] var4 = var2.getParameterTypes();

      for(int var5 = 0; var5 < var4.length; ++var5) {
         var3.append(":");
         var3.append(var4[var5].getName());
      }

      return var3.toString();
   }

   private int getTargetDefaultEventIndex() {
      return this.defaultEventIndex;
   }

   private int getTargetDefaultPropertyIndex() {
      return this.defaultPropertyIndex;
   }

   private BeanDescriptor getTargetBeanDescriptor() throws IntrospectionException {
      if (this.informant != null) {
         BeanDescriptor var1 = this.informant.getBeanDescriptor();
         if (var1 != null) {
            return var1;
         }
      }

      return new BeanDescriptor(this.beanClass);
   }

   private boolean isEventHandler(Method var1) throws IntrospectionException {
      try {
         Class[] var2 = var1.getParameterTypes();
         if (var2.length != 1) {
            return false;
         } else {
            String var3 = String.valueOf(var2[0]);
            return var3.indexOf("Event") >= 0;
         }
      } catch (Exception var4) {
         throw new IntrospectionException("Unexpected reflection exception: " + var4);
      }
   }

   private static synchronized Method[] getDeclaredMethods(Class var0) {
      if (declaredMethodCache == null) {
         declaredMethodCache = new Hashtable();
      }

      Method[] var1 = (Method[])declaredMethodCache.get(var0);
      if (var1 == null) {
         var1 = var0.getDeclaredMethods();
         declaredMethodCache.put(var0, var1);
      }

      return var1;
   }

   static Method findMethod(Class var0, String var1, int var2) throws IntrospectionException {
      if (var1 == null) {
         return null;
      } else {
         while(var0 != null) {
            Method[] var3 = getDeclaredMethods(var0);

            for(int var4 = 0; var4 < var3.length; ++var4) {
               Method var5 = var3[var4];
               int var6 = var5.getModifiers();
               if (!Modifier.isStatic(var6) && Modifier.isPublic(var6) && var5.getName().equals(var1) && var5.getParameterTypes().length == var2) {
                  return var5;
               }
            }

            var0 = var0.getSuperclass();
         }

         throw new IntrospectionException("No method \"" + var1 + "\" with " + var2 + " arg(s)");
      }
   }

   static boolean isSubclass(Class var0, Class var1) {
      if (var0 == var1) {
         return true;
      } else if (var0 != null && var1 != null) {
         for(Class var2 = var0; var2 != null; var2 = var2.getSuperclass()) {
            if (var2 == var1) {
               return true;
            }

            if (var1.isInterface()) {
               Class[] var3 = var2.getInterfaces();

               for(int var4 = 0; var4 < var3.length; ++var4) {
                  if (isSubclass(var3[var4], var1)) {
                     return true;
                  }
               }
            }
         }

         return false;
      } else {
         return false;
      }
   }

   private boolean throwsException(Method var1, Class var2) {
      Class[] var3 = var1.getExceptionTypes();

      for(int var4 = 0; var4 < var3.length; ++var4) {
         if (var3[var4] == var2) {
            return true;
         }
      }

      return false;
   }

   static Object instantiate(Class var0, String var1) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
      ClassLoader var2 = var0.getClassLoader();
      if (var2 != null) {
         try {
            Class var5 = var2.loadClass(var1);
            return var5.newInstance();
         } catch (Exception var4) {
         }
      }

      Class var3 = Class.forName(var1);
      return var3.newInstance();
   }

   // $FF: synthetic method
   static Class class$(String var0) {
      try {
         return Class.forName(var0);
      } catch (ClassNotFoundException var2) {
         throw new NoClassDefFoundError(((Throwable)var2).getMessage());
      }
   }

   static {
      eventListenerType = class$java$util$EventListener != null ? class$java$util$EventListener : (class$java$util$EventListener = class$("java.util.EventListener"));
      searchPath = new String[]{"sun.beans.infos"};
   }
}