introspector.java

this gcc-g++-3.3.1.tar.gz is a source file of gcc, you can learn more about gcc through this codes f

	  {
	    if(!currentInfo.hasEvent(e[i])) 
	      {
		currentInfo.addEvent(e[i]);
	      }
	  }
	if(explicit.defaultEvent != -1) 
	  {
	    currentInfo.setDefaultEventName(e[explicit.defaultEvent].getName());
	  }
      }
    MethodDescriptor[] m = explicit.explicitMethodDescriptors;
    if(m!=null) 
      {
	for(int i=0;i<m.length;i++) 
	  {
	    if(!currentInfo.hasMethod(m[i])) 
	      {
		currentInfo.addMethod(m[i]);
	      }
	  }
      }
    
    if(explicit.explicitBeanDescriptor != null) 
      {
	currentInfo.setBeanDescriptor(new BeanDescriptor(beanClass,explicit.explicitBeanDescriptor.getCustomizerClass()));
      } 
    else 
      {
	currentInfo.setBeanDescriptor(new BeanDescriptor(beanClass,null));
      }
    
    currentInfo.setAdditionalBeanInfo(explicit.explicitBeanInfo);
    currentInfo.setIcons(explicit.im);
    
    return currentInfo.getBeanInfo();
  }
  
  /** 
   * Get the search path for BeanInfo classes.
   *
   * @return the BeanInfo search path.
   */
  public static String[] getBeanInfoSearchPath() 
  {
    return beanInfoSearchPath;
  }
  
  /** 
   * Set the search path for BeanInfo classes.
   * @param beanInfoSearchPath the new BeanInfo search
   *        path.
   */
  public static void setBeanInfoSearchPath(String[] beanInfoSearchPath) 
  {
    Introspector.beanInfoSearchPath = beanInfoSearchPath;
  }
  
  /** 
   * A helper method to convert a name to standard Java
   * naming conventions: anything with two capitals as the
   * first two letters remains the same, otherwise the
   * first letter is decapitalized.  URL = URL, I = i,
   * MyMethod = myMethod.
   *
   * @param name the name to decapitalize.
   * @return the decapitalized name.
   */
  public static String decapitalize(String name) 
  {
    try 
      {
      if(!Character.isUpperCase(name.charAt(0))) 
	{
	  return name;
	} 
      else 
	{
	try 
	  {
	  if(Character.isUpperCase(name.charAt(1))) 
	    {
	      return name;
	    } 
	  else 
	    {
	      char[] c = name.toCharArray();
	      c[0] = Character.toLowerCase(c[0]);
	      return new String(c);
	    }
	  } 
	catch(StringIndexOutOfBoundsException E) 
	  {
	    char[] c = new char[1];
	    c[0] = Character.toLowerCase(name.charAt(0));
	    return new String(c);
	  }
	}
      } 
    catch(StringIndexOutOfBoundsException E) 
      {
	return name;
      } 
    catch(NullPointerException E) 
      {
	return null;
      }
  }
  
  static BeanInfo copyBeanInfo(BeanInfo b) 
  {
    java.awt.Image[] icons = new java.awt.Image[4];
    for(int i=1;i<=4;i++) 
      {
	icons[i-1] = b.getIcon(i);
      }
    return new ExplicitBeanInfo(b.getBeanDescriptor(),
				b.getAdditionalBeanInfo(),
				b.getPropertyDescriptors(),
				b.getDefaultPropertyIndex(),
				b.getEventSetDescriptors(),
				b.getDefaultEventIndex(),
				b.getMethodDescriptors(),icons);
  }
}

class ExplicitInfo 
{
  BeanDescriptor explicitBeanDescriptor;
  BeanInfo[] explicitBeanInfo;
  
  PropertyDescriptor[] explicitPropertyDescriptors;
  EventSetDescriptor[] explicitEventSetDescriptors;
  MethodDescriptor[] explicitMethodDescriptors;
  
  int defaultProperty;
  int defaultEvent;
  
  java.awt.Image[] im = new java.awt.Image[4];
  
