Initial import from SVN

1 files changed, 258 insertions, 0 deletions

diff --git a/projects/net.wotonomy.test/src/main/java/net/wotonomy/test/TestObjectStore.java b/projects/net.wotonomy.test/src/main/java/net/wotonomy/test/TestObjectStore.java
new file mode 100644
index 0000000..8fcb8a0
--- /dev/null
+++ b/projects/net.wotonomy.test/src/main/java/net/wotonomy/test/TestObjectStore.java
@@ -0,0 +1,258 @@
+package net.wotonomy.test;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import net.wotonomy.control.EOEditingContext;
+import net.wotonomy.control.EOFetchSpecification;
+import net.wotonomy.control.EOGlobalID;
+import net.wotonomy.control.EOObjectStore;
+import net.wotonomy.control.EOObserverCenter;
+import net.wotonomy.test.DataKeyID;
+import net.wotonomy.datastore.DataSoup;
+import net.wotonomy.datastore.DataView;
+import net.wotonomy.datastore.XMLFileSoup;
+import net.wotonomy.foundation.NSArray;
+import net.wotonomy.foundation.NSMutableArray;
+import net.wotonomy.foundation.internal.Duplicator;
+import net.wotonomy.foundation.internal.WotonomyException;
+
+/**
+* An object store that wraps a datastore
+* for vending test objects.
+*/
+public class TestObjectStore extends EOObjectStore
+{
+    DataSoup soup;
+    
+    /**
+    * Constructor specifies path to datastore.
+    */
+    public TestObjectStore( String aPath )
+    {
+        soup = new XMLFileSoup( aPath );
+    }
+        
+    /**
+    * This implementation simply returns 
+    * objectsWithSourceGlobalID.
+    */
+    public NSArray arrayFaultWithSourceGlobalID ( 
+        EOGlobalID aGlobalID,
+        String aRelationship,
+        EOEditingContext aContext )
+    {
+        return objectsForSourceGlobalID( 
+            aGlobalID, aRelationship, aContext );
+    }
+     
+    /**
+    * This implementation returns the actual
+    * object for the specified id.
+    */
+    public Object faultForGlobalID ( 
+        EOGlobalID aGlobalID,
+        EOEditingContext aContext )
+    {
+System.out.println( "TestObjectStore: * reading object * : " + aGlobalID );
+        return soup.getObjectByKey( 
+            ((DataKeyID)aGlobalID).getKey() );
+    }
+        
+    /**
+    * Returns a fault representing an object of 
+    * the specified entity type with values from 
+    * the specified dictionary.  The fault should
+    * belong to the specified editing context.
+    */        
+    public Object faultForRawRow ( 
+        Map aDictionary,
+        String anEntityName,
+        EOEditingContext aContext )
+    {
+        //TODO: faults are not yet supported
+        throw new WotonomyException( 
+            "Faults are not yet supported." );
+    }
+        
+    /**
+    * Given a newly instantiated object, this method 
+    * initializes its properties to values appropriate
+    * for the specified id.  The object should belong
+    * to the specified editing context.  
+    * This method is called to populate faults.
+    */        
+    public void initializeObject ( 
+        Object anObject,
+        EOGlobalID aGlobalID,
+        EOEditingContext aContext )
+    {
+System.out.println( "TestObjectStore: * reading object * : " + aGlobalID );
+        Object original = soup.getObjectByKey( 
+            ((DataKeyID)aGlobalID).getKey() );
+        EOObserverCenter.notifyObserversObjectWillChange( anObject );
+        Duplicator.deepCopy( original, anObject );
+        //TODO: need to handle child object registration in aContext
+    }
+        
+    /**
+    * Remove all values from all objects in memory,
+    * turning them into faults, and posts a notification
+    * that all objects have been invalidated.
+    */
+    public void invalidateAllObjects ()
+    {
+        // does nothing        
+    }
+    
+    /**
+    * Removes values with the specified ids from memory,
+    * turning them into faults, and posts a notification
+    * that those objects have been invalidated.
+    */
+    public void invalidateObjectsWithGlobalIDs ( 
+        List aList )
+    {
+        // does nothing
+    }
+        
+    /**
+    * Returns false because locking is not permitted.
+    */
+    public boolean isObjectLockedWithGlobalID ( 
+        EOGlobalID aGlobalID,
+        EOEditingContext aContext )
+    {
+        return false;
+    }
+        
+    /**
+    * Does nothing because locking is not permitted.
+    */
+    public void lockObjectWithGlobalID ( 
+        EOGlobalID aGlobalID,
+        EOEditingContext aContext )
+    {
+        // does nothing   
+    }
+        
+    /**
+    * Returns a List of objects associated with the object 
+    * with the specified id for the specified property 
+    * relationship.  Faults are not allowed in the array.
+    * All objects should belong to the specified editing context.
+    */
+    public NSArray objectsForSourceGlobalID ( 
+        EOGlobalID aGlobalID,
+        String aRelationship,
+        EOEditingContext aContext )
+    {
+        //TODO: relationships are not yet supported
+        throw new WotonomyException( 
+            "Relationships are not yet supported." );
+    }
+        
+    /**
+    * Returns a List of objects the meet the criteria of
+    * the supplied specification.  Faults are not allowed in the array.
+    * Each object is registered with the specified editing context.
+    * If any object is already registered in the specified context, 
+    * it is not refetched and that object should be used in the array.
+    */
+    public NSArray objectsWithFetchSpecification ( 
+        EOFetchSpecification aFetchSpec,
+        EOEditingContext aContext )
+    {
+        //TODO: fetch specs are not yet supported
+        
+        DataView view = soup.queryObjects( null, null );
+System.out.println( "TestObjectStore: ** querying all objects **" );
+        NSMutableArray result = new NSMutableArray();
+        Object o;
+        Object existing;
+        DataKeyID id;
+        Iterator it = view.iterator();
+        while ( it.hasNext() )
+        {
+            o = it.next();
+            id = new DataKeyID( view.getKeyForObject( o ) );
+            existing = aContext.objectForGlobalID( id );
+            if ( existing != null )
+            {
+                o = existing;    
+            }
+            else
+            {
+                aContext.recordObject( o, id );
+            }
+            result.addObject( o );
+        }
+        return result;
+    }
+        
+    /**
+    * Removes all values from the specified object, 
+    * converting it into a fault for the specified id.
+    * New or deleted objects should not be refaulted.
+    */
+    public void refaultObject ( 
+        Object anObject,
+        EOGlobalID aGlobalID,
+        EOEditingContext aContext )
+    {
+        //TODO: faults are not yet supported
+        // just re-initialize the object
+        initializeObject( anObject, aGlobalID, aContext );
+    }
+        
+    /**
+    * Writes all changes in the specified editing context
+    * to the respository.
+    */
+    public void saveChangesInEditingContext ( 
+        EOEditingContext aContext )
+    {
+        Object o;
+        DataKeyID id;
+        Iterator it;
+        
+        System.out.println( aContext.updatedObjects() );
+        
+        // process updates
+        it = aContext.updatedObjects().iterator();
+        while ( it.hasNext() )
+        {
+            o = it.next();
+            id = (DataKeyID) aContext.globalIDForObject( o );
+System.out.println( "TestObjectStore: * updating object * : " + id );
+            soup.updateObject( id.getKey(), o );
+        }
+        
+        // process deletes
+        it = aContext.deletedObjects().iterator();
+        while ( it.hasNext() )
+        {
+            o = it.next();
+            id = (DataKeyID) aContext.globalIDForObject( o );
+System.out.println( "TestObjectStore: * deleting object * : " + id );
+            soup.removeObject( id.getKey() );
+            // remove object from editing context
+            aContext.forgetObject( o );
+        }
+        
+        // process inserts
+        it = aContext.insertedObjects().iterator();
+        while ( it.hasNext() )
+        {   
+            o = it.next();
+            id = new DataKeyID( soup.addObject( o ) );
+System.out.println( "TestObjectStore: * adding object * : " + id );
+            // register object in editing context with new id
+            aContext.forgetObject( o );
+            aContext.recordObject( o, id );
+        }
+        
+    }
+}
+