/*
   Wotonomy: OpenStep design patterns for pure Java applications.
   Copyright (C) 2001 Michael Powers
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, see http://www.gnu.org
  */
  
  package net.wotonomy.control;
  
  import java.lang.ref.WeakReference;
  import java.util.Collection;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import net.wotonomy.foundation.NSArray;
  import net.wotonomy.foundation.NSDictionary;
  import net.wotonomy.foundation.NSMutableArray;
  import net.wotonomy.foundation.NSMutableDictionary;
  import net.wotonomy.foundation.NSNotification;
  import net.wotonomy.foundation.NSNotificationCenter;
  import net.wotonomy.foundation.NSRunLoop;
  import net.wotonomy.foundation.NSSelector;
  import net.wotonomy.foundation.internal.WotonomyException;
  
  // swing dependency for undo manager
  //import javax.swing.undo.UndoManager;
  
  /***
  * EOEditingContext provides transactional support for 
  * fetching, editing, and committing changes made on a 
  * collection of objects to a parent object store. <br><br>
  *
  * EOEditingContext is itself a subclass of EOObjectStore,
  * and this means that EOEditingContexts can use other 
  * EOEditingContexts as their parent.  However, there
  * still must exist an EOObjectStore as the root of the 
  * editing hierarchy that can maintain persistent state.
  *
  * @author michael@mpowers.net
  * @author $Author: cgruber $
  * @version $Revision: 894 $
  */
  public class EOEditingContext 
      extends EOObjectStore 
      implements EOObserving
  {
      /***
      * Key for the NSNotification posted after this editing context
      * saves changes.  Object of the notification will be this editing 
      * context, and user info will contain InsertedKey, UpdatedKey,
      * and DeletedKey (keys are defined in EOObjectStore).
      */
      public static final String 
          EditingContextDidSaveChangesNotification = 
          "EOEditingContextDidSaveChangesNotification";
  
      /***
      * Key for the NSNotification posted after this editing context
      * observes changes.  Object of the notification will be this editing 
      * context, and user info will contain InsertedKey, UpdatedKey, InvalidatedKey,
      * and DeletedKey (keys are defined in EOObjectStore), however
      * the objects in the corresponding Lists will be the actual
      * objects, not their ids.
      */
      public static final String 
          ObjectsChangedInEditingContextNotification = 
          "EOObjectsChangedInEditingContextNotification";
          
      /***
      * The default run loop ordering processes recent changes
      * before delayed observers are notified and before dispatching 
      * the AWT event queue.
      */
      public static int 
          EditingContextFlushChangesRunLoopOrdering = 300000;
  
      private static NSSelector runLaterSelector = 
          new NSSelector( "flushRecentChanges",
              new Class[] { Object.class } );
  
      private static EOObjectStore defaultParentObjectStore = null;
      private static double defaultFetchTimestampLag = 0;
      private static boolean retainsRegisteredObjects = true;
         
     private EOObjectStore parentStore;        
     private WeakReference delegate;
     private WeakReference messageHandler;
     private List editorSet;
     private double fetchTimestamp;
     private boolean lockBeforeModify;
     private boolean propagateDeletesAfterEvent;
     private boolean stopValidationAfterError;
     private NSMutableArray insertedObjects;
     private NSMutableArray insertedObjectsBuffer;
     private NSArray insertedObjectsProxy;
     private NSMutableArray updatedObjects;
     private NSMutableArray updatedObjectsBuffer;
     private NSArray updatedObjectsProxy;
     private NSMutableArray deletedObjects;
     private NSMutableArray deletedObjectsBuffer;
     private NSArray deletedObjectsProxy;
     private NSMutableArray deletedIDsBuffer;
     private NSMutableArray invalidatedObjectsBuffer;
     private NSMutableArray invalidatedIDsBuffer;
     private Registrar registrar;
 //    private UndoManager undoManager;
 
     // so we don't have to trouble EOObserverCenter
     private boolean ignoreChanges;
     
     // for delayed handling of processRecentChanges
     private boolean willRunLater;
     
     // for handling of notifications posted 
     //   while we're in the saveChanges method
     private boolean isInvalidating;
 
     // for i18n or other customization
     static protected String MessageChangeConflict =
         "Another user changed an object you are editing: ";
  
     /***
     * Default constructor creates a new editing context
     * that uses the default object store.  If the default
     * object store has not been set, an exception is thrown.
     */ 
     public EOEditingContext()
     {
         this( defaultParentObjectStore() );
     }
 
     /***
     * Creates a new editing context that uses the specified
     * object store as its parent object store.
     */
     public EOEditingContext( EOObjectStore anObjectStore )
     {
         if ( anObjectStore == null ) 
         {
             throw new IllegalArgumentException(
                 "A parent object store must be specified." );
         }
         
         parentStore = anObjectStore;
         delegate = null;
         messageHandler = null;
         editorSet = new LinkedList();
         fetchTimestamp = 0;
         lockBeforeModify = false;
         propagateDeletesAfterEvent = true;
         stopValidationAfterError = true;
         insertedObjects = new NSMutableArray();
         insertedObjectsBuffer = new NSMutableArray();
         insertedObjectsProxy = NSArray.arrayBackedByList( insertedObjects );
         updatedObjects = new NSMutableArray();
         updatedObjectsBuffer = new NSMutableArray();
         updatedObjectsProxy = NSArray.arrayBackedByList( updatedObjects );
         deletedObjects = new NSMutableArray();
         deletedObjectsBuffer = new NSMutableArray();
         deletedObjectsProxy = NSArray.arrayBackedByList( deletedObjects );
         deletedIDsBuffer = new NSMutableArray();
         invalidatedObjectsBuffer = new NSMutableArray();
         invalidatedIDsBuffer = new NSMutableArray();
         
         if ( instancesRetainRegisteredObjects() )
         {
             registrar = new Registrar( this );
         }
         else
         {
             registrar = new WeakRegistrar( this );
         }
         
         ignoreChanges = false;
         willRunLater = false;
         isInvalidating = false;
 
         // create undo manager
         //TODO: this should be NSUndoManager
 //        undoManager = new UndoManager();
 
         // register for notifications
         NSSelector handleNotification = 
             new NSSelector( "handleNotification",
                 new Class[] { NSNotification.class } );
         // any from parent store
         NSNotificationCenter.defaultCenter().addObserver(
             this, handleNotification, null, parentStore );
         // global id change from any
         NSNotificationCenter.defaultCenter().addObserver(
             this, handleNotification, EOGlobalID.GlobalIDChangedNotification, null );
 //new net.wotonomy.ui.swing.NotificationInspector( null, parentStore );                
     }
 
     /***
     * Registers the specified object as an editor for this
     * context.  The object is expected to implement
     * EOEditingContext.Editor.
     */
     public void addEditor ( Object anEditor )
     {
         if ( anEditor == null ) return;
         editorSet.add( new WeakReference( anEditor ) );
     }
 
     /***
     * Returns a read-only List of objects associated with the object 
     * with the specified id for the specified property 
     * relationship, or may return a placeholder array that
     * will defer the fetch until needed (aka an array fault).
     * All objects must be registered in the specified editing context.
     * This implementation calls to its parent object store's
     * implementation if the requested source object is not 
     * registered in this editing context.
     * The specified relationship key must produce a result of
     * type Collection for the source object or an exception is thrown.
     */
     public NSArray arrayFaultWithSourceGlobalID ( 
         EOGlobalID aGlobalID,
         String aRelationshipKey,
         EOEditingContext aContext )
     {
         NSArray result = null;
         Object source = registrar.objectForGlobalID( aGlobalID );
         
         // if not registered in our context
         if ( source == null )
         {
             // get the object registered into our context
             result = parentStore.arrayFaultWithSourceGlobalID( 
                 aGlobalID, aRelationshipKey, this );
         }
         else // source is registered in our context
         {
             // get existing value
             Object value;
             if ( source instanceof EOKeyValueCoding )
             {
                 value = ((EOKeyValueCoding)source).storedValueForKey( 
                     aRelationshipKey );
             }
             else // handle directly
             {
                 value = EOKeyValueCodingSupport.storedValueForKey( 
                     source, aRelationshipKey );
             }
             
             if ( value == null )
             {
                 // do the same as if the source was null
                 result = parentStore.arrayFaultWithSourceGlobalID( 
                     aGlobalID, aRelationshipKey, this );
             }
             else
             if ( value instanceof NSArray )
             {
                 result = (NSArray) value;
             }
             else // not NSArray
             if ( value instanceof Collection )
             {
                 // convert to NSArray
                 result = new NSArray( (Collection) value );
             }
             else
             {
                 throw new WotonomyException( 
                     "Relationship key did not return a collection: " 
                     + aGlobalID + " : " + aRelationshipKey );   
             }
         }
         
         // if our context is not the specified context
         if ( aContext != this ) 
         {
             result = (NSArray) clone( this, result, aContext );
         }
         
         return result;
     }
  
     /***
     * Returns a snapshot of the specified object as it
     * existed when it was last read or committed to the
     * parent object store.
     */
     public NSDictionary committedSnapshotForObject ( 
         Object anObject )
     {
         byte[] snapshot = (byte[])
             registrar.getCommitSnapshot( anObject );
         if ( snapshot == null )
         {
             // this object not modified: take a current snapshot
             snapshot = takeSnapshot( anObject );
         }                
         return convertSnapshotToDictionary( snapshot );
     }
 
     /***
     * Returns a snapshot of the specified object as it
     * existed before the edits triggered by the current
     * event loop were processed.
     */
     public NSDictionary currentEventSnapshotForObject ( 
         Object anObject )
     {
         byte[] result = (byte[])
             registrar.getCurrentSnapshot( anObject );
         if ( result == null )
         {
             return committedSnapshotForObject( anObject );   
         }
         return convertSnapshotToDictionary( result );
     }
     
     /***
     * Returns the delegate for this editing context,
     * or null if no delegate has been set.
     */
     public Object delegate ()
     {
         if ( delegate == null ) return null;
         return delegate.get();
     }
 
     /***
     * Deletes the specified object from this editing context.
     * The editing context marks the object as deleted and
     * will notify the parent store when changes are committed.
     */
     public void deleteObject ( 
         Object anObject )
     {
         willChange();
 
 		int i;
 		// remove from added objects if necessary
 		i = insertedObjects.indexOfIdenticalObject( anObject );
 		if ( i != NSArray.NotFound )
 		{
 			insertedObjects.removeObjectAtIndex( i );
                         
             // if in the inserted objects buffer
             int index = insertedObjectsBuffer.indexOfIdenticalObject( anObject );
             if ( index != NSArray.NotFound )
             {
                 // remove from inserted objects buffer
                 insertedObjectsBuffer.removeObjectAtIndex( index );
             }
 
             // now forget the object ever existed.
             forgetObject( anObject );
 
             // we're done
             return;
 		}
 		else // otherwise add to deleted objects list
 		{
 			deletedObjects.addObject( anObject );
 		}
 		
 		// remove from updated objects if necessary
 		i = updatedObjects.indexOfIdenticalObject( anObject );
 		if ( i != NSArray.NotFound )
         {
             updatedObjects.removeObjectAtIndex( i );
         }
 
         // add to buffer
         deletedObjectsBuffer.addObject( anObject );            
         deletedIDsBuffer.addObject( globalIDForObject( anObject ) );            
     }
 
     /***
     * Returns a read-only List of all objects marked as deleted
     * in this editing context.
     */
     public NSArray deletedObjects ()
     {
         return deletedObjectsProxy;
     }
 
     /***
     * Called by child editing contexts when they no longer
     * need to track the specified id.
     * This implementation forwards the call to the parent store.
     */
     public void editingContextDidForgetObjectWithGlobalID ( 
         EOEditingContext aContext,
         EOGlobalID aGlobalID )
     {
         parentStore.editingContextDidForgetObjectWithGlobalID(
             aContext, aGlobalID );
     }
 
     /***
     * Returns a read-only List of registered editors of this
     * editing context.
     */
     public NSArray editors ()
     {
         NSMutableArray result = new NSMutableArray();
         Object o;
         Iterator i = editorSet.iterator();
         while ( i.hasNext() )
         {
             o = ((WeakReference)i.next()).get();
             if ( o != null )
             {
                 result.addObject( o );
             }
             else
             {
                 i.remove();
             }
         }
         return result;
     }
     
 /*
     public static void encodeObjectWithCoder ( 
         Object anObject,
         NSCoder aCoder )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
 
     /***
     * Returns the object for the specified id.
     * If the object is registered in in this context
     * but not in the specified context, 
     * this implementation will create a copy of the object 
     * and register it in the specified context.
     * Otherwise it will forward the call to the parent
     * object store.
     */
     public /*EOEnterpriseObject*/ Object faultForGlobalID ( 
         EOGlobalID aGlobalID,
         EOEditingContext aContext )
     {
         Object result = registrar.objectForGlobalID( aGlobalID );
         
         // if not registered in our context
         if ( result == null )
         {
             // get the object registered into our context
             result = parentStore.faultForGlobalID( aGlobalID, this );
         }
         
         // if our context is not the specified context
         if ( aContext != this ) 
         {
             result = registerClone( aGlobalID, this, result, aContext );
         }
         
         return result;
     }
 
     /***
     * Returns a fault representing an object of 
     * the specified entity type with values from 
     * the specified dictionary.  
     * This implementation calls faultForRawRow 
     * on the parent store.
     */
     public Object faultForRawRow ( 
         Map aDictionary,
         String anEntityName )
     {
         return parentStore.faultForRawRow(
             aDictionary, anEntityName, this );
     }
 
     /***
     * 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.
     * This implementation forwards the call to
     * the parent store.
     */
     public /*EOEnterpriseObject*/ Object faultForRawRow ( 
         Map aDictionary,
         String anEntityName,
         EOEditingContext aContext )
     {
         return parentStore.faultForRawRow(
             aDictionary, anEntityName, aContext );
     }
 
     /***
     * Returns the fetch timestamp for this editing context.
     */
     public double fetchTimestamp ()
     {
         return fetchTimestamp;
     }
 
     /***
     * Unregisters the specified object from this editing context,
     * removing all references to it.  Use this method to remove
     * an object from the context without marking it for deletion.
     */ 
     public void forgetObject ( 
         Object anObject )
     {
         EOGlobalID id = registrar.globalIDForObject( anObject );
         if ( id == null ) 
         {
             System.err.println( 
                 "EOEditingContext.forgetObject: not registered: " + anObject );
             return;
         }
         
         // unregister object
         registrar.forgetObject( anObject );   
         
         // remove from all, inserted, updated, and deleted lists
         int index;
         index = updatedObjects.indexOfIdenticalObject( anObject );
         if ( index != NSArray.NotFound )
         {
             updatedObjects.removeObjectAtIndex( index );   
         }
         index = insertedObjects.indexOfIdenticalObject( anObject );
         if ( index != NSArray.NotFound )
         {
             insertedObjects.removeObjectAtIndex( index );   
             return;
         }
         index = deletedObjects.indexOfIdenticalObject( anObject );
         if ( index != NSArray.NotFound )
         {
             deletedObjects.removeObjectAtIndex( index );   
             return;
         }
 
         // notify parent context
         parentStore.editingContextDidForgetObjectWithGlobalID( this, id );
     }
 
     /***
     * Returns the id for the specified object, or null
     * if the object is not registered in this context.
     */
     public EOGlobalID globalIDForObject ( 
         Object anObject )
     {
         return registrar.globalIDForObject( anObject );
     }
     
     /***
     * Returns an array of ids for an array of objects.
     */
     private NSArray globalIDsForObjects( 
         List anObjectList )
     {
         NSMutableArray result = new NSMutableArray();
         Iterator it = anObjectList.iterator();
         while ( it.hasNext() )
         {
             result.add( globalIDForObject( it.next() ) );
         }
         return result;
     }
 
     /***
     * Returns whether this editing context has changes that
     * have not yet been committed to the parent object store.
     */
     public boolean hasChanges ()
     {
         if ( updatedObjects.count() > 0 ) return true;
         if ( insertedObjects.count() > 0 ) return true;
         if ( deletedObjects.count() > 0 ) return true;
         return false;
     }
 
     /***
     * Given a newly instantiated object, this method 
     * initializes its properties to values appropriate
     * for the specified id.  The object should already
     * belong to the specified editing context.  
     * This method is called to populate faults.
     * This implementation will try to apply the values
     * from an object with a matching id in this editing 
     * context if possible, calling to the parent object 
     * store only if such an object is not found.
     */
     public void initializeObject ( 
         /*EOEnterpriseObject*/ Object anObject,
         EOGlobalID aGlobalID,
         EOEditingContext aContext )
     {
         Object existingObject = registrar.objectForGlobalID( aGlobalID );
         
         // if not registered in our context
         if ( existingObject == null )
         {
             // get the object registered into our context
             existingObject = parentStore.faultForGlobalID( aGlobalID, this );
         }
         
         if ( aContext == this )
         {
             // initialize the object
             parentStore.initializeObject(
                 /*(EOEnterpriseObject)*/existingObject, aGlobalID, this );
         }
         else // ( aContext != this )
         {
             // translates child relationships
             copy( this, existingObject, aContext, anObject );
         }
 
         aContext.registrar.setCommitSnapshot( anObject, null );
         aContext.registrar.setCurrentSnapshot( anObject, null );
     }
 
     /***
     * Inserts the specified object into this editing context.
     * This implementation calls insertObjectWithGlobalID
     * with an EOTemporaryGlobalID.
     */
     public void insertObject ( Object anObject )
     {
         insertObjectWithGlobalID( 
             anObject, new EOTemporaryGlobalID() );
     }
 
     /***
     * Inserts the specified object into this editing context
     * with the specified id, which is expected to be a
     * temporary id.
     */
     public void insertObjectWithGlobalID ( 
         Object anObject,
         EOGlobalID aGlobalID )
     {
         willChange();
         
         // if this object was marked for deletion
         int index = deletedObjects.indexOfIdenticalObject( anObject );
         if ( index != NSArray.NotFound )
         {
              // don't need to re-register: just update the lists
             
              // remove from deleted list
              deletedObjects.removeObjectAtIndex( index );
     
              // if in the deleted ids buffer         
              index = deletedIDsBuffer.indexOfIdenticalObject( anObject );
              if ( index != NSArray.NotFound )
              {
                  // remove from deleted ids buffer
                  deletedIDsBuffer.removeObjectAtIndex( index );
              }
     
              // if in the deleted objects buffer         
              index = deletedObjectsBuffer.indexOfIdenticalObject( anObject );
              if ( index != NSArray.NotFound )
              {
                  // remove from deleted objects buffer
                  deletedObjectsBuffer.removeObjectAtIndex( index );
              }
              else // not in the deleted objects buffer
              {
                  // add to the inserted objects buffer
                  insertedObjectsBuffer.addObject( anObject );
              }
              
              // we're done
              return;
         }
 
         // make sure object is not already in editing context
         if ( objectForGlobalID( aGlobalID ) != null )
         {
             throw new WotonomyException( 
                 "Tried to insert but object was already registered:" 
                 + aGlobalID );
         }
         
         // register object
         recordObject( anObject, aGlobalID );
         
         // add to inserted list
         insertedObjects.addObject( anObject );
         // add to buffer
         insertedObjectsBuffer.addObject( anObject );
     }
 
     /***
     * Returns a read-only List of the objects that have been 
     * inserted into this editing context.
     */
     public NSArray insertedObjects ()
     {
         return insertedObjectsProxy;
     }
 
     /***
     * Turn all objects in this editing context into faults,
     * so that they will be fetched the next time they are 
     * accessed, and calls invalidateObjectsWithGlobalIDs
     * on the parent object store.
     */
     public void invalidateAllObjects ()
     {
         // register change so processRecentChanges is called
         willChange();
         
         invalidateAllObjectsQuietly();
         
         // post notification
         NSNotificationCenter.defaultCenter().postNotification(
             new NSNotification(
                 InvalidatedAllObjectsInStoreNotification, this ) );
     }
     
     /***
     * Only refaults all objects, does not notify will change
     * nor post notification, but does call parent store.
     * Called by invalidateAllObjects() and handleNotification().
     */ 
     private void invalidateAllObjectsQuietly()
     {
         // remember the ids
         NSMutableArray ids = new NSMutableArray( registrar.registeredGlobalIDs() );
 
         // track of discarded IDs (from inserted objects)
         NSMutableArray discardedIDs = new NSMutableArray();
 
         // refault all objects
         EOGlobalID id;
         Object o;
         Enumeration e = ids.objectEnumerator();
         while ( e.hasMoreElements() )
         {
             id = (EOGlobalID) e.nextElement();
             o = objectForGlobalID( id );
 
             // some objects may have been manually discarded
             if ( o != null )
             {
                 // don't refault newly inserted objects
                 if ( insertedObjects.indexOfIdenticalObject( o ) == NSArray.NotFound )
                 {
                     refaultObject( o, id, this );
                 }
                 else
                 {
                     // discard inserted objects
                     forgetObject( o );
                     discardedIDs.add( id );
                 }
                 invalidatedObjectsBuffer.add( o );
             }
             invalidatedIDsBuffer.add( id );
         }
         ids.removeAll( discardedIDs );
         
         // call to parent store (should call this after posting instead?)
         isInvalidating = true;        
         parentStore.invalidateObjectsWithGlobalIDs( ids );
         isInvalidating = false;        
     }
 
     /***
     * Turns the objects with the specified ids into faults,
     * so that they will be fetched the next time they are
     * accessed, and forwards the call to the parent object store.
     */
     public void invalidateObjectsWithGlobalIDs ( 
         List anArray )
     {
         // register change so processRecentChanges is called
         willChange();
 
         // call to parent to invalidate objects
         parentStore.invalidateObjectsWithGlobalIDs( anArray );
 
         Object o;
         EOGlobalID id;
         Iterator it = anArray.iterator();
         while ( it.hasNext() )
         {
             id = (EOGlobalID) it.next();
             if ( id != null )
             {
                 o = objectForGlobalID( id );
                 if ( o != null )
                 {
                     Object result = notifyDelegate(
                         "editingContextShouldInvalidateObject",
                         new Class[] { EOEditingContext.class, Object.class, EOGlobalID.class },
                         new Object[] { this, o, id } );
                     if ( ( result == null ) || ( Boolean.TRUE.equals( result ) ) )
                     {
                         // refault the object
                         refaultObject( o, id, this );
                         invalidatedObjectsBuffer.add( o );
                         invalidatedIDsBuffer.add( id );
                     }
                 }
             }
             else
             {
                 throw new WotonomyException(
                     "Attempted to invalidate a null global id: " + anArray );
             }
         }
         
     }
 /*
     public boolean invalidatesObjectsWhenFinalized (  )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 
     public boolean invalidatesObjectsWhenFreed (  )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
     /***
     * Returns whether the object referenced by the 
     * specified id is locked.  
     * This implementation simply forwards the call to
     * the parent object store.
     */
     public boolean isObjectLockedWithGlobalID ( 
         EOGlobalID aGlobalID,
         EOEditingContext aContext)
     {
         return parentStore.isObjectLockedWithGlobalID(
             aGlobalID, aContext );
     }
 
 /*    
     public void lock ()
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
     /***
     * Locks the specified object in this editing context
     * by calling lockObjectWithGlobalID on the parent store.
     */
     public void lockObject ( 
         Object anObject )
     {
         parentStore.lockObjectWithGlobalID( 
             globalIDForObject( anObject ), this );
     }
 
     /***
     * Locks the object referenced by the specified id
     * in the specified editing context.
     * This implementation simply forwards the call to
     * the parent object store.
     */
     public void lockObjectWithGlobalID ( 
         EOGlobalID aGlobalID,
         EOEditingContext aContext)
     {
         parentStore.lockObjectWithGlobalID(
             aGlobalID, aContext );
     }
 
     /***
     * Returns whether this editing context attempts to
     * lock objects when they are first modified.
     */
     public boolean locksObjectsBeforeFirstModification ()
     {
         return lockBeforeModify;
     }
 
     /***
     * Returns the message handler for this editing context,
     * or null if no message handler has been set.
     */
     public Object messageHandler ()
     {
         if ( messageHandler == null ) return null;
         return messageHandler.get();
     }
 
     /***
     * Returns the object registered in this editing context
     * for the specified id, or null if that id is not 
     * registered.
     */
     public Object objectForGlobalID ( 
         EOGlobalID aGlobalID )
     {
         return registrar.objectForGlobalID( aGlobalID );
     }
 
     /***
     * Returns a read-only List of objects associated with the object 
     * with the specified id for the specified property 
     * relationship.  This method may not return an array fault
     * because array faults call this method to fetch on demand.
     * All objects must be registered the specified editing context.
     * The specified relationship key must produce a result of
     * type Collection for the source object or an exception is thrown.
     */
     public NSArray objectsForSourceGlobalID ( 
         EOGlobalID aGlobalID,
         String aRelationshipKey,
         EOEditingContext aContext )
     {
 //System.out.println( "EOEditingContext.objectsForSourceGlobalID: " 
 //+ aGlobalID + " : " + aRelationshipKey );        
     
         NSArray result = null;
         
 if ( aContext == this )
 {
     throw new WotonomyException( "Assert failed: calling objectsForSourceGlobalID on ourself." );   
 }
         Object source = registrar.objectForGlobalID( aGlobalID );
         
         // if not registered in our context
         if ( source == null )
         {
             // get the object registered into our context
             result = parentStore.objectsForSourceGlobalID( 
                 aGlobalID, aRelationshipKey, this );
         }
         else // source is registered in our context
         {
             // get existing value
             Object value;
             if ( source instanceof EOKeyValueCoding )
             {
                 value = ((EOKeyValueCoding)source).storedValueForKey( 
                     aRelationshipKey );
             }
             else // handle directly
             {
                 value = EOKeyValueCodingSupport.storedValueForKey( 
                     source, aRelationshipKey );
             }
             
             // if we don't have a valid value on our object
             if ( ( value == null ) 
             || ( ( value instanceof ArrayFault ) 
               && ( !((ArrayFault)value).isFetched() ) ) )
             {
                 // do the same as if the source was null
                 result = parentStore.objectsForSourceGlobalID( 
                     aGlobalID, aRelationshipKey, this );
                     
                 // set our value since we have it
                 if ( source instanceof EOKeyValueCoding )
                 {
                     ((EOKeyValueCoding)source).takeStoredValueForKey( 
                         result, aRelationshipKey );
                 }
                 else // handle directly
                 {
                     EOKeyValueCodingSupport.takeStoredValueForKey( 
                         source, result, aRelationshipKey );
                 }
             }
             else
             if ( ( value instanceof ArrayFault ) 
               && ( !((ArrayFault)value).isFetched() ) )
             {
                 // do the same as if the source was null
                 result = parentStore.objectsForSourceGlobalID( 
                     aGlobalID, aRelationshipKey, this );
             }
             else
             if ( value instanceof NSArray )
             {
                 result = (NSArray) value;
             }
             else // not NSArray
             if ( value instanceof Collection )
             {
                 // convert to NSArray
                 result = new NSArray( (Collection) value );
             }
             else
             {
                 throw new WotonomyException( 
                     "Relationship key did not return a collection: " 
                     + aGlobalID + " : " + aRelationshipKey );   
             }
         }
             
         // if our context is not the specified context
         if ( aContext != this ) 
         {
             result = (NSArray) clone( this, result, aContext );
         }
         
         return result;
     }
 
     /***
     * Returns a read-only List of objects the meet the criteria of
     * the supplied specification.  This method simply calls
     * objectsWithFetchSpecification on this editing context 
     * with this editing context as the parameter.
     */
     public NSArray objectsWithFetchSpecification ( 
         EOFetchSpecification aFetchSpec )
     {
         return objectsWithFetchSpecification( aFetchSpec, this );
     }
 
     /***
     * Returns a read-only List of objects the meet the criteria of
     * the supplied specification.  Faults are not allowed in the array.
     * If any objects are already fetched, they should not be
     * refetched. All objects should belong to the specified editing context.
     * This implementation forwards the call to the parent object
     * store, which will register each object in the specified editing
     * context only if it does not already exist.
     */
     public NSArray objectsWithFetchSpecification ( 
         EOFetchSpecification aFetchSpec,
         EOEditingContext aContext)
     {
         if ( aContext == this )
         {
             Object result = notifyDelegate(
                 "editingContextShouldFetchObjects",
                 new Class[] { EOEditingContext.class, EOFetchSpecification.class },
                 new Object[] { aContext, aFetchSpec } );
             if ( result instanceof NSArray ) return (NSArray) result;
         }
         return parentStore.objectsWithFetchSpecification( aFetchSpec, aContext );
     }
 
     /***
     * Returns the parent object store for this editing context.
     * The result will not be null.
     */
     public EOObjectStore parentObjectStore ()
     {
         return parentStore;
     }
 
     /***
     * Updates the inserted, updated, and deleted objects lists,
     * and posts notifications about which objects have been changed.
     * This method is called at the end of an event loop in which
     * objects were modified.  This method is additionally called
     * by saveChanges() so that any changes in the same event loop
     * will be processed correctly before calling to the parent
     * object store.
     * This implementation updates those lists immediately, but
     * only posts notifications when this method is called.
     */
     public void processRecentChanges ()
     { // System.out.println( "EOEditingContext.processRecentChanges: " + invalidatedObjectsBuffer );
         
     /*
     * This implementation actually updates those lists immediately,
     * but keeps a separate buffer of changes in the current event 
     * loop for the purposes of posting a notification.
     * NOTE: to reenable buffering, uncomment lines from this method
     * body and reenable the RecentChangesObserver in the constructor.
     */
 
         // broadcast ObjectsChangedInStoreNotification
         // for the benefit of child editing contexts
         
         boolean postStoreInfo = 
             ( insertedObjectsBuffer.size() + 
               updatedObjectsBuffer.size() +
               deletedIDsBuffer.size() +
               invalidatedIDsBuffer.size() > 0 );
         
         NSMutableDictionary storeInfo = new NSMutableDictionary();
         if ( postStoreInfo )
         {
             storeInfo.setObjectForKey( 
                 globalIDsForObjects( insertedObjectsBuffer ), 
     //            globalIDsForObjects( insertedObjects ), 
                 EOObjectStore.InsertedKey );
             storeInfo.setObjectForKey( 
                 globalIDsForObjects( updatedObjectsBuffer ), 
     //            globalIDsForObjects( updatedObjects ), 
                 EOObjectStore.UpdatedKey );
             storeInfo.setObjectForKey( 
                 new NSArray( (Collection) deletedIDsBuffer ), 
     //            globalIDsForObjects( deletedObjects ), 
                 EOObjectStore.DeletedKey );
             storeInfo.setObjectForKey( 
                 new NSArray( (Collection) invalidatedIDsBuffer ), 
                 EOObjectStore.InvalidatedKey );
         }
 
         // broadcast ObjectsChangedInEditingContextNotification
         // for the benefit of attached display groups
         
         boolean postContextInfo = 
             ( insertedObjectsBuffer.size() + 
               updatedObjectsBuffer.size() +
               deletedObjectsBuffer.size() +
               invalidatedObjectsBuffer.size() > 0 );
         
         NSMutableDictionary contextInfo = new NSMutableDictionary();
 
         if ( postContextInfo )
         {
                 
             contextInfo.setObjectForKey( 
                new NSArray( (Collection) insertedObjectsBuffer ), 
     //            new NSArray( (Collection) insertedObjects ), 
                 EOObjectStore.InsertedKey );
             contextInfo.setObjectForKey( 
                 new NSArray( (Collection) updatedObjectsBuffer ),  
     //            new NSArray( (Collection) updatedObjects ),  
                 EOObjectStore.UpdatedKey );
             contextInfo.setObjectForKey( 
                 new NSArray( (Collection) deletedObjectsBuffer ),  
     //            new NSArray( (Collection) deletedObjects ),  
                 EOObjectStore.DeletedKey );
             contextInfo.setObjectForKey( 
                 new NSArray( (Collection) invalidatedObjectsBuffer ),  
                 EOObjectStore.InvalidatedKey );
         }
     
         // update the current snapshots
         
         Object o;
         Iterator it;
         it = insertedObjectsBuffer.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             registrar.setCurrentSnapshot( o, takeSnapshot( o ) );
         }
         it = updatedObjectsBuffer.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             registrar.setCurrentSnapshot( o, takeSnapshot( o ) );
         }
 
         // clear buffers
         
         insertedObjectsBuffer.removeAllObjects();
         updatedObjectsBuffer.removeAllObjects();
         deletedObjectsBuffer.removeAllObjects();
         deletedIDsBuffer.removeAllObjects();
         invalidatedObjectsBuffer.removeAllObjects();
         invalidatedIDsBuffer.removeAllObjects();
 
         // post notifications (does order matter?)
         
         if ( postStoreInfo )
         {
             NSNotificationCenter.defaultCenter().postNotification(
                 new NSNotification(
                     ObjectsChangedInStoreNotification, this, storeInfo ) );
         }
         
         if ( postContextInfo )
         {
             NSNotificationCenter.defaultCenter().postNotification( 
                 new NSNotification(
                     ObjectsChangedInEditingContextNotification, this, contextInfo ) );
         }
 
     }
 
     /***
     * Returns whether this editing context propagates deletes
     * immediately after the event that triggered the delete.
     * Otherwise, propagation occurs only before commit.
     */
     public boolean propagatesDeletesAtEndOfEvent ()
     {
         return propagateDeletesAfterEvent;
     }
 
     /***
     * Registers the specified object in this editing context 
     * for the specified id.  This method is called by an object
     * store when fetching objects for a display group, or when
     * objects are inserted into a display group.
     * This implementation will re-register the object under the
     * new id if it is already registered under a different id.
     */
     public void recordObject ( 
         Object anObject,
         EOGlobalID aGlobalID )
     { 
         // find state for re-registration
         boolean inserted = false;
         boolean updated = false;
         boolean deleted = false;
 
         // is the object already registered?
         EOGlobalID existingID = globalIDForObject( anObject );
         if ( existingID != null )
         {
             // remember object state
             int index;
             index = insertedObjects.indexOfIdenticalObject( anObject );
             if ( index != NSArray.NotFound ) inserted = true;    
             index = updatedObjects.indexOfIdenticalObject( anObject );
             if ( index != NSArray.NotFound ) updated = true;    
             index = deletedObjects.indexOfIdenticalObject( anObject );
             if ( index != NSArray.NotFound ) deleted = true;    
             // forget the object
             forgetObject( anObject );
         }
 
         // is the global id already in use?
         Object existingObject = objectForGlobalID( aGlobalID );
         if ( existingObject != null )
         {
             // forget it (don't worry about state?)
             forgetObject( existingObject );
         }
 
         registrar.registerObject( anObject, aGlobalID );
         
         // restore state if necessary
         if ( inserted ) insertedObjects.addObject( anObject );
         if ( updated ) updatedObjects.addObject( anObject );
         if ( deleted ) deletedObjects.addObject( anObject );
     }
 
     /***
     * Undoes the last undo operation.
     */
     public void redo ()
     {
         //TODO: not supported yet
         throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /***
     * Refaults this editing context, turning all unmodified
     * objects into faults.  This implementation calls
     * editingContextWillSaveChanges() on all editors, and
     * then calls refaultObjects().
     */
     public void refault ()
     {
         fireWillSaveChanges();
         refaultObjects();
     }
 
     /***
     * Refaults the specified object, turning it into a fault
     * for the specified global id in the specified context.
     */
     public void refaultObject ( 
         Object anObject,
         EOGlobalID aGlobalID,
         EOEditingContext aContext)
     {
         aContext.registrar.setCurrentSnapshot( anObject, null );
 
         ignoreChanges = true;
         parentStore.refaultObject( anObject, aGlobalID, aContext );
         ignoreChanges = false;
         
 		// remove from updated objects if necessary
 		int i = updatedObjects.indexOfIdenticalObject( anObject );
 		if ( i != NSArray.NotFound )
         {
             updatedObjects.removeObjectAtIndex( i );
         }
 
         // add to invalidated notification queue
         invalidatedObjectsBuffer.addObject( anObject );
         invalidatedIDsBuffer.addObject( aGlobalID );
     }
 
     /***
     * Turns all unmodified objects into faults, calling
     * processRecentChanges() and then refaultObject() for
     * each unmodified object.
     */
     public void refaultObjects ()
     {
         // is this call really needed?
         // processRecentChanges();
         
         Object o;
         EOGlobalID id;
         Iterator it = registeredObjects().iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             if ( ( updatedObjects.indexOfIdenticalObject( o ) == NSArray.NotFound )
             &&   ( insertedObjects.indexOfIdenticalObject( o ) == NSArray.NotFound )
             &&   ( deletedObjects.indexOfIdenticalObject( o ) == NSArray.NotFound ) )
             {
                 id = globalIDForObject( o );
                 refaultObject( o, id, this );
             }
         }
     }
 
     /*** 
     * Calls editingContextWillSaveChanges() on all editors,
     * and then calls invalidateAllObjects().
     */ 
     public void refetch ()
     {
         fireWillSaveChanges();
         invalidateAllObjects();
     }
 
     /***
     * Returns a read-only List of all objects registered in this
     * editing context.
     */
     public NSArray registeredObjects ()
     {
         return registrar.registeredObjects();
     }
 
     /***
     * Unregisters the specified editor with this editing context.
     */
     public void removeEditor ( Object anObject )
     {
         if ( anObject == null ) return;
         
         Object o;
         Iterator i = editorSet.iterator();
         while ( i.hasNext() )
         {
             o = ((WeakReference)i.next()).get();
             if ( ( o == null ) || ( o == anObject ) )
             {
                 i.remove();
             }
         }
     }
 
     /***
     * Unregisters all objects from this editing context,
     * and resets the fetch timestamp.
     */
     public void reset ()
     {
         Iterator it = registeredObjects().iterator();
         while ( it.hasNext() )
         {
             forgetObject( it.next() );   
         }
         fetchTimestamp = 0; //FIXME: reset timestamp properly
     }
 
     /***
     * Reverts the objects in this editing context to
     * their original state.
     * Calls editingContextWillSaveChanges on all editors,
     * discards all inserted objects, restores deleted
     * objects, and applies the fetch snapshot to all
     * registered objects.
     */
     public void revert ()
     {
         willChange();
         fireWillSaveChanges();
 
         Iterator it;
         
         // forget inserted objects
         it = new NSArray( insertedObjects ).iterator();
         while ( it.hasNext() )
         {
             forgetObject( it.next() );
         }
 
         EOGlobalID id;
         Object o;
         byte[] snapshot;
 
         // re-initialize updated objects
         it = new NSArray( updatedObjects ).iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             snapshot = (byte[]) registrar.getCommitSnapshot( o );
             if ( snapshot != null )
             {
                 applySnapshot( snapshot, o );
             }
             registrar.setCommitSnapshot( o, null );
             updatedObjectsBuffer.addObject( o );
         }
 
         // re-initialize deleted objects
         it = new NSArray( deletedObjects ).iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             snapshot = (byte[]) registrar.getCommitSnapshot( o );
             if ( snapshot != null )
             {
                 applySnapshot( snapshot, o );
             }
             registrar.setCommitSnapshot( o, null );
             updatedObjectsBuffer.addObject( o );
         }
 
         // reset lists
         insertedObjects.removeAllObjects(); // unneccessary?
         deletedObjects.removeAllObjects();
         updatedObjects.removeAllObjects();
 
         // post notification
         processRecentChanges();        
     }
 
     /***
     * Returns the root object store, which is the parent
     * of all parent object stores of this editing context.
     */
     public EOObjectStore rootObjectStore ()
     {
         EOObjectStore parent = parentObjectStore();
         while ( parent instanceof EOEditingContext )
         {
             parent = ((EOEditingContext)parent).parentObjectStore();   
         }
         return parent;
     }
 
     /***
     * Calls editingContextWillSaveChanges on all editors,
     * and commits all changes in this editing context to 
     * the parent editing context by calling 
     * saveChangesInEditingContext to the parent.
     * Then posts EditingContextDidSaveChangeNotification.
     */
     public void saveChanges ()
     {
 //System.out.println( "EOEditingContext.saveChanges: " + this );        
         willChange();
 
         // process any changes
         processRecentChanges();
         
         // set up user info for notification to be posted.
         NSMutableDictionary userInfo = new NSMutableDictionary();
         userInfo.setObjectForKey( 
             new NSArray( (Collection) insertedObjects ), 
             EOObjectStore.InsertedKey );
         userInfo.setObjectForKey( 
             new NSArray( (Collection) updatedObjects ),  
             EOObjectStore.UpdatedKey );
         userInfo.setObjectForKey( 
             new NSArray( (Collection) deletedObjects ),  
             EOObjectStore.DeletedKey );
         
         // notify the editors
         fireWillSaveChanges();
 
         // notify the delegate
         notifyDelegate(
             "editingContextWillSaveChanges",
             new Class[] { EOEditingContext.class },
             new Object[] { this } );
 
         // needed for notification handling
         isInvalidating = true;
         try
         {
             // ask parent to save us
             parentStore.saveChangesInEditingContext( this );
         }
         catch ( RuntimeException e )
         {
             // unset save flag and rethrow
             isInvalidating = false;
             throw e;
         }
         isInvalidating = false;
         
         // no exceptions: proceed!
         
         Object o, key;
         Iterator it;
         
         // update the committed snapshots
         it = insertedObjects.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             registrar.setCommitSnapshot( o, null );
             registrar.setCurrentSnapshot( o, null );
         }
         it = updatedObjects.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             registrar.setCommitSnapshot( o, null );
             registrar.setCurrentSnapshot( o, null );
         }
         
         // clear the lists
         updatedObjects.removeAllObjects();
         insertedObjects.removeAllObjects();
         it = new NSArray( deletedObjects() ).iterator();
         while ( it.hasNext() )
         {   // parent is doing this as well?
             forgetObject( it.next() );   
         }
         
         // post notification
         NSNotificationCenter.defaultCenter().postNotification(
             new NSNotification(
                 EditingContextDidSaveChangesNotification, this, userInfo ) );
     }
 
     /***
     * Commits all changes in the specified editing context
     * to this one.  Called by child editing contexts in
     * their saveChanges() method.
     */
     public void saveChangesInEditingContext ( 
         EOEditingContext aContext)
     {
         Object o;
         Iterator it;
         
         // process deletes
         List deletes = new NSArray( aContext.deletedObjects() );
         it = deletes.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             EOGlobalID id = aContext.globalIDForObject( o );
             Object localVersion = objectForGlobalID( id );
             if ( localVersion == null )
             {
                 // make a local copy and register it
                 localVersion = registerClone( id, aContext, o, this );
                 if ( localVersion == null )
                 {
                     throw new WotonomyException(
                         "Deleted object could not be serialized: " 
                         + id + " : " + o );
                 }
             }
             else // we have a local version, copy changes
             {
                 copy( aContext, o, this, localVersion );
                 // copy marks the object as updated: will be on both lists
             }
             // delete our copy -- marks context as changed
             deleteObject( localVersion );
         }
 
         // process inserts - all inserts are new objects
         List inserts = new NSArray( aContext.insertedObjects() );
         it = inserts.iterator();
         while ( it.hasNext() )
         {
             o = it.next();
             // make a local copy and register it
             EOGlobalID id = aContext.globalIDForObject( o );
             willChange(); // need to mark editing context as changed
             Object localVersion = registerClone( id, aContext, o, this );
             if ( localVersion == null )
             {
                 throw new WotonomyException(
                     "Inserted object could not be serialized: " 
                     + o );
             }
             // insert our copy manually so a new id is not generated
             insertedObjects.addObject( localVersion );
             insertedObjectsBuffer.addObject( localVersion );
         }
 
         // process updates
         List updates = new NSArray( aContext.updatedObjects() ); 
         it = updates.iterator();
         while ( it.hasNext() )
         {
             willChange(); // need to mark editing context as changed
             o = it.next();
             EOGlobalID id = aContext.globalIDForObject( o );
             Object localVersion = objectForGlobalID( id );
             if ( localVersion == null )
             {
                 // make a local copy and register it
                 localVersion = registerClone( id, aContext, o, this );
                 if ( localVersion == null )
                 {
                     throw new WotonomyException(
                         "Updated object could not be serialized: " 
                         + id + " : " + o );
                 }
                 if ( id.isTemporary() )
                 {
                     // mark this object as inserted
                     insertedObjects.addObject( localVersion );
                     insertedObjectsBuffer.addObject( localVersion );
                 }
                 else
                 {
                     // mark this object as updated
                     updatedObjects.addObject( localVersion );
                     
                     // notify of update only if not on deleted list
                     if ( deletedObjectsBuffer.indexOfIdenticalObject( 
                         localVersion ) == NSArray.NotFound )
                     {
                         updatedObjectsBuffer.addObject( localVersion );
                     }
                 }
             }
             else // we have a local version, copy changes
             {
                 copy( aContext, o, this, localVersion );
                 // copy marks the object as updated 
             }
         }
         
     }
 
     /***
     * Sets the delegate for this editing context.
     * Note: this implementation retains only a 
     * weak reference to the specified object.
     */
     public void setDelegate ( 
         Object anObject )
     {
         if ( anObject == null ) delegate = null;
         delegate = new WeakReference( anObject );
     }
 
     /***
     * Sets the fetch timestamp for this editing context.
     */
     public void setFetchTimestamp ( 
         double aDouble )
     {
         fetchTimestamp = aDouble;
     }
 /*
     public void setInvalidatesObjectsWhenFinalized ( 
         boolean invalidatesObjects )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 
     public void setInvalidatesObjectsWhenFreed ( 
         boolean invalidatesObjects )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
     /***
     * Sets whether this editing context attempts to
     * lock objects when they are first modified.
     * Default is false.
     */
     public void setLocksObjectsBeforeFirstModification ( 
         boolean locksObjects )
     {
         lockBeforeModify = locksObjects;
     }
 
     /***
     * Sets the message handler for this editing context.
     * Note: this implementation retains only a 
     * weak reference to the specified object.
     */
     public void setMessageHandler ( 
         Object anObject )
     {
         if ( anObject == null ) messageHandler = null;
         messageHandler = new WeakReference( anObject );
     }
 
     /***
     * Sets whether this editing context propagates deletes
     * immediately after the event that triggered the delete.
     * Otherwise, propagation occurs only before commit.
     * Default is true.
     */
     public void setPropagatesDeletesAtEndOfEvent ( 
         boolean propagatesDeletes )
     {
         propagateDeletesAfterEvent = propagatesDeletes;
     }
 /*
     public void setSharedEditingContext ( 
         EOSharedEditingContext aSharedEditingContext )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
     /***
     * Sets whether validation is stopped after the
     * first error occurs.  Otherwise, validation will
     * continue for all other objects.
     * Default is true.
     */
     public void setStopsValidationAfterFirstError ( 
         boolean stopsValidation )
     {
         stopValidationAfterError = stopsValidation;
     }
 
     /***
     * Sets the undo manager to be used for this context.
     * Note: This is currently javax.swing.undo.UndoManager,
     * until we have a implementation of NSUndoManager.
     */
 /*
     public void setUndoManager ( 
         UndoManager anUndoManager )
     {
         undoManager = anUndoManager;
     }
 */
 /*
     public EOSharedEditingContext sharedEditingContext ()
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
     /***
     * Returns whether validation is stopped after the
     * first error occurs.  Otherwise, validation will
     * continue for all other objects.
     */
     public boolean stopsValidationAfterFirstError ()
     {
         return stopValidationAfterError;
     }
 
     /***
     * Reverts the last change on the undo stack.
     */
     public void undo ()
     {
         //TODO: not supported yet
         throw new UnsupportedOperationException("Not implemented yet.");
     }
 /*
     public NSUndoManager undoManager ()
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
 /***
     public void unlock ()
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */    
     /***
     * Returns a read-only list of all objects marked as modified,
     * but not inserted or deleted, in this editing context.
     */
     public NSArray updatedObjects ()
     {
         return updatedObjectsProxy;
     }
 
     /***
     * Notify editors of changes.
     */    
     private void fireWillSaveChanges()
     {
         Object o = null;
         Iterator i = editors().iterator();
         while ( i.hasNext() )
         {
             try
             {
                 o = i.next();
                 NSSelector.invoke( "editingContextWillSaveChanges", 
                     new Class[] { EOEditingContext.class }, o, this );
             }
             catch ( NoSuchMethodException e )
             {
                 // ignore: not implemented
             }
             catch ( Exception exc )
             {
                 // log to standard error
                 System.err.println( "Error while notifying editor of pending save: " + o );
                 exc.printStackTrace();
             }
         }
     }
     
     /***
     * Handles notifications from parent store, looking for
     * InvalidatedAllObjectsInStoreNotification and
     * ObjectsChangedInStoreNotification.
     * The former causes all objects in this store to be
     * invalidated.
     * The latter refaults the invalidated ids, merges changes
     * from the updated ids, and forgets the deleted ids, then
     * posts a ObjectsChangedInStoreNotification.
     * Note: This method is not in the public specification.
     */
     public void handleNotification( NSNotification aNotification )
     { // System.out.println( "EOEditingContext: " + this + " : " + aNotification );
 
         willChange();
         if ( InvalidatedAllObjectsInStoreNotification
             .equals( aNotification.name() ) )
         {
             refaultObjects();
             
             // relay notification
             NSNotificationCenter.defaultCenter().postNotification(
                 new NSNotification(
                     InvalidatedAllObjectsInStoreNotification, this ) );
         }
         else
         if ( EOGlobalID.GlobalIDChangedNotification
             .equals( aNotification.name() ) )
         {
             NSDictionary userInfo = aNotification.userInfo();
             
             // if any keys in userInfo are registered ids, 
             // re-register with new permanent values.
 
             Object o;
             EOGlobalID id;
             Enumeration e = userInfo.keyEnumerator();
             while ( e.hasMoreElements() )
             {
                 id = (EOGlobalID) e.nextElement();
                 o = objectForGlobalID( id );
                 if ( o != null )
                 {
                     // record object is assumed to handle key updates
                     recordObject( o, (EOGlobalID) userInfo.objectForKey( id ) );
                 }
             }
         }
         else
         if ( EOObjectStore.ObjectsChangedInStoreNotification
             .equals( aNotification.name() ) )
         {
             //System.out.println( "EOEditingContext.handleNotification: " + aNotification + " : " + this );            
             // post so child contexts are notified
             willChange();
 
             Object o;
             EOGlobalID id;
             Enumeration e;
             NSDictionary userInfo = aNotification.userInfo();
             
             // inserted objects are ignored
             
             // existing deleted objects are removed
             NSArray deletes = (NSArray) userInfo.objectForKey( 
                 EOObjectStore.DeletedKey );
             e = deletes.objectEnumerator();
             while ( e.hasMoreElements() )
             {
                 id = (EOGlobalID) e.nextElement();
                 o = objectForGlobalID( id );
                 if ( o != null )
                 {
                     //System.out.println( "EOEditingContext: deleted: " + id );
                     forgetObject( o );
                     deletedObjectsBuffer.addObject( o );            
                     deletedIDsBuffer.addObject( id );            
                 }
             }
             
             // existing updated objects are merged
             NSArray updates = (NSArray) userInfo.objectForKey( 
                 EOObjectStore.UpdatedKey );
             e = updates.objectEnumerator();
             while ( e.hasMoreElements() )
             {
                 id = (EOGlobalID) e.nextElement();
                 o = objectForGlobalID( id );
                 if ( o != null )
                 {
                     //System.out.println( "EOEditingContext: updated: " + id );
                     if ( updatedObjects // only update if unchanged
                         .indexOfIdenticalObject( o ) == NSArray.NotFound )
                     {
                         refaultObject( o, id, this );
                         updatedObjectsBuffer.addObject( o );            
                     }
                     else
                     {
                         // notify user and/or merge
                         handleUpdateConflict( id, o );
                     }
                 }
             }
                 
             // existing invalidated objects are refaulted           
             NSArray invalidates = (NSArray) userInfo.objectForKey( 
                 EOObjectStore.InvalidatedKey );
             e = invalidates.objectEnumerator();
             while ( e.hasMoreElements() )
             {
                 id = (EOGlobalID) e.nextElement();
                 o = objectForGlobalID( id );
                 if ( o != null )
                 {
                     if ( updatedObjects // only invalidate if unchanged
                         .indexOfIdenticalObject( o ) == NSArray.NotFound )
                     {
                         refaultObject( o, id, this );
                     }
                     else
                     {
                         // notify user and/or merge
                         handleUpdateConflict( id, o );
                     }
                     if ( invalidatedObjectsBuffer
                         .indexOfIdenticalObject( o ) == NSArray.NotFound )
                     {
                         invalidatedObjectsBuffer.addObject( o ); 
                     }
                     if ( invalidatedIDsBuffer
                         .indexOfIdenticalObject( id ) == NSArray.NotFound )
                     {
                         invalidatedIDsBuffer.addObject( id );
                     }
                 }
             }
                
         }
     }
     
     /***
     * Called by handleNotification to resolve the case where we have
     * received notification that another user or context has updated
     * an object that is currently marked as edited in this context.
     * This implementation first asks the delegate if it should merge.
     * If true or no delegate, the changes are merged. True or false, 
     * the delegate is then sent editingContextDidMergeChanges.
     */
     private void handleUpdateConflict( EOGlobalID anID, Object anObject )
     {
         // if we're causing the invalidation, ignore
         // (this is probably better handled by the caller...)
         if ( isInvalidating ) 
         {
             ignoreChanges = true;
             parentStore.refaultObject( anObject, anID, this );
             ignoreChanges = false;
             return;
         }
 
         Boolean result = (Boolean) notifyDelegate( 
             "editingContextShouldMergeChangesForObject", 
             new Class[] { EOEditingContext.class, Object.class },
             new Object[] { this, anObject } );
 
         if ( ( result == null ) || ( Boolean.TRUE.equals( result ) ) )         
         {
             // do merge
             mergeExternalChanges( anID, anObject );
         }
         else // Boolean.FALSE
         {
             // do nothing: don't lose the user's changes
         }
         
         // notify merge did happen
         notifyDelegate( 
             "editingContextDidMergeChanges", 
             new Class[] { EOEditingContext.class },
             new Object[] { this } );
     }    
     
     /***
     * For the currently modified object with the specified global id,
     * this method merges changes with the updated version in the parent 
     * object store.  This implementation looks at the fetch snapshot
     * to determine which changes where made by the user, fetches the
     * updated version of the object, and then determine what external
     * changes were made.  If the changes do not overlap, the original
     * changes are applied to the updated version.  If there is a conflict,
     * notifies the user of the conflict.  
     */
     private boolean mergeExternalChanges( EOGlobalID anID, Object anObject )
     {
         try
         {
             Iterator i;
             Object key;
             
             // get fetch snapshot
             Map fetchSnapshot = committedSnapshotForObject( anObject );
             
             // get current snapshot
             Map currentSnapshot = currentEventSnapshotForObject( anObject );
             
             // diff against fetch snapshot
             Map currentDiff = new HashMap();
             i = currentSnapshot.keySet().iterator();
             while ( i.hasNext() )
             {
                 key = i.next();
                 if ( ! currentSnapshot.get( key ).equals( fetchSnapshot.get( key ) ) )
                 {
                     currentDiff.put( key, currentSnapshot.get( key ) );
                 }
             }
             
             // refault
             ignoreChanges = true;
             parentStore.refaultObject( anObject, anID, this );
             ignoreChanges = false;
             
             // get updated snapshot
             Map updatedSnapshot = convertSnapshotToDictionary( takeSnapshot( anObject ) );
             
             // diff against fetch snapshot
             Map updatedDiff = new HashMap();
             i = updatedSnapshot.keySet().iterator();
             while ( i.hasNext() )
             {
                 key = i.next();
                 if ( ! updatedSnapshot.get( key ).equals( fetchSnapshot.get( key ) ) )
                 {
                     updatedDiff.put( key, updatedSnapshot.get( key ) );
                 }
             }
             
             // determine if there's a conflict
             boolean proceed = true;
             Set updatedKeys = updatedDiff.keySet();
             i = currentDiff.keySet().iterator();
            while ( i.hasNext() )
             {
                 if ( updatedKeys.contains( i.next() ) )
                 {
                     proceed = false;
                     break;
                 }
             }
             
             // if no conflicts, apply original diff to current object and exit
             if ( proceed )
             {
                 KeyValueCodingUtilities.takeStoredValuesFromDictionary( anObject, currentDiff );
                 return true; // exit!
             }
         }
         catch ( Exception exc )
         {
             // log error to standard out
             exc.printStackTrace();
         }
         
         // notify user we're unable to merge
         notifyMessageHandler( MessageChangeConflict + anObject );
         return false;
     }
 
     /***
      * Sends the specified message to the message handler.
      */
     private void notifyMessageHandler( String aMessage )
     {
         Object handler = null;
         try
         {
             handler = messageHandler();
             if ( handler == null ) return;
             NSSelector.invoke( "editingContextPresentErrorMessage", 
                 new Class[] { EOEditingContext.class, String.class }, 
                 handler, this, aMessage );
         }
         catch ( NoSuchMethodException e )
         {
             // ignore: not implemented
         }
         catch ( Exception exc )
         {
             // log to standard error
             System.err.println( 
                 "Error while notifying message handler: " + 
                     handler + " : " + aMessage );
             exc.printStackTrace();
         }
     }
     
     /***
      * Sends the specified message to the delegate.
      * Returns the return value of the method,
      * or null if no return value or no delegate
      * or no implementation.
      */
     private Object notifyDelegate( 
         String aMethodName, Class[] types, Object[] params )
     {
         try
         {
             Object delegate = delegate();
             if ( delegate == null ) return null;
             return NSSelector.invoke( 
                 aMethodName, types, delegate, params );
         }
         catch ( NoSuchMethodException e )
         {
             // ignore: not implemented
         }
         catch ( Exception exc )
         {
             // log to standard error
             System.err.println( 
                 "Error while messaging delegate: " + 
                     delegate + " : " + aMethodName );
             exc.printStackTrace();
         }
         
         return null;
     }
     
     // interface EOObserving
 	
     /***
     * Implementation of the EOObserving interface.
     * Called before objects are modified.
     */
     public void objectWillChange ( 
         Object anObject )
     {
         if ( ignoreChanges ) return;
 //NSNotificationCenter.defaultCenter().postNotification( "objectWillChange", this, new NSDictionary( "object", anObject ) );
 //new RuntimeException().printStackTrace();
 
         willChange();
 
         // mark as updated if not marked already
         int i = updatedObjects.indexOfIdenticalObject( anObject );
         if ( i == NSArray.NotFound )
         {
             // don't mark inserted objects as updated
             i = insertedObjects.indexOfIdenticalObject( anObject );
             if ( i == NSArray.NotFound )
             {
                 i = deletedObjects.indexOfIdenticalObject( anObject );
                 if ( i == NSArray.NotFound )
                 {
                     // add object
                     updatedObjects.addObject( anObject );
 
                     // record revert snapshot
                     registrar.setCommitSnapshot( anObject, takeSnapshot( anObject ) );
                 }
             }
         }
         
         // add to buffer
         if ( updatedObjectsBuffer.indexOfIdenticalObject( anObject )
                == NSArray.NotFound )
         {
             updatedObjectsBuffer.addObject( anObject );
         }
     }
 
     // static methods
     
     public static double defaultFetchTimestampLag ()
     {
         return defaultFetchTimestampLag;
     }
 
     /***
     * Returns the default parent object store for all
     * object stores created with the parameterless 
     * constructor.
     */
     public static EOObjectStore defaultParentObjectStore ()
     {
         return defaultParentObjectStore;
     }
 
 /*
     public static Object initObjectWithCoder ( 
         Object anObject,
         NSCoder aCoder )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
 
     /***
     * Returns whether editing contexts are configured to retain strong
     * references to their registered objects.  If false, editing contexts
     * will only retain weak references to their registered objects.
     */ 
     public static boolean instancesRetainRegisteredObjects()
     {
         return retainsRegisteredObjects;
     }
 
     /***
     * Sets the global default fetch timestamp lag.
     */
     public static void setDefaultFetchTimestampLag ( 
         double aDouble )
     {
         defaultFetchTimestampLag = aDouble;
     }
 
     /***
     * Sets the global default parent object store,
     * used for the parameterless constructor.
     */
     public static void setDefaultParentObjectStore ( 
         EOObjectStore anObjectStore )
     {
         defaultParentObjectStore = anObjectStore;
     }
 
     public static void setInstancesRetainRegisteredObjects ( 
         boolean retainsObjects )
     {
         retainsRegisteredObjects = retainsObjects;
     }
 
 /*
     public static void setSubstitutionEditingContext ( 
         EOEditingContext aContext)
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 
     public static void setUsesContextRelativeEncoding ( 
         boolean usesRelativeEncoding )
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 
     public static EOEditingContext substitutionEditingContext ()
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 
     public static boolean usesContextRelativeEncoding ()
     {
         throw new net.wotonomy.util.WotonomyException("Not implemented yet.");
     }
 */
 
     public String toString()
     {
         return "[EOEditingContext@"+Integer.toHexString(System.identityHashCode(this))+":"+
             " inserted="+idsForObjects(insertedObjects)+
             " updated="+idsForObjects(updatedObjects)+
             " deleted="+idsForObjects(deletedObjects)+
             " registered="+registrar.registeredGlobalIDs()+" ]";
     }
     private List idsForObjects( List objects )
     {
         List result = new LinkedList();
         Iterator i = objects.iterator();
         while ( i.hasNext() ) result.add( globalIDForObject( i.next() ) );
         return result;
     }
     
     // snapshots
     
     /***
     * Returns a NSDictionary containing only the mutable properties 
     * for the specified object and deep clones of their values.
     * Nulls are represented by NSNull.nullValue().
     */
     private byte[] takeSnapshot( Object anObject )
     { // System.out.println( "takeSnapshot: " + anObject );
         return KeyValueCodingUtilities.freeze( anObject, this, anObject, true );
     }
     
     /***
     * Applies the map of properties and values to the
     * specified object.  Null values for properties must
     * be represented by the NSNull.nullValue().
     * Posts a willChange event before applying changes.
     */
     private void applySnapshot( byte[] aSnapshot, Object anObject )
     { 
         // must clone snapshot to avoid changing existing snapshot
         NSDictionary values = convertSnapshotToDictionary( aSnapshot ); 
 
 //System.out.println( "applySnapshot: " + aSnapshot + " : " + values );
 //ignoreChanges = true;        
         willChange();
         KeyValueCodingUtilities.takeStoredValuesFromDictionary( anObject, values );        
 //ignoreChanges = false;        
     }
 
     /***
     * Snapshots are stored internally in binary format,
     * but exposed to the user as NSDictionaries.
     */
     private NSDictionary convertSnapshotToDictionary( byte[] aSnapshot )
     {
         // get the object
         Object clone = KeyValueCodingUtilities.thaw( aSnapshot, this, true );
         // get all keys for this object
         EOClassDescription classDesc =
             EOClassDescription.classDescriptionForClass( clone.getClass() );            
         List keys = new LinkedList();
         keys.addAll( classDesc.attributeKeys() ); 
         keys.addAll( classDesc.toOneRelationshipKeys() ); 
         keys.addAll( classDesc.toManyRelationshipKeys() ); 
 
         return KeyValueCodingUtilities.valuesForKeys( clone, keys );
     }
     /***
     * Creates a deep clone of the specified object.
     * (Object.clone() only creates a shallow clone.)
     * Returns null if operation fails.
     */ 
     static private Object clone( 
         EOEditingContext aSourceContext,
         Object aSource, 
         EOEditingContext aDestinationContext )
     { // System.out.println( "clone: " + aSource );
         return KeyValueCodingUtilities.clone( 
             aSourceContext, aSource, aDestinationContext );
     }
 
     /***
     * Creates a deep clone of the specified object.
     * but does not transpose references.  This allows
     * us to register an object before transposing
     * references so that child objects will be able
     * to resolve references to their parent.
     * After recording the object, we copy the source
     * object into the clone, which does transpose
     * and resolve properly.
     * Returns null if operation fails.
     */ 
     static private Object registerClone( 
         EOGlobalID aGlobalID,
         EOEditingContext aSourceContext,
         Object aSource, 
         EOEditingContext aDestinationContext )
     { 
         // while we'd like to just transpose/clone at the same time
         //   we must record a clone without transposing: this
         //   avoids a endless loop if the object graph has a cycle
         Object clone = KeyValueCodingUtilities.thaw( 
                 KeyValueCodingUtilities.freeze( 
                     aSource, aSourceContext, aSource, false ), 
                 aDestinationContext, false );
             
         aDestinationContext.recordObject( clone, aGlobalID );
         
         // need to copy to transpose references into this context
         //   while preserving the same instance of the object
         aDestinationContext.ignoreChanges = true;
         copy( aSourceContext, aSource, aDestinationContext, clone );
         aDestinationContext.ignoreChanges = false;
 
         // return our clone
         return clone;
     }
     
     /***
     * Copies values from one object to another.
     * Returns the destination object, or throws exception
     * if operation fails.
     */ 
     static private Object copy( 
         EOEditingContext aSourceContext,
         Object aSource, 
         EOEditingContext aDestinationContext,
         Object aDestination )
     { // System.out.println( "copy: " );
         EOObserverCenter.notifyObserversObjectWillChange( aDestination );
         KeyValueCodingUtilities.copy( aSourceContext, aSource, aDestinationContext, aDestination );
         return aDestination;
     }
     
     // process recent changes 
     
     /***
     * Called to notify observers of changes.
     * Also calls runLater().
     */
     private void willChange()
     {
         EOObserverCenter.notifyObserversObjectWillChange( this );        
         runLater();
     }
     
 	/***
 	* Called to ensure that processRecentChanges
 	* will be called on the next event loop.
 	*/
 	private void runLater()
 	{
 		if ( ! willRunLater )
 		{
 			willRunLater = true;
             NSRunLoop.currentRunLoop().performSelectorWithOrder(
                 runLaterSelector, this, null, EditingContextFlushChangesRunLoopOrdering, null );
 		}
 	}
 	
 	/***
 	* This method is called by the event queue run loop
 	* and calls processRecentChanges.
 	* NOTE: This method is not part of the specification.
 	*/
 	public void flushRecentChanges( Object anObject )
 	{
 //System.out.println( "EODelayedObserverQueue: running" );		
     	processRecentChanges();
 		willRunLater = false;
 	}
 	
     // inner classes
 
     /***
     * Gatekeeper for all access to registered objects.
     */
     static private class Registrar
     {
         EOEditingContext context;
         NSMutableDictionary IDsToObjects;
         NSMutableDictionary objectsToIDs;
         NSMutableDictionary objectsToCommitSnapshots;
         NSMutableDictionary objectsToCurrentSnapshots;
 
         ReferenceKey comparisonKey; //FIXME not thread safe!
 
         public Registrar( EOEditingContext aContext )
         {
             context = aContext;
             IDsToObjects = new NSMutableDictionary();
             objectsToIDs = new NSMutableDictionary();
             objectsToCommitSnapshots = new NSMutableDictionary();
             objectsToCurrentSnapshots = new NSMutableDictionary();
             comparisonKey = new ReferenceKey();
         }
         
         public NSArray registeredObjects()
         {
             return IDsToObjects.allValues();
         }
         
         public NSArray registeredGlobalIDs()
         {
             return IDsToObjects.allKeys();
         }
         
         public Object objectForGlobalID( EOGlobalID aGlobalID )
         {
             return IDsToObjects.objectForKey( aGlobalID );
         }
         
         public EOGlobalID globalIDForObject( Object anObject )
         {
             comparisonKey.set( anObject );
             return (EOGlobalID) objectsToIDs.objectForKey( comparisonKey );
         }
         
         public byte[] getCommitSnapshot( Object anObject )
         {
             comparisonKey.set( anObject );
             return (byte[]) objectsToCommitSnapshots.objectForKey( comparisonKey );
         }
         
         public void setCommitSnapshot( Object anObject, byte[] aSnapshot )
         {
             if ( aSnapshot == null )
             {
                 comparisonKey.set( anObject );
                 objectsToCommitSnapshots.removeObjectForKey( comparisonKey );
             }
             else
             {
                 objectsToCommitSnapshots.setObjectForKey( 
                     aSnapshot, new ReferenceKey( anObject ) );
             }
         }
         
         public byte[] getCurrentSnapshot( Object anObject )
         {
             comparisonKey.set( anObject );
             return (byte[]) objectsToCurrentSnapshots.objectForKey( comparisonKey );
         }
         
         public void setCurrentSnapshot( Object anObject, byte[] aSnapshot )
         {
             if ( aSnapshot == null )
             {
                 comparisonKey.set( anObject );
                 objectsToCurrentSnapshots.removeObjectForKey( comparisonKey );
             }
             else
             {
                 objectsToCurrentSnapshots.setObjectForKey( 
                     aSnapshot, new ReferenceKey( anObject ) );
             }
         }
         
         public void registerObject( Object anObject, EOGlobalID aGlobalID )
         {
             IDsToObjects.setObjectForKey( anObject, aGlobalID );
             objectsToIDs.setObjectForKey( aGlobalID, new ReferenceKey( anObject ) );
             EOObserverCenter.addObserver( context, anObject );
         }
         
         public void forgetObject( Object anObject )
         {
             comparisonKey.set( anObject );
             Object id = objectsToIDs.objectForKey( comparisonKey );
             IDsToObjects.removeObjectForKey( id );
             objectsToIDs.removeObjectForKey( comparisonKey );
             EOObserverCenter.removeObserver( context, anObject );
         }
         
         public void disposeSnapshots( Object anObject )
         {
             setCommitSnapshot( anObject, null );
             setCurrentSnapshot( anObject, null );
         }
 
     }
     
     /***
     * Registrar that uses only WeakReferences.
     * Used if retainsRegisteredObjects is false.
     */
     static private class WeakRegistrar extends Registrar
     {
         private WeakReferenceKey weakComparisonKey; //FIXME not thread safe!
         
         public WeakRegistrar( EOEditingContext aContext )
         {
             super( aContext );
             weakComparisonKey = new WeakReferenceKey();
         }
         
         public NSArray registeredObjects()
         {
             Object object;
             WeakReferenceKey weakKey;
             NSMutableArray result = new NSMutableArray();
             Enumeration e = new NSArray( objectsToIDs.allKeys() ).objectEnumerator();
             while ( e.hasMoreElements() )
             {
                 weakKey = (WeakReferenceKey) e.nextElement();
                 object = weakKey.get();
                 if ( object != null )
                 {
                     result.addObject( object );
                 }
                 else
                 {
                     // object has been released: perform cleanup
                     disposeObject( null, weakKey );
                 }
             }
             return result;
         }
         
         public Object objectForGlobalID( EOGlobalID aGlobalID )
         {
             WeakReference ref = (WeakReference) super.objectForGlobalID( aGlobalID );
             if ( ref == null ) return null;
             Object result = ref.get();
             if ( result == null )
             {
                 // clean up manually
                 IDsToObjects.removeObjectForKey( aGlobalID );
                 Iterator i = new LinkedList( objectsToIDs.allKeysForObject( ref ) ).iterator();
                 while ( i.hasNext() )
                 {
                     objectsToIDs.removeObjectForKey( i.next() );
                 }
                 disposeSnapshots( aGlobalID ); 
             }
             return result;
         }
         
         public byte[] getCommitSnapshot( Object anObject )
         {
             weakComparisonKey.set( anObject );
             return (byte[]) objectsToCommitSnapshots.objectForKey( weakComparisonKey );
         }
         
         public void setCommitSnapshot( Object anObject, byte[] aSnapshot )
         {
             if ( aSnapshot == null )
             {
                 weakComparisonKey.set( anObject );
                 objectsToCommitSnapshots.removeObjectForKey( weakComparisonKey );
             }
             else
             {
                 objectsToCommitSnapshots.setObjectForKey( 
                     aSnapshot, new WeakReferenceKey( anObject ) );
             }
         }
         
         public byte[] getCurrentSnapshot( Object anObject )
         {
             weakComparisonKey.set( anObject );
             return (byte[]) objectsToCurrentSnapshots.objectForKey( weakComparisonKey );
         }
         
         public void setCurrentSnapshot( Object anObject, byte[] aSnapshot )
         {
             if ( aSnapshot == null )
             {
                 weakComparisonKey.set( anObject );
                 objectsToCurrentSnapshots.removeObjectForKey( weakComparisonKey );
             }
             else
             {
                 objectsToCurrentSnapshots.setObjectForKey( 
                     aSnapshot, new WeakReferenceKey( anObject ) );
             }
         }
         
         public void registerObject( Object anObject, EOGlobalID aGlobalID )
         { // new net.wotonomy.ui.swing.ReferenceInspector( anObject );            
             IDsToObjects.setObjectForKey( new WeakReference( anObject ), aGlobalID );
             objectsToIDs.setObjectForKey( aGlobalID, new WeakReferenceKey( anObject ) );
             EOObserverCenter.addObserver( context, anObject );
         }
         
         public void forgetObject( Object anObject )
         {
             disposeObject( anObject, null );
         }
         
         // must specify one or the other
         private void disposeObject( Object anObject, WeakReferenceKey key )
         {
             if ( key == null ) key = new WeakReferenceKey( anObject );
             EOGlobalID id = (EOGlobalID) objectsToIDs.objectForKey( key );
             if ( id != null ) IDsToObjects.removeObjectForKey( id );
             objectsToIDs.removeObjectForKey( key );
             disposeSnapshots( id );
             if ( anObject != null )
             {
                 EOObserverCenter.removeObserver( context, anObject );
             }
         }
     }
     
     /***
     * Private class used to force a hashmap to
     * perform key comparisons by reference.
     */
 	static private class ReferenceKey 
     {
         int hashCode;
         Object referent;
         
         public ReferenceKey()
         {
             referent = null;
             hashCode = -1;
         }
         
         public ReferenceKey( Object anObject )
         {
             set( anObject );
         }
         
         public Object get()
         {
             return referent;
         }
         
         public void set( Object anObject )
         {
             referent = anObject;
             hashCode = anObject.hashCode();
         }
         
         /***
         * Returns the actual key's hash code.
         */
         public int hashCode()
         {
             return hashCode;   
         }
         
         /***
         * Compares by reference.
         */ 
         public boolean equals( Object anObject )
         {
             if ( anObject == this ) return true;
             if ( anObject instanceof ReferenceKey )
             {
                 return ((ReferenceKey)anObject).get() == referent;
             }
             return false;  
         }
     }
 
     /***
     * Private class used to force a hashmap to
     * perform key comparisons by reference.
     */
 	static private class WeakReferenceKey extends ReferenceKey
     {
         public WeakReferenceKey()
         {
             super();
         }
         
         public WeakReferenceKey( Object anObject )
         {
             super( anObject );
         }
         
         public Object get()
         {
             return ((WeakReference)referent).get();
         }
         
         public void set( Object anObject )
         {
             referent = new WeakReference( anObject );
             hashCode = anObject.hashCode();
         }
         
         /***
         * Compares by reference.
         */ 
         public boolean equals( Object anObject )
         {
             if ( anObject == this ) return true;
             if ( anObject instanceof ReferenceKey )
             {
                 return ((ReferenceKey)anObject).get() == get();
             }
             return false;  
         }
     }
 
     /***
     * Key combining an object with a string.
     * Object is compared by reference.
     */ 
 	static private class CompoundKey 
     {
         private Object object;
         private String string;
         private int hashCode;
         
         /***
         * Creates compound key.  
         * Neither name nor object may be null.
         */
         public CompoundKey ( 
             Object anObject, String aString )
         {
             object = anObject;
             string = aString;
             hashCode = object.hashCode() + string.hashCode();
         }
         
         public int hashCode()
         {
             return hashCode;
         }
         
         public boolean equals( Object anObject )
         {
             if ( anObject instanceof CompoundKey )
             {
                 CompoundKey key = (CompoundKey) anObject;
                 return ( ( key.object == object ) && ( key.string.equals( string ) ) );
             }
             return false;  
         }
         
         public String toString()
         {
             return "[CompoundKey:"+object+":"+string+"]";   
         }
     }
 	
     /***
     * Used by EditingContext to delegate behavior to another class.
     * Note that EditingContext doesn't require its delegates to implement
     * this interface: rather, this interface defines the methods that
     * EditingContext will attempt to invoke dynamically on its delegate.
     * The delegate may choose to implement only a subset of the methods
     * on the interface.
     */
     public interface Delegate
     {
         /***
         * Called after the editing context has completed merge operations
         * on one or more objects after receiving an ObjectChangedInStore
         * notification.
         */
         void editingContextDidMergeChanges( 
             EOEditingContext anEditingContext );
             
         /***
         * Called by objectsWithFetchSpecification.  
         * If null, the editing context will pass the fetch specification
         * on to its parent store, as normal.  Otherwise, the context
         * will use the returned array to service the request.
         */
         NSArray editingContextShouldFetchObjects( 
             EOEditingContext anEditingContext,
             EOFetchSpecification fetchSpecification );
             
         /***
         * Called to determine whether an object should be invalidated.
         * Return false to prevent the object from being invalidated.
         * Default is true.
         */
         boolean editingContextShouldInvalidateObject( 
             EOEditingContext anEditingContext,
             Object anObject, 
             EOGlobalID aGlobalID );
             
         /***
         * Called to determine whether the editing context should attempt
         * to merge changes in the specified object that the parent store
         * says has changed via an ObjectChangedInStore notification.
         * Default is true.  Return false if you wish to handle the merge
         * yourself, by extracting the values in the object now and comparing
         * them to the values when editingContextDidMergeChanges is called.
         */
         boolean editingContextShouldMergeChangesForObject( 
             EOEditingContext anEditingContext,
             Object anObject );
             
         /***
         * Returns whether the editing context should ask its message handler
         * to display a message.  Return false if the delegate will display the error.
         * Default is true.
         */
         boolean editingContextShouldPresentException( 
             EOEditingContext anEditingContext,
             Throwable exception );
             
         /***
         * Returns whether the editing context should undo the most
         * recent set of changes that resulted in a validation failure.
         * Default is true.
         */
         boolean editingContextShouldUndoUserActionsAfterFailure( 
             EOEditingContext anEditingContext );
             
         /***
         * Returns whether the editing context should validate the
         * most recent set of changes.  Default is true.
         */
         boolean editingContextShouldValidateChanges( 
             EOEditingContext anEditingContext );
             
         /***
         * Called before the editing context saves its changes
         * to the parent object store.
         */
         void editingContextWillSaveChanges( 
             EOEditingContext anEditingContext );
 
     }
     
     /***
     * Editors register themselves with the editing context
     * so that they may receive notification before the context
     * commits changes.  This is useful for associations whose
     * components do not immediately commit their changes to
     * the object they are editing.
     */
     public interface Editor
     {
         /***
         * Called before the editing context saves its changes
         * to the parent object store.
         */
         void editingContextWillSaveChanges( 
             EOEditingContext anEditingContext );
 
         /***
         * Called to determine whether this editor has changes
         * that have not been committed to the object in the context.
         */
         boolean editorHasChangesForEditingContext(
             EOEditingContext anEditingContext );
 
     }
             
     /***
     * Used by EditingContext to delegate messaging handling to another class,
     * typically the display group that has the currently active association.
     * Note that EditingContext doesn't require its message handlers to implement
     * this interface: rather, this interface defines the methods that
     * EditingContext will attempt to invoke dynamically on its delegate.
     * The delegate may choose to implement only a subset of the methods
     * on the interface.
     */
     public interface MessageHandler
     {
         /***
         * Called to display a message for an error that occurred
         * in the specified editing context.
         */
         void editingContextPresentErrorMessage( 
             EOEditingContext anEditingContext,
             String aMessage );
 
         /***
         * Called by the specified object store to determine whether
         * fetching should continue, where count is the current count
         * and limit is the limit as specified by the fetch specification.
         * Default is false.
         */
         boolean editingContextShouldContinueFetching(
             EOEditingContext anEditingContext,
             int count,
             int limit,
             EOObjectStore anObjectStore );
 
     }
             
 }
 
 /*
  * $Log$
  * Revision 1.2  2006/02/16 16:47:14  cgruber
  * Move some classes in to "internal" packages and re-work imports, etc.
  *
  * Also use UnsupportedOperationExceptions where appropriate, instead of WotonomyExceptions.
  *
  * Revision 1.1  2006/02/16 13:19:57  cgruber
  * Check in all sources in eclipse-friendly maven-enabled packages.
  *
  * Revision 1.86  2003/12/18 15:37:38  mpowers
  * Changes to retain ability to work with objects that don't necessarily
  * implement EOEnterpriseObject.  I would still like to preserve this case
  * for general usage, however the access package is free to assume that
  * those objects will be EOs and cast appropriately.
  *
  * Revision 1.85  2003/08/19 01:53:12  chochos
  * EOObjectStore had some incompatible return types (Object instead of EOEnterpriseObject, in fault methods mostly). It's internally consistent but I hope it doesn't break anything based on this, even though fault methods mostly throw exceptions for now.
  *
  * Revision 1.84  2003/08/06 23:07:52  chochos
  * general code cleanup (mostly, removing unused imports)
  *
  * Revision 1.83  2003/02/13 15:24:33  mpowers
  * hasChanges is now derived, not tracked.
  * refaultObject now more consistently removes object from updated list.
  *
  * Revision 1.82  2002/12/16 15:46:00  mpowers
  * Major refactoring to implement setInstancesRetainRegisteredObjects().
  *
  * Revision 1.81  2002/11/18 22:10:58  mpowers
  * Now resetting hasChanges flag on reset.
  *
  * Revision 1.80  2002/10/24 21:15:33  mpowers
  * New implementations of NSArray and subclasses.
  *
  * Revision 1.79  2002/10/24 18:18:12  mpowers
  * NSArray's are now considered read-only, so we can return our internal
  * representation to reduce unnecessary object allocation.
  *
  * Revision 1.78  2002/06/21 21:44:33  mpowers
  * No longer marking deleted objects as updated (thanks to dwang).
  *
  * Revision 1.77  2002/05/20 15:10:17  mpowers
  * No longer refaulting if delegate does not wish to handle the merge.
  *
  * Revision 1.76  2002/03/26 21:46:06  mpowers
  * Contributing EditingContext as a java-friendly convenience.
  *
  * Revision 1.75  2002/03/06 16:14:57  mpowers
  * More attempts at ignoring update conflicts that come from ourself.
  *
  * Revision 1.74  2002/02/21 21:57:50  mpowers
  * Implemented default merge behavior.
  *
  * Revision 1.73  2002/02/20 16:46:54  mpowers
  * Implemented better support for EOEditingContext.Delegate.
  *
  * Revision 1.70  2002/02/19 22:26:05  mpowers
  * Implemented EOEditingContext.MessageHandler support.
  *
  * Revision 1.69  2002/02/19 16:33:42  mpowers
  * Implemented support for EditingContext.Editor
  *
  * Revision 1.68  2002/02/13 22:00:34  mpowers
  * Fixed: invalidateAllObjects tries to invalidate inserted objects,
  * typically causing class cast exceptions involving EOTemporaryGlobalID.
  *
  * Revision 1.67  2002/02/06 21:15:35  mpowers
  * No longer refaulting a dirty object when we receive an invalidation notif.
  *
  * Revision 1.66  2002/01/08 19:31:03  mpowers
  * refaultObject now correctly refaults the object.
  *
  * Revision 1.65  2001/12/20 18:56:15  mpowers
  * Refinements to snapshotting and calling processRecentChanges.
  *
  * Revision 1.64  2001/12/10 15:11:41  mpowers
  * Now only tracking a commit snapshot after an object has been modified.
  *
  * Revision 1.63  2001/11/14 00:08:10  mpowers
  * Now marking context changed when objects are inserted or deleted
  * and when child contexts save their changes into this context.
  *
  * Revision 1.62  2001/11/07 14:49:31  mpowers
  * invalidateAllObjects now handles objects manually discarded in the course
  * of invalidation.
  *
  * Revision 1.61  2001/10/26 20:02:49  mpowers
  * No longer using NSNotificationQueue: all notifications are posted immed.
  *
  * Revision 1.60  2001/10/26 18:37:50  mpowers
  * Now using NSRunLoop to correctly flush recent changes before delayed
  * observers and AWT events.
  *
  * Revision 1.59  2001/10/23 22:29:59  mpowers
  * Now posting notifications immediately.
  * Recent changes are flushed at ObserverPrioritySixth, soon to change.
  *
  * Revision 1.58  2001/09/10 14:16:51  mpowers
  * EditingContexts now relay InvalidatedAllObjectsInStore notifications.
  *
  * Revision 1.57  2001/06/18 14:11:15  mpowers
  * Inserting a deleted object simply cancels the delete operation.
  *
  * Revision 1.56  2001/06/07 22:07:59  mpowers
  * Now handling delete notifications before update notifications.
  * Eliminated the case where deleted objects were also being put
  * on the updated list when notifying child contexts.
  *
  * Revision 1.55  2001/05/18 21:04:33  mpowers
  * Reimplemented EditingContext.initializeObject.
  *
  * Revision 1.54  2001/05/05 23:05:42  mpowers
  * Implemented Array Faults.
  *
  * Revision 1.53  2001/05/05 15:00:06  mpowers
  * Tested load-on-demand: still works.
  * Now using registerClone for consistency.
  * Editing context is temporarily posting notification on objectWillChange.
  *
  * Revision 1.52  2001/05/05 14:11:48  mpowers
  * Implemented registerClone.
  *
  * Revision 1.51  2001/05/04 16:57:56  mpowers
  * Now correctly transposing references to editing contexts when
  * cloning/copying between editing contexts.
  *
  * Revision 1.50  2001/05/02 17:58:41  mpowers
  * Removed debugging code, added comments.
  *
  * Revision 1.49  2001/05/02 15:47:40  mpowers
  * Fixed the pernicious problem with reverts: recordObject was recording
  * a snapshot of the clone before the transposition-copy happened,
  * so the revert object would lose all of its transposed relationships.
  *
  * Revision 1.48  2001/05/02 12:39:05  mpowers
  * Fixed a nasty problem with transpose-cloning and faultForGlobalID.
  * Now we're forced to create a deep clone, registered it, and then
  * transpose it after it has been registered.
  *
  * Revision 1.47  2001/04/30 13:15:24  mpowers
  * Child contexts re-initializing objects invalidated in parent now
  * propery transpose relationships.
  *
  * Revision 1.46  2001/04/29 22:02:45  mpowers
  * Work on id transposing between editing contexts.
  *
  * Revision 1.45  2001/04/29 02:29:31  mpowers
  * Debugging relationship faulting.
  *
  * Revision 1.44  2001/04/28 16:18:44  mpowers
  * Implementing relationships.
  *
  * Revision 1.43  2001/04/28 14:12:23  mpowers
  * Refactored cloning/copying into KeyValueCodingUtilities.
  *
  * Revision 1.42  2001/04/27 00:27:11  mpowers
  * Provided description to not-implemented exceptions.
  *
  * Revision 1.41  2001/04/26 01:16:44  mpowers
  * Major bug fix so we no longer accumulate objects in the all objects
  * list with every InvalidateAllObjectsInStore.
  *
  * Revision 1.40  2001/04/21 23:07:49  mpowers
  * Now only broadcasts notifications if there's actually a change.
  *
  * Revision 1.39  2001/04/13 16:33:11  mpowers
  * Corrected the refaulting behavior.
  *
  * Revision 1.38  2001/04/09 21:42:10  mpowers
  * Debugging and optimizing notifications.
  *
  * Revision 1.37  2001/04/08 20:59:47  mpowers
  * objectsForFetchSpecification now relies on faultForGlobalID.
  *
  * Revision 1.36  2001/04/03 20:36:01  mpowers
  * Fixed refaulting/reverting/invalidating to be self-consistent.
  *
  * Revision 1.35  2001/03/29 03:29:49  mpowers
  * Now using KeyValueCoding and Support instead of Introspector.
  *
  * Revision 1.34  2001/03/28 14:06:29  mpowers
  * Implemented snapshots.  Revert now uses snapshots.
  *
  * Revision 1.33  2001/03/20 23:20:33  mpowers
  * invalidating all objects now sets the dirty flag to false.
  *
  * Revision 1.32  2001/03/19 21:44:36  mpowers
  * Reverts reinitialize for now.
  * Testing for inserted objects instead of temp id when invalidating object.
  *
  * Revision 1.31  2001/03/15 21:10:26  mpowers
  * Implemented global id re-registration for newly saved inserts.
  *
  * Revision 1.30  2001/03/13 21:41:34  mpowers
  * Broadcasting willChange for any change to hasChanges.
  * Fixed major bug with inserted objects treated as updated objects
  * in child display groups.
  *
  * Revision 1.29  2001/03/09 22:10:30  mpowers
  * Fine tuned initializeObject.
  *
  * Revision 1.28  2001/03/06 23:23:55  mpowers
  * objectForGlobalID now returns null if not found.
  * objectsForFetchSpecification again does things the old way, for now.
  *
  * Revision 1.27  2001/03/02 16:31:45  mpowers
  * Trying to better handle fetches from child contexts.
  * No longer trying to invalidate temporary objects.
  *
  * Revision 1.26  2001/02/28 16:25:19  mpowers
  * Now calling globalIDForObject internally.
  *
  * Revision 1.25  2001/02/27 17:36:55  mpowers
  * Objects inserted from child now preserve the existing temporary id.
  *
  * Revision 1.24  2001/02/27 02:11:17  mpowers
  * Now throwing exception when cloning fails.
  * Removed debugging printlns.
  *
  * Revision 1.23  2001/02/26 22:41:51  mpowers
  * Implemented null placeholder classes.
  * Duplicator now uses NSNull.
  * No longer catching base exception class.
  *
  * Revision 1.22  2001/02/26 21:18:45  mpowers
  * Now marking edited objects from child contexts that were not already
  * recorded in parent as changed in saveChangesInEditingContext.
  *
  * Revision 1.21  2001/02/26 15:53:22  mpowers
  * Fine-tuning notification firing.
  * Child display groups now update properly after parent save or invalidate.
  *
  * Revision 1.20  2001/02/24 17:03:22  mpowers
  * Implemented the notification queue, and changed editing context to use it.
  *
  * Revision 1.19  2001/02/23 23:44:15  mpowers
  * Fine-tuning notification handling.
  *
  * Revision 1.18  2001/02/22 22:56:57  mpowers
  * Only refaulting edited objects on parent store invalidateAll.
  *
  * Revision 1.17  2001/02/22 20:54:39  mpowers
  * Implemented notification handling.
  *
  * Revision 1.16  2001/02/21 22:10:55  mpowers
  * Editing context is now posting appropriate notifications.
  *
  * Revision 1.15  2001/02/21 21:17:32  mpowers
  * Now retaining a reference to the recent changes observer.
  * Better documented need to retain reference.
  * Started implementing notifications.
  *
  * Revision 1.14  2001/02/20 17:24:22  mpowers
  * Now using reference keys in objectToID.
  *
  * Revision 1.13  2001/02/20 16:45:36  mpowers
  * Child data sources now accept a data source instead of an editing context
  * for more flexibility.  Child data sources now forward relationship
  * methods to parent source.
  *
  * Revision 1.12  2001/02/16 22:51:29  mpowers
  * Now deep-cloning objects passed between editing contexts.
  *
  * Revision 1.11  2001/02/16 18:34:19  mpowers
  * Implementing nested contexts.
  *
  * Revision 1.9  2001/02/15 21:13:30  mpowers
  * First draft implementation is complete.  Now on to debugging.
  *
  * Revision 1.7  2001/02/13 23:24:29  mpowers
  * Implementing more of editing context.
  *
  * Revision 1.4  2001/02/09 22:09:34  mpowers
  * Completed implementation of EOObjectStore.
  *
  * Revision 1.3  2001/02/06 15:24:11  mpowers
  * Widened parameters on abstract method to fix build.
  *
  * Revision 1.2  2001/02/05 03:45:37  mpowers
  * Starting work on EOEditingContext.
  *
  * Revision 1.1.1.1  2000/12/21 15:46:42  mpowers
  * Contributing wotonomy.
  *
  */