  Class propertyStopClass;
  Class eventStopClass;
  Class methodStopClass;
  
  ExplicitInfo(Class beanClass, Class stopClass) 
  {
    while(beanClass != null && !beanClass.equals(stopClass)) 
      {
	BeanInfo explicit = findExplicitBeanInfo(beanClass);
	if(explicit != null) 
	  {
	    if(explicitBeanDescriptor == null) 
	      {
		explicitBeanDescriptor = explicit.getBeanDescriptor();
	      }
	    if(explicitBeanInfo == null) 
	      {
		explicitBeanInfo = explicit.getAdditionalBeanInfo();
	      }
	    if(explicitPropertyDescriptors == null) 
	      {
		if(explicit.getPropertyDescriptors() != null) 
		  {
		    explicitPropertyDescriptors = explicit.getPropertyDescriptors();
		    defaultProperty = explicit.getDefaultPropertyIndex();
		    propertyStopClass = beanClass;
		  }
	      }
	    if(explicitEventSetDescriptors == null) 
	      {
		if(explicit.getEventSetDescriptors() != null) 
		  {
		    explicitEventSetDescriptors = explicit.getEventSetDescriptors();
		    defaultEvent = explicit.getDefaultEventIndex();
		    eventStopClass = beanClass;
		  }
	      }
	    if(explicitMethodDescriptors == null) 
	      {
		if(explicit.getMethodDescriptors() != null) 
		  {
		    explicitMethodDescriptors = explicit.getMethodDescriptors();
		    methodStopClass = beanClass;
		  }
	      }
	    if(im[0] == null && im[1] == null 
	       && im[2] == null && im[3] == null) 
	      {
		im[0] = explicit.getIcon(0);
		im[1] = explicit.getIcon(1);
		im[2] = explicit.getIcon(2);
		im[3] = explicit.getIcon(3);
	      }
	  }
	beanClass = beanClass.getSuperclass();
      }
    if(propertyStopClass == null) 
      {
	propertyStopClass = stopClass;
      }
    if(eventStopClass == null) 
      {
	eventStopClass = stopClass;
      }
    if(methodStopClass == null) 
      {
	methodStopClass = stopClass;
      }
  }
  
  static Hashtable explicitBeanInfos = new Hashtable();
  static Vector emptyBeanInfos = new Vector();
  
  static BeanInfo findExplicitBeanInfo(Class beanClass) 
  {
    BeanInfo retval = (BeanInfo)explicitBeanInfos.get(beanClass);
    if(retval != null) 
      {
	return retval;
      } 
    else if(emptyBeanInfos.indexOf(beanClass) != -1) 
      {
	return null;
      } 
    else 
      {
	retval = reallyFindExplicitBeanInfo(beanClass);
	if(retval != null) 
	  {
	    explicitBeanInfos.put(beanClass,retval);
	  } 
	else 
	  {
	    emptyBeanInfos.addElement(beanClass);
	  }
	return retval;
      }
  }
  
  static BeanInfo reallyFindExplicitBeanInfo(Class beanClass) 
  {
    try 
      {
      try 
	{
	  return (BeanInfo)Class.forName(beanClass.getName()+"BeanInfo").newInstance();
	} 
      catch(ClassNotFoundException E) 
	{
	}
      String newName = ClassHelper.getTruncatedClassName(beanClass) + "BeanInfo";
      for(int i=0;i<Introspector.beanInfoSearchPath.length;i++) 
	{
	  try 
	    {
	      if(Introspector.beanInfoSearchPath[i].equals("")) 
		{
		  return (BeanInfo)Class.forName(newName).newInstance();
		} 
	      else 
		{
		  return (BeanInfo)Class.forName(Introspector.beanInfoSearchPath[i] + "." + newName).newInstance();
		}
	    } 
	  catch(ClassNotFoundException E) 
	    {
	    }
	}
      } 
    catch(IllegalAccessException E) 
      {
      } 
    catch(InstantiationException E) 
      {
      }
    return null;
  }
}