path: root/projects/net.wotonomy.persistence/src/main/java/net/wotonomy/control/KeyValueCodingUtilities.java

/*
Wotonomy: OpenStep design patterns for pure Java applications.
Copyright (C) 2001 Intersect Software Corporation

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.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import net.wotonomy.foundation.NSDictionary;
import net.wotonomy.foundation.NSMutableDictionary;
import net.wotonomy.foundation.internal.Duplicator;
import net.wotonomy.foundation.internal.WotonomyException;

/**
* KeyValueCodingUtilities implements what 
* EOKeyValueCodingSupport leaves out.  Importantly,
* this class implements the deep clone and deep copy 
* operations that are essential to the functioning of 
* nested editing contexts.
*
* @author michael@mpowers.net
* @author $Author: cgruber $
* @version $Revision: 900 $
*/
public class KeyValueCodingUtilities
{
    /**
    * Returns a Map of the specified keys to their values,
    * each of which is obtained by calling valueForKey
    * on the specified object if it implements EOKeyValueCoding,
    * and otherwise falling back on EOKeyValueCodingSupport.
    * Null values must be represented by NSNull.nullValue().
    */
    static public NSDictionary valuesForKeys( 
        Object anObject, List aKeyList )
    {
        return valuesForKeys( anObject, aKeyList, false );
    }
    
    /**
    * Returns a Map of the specified keys to their values,
    * each of which is obtained by calling storedValueForKey
    * on the specified object if it implements EOKeyValueCoding,
    * and otherwise falling back on EOKeyValueCodingSupport.
    * Null values must be represented by NSNull.nullValue().
    */
    static public NSDictionary storedValuesForKeys( 
        Object anObject, List aKeyList )
    {
        return valuesForKeys( anObject, aKeyList, true );
    }
    
    /**
    * Called by valuesForKeys and storedValuesForKeys.
    * This uses storedValueForKey if isStored is true,
    * otherwise uses valueForKey.
    */
    static private NSDictionary valuesForKeys( 
        Object anObject, List aKeyList, boolean isStored )
    {
        EOKeyValueCoding coding;
        if ( anObject instanceof EOKeyValueCoding )
        {
            coding = (EOKeyValueCoding) anObject;
        }
        else
        {
            coding = null;   
        }
        
        String key;
        Object value;
        NSMutableDictionary result = new NSMutableDictionary();
        Iterator it = aKeyList.iterator();
        while ( it.hasNext() )
        {
            //TODO: get rid of this try/catch - exceptions should be fatal (?) 
            try
            {
                key = it.next().toString();            
                if ( coding != null )
                {
                    if ( isStored )
                        value = coding.storedValueForKey( key );
                    else
                        value = coding.valueForKey( key );
                }
                else
                {
                    if ( isStored )
                        value = EOKeyValueCodingSupport.storedValueForKey( anObject, key );
                    else
                        value = EOKeyValueCodingSupport.valueForKey( anObject, key );
                }
                if ( value == null )
                {
                    value = EONullValue.nullValue();   
                }
                result.setObjectForKey( value, key );
            }
            catch ( RuntimeException exc )
            {
                System.out.println( 
                "KeyValueCodingUtilities.valuesForKeys: " 
                + isStored + " : " + exc );   
            }
        }
        return result;
    }
    
    /**
    * Takes the keys from the specified Map as properties
    * and applies the corresponding values, each of which
    * might be set by calling takeValueForKey on the 
    * specified object if it implements EOKeyValueCoding,
    * and otherwise falling back on EOKeyValueCodingSupport.
    * Null values must be represented by NSNull.nullValue().
    */
    static public void takeValuesFromDictionary( 
        Object anObject, Map aMap )
    {
        takeStoredValuesFromDictionary( anObject, aMap, false );
    }

    /**
    * Takes the keys from the specified Map as properties
    * and applies the corresponding values, each of which
    * might be set by calling takeStoredValueForKey on the 
    * specified object if it implements EOKeyValueCoding,
    * and otherwise falling back on EOKeyValueCodingSupport.
    * Null values must be represented by NSNull.nullValue().
    */
    static public void takeStoredValuesFromDictionary( 
        Object anObject, Map aMap )
    {
        takeStoredValuesFromDictionary( anObject, aMap, true );    
    }
    
