Formatting pass

12 files changed, 2887 insertions, 3351 deletions

diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/Duplicator.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/Duplicator.java
index ddf347d..16ef393 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/Duplicator.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/Duplicator.java
@@ -26,274 +26,219 @@ import java.io.*;
 import java.util.*; //collections
 
 /**
-* Duplicator makes use of Introspector to duplicate objects,
-* either by shallow copy, deep copy, or by copying properties
-* from one object to apply to another object.  You may find this
-* class useful because java.lang.Object.clone() only supports
-* shallow copying.
-*
-* @author michael@mpowers.net
-* @author $Author: cgruber $
-* @version $Revision: 895 $
-*/
+ * Duplicator makes use of Introspector to duplicate objects, either by shallow
+ * copy, deep copy, or by copying properties from one object to apply to another
+ * object. You may find this class useful because java.lang.Object.clone() only
+ * supports shallow copying.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 895 $
+ */
+
+public class Duplicator {
+	/**
+	 * Used to represent null values for properties in the maps returned by
+	 * readProperties and cloneProperties and in the parameter to writeProperties.
+	 * This actually references the NSNull instance.
+	 */
+	public static final Object NULL = NSNull.nullValue();
+	private static NSSelector clone = new NSSelector("clone");
+
+	/**
+	 * Returns a list of properties for the specified class that are both readable
+	 * and writable.
+	 */
+	static public List editablePropertiesForObject(Object anObject) {
+		List readProperties = new ArrayList();
+		String[] read = Introspector.getReadPropertiesForObject(anObject);
+		for (int i = 0; i < read.length; i++) {
+			readProperties.add(read[i]);
+		}
+
+		List properties = new ArrayList();
+		String[] write = Introspector.getWritePropertiesForObject(anObject);
+		for (int i = 0; i < write.length; i++) {
+			properties.add(write[i]);
+		}
+
+		// only use properties on both lists: read/write
+		properties.retainAll(readProperties);
+
+		return properties;
+	}
 
-public class Duplicator
-{
-    /**
-    * Used to represent null values for properties in the
-    * maps returned by readProperties and cloneProperties
-    * and in the parameter to writeProperties.
-    * This actually references the NSNull instance.
-    */
-    public static final Object NULL = NSNull.nullValue();
-    private static NSSelector clone = new NSSelector( "clone" );
+	/**
+	 * Returns a Map containing only the mutable properties for the specified object
+	 * and their values. Any null values for properties will be represented with the
+	 * NULL object.
+	 */
+	static public Map readPropertiesForObject(Object anObject) {
+		NSMutableDictionary result = new NSMutableDictionary();
 
-    /**
-    * Returns a list of properties for the specified class
-    * that are both readable and writable.
-    */
-    static public List editablePropertiesForObject( 
-        Object anObject )
-    {
-        List readProperties = new ArrayList();
-        String[] read = Introspector.getReadPropertiesForObject( anObject );
-        for ( int i = 0; i < read.length; i++ )
-        {
-            readProperties.add( read[i] );
-        }
+		String key;
+		Object value;
+		Iterator it = editablePropertiesForObject(anObject).iterator();
+		while (it.hasNext()) {
+			key = it.next().toString();
+			value = Introspector.get(anObject, key);
+			if (value == null)
+				value = NULL;
+			result.setObjectForKey(value, key);
+		}
+		return result;
+	}
 
-        List properties = new ArrayList();
-        String[] write = Introspector.getWritePropertiesForObject( anObject );
-        for ( int i = 0; i < write.length; i++ )
-        {
-            properties.add( write[i] );
-        }
-        
-        // only use properties on both lists: read/write
-        properties.retainAll( readProperties );
+	/**
+	 * Returns a Map containing only the mutable properties for the specified object
+	 * and deep clones of their values. Nulls are represented by the NULL object.
+	 */
+	static public Map clonePropertiesForObject(Object anObject) {
+		Object key, value;
+		Map result = readPropertiesForObject(anObject);
+		Iterator it = result.keySet().iterator();
+		while (it.hasNext()) {
+			key = it.next();
+			value = result.get(key);
+			value = deepClone(value);
+			result.put(key, value);
+		}
+		return result;
+	}
 
-        return properties;
-    }
-    
-    /**
-    * Returns a Map containing only the mutable properties 
-    * for the specified object and their values.
-    * Any null values for properties will be represented with
-    * the NULL object.
-    */
-    static public Map readPropertiesForObject( 
-        Object anObject )
-    {
-        NSMutableDictionary result = new NSMutableDictionary();
-        
-        String key;
-        Object value;
-        Iterator it = editablePropertiesForObject( anObject ).iterator();
-        while ( it.hasNext() )
-        {
-            key = it.next().toString();
-            value = Introspector.get( anObject, key );
-            if ( value == null ) value = NULL;
-            result.setObjectForKey( value, key );
-        }
-        return result;        
-    }
-    
-    /**
-    * Returns a Map containing only the mutable properties 
-    * for the specified object and deep clones of their values.
-    * Nulls are represented by the NULL object.
-    */
-    static public Map clonePropertiesForObject( 
-        Object anObject )
-    {
-        Object key, value;
-        Map result = readPropertiesForObject( anObject );
-        Iterator it = result.keySet().iterator();
-        while ( it.hasNext() )
-        {
-            key = it.next(); 
-            value = result.get( key );            
-            value = deepClone( value );
-            result.put( key, value );
-        }
-        return result;
-    }
-    
-    /**
-    * Applies the map of properties and values to the
-    * specified object.  Null values for properties must
-    * be represented by the NULL object.
-    */
-    static public void writePropertiesForObject( 
-        Map aMap, Object anObject )
-    {
-        String key;
-        Object value;
-        Iterator it = aMap.keySet().iterator();
-        while ( it.hasNext() )
-        {
-            key = it.next().toString();
-            value = aMap.get( key );
-            if ( NULL.equals( value ) ) value = null;
-            Introspector.set( anObject, key, value );
-        }
-    }    
-    
-    /**
-    * Creates a new copy of the specified object.
-    * This implementation tries to call clone(),
-    * and failing that, calls newInstance
-    * and then calls copy() to transfer the values.
-    * @throws WotonomyException if any operation fails.
-    */ 
-    static public Object clone( 
-        Object aSource )
-    {
-        Object result = null;
-        if ( clone.implementedByObject( aSource ) )
-        {
-            try 
-            {
-                result = clone.invoke( aSource );
-                return result;
-            }
-            catch ( Exception exc )
-            {
-                // fall back on newInstance()
-            }
-        }
-        
-        Class c = aSource.getClass();
-        try 
-        {
-            result = c.newInstance();
-        }
-        catch ( Exception exc )
-        {
-            throw new WotonomyException( exc );
-        }
-        return copy( aSource, result );        
-    }
+	/**
+	 * Applies the map of properties and values to the specified object. Null values
+	 * for properties must be represented by the NULL object.
+	 */
+	static public void writePropertiesForObject(Map aMap, Object anObject) {
+		String key;
+		Object value;
+		Iterator it = aMap.keySet().iterator();
+		while (it.hasNext()) {
+			key = it.next().toString();
+			value = aMap.get(key);
+			if (NULL.equals(value))
+				value = null;
+			Introspector.set(anObject, key, value);
+		}
+	}
 
-    /**
-    * Creates a deep copy of the specified object.
-    * Every object in this objects graph will be
-    * duplicated with new instances.
-    * @throws WotonomyException if any operation fails.
-    */ 
-    static public Object deepClone(
-        Object aSource )
-    {
-        // the only known way to deep copy in
-        // java without native code is serialization
-        
-        try
-        {
-            ByteArrayOutputStream byteOutput =
-                new ByteArrayOutputStream();
-            ObjectOutputStream objectOutput =
-                new ObjectOutputStream( byteOutput );
-                
-            objectOutput.writeObject( aSource );
-            objectOutput.flush();
-            objectOutput.close();
-            
-            ByteArrayInputStream byteInput =
-                new ByteArrayInputStream( byteOutput.toByteArray() );
-            ObjectInputStream objectInput =
-                new ObjectInputStream( byteInput );
-            return objectInput.readObject();
-        } 
-        catch ( Exception exc )
-        {
-            throw new WotonomyException( "Error cloning object: " + aSource, exc );
-        }
-    }
+	/**
+	 * Creates a new copy of the specified object. This implementation tries to call
+	 * clone(), and failing that, calls newInstance and then calls copy() to
+	 * transfer the values.
+	 * 
+	 * @throws WotonomyException if any operation fails.
+	 */
+	static public Object clone(Object aSource) {
+		Object result = null;
+		if (clone.implementedByObject(aSource)) {
+			try {
+				result = clone.invoke(aSource);
+				return result;
+			} catch (Exception exc) {
+				// fall back on newInstance()
+			}
+		}
 
-    /**
-    * Copies values from one object to another.
-    * Returns the destination object.
-    * @throws WotonomyException if any operation fails.
-    */ 
-    static public Object copy( 
-        Object aSource, Object aDestination )
-    {
-        try 
-        {
-            writePropertiesForObject(
-                readPropertiesForObject( aSource ), aDestination );
-        }
-        catch ( RuntimeException exc )
-        {
-            throw new WotonomyException( exc );
-        }
-        return aDestination;        
-    }
-    
-    /**
-    * Deeply clones the values from one object and applies them
-    * to another object.
-    * Returns the destination object.
-    * @throws WotonomyException if any operation fails.
-    */ 
-    static public Object deepCopy( 
-        Object aSource, Object aDestination )
-    {
-        try 
-        {
-            writePropertiesForObject(
-                clonePropertiesForObject( aSource ), aDestination );
-        }
-        catch ( RuntimeException exc )
-        {
-            throw new WotonomyException( exc );
-        }
-        return aDestination;        
-    }
+		Class c = aSource.getClass();
+		try {
+			result = c.newInstance();
+		} catch (Exception exc) {
+			throw new WotonomyException(exc);
+		}
+		return copy(aSource, result);
+	}
+
+	/**
+	 * Creates a deep copy of the specified object. Every object in this objects
+	 * graph will be duplicated with new instances.
+	 * 
+	 * @throws WotonomyException if any operation fails.
+	 */
+	static public Object deepClone(Object aSource) {
+		// the only known way to deep copy in
+		// java without native code is serialization
+
+		try {
+			ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();
+			ObjectOutputStream objectOutput = new ObjectOutputStream(byteOutput);
+
+			objectOutput.writeObject(aSource);
+			objectOutput.flush();
+			objectOutput.close();
+
+			ByteArrayInputStream byteInput = new ByteArrayInputStream(byteOutput.toByteArray());
+			ObjectInputStream objectInput = new ObjectInputStream(byteInput);
+			return objectInput.readObject();
+		} catch (Exception exc) {
+			throw new WotonomyException("Error cloning object: " + aSource, exc);
+		}
+	}
+
+	/**
+	 * Copies values from one object to another. Returns the destination object.
+	 * 
+	 * @throws WotonomyException if any operation fails.
+	 */
+	static public Object copy(Object aSource, Object aDestination) {
+		try {
+			writePropertiesForObject(readPropertiesForObject(aSource), aDestination);
+		} catch (RuntimeException exc) {
+			throw new WotonomyException(exc);
+		}
+		return aDestination;
+	}
+
+	/**
+	 * Deeply clones the values from one object and applies them to another object.
+	 * Returns the destination object.
+	 * 
+	 * @throws WotonomyException if any operation fails.
+	 */
+	static public Object deepCopy(Object aSource, Object aDestination) {
+		try {
+			writePropertiesForObject(clonePropertiesForObject(aSource), aDestination);
+		} catch (RuntimeException exc) {
+			throw new WotonomyException(exc);
+		}
+		return aDestination;
+	}
 }
 
 /*
- * $Log$
- * Revision 1.1  2006/02/16 16:52:12  cgruber
- * Add cvsignore crap to find off checking in binary crap.
+ * $Log$ Revision 1.1 2006/02/16 16:52:12 cgruber Add cvsignore crap to find off
+ * checking in binary crap.
  *
- * Revision 1.1  2006/02/16 13:22:22  cgruber
- * Check in all sources in eclipse-friendly maven-enabled packages.
+ * Revision 1.1 2006/02/16 13:22:22 cgruber Check in all sources in
+ * eclipse-friendly maven-enabled packages.
  *
- * Revision 1.11  2001/08/22 19:24:26  mpowers
- * Providing a more helpful error message for cloning exceptions.
+ * Revision 1.11 2001/08/22 19:24:26 mpowers Providing a more helpful error
+ * message for cloning exceptions.
  *
- * Revision 1.10  2001/03/29 03:30:36  mpowers
- * Refactored duplicator a bit.
+ * Revision 1.10 2001/03/29 03:30:36 mpowers Refactored duplicator a bit.
  * Disabled MissingPropertyExceptions for now.
  *
- * Revision 1.9  2001/03/28 14:11:23  mpowers
- * Removed debugging printlns.
+ * Revision 1.9 2001/03/28 14:11:23 mpowers Removed debugging printlns.
  *
- * Revision 1.8  2001/03/27 23:25:48  mpowers
- * Basically reverting to the previous version.
+ * Revision 1.8 2001/03/27 23:25:48 mpowers Basically reverting to the previous
+ * version.
  *
- * Revision 1.7  2001/03/06 23:18:13  mpowers
- * Clarified some comments.
+ * Revision 1.7 2001/03/06 23:18:13 mpowers Clarified some comments.
  *
- * Revision 1.6  2001/03/01 20:36:35  mpowers
- * Better error handling and better handling of nulls.
+ * Revision 1.6 2001/03/01 20:36:35 mpowers Better error handling and better
+ * handling of nulls.
  *
- * Revision 1.5  2001/02/27 21:43:40  mpowers
- * Removed NullMarker class in favor of NSNull.
+ * Revision 1.5 2001/02/27 21:43:40 mpowers Removed NullMarker class in favor of
+ * NSNull.
  *
- * Revision 1.4  2001/02/26 22:41:51  mpowers
- * Implemented null placeholder classes.
- * Duplicator now uses NSNull.
- * No longer catching base exception class.
+ * Revision 1.4 2001/02/26 22:41:51 mpowers Implemented null placeholder
+ * classes. Duplicator now uses NSNull. No longer catching base exception class.
  *
- * Revision 1.3  2001/02/23 21:07:46  mpowers
- * Documented the NULL object.
+ * Revision 1.3 2001/02/23 21:07:46 mpowers Documented the NULL object.
  *
- * Revision 1.1  2001/02/16 22:51:29  mpowers
- * Now deep-cloning objects passed between editing contexts.
+ * Revision 1.1 2001/02/16 22:51:29 mpowers Now deep-cloning objects passed
+ * between editing contexts.
  *
  *
  */
-
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/Introspector.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/Introspector.java
index 2b313d0..09687e2 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/Introspector.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/Introspector.java
@@ -30,912 +30,750 @@ 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 $
-*/
+ * 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;
 
-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;
-        }
-    }
+	// method cache - use hashtables for thread safety
+	private static Map getterMethods = new Hashtable();
+	private static Map setterMethods = new Hashtable();
 
