Initial import from SVN

1 files changed, 362 insertions, 0 deletions

diff --git a/projects/net.wotonomy.test/src/main/java/net/wotonomy/test/TestObject.java b/projects/net.wotonomy.test/src/main/java/net/wotonomy/test/TestObject.java
new file mode 100644
index 0000000..72a3dbc
--- /dev/null
+++ b/projects/net.wotonomy.test/src/main/java/net/wotonomy/test/TestObject.java
@@ -0,0 +1,362 @@
+package net.wotonomy.test;
+
+import java.io.Serializable;
+import java.util.Date;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+import net.wotonomy.control.EOEditingContext;
+import net.wotonomy.control.EOKeyValueCodingSupport;
+import net.wotonomy.datastore.DataSoup;
+import net.wotonomy.datastore.SerializedFileSoup;
+import net.wotonomy.datastore.XMLFileSoup;
+import net.wotonomy.foundation.internal.ValueConverter;
+
+public class TestObject implements Serializable // , EOKeyValueCoding
+{
+    static final long serialVersionUID = -5482454640042392838L;
+    
+// for testing manual array faulting
+public EOEditingContext editingContext;
+public EOEditingContext getEditingContext() { return editingContext; };
+    
+    public TestObject()
+    {
+    	date = new Date();
+    	firstName = randomParse(
+            "Bert|Ernie|Elmo|Zoe|Arthur|Emily|DJ|Grover|Oscar|Max|Big|Twinkle");
+        middleName = new StringBuffer( randomParse(
+            "Rufus|Remy|Martin|Josephus|Ulysses|Homer|Bart|Tip|Onegin|Meredith|Jay") );
+        lastName = randomParse(
+            "Alejandro|Alexander|Bird|Gosling|Joy|Van Hoff|Pedia|Marr|McNealy|Ping");
+        address = randomParse( "1|2|3|4" ) + randomParse( "0|1|00|10|5|50" ) +
+            randomParse( "0|00|1|01|5|05|9|09||000" ) +	" " + randomParse(
+            "Merry|Berry|Perry|Jerry|Meadow|Falls|Elm|Raspberry|Strawberry") + " "
+            + randomParse( "Road|Lane|Court|Drive|Parkway|Terrace" );
+        city = randomParse(
+            "Springfield|Sterling|Cascades|Vienna|Reston|Paris|London|Runnymeade");
+        state = randomParse(
+            "TX|NJ|NY|VA|DC|MD|NC|SC|WV|AR|FL|CA|TN" );
+        zip = ValueConverter.getIntValue(
+            randomParse( "1|2|3|4" ) + "0" + randomParse( "0|1|2|3|5" ) +
+            randomParse( "6|7|8|9" ) +	randomParse( "6|7|8|9" ) );
+        age = (short) ( new Random().nextDouble() * 40 + 18 );
+		childCount = -1;
+//	    children = null;
+        childList = null;
+    }
+    
+    protected Date date;
+    public Date getCreateDate() { return date; }
+    public void setCreateDate( Date aDate ) { date = aDate; }
+    
+    protected String firstName;
+    public String getFirstName() { return firstName; }
+    public void setFirstName( String aName ) { firstName = aName; }
+    
+    protected String lastName;
+    public String getLastName() { return lastName; }
+    public void setLastName( String aName ) { 
+        if ( "Jones".equals( aName ) ) throw new RuntimeException( "Jones not allowed" ) ;
+        lastName = aName; 
+    }
+    
+    protected StringBuffer middleName;
+    public StringBuffer getMiddleName() { return middleName; }
+    public void setMiddleName( StringBuffer aName ) { middleName = aName; }
+    
+    protected String address;
+    public String getAddress() { return address; }
+    public void setAddress( String anAddress ) { address = anAddress; }
+    
+    protected String city;
+    public String getCity() { return city; }
+    public void setCity( String aCity ) { city = aCity; }
+    
+    protected String state;
+    public String getState() { return state; }
+    public void setState( String aState ) { state = aState; }
+        
+    protected int zip;
+    public int getZipCode() { return zip; }
+    public void setZipCode( int aZipCode ) { zip = aZipCode; }
+        
+    protected short age;
+    public short getAge() { return age; }
+    public void setAge( short anAge ) { age = anAge; }
+    
+    protected boolean special;
+    public Boolean isSpecial() { return new Boolean( special ); }
+    public void setSpecial( Boolean isSpecial ) { special = isSpecial.booleanValue(); }
+	
+/*	
+	protected Object[] children;
+    
+	private Object[] getChildren()
+	{
+		if ( children == null )
+		{
+			int n = getChildCount();
+			children = new Object[ n ];
+			for ( int i = 0; i < n; i++ )
+			{
+				children[i] = new TestObject();
+			}
+            //System.out.println( "TestObject.getChildren: " + toString() + " : " + getChildCount() );        
+		}
+		return children;
+	}
+	private void setChildren( Object[] aChildArray )
+	{
+		children = aChildArray;
+        childCount = aChildArray.length;
+	}
+
+    // following child list implementation wraps child array
+    
+	public List getChildList()
+	{
+		List result = new LinkedList();
+		Object[] childArray = getChildren();
+		for ( int i = 0; i < childArray.length; i++ )
+		{
+			result.add( childArray[i] );	
+		}
+		return result;
+	}
+	public void setChildList( List aChildList )
+	{
+		children = new Object[ aChildList.size() ];
+		for ( int i = 0; i < children.length; i++ )
+		{
+			children[i] = (TestObject) aChildList.get( i );	
+		}
+        childCount = children.length;
+	}
+*/    
+	protected int childCount;
+	public int getChildCount() 
+	{
+		if ( childCount == -1 )
+		{            
+// uncomment this to enable random children
+//			childCount = (int) ( random.nextDouble() * 6 ) - 3; // + 100; // tree scalability test
+            if ( childCount < 0 ) childCount = 0;
+		}
+        
+// this tests internal count        
+//		return childCount; 
+// this tests deferred count    
+        if ( childList != null )
+        {
+            return childList.size();
+        }
+        else
+        {
+            return 0;
+        }
+	};
+
+    // following child list implementation stands alone
+
+    protected List childList;
+	public List getChildList()
+	{
+/* 
+        // this tests random child population        
+		if ( childList == null )
+		{
+			int n = getChildCount();
+			childList = new LinkedList();
+			for ( int i = 0; i < n; i++ )
+			{
+				childList.add( new TestObject() );
+			}
+		}
+*/
+        // this tests manual loading        
+		if ( childList == null )
+		{
+            childList = new LinkedList();
+		}
+		return childList;
+	}
+	public void setChildList( List aChildList )
+	{
+        childList = aChildList;
+	}
+    
+    protected TestObject parent;
+    public TestObject getParent() { return parent; }
+    public void setParent( TestObject anObject ) { parent = anObject; }
+    
+    public String getHash() { return Integer.toHexString( System.identityHashCode( this ) ); }
+    
+    public String getFullName() 
+    {
+//    	return getHash() + ": " + firstName + " " + middleName + " " + lastName;
+    	return firstName + " " + middleName + " " + lastName;
+    }
+    
+    public boolean equals( Object anObject )
+    {
+    	return anObject == this;
+    }
+	
+	public String toString()
+	{
+		return "[" + getClass().getName() 
+            + "@" + Integer.toHexString( System.identityHashCode(this) )
+            + ":" + getFullName() + "]";	
+	}
+	    
+    // statics
+    
+    private static Random random = new Random();
+    private static String randomParse( String aString )
+    {
+    	String result = "";
+    	StringTokenizer tokens = new StringTokenizer( aString, "|" );
+        int n = (int) ( random.nextDouble() * tokens.countTokens() );
+        for ( int i = 0; i <= n; i++ )
+        {
+            result = tokens.nextToken();
+        }
+        return result;
+    }
+
+    
+    // interface EOKeyValueCoding:
+    // disable this interface by commenting out the "implements" declaration
+    
+    /**
+    * Returns the value for the specified property.
+    * If the property does not exist, this method should
+    * call handleQueryWithUnboundKey.
+    */
+    public Object valueForKey( String aKey )
+    {
+        System.out.println( "valueForKey: " + aKey );
+        return EOKeyValueCodingSupport.valueForKey( this, aKey );
+    }
+
+    /**
+    * Sets the property to the specified value.
+    * If the property does not exist, this method should
+    * call handleTakeValueForUnboundKey.
+    * If the property is of a type that cannot allow
+    * null (e.g. primitive types) and aValue is null,
+    * this method should call unableToSetNullForKey.
+    */
+    public void takeValueForKey( Object aValue, String aKey )
+    {
+        System.out.println( "takeValueForKey: " + aValue + " : " + aKey );
+        EOKeyValueCodingSupport.takeValueForKey( this, aValue, aKey );
+    }
+
+    /**
+    * Returns the value for the private field that 
+    * corresponds to the specified property.
+    */
+    public Object storedValueForKey( String aKey )
+    {
+        System.out.println( "storedValueForKey: " + aKey );
+        return EOKeyValueCodingSupport.storedValueForKey( this, aKey );
+    }
+
+    /**
+    * Sets the the private field that corresponds to the 
+    * specified property to the specified value.
+    */
+    public void takeStoredValueForKey( Object aValue, String aKey )
+    {
+        System.out.println( "takeStoredValueForKey: " + aValue + " : " + aKey );
+        EOKeyValueCodingSupport.takeStoredValueForKey( this, aValue, aKey );
+    }
+
+    /**
+    * Called by valueForKey when the specified key is
+    * not found on this object.  Implementing classes 
+    * should handle the specified value or otherwise 
+    * throw an exception.
+    */
+    public Object handleQueryWithUnboundKey( String aKey )
+    {
+        System.out.println( "handleQueryWithUnboundKey: " + aKey );
+        return EOKeyValueCodingSupport.handleQueryWithUnboundKey( this, aKey );
+    }
+
+    /**
+    * Called by takeValueForKey when the specified key
+    * is not found on this object.  Implementing classes
+    * should handle the specified value or otherwise 
+    * throw an exception.
+    */
+    public void handleTakeValueForUnboundKey( Object aValue, String aKey )
+    {
+        System.out.println( "handleTakeValueForUnboundKey: " + aValue + " : " + aKey );
+        EOKeyValueCodingSupport.handleTakeValueForUnboundKey( this, aValue, aKey );
+    }
+
+    /**
+    * Called by takeValueForKey when the type of the
+    * specified key is not allowed to be null, as is
+    * the case with primitive types.  Implementing 
+    * classes should handle this case appropriately
+    * or otherwise throw an exception.
+    */
+    public void unableToSetNullForKey( String aKey )
+    {
+        System.out.println( "unableToSetNullForKey: " + aKey );
+        EOKeyValueCodingSupport.unableToSetNullForKey( this, aKey );
+    }
+
+    
+    // main entry point    
+    
+    public static void main( String[] argv ) 
+    {
+        int count = 100;
+        boolean xmlMode = false;
+        if ( argv.length > 0 )
+        {
+            Integer parsed = ValueConverter.getInteger( argv[0] );
+            if ( parsed != null ) count = parsed.intValue();
+            
+            if ( argv.length > 1 )
+            {
+                if ( argv[1].indexOf( "xml" ) > -1 )
+                {
+                    xmlMode = true;
+                }
+            }
+        }
+
+long millis = System.currentTimeMillis();
+        
+    	DataSoup store = null;
+        if ( xmlMode )
+        {
+            store = new XMLFileSoup( "testObjects-xml" );
+        }
+        else
+        {
+            store = new SerializedFileSoup( "testObjects-java" );
+        }
+		
+        Object o;
+        for ( int i = 0; i < count; i++ )
+        {
+            store.addObject( new TestObject() );
+        }
+ /*
+        store.addIndex( "age", "age" );
+        store.addIndex( "zipCode", "zipCode" );
+        store.addIndex( "firstName", "firstName" );
+        store.addIndex( "lastName", "lastName" );
+*/ 
+System.out.println( System.currentTimeMillis() - millis + " milliseconds" );
+    }
+}