    /**
    * Called by takeValuesFromDictionary and takeStoredValuesFromDictionary.
    * This uses takeStoredValueForKey if isStored is true,
    * otherwise uses takeValueForKey.
    */
    static private void takeStoredValuesFromDictionary( 
        Object anObject, Map aMap, boolean isStored )
    {
        EOKeyValueCoding coding;
        if ( anObject instanceof EOKeyValueCoding )
        {
            coding = (EOKeyValueCoding) anObject;
        }
        else
        {
            coding = null;   
        }
        
        String key;
        Object value;
        NSMutableDictionary result = new NSMutableDictionary();
        Iterator it = aMap.keySet().iterator();
        while ( it.hasNext() )
        {
            //TODO: get rid of this try/catch - exceptions should be fatal (?) 
            try
            {
                key = it.next().toString();
                value = aMap.get( key );
                if ( value instanceof EONullValue ) 
                // can't use == nullValue() because of cloning/serialization
                {
                    value = null;   
                }
                if ( coding != null )
                {
                    if ( isStored )
                        coding.takeStoredValueForKey( value, key );
                    else
                        coding.takeValueForKey( value, key );
                }
                else
                {
                    if ( isStored )
                        EOKeyValueCodingSupport.takeStoredValueForKey( 
                            anObject, value, key );
                    else
                        EOKeyValueCodingSupport.takeValueForKey( 
                            anObject, value, key );
                }
            }
            catch ( WotonomyException exc )
            {
                System.out.println( 
                    "KeyValueCodingUtilities.takeStoredValuesFromDictionary: " 
                    + isStored + " : " + exc );
            }
        }
    }

    /**
    * Creates a deep clone of the specified object.
    * (Object.clone() only creates a shallow clone.)
    * Returns null if operation fails.
    */ 
    static public Object clone( Object aSource )
    {
        return Duplicator.deepClone( aSource );
    }

    /**
    * Creates a deep clone of the specified object,
    * registered in the specified source editing context,
    * transposing it into the specified destination
    * editing context.
    * Returns null if operation fails.
    */ 
    static public Object clone( 
        EOEditingContext aSourceContext, Object aSource,
        EOEditingContext aDestinationContext )
    {
        return clone( aSourceContext, aSource, aDestinationContext, aSource );    
    }
    
    /**
    * Called by clone and copy.
    * The specified root object will not be replaced
    * by an object in the destination editing context:
    * this should be the same as the source object for
    * cloning, but should be null for copying.
    * Returns null if operation fails.
    */ 
    static private Object clone( 
        EOEditingContext aSourceContext, Object aSource,
        EOEditingContext aDestinationContext,
        Object aRootObject )
    {

//System.out.println();
//System.out.println( "clone: " + aSourceContext );
//System.out.println( "     : " + aSource );
//System.out.println( "     : " + aDestinationContext );
//System.out.println();

        // the only known way to deep copy in
        // java without native code is serialization
        
        return thaw( 
            freeze( aSource, aSourceContext, aRootObject, true ), 
            aDestinationContext, true );
    }
    
