package rac;

import listFW.*;
/**
 * Defines the interface for a restricted access container.
 */
public interface IRAContainer {
    /**
     * Empty the container.
     * NOTE: This implies a state change.
     * This behavior can be achieved by repeatedly removing elements from this IRAContainer.
     * It is specified here as a convenience to the client.
     */
    public void clear();
    /**
     * Return TRUE if the container is empty; otherwise, return
     * FALSE. 
     */
    public boolean isEmpty();
    /**
     * Return TRUE if the container is full; otherwise, return
     * FALSE. 
     */
    public boolean isFull();
    /**
     * Return an immutable list of all elements in the container.
     * @param fact for manufacturing an IList.
     */
    public IList elements(IListFactory fact);
    /**
     * Remove the next item from the container and return it.
     * NOTE: This implies a state change.
     * @throw an Exception if this IRAContainer is empty.
     */
    public Object get();
    /**
     * Add an item to the container.
     * NOTE: This implies a state change.
     * @param input the Object to be added to this IRAContainer.
     * @throw an Exception if this IRAContainer is full.
     */
    public void put(Object input);
    /**
     * Return the next element in this IRAContainer withour removing it.
     * @throw an Exception if this IRAContainer is empty.
     */
    public Object peek();
}

package rac;

/**
 * Abstract Factory to manufacture RACs.
 */
public interface IRACFactory {
    /**
     * Returns an empty IRAContainer.
     */
    public IRAContainer makeRAC();
}
 

package rac;

import listFW.*;
import listFW.factory.*;
import lrs.*;

/**
 * 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 implements IRACFactory {
    /**
     * 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 nested static 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 implements IRAContainer {
        private IAlgo _insertStrategy;
        private LRStruct _lrs;

        public LRSRAContainer(IAlgo strategy) {
            _insertStrategy = strategy;
            _lrs = new LRStruct();
        }

        /**
         * Empty the container.
         */
        public void clear() {
            _lrs = new LRStruct();
        }
        
        /**
         * Return TRUE if the container is empty; otherwise, return
         * FALSE.
         */
        public boolean isEmpty() {
            return (Boolean)_lrs.execute(CheckEmpty.Singleton);
        }

        /**
         * 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 elements(final IListFactory fact) {
            return (IList)_lrs.execute(new IAlgo() {               
                public Object emptyCase(LRStruct host, Object... nu) {
                    return fact.makeEmptyList();
                }

                public Object nonEmptyCase(LRStruct host, Object... nu) {
                    return fact.makeNEList(host.getFirst(),
                                           (IList)host.getRest().execute(this));
                }
            });
        }

        /**
         * Remove the next item from the container and return it.
         */
        public Object get() {
            return _lrs.removeFront();
        }

        /**
         * Add an item to the container.
         */
        public void put(Object input) {
            _lrs.execute(_insertStrategy, input);
        }

        public Object peek() {
            return _lrs.getFirst();
        }
    }    
}

/**
 * Package private class used by ALRSRACFactory to check for emptiness of its internal LRStruct.
 */
class CheckEmpty implements IAlgo {
    public static final CheckEmpty Singleton= new CheckEmpty();
    private CheckEmpty() {
    }

    public Object emptyCase(LRStruct host, Object... input) {
        return Boolean.TRUE;
    }

    public Object nonEmptyCase(LRStruct host, Object... input) {
        return Boolean.FALSE;
    }
}

package rac;

import lrs.*;

public class LRSStackFactory extends ALRSRACFactory {
    /**
     * Create a ``last-in, first-out'' (LIFO) container.
     */
    public IRAContainer makeRAC() {
        return new LRSRAContainer(new IAlgo() {
            public Object emptyCase(LRStruct host, Object... input) {
                return host.insertFront(input[0]);
            }

            public Object nonEmptyCase(LRStruct host, Object... input) {
                return host.insertFront(input[0]);
            }
        });
    }
}

package rac;

import lrs.*;

public class LRSQueueFactory extends ALRSRACFactory {
    /**
     * Create a ``first-in, first-out'' (FIFO) container.
     */
    public IRAContainer makeRAC() {
        return new LRSRAContainer(new IAlgo() {
            public Object emptyCase(LRStruct host, Object... input) {
                return host.insertFront(input[0]);
            }

            public Object nonEmptyCase(LRStruct host, Object... input) {
                return host.getRest().execute(this, input);
            }
        });
    }    
}

package rac;

import lrs.*;

/*
 * Implements a factory for restricted access containers, including a
 * container that returns a random item.
 */
public class RandomRACFactory extends ALRSRACFactory {
    /**
     * Create a container that returns a random item.
     */
    public IRAContainer makeRAC() {
        return new LRSRAContainer(new IAlgo() {
            public Object emptyCase(LRStruct host, Object... input) {
                return host.insertFront(input[0]);
            }

            public Object nonEmptyCase(LRStruct host, Object input) {
                /*
                 * Math.Random returns a value between 0.0 and 1.0.
                 */
                if (0.5 > Math.random())
                    return host.insertFront(input[0]);
                else
                    return host.getRest().execute(this, input);
            }
        });
    }
}