-/**
-* 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 );
+	// 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;
 
-        return result;
-    }
+	// empty class array - prevents having to create one every time
+	private static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
 
-/**
-* 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 );
+	// use OGNL for property access
+	private static boolean useOGNL;
 
-        return result;
-    }
+	static {
+		try {
+			useOGNL = (Class.forName("ognl.Ognl") != null);
+		} catch (ClassNotFoundException t) {
+			useOGNL = false;
+		}
+	}
 
-/**
-* 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] ) ) )
-                {
+	/**
+	 * 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 );
-    }
+					continue methods_loop; // continue with outer loop
+				}
+			}
 
-/**
-* 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 );
-   }
+			// all params match
+			return methods[i];
+		}
 
-/**
-* 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 );
+		// 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);
+						}
+					}
+				}
 			}
-            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 )
+		} 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
 			{
-				System.out.println(
-					"Introspector.getValueForObject: " 
-					+ anObject + "' ( " + anObject.getClass() + " )" 
-					+ ", " + aProperty + ": " );
-            }                    
-            throw new WotonomyException( exc );
-	    }
+				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 } );
+	}
+
+	/**
+	 * 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);
+				}
 			}
-            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 );
+			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 ( anObject instanceof List )
+			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
 			{
-                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 );
+				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 )
-            {
+		} 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 )
-			{
+						"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 + "' ):" );
+						"Introspector.setValueForObject: " + anObject + " , " + aProperty + " , '" + aValue + "' ):");
 			}
-            throw new WotonomyException( exc );
-	    }
-        return null;        
+			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 ) 
-		{
+	}
+
+	/**
+	 * 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 );
+			setValueForObject(anObject, pathElement, result);
 		}
-		return set( result, remainder, aValue );
-    }
-	
+		return set(result, remainder, aValue);
+	}
+
 	/**
-	* If set to true, exceptions printed to System.out.println.
-	* Defaults to true.
-	*/
-	public void setDebug( boolean isDebug )
-	{
+	 * 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.
+ * $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.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.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.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.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.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.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.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.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.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.
+ * 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.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.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.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.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.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.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.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.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.
+ * Revision 1.5 2000/12/20 16:25:46 michael Added log to all files.
  *
  *
  */
-
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/IntrospectorException.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/IntrospectorException.java
index b1ad824..45080a2 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/IntrospectorException.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/IntrospectorException.java
@@ -19,14 +19,13 @@ License along with this library; if not, see http://www.gnu.org
 package net.wotonomy.foundation.internal;
 
 /**
-* A WotonomyException that is thrown by Introspector.
-* This class serves as a base class for other exceptions.
-*
-* @author michael@mpowers.net
-* @author $Author: cgruber $
-* @version $Revision: 893 $
-*/
+ * A WotonomyException that is thrown by Introspector. This class serves as a
+ * base class for other exceptions.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 893 $
+ */
 
-public class IntrospectorException extends WotonomyException
-{
+public class IntrospectorException extends WotonomyException {
 }
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/MissingPropertyException.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/MissingPropertyException.java
index c1e30d3..c89742f 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/MissingPropertyException.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/MissingPropertyException.java
@@ -19,14 +19,13 @@ License along with this library; if not, see http://www.gnu.org
 package net.wotonomy.foundation.internal;
 
 /**
-* A IntrospectorException that is thrown by Introspector when
-* a property does not exist for an object.
-*
-* @author michael@mpowers.net
-* @author $Author: cgruber $
-* @version $Revision: 893 $
-*/
+ * A IntrospectorException that is thrown by Introspector when a property does
+ * not exist for an object.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 893 $
+ */
 
-public class MissingPropertyException extends IntrospectorException
-{
+public class MissingPropertyException extends IntrospectorException {
 }
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/NetworkClassLoader.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/NetworkClassLoader.java
index 43c14a5..7761876 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/NetworkClassLoader.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/NetworkClassLoader.java
@@ -47,7 +47,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
- */ 
+ */
 
 package net.wotonomy.foundation.internal;
 
@@ -59,310 +59,284 @@ import java.util.Enumeration;
 import java.util.Hashtable;
 
 /**
- * The correct name for this class should be URLClassLoader.
- * But there is already a class by that name in JDK1.2.
+ * The correct name for this class should be URLClassLoader. But there is
+ * already a class by that name in JDK1.2.
  *
- * I have had quite a few problems with URLClassLoader in
- * past, so I ended up writing this ClassLoader. I found that
- * the Java 2's URLClassLoader, does not close the Jar file once
- * opened. It is a pretty good optimization step, but if you
- * modify the class in the jar file, it does not pick it up. Some
- * operating systems may not let you modify the jar file while it is
- * still open. IMHO, it does make sense to close the jar file
- * after you are done reading the class data. But this approach may not
- * get you the performance of the URLClassLoader, but it works in all
- * cases and also runs on JDK1.1. I have enhanced this class loader
- * to read all the zip/jar entries once & cache the data, so that
- * there is no overhead of opening/closing jar file to pick up
+ * I have had quite a few problems with URLClassLoader in past, so I ended up
+ * writing this ClassLoader. I found that the Java 2's URLClassLoader, does not
+ * close the Jar file once opened. It is a pretty good optimization step, but if
+ * you modify the class in the jar file, it does not pick it up. Some operating
+ * systems may not let you modify the jar file while it is still open. IMHO, it
+ * does make sense to close the jar file after you are done reading the class
+ * data. But this approach may not get you the performance of the
+ * URLClassLoader, but it works in all cases and also runs on JDK1.1. I have
+ * enhanced this class loader to read all the zip/jar entries once & cache the
+ * data, so that there is no overhead of opening/closing jar file to pick up
  * each entry.
  *
  *
  * @author Harish Prabandham
  */
 public class NetworkClassLoader extends ClassLoader {
-    private ClassLoader parent = null; // parent classloader
-    private Hashtable classCache = new Hashtable();
-    private Hashtable urlset = new Hashtable();
-
-    /**
-     * Creates a new instance of the class loader.
-     * @param delegate/parent class loader.
-     */
-    public NetworkClassLoader(ClassLoader parent) {
-        setParent(parent);
-    }
-
-    /**
-     * Sets the parent/delegate class loader.
-     * @param delegate/parent class loader.
-     */
-    protected final void setParent(ClassLoader parent) {
-        this.parent = parent;
-    }
-
-    /**
-     * Adds the given URL to this class loader. If the URL
-     * ends with "/", then it is assumed to be a directory
-     * otherwise, it is assumed to be a zip/jar file. If the
-     * same URL is added again, the URL is re-opened and this
-     * zip/jar file is used for serving any future class requests.
-     * @param URL where to look for the classes.
-     */
-    public synchronized void addURL(URL url) {
-        // System.out.println("Adding url: " + url);
-        if(!urlset.containsKey(url)) {
-            try {
-                urlset.put(url, new URLResourceReader(url));
-            }catch(IOException ioe){
-                // Probably a bad url...
-            }
-        } else {
-            // remove the old one & add a new one...
-            try{
-                URLResourceReader newu = new URLResourceReader(url);
-                URLResourceReader oldu = (URLResourceReader) urlset.get(url);
-                oldu.close();
-                urlset.remove(url);
-                urlset.put(url, newu);
-            } catch (IOException ioe) {
-            }
-        }
-    }
-
-    /**
-     * @return An enumeration of  URLs where this class loader
-     * looks for classes.
-     */
-    public Enumeration getURLs() {
-        return urlset.keys();
-    }
-
-    /**
-     * Call this to bypass the implementation of loadClass.
-     */
-    public Class findClass(String name) {
-        byte[] b = loadClassData(name);
-        if ( b == null ) return null;
-        return defineClass(name, b, 0, b.length);
-    }
-
-    protected byte[] loadResource(URL url, String resourceName)
-        throws IOException {
-        URLResourceReader urr = (URLResourceReader) urlset.get(url);
-        // System.out.println("Loading from " + urr + " " + resourceName);
-        if(urr != null) {
-            return urr.getResource(resourceName);
-        }
-
-        return null;
-    }
-
-    protected byte[] loadResource(String resource) {
-        byte[] barray = null;
-        for(Enumeration e = urlset.keys(); e.hasMoreElements();) {
-            URL url = (URL) e.nextElement();
-
-            try {
-                barray = loadResource(url, resource);
-            } catch(Exception ex) {
-            } finally {
-                if(barray != null)
-                    break;
-            }
-        }
-
-        return barray;
-    }
-
-    protected byte[] loadClassData(String classname) {
-        String resourceName = classname.replace('.', '/') + ".class";
-        return loadResource(resourceName);
-    }
-
-    /**
-     * Overridden to search for a resource and return 
-     * a "jar"-style URL or normal "file" URL as necessary.
-     */
-    protected URL findResource(String name) 
-    { //System.out.println( "findResource: " + name ); 
-        URL url;
-        byte[] barray = null;
-        
-        for ( Enumeration e = urlset.keys(); e.hasMoreElements();  ) 
-        {
-            url = (URL) e.nextElement();
-            try 
-            {
-                barray = loadResource(url, name); // loads fully: wasteful
-            } 
-            catch(Exception ex) 
-            {
-                // do nothing
-            } 
-            if( barray != null ) 
-            {
-                try
-                {
-                    String ref = url.toString();
-                    if ( ref.endsWith( ".jar" ) )
-                    {
-                        //System.out.println( "jar:" + ref + "!/" + name );
-                        return new URL( "jar:" + ref + "!/" + name );
-                    }
-                    else
-                    {
-                        //System.out.println( new URL( url, name ).toString() );
-                        return new URL( url, name );
-                    }
-                }
-                catch ( Throwable t )
-                {
-                    t.printStackTrace();
-                }
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * @return The resource as the input stream if such a resource
-     * exists, otherwise returns null.
-     */
-    public InputStream getResourceAsStream(String name) {
-        //System.out.println( "getResourceAsStream: " + name );        
-        InputStream istream = null;
-        
-        // Algorithm:
-        //
-        // 1. first check the system path for the resource
-        // 2. next  check the  delegate/parent class loader for the resource
-        // 3. then attempt to get the resource from the url set.
-        //
-
-        // Lets check the system path for the resource.
-        istream = getSystemResourceAsStream(name);
-        if(istream != null)
-            return istream;
-
-        // Lets check the parent/delegate class loader for the resource.
-        if(parent != null) {
-            istream = parent.getResourceAsStream(name);
-            if(istream != null)
-                return istream;
-        }
-
-        // Lets load it ourselves.
-        byte[] data = loadResource(name);
-        if(data != null) {
-            istream = new ByteArrayInputStream(data);
-        }
-
-        return istream;
-    }
-
-    /**
-     * java.lang.ClassLoader's defineClass method is final, so the
-     * its subclasses cannot override this method. But, this class
-     * calls this method in the loadClass() instead.
-     * @param The name of the class without ".class" extension.
-     * @param The class data bytes.
-     * @return The class object.
-     */
-    protected Class defineClass(String classname, byte[] classdata) {
-        return defineClass(classname, classdata, 0, classdata.length);
-    }
-
-    public synchronized Class loadClass(String name, boolean resolve)
-        throws ClassNotFoundException {
-        Class c = null;
-
-        // Algorithm: (Please do not change the order; unless you
-        // have a good reason to do so).
-        //
-        // 1. first check the system class loader.
-        // 2. next  check the  delegate/parent class loader.
-        // 3. next  check the class cache
-        // 4. then attempt to load classes from the URL set.
-        //
-        
-        // Lets see if the class is in system class loader.
-        try {
-            c = findSystemClass(name);
-        }catch(ClassNotFoundException cnfe) {
-        }finally {
-            if(c != null)
-                return c;
-        }
-
-        // Lets see if the class is in parent class loader.
-        try {
-            if(parent != null)
-                c = parent.loadClass(name);
-        }catch(ClassNotFoundException cnfe) {
-        }finally {
-            if(c != null)
-                return c;
-        }
-
-        // Lets see if the class is in the cache..
-        c = (Class) classCache.get(name);
-
-        if(c != null)
-            return c;
-
-
-        // Lets see if we find the class all by ourselves.
-        byte[] data = loadClassData(name);
-
-        if(data != null) {
-            // we did !!
-            c = defineClass(name, data);
-            classCache.put(name, c);
-            if(resolve)
-                resolveClass(c);
-        } else {
-            // We are out of luck at this point...
-            throw new ClassNotFoundException(name);
-        }
-
-        return c;
-    }
-
-    /**
-     * This method resets this ClassLoader's state. It completely
-     * removes all the URLs and classes in this class loader cache. 
-     */
-    public final void clear() {
-        urlset.clear();
-        classCache.clear();
-    }
-
-    /**
-     * This method resets this ClassLoader's state and resets the
-     * references for garbage collection.
-     */
-    protected void finalize() throws Throwable {
-        // Cleanup real well. Otherwise, this can be
-        // a major source of memory leaks...
-
-        // remove all the urls & class entries.
-        clear();
-        
-        parent = null;
-        urlset = null;
-        classCache = null;
-    }
+	private ClassLoader parent = null; // parent classloader
+	private Hashtable classCache = new Hashtable();
+	private Hashtable urlset = new Hashtable();
+
+	/**
+	 * Creates a new instance of the class loader.
+	 * 
+	 * @param delegate/parent class loader.
+	 */
+	public NetworkClassLoader(ClassLoader parent) {
+		setParent(parent);
+	}
+
+	/**
+	 * Sets the parent/delegate class loader.
+	 * 
+	 * @param delegate/parent class loader.
+	 */
+	protected final void setParent(ClassLoader parent) {
+		this.parent = parent;
+	}
+
+	/**
+	 * Adds the given URL to this class loader. If the URL ends with "/", then it is
+	 * assumed to be a directory otherwise, it is assumed to be a zip/jar file. If
+	 * the same URL is added again, the URL is re-opened and this zip/jar file is
+	 * used for serving any future class requests.
+	 * 
+	 * @param URL where to look for the classes.
+	 */
+	public synchronized void addURL(URL url) {
+		// System.out.println("Adding url: " + url);
+		if (!urlset.containsKey(url)) {
+			try {
+				urlset.put(url, new URLResourceReader(url));
+			} catch (IOException ioe) {
+				// Probably a bad url...
+			}
+		} else {
+			// remove the old one & add a new one...
+			try {
+				URLResourceReader newu = new URLResourceReader(url);
+				URLResourceReader oldu = (URLResourceReader) urlset.get(url);
+				oldu.close();
+				urlset.remove(url);
+				urlset.put(url, newu);
+			} catch (IOException ioe) {
+			}
+		}
+	}
+
+	/**
+	 * @return An enumeration of URLs where this class loader looks for classes.
+	 */
+	public Enumeration getURLs() {
+		return urlset.keys();
+	}
+
+	/**
+	 * Call this to bypass the implementation of loadClass.
+	 */
+	public Class findClass(String name) {
+		byte[] b = loadClassData(name);
+		if (b == null)
+			return null;
+		return defineClass(name, b, 0, b.length);
+	}
+
+	protected byte[] loadResource(URL url, String resourceName) throws IOException {
+		URLResourceReader urr = (URLResourceReader) urlset.get(url);
+		// System.out.println("Loading from " + urr + " " + resourceName);
+		if (urr != null) {
+			return urr.getResource(resourceName);
+		}
+
+		return null;
+	}
+
+	protected byte[] loadResource(String resource) {
+		byte[] barray = null;
+		for (Enumeration e = urlset.keys(); e.hasMoreElements();) {
+			URL url = (URL) e.nextElement();
+
+			try {
+				barray = loadResource(url, resource);
+			} catch (Exception ex) {
+			} finally {
+				if (barray != null)
+					break;
+			}
+		}
+
+		return barray;
+	}
+
+	protected byte[] loadClassData(String classname) {
+		String resourceName = classname.replace('.', '/') + ".class";
+		return loadResource(resourceName);
+	}
+
+	/**
+	 * Overridden to search for a resource and return a "jar"-style URL or normal
+	 * "file" URL as necessary.
+	 */
+	protected URL findResource(String name) { // System.out.println( "findResource: " + name );
+		URL url;
+		byte[] barray = null;
+
+		for (Enumeration e = urlset.keys(); e.hasMoreElements();) {
+			url = (URL) e.nextElement();
+			try {
+				barray = loadResource(url, name); // loads fully: wasteful
+			} catch (Exception ex) {
+				// do nothing
+			}
+			if (barray != null) {
+				try {
+					String ref = url.toString();
+					if (ref.endsWith(".jar")) {
+						// System.out.println( "jar:" + ref + "!/" + name );
+						return new URL("jar:" + ref + "!/" + name);
+					} else {
+						// System.out.println( new URL( url, name ).toString() );
+						return new URL(url, name);
+					}
+				} catch (Throwable t) {
+					t.printStackTrace();
+				}
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * @return The resource as the input stream if such a resource exists, otherwise
+	 *         returns null.
+	 */
+	public InputStream getResourceAsStream(String name) {
+		// System.out.println( "getResourceAsStream: " + name );
+		InputStream istream = null;
+
+		// Algorithm:
+		//
+		// 1. first check the system path for the resource
+		// 2. next check the delegate/parent class loader for the resource
+		// 3. then attempt to get the resource from the url set.
+		//
+
+		// Lets check the system path for the resource.
+		istream = getSystemResourceAsStream(name);
+		if (istream != null)
+			return istream;
+
+		// Lets check the parent/delegate class loader for the resource.
+		if (parent != null) {
+			istream = parent.getResourceAsStream(name);
+			if (istream != null)
+				return istream;
+		}
+
+		// Lets load it ourselves.
+		byte[] data = loadResource(name);
+		if (data != null) {
+			istream = new ByteArrayInputStream(data);
+		}
+
+		return istream;
+	}
+
+	/**
+	 * java.lang.ClassLoader's defineClass method is final, so the its subclasses
+	 * cannot override this method. But, this class calls this method in the
+	 * loadClass() instead.
+	 * 
+	 * @param The name of the class without ".class" extension.
+	 * @param The class data bytes.
+	 * @return The class object.
+	 */
+	protected Class defineClass(String classname, byte[] classdata) {
+		return defineClass(classname, classdata, 0, classdata.length);
+	}
+
+	public synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
+		Class c = null;
+
+		// Algorithm: (Please do not change the order; unless you
+		// have a good reason to do so).
+		//
+		// 1. first check the system class loader.
+		// 2. next check the delegate/parent class loader.
+		// 3. next check the class cache
+		// 4. then attempt to load classes from the URL set.
+		//
+
+		// Lets see if the class is in system class loader.
+		try {
+			c = findSystemClass(name);
+		} catch (ClassNotFoundException cnfe) {
+		} finally {
+			if (c != null)
+				return c;
+		}
+
+		// Lets see if the class is in parent class loader.
+		try {
+			if (parent != null)
+				c = parent.loadClass(name);
+		} catch (ClassNotFoundException cnfe) {
+		} finally {
+			if (c != null)
+				return c;
+		}
+
+		// Lets see if the class is in the cache..
+		c = (Class) classCache.get(name);
+
+		if (c != null)
+			return c;
+
+		// Lets see if we find the class all by ourselves.
+		byte[] data = loadClassData(name);
+
+		if (data != null) {
+			// we did !!
+			c = defineClass(name, data);
+			classCache.put(name, c);
+			if (resolve)
+				resolveClass(c);
+		} else {
+			// We are out of luck at this point...
+			throw new ClassNotFoundException(name);
+		}
+
+		return c;
+	}
+
+	/**
+	 * This method resets this ClassLoader's state. It completely removes all the
+	 * URLs and classes in this class loader cache.
+	 */
+	public final void clear() {
+		urlset.clear();
+		classCache.clear();
+	}
+
+	/**
+	 * This method resets this ClassLoader's state and resets the references for
+	 * garbage collection.
+	 */
+	protected void finalize() throws Throwable {
+		// Cleanup real well. Otherwise, this can be
+		// a major source of memory leaks...
+
+		// remove all the urls & class entries.
+		clear();
+
+		parent = null;
+		urlset = null;
+		classCache = null;
+	}
 }
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/NullPrimitiveException.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/NullPrimitiveException.java
index e367211..bf1dffd 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/NullPrimitiveException.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/NullPrimitiveException.java
@@ -19,14 +19,13 @@ License along with this library; if not, see http://www.gnu.org
 package net.wotonomy.foundation.internal;
 
 /**
-* A IntrospectorException that is thrown by Introspector when
-* trying to set a primitive type to null.
-*
-* @author michael@mpowers.net
-* @author $Author: cgruber $
-* @version $Revision: 893 $
-*/
+ * A IntrospectorException that is thrown by Introspector when trying to set a
+ * primitive type to null.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 893 $
+ */
 
-public class NullPrimitiveException extends IntrospectorException
-{
+public class NullPrimitiveException extends IntrospectorException {
 }
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/PropertyComparator.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/PropertyComparator.java
index abdc82f..c804893 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/PropertyComparator.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/PropertyComparator.java
@@ -21,80 +21,61 @@ package net.wotonomy.foundation.internal;
 import java.io.Serializable;
 import java.util.Comparator;
 
-
 /**
-* A Comparator that will sort elements based on the
-* property specified in the constructor.
-*
-* @author michael@mpowers.net
-* @author $Author: cgruber $
-* @version $Revision: 893 $
-*/
-public class PropertyComparator implements Comparator, Serializable
-{
-    private String property;
+ * A Comparator that will sort elements based on the property specified in the
+ * constructor.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 893 $
+ */
+public class PropertyComparator implements Comparator, Serializable {
+	private String property;
 
-/**
-* Standard constructor to configure the comparator.
-* @param aProperty A property whose value is used to sort elements.
-*/
-    public PropertyComparator( String aProperty )
-    {
+	/**
+	 * Standard constructor to configure the comparator.
+	 * 
+	 * @param aProperty A property whose value is used to sort elements.
+	 */
+	public PropertyComparator(String aProperty) {
 		property = aProperty;
-    }
+	}
 
-    // interface Comparator
+	// interface Comparator
 
-    public int compare(Object o1, Object o2)
-    {
-		Object v1 = Introspector.get( o1, property );
-		Object v2 = Introspector.get( o2, property );
-		if ( v1 instanceof Comparable )
-		{
-			return ((Comparable)v1).compareTo( v2 );
-		}
-		else
-		if ( v2 instanceof Comparable )
-		{
-			return ((Comparable)v2).compareTo( v1 );
-		}
-		else
-		{
-			if ( v1 == null )
-			{
-				if ( v2 == null )
-				{
+	public int compare(Object o1, Object o2) {
+		Object v1 = Introspector.get(o1, property);
+		Object v2 = Introspector.get(o2, property);
+		if (v1 instanceof Comparable) {
+			return ((Comparable) v1).compareTo(v2);
+		} else if (v2 instanceof Comparable) {
+			return ((Comparable) v2).compareTo(v1);
+		} else {
+			if (v1 == null) {
+				if (v2 == null) {
 					return 0; // both nulls are equal
 				}
 				return -1; // null is less than any object
-			}
-			else
-			if ( v2 == null )
-			{
+			} else if (v2 == null) {
 				return 1; // any object is greater than null
 			}
 		}
 		// last resort: compare string conversions
-		return v1.toString().compareTo( v2.toString() );
+		return v1.toString().compareTo(v2.toString());
 	}
-	
-	public boolean equals( Object obj )
-	{
-		return ( obj instanceof PropertyComparator );	
+
+	public boolean equals(Object obj) {
+		return (obj instanceof PropertyComparator);
 	}
 }
 
 /*
- * $Log$
- * Revision 1.2  2006/02/16 13:11:47  cgruber
- * Check in all sources in eclipse-friendly maven-enabled packages.
+ * $Log$ Revision 1.2 2006/02/16 13:11:47 cgruber Check in all sources in
+ * eclipse-friendly maven-enabled packages.
  *
- * Revision 1.1.1.1  2000/12/21 15:52:07  mpowers
- * Contributing wotonomy.
+ * Revision 1.1.1.1 2000/12/21 15:52:07 mpowers Contributing wotonomy.
  *
- * Revision 1.2  2000/12/20 16:25:46  michael
- * Added log to all files.
+ * Revision 1.2 2000/12/20 16:25:46 michael Added log to all files.
  *
  *
  */
-
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/PropertyListParser.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/PropertyListParser.java
index 03231c7..3698325 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/PropertyListParser.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/PropertyListParser.java
@@ -23,23 +23,26 @@ import java.io.*;
 
 /**
  * PropertyListParser can parse a property list (plist) file or string, and
- * return the top-level object represented by the plist. <p>
+ * return the top-level object represented by the plist.
+ * <p>
  * 
- * A property list is a heirarchical data structure containing only Maps,
- * Lists, and Strings -- nothing else.  In other words, a property list is
- * either a Map, List, or String instance, with the restrictions that the
- * collections may only contain Map, List, or String instances. <p>
+ * A property list is a heirarchical data structure containing only Maps, Lists,
+ * and Strings -- nothing else. In other words, a property list is either a Map,
+ * List, or String instance, with the restrictions that the collections may only
+ * contain Map, List, or String instances.
+ * <p>
  * 
- * This class can read a particularly-formatted string or file, and create
- * the property list structure described.  It provides a convenient means
- * for having a structured data file, letting programs simply deal with the
- * structure rather than having to do a lot of string parsing work as well.
- * The concept is similar to Properties files, except that the values can
- * be nested Maps or Lists instead of only Strings. <p>
+ * This class can read a particularly-formatted string or file, and create the
+ * property list structure described. It provides a convenient means for having
+ * a structured data file, letting programs simply deal with the structure
+ * rather than having to do a lot of string parsing work as well. The concept is
+ * similar to Properties files, except that the values can be nested Maps or
+ * Lists instead of only Strings.
+ * <p>
  * 
  * A Map is specified in a file by key/value pairs surrounded by brace
- * characters.  An equal sign (=) must be between the key and value, and
- * there must be a semicolon (;) following the value.
+ * characters. An equal sign (=) must be between the key and value, and there
+ * must be a semicolon (;) following the value.
  *
  * <pre>
  *     {
@@ -49,35 +52,42 @@ import java.io.*;
  *     }
  * </pre>
  *
- * A List is specified by a comma-separated list of values surrounded by parentheses, like:
+ * A List is specified by a comma-separated list of values surrounded by
+ * parentheses, like:
+ * 
  * <pre>
  *     ( value1, value2, value3, etc... )
  * </pre>
  *
- * A String can either be quoted in the manner of a constant string in
- * Java, or unquoted.  If unquoted, the string can only contain
- * alphanumerics, underscores (_), periods (.), dollar signs ($), colons
- * (:), or forward slashes (/).  If any other character appears in the
- * string, it must be quoted (i.e., surrounded by &quot; characters).
- * Quoted strings may also contain \n, \t, \f, \v, \b, and \a escapes,
- * octal escapes of the form \000, and unicode escapes of the form of \U
- * followed by four hexadecimal characters.  Any other character escaped
- * by a backslash will be treated as that character, and the escaping
- * backslash character will be omitted.  Thus, to represent an actual
- * backslash, it must appear as \\ in the quoted string. <p>
+ * A String can either be quoted in the manner of a constant string in Java, or
+ * unquoted. If unquoted, the string can only contain alphanumerics, underscores
+ * (_), periods (.), dollar signs ($), colons (:), or forward slashes (/). If
+ * any other character appears in the string, it must be quoted (i.e.,
+ * surrounded by &quot; characters). Quoted strings may also contain \n, \t, \f,
+ * \v, \b, and \a escapes, octal escapes of the form \000, and unicode escapes
+ * of the form of \U followed by four hexadecimal characters. Any other
+ * character escaped by a backslash will be treated as that character, and the
+ * escaping backslash character will be omitted. Thus, to represent an actual
+ * backslash, it must appear as \\ in the quoted string.
+ * <p>
+ * 
+ * All whitespace between elements is ignored, and both //-style and /*-style
+ * comments are allowed to appear anywhere between elements.
+ * <p>
  * 
- * All whitespace between elements is ignored, and both //-style and
- * /*-style comments are allowed to appear anywhere between elements. <p>
+ * If there are any syntax errors encountered while parsing, RuntimeExceptions
+ * are thrown with the line number and column of the problem.
+ * <p>
  * 
- * If there are any syntax errors encountered while parsing,
- * RuntimeExceptions are thrown with the line number and column of the
- * problem. <p>
+ * Currenty, HashMaps and ArrayLists are the actual Map and List classes used
+ * when creating the property list.
+ * <p>
  * 
- * Currenty, HashMaps and ArrayLists are the actual Map and List classes
- * used when creating the property list. <p>
+ * Examples:
+ * <p>
+ * <blockquote>
  * 
- * Examples: <p><blockquote>
- <pre>
+ * <pre>
    // This plist file represents a Map, since it starts with a '{'.
    {
        Map1 = { subkey1 = "foo"; };
@@ -104,443 +114,425 @@ import java.io.*;
            }
        );
    }
- </pre>
- </blockquote>
- * For those wondering, this is essentially a re-implementation of
+ * </pre>
+ * 
+ * </blockquote> For those wondering, this is essentially a re-implementation of
  * NeXT/Apple's property lists, except that data values are not supported.
  *
  * @author clindberg@blacksmith.com
  * @version $Revision: 899 $
  */
 
-public class PropertyListParser
-{
-    private char buffer[];
-    private int currIndex;
-    private int lineNumber;
-    private int currLineStartIndex;
-
-    /** Reads an object (String, List, or Map) from plistString and returns it.
-     *  RuntimeExceptions are raised if there are parse problems.
-     */
-    public static Object propertyListFromString(String plistString)
-    {
-        PropertyListParser parser = new PropertyListParser(plistString);
-        return parser.readTopLevelObject();
-    }
-
-    /**
-     * Reads all remaining characters from the Reader, and returns the
-     * result of propertyListFromString().  RuntimeExceptions are raised if
-     * there are parse problems
-     */
-    public static Object propertyListFromReader(Reader reader) throws IOException
-    {
-        char         charBuffer[] = new char[2048];
-        StringBuffer stringBuffer = new StringBuffer();
-        int          numRead = 0;
-
-        while (numRead >= 0)
-        {
-            numRead = reader.read(charBuffer);
-            if (numRead > 0) stringBuffer.append(charBuffer, 0, numRead);
-        }
-
-        return propertyListFromString(stringBuffer.toString());
-    }
-
-    /**
-     * Reads the contents of the specified file, and parses the contents.
-     * If any error occurs, prints out a message using System.out.println()
-     * and returns null.
-     */
-    public static Object propertyListFromFile(String filename)
-    {
-        try {
-            FileInputStream stream = new FileInputStream(filename);
-            return propertyListFromReader(new InputStreamReader(stream));
-        } catch (Exception exception) {
-            String errorMessage = exception.getMessage();
-            System.out.println("Error parsing property list from "+filename+": "+errorMessage);
-        }
-
-        return null;
-    }
-
-    /**
-     * Creates a new PropertyListParser to parse the contents of the
-     * specified String.
-     */
-    public PropertyListParser(String plistString)
-    {
-        this(plistString.toCharArray());
-    }
-
-    /**
-     * Creates a new PropertyListParser to parse the specified char array.
-     */
-    public PropertyListParser(char[] charArray)
-    {
-        buffer = charArray;
-        lineNumber = 1;
-        currLineStartIndex = 1;
-        currIndex = 0;
-    }
-
-    public Object readTopLevelObject()
-    {
-        Object plist = readObject();
-
-        skipCommentWhitespace();
-        if (!isAtEnd())
-        {
-            throwParseException("Extra characters in plist string after parsing object.  A plist should only contain one top-level object.");
-        }
-
-        return plist;
-    }
-
-    private void throwParseException(String errorMessage)
-    {
-        int column = currIndex - currLineStartIndex + 1;
-        throw new RuntimeException(errorMessage + " (Line " + lineNumber + ", column " + column + ")");
-    }
-
-    private void updateLineNumberWithIndex(int lineStartIndex)
-    {
-        lineNumber++;
-        currLineStartIndex = lineStartIndex;
-    }
-
-    private boolean isAtEnd()
-    {
-        return currIndex >= buffer.length;
-    }
-
-    private void skipDoubleslashComment()
-    {
-        while (!isAtEnd() && buffer[currIndex] != '\n') {
-            currIndex++;
-        }
-    }
-
-    private void skipStandardCComment()
-    {
-        currIndex++;  //skip over the starting '/'
-
-        while (!isAtEnd())
-        {
-            if (buffer[currIndex] == '\n')
-                updateLineNumberWithIndex(currIndex+1);
-
-            currIndex++;
-
-            if (buffer[currIndex-2] == '*' && buffer[currIndex-1] == '/')
-            {
-                return;
-            }
-        }
-
-        throwParseException("Input exhausted while parsing comment");
-    }
-
-    private void skipWhitespace()
-    {
-        while (!isAtEnd() && isWhitespace(buffer[currIndex]))
-        {
-            if (buffer[currIndex] == '\n')
-                updateLineNumberWithIndex(currIndex+1);
-            currIndex++;
-        }
-    }
-
-    private void skipCommentWhitespace()
-    {
-        boolean done = false;
-
-        while (!done)
-        {
-            done = true;
-
-            skipWhitespace();
-            if ((buffer.length - currIndex) > 1 && buffer[currIndex] == '/')
-            {
-                if (buffer[currIndex+1] == '/') {
-                    done = false; //iterate again
-                    skipDoubleslashComment();
-                }
-                else if (buffer[currIndex+1] == '*') {
-                    done = false; //iterate again
-                    skipStandardCComment();
-                }
-            }
-        }
-    }
-
-    private Object readObject()
-    {
-        skipCommentWhitespace();
-        if (isAtEnd()) return null;
-
-        // Data (i.e. byte[]) not supported
-        if (buffer[currIndex] == '"')
-            return readQuotedString();
-        if (buffer[currIndex] == '(')
-            return readList();
-        if (buffer[currIndex] == '{')
-            return readMap();
-
-        return readUnquotedString();
-    }
-
-    private static final byte valueForHexDigit(char c)
-    {
-        if(c >= '0' && c <= '9') return (byte)(c - '0');
-        if(c >= 'a' && c <= 'f') return (byte)((c - 'a') + 10);
-        if(c >= 'A' && c <= 'F') return (byte)((c - 'A') + 10);
-
-        return 0;
-    }
-
-    private static final boolean isOctalDigit(char c)
-    {
-        return c >= '0' && c <= '7';
-    }
-
-    private static final boolean isHexDigit(char c)
-    {
-        return (c >= '0' && c <= '9') ||
-               (c >= 'a' && c <= 'f') ||
-               (c >= 'A' && c <= 'F');
-    }
-
-    private static String unquotedStringChars = "._$:/";   // chars allowed in unquoted strings
-    private static String whitespaceChars = " \t\n\r\f";
-
-    private static final boolean isWhitespace(char c)
-    {
-        return whitespaceChars.indexOf(c) >= 0;
-    }
-
-    private static final boolean isValidUnquotedStringChar(char c)
-    {
-        return ((c >= 'a' && c <= 'z') ||
-                (c >= 'A' && c <= 'Z') ||
-                (c >= '0' && c <= '9') ||
-                unquotedStringChars.indexOf(c) >= 0);
-    }
-
-    private String readUnquotedString()
-    {
-        int startIndex = currIndex;
-
-        while (!isAtEnd() && isValidUnquotedStringChar(buffer[currIndex]))
-            currIndex++;
-
-        if (startIndex == currIndex)
-            throwParseException("No allowable characters found to parse unquoted string");
-
-        return new String(buffer, startIndex, currIndex - startIndex);
-    }
-
-    private String readQuotedString()
-    {
-        currIndex++;  //skip over '"'
-
-        StringBuffer stringBuffer = new StringBuffer();
-        int          startIndex = currIndex;
-
-        while (!isAtEnd() && buffer[currIndex] != '"')
-        {
-            if (buffer[currIndex] != '\\')
-            {
-                if (buffer[currIndex] == '\n')
-                    updateLineNumberWithIndex(currIndex+1);
-
-                /*
-                 * Just increment the index -- all these characters will be
-                 * appended in chunks, either before an escape sequence or
-                 * at the end.
-                 */
-                currIndex++;
-            }
-            else  // it's an escape
-            {
-                /* Append anything scanned past before the '\\' */
-                if (startIndex < currIndex)
-                    stringBuffer.append(buffer, startIndex, currIndex - startIndex);
-                currIndex++; // skip over '\\'
-
-                if (isAtEnd())
-                    throwParseException("Input exhausted while parsing escape sequence");
-
-                switch (buffer[currIndex])
-                {
-                    case 't': stringBuffer.append('\t'); currIndex++; break;   // tab
-                    case 'n': stringBuffer.append('\n'); currIndex++; break;   // newline
-                    case 'r': stringBuffer.append('\r'); currIndex++; break;   // carriage return
-                    case 'f': stringBuffer.append('\f'); currIndex++; break;   // form feed
-                    case 'b': stringBuffer.append('\b'); currIndex++; break;   // backspace
-                    case 'a': stringBuffer.append('\007'); currIndex++; break; // bell
-                    case 'v': stringBuffer.append('\013'); currIndex++; break; // vertical tab
-                    case 'U':
-                    case 'u':
-                    {
-                        /* A Unicode escape.  Always followed by 4 hex digits. */
-                        currIndex++; // skip past the 'U'
-                        if ((currIndex+4) > buffer.length)
-                            throwParseException("Not enough chars to parse \\U sequence");
-
-                        if(!isHexDigit(buffer[currIndex])   || !isHexDigit(buffer[currIndex+1]) ||
-                           !isHexDigit(buffer[currIndex+2]) || !isHexDigit(buffer[currIndex+3]))
-                        {
-                            throwParseException("Four hex digits not found for \\U sequence");
-                        }
-
-                        byte byte3 = valueForHexDigit(buffer[currIndex]);
-                        byte byte2 = valueForHexDigit(buffer[currIndex+1]);
-                        byte byte1 = valueForHexDigit(buffer[currIndex+2]);
-                        byte byte0 = valueForHexDigit(buffer[currIndex+3]);
-                        char theChar = (char)((byte3 << 12) + (byte2 << 8) + (byte1 << 4) + byte0);
-                        stringBuffer.append(theChar);
-                        currIndex += 4;
-                        break;
-                    }
-                    case '0': case '1': case '2': case '3':
-                    case '4': case '5': case '6': case '7':
-                    {
-                        /* An octal escape.  Expect 1, 2, or 3 octal digits. */
-                        int digits = 0;
-                        int value = 0;
-
-                        do {
-                            value *= 8;
-                            value += (int)(buffer[currIndex] - '0');
-                            currIndex++;
-                            digits++;
-                        } while (digits <= 3 && !isAtEnd() && isOctalDigit(buffer[currIndex]));
-
-                        if (value > 255)
-                            throwParseException("Value too large in octal escape sequence (> 0377)");
-
-                        // This assumes value is in ISO Latin 1 encoding
-                        stringBuffer.append((char)value);
-                        break;
-                    }
-                    /* I guess plists can't have the \x{HEX}{HEX} escapes */
-                    default:
-                    {
-                        // Unknown escape sequence, just add the character.
-                        // GCC warns if this isn't a '"', '\'', or '\\'...
-                        stringBuffer.append(buffer[currIndex]);
-                        if (buffer[currIndex] == '\n')
-                            updateLineNumberWithIndex(currIndex+1);
-                        currIndex++;
-                        break;
-                    }
-                } // end case
-
-                /* Reset startIndex, so a verbatim copy will now start from this index */
-                startIndex = currIndex;
-
-            } //end '\\' escape
-        }
-
-        if (isAtEnd())
-            throwParseException("Input exhausted while parsing quoted string");
-        if (startIndex < currIndex)
-            stringBuffer.append(buffer, startIndex, currIndex - startIndex);
-        currIndex++; //skip past '"'
-
-        return stringBuffer.toString();
-    }
-
-    private List readList()
-    {
-        List newList = new ArrayList();
-
-        currIndex++;  //skip over '('
-        skipCommentWhitespace();
-        while (!isAtEnd() && buffer[currIndex] != ')')
-        {
-            /* A comma is required between list elements */
-            if (newList.size() > 0)
-            {
-                if (buffer[currIndex] != ',')
-                    throwParseException("List parsing failed: expecting ','");
-                currIndex++;
-                skipCommentWhitespace();
-                if (isAtEnd())
-                    throwParseException("Input exhausted while parsing list");
-            }
-
-            if (buffer[currIndex] != ')')
-            {
-                Object plistObject = readObject();
-                if (plistObject == null)
-                    throwParseException("List parsing failed: could not read contained object.");
-                newList.add(plistObject);
-                skipCommentWhitespace();
-            }
-        }
-
-        if (isAtEnd())
-            throwParseException("Input exhausted while parsing list");
-        currIndex++; //skip past ')'
-
-        return newList;
-    }
-
-    private Map readMap()
-    {
-        HashMap newMap = new HashMap();
-
-        currIndex++; // skip over open brace
-        skipCommentWhitespace();
-
-        while (!isAtEnd() && buffer[currIndex] != '}')
-        {
-            Object key;
-            Object value;
-
-            key = readObject();
-            if (key == null || !(key instanceof String))
-                throwParseException("Map parsing failed: could not parse key or key is not a String");
-
-            skipCommentWhitespace();
-            if (isAtEnd() || buffer[currIndex] != '=')
-                throwParseException("Map parsing failed: expecting '='");
-            currIndex++;  //skip over '='
-            skipCommentWhitespace();
-            if (isAtEnd())
-                throwParseException("Input exhausted while parsing map");
-
-            value = readObject();
-            if (value == null)
-                throwParseException("Map parsing failed: could not parse value object");
-
-            skipCommentWhitespace();
-            if (isAtEnd() || buffer[currIndex] != ';')
-                throwParseException("Map parsing failed: expecting ';'");
-            currIndex++;  //skip over ';'
-            skipCommentWhitespace();
-
-            newMap.put(key, value);
-        }
-
-        if (isAtEnd())
-            throwParseException("Input exhausted while parsing map");
-        currIndex++; //skip past '}'
-
-        return newMap;
-    }
-
-
-    public static void main(String[] args)
-    {
-        String filename = args[0];
-        Object plist = PropertyListParser.propertyListFromFile(filename);
-        System.out.println(plist);
-    }
+public class PropertyListParser {
+	private char buffer[];
+	private int currIndex;
+	private int lineNumber;
+	private int currLineStartIndex;
+
+	/**
+	 * Reads an object (String, List, or Map) from plistString and returns it.
+	 * RuntimeExceptions are raised if there are parse problems.
+	 */
+	public static Object propertyListFromString(String plistString) {
+		PropertyListParser parser = new PropertyListParser(plistString);
+		return parser.readTopLevelObject();
+	}
+
+	/**
+	 * Reads all remaining characters from the Reader, and returns the result of
+	 * propertyListFromString(). RuntimeExceptions are raised if there are parse
+	 * problems
+	 */
+	public static Object propertyListFromReader(Reader reader) throws IOException {
+		char charBuffer[] = new char[2048];
+		StringBuffer stringBuffer = new StringBuffer();
+		int numRead = 0;
+
+		while (numRead >= 0) {
+			numRead = reader.read(charBuffer);
+			if (numRead > 0)
+				stringBuffer.append(charBuffer, 0, numRead);
+		}
+
+		return propertyListFromString(stringBuffer.toString());
+	}
+
+	/**
+	 * Reads the contents of the specified file, and parses the contents. If any
+	 * error occurs, prints out a message using System.out.println() and returns
+	 * null.
+	 */
+	public static Object propertyListFromFile(String filename) {
+		try {
+			FileInputStream stream = new FileInputStream(filename);
+			return propertyListFromReader(new InputStreamReader(stream));
+		} catch (Exception exception) {
+			String errorMessage = exception.getMessage();
+			System.out.println("Error parsing property list from " + filename + ": " + errorMessage);
+		}
+
+		return null;
+	}
+
+	/**
+	 * Creates a new PropertyListParser to parse the contents of the specified
+	 * String.
+	 */
+	public PropertyListParser(String plistString) {
+		this(plistString.toCharArray());
+	}
+
+	/**
+	 * Creates a new PropertyListParser to parse the specified char array.
+	 */
+	public PropertyListParser(char[] charArray) {
+		buffer = charArray;
+		lineNumber = 1;
+		currLineStartIndex = 1;
+		currIndex = 0;
+	}
+
+	public Object readTopLevelObject() {
+		Object plist = readObject();
+
+		skipCommentWhitespace();
+		if (!isAtEnd()) {
+			throwParseException(
+					"Extra characters in plist string after parsing object.  A plist should only contain one top-level object.");
+		}
+
+		return plist;
+	}
+
+	private void throwParseException(String errorMessage) {
+		int column = currIndex - currLineStartIndex + 1;
+		throw new RuntimeException(errorMessage + " (Line " + lineNumber + ", column " + column + ")");
+	}
+
+	private void updateLineNumberWithIndex(int lineStartIndex) {
+		lineNumber++;
+		currLineStartIndex = lineStartIndex;
+	}
+
+	private boolean isAtEnd() {
+		return currIndex >= buffer.length;
+	}
+
+	private void skipDoubleslashComment() {
+		while (!isAtEnd() && buffer[currIndex] != '\n') {
+			currIndex++;
+		}
+	}
+
+	private void skipStandardCComment() {
+		currIndex++; // skip over the starting '/'
+
+		while (!isAtEnd()) {
+			if (buffer[currIndex] == '\n')
+				updateLineNumberWithIndex(currIndex + 1);
+
+			currIndex++;
+
+			if (buffer[currIndex - 2] == '*' && buffer[currIndex - 1] == '/') {
+				return;
+			}
+		}
+
+		throwParseException("Input exhausted while parsing comment");
+	}
+
+	private void skipWhitespace() {
+		while (!isAtEnd() && isWhitespace(buffer[currIndex])) {
+			if (buffer[currIndex] == '\n')
+				updateLineNumberWithIndex(currIndex + 1);
+			currIndex++;
+		}
+	}
+
+	private void skipCommentWhitespace() {
+		boolean done = false;
+
+		while (!done) {
+			done = true;
+
+			skipWhitespace();
+			if ((buffer.length - currIndex) > 1 && buffer[currIndex] == '/') {
+				if (buffer[currIndex + 1] == '/') {
+					done = false; // iterate again
+					skipDoubleslashComment();
+				} else if (buffer[currIndex + 1] == '*') {
+					done = false; // iterate again
+					skipStandardCComment();
+				}
+			}
+		}
+	}
+
+	private Object readObject() {
+		skipCommentWhitespace();
+		if (isAtEnd())
+			return null;
+
+		// Data (i.e. byte[]) not supported
+		if (buffer[currIndex] == '"')
+			return readQuotedString();
+		if (buffer[currIndex] == '(')
+			return readList();
+		if (buffer[currIndex] == '{')
+			return readMap();
+
+		return readUnquotedString();
+	}
+
+	private static final byte valueForHexDigit(char c) {
+		if (c >= '0' && c <= '9')
+			return (byte) (c - '0');
+		if (c >= 'a' && c <= 'f')
+			return (byte) ((c - 'a') + 10);
+		if (c >= 'A' && c <= 'F')
+			return (byte) ((c - 'A') + 10);
+
+		return 0;
+	}
+
+	private static final boolean isOctalDigit(char c) {
+		return c >= '0' && c <= '7';
+	}
+
+	private static final boolean isHexDigit(char c) {
+		return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+	}
+
+	private static String unquotedStringChars = "._$:/"; // chars allowed in unquoted strings
+	private static String whitespaceChars = " \t\n\r\f";
+
+	private static final boolean isWhitespace(char c) {
+		return whitespaceChars.indexOf(c) >= 0;
+	}
+
+	private static final boolean isValidUnquotedStringChar(char c) {
+		return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
+				|| unquotedStringChars.indexOf(c) >= 0);
+	}
+
+	private String readUnquotedString() {
+		int startIndex = currIndex;
+
+		while (!isAtEnd() && isValidUnquotedStringChar(buffer[currIndex]))
+			currIndex++;
+
+		if (startIndex == currIndex)
+			throwParseException("No allowable characters found to parse unquoted string");
+
+		return new String(buffer, startIndex, currIndex - startIndex);
+	}
+
+	private String readQuotedString() {
+		currIndex++; // skip over '"'
+
+		StringBuffer stringBuffer = new StringBuffer();
+		int startIndex = currIndex;
+
+		while (!isAtEnd() && buffer[currIndex] != '"') {
+			if (buffer[currIndex] != '\\') {
+				if (buffer[currIndex] == '\n')
+					updateLineNumberWithIndex(currIndex + 1);
+
+				/*
+				 * Just increment the index -- all these characters will be appended in chunks,
+				 * either before an escape sequence or at the end.
+				 */
+				currIndex++;
+			} else // it's an escape
+			{
+				/* Append anything scanned past before the '\\' */
+				if (startIndex < currIndex)
+					stringBuffer.append(buffer, startIndex, currIndex - startIndex);
+				currIndex++; // skip over '\\'
+
+				if (isAtEnd())
+					throwParseException("Input exhausted while parsing escape sequence");
+
+				switch (buffer[currIndex]) {
+				case 't':
+					stringBuffer.append('\t');
+					currIndex++;
+					break; // tab
+				case 'n':
+					stringBuffer.append('\n');
+					currIndex++;
+					break; // newline
+				case 'r':
+					stringBuffer.append('\r');
+					currIndex++;
+					break; // carriage return
+				case 'f':
+					stringBuffer.append('\f');
+					currIndex++;
+					break; // form feed
+				case 'b':
+					stringBuffer.append('\b');
+					currIndex++;
+					break; // backspace
+				case 'a':
+					stringBuffer.append('\007');
+					currIndex++;
+					break; // bell
+				case 'v':
+					stringBuffer.append('\013');
+					currIndex++;
+					break; // vertical tab
+				case 'U':
+				case 'u': {
+					/* A Unicode escape. Always followed by 4 hex digits. */
+					currIndex++; // skip past the 'U'
+					if ((currIndex + 4) > buffer.length)
+						throwParseException("Not enough chars to parse \\U sequence");
+
+					if (!isHexDigit(buffer[currIndex]) || !isHexDigit(buffer[currIndex + 1])
+							|| !isHexDigit(buffer[currIndex + 2]) || !isHexDigit(buffer[currIndex + 3])) {
+						throwParseException("Four hex digits not found for \\U sequence");
+					}
+
+					byte byte3 = valueForHexDigit(buffer[currIndex]);
+					byte byte2 = valueForHexDigit(buffer[currIndex + 1]);
+					byte byte1 = valueForHexDigit(buffer[currIndex + 2]);
+					byte byte0 = valueForHexDigit(buffer[currIndex + 3]);
+					char theChar = (char) ((byte3 << 12) + (byte2 << 8) + (byte1 << 4) + byte0);
+					stringBuffer.append(theChar);
+					currIndex += 4;
+					break;
+				}
+				case '0':
+				case '1':
+				case '2':
+				case '3':
+				case '4':
+				case '5':
+				case '6':
+				case '7': {
+					/* An octal escape. Expect 1, 2, or 3 octal digits. */
+					int digits = 0;
+					int value = 0;
+
+					do {
+						value *= 8;
+						value += (int) (buffer[currIndex] - '0');
+						currIndex++;
+						digits++;
+					} while (digits <= 3 && !isAtEnd() && isOctalDigit(buffer[currIndex]));
+
+					if (value > 255)
+						throwParseException("Value too large in octal escape sequence (> 0377)");
+
+					// This assumes value is in ISO Latin 1 encoding
+					stringBuffer.append((char) value);
+					break;
+				}
+				/* I guess plists can't have the \x{HEX}{HEX} escapes */
+				default: {
+					// Unknown escape sequence, just add the character.
+					// GCC warns if this isn't a '"', '\'', or '\\'...
+					stringBuffer.append(buffer[currIndex]);
+					if (buffer[currIndex] == '\n')
+						updateLineNumberWithIndex(currIndex + 1);
+					currIndex++;
+					break;
+				}
+				} // end case
+
+				/* Reset startIndex, so a verbatim copy will now start from this index */
+				startIndex = currIndex;
+
+			} // end '\\' escape
+		}
+
+		if (isAtEnd())
+			throwParseException("Input exhausted while parsing quoted string");
+		if (startIndex < currIndex)
+			stringBuffer.append(buffer, startIndex, currIndex - startIndex);
+		currIndex++; // skip past '"'
+
+		return stringBuffer.toString();
+	}
+
+	private List readList() {
+		List newList = new ArrayList();
+
+		currIndex++; // skip over '('
+		skipCommentWhitespace();
+		while (!isAtEnd() && buffer[currIndex] != ')') {
+			/* A comma is required between list elements */
+			if (newList.size() > 0) {
+				if (buffer[currIndex] != ',')
+					throwParseException("List parsing failed: expecting ','");
+				currIndex++;
+				skipCommentWhitespace();
+				if (isAtEnd())
+					throwParseException("Input exhausted while parsing list");
+			}
+
+			if (buffer[currIndex] != ')') {
+				Object plistObject = readObject();
+				if (plistObject == null)
+					throwParseException("List parsing failed: could not read contained object.");
+				newList.add(plistObject);
+				skipCommentWhitespace();
+			}
+		}
+
+		if (isAtEnd())
+			throwParseException("Input exhausted while parsing list");
+		currIndex++; // skip past ')'
+
+		return newList;
+	}
+
+	private Map readMap() {
+		HashMap newMap = new HashMap();
+
+		currIndex++; // skip over open brace
+		skipCommentWhitespace();
+
+		while (!isAtEnd() && buffer[currIndex] != '}') {
+			Object key;
+			Object value;
+
+			key = readObject();
+			if (key == null || !(key instanceof String))
+				throwParseException("Map parsing failed: could not parse key or key is not a String");
+
+			skipCommentWhitespace();
+			if (isAtEnd() || buffer[currIndex] != '=')
+				throwParseException("Map parsing failed: expecting '='");
+			currIndex++; // skip over '='
+			skipCommentWhitespace();
+			if (isAtEnd())
+				throwParseException("Input exhausted while parsing map");
+
+			value = readObject();
+			if (value == null)
+				throwParseException("Map parsing failed: could not parse value object");
+
+			skipCommentWhitespace();
+			if (isAtEnd() || buffer[currIndex] != ';')
+				throwParseException("Map parsing failed: expecting ';'");
+			currIndex++; // skip over ';'
+			skipCommentWhitespace();
+
+			newMap.put(key, value);
+		}
+
+		if (isAtEnd())
+			throwParseException("Input exhausted while parsing map");
+		currIndex++; // skip past '}'
+
+		return newMap;
+	}
+
+	public static void main(String[] args) {
+		String filename = args[0];
+		Object plist = PropertyListParser.propertyListFromFile(filename);
+		System.out.println(plist);
+	}
 }
-
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/QueueMap.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/QueueMap.java
index 6d35b7b..59104e5 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/QueueMap.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/QueueMap.java
@@ -21,518 +21,488 @@ package net.wotonomy.foundation.internal;
 import java.util.*; //collections
 
 /**
-* A queue based implementation of the Map interface.  This class provides for
-* all the opertions of a map, but keeps the entries in the same sequence as
-* originally added.  The first entry placed in the map will be the first
-* entry retreived during iteration: first-in, first-out (FIFO). <BR><BR>
-*
-* Keys cannot be duplicated.  If an entry is made using a key that already
-* exists, the value for that key will be replaced with that new value.  There
-* are no such restrictions on the values.  The values may be null.  <BR><BR>
-*
-* Some convenience methods are provided for the queue type operations.  The
-* first key can be retreived as well as the last key.  A key can be used
-* to retreive its corresponding value from the map.  A value can also be used
-* to retreive its key from the map, however, since there may be multiple values
-* of the same equality, the first key found will be returned. <BR><BR>
-*
-* @author rglista@blacksmith.com
-* @author mpowers@blacksmith.com
-* @date $Date: 2006-02-18 17:41:36 -0500 (Sat, 18 Feb 2006) $
-* @revision $Revision: 899 $
-*/
-public class QueueMap implements Map
-{
-    List values;
-    List keys;
-    Map keyToValue;
-
-/**
-* Creates an empty QueueMap.
-*/
-    public QueueMap()
-    {
-        values = new LinkedList();
-        keys = new LinkedList();
-        keyToValue = new HashMap();
-    }
-
-/**
-* Creates a QueueMap and places the entries from the passed in map into this map.
-* The order of the entries is based on however the iterator iteratated through
-* the map entries.
-* @param t A map object.
-*/
-    public QueueMap( Map t )
-    {
-        values = new ArrayList();
-        keys = new ArrayList();
-        keyToValue = new HashMap();
-
-        putAll( t );
-    }
-
-/**
-* Removes all the entries from this map.
-*/
-    public void clear()
-    {
-        values.clear();
-        keys.clear();
-        keyToValue.clear();
-    }
-
-/**
-* Tests to see if the key is contained in the map.  If the key is present in
-* the map, then TRUE is returned, otherwise FALSE is returned.  The equals()
-* operation is used to determine equality.
-* @return True if the map contains the given key, false otherwise.
-*/
-    public boolean containsKey( Object key )
-    {
-        return keyToValue.containsKey( key );
-    }
-
-/**
-* Tests to see if the value is contained in the map.  If the value is present in
-* the map, then TRUE is returned, otherwise FALSE is returned.  The equals()
-* operation is used to determine equality.  The value can be null and will
-* return TRUE if null is a value in the map.  If TRUE is returned, then there
-* may be more than one values in the map.
-* @return True if the map contains the given value, false otherwise.
-*/
-    public boolean containsValue( Object value )
-    {
-        return keyToValue.containsValue( value );
-    }
-
-/**
-* Returns a set view of the mappings contained in this map.  Each element
-* in the returned set is a <tt>Map.Entry</tt>.  The returned set is NOT backed
-* by the map, so changes to the map are NOT reflected in the set, and vice-versa.
-* The returned set is independent of this Map and its underlying structure.
-*
-* @return a set view of the mappings contained in this map.
-*/
-    public Set entrySet()
-    {
-        Set result = new HashSet(keys.size(), 1F);
-
-        for ( int i = 0; i < keys.size(); i++ )
-        {
-            result.add( new KeyValuePair( keys.get(i), values.get(i) ) );
-        }
-
-        return result;
-    }
-
-/**
-* Compares the specified object with this map for equality.  Returns
-* <tt>true</tt> if the given object is also a map and the two Maps
-* represent the same mappings.  More formally, two maps <tt>t1</tt> and
-* <tt>t2</tt> represent the same mappings if
-* <tt>t1.entrySet().equals(t2.entrySet())</tt>.  This ensures that the
-* <tt>equals</tt> method works properly across different implementations
-* of the <tt>Map</tt> interface.
-*
-* @param o object to be compared for equality with this map.
-* @return <tt>true</tt> if the specified object is equal to this map.
-*/
-    public boolean equals( Object o )
-    {
-        return keyToValue.equals( o );
-    }
-
-/**
-* Returns the corresponding value for the given key.  The returned value may be
-* null as that is a legal value in this map.  However, if the key is not
-* contained in this map then null is also returned.  Use the containsKey()
-* method to distinguish between the two cases.
-* @param key A key into the map.
-* @return The value corresponding to the key (can be null), or null if the key
-*         is not contained in the map.
-*/
-    public Object get( Object key )
-    {
-        return keyToValue.get( key );
-    }
-
-/**
-* Returns the hash code value for this map.  The hash code of a map
-* is defined to be the sum of the hashCodes of each entry in the map's
-* entrySet view.  This ensures that <tt>t1.equals(t2)</tt> implies
-* that <tt>t1.hashCode()==t2.hashCode()</tt> for any two maps
-* <tt>t1</tt> and <tt>t2</tt>, as required by the general
-* contract of Object.hashCode.
-*
-* @return the hash code value for this map.
-*/
-    public int hashCode()
-    {
-        return keyToValue.hashCode();
-    }
-
-/**
-* Returns true is this map contains no key-value mappings.
-* @return True is this map contains no entries, false otherwise.
-*/
-    public boolean isEmpty()
-    {
-        return keyToValue.isEmpty();
-    }
-
-/**
-* Returns the keys used in the map. There is no order implied in the returned
-* set and may be different than the the order in which they were inserted.
-* @return A Set containing all the keys used in the map.
-*/
-    public Set keySet()
-    {
-        Set result = new HashSet(keys.size(), 1F);
-
-        for ( int i = 0; i < keys.size(); i++ )
-        {
-            result.add( keys.get(i) );
-        }
-
-        return result;
-    }
-
-/**
-* Places the key/value entry into the map at the end position.  If the key
-* already exists in the map, then its value is replaced by the new given
-* value.  The mapping does not change order in this case.  The specified
-* key cannot be null.
-* @param key The key to place into the map, cannot be null.
-* @param value The value to associate with the key, may be null.
-* @return Null if the key is new, the replaced value if the key already
-*         existed. (Note: If the key was null, then null is returned.)
-*/
-    public Object put( Object key, Object value )
-    {
-        if ( key == null ) return null;
-
-        if ( keys.contains( key ) )
-        {
-            values.remove( keys.indexOf( key ) );
-            values.add( keys.indexOf( key ), value );
-        }
-        else
-        {
-            values.add( value );
-            keys.add( key );
-        }
-
-        return keyToValue.put( key, value );
-    }
-
-/**
-* Places all the entries from this given map into this map.  If the keys
-* already exist, then there values are replaced.
-* @param t A map of key/value entries.
-*/
-    public void putAll( Map t )
-    {
-        if ( t == null )
-        {
-            // Nothing to do!
-            return;
-        }
-
-        // Place the entries from the passed in map into this map.
-        for ( Iterator it = t.keySet().iterator(); it.hasNext(); )
-        {
-            Object aKey = it.next();
-            put( aKey, t.get( aKey ) );
-        }
-    }
-
-/**
-* Remove the mapping of the key and associated value from this map.
-* Note: null is a valid value in the map.
-* @param key A key to remove from the map, cannot be null.
-* @return The value of the removed mapping, null if the mapping did not exist.
-*         Null could also be returned if the associated value of the key was null.
-*/
-    public Object remove( Object key )
-    {
-        if ( key == null ) return null;
-
-        Object value = null;
-
-        if ( containsKey( key ) )
-        {
-            value = keyToValue.remove( key );
-            int i = values.indexOf( value );
-            if ( i != -1 )
-            {
-                keys.remove( i );
-                values.remove( i );
-            }
-        }
-
-        return value;
-    }
-
-/**
-* Returns the number of key/value pairs in this map.
-* @return The number of pairs.
-*/
-    public int size()
-    {
-        return values.size();
-    }
-
-/**
-* Returns an ordered list of keys from the map.  The order is the same
-* as the added order of the mapped items.<br>
-* NOTE: The returned list is the underlying keys list used by this class.
-* If modification are to be made to this list, it should be cloned first.
-* @return An ordered list of keys.
-*/
-    public List keys()
-    {
-        return keys;
-    }
-
-/**
-* Returns an ordered list of values from the map.  The order is the same
-* as the added order of the mapped items.
-* NOTE: The returned list is the underlying keys list used by this class.
-* If modification are to be made to this list, it should be cloned first.
-* @return An ordered list of values.
-*/
-    public Collection values()
-    {
-        return values;
-    }
-
-/**
-* Returns the corresponding value for the given key.  The returned value may be
-* null as that is a legal value in this map.  However, if the key is not
-* contained in this map then null is also returned.  Use the containsKey()
-* method to distinguish between the two cases.
-* @param key A key into the map.
-* @return The value corresponding to the key (can be null), or null if the key
-*         is not contained in the map.
-*/
-    public Object getValueForKey( Object key )
-    {
-        return keyToValue.get( key );
-    }
-
-/**
-* Returns the associated key for this value.  Since there may be more than one
-* of the same value in the map, this returns the first key associated with this
-* value. Null is returned if the value is not in the map.
-* @param value A value that is contained in this map.
-* @return A first key that corresponds to this value.
-*/
-    public Object getKeyForValue( Object value )
-    {
-        int i = values.indexOf( value );
-        if ( i != -1 )
-        {
-            return keys.get( i );
-        }
-        return null;
-    }
-
-/**
-* Returns the first key in the map.  If the map is empty, then null is
-* returned.
-* @return The first key in the map, null if there are no mappings.
-*/
-    public Object getFirstKey()
-    {
-        if ( keys.size() < 1 )
-        {
-            return null;
-        }
-        return keys.get(0);
-    }
-
-/**
-* Returns the last key in the map.  If the map is empty, then null is
-* returned.
-* @return The last key in the map, null if there are no mappings.
-*/
-    public Object getLastKey()
-    {
-        if ( keys.size() < 1 )
-        {
-            return null;
-        }
-        return keys.get( keys.size() -1 );
-    }
-
-/**
-* This class contains a key/value pair.  The key must be a valid object,
-* it cannot be null.  The value can be a valid object or null.
-*/
-    static public class KeyValuePair implements Map.Entry
-    {
-        Object key;
-        Object value;
-
-    /**
-    * Default constructor.  The constructor takes the key and value as parameters.
-    * Since the key cannot be null, it must be specified during initialization.
-    * The value can be null.
-    * @param key The key object of this pair.  The key cannot be null.
-    * @param value The value object of this pair.  The value can be null.
-    */
-        public KeyValuePair( Object aKey, Object aValue )
-        {
-            key = aKey;
-            value = aValue;
-        }
-
-    /**
-    * Returns the key object of this pair.
-    * @return The key object.
-    */
-        public Object getKey()
-        {
-            return key;
-        }
-
-    /**
-    * Returns the the value object of this pair.  May be null.
-    * @return The value object.
-    */
-        public Object getValue()
-        {
-            return value;
-        }
-
-    /**
-    * Sets the value object of this pair.  May be an object or null.
-    * @param aValue The value object to place into this pair.
-    */
-        public Object setValue( Object aValue )
-        {
-            Object result = value;
-            value = aValue;
-            return result;
-        }
-
-        public boolean equals( Object o )
-        {
-            if ( o instanceof KeyValuePair )
-            {
-                KeyValuePair p = (KeyValuePair) o;
-                if ( ( key.equals( p.getKey() ) ) && ( value.equals( p.getValue() ) ) )
-                {
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-
-    /**
-     * Returns a string reprsentation of this class.  The contents of the
-     * map are placed in the string in its proper order.
-     */
-    public String toString()
-    {
-        int max = size() - 1;
-        StringBuffer buf = new StringBuffer();
-
-        buf.append("{");
-        for (int j = 0; j <= max; j++)
-        {
-            buf.append(keys.get(j) + "=" + values.get(j));
-            if (j < max)
-            {
-                buf.append(", ");
-            }
-        }
-        buf.append("}");
-
-        return buf.toString();
-    }
-
-    // unit test
-    public static void main( String[] argv )
-    {
-        QueueMap qMap;
-
-        qMap = new QueueMap();
-        for (int i = 0; i < 5; i++)
-        {
-            qMap.put(Integer.toString(i), Integer.toString(i));
-        }
-        System.out.println("\nMap = " + qMap);
-        System.out.println("Keys = " + qMap.keys());
-        System.out.println("Values = " + qMap.values());
-
-        qMap = new QueueMap();
-        for (int i = 0; i < 5; i++)
-        {
-            qMap.put(Integer.toString(i), "A");
-        }
-        System.out.println("\nMap = " + qMap);
-        System.out.println("Keys = " + qMap.keys());
-        System.out.println("Values = " + qMap.values());
-
-        qMap = new QueueMap();
-        for (int i = 0; i < 5; i++)
-        {
-            qMap.put(Integer.toString(i), null);
-        }
-        System.out.println("\nMap = " + qMap);
-        System.out.println("Keys = " + qMap.keys());
-        System.out.println("Values = " + qMap.values());
-
-        Map aMap = new HashMap();
-        for (int i = 0; i < 5; i++)
-        {
-            aMap.put(Integer.toString(i), Integer.toString(i));
-        }
-        qMap = new QueueMap( aMap );
-        System.out.println("\nHashMap = " + aMap);
-        System.out.println("Map = " + qMap);
-        System.out.println("Keys = " + qMap.keys());
-        System.out.println("Values = " + qMap.values());
-
-        qMap = new QueueMap();
-        qMap.put( "Test1", "String1" );
-        qMap.put( "Test2", "String2" );
-        qMap.put( "Test3", "String3" );
-        qMap.put( "Test4", "String4" );
-        qMap.put( "Test5", "String5" );
-        System.out.println("\nStandard Test, Map = " + qMap);
-        qMap.put( "Test6", "String6" );
-        qMap.put( "Test7", "String7" );
-        System.out.println("Put New Test, Map = " + qMap);
-        qMap.put( "Test2", "New String2" );
-        qMap.put( "Test6", "New String6" );
-        System.out.println("Put Existing Test, Map = " + qMap);
-        qMap.put( "Test5", null );
-        qMap.put( "Test8", null );
-        System.out.println("Put Null Test, Map = " + qMap);
-        qMap.remove( "Test1" );
-        qMap.remove( "Test3" );
-        qMap.remove( "Test5" );
-        qMap.remove( "Test9" );
-        System.out.println("Remove Test, Map = " + qMap);
-        System.out.println("             Keys = " + qMap.keys());
-        System.out.println("             Values = " + qMap.values());
-        qMap.clear();
-        qMap.put( "Test10", "String10" );
-        qMap.put( "Test11", "String11" );
-        qMap.put( "Test12", "String12" );
-        System.out.println("Clear Test, Map = " + qMap);
-
-        aMap = new HashMap();
-        aMap.put( "Test10", "String10" );
-        aMap.put( "Test11", "String11" );
-        aMap.put( "Test12", "String12" );
-        System.out.println("Equality Test, Equal = " + qMap.equals( aMap ));
-    }
+ * A queue based implementation of the Map interface. This class provides for
+ * all the opertions of a map, but keeps the entries in the same sequence as
+ * originally added. The first entry placed in the map will be the first entry
+ * retreived during iteration: first-in, first-out (FIFO). <BR>
+ * <BR>
+ *
+ * Keys cannot be duplicated. If an entry is made using a key that already
+ * exists, the value for that key will be replaced with that new value. There
+ * are no such restrictions on the values. The values may be null. <BR>
+ * <BR>
+ *
+ * Some convenience methods are provided for the queue type operations. The
+ * first key can be retreived as well as the last key. A key can be used to
+ * retreive its corresponding value from the map. A value can also be used to
+ * retreive its key from the map, however, since there may be multiple values of
+ * the same equality, the first key found will be returned. <BR>
+ * <BR>
+ *
+ * @author rglista@blacksmith.com
+ * @author mpowers@blacksmith.com
+ * @date $Date: 2006-02-18 17:41:36 -0500 (Sat, 18 Feb 2006) $
+ * @revision $Revision: 899 $
+ */
+public class QueueMap implements Map {
+	List values;
+	List keys;
+	Map keyToValue;
+
+	/**
+	 * Creates an empty QueueMap.
+	 */
+	public QueueMap() {
+		values = new LinkedList();
+		keys = new LinkedList();
+		keyToValue = new HashMap();
+	}
+
+	/**
+	 * Creates a QueueMap and places the entries from the passed in map into this
+	 * map. The order of the entries is based on however the iterator iteratated
+	 * through the map entries.
+	 * 
+	 * @param t A map object.
+	 */
+	public QueueMap(Map t) {
+		values = new ArrayList();
+		keys = new ArrayList();
+		keyToValue = new HashMap();
+
+		putAll(t);
+	}
+
+	/**
+	 * Removes all the entries from this map.
+	 */
+	public void clear() {
+		values.clear();
+		keys.clear();
+		keyToValue.clear();
+	}
+
+	/**
+	 * Tests to see if the key is contained in the map. If the key is present in the
+	 * map, then TRUE is returned, otherwise FALSE is returned. The equals()
+	 * operation is used to determine equality.
+	 * 
+	 * @return True if the map contains the given key, false otherwise.
+	 */
+	public boolean containsKey(Object key) {
+		return keyToValue.containsKey(key);
+	}
+
+	/**
+	 * Tests to see if the value is contained in the map. If the value is present in
+	 * the map, then TRUE is returned, otherwise FALSE is returned. The equals()
+	 * operation is used to determine equality. The value can be null and will
+	 * return TRUE if null is a value in the map. If TRUE is returned, then there
+	 * may be more than one values in the map.
+	 * 
+	 * @return True if the map contains the given value, false otherwise.
+	 */
+	public boolean containsValue(Object value) {
+		return keyToValue.containsValue(value);
+	}
+
+	/**
+	 * Returns a set view of the mappings contained in this map. Each element in the
+	 * returned set is a <tt>Map.Entry</tt>. The returned set is NOT backed by the
+	 * map, so changes to the map are NOT reflected in the set, and vice-versa. The
+	 * returned set is independent of this Map and its underlying structure.
+	 *
+	 * @return a set view of the mappings contained in this map.
+	 */
+	public Set entrySet() {
+		Set result = new HashSet(keys.size(), 1F);
+
+		for (int i = 0; i < keys.size(); i++) {
+			result.add(new KeyValuePair(keys.get(i), values.get(i)));
+		}
+
+		return result;
+	}
+
+	/**
+	 * Compares the specified object with this map for equality. Returns
+	 * <tt>true</tt> if the given object is also a map and the two Maps represent
+	 * the same mappings. More formally, two maps <tt>t1</tt> and <tt>t2</tt>
+	 * represent the same mappings if <tt>t1.entrySet().equals(t2.entrySet())</tt>.
+	 * This ensures that the <tt>equals</tt> method works properly across different
+	 * implementations of the <tt>Map</tt> interface.
+	 *
+	 * @param o object to be compared for equality with this map.
+	 * @return <tt>true</tt> if the specified object is equal to this map.
+	 */
+	public boolean equals(Object o) {
+		return keyToValue.equals(o);
+	}
+
+	/**
+	 * Returns the corresponding value for the given key. The returned value may be
+	 * null as that is a legal value in this map. However, if the key is not
+	 * contained in this map then null is also returned. Use the containsKey()
+	 * method to distinguish between the two cases.
+	 * 
+	 * @param key A key into the map.
+	 * @return The value corresponding to the key (can be null), or null if the key
+	 *         is not contained in the map.
+	 */
+	public Object get(Object key) {
+		return keyToValue.get(key);
+	}
+
+	/**
+	 * Returns the hash code value for this map. The hash code of a map is defined
+	 * to be the sum of the hashCodes of each entry in the map's entrySet view. This
+	 * ensures that <tt>t1.equals(t2)</tt> implies that
+	 * <tt>t1.hashCode()==t2.hashCode()</tt> for any two maps <tt>t1</tt> and
+	 * <tt>t2</tt>, as required by the general contract of Object.hashCode.
+	 *
+	 * @return the hash code value for this map.
+	 */
+	public int hashCode() {
+		return keyToValue.hashCode();
+	}
+
+	/**
+	 * Returns true is this map contains no key-value mappings.
+	 * 
+	 * @return True is this map contains no entries, false otherwise.
+	 */
+	public boolean isEmpty() {
+		return keyToValue.isEmpty();
+	}
+
+	/**
+	 * Returns the keys used in the map. There is no order implied in the returned
+	 * set and may be different than the the order in which they were inserted.
+	 * 
+	 * @return A Set containing all the keys used in the map.
+	 */
+	public Set keySet() {
+		Set result = new HashSet(keys.size(), 1F);
+
+		for (int i = 0; i < keys.size(); i++) {
+			result.add(keys.get(i));
+		}
+
+		return result;
+	}
+
+	/**
+	 * Places the key/value entry into the map at the end position. If the key
+	 * already exists in the map, then its value is replaced by the new given value.
+	 * The mapping does not change order in this case. The specified key cannot be
+	 * null.
+	 * 
+	 * @param key   The key to place into the map, cannot be null.
+	 * @param value The value to associate with the key, may be null.
+	 * @return Null if the key is new, the replaced value if the key already
+	 *         existed. (Note: If the key was null, then null is returned.)
+	 */
+	public Object put(Object key, Object value) {
+		if (key == null)
+			return null;
+
+		if (keys.contains(key)) {
+			values.remove(keys.indexOf(key));
+			values.add(keys.indexOf(key), value);
+		} else {
+			values.add(value);
+			keys.add(key);
+		}
+
+		return keyToValue.put(key, value);
+	}
+
+	/**
+	 * Places all the entries from this given map into this map. If the keys already
+	 * exist, then there values are replaced.
+	 * 
+	 * @param t A map of key/value entries.
+	 */
+	public void putAll(Map t) {
+		if (t == null) {
+			// Nothing to do!
+			return;
+		}
+
+		// Place the entries from the passed in map into this map.
+		for (Iterator it = t.keySet().iterator(); it.hasNext();) {
+			Object aKey = it.next();
+			put(aKey, t.get(aKey));
+		}
+	}
+
+	/**
+	 * Remove the mapping of the key and associated value from this map. Note: null
+	 * is a valid value in the map.
+	 * 
+	 * @param key A key to remove from the map, cannot be null.
+	 * @return The value of the removed mapping, null if the mapping did not exist.
+	 *         Null could also be returned if the associated value of the key was
+	 *         null.
+	 */
+	public Object remove(Object key) {
+		if (key == null)
+			return null;
+
+		Object value = null;
+
+		if (containsKey(key)) {
+			value = keyToValue.remove(key);
+			int i = values.indexOf(value);
+			if (i != -1) {
+				keys.remove(i);
+				values.remove(i);
+			}
+		}
+
+		return value;
+	}
+
+	/**
+	 * Returns the number of key/value pairs in this map.
+	 * 
+	 * @return The number of pairs.
+	 */
+	public int size() {
+		return values.size();
+	}
+
+	/**
+	 * Returns an ordered list of keys from the map. The order is the same as the
+	 * added order of the mapped items.<br>
+	 * NOTE: The returned list is the underlying keys list used by this class. If
+	 * modification are to be made to this list, it should be cloned first.
+	 * 
+	 * @return An ordered list of keys.
+	 */
+	public List keys() {
+		return keys;
+	}
+
+	/**
+	 * Returns an ordered list of values from the map. The order is the same as the
+	 * added order of the mapped items. NOTE: The returned list is the underlying
+	 * keys list used by this class. If modification are to be made to this list, it
+	 * should be cloned first.
+	 * 
+	 * @return An ordered list of values.
+	 */
+	public Collection values() {
+		return values;
+	}
+
+	/**
+	 * Returns the corresponding value for the given key. The returned value may be
+	 * null as that is a legal value in this map. However, if the key is not
+	 * contained in this map then null is also returned. Use the containsKey()
+	 * method to distinguish between the two cases.
+	 * 
+	 * @param key A key into the map.
+	 * @return The value corresponding to the key (can be null), or null if the key
+	 *         is not contained in the map.
+	 */
+	public Object getValueForKey(Object key) {
+		return keyToValue.get(key);
+	}
+
+	/**
+	 * Returns the associated key for this value. Since there may be more than one
+	 * of the same value in the map, this returns the first key associated with this
+	 * value. Null is returned if the value is not in the map.
+	 * 
+	 * @param value A value that is contained in this map.
+	 * @return A first key that corresponds to this value.
+	 */
+	public Object getKeyForValue(Object value) {
+		int i = values.indexOf(value);
+		if (i != -1) {
+			return keys.get(i);
+		}
+		return null;
+	}
+
+	/**
+	 * Returns the first key in the map. If the map is empty, then null is returned.
+	 * 
+	 * @return The first key in the map, null if there are no mappings.
+	 */
+	public Object getFirstKey() {
+		if (keys.size() < 1) {
+			return null;
+		}
+		return keys.get(0);
+	}
+
+	/**
+	 * Returns the last key in the map. If the map is empty, then null is returned.
+	 * 
+	 * @return The last key in the map, null if there are no mappings.
+	 */
+	public Object getLastKey() {
+		if (keys.size() < 1) {
+			return null;
+		}
+		return keys.get(keys.size() - 1);
+	}
+
+	/**
+	 * This class contains a key/value pair. The key must be a valid object, it
+	 * cannot be null. The value can be a valid object or null.
+	 */
+	static public class KeyValuePair implements Map.Entry {
+		Object key;
+		Object value;
+
+		/**
+		 * Default constructor. The constructor takes the key and value as parameters.
+		 * Since the key cannot be null, it must be specified during initialization. The
+		 * value can be null.
+		 * 
+		 * @param key   The key object of this pair. The key cannot be null.
+		 * @param value The value object of this pair. The value can be null.
+		 */
+		public KeyValuePair(Object aKey, Object aValue) {
+			key = aKey;
+			value = aValue;
+		}
+
+		/**
+		 * Returns the key object of this pair.
+		 * 
+		 * @return The key object.
+		 */
+		public Object getKey() {
+			return key;
+		}
+
+		/**
+		 * Returns the the value object of this pair. May be null.
+		 * 
+		 * @return The value object.
+		 */
+		public Object getValue() {
+			return value;
+		}
+
+		/**
+		 * Sets the value object of this pair. May be an object or null.
+		 * 
+		 * @param aValue The value object to place into this pair.
+		 */
+		public Object setValue(Object aValue) {
+			Object result = value;
+			value = aValue;
+			return result;
+		}
+
+		public boolean equals(Object o) {
+			if (o instanceof KeyValuePair) {
+				KeyValuePair p = (KeyValuePair) o;
+				if ((key.equals(p.getKey())) && (value.equals(p.getValue()))) {
+					return true;
+				}
+			}
+			return false;
+		}
+	}
+
+	/**
+	 * Returns a string reprsentation of this class. The contents of the map are
+	 * placed in the string in its proper order.
+	 */
+	public String toString() {
+		int max = size() - 1;
+		StringBuffer buf = new StringBuffer();
+
+		buf.append("{");
+		for (int j = 0; j <= max; j++) {
+			buf.append(keys.get(j) + "=" + values.get(j));
+			if (j < max) {
+				buf.append(", ");
+			}
+		}
+		buf.append("}");
+
+		return buf.toString();
+	}
+
+	// unit test
+	public static void main(String[] argv) {
+		QueueMap qMap;
+
+		qMap = new QueueMap();
+		for (int i = 0; i < 5; i++) {
+			qMap.put(Integer.toString(i), Integer.toString(i));
+		}
+		System.out.println("\nMap = " + qMap);
+		System.out.println("Keys = " + qMap.keys());
+		System.out.println("Values = " + qMap.values());
+
+		qMap = new QueueMap();
+		for (int i = 0; i < 5; i++) {
+			qMap.put(Integer.toString(i), "A");
+		}
+		System.out.println("\nMap = " + qMap);
+		System.out.println("Keys = " + qMap.keys());
+		System.out.println("Values = " + qMap.values());
+
+		qMap = new QueueMap();
+		for (int i = 0; i < 5; i++) {
+			qMap.put(Integer.toString(i), null);
+		}
+		System.out.println("\nMap = " + qMap);
+		System.out.println("Keys = " + qMap.keys());
+		System.out.println("Values = " + qMap.values());
+
+		Map aMap = new HashMap();
+		for (int i = 0; i < 5; i++) {
+			aMap.put(Integer.toString(i), Integer.toString(i));
+		}
+		qMap = new QueueMap(aMap);
+		System.out.println("\nHashMap = " + aMap);
+		System.out.println("Map = " + qMap);
+		System.out.println("Keys = " + qMap.keys());
+		System.out.println("Values = " + qMap.values());
+
+		qMap = new QueueMap();
+		qMap.put("Test1", "String1");
+		qMap.put("Test2", "String2");
+		qMap.put("Test3", "String3");
+		qMap.put("Test4", "String4");
+		qMap.put("Test5", "String5");
+		System.out.println("\nStandard Test, Map = " + qMap);
+		qMap.put("Test6", "String6");
+		qMap.put("Test7", "String7");
+		System.out.println("Put New Test, Map = " + qMap);
+		qMap.put("Test2", "New String2");
+		qMap.put("Test6", "New String6");
+		System.out.println("Put Existing Test, Map = " + qMap);
+		qMap.put("Test5", null);
+		qMap.put("Test8", null);
+		System.out.println("Put Null Test, Map = " + qMap);
+		qMap.remove("Test1");
+		qMap.remove("Test3");
+		qMap.remove("Test5");
+		qMap.remove("Test9");
+		System.out.println("Remove Test, Map = " + qMap);
+		System.out.println("             Keys = " + qMap.keys());
+		System.out.println("             Values = " + qMap.values());
+		qMap.clear();
+		qMap.put("Test10", "String10");
+		qMap.put("Test11", "String11");
+		qMap.put("Test12", "String12");
+		System.out.println("Clear Test, Map = " + qMap);
+
+		aMap = new HashMap();
+		aMap.put("Test10", "String10");
+		aMap.put("Test11", "String11");
+		aMap.put("Test12", "String12");
+		System.out.println("Equality Test, Equal = " + qMap.equals(aMap));
+	}
 
 }
-
-
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/URLResourceReader.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/URLResourceReader.java
index 9133a8d..8694564 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/URLResourceReader.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/URLResourceReader.java
@@ -47,7 +47,7 @@
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
- */ 
+ */
 
 package net.wotonomy.foundation.internal;
 
@@ -61,147 +61,134 @@ import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 
 /**
- * This implementation of URL Resource Reader assumes 2 types
- * of base urls. A base url that ends with / is considered a
- * resource folder, whereas a resource that does not end with
- * / is considered a zip/jar resource folder.
+ * This implementation of URL Resource Reader assumes 2 types of base urls. A
+ * base url that ends with / is considered a resource folder, whereas a resource
+ * that does not end with / is considered a zip/jar resource folder.
  *
- * If the resource folder happens is a zip/jar archive, the
- * entries are always cached.
- * For non-zip base urls, one could specify whether or not it should
- * be cached.
+ * If the resource folder happens is a zip/jar archive, the entries are always
+ * cached. For non-zip base urls, one could specify whether or not it should be
+ * cached.
  *
  * @author Harish Prabandham
  */
-public class URLResourceReader  {
-    private Hashtable resourceCache = new Hashtable();
-    private boolean iszip = true;
-    private URL url = null;
-    private boolean cache = true;
-
-    /**
-     * Creates a new URLResourceReader object. You can either give
-     * the URL of the zip/jar file or a base url where to
-     * look for additional resources. If the url ends with
-     * "/" then it is assumed to be  a Base URL. 
-     * @param The base url to look for the resources.
-     * @param If the base url is not a zip/jar, then true indicates
-     * that entries should be cached, false otherwise.
-     */
-    public URLResourceReader(URL baseurl, boolean cache) throws IOException {
-        this.url = baseurl;
-        this.cache = cache;
-        this.iszip = !url.getFile().endsWith("/");
-        if(this.iszip)
-            this.cache = true;
-        initialize();
-    }
-
-    /**
-     * equivalent to URLResourceReader(baseurl, false)
-     */
-    public URLResourceReader(URL baseurl) throws IOException {
-        this(baseurl, false);
-    }
-
-    /**
-     * Creates a new URLResourceReader object with the given
-     * input stream. The stream is assumed to be a zip/jar
-     * stream.
-     */
-    public URLResourceReader(InputStream is) throws IOException {
-        init(is);
-    }
-
-    private void initialize() throws IOException {
-        if(iszip) {
-            InputStream is = url.openStream();
-            init(is);
-            is.close();
-        }
-    }
-
-    private byte[] readFully(InputStream is) throws IOException {
-        byte[] buf = new byte[1024];
-        int num = 0;
-        ByteArrayOutputStream bout = new ByteArrayOutputStream();
-
-        while( (num = is.read(buf)) != -1) {
-            bout.write(buf, 0, num);
-        }
-
-        return bout.toByteArray();
-    }
-
-    private void init(InputStream is) throws IOException {
-        ZipInputStream zstream = new ZipInputStream(is);
-        ZipEntry entry;
-        
-        while( (entry = zstream.getNextEntry()) != null) {
-            byte[] entryData = readFully(zstream);
-            if(cache)
-                resourceCache.put(entry.getName(), entryData);
-            zstream.closeEntry();
-        }
-        
-        zstream.close();
-    }
-
-    /**
-     * Returns an Enumeration of all "known" resource names.
-     */
-    public Enumeration getResourceNames() {
-        return resourceCache.keys();
-    }
-
-    /**
-     * Returns an array of bytes read for this resource if the
-     * resource exists. This method blocks until the resource
-     * has been fully read. If the resource does not exist,
-     * this method returns null.
-     */
-    public byte[] getResource(String  resource) {
-        // lookup the data in the cache...
-        byte[] data = (byte[]) resourceCache.get(resource);
-        if(data != null) {
-            return data;
-        }
-
-        // if the data was to come from a zip file that we
-        // already read fully & cached , then it is probably
-        // not there.
-        if(iszip) {
-            return null;
-        }
-
-        // Now the only choice left is to make a url connection.
-        try {
-            URL realURL = new URL(url.getProtocol(), url.getHost(),
-                                  url.getFile() + resource);
-            data = readFully(realURL.openStream());
-            // add it to cache if needed...
-            if(cache)
-                resourceCache.put(resource, data);
-            return data;
-        } catch(Exception e) {
-            return null;
-        }
-    }
-
-    public void close() {
-        resourceCache.clear();
-        resourceCache = null;
-    }
-
-    public String toString() {
-	return url.toString();
-    }
+public class URLResourceReader {
+	private Hashtable resourceCache = new Hashtable();
+	private boolean iszip = true;
+	private URL url = null;
+	private boolean cache = true;
+
+	/**
+	 * Creates a new URLResourceReader object. You can either give the URL of the
+	 * zip/jar file or a base url where to look for additional resources. If the url
+	 * ends with "/" then it is assumed to be a Base URL.
+	 * 
+	 * @param The base url to look for the resources.
+	 * @param If  the base url is not a zip/jar, then true indicates that entries
+	 *            should be cached, false otherwise.
+	 */
+	public URLResourceReader(URL baseurl, boolean cache) throws IOException {
+		this.url = baseurl;
+		this.cache = cache;
+		this.iszip = !url.getFile().endsWith("/");
+		if (this.iszip)
+			this.cache = true;
+		initialize();
+	}
+
+	/**
+	 * equivalent to URLResourceReader(baseurl, false)
+	 */
+	public URLResourceReader(URL baseurl) throws IOException {
+		this(baseurl, false);
+	}
+
+	/**
+	 * Creates a new URLResourceReader object with the given input stream. The
+	 * stream is assumed to be a zip/jar stream.
+	 */
+	public URLResourceReader(InputStream is) throws IOException {
+		init(is);
+	}
+
+	private void initialize() throws IOException {
+		if (iszip) {
+			InputStream is = url.openStream();
+			init(is);
+			is.close();
+		}
+	}
+
+	private byte[] readFully(InputStream is) throws IOException {
+		byte[] buf = new byte[1024];
+		int num = 0;
+		ByteArrayOutputStream bout = new ByteArrayOutputStream();
+
+		while ((num = is.read(buf)) != -1) {
+			bout.write(buf, 0, num);
+		}
+
+		return bout.toByteArray();
+	}
+
+	private void init(InputStream is) throws IOException {
+		ZipInputStream zstream = new ZipInputStream(is);
+		ZipEntry entry;
+
+		while ((entry = zstream.getNextEntry()) != null) {
+			byte[] entryData = readFully(zstream);
+			if (cache)
+				resourceCache.put(entry.getName(), entryData);
+			zstream.closeEntry();
+		}
+
+		zstream.close();
+	}
+
+	/**
+	 * Returns an Enumeration of all "known" resource names.
+	 */
+	public Enumeration getResourceNames() {
+		return resourceCache.keys();
+	}
+
+	/**
+	 * Returns an array of bytes read for this resource if the resource exists. This
+	 * method blocks until the resource has been fully read. If the resource does
+	 * not exist, this method returns null.
+	 */
+	public byte[] getResource(String resource) {
+		// lookup the data in the cache...
+		byte[] data = (byte[]) resourceCache.get(resource);
+		if (data != null) {
+			return data;
+		}
+
+		// if the data was to come from a zip file that we
+		// already read fully & cached , then it is probably
+		// not there.
+		if (iszip) {
+			return null;
+		}
+
+		// Now the only choice left is to make a url connection.
+		try {
+			URL realURL = new URL(url.getProtocol(), url.getHost(), url.getFile() + resource);
+			data = readFully(realURL.openStream());
+			// add it to cache if needed...
+			if (cache)
+				resourceCache.put(resource, data);
+			return data;
+		} catch (Exception e) {
+			return null;
+		}
+	}
+
+	public void close() {
+		resourceCache.clear();
+		resourceCache = null;
+	}
+
+	public String toString() {
+		return url.toString();
+	}
 }
-
-
-
-
-
-
-
-
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/ValueConverter.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/ValueConverter.java
index d6bc797..7f28e06 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/ValueConverter.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/ValueConverter.java
@@ -17,6 +17,7 @@ License along with this library; if not, see http://www.gnu.org
 */
 
 package net.wotonomy.foundation.internal;
+
 import java.lang.reflect.Array;
 import java.lang.reflect.Constructor;
 import java.util.Collection;
@@ -25,694 +26,562 @@ import java.util.LinkedList;
 import java.util.Map;
 
 /**
-* A utility class to convert objects to a desired class.
-*
-* @author michael@mpowers.net
-* @author $Author: cgruber $
-* @version $Revision: 893 $
-*/
-public class ValueConverter
-{
-    /**
-    * Returns the specified object as converted to an instance of the 
-    * specified class, or null if the conversion could not be performed.
-    */
-    static public Object convertObjectToClass( Object anObject, Class aClass )
-    { 
-    	if ( aClass == String.class )
-        {
-            return getString( anObject );
-        }
-    	if ( aClass == Short.class )
-        {
-            return getShort( anObject );
-        }
-    	if ( aClass == short.class )
-        {
-            return getShort( anObject );
-        }
-    	if ( aClass == Integer.class )
-        {
-            return getInteger( anObject );
-        }
-    	if ( aClass == int.class )
-        {
-            return getInteger( anObject );
-        }
-    	if ( aClass == Long.class )
-        {
-            return getLong( anObject );
-        }
-    	if ( aClass == long.class )
-        {
-            return getLong( anObject );
-        }
-    	if ( aClass == Float.class )
-        {
-            return getFloat( anObject );
-        }
-    	if ( aClass == float.class )
-        {
-            return getFloat( anObject );
-        }
-    	if ( aClass == Double.class )
-        {
-            return getDouble( anObject );
-        }
-    	if ( aClass == double.class )
-        {
-            return getDouble( anObject );
-        }
-    	if ( aClass == java.util.Date.class )
-        {
-            return getDate( anObject );
-        }
-    	if ( aClass == Boolean.class )
-        {
-            return getBoolean( anObject );
-        }
-    	if ( aClass == boolean.class )
-        {
-            return getBoolean( anObject );
-        }
-    	if ( aClass == Character.class )
-        {
-            return getCharacter( anObject );
-        }
-    	if ( aClass == char.class )
-        {
-            return getCharacter( anObject );
-        }
-    	if ( aClass == Byte.class )
-        {
-            return getByte( anObject );
-        }
-    	if ( aClass == byte.class )
-        {
-            return getByte( anObject );
-        }
-    	if ( Collection.class.isAssignableFrom( aClass ) )
-        {
-            return getCollection( anObject, aClass );
-        }
-    	if ( aClass.isArray() )
-        {
-            return getArray( anObject, aClass );
-        }
-
-        return convert( anObject, aClass );
-    }
-    
-    /**
-    * Called by convertObjectToClass() when we need to 
-    * convert to an unrecognized type.
-    * This implementation scans the constructors of the 
-    * specified class for the best fit to the object.
-    * and returns a new instance with that constructor.
-    * Subclasses can override to directly support specific
-    * types.
-    */
-    static protected Object convert( Object anObject, Class aClass )
-    {
-        Constructor[] ctors = aClass.getConstructors();
-        
-        Class[] types;
-        for ( int i = 0; i < ctors.length; i++ )
-        {
-            types = ctors[i].getParameterTypes();
-            if ( types.length == 1 )
-            {
-                if ( types[0].equals( anObject.getClass() ) )
-                {
-                    try
-                    {
-                        return ctors[i].newInstance( new Object[] { anObject } );
-                    }
-                    catch ( Exception exc )
-                    {
-                        // fall through
-                    }
-                }
-            }
-        }
-        
-        for ( int i = 0; i < ctors.length; i++ )
-        {
-            types = ctors[i].getParameterTypes();
-            if ( types.length == 1 )
-            {
-                if ( anObject.getClass().isAssignableFrom( types[0] ) )
-                {
-                    try
-                    {
-                        return ctors[i].newInstance( new Object[] { anObject } );
-                    }
-                    catch ( Exception exc )
-                    {
-                        // fall through
-                    }
-                }
-            }
-        }
-        
-        return null;
-    }
-        
-    /**
-    * Tries to convert all objects to either Numbers or objects
-    * that will produce a parsable toString result.
-    */
-    static protected Object preprocess( Object anObject )
-    {
-        if ( anObject instanceof Boolean )
-        {
-            if ( ((Boolean)anObject).booleanValue() )
-            {
-                return new Double( 1.0 );
-            }
-            return new Double( 0.0 );
-        }
-
-        if ( anObject instanceof Character )
-        {
-            return anObject.toString();
-        }
-
-        return anObject;	
-    }
-    
-    static public short getShortValue( Object anObject )
-    {
-    	Short result = getShort( anObject );
-        return ( result == null ) ? (short) 0 : result.shortValue();
-    }
-    static public Short getShort( Object anObject )
-    {
-        if ( anObject == null ) return new Short( (short) 0 );
-        if ( "".equals( anObject ) ) return new Short( (short) 0 );
-		if ( anObject instanceof Short ) return (Short) anObject;
-
-		anObject = preprocess( anObject );
-
-        if ( anObject instanceof Number )
-        {
-            return new Short( ((Number)anObject).shortValue() );
-        }
-
-		try
-        {
-            return Short.valueOf( anObject.toString() );
-        }
-        catch ( Exception exc )
-        {
-            return null;
-        }
-    }	
-    
-    static public int getIntValue( Object anObject )
-    {
-    	Integer result = getInteger( anObject );
-        return ( result == null ) ? 0 : result.intValue();
-    }
-    static public Integer getInteger( Object anObject )
-    {
-        if ( anObject == null ) return new Integer( 0 );
-        if ( "".equals( anObject ) ) return new Integer( 0 );
-    	if ( anObject instanceof Integer ) return (Integer) anObject;
-    
-    	anObject = preprocess( anObject );
-
-        if ( anObject instanceof Number )
-        {
-            return new Integer( ((Number)anObject).intValue() );
-        }
-
-        try
-        {
-            return Integer.valueOf( anObject.toString() );
-        }
-        catch ( Exception exc )
-        {
-            return null;
-        }
-    }	
-    
-    static public long getLongValue ( Object anObject )
-    {
-    	Long result = getLong( anObject );
-        return ( result == null ) ? (long) 0 : result.longValue();
-    }
-    static public Long getLong( Object anObject )
-    {
-        if ( anObject == null ) return new Long( 0 );
-        if ( "".equals( anObject ) ) return new Long( 0 );
-    	if ( anObject instanceof Long ) return (Long) anObject;
-    
-    	anObject = preprocess( anObject );
-
-        if ( anObject instanceof Number )
-        {
-            return new Long( ((Number)anObject).longValue() );
-        }
-
-        try
-        {
-            return Long.valueOf( anObject.toString() );
-        }
-        catch ( Exception exc )
-        {
-            return null;
-        }
-    }	
-    
-    static public double getDoubleValue ( Object anObject )
-    {
-    	Double result = getDouble( anObject );
-        return ( result == null ) ? 0.0f : result.doubleValue();
-    }
-    static public Double getDouble( Object anObject )
-    {
-        if ( anObject == null ) return new Double( 0.0 );
-        if ( "".equals( anObject ) ) return new Double( 0 );
-    	if ( anObject instanceof Double ) return (Double) anObject;
-    
-    	anObject = preprocess( anObject );
-
-        if ( anObject instanceof Number )
-        {
-            return new Double( ((Number)anObject).doubleValue() );
-        }
-	
-        try
-        {
-            return Double.valueOf( anObject.toString() );
-        }
-        catch ( Exception exc )
-        {
-            return null;
-        }
-    }	
-    
-    static public float getFloatValue( Object anObject )
-    {
-    	Float result = getFloat( anObject );
-        return ( result == null ) ? 0.0f : result.floatValue();
-    }
-    static public Float getFloat( Object anObject )
-    {
-        if ( anObject == null ) return new Float( 0.0 );
-        if ( "".equals( anObject ) ) return new Float( 0.0 );
-    	if ( anObject instanceof Float ) return (Float) anObject;
-    
-    	anObject = preprocess( anObject );
-
-        if ( anObject instanceof Number )
-        {
-            return new Float( ((Number)anObject).floatValue() );
-        }
-	
-    	try
-        {
-            return Float.valueOf( anObject.toString() );
-        }
-        catch ( Exception exc )
-        {
-            return null;
-        }
-    }	
-        
-    static public char getCharValue( Object anObject )
-    {
-    	Character result = getCharacter( anObject );
-        return ( result == null ) ? (char) 0 : result.charValue();
-    }
-    static public Character getCharacter( Object anObject )
-    {
-        if ( anObject == null ) return new Character( (char) 0 );
-    	if ( anObject instanceof Character ) return (Character) anObject;
-    
-    	anObject = preprocess( anObject );
-
-        if ( anObject instanceof Number )
-        {
-            return new Character( (char) ((Number)anObject).byteValue() );
-        }
-
-        try
-        {
-            return new Character( anObject.toString().charAt( 0 ) );
-        }
-        catch ( Exception exc )
-        {
-            return null;
-        }
-    }
-
-    static public byte getByteValue( Object anObject )
-    {
-    	Byte result = getByte ( anObject );
-        return ( result == null ) ? (byte) 0 : result.byteValue();
-    }
-    static public Byte getByte( Object anObject )
-    {
-        if ( anObject == null ) return new Byte( Byte.MIN_VALUE );
-        if ( "".equals( anObject ) ) return new Byte( Byte.MIN_VALUE );
-    	if ( anObject instanceof Byte ) return (Byte) anObject;
-    
-    	anObject = preprocess( anObject );
-
-        if ( anObject instanceof Number )
-        {
-            return new Byte( ((Number)anObject).byteValue() );
-        }
-	
-    	try
-        {
-            return Byte.decode( anObject.toString() );
-        }
-        catch ( Exception exc )
-        {
-            // fall through
-        }
-    	
-        try
-        {
-            return Byte.valueOf( anObject.toString() );
-        }
-        catch ( Exception exc )
-        {
-            return null;
-        }
-    }
+ * A utility class to convert objects to a desired class.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 893 $
+ */
+public class ValueConverter {
+	/**
+	 * Returns the specified object as converted to an instance of the specified
+	 * class, or null if the conversion could not be performed.
+	 */
+	static public Object convertObjectToClass(Object anObject, Class aClass) {
+		if (aClass == String.class) {
+			return getString(anObject);
+		}
+		if (aClass == Short.class) {
+			return getShort(anObject);
+		}
+		if (aClass == short.class) {
+			return getShort(anObject);
+		}
+		if (aClass == Integer.class) {
+			return getInteger(anObject);
+		}
+		if (aClass == int.class) {
+			return getInteger(anObject);
+		}
+		if (aClass == Long.class) {
+			return getLong(anObject);
+		}
+		if (aClass == long.class) {
+			return getLong(anObject);
+		}
+		if (aClass == Float.class) {
+			return getFloat(anObject);
+		}
+		if (aClass == float.class) {
+			return getFloat(anObject);
+		}
+		if (aClass == Double.class) {
+			return getDouble(anObject);
+		}
+		if (aClass == double.class) {
+			return getDouble(anObject);
+		}
+		if (aClass == java.util.Date.class) {
+			return getDate(anObject);
+		}
+		if (aClass == Boolean.class) {
+			return getBoolean(anObject);
+		}
+		if (aClass == boolean.class) {
+			return getBoolean(anObject);
+		}
+		if (aClass == Character.class) {
+			return getCharacter(anObject);
+		}
+		if (aClass == char.class) {
+			return getCharacter(anObject);
+		}
+		if (aClass == Byte.class) {
+			return getByte(anObject);
+		}
+		if (aClass == byte.class) {
+			return getByte(anObject);
+		}
+		if (Collection.class.isAssignableFrom(aClass)) {
+			return getCollection(anObject, aClass);
+		}
+		if (aClass.isArray()) {
+			return getArray(anObject, aClass);
+		}
+
+		return convert(anObject, aClass);
+	}
+
+	/**
+	 * Called by convertObjectToClass() when we need to convert to an unrecognized
+	 * type. This implementation scans the constructors of the specified class for
+	 * the best fit to the object. and returns a new instance with that constructor.
+	 * Subclasses can override to directly support specific types.
+	 */
+	static protected Object convert(Object anObject, Class aClass) {
+		Constructor[] ctors = aClass.getConstructors();
+
+		Class[] types;
+		for (int i = 0; i < ctors.length; i++) {
+			types = ctors[i].getParameterTypes();
+			if (types.length == 1) {
+				if (types[0].equals(anObject.getClass())) {
+					try {
+						return ctors[i].newInstance(new Object[] { anObject });
+					} catch (Exception exc) {
+						// fall through
+					}
+				}
+			}
+		}
+
+		for (int i = 0; i < ctors.length; i++) {
+			types = ctors[i].getParameterTypes();
+			if (types.length == 1) {
+				if (anObject.getClass().isAssignableFrom(types[0])) {
+					try {
+						return ctors[i].newInstance(new Object[] { anObject });
+					} catch (Exception exc) {
+						// fall through
+					}
+				}
+			}
+		}
+
+		return null;
+	}
+
+	/**
+	 * Tries to convert all objects to either Numbers or objects that will produce a
+	 * parsable toString result.
+	 */
+	static protected Object preprocess(Object anObject) {
+		if (anObject instanceof Boolean) {
+			if (((Boolean) anObject).booleanValue()) {
+				return new Double(1.0);
+			}
+			return new Double(0.0);
+		}
+
+		if (anObject instanceof Character) {
+			return anObject.toString();
+		}
+
+		return anObject;
+	}
+
+	static public short getShortValue(Object anObject) {
+		Short result = getShort(anObject);
+		return (result == null) ? (short) 0 : result.shortValue();
+	}
+
+	static public Short getShort(Object anObject) {
+		if (anObject == null)
+			return new Short((short) 0);
+		if ("".equals(anObject))
+			return new Short((short) 0);
+		if (anObject instanceof Short)
+			return (Short) anObject;
+
+		anObject = preprocess(anObject);
+
+		if (anObject instanceof Number) {
+			return new Short(((Number) anObject).shortValue());
+		}
+
+		try {
+			return Short.valueOf(anObject.toString());
+		} catch (Exception exc) {
+			return null;
+		}
+	}
+
+	static public int getIntValue(Object anObject) {
+		Integer result = getInteger(anObject);
+		return (result == null) ? 0 : result.intValue();
+	}
+
+	static public Integer getInteger(Object anObject) {
+		if (anObject == null)
+			return new Integer(0);
+		if ("".equals(anObject))
+			return new Integer(0);
+		if (anObject instanceof Integer)
+			return (Integer) anObject;
+
+		anObject = preprocess(anObject);
+
+		if (anObject instanceof Number) {
+			return new Integer(((Number) anObject).intValue());
+		}
+
+		try {
+			return Integer.valueOf(anObject.toString());
+		} catch (Exception exc) {
+			return null;
+		}
+	}
+
+	static public long getLongValue(Object anObject) {
+		Long result = getLong(anObject);
+		return (result == null) ? (long) 0 : result.longValue();
+	}
+
+	static public Long getLong(Object anObject) {
+		if (anObject == null)
+			return new Long(0);
+		if ("".equals(anObject))
+			return new Long(0);
+		if (anObject instanceof Long)
+			return (Long) anObject;
+
+		anObject = preprocess(anObject);
+
+		if (anObject instanceof Number) {
+			return new Long(((Number) anObject).longValue());
+		}
+
+		try {
+			return Long.valueOf(anObject.toString());
+		} catch (Exception exc) {
+			return null;
+		}
+	}
+
+	static public double getDoubleValue(Object anObject) {
+		Double result = getDouble(anObject);
+		return (result == null) ? 0.0f : result.doubleValue();
+	}
+
+	static public Double getDouble(Object anObject) {
+		if (anObject == null)
+			return new Double(0.0);
+		if ("".equals(anObject))
+			return new Double(0);
+		if (anObject instanceof Double)
+			return (Double) anObject;
+
+		anObject = preprocess(anObject);
+
+		if (anObject instanceof Number) {
+			return new Double(((Number) anObject).doubleValue());
+		}
+
+		try {
+			return Double.valueOf(anObject.toString());
+		} catch (Exception exc) {
+			return null;
+		}
+	}
+
+	static public float getFloatValue(Object anObject) {
+		Float result = getFloat(anObject);
+		return (result == null) ? 0.0f : result.floatValue();
+	}
+
+	static public Float getFloat(Object anObject) {
+		if (anObject == null)
+			return new Float(0.0);
+		if ("".equals(anObject))
+			return new Float(0.0);
+		if (anObject instanceof Float)
+			return (Float) anObject;
+
+		anObject = preprocess(anObject);
+
+		if (anObject instanceof Number) {
+			return new Float(((Number) anObject).floatValue());
+		}
+
+		try {
+			return Float.valueOf(anObject.toString());
+		} catch (Exception exc) {
+			return null;
+		}
+	}
+
+	static public char getCharValue(Object anObject) {
+		Character result = getCharacter(anObject);
+		return (result == null) ? (char) 0 : result.charValue();
+	}
+
+	static public Character getCharacter(Object anObject) {
+		if (anObject == null)
+			return new Character((char) 0);
+		if (anObject instanceof Character)
+			return (Character) anObject;
+
+		anObject = preprocess(anObject);
+
+		if (anObject instanceof Number) {
+			return new Character((char) ((Number) anObject).byteValue());
+		}
+
+		try {
+			return new Character(anObject.toString().charAt(0));
+		} catch (Exception exc) {
+			return null;
+		}
+	}
+
+	static public byte getByteValue(Object anObject) {
+		Byte result = getByte(anObject);
+		return (result == null) ? (byte) 0 : result.byteValue();
+	}
+
+	static public Byte getByte(Object anObject) {
+		if (anObject == null)
+			return new Byte(Byte.MIN_VALUE);
+		if ("".equals(anObject))
+			return new Byte(Byte.MIN_VALUE);
+		if (anObject instanceof Byte)
+			return (Byte) anObject;
+
+		anObject = preprocess(anObject);
+
+		if (anObject instanceof Number) {
+			return new Byte(((Number) anObject).byteValue());
+		}
+
+		try {
+			return Byte.decode(anObject.toString());
+		} catch (Exception exc) {
+			// fall through
+		}
+
+		try {
+			return Byte.valueOf(anObject.toString());
+		} catch (Exception exc) {
+			return null;
+		}
+	}
 
 	/**
-	* Calls getBoolean and converts result to primitive.
-	*/
-    static public boolean getBooleanValue( Object anObject )
-    {
-    	Boolean result = getBoolean( anObject );
-        return ( result == null ) ? false : result.booleanValue();
-    }
-	
+	 * Calls getBoolean and converts result to primitive.
+	 */
+	static public boolean getBooleanValue(Object anObject) {
+		Boolean result = getBoolean(anObject);
+		return (result == null) ? false : result.booleanValue();
+	}
+
 	/**
-	* Numbers equal to zero are true; Strings equal to "yes" are true;
-	* Strings are then passed to the Boolean constructor.
-	* Other values return null.
-	*/
-    static public Boolean getBoolean( Object anObject )
-    {		
-		if ( anObject instanceof Boolean )
-		{
+	 * Numbers equal to zero are true; Strings equal to "yes" are true; Strings are
+	 * then passed to the Boolean constructor. Other values return null.
+	 */
+	static public Boolean getBoolean(Object anObject) {
+		if (anObject instanceof Boolean) {
 			return (Boolean) anObject;
 		}
-    	if ( anObject instanceof Number )
-        {
-            return new Boolean( ((Number)anObject).doubleValue() == 0.0 );
-        }
-    
-    	if ( anObject instanceof String )
-        {
-			if ( anObject.toString().toLowerCase().equals( "yes" ) ) 
-			{
+		if (anObject instanceof Number) {
+			return new Boolean(((Number) anObject).doubleValue() == 0.0);
+		}
+
+		if (anObject instanceof String) {
+			if (anObject.toString().toLowerCase().equals("yes")) {
 				return Boolean.TRUE;
 			}
-            return new Boolean( (String) anObject );
-        }
-	
-        return null;
-    }
-    
-    /**
-    * Get an appropriate String representation for the 
-    * object.  Nulls are converted to "null".  Date are
-    * formatted according to the current date format.
-    * All else uses toString.
-    */
-    static public String getString( Object anObject )
-    {
-        if ( anObject == null ) return "null";
-        if ( anObject instanceof java.util.Date )
-        {
-            return dateFormat.format( (java.util.Date) anObject );
-        }
-        return anObject.toString();
-    }
-
-    /**
-    * Converts the object into the specified collection class.
-    * If unable to convert in any other way, resorts to creating
-    * a new collection of the specified type containing the
-    * specified object.
-    */
-    static public Collection getCollection( Object anObject, Class aCollectionClass )
-    {
-        if ( anObject == null ) return null;
-        if ( aCollectionClass.isAssignableFrom( anObject.getClass() ) )
-        {
-            return (Collection) anObject;
-        }
-        
-        Collection converted = null;
-        
-        // convert to collection class
-        if ( anObject instanceof Collection )
-        {
-            converted = (Collection) anObject;
-        }
-        else
-        // try to convert an array
-        if ( anObject.getClass().isArray() )
-        {
-            try
-            {
-                int length = Array.getLength( anObject );
-                converted = new LinkedList();
-                for ( int i = 0; i < length; i++ )
-                {
-                    converted.add( Array.get( anObject, i ) );
-                }
-            }
-            catch ( Exception exc )
-            {
-                // try another approach   
-            }
-        }
-        else
-        // convert map values to collection and pass through
-        if ( anObject instanceof Map )
-        {
-            converted = ((Map)anObject).values();
-        }
-
-        // fall back on list containing the object
-        if ( converted == null )
-        {
-            converted = new LinkedList();
-            converted.add( anObject );
-        }
-        
-        Collection result = null;
-        
-        if ( converted != null )
-        {
-            try
-            {
-                // collections required to have the copy constructor.
-                Constructor ctor = aCollectionClass.getConstructor(
-                    new Class[] { Collection.class } );        
-                result = (Collection) ctor.newInstance( new Object[] { converted } );
-            }
-            catch ( Exception exc )
-            {
-                try
-                {
-                    result = new LinkedList();
-                    result.addAll( converted );
-                }
-                catch ( Exception exc2 )
-                {
-                    // all attempts failed
-                    result = null;
-                }
-            }
-        }
-        
-        return result;
-    }
-
-    /**
-    * Convert the object to the specified array type.
-    */
-    static public Object getArray( Object anObject, Class anArrayClass )
-    {
-        if ( anObject == null ) return null;
-        
-        // try to convert an array
-        if ( anObject.getClass().isArray() )
-        {
-            try
-            {
-                int length = Array.getLength( anObject );
-                Object result = Array.newInstance( 
-                    anArrayClass.getComponentType(), length );
-                for ( int i = 0; i < length; i++ )
-                {
-                    Array.set( result, i, Array.get( anObject, i ) );
-                }
-                return result;
-            }
-            catch ( Exception exc )
-            {
-                // try another approach   
-            }
-        }
-        // convert map values to collection and pass through
-        if ( anObject instanceof Map )
-        {
-            anObject = ((Map)anObject).values();
-        }
-        // try to convert a collection
-        if ( anObject instanceof Collection )
-        {
-            try
-            {
-                int length = ((Collection)anObject).size();
-                Object result = Array.newInstance( 
-                    anArrayClass.getComponentType(), length );
-                Iterator it = ((Collection)anObject).iterator();
-                for ( int i = 0; i < length; i++ )
-                {
-                    Array.set( result, i, it.next() ); 
-                }
-                return result;
-            }
-            catch ( Exception exc )
-            {
-                // try another approach   
-            }
-        }
-        // if appropriate type, put the object in a single element array
-        if ( anObject.getClass().equals( anArrayClass.getComponentType() ) )
-        {
-            try
-            {
-                Object result = Array.newInstance( 
-                    anArrayClass.getComponentType(), 1 );
-                Array.set( result, 0, anObject ); 
-                return result;
-            }
-            catch ( Exception exc )
-            {
-                // try another approach   
-            }
-        }
-        return null;
-    }
-
-    /**
-    * Get an appropriate Date from the given object.
-    */
-    static public java.util.Date getDate( Object anObject )
-    {
-        if ( anObject == null ) return new java.util.Date( 0 );
-    	if ( anObject instanceof java.util.Date ) 
-	    	return (java.util.Date) anObject;
-	
-        if ( anObject instanceof Number )
-        {
-            return new java.util.Date( getLongValue( anObject ) );
-        }
-
-        try
-        {
-            return dateFormat.parse( anObject.toString() );
-        }
-        catch ( Exception exc )
-        {
-            return null;
-        }
-    }
-
-    static private java.text.DateFormat dateFormat = 
-    	new java.text.SimpleDateFormat();
-    static public java.text.DateFormat getDateFormat()
-    {
-    	return dateFormat;
-    }
-    static public void setDateFormat( java.text.DateFormat aDateFormat )
-    {
-    	if ( aDateFormat != null )
-        {
-            dateFormat = aDateFormat;
-        }
-    }
-
-    /**
-    * Returns the "inverted" value of the specified object.
-    * Numbers except for chars and bytes are converted to 
-    * their negative representation.  Chars and bytes are
-    * treated as booleans.  String are converted to booleans.
-    * Booleans are converted to their opposite.
-    * All other types return null.
-    */    
-    public static Object invert( Object anObject )
-    {
-        if ( anObject == null ) return null;
-        Class aClass = anObject.getClass();
-        
-    	if ( ( ( anObject instanceof Number )
-           &&! ( anObject instanceof Byte )
-           &&! ( anObject instanceof Character ) )
-          || ( aClass == short.class )
-          || ( aClass == int.class )
-          || ( aClass == long.class )
-          || ( aClass == float.class )
-          || ( aClass == double.class ) )
-        {
-            return convertObjectToClass( 
-                new Double( getDoubleValue( anObject ) * -1 ), aClass );
-        }
-        
-        Boolean converted = getBoolean( anObject );
-        if ( converted != null )
-        {
-            if ( converted.booleanValue() )
-            {
-                return convertObjectToClass(
-                    Boolean.FALSE, anObject.getClass() );
-            }
-            else
-            {
-                return convertObjectToClass(
-                    Boolean.TRUE, anObject.getClass() );
-            }
-        }
-        
-        return null;
-    }
+			return new Boolean((String) anObject);
+		}
+
+		return null;
+	}
+
+	/**
+	 * Get an appropriate String representation for the object. Nulls are converted
+	 * to "null". Date are formatted according to the current date format. All else
+	 * uses toString.
+	 */
+	static public String getString(Object anObject) {
+		if (anObject == null)
+			return "null";
+		if (anObject instanceof java.util.Date) {
+			return dateFormat.format((java.util.Date) anObject);
+		}
+		return anObject.toString();
+	}
+
+	/**
+	 * Converts the object into the specified collection class. If unable to convert
+	 * in any other way, resorts to creating a new collection of the specified type
+	 * containing the specified object.
+	 */
+	static public Collection getCollection(Object anObject, Class aCollectionClass) {
+		if (anObject == null)
+			return null;
+		if (aCollectionClass.isAssignableFrom(anObject.getClass())) {
+			return (Collection) anObject;
+		}
+
+		Collection converted = null;
+
+		// convert to collection class
+		if (anObject instanceof Collection) {
+			converted = (Collection) anObject;
+		} else
+		// try to convert an array
+		if (anObject.getClass().isArray()) {
+			try {
+				int length = Array.getLength(anObject);
+				converted = new LinkedList();
+				for (int i = 0; i < length; i++) {
+					converted.add(Array.get(anObject, i));
+				}
+			} catch (Exception exc) {
+				// try another approach
+			}
+		} else
+		// convert map values to collection and pass through
+		if (anObject instanceof Map) {
+			converted = ((Map) anObject).values();
+		}
+
+		// fall back on list containing the object
+		if (converted == null) {
+			converted = new LinkedList();
+			converted.add(anObject);
+		}
+
+		Collection result = null;
+
+		if (converted != null) {
+			try {
+				// collections required to have the copy constructor.
+				Constructor ctor = aCollectionClass.getConstructor(new Class[] { Collection.class });
+				result = (Collection) ctor.newInstance(new Object[] { converted });
+			} catch (Exception exc) {
+				try {
+					result = new LinkedList();
+					result.addAll(converted);
+				} catch (Exception exc2) {
+					// all attempts failed
+					result = null;
+				}
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Convert the object to the specified array type.
+	 */
+	static public Object getArray(Object anObject, Class anArrayClass) {
+		if (anObject == null)
+			return null;
+
+		// try to convert an array
+		if (anObject.getClass().isArray()) {
+			try {
+				int length = Array.getLength(anObject);
+				Object result = Array.newInstance(anArrayClass.getComponentType(), length);
+				for (int i = 0; i < length; i++) {
+					Array.set(result, i, Array.get(anObject, i));
+				}
+				return result;
+			} catch (Exception exc) {
+				// try another approach
+			}
+		}
+		// convert map values to collection and pass through
+		if (anObject instanceof Map) {
+			anObject = ((Map) anObject).values();
+		}
+		// try to convert a collection
+		if (anObject instanceof Collection) {
+			try {
+				int length = ((Collection) anObject).size();
+				Object result = Array.newInstance(anArrayClass.getComponentType(), length);
+				Iterator it = ((Collection) anObject).iterator();
+				for (int i = 0; i < length; i++) {
+					Array.set(result, i, it.next());
+				}
+				return result;
+			} catch (Exception exc) {
+				// try another approach
+			}
+		}
+		// if appropriate type, put the object in a single element array
+		if (anObject.getClass().equals(anArrayClass.getComponentType())) {
+			try {
+				Object result = Array.newInstance(anArrayClass.getComponentType(), 1);
+				Array.set(result, 0, anObject);
+				return result;
+			} catch (Exception exc) {
+				// try another approach
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Get an appropriate Date from the given object.
+	 */
+	static public java.util.Date getDate(Object anObject) {
+		if (anObject == null)
+			return new java.util.Date(0);
+		if (anObject instanceof java.util.Date)
+			return (java.util.Date) anObject;
+
+		if (anObject instanceof Number) {
+			return new java.util.Date(getLongValue(anObject));
+		}
+
+		try {
+			return dateFormat.parse(anObject.toString());
+		} catch (Exception exc) {
+			return null;
+		}
+	}
+
+	static private java.text.DateFormat dateFormat = new java.text.SimpleDateFormat();
+
+	static public java.text.DateFormat getDateFormat() {
+		return dateFormat;
+	}
+
+	static public void setDateFormat(java.text.DateFormat aDateFormat) {
+		if (aDateFormat != null) {
+			dateFormat = aDateFormat;
+		}
+	}
+
+	/**
+	 * Returns the "inverted" value of the specified object. Numbers except for
+	 * chars and bytes are converted to their negative representation. Chars and
+	 * bytes are treated as booleans. String are converted to booleans. Booleans are
+	 * converted to their opposite. All other types return null.
+	 */
+	public static Object invert(Object anObject) {
+		if (anObject == null)
+			return null;
+		Class aClass = anObject.getClass();
+
+		if (((anObject instanceof Number) && !(anObject instanceof Byte) && !(anObject instanceof Character))
+				|| (aClass == short.class) || (aClass == int.class) || (aClass == long.class) || (aClass == float.class)
+				|| (aClass == double.class)) {
+			return convertObjectToClass(new Double(getDoubleValue(anObject) * -1), aClass);
+		}
+
+		Boolean converted = getBoolean(anObject);
+		if (converted != null) {
+			if (converted.booleanValue()) {
+				return convertObjectToClass(Boolean.FALSE, anObject.getClass());
+			} else {
+				return convertObjectToClass(Boolean.TRUE, anObject.getClass());
+			}
+		}
+
+		return null;
+	}
 }
 
 /*
- * $Log$
- * Revision 1.2  2006/02/16 13:11:47  cgruber
- * Check in all sources in eclipse-friendly maven-enabled packages.
+ * $Log$ Revision 1.2 2006/02/16 13:11:47 cgruber Check in all sources in
+ * eclipse-friendly maven-enabled packages.
  *
- * Revision 1.4  2002/10/11 15:33:53  mpowers
- * Now supporting "!" to invert the value of a string property.
+ * Revision 1.4 2002/10/11 15:33:53 mpowers Now supporting "!" to invert the
+ * value of a string property.
  *
- * Revision 1.3  2001/07/02 16:29:08  mpowers
- * XMLRPC decoder was relying on ValueConverter to convert LinkedLists into
- * the appropriate type.  This is now implemented in ValueConverter.
+ * Revision 1.3 2001/07/02 16:29:08 mpowers XMLRPC decoder was relying on
+ * ValueConverter to convert LinkedLists into the appropriate type. This is now
+ * implemented in ValueConverter.
  *
- * Revision 1.2  2001/03/01 20:36:35  mpowers
- * Better error handling and better handling of nulls.
+ * Revision 1.2 2001/03/01 20:36:35 mpowers Better error handling and better
+ * handling of nulls.
  *
- * Revision 1.1.1.1  2000/12/21 15:52:33  mpowers
- * Contributing wotonomy.
+ * Revision 1.1.1.1 2000/12/21 15:52:33 mpowers Contributing wotonomy.
  *
- * Revision 1.8  2000/12/20 16:25:48  michael
- * Added log to all files.
+ * Revision 1.8 2000/12/20 16:25:48 michael Added log to all files.
  *
  *
  */
-
diff --git a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/WotonomyException.java b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/WotonomyException.java
index e2210d0..21b47b3 100644
--- a/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/WotonomyException.java
+++ b/projects/net.wotonomy.foundation/src/main/java/net/wotonomy/foundation/internal/WotonomyException.java
@@ -22,113 +22,96 @@ import java.io.PrintStream;
 import java.io.PrintWriter;
 
 /**
-* This is a simple RuntimeException that can encapsulate
-* another throwable.  Behaves as a normal RuntimeException
-* except that it prints a stack trace of the wrapped 
-* throwable if one is specified.
-*
-* Intended to be used anytime you'd 
-* report an exception with System.out.println: that is,
-* for debugging and non-user-visible exceptions.
-*
-* @author michael@mpowers.net
-* @author $Author: cgruber $
-* @version $Revision: 893 $
-*/
+ * This is a simple RuntimeException that can encapsulate another throwable.
+ * Behaves as a normal RuntimeException except that it prints a stack trace of
+ * the wrapped throwable if one is specified.
+ *
+ * Intended to be used anytime you'd report an exception with
+ * System.out.println: that is, for debugging and non-user-visible exceptions.
+ *
+ * @author michael@mpowers.net
+ * @author $Author: cgruber $
+ * @version $Revision: 893 $
+ */
 
-public class WotonomyException extends RuntimeException
-{
+public class WotonomyException extends RuntimeException {
 	protected String message;
 	protected Throwable wrappedThrowable;
-	
+
 	/**
-	* Default constructor.
-	*/ 
-	public WotonomyException()
-	{
+	 * Default constructor.
+	 */
+	public WotonomyException() {
 		super();
 		message = null;
-		wrappedThrowable = null;	
+		wrappedThrowable = null;
 	}
-	
+
 	/**
-	* Standard constructor with message.
-	*/
-	public WotonomyException( String aMessage )
-	{
-		super( aMessage );
+	 * Standard constructor with message.
+	 */
+	public WotonomyException(String aMessage) {
+		super(aMessage);
 		message = aMessage;
 		wrappedThrowable = null;
 	}
-	
+
 	/**
-	* Specifies a throwable to wrap.
-	*/ 
-	public WotonomyException( Throwable aThrowable )
-	{
+	 * Specifies a throwable to wrap.
+	 */
+	public WotonomyException(Throwable aThrowable) {
 		super();
 		message = null;
 		wrappedThrowable = aThrowable;
 	}
-	
+
 	/**
-	* Specifies a message and a throwable to wrap.
-	*/ 
-	public WotonomyException( String aMessage, Throwable aThrowable )
-	{
-		super( aMessage );
+	 * Specifies a message and a throwable to wrap.
+	 */
+	public WotonomyException(String aMessage, Throwable aThrowable) {
+		super(aMessage);
 		message = aMessage;
 		wrappedThrowable = aThrowable;
 	}
-    
-    /**
-    * Returns the wrapped throwable.
-    */
-    public Throwable getWrappedThrowable()
-    {
-        return wrappedThrowable;   
-    }
-	
-	public void printStackTrace(PrintWriter s)
-	{
-		if ( message != null )
-		{
-			s.println( "Exception: " + message );	
+
+	/**
+	 * Returns the wrapped throwable.
+	 */
+	public Throwable getWrappedThrowable() {
+		return wrappedThrowable;
+	}
+
+	public void printStackTrace(PrintWriter s) {
+		if (message != null) {
+			s.println("Exception: " + message);
 		}
-		if ( wrappedThrowable != null )
-		{
-			wrappedThrowable.printStackTrace( s );
+		if (wrappedThrowable != null) {
+			wrappedThrowable.printStackTrace(s);
 			return;
 		}
-		super.printStackTrace( s );
+		super.printStackTrace(s);
 	}
-	
-	public void printStackTrace(PrintStream s)
-	{
-		if ( message != null )
-		{
-			s.println( "Exception: " + message );	
+
+	public void printStackTrace(PrintStream s) {
+		if (message != null) {
+			s.println("Exception: " + message);
 		}
-		if ( wrappedThrowable != null )
-		{
-			wrappedThrowable.printStackTrace( s );	
+		if (wrappedThrowable != null) {
+			wrappedThrowable.printStackTrace(s);
 			return;
 		}
-		super.printStackTrace( s );
+		super.printStackTrace(s);
 	}
-	
-	public void printStackTrace()
-	{
-		if ( message != null )
-		{
-			System.err.println( "Exception: " + message );	
+
+	public void printStackTrace() {
+		if (message != null) {
+			System.err.println("Exception: " + message);
 		}
-		if ( wrappedThrowable != null )
-		{
-			wrappedThrowable.printStackTrace();	
+		if (wrappedThrowable != null) {
+			wrappedThrowable.printStackTrace();
 			return;
 		}
 		super.printStackTrace();
 	}
-	
+
 }