    /**
    * Serializes an object to a byte array containing
    * GlobalIDMarkers in place of references to other objects 
    * registered in the specified context.
    * The specified root object will be serialized, 
    * even if it is registered in the specified context:
    * this is typically the root object you're trying to
    * serialize.
    * Package access, as this method is used by editing
    * context for snapshots.
    */
    static public byte[] freeze( 
        Object anObject, EOEditingContext aContext, Object aRootObject, boolean transpose )
    {
        try
        {
//long t = System.currentTimeMillis();            
            ByteArrayOutputStream byteOutput =
                new ByteArrayOutputStream();// CloneBufferSize );
            ObjectOutputStream objectOutput;
            if ( transpose )
            {
                objectOutput =
                    new TransposingContextObjectOutputStream( 
                        byteOutput, aContext, aRootObject );
            }
            else
            {
                objectOutput =
                    new ContextObjectOutputStream( 
                        byteOutput, aContext );
            }
                
            objectOutput.writeObject( anObject );
            objectOutput.flush();
            objectOutput.close();

            return byteOutput.toByteArray();

// profiling
/*
byte[] result = byteOutput.toByteArray();
long size = result.length;
long time = ( System.currentTimeMillis() - t );
maxSize = Math.max( size, maxSize );
minSize = Math.min( size, minSize );
totSize += size;
maxTime = Math.max( time, maxTime );
minTime = Math.min( time, minTime );
totTime += time;
nTime++;
System.out.println( "freeze: size = [ " + size + " : " + minSize + " : " + ( (float)totSize / (float)nTime ) + " : " + maxSize 
+ " ]  time = [ " + time + " : " + minTime + " : " + ( (float)totTime / (float)nTime ) + " : " + maxTime + " ]" );
return result;            
*/
// end profiling

        } 
        catch ( Exception exc )
        {
            throw new WotonomyException( exc );
        }
    }
    
//static long maxTime, minTime, totTime, nTime, maxSize, minSize, totSize;    
//static long maxTimeThaw, minTimeThaw, totTimeThaw, nTimeThaw;

    /**
    * De-serializes an object from the specified byte
    * array, replacing GlobalIDMarkers with reference
    * to objects registered in the specified editing
    * context.
    * Package access, as this method is used by editing
    * context for snapshots.
    */
    static public Object thaw( 
        byte[] aByteArray, EOEditingContext aContext, boolean transpose )
    {
        return thaw( aByteArray, aContext, null, transpose );
    }

    /**
    * De-serializes an object from the specified byte
    * array, replacing GlobalIDMarkers with reference
    * to objects registered in the specified editing
    * context.
    * Package access, as this method is used by editing
    * context for snapshots.
    */
    static public Object thaw( 
        byte[] aByteArray, EOEditingContext aContext, ClassLoader aLoader, boolean transpose )
    {
        try
        {
//long t = System.currentTimeMillis();            
            ByteArrayInputStream byteInput =
                new ByteArrayInputStream( aByteArray );
            ObjectInputStream objectInput;
            if ( transpose )
            {
                objectInput =
                    new TransposingContextObjectInputStream( 
                        byteInput, aContext, aLoader );
            }
            else
            {
                objectInput =
                    new ContextObjectInputStream( 
                        byteInput, aContext, aLoader );
            }
                    
            return objectInput.readObject();
// profiling
/*
Object result = objectInput.readObject();
long timeThaw = ( System.currentTimeMillis() - t );
maxTimeThaw = Math.max( timeThaw, maxTimeThaw );
minTimeThaw = Math.min( timeThaw, minTimeThaw );
totTimeThaw += timeThaw;
nTimeThaw++;
System.out.println( "thaw: size = " + aByteArray.length + ", time = [ " + timeThaw + " : " + minTimeThaw + " : " + ( (float)totTimeThaw / (float)nTimeThaw ) + " : " + maxTimeThaw + " ]" );
return result;
*/
// end profiling
        } 
        catch ( Exception exc )
        {
            throw new WotonomyException( exc );
        }
    }

    /**
    * Copies values from one object registered in the
    * specified origin context to the specified destination
    * object 
    * The values themselves are cloned, so this is a deep copy.
    * Returns the destination object, or throws exception
    * if operation fails.
    */ 
    static public Object copy( Object aSource, Object aDestination )
    {
        NSDictionary values = (NSDictionary) 
            clone( valuesForKeys( aSource, 
                EOClassDescription.classDescriptionForClass( 
                    aSource.getClass() ).attributeKeys() ) );

        takeStoredValuesFromDictionary( aDestination, values );        
        return aDestination;
    }
    
