PC Online 1998 January/PCO0198.ISO/browser/net_linx/jae40.jar/java/beans/Introspector.class

Java Class File | 1997-11-03 | 9.5 KB | 555 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 cache = new Hashtable();
   private static Class eventListenerType = getClassForName("java.util.EventListener.class");
   private String defaultEventName;
   private String defaultPropertyName;
   private int defaultEventIndex = -1;
   private int defaultPropertyIndex = -1;
   private Hashtable methods = new Hashtable();
   private Hashtable properties = new Hashtable();
   private Hashtable events = new Hashtable();
   private static String[] searchPath = new String[]{"sun.beans.infos"};

   public static BeanInfo getBeanInfo(Class var0) throws IntrospectionException {
      BeanInfo var1 = (BeanInfo)cache.get(var0);
      if (var1 == null) {
         var1 = (new Introspector(var0, (Class)null)).getBeanInfo();
         cache.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 {
         ClassLoader var8 = var1.getClassLoader();
         Object var9 = null;
         Class var10;
         if (var8 == null) {
            var10 = Class.forName(var2);
         } else {
            var10 = var8.loadClass(var2);
         }

         return (BeanInfo)var10.newInstance();
      } catch (Exception var7) {
         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;
               Class var5 = Class.forName(var4);
               return (BeanInfo)var5.newInstance();
            }
         }

         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[] var10 = this.superBeanInfo.getPropertyDescriptors();

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

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

      for(int var11 = 0; var11 < this.additionalBeanInfo.length; ++var11) {
         PropertyDescriptor[] var12 = this.additionalBeanInfo[var11].getPropertyDescriptors();
         if (var12 != null) {
            for(int var16 = 0; var16 < var12.length; ++var16) {
               this.addProperty(var12[var16]);
            }
         }
      }

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

         for(int var17 = 0; var17 < var14.length; ++var17) {
            Method var5 = var14[var17];
            if (Modifier.isPublic(var5.getModifiers())) {
               String var6 = var5.getName();
               Class[] var7 = var5.getParameterTypes();
               Class var8 = var5.getReturnType();
               Object var9 = null;
               if (var6.startsWith("get") && var7.length == 0) {
                  var9 = new PropertyDescriptor(decapitalize(var6.substring(3)), var5, (Method)null);
               } else if (var6.startsWith("get") && var7.length == 1 && var7[0] == Integer.TYPE) {
                  var9 = new IndexedPropertyDescriptor(decapitalize(var6.substring(3)), (Method)null, (Method)null, var5, (Method)null);
               } else if (var6.startsWith("set") && var7.length == 1 && var8 == Void.TYPE) {
                  var9 = new PropertyDescriptor(decapitalize(var6.substring(3)), (Method)null, var5);
                  if (this.throwsException(var5, getClassForName("PropertyVetoException.class"))) {
                     ((PropertyDescriptor)var9).setConstrained(true);
                  }
               } else if (var6.startsWith("set") && var7.length == 2 && var7[0] == Integer.TYPE) {
                  var9 = new IndexedPropertyDescriptor(decapitalize(var6.substring(3)), (Method)null, (Method)null, (Method)null, var5);
                  if (this.throwsException(var5, getClassForName("PropertyVetoException.class"))) {
                     ((PropertyDescriptor)var9).setConstrained(true);
                  }
               } else if (var6.startsWith("is") && var7.length == 0 && var8 == Boolean.TYPE) {
                  var9 = new PropertyDescriptor(decapitalize(var6.substring(2)), var5, (Method)null);
               }

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

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

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

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

      return var15;
   }

   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 = this.beanClass.getDeclaredMethods();
         Hashtable var28 = new Hashtable();
         Hashtable var5 = new Hashtable();

         for(int var6 = 0; var6 < var25.length; ++var6) {
            Method var7 = var25[var6];
            if (Modifier.isPublic(var7.getModifiers())) {
               String var8 = var7.getName();
               Class[] var9 = var7.getParameterTypes();
               Class var10 = var7.getReturnType();
               if (var8.startsWith("add") && var9.length == 1 && var10 == Void.TYPE) {
                  String var35 = var8.substring(3) + ":" + var9[0];
                  var28.put(var35, var7);
               } else if (var8.startsWith("remove") && var9.length == 1 && var10 == Void.TYPE) {
                  String var11 = var8.substring(6) + ":" + var9[0];
                  var5.put(var11, 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 var36 = (Method)var28.get(var32);
               Method var12 = (Method)var5.get(var32);
               Class var13 = var36.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, var36, var12);
                  if (this.throwsException(var36, getClassForName("java.util.TooManyListenersException.class"))) {
                     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 = this.beanClass.getDeclaredMethods();

         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) {
      Method var2 = var1.getMethod();
      StringBuffer var3 = new StringBuffer();
      var3.append(var2.getName());
      Class[] var4 = var2.getParameterTypes();

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

      String var6 = var3.toString();
      MethodDescriptor var7 = (MethodDescriptor)this.methods.get(var6);
      if (var7 == null) {
         this.methods.put(var6, var1);
      } else {
         MethodDescriptor var8 = new MethodDescriptor(var7, var1);
         this.methods.put(var6, var8);
      }
   }

   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);
      }
   }

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

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

         return findDirectMethod(var0, var1, var2);
      }
   }

   static Method findDirectMethod(Class var0, String var1, int var2) throws IntrospectionException {
      Method[] var3 = var0.getDeclaredMethods();

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

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

   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 (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;
   }

   public static Class getClassForName(String var0) {
      try {
         return Class.forName(var0);
      } catch (ClassNotFoundException var1) {
         return null;
      }
   }
}