/*

 Wotonomy: OpenStep design patterns for pure Java applications.

 Copyright (C) 2000 Michael Powers

 This library is free software; you can redistribute it and/or

 modify it under the terms of the GNU Lesser General Public

 License as published by the Free Software Foundation; either

 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,

 but WITHOUT ANY WARRANTY; without even the implied warranty of

 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public

 License along with this library; if not, see http://www.gnu.org

 */

 package net.wotonomy.foundation.internal;

 import java.lang.reflect.Field;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.Hashtable;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 /**

 * This Introspector is a static utility class written to work

 * around limitations in PropertyDescriptor and Introspector.<br><br>

 *

 * Of particular note are the get() and set() methods, which will attempt

 * to get and set artibrary values on arbitrary objects to the best of its

 * ability, converting values as appropriate.  Properties of the form

 * "property.nestedproperty.anotherproperty" are supported to get and set

 * values on property values directly.<br><br>

 *

 * Note that for naming getter methods, this class supports "get", "is",

 * and also the property name itself, which supports NeXT-style properties.

 * Introspector supports Maps by treating the keys a property names,

 * supports Lists by treating the indexes as property names. <br><br>

 *

 * Numeric and boolean types can be inverted by prepending a "!" before

 * the name of the property, like "manager.!active" or "task.!lag".

 *

 * @author michael@mpowers.net

 * @author $Author: cgruber $

 * @version $Revision: 893 $

 */

 public class Introspector

 {

     // allows "hasProperty" or "property" forms

     public static boolean strict = false; 

         // print exception stack traces

         private static boolean debug = true;

         // path separator

         public static final String SEPARATOR = ".";

     // method cache - use hashtables for thread safety

     private static Map getterMethods = new Hashtable();

     private static Map setterMethods = new Hashtable();

     // wildcard value - using this class to represent a "wildcard" generic class.

     //      we have to do this when matching methods by parameter types and a

     //      null value is passed in - can't tell what class the null should be.

     public static Class WILD = Introspector.class;

     // empty class array - prevents having to create one every time

     private static final Class[] EMPTY_CLASS_ARRAY = new Class[0];

     // use OGNL for property access

     private static boolean useOGNL;

     static

     {

         try

         {

             useOGNL = ( Class.forName( "ognl.Ognl" ) != null );

         } 

         catch ( ClassNotFoundException t )

         {

             useOGNL = false;

         }

     }

 /**

 * Utility method to get the read method for a property belonging to a class.

 * Will search for methods in the form of "getProperty" and failing that

 * "isProperty" (to handle booleans).

 * @param objectClass the class whose property methods will be retrieved.

 * @param aProperty The property whose method will be retrieved.

 * @param paramTypes An array of class objects representing the types of parameters.

 * @return The appropriate method for the class, or null if not found.

 */

     static public Method getPropertyReadMethod(

         Class objectClass, String aProperty, Class[] paramTypes )

     {

         Method result = null;

         result = getMethodFromClass( objectClass, aProperty, paramTypes, true );

         return result;

     }

 /**

 * Utility method to get the write method for a property belonging to a class.

 * Will search for methods in the form of "setProperty".

 * @param objectClass the class whose property methods will be retrieved.

 * @param aProperty The property whose method will be retrieved.

 * @param paramTypes An array of class objects representing the types of parameters.

 * @return The appropriate method for the class, or null if not found.

 */

     static public Method getPropertyWriteMethod(

         Class objectClass, String aProperty, Class[] paramTypes )

     {

         Method result = null;

         result = getMethodFromClass( objectClass, aProperty, paramTypes, false );

         return result;

     }

 /**

 * Gets a named method from a class.  Using this method is preferred because

 * the results are cached and should be faster than calling Class.getMethod().

 * Note that if an object has a "get" getter method and an "is" getter method

 * with the same signature defined for a given property.  The "get" method

 * is called.

 * @param objectClass the Class whose property methods will be retrieved.

 * @param aMethodName A String containing the name of the desired method.

 * @param paramTypes An array of class objects representing the types of parameters.

 * @return The appropriate Method from the Class, or null if not found.

 */

     static private Method getMethodFromClass(

         Class objectClass, String aProperty, Class[] paramTypes, boolean doGetter)

     { // System.out.print( "Introspector.getMethodFromClass: " + aMethodName + " : " );

         Map classesToMethods = (doGetter ?

                                 getterMethods :

                                 setterMethods);

         Map allMethods = (Map) classesToMethods.get( objectClass );

         if (allMethods == null)

         {

             // need to build maps for this class

             mapPropertiesForClass( objectClass );

             // now the map should exist

             allMethods = (Map) classesToMethods.get( objectClass );

         }

         Method[] methods = (Method[]) allMethods.get( aProperty );

         if ( methods == null )

         {

             return null; // property doesn't exist 

         }

         methods_loop: // walks through all methods for name

         for ( int i = 0; i < methods.length; i++ )

         {

             Class[] types = methods[i].getParameterTypes();

             // if parameter lengths don't match

             if ( types.length != paramTypes.length )

             {

                 // System.out.println( aMethodName + " : " + types.length + " != " + paramTypes.length );

                 continue methods_loop; // continue with outer loop

             }

             // match up each parameter

             for ( int j = 0; j < types.length; j++ )

             {

                 // convert primitives so they'll match - ugly

                 // (would have thought isAssignableFrom() would catch this)

                 if ( types[j].isPrimitive() )

                 {

                     if ( types[j] == Boolean.TYPE )

                     {

                         types[j] = Boolean.class;

                     }

                     else

                     if ( types[j] == Character.TYPE )

                     {

                         types[j] = Character.class;

                     }

                     else

                     if ( types[j] == Byte.TYPE )

                     {

                         types[j] = Byte.class;

                     }

                     else

                     if ( types[j] == Short.TYPE )

                     {

                         types[j] = Short.class;

                     }

                     else

                     if ( types[j] == Integer.TYPE )

                     {

                         types[j] = Integer.class;

                     }

                     else

                     if ( types[j] == Long.TYPE )

                     {

                         types[j] = Long.class;

                     }

                     else

                     if ( types[j] == Float.TYPE )

                     {

                         types[j] = Float.class;

                     }

                     else

                     if ( types[j] == Double.TYPE )

                     {

                         types[j] = Double.class;

                     }

                 }

                 // if parameters don't match

                 if ( ( paramTypes[j] != WILD ) && ( ! types[j].isAssignableFrom( paramTypes[j] ) ) )

                 {

 //                          System.out.println( "Introspector.getMethodFromClass: " +

 //                              aProperty + " : " + types[j] + " != " + paramTypes[j] );

                     continue methods_loop; // continue with outer loop

                 }

             }

             // all params match

             return methods[i];

         }

         // no match

         return null;

     }

     static private final Method[] getAllMethodsForClass( Class aClass )

     {

         Method[] local = aClass.getDeclaredMethods(); // only local

         Method[] all = aClass.getMethods(); // all public

         Method[] result = new Method[ local.length + all.length ];

         System.arraycopy( local, 0, result, 0, local.length );

         System.arraycopy( all, 0, result, local.length, all.length );

         return result;

     }

     /**

     * Generates a map of properties to both getter or setter methods for the given class.

     * Then assigned those maps into the appropriate getterMethods and setterMethods maps

     * keyed by the specified class.  Even on error, this method will at least place empty 

     * property maps into each of the methods maps.

     */

     static private void mapPropertiesForClass( Class objectClass )

     {

         try

         {

             Map readProperties = new HashMap();

             getterMethods.put( objectClass, readProperties );

             Map writeProperties = new HashMap();

             setterMethods.put( objectClass, writeProperties );

             String name, property;

             Method[] methods = getAllMethodsForClass( objectClass ); // throws SecurityException

             for ( int i = 0; i < methods.length; i++ )

             {

                 name = methods[i].getName();

                 methods[i].setAccessible( true ); // throws SecurityException

                 if ( name.startsWith( "set" ) )

                 {

                     name = name.substring( 3 );

                     if ( ! "".equals( name ) ) // excludes "set()"

                     {

                         putMethodIntoPropertyMap( name, methods[i], writeProperties );

                     }

                 }

                 else

                 if ( methods[i].getReturnType() != void.class )

                 {

                     String fullname = name; 

                     if ( name.startsWith( "get" ) )

                     {

                         name = name.substring( 3 );

                     }

                     else

                     if ( name.startsWith( "is" ) )

                     {

                         name = name.substring( 2 );

                     }

                     else

                     if ( name.startsWith( "has" ) && ( !strict ) ) // what about hashCode()?

                     {

                         name = name.substring( 3 );

                     }

                     if ( ! "".equals( name ) && ( !strict ) ) // excludes "get()", "has()", and "is()"

                     {

                         putMethodIntoPropertyMap( name, methods[i], readProperties );

                         if ( fullname != name )

                         { // allows us to match properties that include the get/set prefix as well

                             putMethodIntoPropertyMap( fullname, methods[i], readProperties );

                         }

                     }

                 }

             }

         }

         catch ( SecurityException se )

         {

             System.out.println( "Introspector.getMethodFromClass: " + se );

             // this class will show up with empty getter/setter maps

         }

     }

     /**

     * Places a property-method pair into one of the properties maps.

     * This in effect maps a property to an array of methods.

     */

     private static void putMethodIntoPropertyMap( String aProperty, Method aMethod, Map aMap )

     {

         // ensure first character is lower case

         StringBuffer buffer = new StringBuffer( aProperty );

         buffer.setCharAt(0, Character.toLowerCase(buffer.charAt(0)));

         String key = buffer.toString();

         // build array of methods for property

         Method[] result = (Method[]) aMap.get( key );

         if ( result == null )

         {

             result = new Method[] { aMethod };

         }

         else

         {

             // create new array that's larger by one and copy 

             int i;

             Method[] enlarged = new Method[ result.length + 1 ];

             for ( i = 0; i < result.length; i ++ )

             {

                 enlarged[i] = result[i];

             }

             // add the new method to end

             enlarged[i] = aMethod;

             result = enlarged;

         }

         aMap.put( key, result );

     }

 /**

 * Utility method to get a method for a property belonging to a class.

 * Use this if you don't feel like making the Class array from the parameters

 * you will be using - pass in the parameters themselves.

 * @param objectClass the Class whose property methods will be retrieved.

 * @param aProperty The property whose method will be retrieved.

 * @param params An array of parameters to be used.

 * @return The appropriate method for the class, or null if not found.

 */

     static public Method getPropertyReadMethod(

         Class objectClass, String aProperty, Object[] params )

    {

         // optimization: avoid allocating class array for common case

         if ( params.length == 0 )

         {

             return getPropertyReadMethod( 

                 objectClass, aProperty, EMPTY_CLASS_ARRAY );    

         }

         Class[] paramList = new Class[ params.length ];

         for ( int i = 0; i < params.length; i++ )

         {

             if ( params[i] != null )

             {

                 paramList[i] = params[i].getClass();

             }

             else

             {

                 paramList[i] = WILD;

             }

         }

         return getPropertyReadMethod( objectClass, aProperty, paramList );

    }

 /**

 * Utility method to get a method for a property belonging to a class.

 * Use this if you don't feel like making the Class array from the parameters

 * you will be using - pass in the parameters themselves.

 * @param objectClass the Class whose property methods will be retrieved.

 * @param aProperty The property whose method will be retrieved.

 * @param params An array of parameters to be used.

 * @return The appropriate method for the class, or null if not found.

 */

     static public Method getPropertyWriteMethod(

         Class objectClass, String aProperty, Object[] params )

    {

         Class[] paramList = new Class[ params.length ];

         for ( int i = 0; i < params.length; i++ )

         {

             if ( params[i] != null )

             {

                 paramList[i] = params[i].getClass();

             }

             else

             {

                 paramList[i] = WILD;

             }

         }

         return getPropertyWriteMethod( objectClass, aProperty, paramList );

    }

     /**

     * Gets a list of the readable properties for the given class.

     * Note that readable properties may not be writable - see getWriteProperties().

     * @return An array of property names in no particular order 

     * where each name is a string with the first character in lower case.

     */   

     public static String[] getReadPropertiesForClass( Class objectClass )

     {

         Map properties = (Map) getterMethods.get( objectClass );

         if ( properties == null )

         {

             // need to build maps for this class

             mapPropertiesForClass( objectClass );

             // now the map should exist

             properties = (Map) getterMethods.get( objectClass );

         }

         // put property names into string array

         Set keys = properties.keySet();

         Iterator it = keys.iterator();

         int len = keys.size();

         String[] result = new String[ len ];

         for ( int i = 0; i < len; i++ )

         {

             result[i] = (String) it.next();

         }

         return result;

     }

     /**

     * Gets a list of the writable properties for the given class.

     * Note that writable properties may not be writable - see getReadProperties().

     * @return An array of property names in no particular order 

     * where each name is a string with the first character in lower case.

     */   

     public static String[] getWritePropertiesForClass( Class objectClass )

     {

         Map properties = (Map) setterMethods.get( objectClass );

         if ( properties == null )

         {

             // need to build maps for this class

             mapPropertiesForClass( objectClass );

             // now the map should exist

             properties = (Map) setterMethods.get( objectClass );

         }

         // put property names into string array

         Set keys = properties.keySet();

         Iterator it = keys.iterator();

         int len = keys.size();

         String[] result = new String[ len ];

         for ( int i = 0; i < len; i++ )

         {

             result[i] = (String) it.next();

         }

         return result;

     }

     /**

     * Gets a list of the readable properties for the given object, which may

     * not be null.  This method is more useful than getReadPropertiesForClass

     * in that Maps will return their keys as properties and Lists will return

     * their element indices as properties.

     * Note that readable properties may not be writable - see getWriteProperties().

     * @return An array of property names in no particular order 

     * where each name is a string with the first character in lower case.

     */   

     public static String[] getReadPropertiesForObject( Object anObject )

     {

         List properties = new ArrayList();

         String[] classProperties = 

             getReadPropertiesForClass( anObject.getClass() );

         if ( anObject instanceof List )

         {

             properties.addAll( getPropertiesForList( (List) anObject ) );

         }

         if ( anObject instanceof Map )

         {

             properties.addAll( getPropertiesForMap( (Map) anObject ) );

         }

         int i;

         int len = classProperties.length + properties.size();

         String[] result = new String[ len ];

         for ( i = 0; i < classProperties.length; i++ )

         {

             result[i] = classProperties[i];

         }

         Iterator it = properties.iterator();

         while ( it.hasNext() ) 

         {

             result[i++] = it.next().toString();

         }

         return result;

     }

     /**

     * Gets a list of the writable properties for the given object, which may

     * not be null.  This method is more useful than getWritePropertiesForClass

     * in that Maps will return their keys as properties and Lists will return

     * their element indices as properties.

     * Note that writable properties may not be writable - see getReadProperties().

     * @return An array of property names in no particular order 

     * where each name is a string with the first character in lower case.

     */   

     public static String[] getWritePropertiesForObject( Object anObject )

     {

         List properties = new ArrayList();

         String[] classProperties = 

             getWritePropertiesForClass( anObject.getClass() );

         if ( anObject instanceof List )

         {

             properties.addAll( getPropertiesForList( (List) anObject ) );

         }

         if ( anObject instanceof Map )

         {

             properties.addAll( getPropertiesForMap( (Map) anObject ) );

         }

         int i;

         int len = classProperties.length + properties.size();

         String[] result = new String[ len ];

         for ( i = 0; i < classProperties.length; i++ )

         {

             result[i] = classProperties[i];

         }

         Iterator it = properties.iterator();

         while ( it.hasNext() ) 

         {

             result[i++] = it.next().toString();

         }

         return result;

     }

     private static List getPropertiesForList( List aList )

     {

         List result = new ArrayList();

         int len = aList.size();

         for ( int i = 0; i < len; i++ )

         {

             result.add( new Integer( i ).toString() );

         }

         return result;

     }

     private static List getPropertiesForMap( Map aMap )

     {

         List result = new ArrayList();

         Iterator it = ((Map)aMap).keySet().iterator();

         while ( it.hasNext() )

         {

             result.add( it.next().toString() );

         }

         return result;

     }

     private static Object[] EMPTY_ARRAY = new Object[0];

     /**

     * Convenience to get a value for a property from an object.

     * An empty property string is considered the identity property

     * and simply returns the object.

     * @throws MissingPropertyException if the property cannot be 

     * found on the object.

     */

     public static Object getValueForObject( Object anObject, String aProperty )

     {

         if ( ( aProperty == null ) || ( "".equals( aProperty ) ) )

         {

             return anObject;

         }

         if ( useOGNL && aProperty.startsWith( "ognl:" ) )

         {

             try

             {

                 return ognl.Ognl.getValue( aProperty, anObject );

             }

             catch ( Throwable t )

             {

                 if ( debug )

                 {

                     System.err.println(

                         "Introspector.getValueForObject: " 

                         + anObject + "' ( " + anObject.getClass() + " )" 

                         + ", ognl:" + aProperty  );

                     System.err.println( t );

                 }                    

                 return null;

             }

         }

         boolean invert = false;

         if ( aProperty.startsWith( "!" ) )

         {

             aProperty = aProperty.substring(1);

             invert = true;

         }

         Object result = null;

             try

             {

                     Method m = Introspector.getPropertyReadMethod(

                             anObject.getClass(), aProperty, EMPTY_ARRAY );

                     if ( m != null )

                     {

                                 result = m.invoke( anObject, EMPTY_ARRAY );

                         }

             else // no method, try for field

             {

                 try

                 {

                     Field field = anObject.getClass().getDeclaredField( aProperty );

                     if ( field != null )

                     {

                         field.setAccessible( true ); // throws SecurityException

                         result = field.get( anObject );

                     }

                 }

                 catch ( Throwable t )

                 {

                     // ignore for now

                 }

             }

             if ( result == null )

             {

                 if ( anObject instanceof Map )

                 {

                     result = ((Map)anObject).get( aProperty );

                 }

                 else

                 if ( anObject instanceof List )

                 {

                     result = ((List)anObject).get( Integer.parseInt( aProperty ) );

                 }

             }

             if ( invert )

             {

                 Object inverted = ValueConverter.invert( result );

                 if ( inverted != null ) result = inverted;

             }

             //System.out.println( "getValueForObject: " + anObject + " : " + aProperty + " : " + result );

             return result;

             } 

             catch ( Throwable exc )

             {

             if ( exc instanceof InvocationTargetException )

             {

                 exc = ((InvocationTargetException)exc).getTargetException();   

             }

             if ( exc instanceof RuntimeException )

             {

                 throw (RuntimeException)exc;   

             }

                         if ( debug )

                         {

                                 System.out.println(

                                         "Introspector.getValueForObject: " 

                                         + anObject + "' ( " + anObject.getClass() + " )" 

                                         + ", " + aProperty + ": " );

             }                    

             throw new WotonomyException( exc );

             }

 //!                throw new MissingPropertyException();

     }            

     /**

     * Convenience to set a value for a property from an object.

     * Returns the return value from executing the specified method,

     * or null if the method returns type void.

     * @throws MissingPropertyException if the property cannot be 

     * found on the object.

     * @throws NullPrimitiveException if the property is of primitive 

     * type and the value is null.

     */

     public static Object setValueForObject( 

             Object anObject, String aProperty, Object aValue )

     {

         if ( useOGNL && aProperty.startsWith( "ognl:" ) )

         {

             try

             {

                 ognl.Ognl.setValue( aProperty, anObject, aValue );

             }

             catch ( Throwable t )

             {

                 if ( debug )

                 {

                     System.err.println(

                         "Introspector.setValueForObject: " 

                         + anObject + "' ( " + anObject.getClass() + " )" 

                         + ", ognl:" + aProperty + " : " + aValue );

                     System.err.println( t );

                 }                    

             }

             return null;

         }

             try

             {

             if ( aProperty.startsWith( "!" ) )

             {

                 aProperty = aProperty.substring(1);

                 Object inverted = ValueConverter.invert( aValue );

                 if ( inverted != null ) aValue = inverted;

             }

             Method m = null;

             if ( aValue != null )

             {

                 m = Introspector.getPropertyWriteMethod(

                     anObject.getClass(), aProperty, new Class[] { aValue.getClass() } );

             }

             if ( m == null )

             {

                 m = Introspector.getPropertyWriteMethod(

                     anObject.getClass(), aProperty, new Class[] { WILD } );

                 if ( ( m != null ) && ( aValue != null ) )

                 {

                     // check for null primitive

                     if ( ( aValue == null ) && 

                     ( m.getParameterTypes()[0].isPrimitive() ) )

                     {

                         throw new NullPrimitiveException();

                     }

                     // convert if possible

                     Object o = ValueConverter.convertObjectToClass( 

                         aValue, m.getParameterTypes()[0] );

                     if ( o != null )

                     {

                         aValue = o;

                     }

                 }

             }

                     if ( m != null )

                     {

                                 return m.invoke( anObject, new Object[] { aValue } );

                         }

             else // no method, try for field

             {

                 try

                 {

                     Field field = anObject.getClass().getDeclaredField( aProperty );

                     if ( field != null )

                     {

                         field.setAccessible( true ); // throws SecurityException

                         field.set( anObject, aValue );

                         return null;

                     }

                 }

                 catch ( Throwable t )

                 {

                     // ignore for now

                 }

             }

                         if ( anObject instanceof Map )

                         {

                                 return ((Map)anObject).put( aProperty, aValue );

                         }

                         if ( anObject instanceof List )

                         {

                 List list = (List) anObject;

                 int i = Integer.parseInt( aProperty );

                 if ( list.size() < i+1 )

                 {

                     // expand list as necessary

                     for ( int j = list.size(); j <= i; j++ )

                     {

                         list.add( new Object() ); // placeholder

                     }

                 }

                                 return list.set( i, aValue );

                         }

             } 

             catch ( Throwable exc )

             {

             if ( exc instanceof IllegalArgumentException )

             {

                                 System.out.println(

                                         "Introspector.setValueForObject: " 

                                         + anObject + " , " + aProperty + " , '" 

                                         + aValue + "' ):" );

                                 System.out.println( exc );

             }

             else

             if ( exc instanceof InvocationTargetException )

             {

                 exc = ((InvocationTargetException)exc).getTargetException();   

             }

             if ( exc instanceof RuntimeException )

             {

                 throw (RuntimeException)exc;   

             }

                         if ( debug )

                         {

                                 System.out.println(

                                         "Introspector.setValueForObject: " 

                                         + anObject + " , " + aProperty + " , '" 

                                         + aValue + "' ):" );

                         }

             throw new WotonomyException( exc );

             }

         return null;        

 //!                throw new MissingPropertyException();

     }            

     /**

     * Gets a value from an object or any of its child objects.

         * This will parse the property string for "."'s and get 

         * values for each successive object's property in the path.

     * An empty property string is considered the identity property

     * and simply returns the object.

     */

     public static Object get( Object anObject, String aProperty )

     {

                 int i = aProperty.indexOf( SEPARATOR );

                 if ( i == -1 ) return getValueForObject( anObject, aProperty );

                 String pathElement = aProperty.substring( 0, i );

                 String remainder = aProperty.substring( i+1 );

                 Object result = getValueForObject( anObject, pathElement );

                 if ( result == null ) return null;

                 return get( result, remainder );

     }

     /**

     * Sets a value in an object or any of its child objects.

         * This will parse the property string for "."'s and set 

         * values for each successive object's property in the path.<br><br>

         *

         * If a property is not found, this method will try to 

         * implicitly create hash maps (if possible) to fill out the path.

         * This is useful when dealing with trees of nested maps.

     */

     public static Object set( Object anObject, String aProperty, Object aValue )

     {

                 int i = aProperty.indexOf( SEPARATOR );

                 if ( i == -1 ) return setValueForObject( anObject, aProperty, aValue );

                 String pathElement = aProperty.substring( 0, i );

                 String remainder = aProperty.substring( i+1 );

                 Object result = getValueForObject( anObject, pathElement );

                 if ( result == null ) 

                 {

                         result = new HashMap(2);

                         setValueForObject( anObject, pathElement, result );

                 }

                 return set( result, remainder, aValue );

     }

         /**

         * If set to true, exceptions printed to System.out.println.

         * Defaults to true.

         */

         public void setDebug( boolean isDebug )

         {

                 debug = isDebug;

         }        

 }

 /*

  * $Log$

  * Revision 1.2  2006/02/16 13:11:47  cgruber

  * Check in all sources in eclipse-friendly maven-enabled packages.

  *

  * Revision 1.19  2004/02/05 02:20:34  mpowers

  * Added experimental ognl support (if ognl is present).

  *

  * Revision 1.18  2003/03/26 16:44:35  mpowers

  * Now correctly reflecting on all methods, not just locally declared ones.

  *

  * Revision 1.17  2003/02/21 21:10:51  mpowers

  * Now reaching package, protected, and private methods and fields.

  *

  * Revision 1.16  2003/01/28 22:11:59  mpowers

  * Now more lenient in resolving properties starting with "is" "get" or "has".

  *

  * Revision 1.15  2003/01/27 15:10:54  mpowers

  * Better handling for illegal argument exceptions.

  *

  * Revision 1.14  2003/01/18 23:30:42  mpowers

  * WODisplayGroup now compiles.

  *

  * Revision 1.13  2002/10/11 15:35:12  mpowers

  * Removed printlns.

  *

  * Revision 1.11  2001/05/02 17:58:41  mpowers

  * Removed debugging code, added comments.

  *

  * Revision 1.10  2001/04/08 21:00:54  mpowers

  * Changes to support new objectsForFetchSpecification scheme.

  *

  * Revision 1.9  2001/03/29 03:30:36  mpowers

  * Refactored duplicator a bit.

  * Disabled MissingPropertyExceptions for now.

  *

  * Revision 1.8  2001/03/28 17:52:45  mpowers

  * Corrected the throws in the docs.

  *

  * Revision 1.7  2001/03/28 17:49:13  mpowers

  * Better exception handling in Introspector.

  *

  * Revision 1.6  2001/03/13 21:40:20  mpowers

  * Improved handling of runtime exceptions.

  *

  * Revision 1.5  2001/03/09 22:06:35  mpowers

  * Now extracting the wrapped exception from InvocationTargetExceptions.

  *

  * Revision 1.4  2001/03/01 20:36:35  mpowers

  * Better error handling and better handling of nulls.

  *

  * Revision 1.3  2001/01/17 16:20:57  mpowers

  * Introspector now handles the identity property.

  *

  * Revision 1.2  2001/01/09 20:08:17  mpowers

  * Slight optimization.

  *

  * Revision 1.1.1.1  2000/12/21 15:52:04  mpowers

  * Contributing wotonomy.

  *

  * Revision 1.5  2000/12/20 16:25:46  michael

  * Added log to all files.

  *

  *

  */