    /**
    * Copies values from one object registered in the
    * specified origin context to the specified destination
    * object 
    * The values themselves are cloned, so this is a deep copy.
    * Returns the destination object, or throws exception
    * if operation fails.
    */ 
    static public Object copy( 
        EOEditingContext aSourceContext, Object aSource, 
        EOEditingContext aDestinationContext, Object aDestination )
    {
        // get all keys for this object
        EOClassDescription classDesc =
            EOClassDescription.classDescriptionForClass( aSource.getClass() );            
        List keys = new LinkedList();
        keys.addAll( classDesc.attributeKeys() ); 
        keys.addAll( classDesc.toOneRelationshipKeys() ); 
        keys.addAll( classDesc.toManyRelationshipKeys() ); 

        // transpose all objects registered in source context
        NSDictionary values = storedValuesForKeys( aSource, keys );
        values = (NSDictionary)
            clone( aSourceContext, values, aDestinationContext, null );
            
        // apply to destination object
        takeStoredValuesFromDictionary( aDestination, values );        
        return aDestination;
    }
    
    // inner classes
    
    /**
    * An ObjectOutputStream that serializes objects with references
    * to an editing context.  The specified context will not be
    * serialized but referenced, so that a ContextObjectInputStream
    * can replace the reference with another editing context.
    */
    static private class ContextObjectOutputStream extends ObjectOutputStream
    {
        private EditingContextMarker marker = new EditingContextMarker();
        protected EOEditingContext editingContext;
        
        /**
        * Specifies the output stream to wrap,
        * and the source context that should be 
        * referenced but not serialized.
        */
        public ContextObjectOutputStream( 
            OutputStream anOutputStream,
            EOEditingContext aContext )
        throws IOException
        {
            super( anOutputStream );
            editingContext = aContext;
            try
            {
                enableReplaceObject(true);
            }
            catch ( Exception exc )
            {
                exc.printStackTrace();   
            }
        }
        
        protected Object replaceObject(Object anObject) throws IOException
        {
//            if ( anObject == editingContext ) return marker;
//FIXME: this should be more strict as above
            if ( anObject instanceof EOEditingContext ) return marker;
            return anObject;
        }

    }
    
    /**
    * A ContextObjectOutputStream that replaces any objects registered
    * in the source editing context with markers to be used in
    * ContextObjectInputStream.
    */
    static private class TransposingContextObjectOutputStream 
        extends ContextObjectOutputStream
    {
        protected Object rootObject;
        
        /**
        * Specifies the output stream to wrap,
        * the source context containing objects that
        * should be replaced if found, 
        * and the object which should not be re-registered,
        * which is typically the object being cloned, but
        * may be null.
        */
        public TransposingContextObjectOutputStream( 
            OutputStream anOutputStream,
            EOEditingContext aContext, 
            Object anObject )
        throws IOException
        {
            super( anOutputStream, aContext );
            rootObject = anObject;
        }
        
        protected Object replaceObject(Object anObject) throws IOException
        {
            if ( anObject == rootObject ) return anObject;
            if ( editingContext != null )
            {
                EOGlobalID id = editingContext.globalIDForObject( anObject );
                if ( id != null ) 
                {
                    Object result = new GlobalIDMarker( id );
    //System.out.println( "KeyValueCodingUtilities.replaceObject: returning: " + result );
                    return result;
                }
            }
            return super.replaceObject( anObject );
        }

    }
    
    /**
    * A marker class so references to objects registered in editing 
    * contexts get transposed rather than cloned.
    */
    static private class GlobalIDMarker implements Serializable
    {
        private EOGlobalID id;
        
        public GlobalIDMarker( EOGlobalID anID )
        {
            id = anID;   
        }
        
        public EOGlobalID getID() 
        {
            return id;   
        }
        
        public String toString()
        {
            return "[GlobalIDMarker:"+id+"]";   
        }
    }
    
    /**
    * A marker class so references an object's editing context
    * gets transposed rather than cloned.
    */
    static private class EditingContextMarker implements Serializable
    {
        // just a marker class - no implementation necessary
    }
    
    /**
    * An ObjectInputStream that replaces any markers from
    * ContextObjectOutputStream with objects registered
    * in the destination editing context.
    */
    static private class ContextObjectInputStream extends ObjectInputStream
    {
        protected EOEditingContext editingContext;
        protected ClassLoader classLoader;
        
