import java.beans.*;
import java.lang.reflect.*;

/**
 * ClassInfo uses introspection and reflection to get information about a class.
 *
 * @author Thornton Rose
 */
public class ClassInfo {
   public static void main(String[] args) {
      Class                 theClass;
      BeanInfo              beanInfo;
      PropertyDescriptor[]  properties;
      PropertyDescriptor    propInfo;
      Method                getter;
      Method                setter;
      EventSetDescriptor[]  events;
      EventSetDescriptor    eventInfo;
      Class                 listenerClass;
      MethodDescriptor[]    methods;
      MethodDescriptor      methodInfo;

      // If no args specified, print usage, then exit.
      
      if (args.length == 0) {
         System.out.println("Usage: ClassInfo classname");
         System.exit(0);
      }

      try {
         // Load class.

         theClass = Class.forName(args[0]);
         System.out.println("Class: " + theClass.getName());
         System.out.println("");

         // Get bean info. for class.

         beanInfo = Introspector.getBeanInfo(theClass);

         // Get property descriptors.

         System.out.println("Properties:");
         properties = beanInfo.getPropertyDescriptors();

         // If no property info. available, print it.
         
         if (properties != null) {
            // For each property descriptor ...

            for (int i = 0; i < properties.length; i ++) {
               if (i > 0) {
                  System.out.println("");
               }

               // Get property info., getter, and setter.
               
               propInfo = properties[i];
               getter = propInfo.getReadMethod();
               setter = propInfo.getWriteMethod();

               // Print property info.
               
               System.out.println(
                  "   " + propInfo.getPropertyType().getName() +
                  " " + propInfo.getDisplayName() + ": ");

               // Print getter and setter info.
               
               System.out.println("      Read: " + getMethodInfo(getter));
               System.out.println("      Write: " + getMethodInfo(setter));
            }
         } else {
            System.out.println("null");
         }

         // Get event descriptors.

         System.out.println("\nEvents:");
         events = beanInfo.getEventSetDescriptors();

         // If no event info. available, print it.

         if (events != null) {
            // For each event descriptor ...

            for (int i = 0; i < events.length; i ++) {
               // Get event info.

               eventInfo = events[i];
               listenerClass = eventInfo.getListenerType();
               methods = eventInfo.getListenerMethodDescriptors();

               // Print event type and listener class name.

               System.out.println("   " + eventInfo.getDisplayName() + ": ");
               System.out.println("      Listener: " + listenerClass.getName());

               // Print listener methods.

               System.out.println("      Methods: ");
               
               for (int j = 0; j < methods.length; j ++) {
                  System.out.println("         " + 
                     getMethodInfo(methods[j].getMethod()));
               }
            }
         } else {
            System.out.println("null");
         }

         // Get method descriptors.

         System.out.println("\nPublic Methods:");
         methods = beanInfo.getMethodDescriptors();

         // If no method info. available, print blank line, else print
         // descriptors.
         
         if (methods != null) {
            // For each method descriptor ...

            for (int i = 0; i < methods.length; i ++) {
               // Print method info.
               
               System.out.println("   " + getMethodInfo(methods[i].getMethod()));
            }
         } else {
            System.out.println("");
         }
      } catch(Exception ex) {
         System.out.println(ex);
      }
   }

   /**
    * Get information about the given method -- return type, name, parameter
    * types. It will be formatted like this: type name(type[, type...])
    */
   private static String getMethodInfo(Method method) {
      StringBuffer sb = new StringBuffer();
      Class[]      parameters;

      // If method is null, return "null".
      
      if (method == null) {
         sb.append("null");
      } else {
         // Get parameter list.
   
         parameters = method.getParameterTypes();
   
         // Get method return type and method name, then add opening '('.
   
         sb.append(
            method.getReturnType().getName() + " " +
            method.getName() + "(");
   
         // For each parameter ...
   
         for (int j = 0; j < parameters.length; j ++) {
            // If not first parameter, print ','.
            
            if (j > 0) {
               sb.append(", ");
            }
   
            // Get parameter type.
   
            sb.append(parameters[j].getName());
         }

         // Add closing ')'.
   
         sb.append(")");
      }
      
      // Return the information.
      
      return sb.toString();
   }
}