src/main/java/org/apache/bsf/util/ReflectionUtils.java - commons-bsf - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.bsf.util;

 import org.apache.bsf.BSFManager;   // rgf, 20070917

 import java.beans.BeanInfo;
 import java.beans.Beans;
 import java.beans.EventSetDescriptor;
 import java.beans.FeatureDescriptor;
 import java.beans.IndexedPropertyDescriptor;
 import java.beans.IntrospectionException;
 import java.beans.Introspector;
 import java.beans.PropertyDescriptor;
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

 import java.util.TreeSet;
 import java.util.Comparator;
 import java.util.Iterator;

 import org.apache.bsf.util.event.EventAdapter;
 import org.apache.bsf.util.event.EventAdapterRegistry;
 import org.apache.bsf.util.event.EventProcessor;
 import org.apache.bsf.util.type.TypeConvertor;
 import org.apache.bsf.util.type.TypeConvertorRegistry;

 /**
  * This file is a collection of reflection utilities. There are utilities
  * for creating beans, getting bean infos, setting/getting properties,
  * and binding events.
  *
  * @author   Sanjiva Weerawarana
  * @author   Joseph Kesselman
  */
  /*  2007-09-21: Rony G. Flatscher, new class loading sequence:

         - supplied class loader (given as an argument)
         - Thread's context class loader
         - BSFManager's defining class loader

      2011-10-29: Rony G. Flatscher, in case an event is not found, create a
           user-friendly error message that lists all available event names

      2011-10-29: Rony G. Flatscher, make sure that the context class loader
           is used only, if not null
  */
 public class ReflectionUtils {
     // rgf, 20070921: class loaders that we might need to load classes
     static ClassLoader bsfManagerDefinedCL=BSFManager.getDefinedClassLoader();


   //////////////////////////////////////////////////////////////////////////

   /**
    * Add an event processor as a listener to some event coming out of an
    * object.
    *
    * @param source       event source
    * @param eventSetName name of event set from event src to bind to
    * @param processor    event processor the event should be delegated to
    *                     when it occurs; either via processEvent or
    *                     processExceptionableEvent.
    *
    * @exception IntrospectionException if unable to introspect
    * @exception IllegalArgumentException if event set is unknown
    * @exception IllegalAccessException if the event adapter class or
    *            initializer is not accessible.
    * @exception InstantiationException if event adapter instantiation fails
    * @exception InvocationTargetException if something goes wrong while
    *            running add event listener method
    */
   public static void addEventListener (Object source, String eventSetName,
                        EventProcessor processor)
        throws IntrospectionException, IllegalArgumentException,
               IllegalAccessException, InstantiationException,
               InvocationTargetException {
     // find the event set descriptor for this event
     BeanInfo bi = Introspector.getBeanInfo (source.getClass ());

     EventSetDescriptor arrESD[]=bi.getEventSetDescriptors ();
     EventSetDescriptor esd=(EventSetDescriptor) findFeatureByName ("event", eventSetName, arrESD);

     if (esd == null)        // no events found, maybe a proxy from OpenOffice.org?
         {
           String errMsg="event set '" + eventSetName +"' unknown for source type '" + source.getClass () + "': ";
           if (arrESD.length==0)     // no event sets found in class!
           {
               errMsg=errMsg+"class does not implement any event methods following Java's event pattern!";
           }
           else
           {
               // errMsg=errMsg+"class defines the following event set(s): {";
               errMsg=errMsg+"class defines the following event set(s): ";

               // sort ESD by Name
               TreeSet ts=new TreeSet(new Comparator () {
                           public int    compare(Object o1, Object o2) {return ((EventSetDescriptor)o1).getName().compareToIgnoreCase(((EventSetDescriptor)o2).getName());}
                           public boolean equals(Object o1, Object o2) {return ((EventSetDescriptor)o1).getName().equalsIgnoreCase   (((EventSetDescriptor)o2).getName());}
                          });

               for (int i=0;i<arrESD.length;i++)
               {
                   ts.add(arrESD[i]);
               }
               Iterator it=ts.iterator();    // get iterator

               int i=0;
               while (it.hasNext())          // iterate in sorted order
               {
                   EventSetDescriptor tmpESD=(EventSetDescriptor) it.next();

                   if (i>0)
                   {
                       errMsg=errMsg+", ";
                   }
                   errMsg=errMsg+"\n\t"+'\''+tmpESD.getName()+"'={";  // event set name


                     // iterate over listener methods and display their names in sorted order
                   Method m[]=tmpESD.getListenerMethods();
                   TreeSet tsM=new TreeSet(new Comparator () {
                           public int    compare(Object o1, Object o2) {return ((Method)o1).getName().compareToIgnoreCase(((Method)o2).getName());}
                           public boolean equals(Object o1, Object o2) {return ((Method)o1).getName().equalsIgnoreCase   (((Method)o2).getName());}
                          });

                   for (int j=0;j<m.length;j++)
                   {
                       tsM.add(m[j]);
                   }
                   Iterator itM=tsM.iterator();

                   int j=0;
                   while (itM.hasNext())
                   {
                       if (j>0)
                       {
                           errMsg=errMsg+',';
                       }
                       errMsg=errMsg+'\''+((Method) itM.next()).getName()+'\'';
                       j++;
                   }
                   errMsg=errMsg+'}';    // close event method set
                   i++;
               }

               errMsg=errMsg+".";       // close set of event sets
           }
           throw new IllegalArgumentException (errMsg);
     }

     // get the class object for the event
     Class listenerType=esd.getListenerType(); // get ListenerType class object from EventSetDescriptor

     // find an event adapter class of the right type
     Class adapterClass = EventAdapterRegistry.lookup (listenerType);
     if (adapterClass == null) {
       throw new IllegalArgumentException ("event adapter for listener type " +
                           "'" + listenerType + "' (eventset " +
                           "'" + eventSetName + "') unknown");
     }

     // create the event adapter and give it the event processor
     EventAdapter adapter = (EventAdapter) adapterClass.newInstance ();
     adapter.setEventProcessor (processor);

     // bind the adapter to the source bean
     Method addListenerMethod;
     Object[] args;
     if (eventSetName.equals ("propertyChange") ||
         eventSetName.equals ("vetoableChange")) {
       // In Java 1.2, beans may have direct listener adding methods
       // for property and vetoable change events which take the
       // property name as a filter to be applied at the event source.
       // The filter property of the event processor should be used
       // in this case to support the source-side filtering.
       //
       // ** TBD **: the following two lines need to change appropriately
           addListenerMethod = esd.getAddListenerMethod ();
       args = new Object[] {adapter};
     }
         else
         {
           addListenerMethod = esd.getAddListenerMethod ();
       args = new Object[] {adapter};
     }
     addListenerMethod.invoke (source, args);
   }
   //////////////////////////////////////////////////////////////////////////


   /**
    * Create a bean using given class loader and using the appropriate
    * constructor for the given args of the given arg types.

    * @param cld       the class loader to use. If null, Class.forName is used.
    * @param className name of class to instantiate
    * @param argTypes  array of argument types
    * @param args      array of arguments
    *
    * @return the newly created bean
    *
    * @exception ClassNotFoundException    if class is not loaded
    * @exception NoSuchMethodException     if constructor can't be found
    * @exception InstantiationException    if class can't be instantiated
    * @exception IllegalAccessException    if class is not accessible
    * @exception IllegalArgumentException  if argument problem
    * @exception InvocationTargetException if constructor excepted
    * @exception IOException               if I/O error in beans.instantiate
    */
   public static Bean createBean (ClassLoader cld, String className,
                  Class[] argTypes, Object[] args)
        throws ClassNotFoundException, NoSuchMethodException,
               InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException,
               IOException {
     if (argTypes != null) {

             // if class loader given, use that one, else try
             // the Thread's context class loader (if set) and then
             // the BSFMananger defining class loader
           Class cl=null;
           ClassNotFoundException exCTX=null;

 // -----------------------------
           if (cld != null) {    // class loader supplied as argument
               try {     // CL passed as argument
                   cl=cld.loadClass(className);
               }
               catch (ClassNotFoundException e02) {
                   exCTX=e02;
               }
           }

           if (cl==null) {
               // load context class loader, only use it, if not null
               ClassLoader tccl=Thread.currentThread().getContextClassLoader();
               if (tccl!=null) {
                   try {         // CTXCL
                           cl=tccl.loadClass(className);
                       }
                   catch (ClassNotFoundException e01) {}
               }
           }

           if (cl==null) {   // class not loaded yet
                     // defined CL
               if (cld != bsfManagerDefinedCL) {   // if not used already, attempt to load
                   cl=bsfManagerDefinedCL.loadClass(className);
               }
               else {    // classloader was already used, hence re-throw exception
                   throw exCTX;      // re-throw very first exception
               }
           }
 // -----------------------------

       Constructor c = MethodUtils.getConstructor (cl, argTypes);
       return new Bean (cl, c.newInstance (args));
     } else {
       // create the bean with no args constructor
       Object obj = Beans.instantiate (cld, className);
       return new Bean (obj.getClass (), obj);
     }
   }
   //////////////////////////////////////////////////////////////////////////

   /**
    * Create a bean using given class loader and using the appropriate
    * constructor for the given args. Figures out the arg types and
    * calls above.

    * @param cld       the class loader to use. If null, Class.forName is used.
    * @param className name of class to instantiate
    * @param args      array of arguments
    *
    * @return the newly created bean
    *
    * @exception ClassNotFoundException    if class is not loaded
    * @exception NoSuchMethodException     if constructor can't be found
    * @exception InstantiationException    if class can't be instantiated
    * @exception IllegalAccessException    if class is not accessible
    * @exception IllegalArgumentException  if argument problem
    * @exception InvocationTargetException if constructor excepted
    * @exception IOException               if I/O error in beans.instantiate
    */
   public static Bean createBean (ClassLoader cld, String className, Object[] args)
        throws ClassNotFoundException, NoSuchMethodException,
               InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException,
               IOException {
     Class[] argTypes = null;
     if (args != null) {
       argTypes = new Class[args.length];
       for (int i = 0; i < args.length; i++) {
         argTypes[i] = (args[i] != null) ? args[i].getClass () : null;
       }
     }
     return createBean (cld, className, argTypes, args);
   }
   //////////////////////////////////////////////////////////////////////////

   /**
    * locate the item in the fds array whose name is as given. returns
    * null if not found.
    */
   private static
   FeatureDescriptor findFeatureByName (String featureType, String name,
                        FeatureDescriptor[] fds) {
     for (int i = 0; i < fds.length; i++) {
       if (name.equals (fds[i].getName())) {
         return fds[i];
       }
     }
     return null;
   }


   public static Bean getField (Object target, String fieldName)
       throws IllegalArgumentException, IllegalAccessException {
     // This is to handle how we do static fields.
     Class targetClass = (target instanceof Class)
                         ? (Class) target
                         : target.getClass ();

     try {
       Field f = targetClass.getField (fieldName);
       Class fieldType = f.getType ();

       // Get the value and return it.
       Object value = f.get (target);
       return new Bean (fieldType, value);
     } catch (NoSuchFieldException e) {
       throw new IllegalArgumentException ("field '" + fieldName + "' is " +
                           "unknown for '" + target + "'");
     }
   }
   //////////////////////////////////////////////////////////////////////////

   /**
    * Get a property of a bean.
    *
    * @param target    the object whose prop is to be gotten
    * @param propName  name of the property to set
    * @param index     index to get (if property is indexed)
    *
    * @exception IntrospectionException if unable to introspect
    * @exception IllegalArgumentException if problems with args: if the
    *            property is unknown, or if the property is given an index
    *            when its not, or if the property is not writeable, or if
    *            the given value cannot be assigned to the it (type mismatch).
    * @exception IllegalAccessException if read method is not accessible
    * @exception InvocationTargetException if read method excepts
    */
   public static Bean getProperty (Object target, String propName,
                   Integer index)
        throws IntrospectionException, IllegalArgumentException,
               IllegalAccessException, InvocationTargetException {
     // find the property descriptor
     BeanInfo bi = Introspector.getBeanInfo (target.getClass ());
     PropertyDescriptor pd = (PropertyDescriptor)
       findFeatureByName ("property", propName, bi.getPropertyDescriptors ());
     if (pd == null) {
       throw new IllegalArgumentException ("property '" + propName + "' is " +
                           "unknown for '" + target + "'");
     }

     // get read method and type of property
     Method rm;
     Class propType;
     if (index != null) {
       // if index != null, then property is indexed - pd better be so too
       if (!(pd instanceof IndexedPropertyDescriptor)) {
         throw new IllegalArgumentException ("attempt to get non-indexed " +
                             "property '" + propName +
                             "' as being indexed");
       }
       IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
       rm = ipd.getIndexedReadMethod ();
       propType = ipd.getIndexedPropertyType ();
     } else {
       rm = pd.getReadMethod ();
       propType = pd.getPropertyType ();
     }

     if (rm == null) {
       throw new IllegalArgumentException ("property '" + propName +
                           "' is not readable");
     }

     // now get the value
     Object propVal = null;
     if (index != null) {
       propVal = rm.invoke (target, new Object[] {index});
     } else {
       propVal = rm.invoke (target, null);
     }
     return new Bean (propType, propVal);
   }
   public static void setField (Object target, String fieldName, Bean value,
                    TypeConvertorRegistry tcr)
       throws IllegalArgumentException, IllegalAccessException {
     // This is to handle how we do static fields.
     Class targetClass = (target instanceof Class)
                         ? (Class) target
                         : target.getClass ();

     try {
       Field f = targetClass.getField (fieldName);
       Class fieldType = f.getType ();

       // type convert the value if necessary
       Object fieldVal = null;
       boolean okeydokey = true;
       if (fieldType.isAssignableFrom (value.type)) {
         fieldVal = value.value;
       } else if (tcr != null) {
         TypeConvertor cvtor = tcr.lookup (value.type, fieldType);
         if (cvtor != null) {
           fieldVal = cvtor.convert (value.type, fieldType, value.value);
         } else {
           okeydokey = false;
         }
       } else {
         okeydokey = false;
       }
       if (!okeydokey) {
         throw new IllegalArgumentException ("unable to assign '" + value.value +
                             "' to field '" + fieldName + "'");
       }

       // now set the value
       f.set (target, fieldVal);
     } catch (NoSuchFieldException e) {
       throw new IllegalArgumentException ("field '" + fieldName + "' is " +
                           "unknown for '" + target + "'");
     }
   }
   //////////////////////////////////////////////////////////////////////////

   /**
    * Set a property of a bean to a given value.
    *
    * @param target    the object whose prop is to be set
    * @param propName  name of the property to set
    * @param index     index to set (if property is indexed)
    * @param value     the property value
    * @param valueType the type of the above (needed when its null)
    * @param tcr       type convertor registry to use to convert value type to
    *                  property type if necessary
    *
    * @exception IntrospectionException if unable to introspect
    * @exception IllegalArgumentException if problems with args: if the
    *            property is unknown, or if the property is given an index
    *            when its not, or if the property is not writeable, or if
    *            the given value cannot be assigned to the it (type mismatch).
    * @exception IllegalAccessException if write method is not accessible
    * @exception InvocationTargetException if write method excepts
    */
   public static void setProperty (Object target, String propName,
                   Integer index, Object value,
                   Class valueType, TypeConvertorRegistry tcr)
        throws IntrospectionException, IllegalArgumentException,
               IllegalAccessException, InvocationTargetException {
     // find the property descriptor
     BeanInfo bi = Introspector.getBeanInfo (target.getClass ());
     PropertyDescriptor pd = (PropertyDescriptor)
       findFeatureByName ("property", propName, bi.getPropertyDescriptors ());
     if (pd == null) {
       throw new IllegalArgumentException ("property '" + propName + "' is " +
                           "unknown for '" + target + "'");
     }

     // get write method and type of property
     Method wm;
     Class propType;
     if (index != null) {
       // if index != null, then property is indexed - pd better be so too
       if (!(pd instanceof IndexedPropertyDescriptor)) {
         throw new IllegalArgumentException ("attempt to set non-indexed " +
                             "property '" + propName +
                                             "' as being indexed");
       }
       IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
       wm = ipd.getIndexedWriteMethod ();
       propType = ipd.getIndexedPropertyType ();
     } else {
       wm = pd.getWriteMethod ();
       propType = pd.getPropertyType ();
     }

     if (wm == null) {
       throw new IllegalArgumentException ("property '" + propName +
                           "' is not writeable");
     }

     // type convert the value if necessary
     Object propVal = null;
     boolean okeydokey = true;
     if (propType.isAssignableFrom (valueType)) {
       propVal = value;
     } else if (tcr != null) {
       TypeConvertor cvtor = tcr.lookup (valueType, propType);
       if (cvtor != null) {
         propVal = cvtor.convert (valueType, propType, value);
       } else {
         okeydokey = false;
       }
     } else {
       okeydokey = false;
     }
     if (!okeydokey) {
       throw new IllegalArgumentException ("unable to assign '" + value +
                           "' to property '" + propName + "'");
     }

     // now set the value
     if (index != null) {
       wm.invoke (target, new Object[] {index, propVal});
     } else {
       wm.invoke (target, new Object[] {propVal});
     }
   }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.bsf.util;

	import org.apache.bsf.BSFManager; // rgf, 20070917

	import java.beans.BeanInfo;
	import java.beans.Beans;
	import java.beans.EventSetDescriptor;
	import java.beans.FeatureDescriptor;
	import java.beans.IndexedPropertyDescriptor;
	import java.beans.IntrospectionException;
	import java.beans.Introspector;
	import java.beans.PropertyDescriptor;
	import java.io.IOException;
	import java.lang.reflect.Constructor;
	import java.lang.reflect.Field;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;

	import java.util.TreeSet;
	import java.util.Comparator;
	import java.util.Iterator;

	import org.apache.bsf.util.event.EventAdapter;
	import org.apache.bsf.util.event.EventAdapterRegistry;
	import org.apache.bsf.util.event.EventProcessor;
	import org.apache.bsf.util.type.TypeConvertor;
	import org.apache.bsf.util.type.TypeConvertorRegistry;

	/**
	* This file is a collection of reflection utilities. There are utilities
	* for creating beans, getting bean infos, setting/getting properties,
	* and binding events.
	*
	* @author Sanjiva Weerawarana
	* @author Joseph Kesselman
	*/
	/* 2007-09-21: Rony G. Flatscher, new class loading sequence:

	- supplied class loader (given as an argument)
	- Thread's context class loader
	- BSFManager's defining class loader

	2011-10-29: Rony G. Flatscher, in case an event is not found, create a
	user-friendly error message that lists all available event names

	2011-10-29: Rony G. Flatscher, make sure that the context class loader
	is used only, if not null
	*/
	public class ReflectionUtils {
	// rgf, 20070921: class loaders that we might need to load classes
	static ClassLoader bsfManagerDefinedCL=BSFManager.getDefinedClassLoader();


	//////////////////////////////////////////////////////////////////////////

	/**
	* Add an event processor as a listener to some event coming out of an
	* object.
	*
	* @param source event source
	* @param eventSetName name of event set from event src to bind to
	* @param processor event processor the event should be delegated to
	* when it occurs; either via processEvent or
	* processExceptionableEvent.
	*
	* @exception IntrospectionException if unable to introspect
	* @exception IllegalArgumentException if event set is unknown
	* @exception IllegalAccessException if the event adapter class or
	* initializer is not accessible.
	* @exception InstantiationException if event adapter instantiation fails
	* @exception InvocationTargetException if something goes wrong while
	* running add event listener method
	*/
	public static void addEventListener (Object source, String eventSetName,
	EventProcessor processor)
	throws IntrospectionException, IllegalArgumentException,
	IllegalAccessException, InstantiationException,
	InvocationTargetException {
	// find the event set descriptor for this event
	BeanInfo bi = Introspector.getBeanInfo (source.getClass ());

	EventSetDescriptor arrESD[]=bi.getEventSetDescriptors ();
	EventSetDescriptor esd=(EventSetDescriptor) findFeatureByName ("event", eventSetName, arrESD);

	if (esd == null) // no events found, maybe a proxy from OpenOffice.org?
	{
	String errMsg="event set '" + eventSetName +"' unknown for source type '" + source.getClass () + "': ";
	if (arrESD.length==0) // no event sets found in class!
	{
	errMsg=errMsg+"class does not implement any event methods following Java's event pattern!";
	}
	else
	{
	// errMsg=errMsg+"class defines the following event set(s): {";
	errMsg=errMsg+"class defines the following event set(s): ";

	// sort ESD by Name
	TreeSet ts=new TreeSet(new Comparator () {
	public int compare(Object o1, Object o2) {return ((EventSetDescriptor)o1).getName().compareToIgnoreCase(((EventSetDescriptor)o2).getName());}
	public boolean equals(Object o1, Object o2) {return ((EventSetDescriptor)o1).getName().equalsIgnoreCase (((EventSetDescriptor)o2).getName());}
	});

	for (int i=0;i<arrESD.length;i++)
	{
	ts.add(arrESD[i]);
	}
	Iterator it=ts.iterator(); // get iterator

	int i=0;
	while (it.hasNext()) // iterate in sorted order
	{
	EventSetDescriptor tmpESD=(EventSetDescriptor) it.next();

	if (i>0)
	{
	errMsg=errMsg+", ";
	}
	errMsg=errMsg+"\n\t"+'\''+tmpESD.getName()+"'={"; // event set name


	// iterate over listener methods and display their names in sorted order
	Method m[]=tmpESD.getListenerMethods();
	TreeSet tsM=new TreeSet(new Comparator () {
	public int compare(Object o1, Object o2) {return ((Method)o1).getName().compareToIgnoreCase(((Method)o2).getName());}
	public boolean equals(Object o1, Object o2) {return ((Method)o1).getName().equalsIgnoreCase (((Method)o2).getName());}
	});

	for (int j=0;j<m.length;j++)
	{
	tsM.add(m[j]);
	}
	Iterator itM=tsM.iterator();

	int j=0;
	while (itM.hasNext())
	{
	if (j>0)
	{
	errMsg=errMsg+',';
	}
	errMsg=errMsg+'\''+((Method) itM.next()).getName()+'\'';
	j++;
	}
	errMsg=errMsg+'}'; // close event method set
	i++;
	}

	errMsg=errMsg+"."; // close set of event sets
	}
	throw new IllegalArgumentException (errMsg);
	}

	// get the class object for the event
	Class listenerType=esd.getListenerType(); // get ListenerType class object from EventSetDescriptor

	// find an event adapter class of the right type
	Class adapterClass = EventAdapterRegistry.lookup (listenerType);
	if (adapterClass == null) {
	throw new IllegalArgumentException ("event adapter for listener type " +
	"'" + listenerType + "' (eventset " +
	"'" + eventSetName + "') unknown");
	}

	// create the event adapter and give it the event processor
	EventAdapter adapter = (EventAdapter) adapterClass.newInstance ();
	adapter.setEventProcessor (processor);

	// bind the adapter to the source bean
	Method addListenerMethod;
	Object[] args;
	if (eventSetName.equals ("propertyChange") \|\|
	eventSetName.equals ("vetoableChange")) {
	// In Java 1.2, beans may have direct listener adding methods
	// for property and vetoable change events which take the
	// property name as a filter to be applied at the event source.
	// The filter property of the event processor should be used
	// in this case to support the source-side filtering.
	//
	// TBD : the following two lines need to change appropriately
	addListenerMethod = esd.getAddListenerMethod ();
	args = new Object[] {adapter};
	}
	else
	{
	addListenerMethod = esd.getAddListenerMethod ();
	args = new Object[] {adapter};
	}
	addListenerMethod.invoke (source, args);
	}
	//////////////////////////////////////////////////////////////////////////



	/**
	* Create a bean using given class loader and using the appropriate
	* constructor for the given args of the given arg types.

	* @param cld the class loader to use. If null, Class.forName is used.
	* @param className name of class to instantiate
	* @param argTypes array of argument types
	* @param args array of arguments
	*
	* @return the newly created bean
	*
	* @exception ClassNotFoundException if class is not loaded
	* @exception NoSuchMethodException if constructor can't be found
	* @exception InstantiationException if class can't be instantiated
	* @exception IllegalAccessException if class is not accessible
	* @exception IllegalArgumentException if argument problem
	* @exception InvocationTargetException if constructor excepted
	* @exception IOException if I/O error in beans.instantiate
	*/
	public static Bean createBean (ClassLoader cld, String className,
	Class[] argTypes, Object[] args)
	throws ClassNotFoundException, NoSuchMethodException,
	InstantiationException, IllegalAccessException,
	IllegalArgumentException, InvocationTargetException,
	IOException {
	if (argTypes != null) {

	// if class loader given, use that one, else try
	// the Thread's context class loader (if set) and then
	// the BSFMananger defining class loader
	Class cl=null;
	ClassNotFoundException exCTX=null;

	// -----------------------------
	if (cld != null) { // class loader supplied as argument
	try { // CL passed as argument
	cl=cld.loadClass(className);
	}
	catch (ClassNotFoundException e02) {
	exCTX=e02;
	}
	}

	if (cl==null) {
	// load context class loader, only use it, if not null
	ClassLoader tccl=Thread.currentThread().getContextClassLoader();
	if (tccl!=null) {
	try { // CTXCL
	cl=tccl.loadClass(className);
	}
	catch (ClassNotFoundException e01) {}
	}
	}

	if (cl==null) { // class not loaded yet
	// defined CL
	if (cld != bsfManagerDefinedCL) { // if not used already, attempt to load
	cl=bsfManagerDefinedCL.loadClass(className);
	}
	else { // classloader was already used, hence re-throw exception
	throw exCTX; // re-throw very first exception
	}
	}
	// -----------------------------

	Constructor c = MethodUtils.getConstructor (cl, argTypes);
	return new Bean (cl, c.newInstance (args));
	} else {
	// create the bean with no args constructor
	Object obj = Beans.instantiate (cld, className);
	return new Bean (obj.getClass (), obj);
	}
	}
	//////////////////////////////////////////////////////////////////////////

	/**
	* Create a bean using given class loader and using the appropriate
	* constructor for the given args. Figures out the arg types and
	* calls above.

	* @param cld the class loader to use. If null, Class.forName is used.
	* @param className name of class to instantiate
	* @param args array of arguments
	*
	* @return the newly created bean
	*
	* @exception ClassNotFoundException if class is not loaded
	* @exception NoSuchMethodException if constructor can't be found
	* @exception InstantiationException if class can't be instantiated
	* @exception IllegalAccessException if class is not accessible
	* @exception IllegalArgumentException if argument problem
	* @exception InvocationTargetException if constructor excepted
	* @exception IOException if I/O error in beans.instantiate
	*/
	public static Bean createBean (ClassLoader cld, String className, Object[] args)
	throws ClassNotFoundException, NoSuchMethodException,
	InstantiationException, IllegalAccessException,
	IllegalArgumentException, InvocationTargetException,
	IOException {
	Class[] argTypes = null;
	if (args != null) {
	argTypes = new Class[args.length];
	for (int i = 0; i < args.length; i++) {
	argTypes[i] = (args[i] != null) ? args[i].getClass () : null;
	}
	}
	return createBean (cld, className, argTypes, args);
	}
	//////////////////////////////////////////////////////////////////////////

	/**
	* locate the item in the fds array whose name is as given. returns
	* null if not found.
	*/
	private static
	FeatureDescriptor findFeatureByName (String featureType, String name,
	FeatureDescriptor[] fds) {
	for (int i = 0; i < fds.length; i++) {
	if (name.equals (fds[i].getName())) {
	return fds[i];
	}
	}
	return null;
	}


	public static Bean getField (Object target, String fieldName)
	throws IllegalArgumentException, IllegalAccessException {
	// This is to handle how we do static fields.
	Class targetClass = (target instanceof Class)
	? (Class) target
	: target.getClass ();

	try {
	Field f = targetClass.getField (fieldName);
	Class fieldType = f.getType ();

	// Get the value and return it.
	Object value = f.get (target);
	return new Bean (fieldType, value);
	} catch (NoSuchFieldException e) {
	throw new IllegalArgumentException ("field '" + fieldName + "' is " +
	"unknown for '" + target + "'");
	}
	}
	//////////////////////////////////////////////////////////////////////////

	/**
	* Get a property of a bean.
	*
	* @param target the object whose prop is to be gotten
	* @param propName name of the property to set
	* @param index index to get (if property is indexed)
	*
	* @exception IntrospectionException if unable to introspect
	* @exception IllegalArgumentException if problems with args: if the
	* property is unknown, or if the property is given an index
	* when its not, or if the property is not writeable, or if
	* the given value cannot be assigned to the it (type mismatch).
	* @exception IllegalAccessException if read method is not accessible
	* @exception InvocationTargetException if read method excepts
	*/
	public static Bean getProperty (Object target, String propName,
	Integer index)
	throws IntrospectionException, IllegalArgumentException,
	IllegalAccessException, InvocationTargetException {
	// find the property descriptor
	BeanInfo bi = Introspector.getBeanInfo (target.getClass ());
	PropertyDescriptor pd = (PropertyDescriptor)
	findFeatureByName ("property", propName, bi.getPropertyDescriptors ());
	if (pd == null) {
	throw new IllegalArgumentException ("property '" + propName + "' is " +
	"unknown for '" + target + "'");
	}

	// get read method and type of property
	Method rm;
	Class propType;
	if (index != null) {
	// if index != null, then property is indexed - pd better be so too
	if (!(pd instanceof IndexedPropertyDescriptor)) {
	throw new IllegalArgumentException ("attempt to get non-indexed " +
	"property '" + propName +
	"' as being indexed");
	}
	IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
	rm = ipd.getIndexedReadMethod ();
	propType = ipd.getIndexedPropertyType ();
	} else {
	rm = pd.getReadMethod ();
	propType = pd.getPropertyType ();
	}

	if (rm == null) {
	throw new IllegalArgumentException ("property '" + propName +
	"' is not readable");
	}

	// now get the value
	Object propVal = null;
	if (index != null) {
	propVal = rm.invoke (target, new Object[] {index});
	} else {
	propVal = rm.invoke (target, null);
	}
	return new Bean (propType, propVal);
	}
	public static void setField (Object target, String fieldName, Bean value,
	TypeConvertorRegistry tcr)
	throws IllegalArgumentException, IllegalAccessException {
	// This is to handle how we do static fields.
	Class targetClass = (target instanceof Class)
	? (Class) target
	: target.getClass ();

	try {
	Field f = targetClass.getField (fieldName);
	Class fieldType = f.getType ();

	// type convert the value if necessary
	Object fieldVal = null;
	boolean okeydokey = true;
	if (fieldType.isAssignableFrom (value.type)) {
	fieldVal = value.value;
	} else if (tcr != null) {
	TypeConvertor cvtor = tcr.lookup (value.type, fieldType);
	if (cvtor != null) {
	fieldVal = cvtor.convert (value.type, fieldType, value.value);
	} else {
	okeydokey = false;
	}
	} else {
	okeydokey = false;
	}
	if (!okeydokey) {
	throw new IllegalArgumentException ("unable to assign '" + value.value +
	"' to field '" + fieldName + "'");
	}

	// now set the value
	f.set (target, fieldVal);
	} catch (NoSuchFieldException e) {
	throw new IllegalArgumentException ("field '" + fieldName + "' is " +
	"unknown for '" + target + "'");
	}
	}
	//////////////////////////////////////////////////////////////////////////

	/**
	* Set a property of a bean to a given value.
	*
	* @param target the object whose prop is to be set
	* @param propName name of the property to set
	* @param index index to set (if property is indexed)
	* @param value the property value
	* @param valueType the type of the above (needed when its null)
	* @param tcr type convertor registry to use to convert value type to
	* property type if necessary
	*
	* @exception IntrospectionException if unable to introspect
	* @exception IllegalArgumentException if problems with args: if the
	* property is unknown, or if the property is given an index
	* when its not, or if the property is not writeable, or if
	* the given value cannot be assigned to the it (type mismatch).
	* @exception IllegalAccessException if write method is not accessible
	* @exception InvocationTargetException if write method excepts
	*/
	public static void setProperty (Object target, String propName,
	Integer index, Object value,
	Class valueType, TypeConvertorRegistry tcr)
	throws IntrospectionException, IllegalArgumentException,
	IllegalAccessException, InvocationTargetException {
	// find the property descriptor
	BeanInfo bi = Introspector.getBeanInfo (target.getClass ());
	PropertyDescriptor pd = (PropertyDescriptor)
	findFeatureByName ("property", propName, bi.getPropertyDescriptors ());
	if (pd == null) {
	throw new IllegalArgumentException ("property '" + propName + "' is " +
	"unknown for '" + target + "'");
	}

	// get write method and type of property
	Method wm;
	Class propType;
	if (index != null) {
	// if index != null, then property is indexed - pd better be so too
	if (!(pd instanceof IndexedPropertyDescriptor)) {
	throw new IllegalArgumentException ("attempt to set non-indexed " +
	"property '" + propName +
	"' as being indexed");
	}
	IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
	wm = ipd.getIndexedWriteMethod ();
	propType = ipd.getIndexedPropertyType ();
	} else {
	wm = pd.getWriteMethod ();
	propType = pd.getPropertyType ();
	}

	if (wm == null) {
	throw new IllegalArgumentException ("property '" + propName +
	"' is not writeable");
	}

	// type convert the value if necessary
	Object propVal = null;
	boolean okeydokey = true;
	if (propType.isAssignableFrom (valueType)) {
	propVal = value;
	} else if (tcr != null) {
	TypeConvertor cvtor = tcr.lookup (valueType, propType);
	if (cvtor != null) {
	propVal = cvtor.convert (valueType, propType, value);
	} else {
	okeydokey = false;
	}
	} else {
	okeydokey = false;
	}
	if (!okeydokey) {
	throw new IllegalArgumentException ("unable to assign '" + value +
	"' to property '" + propName + "'");
	}

	// now set the value
	if (index != null) {
	wm.invoke (target, new Object[] {index, propVal});
	} else {
	wm.invoke (target, new Object[] {propVal});
	}
	}
	}