        /**
        * Specifies the output stream to wrap,
        * the source context containing objects that
        * should be to replace any markers.
        * The class loader may be null.
        */
        public ContextObjectInputStream( 
            InputStream anInputStream,
            EOEditingContext aContext,
            ClassLoader aClassLoader )
        throws IOException
        {
            super( anInputStream );
            editingContext = aContext;
            classLoader = aClassLoader;
            if ( classLoader == null )
            {
                classLoader = 
                    KeyValueCodingUtilities.class.getClassLoader();
            }
            try
            {
                enableResolveObject(true);
            }
            catch ( Exception exc )
            {
                exc.printStackTrace();   
            }
        }
        
        protected Object resolveObject(Object anObject) throws IOException
        {
            if ( anObject instanceof EditingContextMarker )
            {
                return editingContext;
            }
            return anObject;
        }
        
        protected Class resolveClass(ObjectStreamClass v)
             throws IOException, ClassNotFoundException 
        {
            return classLoader.loadClass( v.getName() );
        }
    }
    
    /**
    * A ContextObjectInputStream that replaces any markers from
    * TransposingContextObjectOutputStream with objects registered
    * in the destination editing context.
    */
    static private class TransposingContextObjectInputStream 
        extends ContextObjectInputStream
    {
        /**
        * Specifies the output stream to wrap,
        * the source context containing objects that
        * should be to replace any markers.
        */
        public TransposingContextObjectInputStream( 
            InputStream anInputStream,
            EOEditingContext aContext,
            ClassLoader aClassLoader )
        throws IOException
        {
            super( anInputStream, aContext, aClassLoader );
        }
        
        protected Object resolveObject(Object anObject) throws IOException
        {
            if ( anObject instanceof GlobalIDMarker )
            {
                return editingContext.faultForGlobalID( 
                    ((GlobalIDMarker)anObject).getID(), editingContext );
            }
            return super.resolveObject( anObject );
        }
    }
    
}

/*
 * $Log$
 * Revision 1.3  2006/02/18 22:46:44  cgruber
 * Add Surrogate map from .util into control's internal package, and fix imports.
 *
 * 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.15  2003/01/21 22:30:10  mpowers
 * thaw() now allows you to pass in a class loader.
 *
 * Revision 1.14  2002/05/15 13:46:35  mpowers
 * Exposed freeze and thaw as public.
 *
 * Revision 1.13  2001/08/22 19:25:13  mpowers
 * Added (and commented out) profiling code for freeze.
 *
 * Revision 1.12  2001/05/06 18:27:10  mpowers
 * More broadly catching editing contexts for now.
 *
 * Revision 1.11  2001/05/05 13:18:49  mpowers
 * Fixed: transposing output stream was not returning the object to replace.
 *
 * Revision 1.10  2001/05/04 16:57:56  mpowers
 * Now correctly transposing references to editing contexts when
 * cloning/copying between editing contexts.
 *
 * Revision 1.9  2001/05/04 14:42:58  mpowers
 * Now getting stored values in KeyValueCoding.
 * MasterDetail now marks dirty based on whether it's an attribute
 * or relation.
 * Implemented editing context marker.
 *
 * Revision 1.8  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.7  2001/04/30 12:33:17  mpowers
 * Fixed problem with use of EONullValue.nullValue(), which can't be used
 * when we're serializably duplicating objects.
 *
 * Revision 1.6  2001/04/30 02:14:25  mpowers
 * Copying should call takeStoredValueForKeys.
 *
 * Revision 1.5  2001/04/29 22:02:45  mpowers
 * Work on id transposing between editing contexts.
 *
 * Revision 1.4  2001/04/29 02:29:31  mpowers
 * Debugging relationship faulting.
 *
 * Revision 1.3  2001/04/28 16:18:44  mpowers
 * Implementing relationships.
 *
 * Revision 1.2  2001/04/28 14:12:23  mpowers
 * Refactored cloning/copying into KeyValueCodingUtilities.
 *
 * Revision 1.1  2001/04/27 23:41:12  mpowers
 * Contributing file for KeyValueCodingUtilities.
 *
 *
 */