View Javadoc
   /* -------------------------------------------------------------------
    * Java source file for the class ClassUtil
    * 
    * Copyright (c), 2002, Masahiro Takatsuka.
    * All Rights Researved.
    * 
    * Original Author: Masahiro Takatsuka (masa@jbeans.net)
    * $Author: takatsukam $
    * 
   * $Date: 2003/07/25 04:51:46 $
   * 
   * $Id: ClassUtil.java,v 1.1.1.1 2003/07/25 04:51:46 takatsukam Exp $
   * 
   * Reference:		Document no:
   * ___				___
   * 
   * To Do:
   * ___
   * 
  ------------------------------------------------------------------- */
  
  /* --------------------------- Package ---------------------------- */
  package net.jbeans.lang;
  
  /* ------------------ Import classes (packages) ------------------- *//package-summary/html">color="#329900"> ------------------ Import classes (packages) ------------------- *//package-summary.html">color="#329900">/* ------------------ Import classes (packages) ------------------- *//package-summary.html">color="#329900"> ------------------ Import classes (packages) ------------------- */
  import java.lang.reflect.*;
  
  import net.jbeans.util.debug.*;
  
  /*====================================================================
                    Implementation of class ClassUtil                   
  ====================================================================*/
  /***
   * This class defines various method for examining class objcts.
   * 
   * @version $Revision: 1.1.1.1 $
   * @author Masahiro Takatsuka (masa@jbeans.net)
   */
  
  public final class ClassUtil {
  	/***
  	 * debug flag
  	 */
  	private static final boolean DEBUG = Debug.getDebugFlag(ClassUtil.class);
  
      private static transient Class OBJ_CLASS = null;
  	
  	/***
  	 * Constructs a new ClassUtil object.
  	 */
      private ClassUtil() {
          super();
      }
  	
      /***
       * Return true if class a is either equivalent to class b, or
       * if class a is a subclass of class b.
       * Either or both "Class" objects may be interfaces.
  	 *
  	 * @param class_a a "Class" object which may be subclass of "Class" b.
  	 * @param class_b a "Class" object which may be superclass of "Class" a.
       */
      public static final boolean isSubclass(Class class_a, Class class_b) {
  		if (class_a == class_b) {
  			return true;
  		}
  		if (class_a == null || class_b == null) {
  			return false;
  		}
  		for (Class x = class_a; x != null; x = x.getSuperclass()) {
  			if (x == class_b) {	
  				return true;
  			}
  			if (class_b.isInterface()) {
  				Class interfaces[] = x.getInterfaces();
  				for (int i = 0; i < interfaces.length; i++) {
  					if (interfaces[i] == class_b) {
  						return true;
  					}
  				}
  			}
  		}
  		return false;
      }
  	
      /***
       * Return true if class <code>c</code> implements interface
  	 * <code>interfc</code>.
  	 *
  	 * @param clazz a "Class" object which may be implement interface interfc.
  	 * @param interfc a "Interface" which may be implemented by "Class" clazz.
       */
      private static final boolean assignableInterface(Class clazz, Class interfc) {
          if (clazz == interfc) {
              return true;
  		}
          Class impl[] = clazz.getInterfaces();
          for (int i = 0; i < impl.length; i++) {
              Class child = impl[i];
             if (assignableInterface(child, interfc)) {
                 return true;
 			}
         }
 		
         return false;
     }
 	
     /***
      * Return true if class <code>source</code> can be casted to
 	 * class <code>target</code>.
 	 *
 	 * @param source a "Class" object which may be subclass of "Class" target.
 	 * @param target a "Class" object which may be superclass of "Class"
 	 * source.	 
      */
     public static final boolean isAssignable(Class source, Class target) {
         if (target.isInterface()) {
             return assignableInterface(source, target);
 		}
         if (OBJ_CLASS == null) {
 			OBJ_CLASS = java.lang.Object.class;
 		}
 		if (target == OBJ_CLASS) {
             return true;
 		}
         for (Class current = source; current != null; current = current.getSuperclass()) {
             if (current == target) {
                 return true;
 			}
 		}
 		
         return false;
     }
 
     /***
      * Return true if object <code>o</code> is an array.
 	 *
 	 * @param o an object which may be an array.
      */
     public static final boolean isArray(Object o) {
 		Class clazz = o.getClass();
         return clazz.isArray();
     }
 
     /***
      * Return true if class <code>c</code> is an array.
 	 *
 	 * @param c a "Class" object which may be an array.
      */
     public static final boolean isArray(Class c) {
         return c.isArray();
     }
 	
     /***
      * Return true if class <code>c</code> is a 2-D array.
 	 *
 	 * @param c a "Class" object which may be a 2-D array.
      */
     public static final boolean is2DArray(Class c) {
         String nm = c.getName();
         return nm.lastIndexOf("[") >= 1;
     }
 
     /***
      * Return the dimensino of array if class <code>c</code> is an array.
 	 *
 	 * @param c a "Class" object which may be an array.
      */
     public static final int getDimensionOfArray(Class c) {
 		int dim = 0;
 		if (!isArray(c)) {
 			return dim;
 		}
         String nm = c.getName();
 		int len = nm.length();
 		for (int i = 0; i < len; i ++) {
 			if (nm.charAt(i) != '[') {
 				break;
 			}
 			dim++;
 		}
         return dim;
     }
 
 	/***
 	 * Sends the name of a method as a message to the receiver.  This is
 	 * equivalent to directly calling the receiver's method.  For example,
 	 * the following two lines do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *		myObject.setTitle("MyName");
 	 *		ClassUtil.makeObjectPerform(myObject, "setTitle", {"MyName"});
 	 * </PRE>
 	 * 
 	 * @param obj an object performing a method.
 	 * @param methodname a method to be performed.	 
 	 * @param args an array of arguments for the method.
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 */
 	public static final Object makeObjectPerform(Object obj, String methodname, Object[] args, Class[] argTypes) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		Class c = obj.getClass(); // get the Class object.
 		Method m = c.getMethod(methodname, argTypes); // get the instance of the method
 		
 		if (args == null) {
 			args = new Object[0]; // set up arguments.
 		}
 		return m.invoke(obj, args); // invoke the method.
 	}
 
 	/***
 	 * Sends the name of a method as a message to the receiver.  This is
 	 * equivalent to directly calling the receiver's method.  For example,
 	 * the following two lines do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *		myObject.setTitle("MyName");
 	 *		ClassUtil.makeObjectPerform(myObject, "setTitle", {"MyName"});
 	 * </PRE>
 	 * 
 	 * @param obj an object performing a method.
 	 * @param methodname a method to be performed.	 
 	 * @param args an array of arguments for the method.
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 */
 	public static final Object makeObjectPerform(Object obj, String methodname, Object[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		Class[] argTypes;
 		if (args == null) { // no parameter...
 			argTypes = new Class[0];
 		} else {					// get fully-qualified names of parameters
 			argTypes = new Class[args.length];
 			for (int i = 0; i < args.length; i++) {
 				argTypes[i] = args[i].getClass();
 			}
 		}
 		return makeObjectPerform(obj, methodname, args, argTypes);
 	}
   
 	/***
 	 * Returns true if the receiver implements or inherits a method that can
 	 * respond to <code>method</code>, false otherwise.  The application is
 	 * responsible for determining whether a false response should be
 	 * considered an error.  
 	 * <PRE>
 	 *  Example:
 	 *		if (ClassUtil.respondsToMethod(myObject, "setTitle", {"xxx"})) {
 	 *			myObject.setTitle("MyName");
 	 *		}
 	 * </PRE>
 	 * 
 	 * @param methodname a method to be performed.
 	 * @param argTypes an array of argument types for the methods.
 	 * @return true if the receiver implements or inherits the methods,
 	 * otherwiise false.
 	 * @see #perform(String, Object[])
 	 * @see #perform(String)
 	 * @see #respondsToMethod(String)
 	 */
 	public static final boolean respondsToMethod(Object obj, String methodname, Class[] argTypes) {
 		
 		Class c = obj.getClass(); // get the Class object.
 		try{
 			Method m = c.getMethod(methodname, argTypes); // get the instance of the method
 		}catch(NoSuchMethodException e){ // want to catch this exception in order to return false.
 			return false;
 		}
 		return true;
 	}
 
 	/***
 	 * Returns true if the receiver implements or inherits a method that can
 	 * respond to <code>method</code>, false otherwise.  The application is
 	 * responsible for determining whether a false response should be
 	 * considered an error.  
 	 * <PRE>
 	 *  Example:
 	 *		if (ClassUtil.respondsToMethod(myObject, "setTitle", {"xxx"})) {
 	 *			myObject.setTitle("MyName");
 	 *		}
 	 * </PRE>
 	 * 
 	 * @param methodname a method to be performed.
 	 * @param args an array of arguments for the methods.
 	 * @return true if the receiver implements or inherits the methods,
 	 * otherwiise false.
 	 * @see #perform(String, Object[])
 	 * @see #perform(String)
 	 * @see #respondsToMethod(String)
 	 */
 	public static final boolean respondsToMethod(Object obj, String methodname, Object[] args) {
 		Class[] argTypes;
 		if (args == null) {		// if there is no parameter...
 			argTypes = new Class[0]; 
 		} else {				// get fully-qualified names of parameters
 			argTypes = new Class[args.length];
 			for (int i = 0; i < args.length; i++)
 				argTypes[i] = args[i].getClass();
 		}
 		return respondsToMethod(obj, methodname, argTypes);
 	}
 	
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.  For example, the following
 	 * two messages do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *		myObject.show();
 	 *		myObject.perform("show");
 	 * </PRE>
 	 * 
 	 * @param obj an object performing a method.
 	 * @param methodname a method to be performed.	 
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 */
 	public static final Object makeObjectPerform(Object obj, String methodname)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		return makeObjectPerform(obj, methodname, null);
 	}
 	
 	/***
 	 * Returns true if the receiver implements or inherits a method that can
 	 * respond to methodname messages, false otherwise.  The application is
 	 * responsible for determining whether a false response should be considered
 	 * an error.
 	 * <PRE>
 	 *  Example:
 	 *		if(ClassUtil.respondsToMethod(myObject, "show"))
 	 *			myObject.show();
 	 * </PRE>
 	 * 
 	 * @param obj an object performing a method.
 	 * @param methodname a method to be performed.	 
 	 * @return true if the receiver implements or inherits the methods,
 	 * otherwiise false.
 	 */
 	public static final boolean respondsToMethod(Object obj, String methodname) {
 		return respondsToMethod(obj, methodname, null);
 	}
 
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.  For example, the following
 	 * two messages do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *	myObject.setTitle("MyName");
 	 *  Object[] args = {String.class};
 	 *  Method method = myObject.getMethod("setTitle", args);
 	 *	ThreadGroup mygroup = new ThreadGroup(this.toString());
 	 *	myObject.performInThread(mygroup, method, {"MyName"}, false);
 	 *  Example of implementation:
 	 *	public synchronized void performInThread(ThreadGroup group, Method method, Object arg, boolean forced)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
 	 *	  ThreadTask task = new ThreadTask(this, method, args);
 	 *	  Thread newThread = new Thread(group,
 	 *						this,
 	 *						method.getName());
 	 *	  newThread.start();
 	 *	}
 	 * </PRE>
 	 *
 	 * @param group a thread group.
 	 * @param method a method to be performed.
 	 * @param args arguments for the method.   
 	 * @param forced a flag to force the specified method to be executed
 	 * even if there is alread a thread executing the same method.
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(ThreadGroup group, Object object, Method method, Object[] args, boolean forced)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 // 		if (! respondsToMethod(object,
 // 							   (method != null)?method.getName():"",
 // 							   args) ) {
 // 			throw new NoSuchMethodException();
 // 		}
 		ThreadTask task = new ThreadTask(object, method, args);
 		Thread newThread = new Thread(group,
 									  task,
 									  method.getName());
 		newThread.start();
 		return newThread;
 	}
 
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.
 	 * 
 	 * @param group a thread group.
 	 * @param methodname a method to be performed.
 	 * @param args arguments for the method.      
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(ThreadGroup group, Object object, Method method, Object[] args)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		return makeObjectPerformInThread(group, object, method, args, false);    
 	}
 	
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.
 	 * 
 	 * @param methodname a method to be performed.
 	 * @param args arguments for the method.         
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(Object object, Method method, Object[] args)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		return makeObjectPerformInThread(null, object, method, args);
 	}
 	
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.  
 	 * 
 	 * @param methodname a method to be performed.
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(Object object, Method method)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		return makeObjectPerformInThread(null, object, method, null);
 	}
 
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.  For example, the following
 	 * two messages do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *		myObject.setTitle("MyName");
 	 *		ThreadGourp myThreadGroup = new ThreadGroup(this.toString());
 	 *		myObject.performInThread(myThreadGroup, "setTitle", {"MyName"}, false);
 	 * </PRE>
 	 * 
 	 * @param group a thread group.
 	 * @param methodname a method to be performed.
 	 * @param args arguments for the method.   
 	 * @param forced a flag to force the specified method to be executed
 	 * even if there is alread a thread executing the same method.
 	 * (This function is not implemented in this release.)
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(ThreadGroup group, Object object, String methodname, Object[] args, boolean forced)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		Class[] parameters;
 		
 		if (args == null) { // no parameter...
 			parameters = new Class[0];
 		} else {					// get fully-qualified names of parameters
 			parameters = new Class[args.length];
 			for (int i = 0; i < args.length; i++) {
 				parameters[i] = args[i].getClass();
 			}
 		}
 		return makeObjectPerformInThread(group, object, methodname, args, parameters, forced);
 	}
 
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.  For example, the following
 	 * two messages do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *		myObject.setTitle("MyName");
 	 *		ThreadGourp myThreadGroup = new ThreadGroup(this.toString());
 	 *		myObject.performInThread(myThreadGroup, "setTitle", {"MyName"}, false);
 	 * </PRE>
 	 * 
 	 * @param group a thread group.
 	 * @param methodname a method to be performed.
 	 * @param args arguments for the method.   
 	 * @param forced a flag to force the specified method to be executed
 	 * even if there is alread a thread executing the same method.
 	 * (This function is not implemented in this release.)
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(ThreadGroup group, Object object, String methodname, Object[] args, Class[] argTypes, boolean forced)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		Method method = object.getClass().getMethod(methodname, argTypes); // get the instance of the method
 		return makeObjectPerformInThread(group, object, method, args, forced);
 	}
 	
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.  For example, the following
 	 * two messages do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *		myObject.setTitle("MyName");
 	 *		myObject.perform("setTitle", {"MyName"});
 	 * </PRE>
 	 * 
 	 * @param group a thread group.
 	 * @param methodname a method to be performed.
 	 * @param args arguments for the method.      
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(ThreadGroup group, Object object, String methodname, Object[] args, Class[] argTypes)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		return makeObjectPerformInThread(group, object, methodname, args, argTypes, false);    
 	}
 
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.  For example, the following
 	 * two messages do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *		myObject.setTitle("MyName");
 	 *		myObject.perform("setTitle", {"MyName"});
 	 * </PRE>
 	 * 
 	 * @param group a thread group.
 	 * @param methodname a method to be performed.
 	 * @param args arguments for the method.      
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(ThreadGroup group, Object object, String methodname, Object[] args)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		return makeObjectPerformInThread(group, object, methodname, args, false);    
 	}
 	
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.  For example, the following
 	 * two messages do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *		myObject.setTitle("MyName");
 	 *		myObject.perform("setTitle", {"MyName"});
 	 * </PRE>
 	 * 
 	 * @param methodname a method to be performed.
 	 * @param args arguments for the method.         
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(Object object, String methodname, Object[] args, Class[] argTypes)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		return makeObjectPerformInThread(null, object, methodname, args, argTypes);
 	}
 
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.  For example, the following
 	 * two messages do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *		myObject.setTitle("MyName");
 	 *		myObject.perform("setTitle", {"MyName"});
 	 * </PRE>
 	 * 
 	 * @param methodname a method to be performed.
 	 * @param args arguments for the method.         
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(Object object, String methodname, Object[] args)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		return makeObjectPerformInThread(null, object, methodname, args);
 	}
 	
 	/***
 	 * Sends a methodname message to the receiver.  This is equivalent to sending
 	 * a methodname message directly to the receiver.  For example, the following
 	 * two messages do the same thing:
 	 * <PRE>
 	 *  Example:
 	 *		myObject.show();
 	 *		myObject.perform("show");
 	 * </PRE>
 	 * 
 	 * @param methodname a method to be performed.
 	 * @exception java.lang.IllegalAccessException
 	 *	if the underlying methods is inaccessible.
 	 * @exception java.lang.IllegalArgumentException
 	 *	if the number of actual and formal parameters differ,
 	 *	or if an unwrapping conversion fails.
 	 * @exception java.lang.reflect.InvocationTargetException
 	 *	if the underlying methods throws an exception.
 	 * @exception java.lang.NoSuchMethodException
 	 *	if a matching methods is not found.
 	 * @see com.gpz.lang.MObject#perform(String)
 	 * @see com.gpz.lang.MObject#respondsToMethod(String, Object[])
 	 * @see com.gpz.lang.MObject#respondsToMethod(String)
 	 */
 	public static final Thread makeObjectPerformInThread(Object object, String methodname)  throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
 		return makeObjectPerformInThread(null, object, methodname, null);
 	}
 
 	/***
 	* Returns a corresponding wrapper class of the specified primitive class.
 	*
 	* @param primitiveClass a class represnts a primitive (one of Boolean.TYPE,
 	* Character.TYPE, Byte.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE,
 	* Double.TYPE).
 	*/
 	public static final Class getWrapperClass(Class primitiveClass) {
 		Class wrapper = null;
 		if (primitiveClass == Boolean.TYPE) {
 			wrapper = Boolean.class;
 		} else if (primitiveClass == Character.TYPE) {
 			wrapper = Character.class;			
 		} else if (primitiveClass == Byte.TYPE) {
 			wrapper = Byte.class;			
 		} else if (primitiveClass == Short.TYPE) {
 			wrapper = Short.class;			
 		} else if (primitiveClass == Integer.TYPE) {
 			wrapper = Integer.class;			
 		} else if (primitiveClass == Long.TYPE) {
 			wrapper = Long.class;			
 		} else if (primitiveClass == Float.TYPE) {
 			wrapper = Float.class;
 		} else if (primitiveClass == Double.TYPE) {
 			wrapper = Double.class;
 		}
 		return wrapper;
 	}
 
 	/***
 	 * Converts Class objects representing primitive classes into
 	 * corresponding wrapper classs.  The original array will be over
 	 * written by new classes.
 	 *
 	 * @param primitiveClasses an array containing classs.
 	*/
 	public static final Class[] getWrapperClasses(Class[] primitiveClasses) {
 		int len = primitiveClasses.length;
 		for (int i = 0; i < len; i++) {
 			if (primitiveClasses[i].isPrimitive()) {
 				primitiveClasses[i] = ClassUtil.getWrapperClass(primitiveClasses[i]);
 			}
 		}
 		return primitiveClasses;
 	}
 	
 	/***
 	* Returns a corresponding class of the specified primitive class.
 	*
 	* @param primitive a string represnts a primitive (one of "boolean", "char",
 	* "byte", "short", "int", "long", "float", "double").
 	*/
 	public static final Class getPrimitiveClass(String primitive) {
 		Class clazz = null;
 		if (primitive.equals("boolean")) {
 			clazz = Boolean.TYPE;
 		} else if (primitive.equals("char")) {
 			clazz = Character.TYPE;			
 		} else if (primitive.equals("byte")) {
 			clazz = Byte.TYPE;			
 		} else if (primitive.equals("short")) {
 			clazz = Short.TYPE;			
 		} else if (primitive.equals("int")) {
 			clazz = Integer.TYPE;			
 		} else if (primitive.equals("long")) {
 			clazz = Long.TYPE;			
 		} else if (primitive.equals("float")) {
 			clazz = Float.TYPE;
 		} else if (primitive.equals("double")) {
 			clazz = Double.TYPE;
 		}
 		return clazz;
 	}
 
 	public static final String[] getClassNames(Class[] classes) {
 		int len = classes.length;
 		String[] names = new String[len];
 		for (int i = 0; i < len; i++) {
 			names[i] = classes[i].getName();
 		}
 		return names;
 	}
 
 	public static final Class[] getClasses(String[] names) {
 		int len = names.length;
 		Class[] classes = new Class[len];
 		for (int i = 0; i < len; i++) {
 			try {
 				Class argclass = ClassUtil.getPrimitiveClass(names[i]);
 				if (argclass != null) {
 					classes[i] = argclass;
 				} else {
 					classes[i] = Class.forName(names[i]);
 				}
 			} catch (ClassNotFoundException e) {
 				classes[i] = null;
 			}
 		}
 		return classes;
 	}
 
 	public static final Class getClass(String name) {
 		Class clazz = null;
 		try {
 			clazz = ClassUtil.getPrimitiveClass(name);
 			if (clazz == null) {
 				clazz = Class.forName(name);
 			}
 		} catch (ClassNotFoundException e) {
 			clazz = null;
 		}
 		return clazz;
 	}
 	
     /*** 
      * Returns the name of the root class from a full class path.
      * @param fullName The full name of the class i.e, java.awt.event.ActionListener
      * @return The root name of the class i.e., ActionListener
      */
     public static final String getRootName(Class clazz)  {
 		return getRootName(clazz.getName());
 	}
 
     /*** 
      * Returns the name of the root class from a full class path.
      * @param fullName The full name of the class i.e, java.awt.event.ActionListener
      * @return The root name of the class i.e., ActionListener
      */
     public static final String getRootName(String fullName)  {
 		String compName = getCompilableName(fullName);
 		int index = compName.lastIndexOf('.');			
 		compName = compName.substring(index + 1);
 		
 		return compName;
     }
 
     /*** 
      * Returns the class name, which can be inserted in java source code,
 	 * from a fully-qualified class name.
      * @param fullName The full name of the class
 	 * i.e, java.awt.event.ActionListener, [[Ljava.lang.String
      * @return The class name that can be inserted in java source code
 	 * i.e., java.awt.event.ActionListener, java.lang.String[][]
      */
     public static final String getCompilableName(Class clazz) {
 		return getCompilableName(clazz.getName());
 	}
 	
 
     /*** 
      * Returns the class name, which can be inserted in java source code,
 	 * from a fully-qualified class name.
      * @param fullName The full name of the class
 	 * i.e, java.awt.event.ActionListener, [[Ljava.lang.String
      * @return The class name that can be inserted in java source code
 	 * i.e., java.awt.event.ActionListener, java.lang.String[][]
      */
     public static final String[] getCompilableNames(Class[] classes) {
 		int count = classes.length;
 		String[] names = new String[count];
 		for (int i = 0; i < count; i++) {
 			names[i] = getCompilableName(classes[i].getName());
 		}
 		return names;
 	}
 	
     /*** 
      * Returns the class name, which can be inserted in java source code,
 	 * from a fully-qualified class name.
      * @param fullName The full name of the class
 	 * i.e, java.awt.event.ActionListener, [[Ljava.lang.String
      * @return The class name that can be inserted in java source code
 	 * i.e., java.awt.event.ActionListener, java.lang.String[][]
      */
     public static final String getCompilableName(String fullName)  {
 		// find array dimension;
 		int dim = 0;
 		int len = fullName.length();
 		int i = 0;
 		for (i = 0; i < len; i++) { // count '['
 			if (fullName.charAt(i) != '[') {
 				break;
 			}
 			dim++;
 		}
 		String name = "";		
 		if (dim > 0) {			// class is an array!
 			/*
 			  B            byte
 			  C            char
 			  D            double
 			  F            float
 			  I            int
 			  J            long
 			  Lclassname;  class or interface
 			  S            short
 			  Z            boolean
 			*/
 			char objLetter = fullName.charAt(i);
 			
 			if (objLetter == 'B') {
 				name = "byte";
 			} else if (objLetter == 'C') {
 				name = "char";
 			} else if (objLetter == 'D') {
 				name = "double";
 			} else if (objLetter == 'F') {
 				name = "float";
 			} else if (objLetter == 'I') {
 				name = "int";
 			} else if (objLetter == 'J') {
 				name = "long";
 			} else if (objLetter == 'S') {
 				name = "short";
 			} else if (objLetter == 'Z') {
 				name = "boolean";
 			} else if (objLetter == 'L') {
 				// there is ';' at the end, so get rid of it!
 				name = fullName.substring(i + 1, len - 1);
 			}
 			StringBuffer sbname = new StringBuffer(name);
 			for (int j = 0; j < dim; j++) {
 				sbname.append("[]");
 			}
 			name = sbname.toString();
 		} else {
 			name = fullName;
 		}
         return name;
     }
 
 	
     /*** 
      * Returns a string that formats the method signature for desplay
      * @param method The method to format.
      */
     public static final String formatMethodSignature(Method method)  {
 		StringBuffer params = new StringBuffer(formatReturnType(method));
 		params.append(method.getName());
 		params.append(formatParameters(method));
 		return params.toString();
 	}
 
     /*** 
      * Returns a string that formats the method signature for desplay
      * @param method The method to format.
      */
     public static final String formatMethodSignatureWithoutReturnType(Method method)  {
 		StringBuffer params = new StringBuffer(method.getName());
 		params.append(formatParameters(method));
 		return params.toString();
 	}
 	
     /*** 
      * Returns a string that formats the parameters for a methods for display
      * @param method The method to format.
      */
     public static final String formatParameters(Method method)  {
         StringBuffer params = new StringBuffer("( ");
         
         Class[] paramTypes = method.getParameterTypes();
         if (paramTypes != null)  {
             for (int i = 0; i < paramTypes.length; i++) {
                 params.append(getRootName(paramTypes[i].getName()));
                 params.append((i == paramTypes.length - 1) ? " " : ", ");
             }
         }
         params.append(")");
         
         return params.toString();
     }
 
     /*** 
      * Returns a string that formats the parameters for a methods for display
      * @param method The method to format.
      */
     public static final String formatReturnType(Method method)  {
         StringBuffer params = new StringBuffer("( ");
         
         Class returnType = method.getReturnType();
         if (returnType != null)  {
 			params.append(getRootName(returnType.getName()));
         }
         params.append(" )");
         
         return params.toString();
     }
 
     /***
      * Utility method to take a string and convert it to normal Java variable
      * name capitalization.  This normally means converting the first
      * character from upper case to lower case, but in the (unusual) special
      * case when there is more than two character and the first, second and
      * third characters are upper case, we leave it alone.
      * <p>
      * Thus "FooBah" becomes "fooBah" and "X" becomes "x", but "URL" stays
      * as "URL".
      *
      * @param  name The string to be decapitalized.
      * @return  The decapitalized version of the string.
      */
     public static final String decapitalize(String name) {
 		if (name == null || name.length() == 0) {
 			return name;
 		}
 		if (name.length() > 1 && Character.isUpperCase(name.charAt(2)) &&
 			Character.isUpperCase(name.charAt(1)) &&
 			Character.isUpperCase(name.charAt(0))){
 			return name;
 		}
 		char chars[] = name.toCharArray();
 		chars[0] = Character.toLowerCase(chars[0]);
 		return new String(chars);
     }
 
     /***
      * Utility method to take a string and convert it to normal Java variable
      * name capitalization.  This normally means converting the first
      * character from upper case to lower case.
      * <p>
      * Thus "FooBah" becomes "fooBah" and "X" becomes "x", and "URL" becomes
      * as "uRL".
      *
      * @param  name The string to be decapitalized.
      * @return  The decapitalized version of the string.
      */
     public static final String forceDecapitalize(String name) {
 		if (name == null || name.length() == 0) {
 			return name;
 		}
 		char chars[] = name.toCharArray();
 		chars[0] = Character.toLowerCase(chars[0]);
 		return new String(chars);
     }
 
     /***
      * Utility method to take a string and convert it to normal Java Class 
      * name capitalization.  This normally means converting the first
      * character from lower case to upper case.
      *
      * @param  name The string to be capitalized.
      * @return  The capitalized version of the string.
      */
     public static final String capitalize(String name) {
 		if (name == null || name.length() == 0) {
 			return name;
 		}
 		char chars[] = name.toCharArray();
 		chars[0] = Character.toUpperCase(chars[0]);
 		return new String(chars);
     }
 
     /*** 
      * Returns the name of the root directory where the specified class
 	 * resides.
      * @param fullName The full name of the class i.e, java.awt.event.ActionListener
      * @return The root name of the class i.e., ActionListener
      */
     public static final String getRootDirectoryName(String fullPath, String classFileName) {
 		int index = fullPath.lastIndexOf(classFileName);
 		if (index >= 0) {
 			return fullPath.substring(0, index);
 		}
 		return null;
     }
 
 	public static final Method getMethod(Object obj, String methodName, Class[] argTypes) {
 		Method method = null;
 		try {
 			Class c = obj.getClass(); // get the Class object.
 			method = c.getMethod(methodName, argTypes); // get the instance of the method
 		}catch(NoSuchMethodException e) {
 			if (DEBUG) {
 				e.printStackTrace();
 			}
 			// let go as method == null.
 		}
 		return method;
 	}
 }