package genRac;

import genListFW.*;
import genListFW.factory.*;
import genLRS.*;

/**
 * Implements a factory for restricted access containers.  These
 * restricted access containers are implemented using an LRStruct to
 * hold the data objects.
 */
public abstract class ALRSRACFactory<T> implements IRACFactory<T> {
    /**
     * Implements a general-purpose restricted access container using
     * an LRStruct.  How? 
     *
     * The next item to remove is always at the front of the list of
     * contained objects.  This is invariant!
     *
     * Insertion is, however, delegated to a strategy routine; and
     * this strategy is provided to the container.  This strategy
     * varies to implement the desired kind of container, e.g., queue
     * vs. stack.
     *
     * This inner class is protected so that classes derived from its
     * factory can reuse it to create other kinds of restricted access
     * container. 
     */
    protected static class LRSRAContainer<T> implements IRAContainer<T> {
        private IAlgo<T, ? extends Object, T> _insertStrategy;
        private LRStruct<T> _genLRS;
        
        // anonymous inner class to check for emptiness!
        private IAlgo<Object, Boolean, Object> _checkEmpty = new IAlgo<Object, Boolean, Object>() {
            
            public Boolean emptyCase(LRStruct<? extends Object> host, Object... input) {
                return Boolean.TRUE;
            }    
            
            public Boolean nonEmptyCase(LRStruct<? extends Object> host, Object... input) {
                return Boolean.FALSE;
            }        
        };
        
        public LRSRAContainer(IAlgo<T, ? extends Object, T> strategy) {
            _insertStrategy = strategy;
            _genLRS = new LRStruct<T>();
        }
        
        /**
         * Empty the container.
         */
        public void clear() {
            _genLRS = new LRStruct<T>();
        }  
        
        /**
         * Return TRUE if the container is empty; otherwise, return
         * FALSE.
         */
        public boolean isEmpty() {
            return _genLRS.execute(_checkEmpty);
        }
        
        /**
         * Return TRUE if the container is full; otherwise, return
         * FALSE. 
         *
         * This implementation can hold an arbitrary number of
         * objects.  Thus, always return false.
         */
        public boolean isFull() {
            return false;
        }
        
        /**
         * Return an immutable list of all elements in the container.
         */
        public IList<T> elements(final IListFactory<T> fact) {
            
            return _genLRS.execute (new IAlgo<T, IList<T>, Object>() {
                
                public IList<T> emptyCase(LRStruct<? extends T> host, Object... nu) {
                    return fact.makeEmptyList();
                }
                
                public IList<T> nonEmptyCase(LRStruct<? extends T> host, Object... nu) {
                    return fact.makeNEList(host.getFirst(),
                                           host.getRest().execute(this));
                }
            });
        }  
        
        /**
         * Remove the next item from the container and return it.
         */
        public T get() {
            return _genLRS.removeFront();
        }        
        
        /**
         * Add an item to the container.
         */
        public void put(T input) {
            _genLRS.execute(_insertStrategy, input);
        }        
        
        public T peek() {
            return _genLRS.getFirst();
        }
    }    
}