Re: Filtered to many relationship

Pierre Bernard Fri, 02 May 2008 00:22:57 -0700

The brave may experiment with this:

public class GenericRecord extends EOGenericRecord
{
        // Relationship filtering


        public void clearFilteredRelationships()
        {

Enumeration filteredRelationshipKeys = _filteredRelationshipKeys().objectEnumerator();


                willRead();

                while (filteredRelationshipKeys.hasMoreElements())
                {
                        String key = (String) 
filteredRelationshipKeys.nextElement();

                        _clearFilteredRelationship(key);
                }
        }

/** Returns the list of keys to potentially filtered toMany relationships

         *
         * @return NSArray of String relationship keys
         */
        protected NSArray _filteredRelationshipKeys()
        {
                return NSArray.EmptyArray;
        }

        protected void _clearFilteredRelationship(String key)
        {
                FilteredMutableArray filteredArray = _filteredArrayForKey(key);

filteredArray .turnIntoFault (FilteringArrayFaultHandler.faultHandler(editingContext()));

        }

        /** Filtering
         * @return _filteredArrayForKey
         */
        protected FilteredMutableArray _filteredArrayForKey(String key)
        {
                FilteredMutableArray array =
                        (FilteredMutableArray) 
_filteredArrayRepository().valueForKey(key);

                if (array == null)
                {
                        synchronized (this)
                        {
                                if (array == null)
                                {
                                        array = new FilteredMutableArray(this, 
key);
                                        
_filteredArrayRepository().setObjectForKey(array, key);
                                }
                        }
                }

                return array;
        }

        /** Filtering
         * @return _filteredArrayRepository
         */
        private NSMutableDictionary _filteredArrayRepository()
        {
                if (_filteredArrayRepository == null)
                {
                        _filteredArrayRepository = new NSMutableDictionary();
                }

                return _filteredArrayRepository;
        }
}

public class SomeEO extends GenericRecord
{
        public NSArray someToManyKey()
        {
                EOEditingContext editingContext = editingContext();
                
                if ((editingContext instanceof FilteringEditingContext)
                        && (! ((FilteringEditingContext) 
editingContext).saveInProgress()))
                {
                        _clearFilteredRelationship(SOME_TO_MANY_KEY);

                        return _filteredArrayForKey(SOME_TO_MANY_KEY);
                }
                else
                {
                        return (NSArray) storedValueForKey(SOME_TO_MANY_KEY);
                }
        }
}

/** Mutable array used by the Map objects for representing filtered toMany relationships

 *
 * @author bernard
 */
public class FilteredMutableArray extends _EOCheapCopyMutableArray
{
        // Priovate instance variables
        
        private String key;
        private EOEnterpriseObject owner;

        // Constructor
        
        public FilteredMutableArray(EOEnterpriseObject owner, String key)
        {
                this.owner = owner;
                this.key = key;
        }
        
        // Public instance methods
        
        public void addObject(Object object)
        {
                NSArray storedArray = storedArray();
                
                if (storedArray instanceof NSMutableArray)
                {
                        ((NSMutableArray) storedArray).addObject(object);
                }
                
                super.addObject(object);
        }

        public void addObjects(Object[] objects)
        {
                NSArray storedArray = storedArray();
                
                if (storedArray instanceof NSMutableArray)
                {
                        ((NSMutableArray) storedArray).addObjects(objects);
                }
                
                super.addObjects(objects);
        }

        public void removeAllObjects()
        {
                NSArray storedArray = storedArray();
                
                if (storedArray instanceof NSMutableArray)
                {
                        NSMutableArray mutableArray = (NSMutableArray) 
storedArray;
                        Enumeration objects = objectEnumerator();
                        
                        while (objects.hasMoreElements())
                        {
                                
mutableArray.removeIdenticalObject(objects.nextElement());
                        }
                }
                
                super.removeAllObjects();
        }

        public Object removeObjectAtIndex(int index)
        {
                NSArray storedArray = storedArray();
                
                if (storedArray instanceof NSMutableArray)
                {
                        Object object = objectAtIndex(index);
                        
                        ((NSMutableArray) 
storedArray).removeIdenticalObject(object);
                }
                
                return super.removeObjectAtIndex(index);
        }

        public Object replaceObjectAtIndex(Object object, int index)
        {
                NSArray storedArray = storedArray();
                
                if (storedArray instanceof NSMutableArray)
                {
                        NSMutableArray mutableArray = (NSMutableArray) 
storedArray;
                        Object oldObject = objectAtIndex(index);
                        
                        mutableArray.removeIdenticalObject(oldObject);
                        mutableArray.addObject(object);
                }

                return super.replaceObjectAtIndex(object, index);
        }