Comp201: Principles of Object-Oriented Programming I
Spring 2008 -- Implementation of Linear Recursive Structure Framework   

1. The Structure

The code for LRStruct follows the state design pattern and is almost trivial.  LRStruc is the invariant part of the system.  It remains the same for all applications using LRStruct.  On the other hand, the different kinds of operations you want to perform on an LRStruct vary from application to application.  They form the variant part of the system.  Their behaviors are abstractly encapsulated in an interface called IAlgo.  This is an example of what we call "behavior abstraction", which is what an OO design should be striving for.  Within this union of all possible algorithms on LRStruct, IAlgo is invariant!  In any system, an abstract class (or interface) should never change.  

package lrs;

/**
 * Mutable linear recursive structure.
 * Visitor Pattern: Serves as a host capable of executing algorithms which are
 * visitors.
 */
public class LRStruct {
    /**
     * The state of of this LRStruct.
     */
    private ANode _head;

    /**
    * Initializes this LRStruct to the empty state.
    */
    public LRStruct() {
	_head = EmptyNode.Singleton;
    }

    /**
     * Returns "()" if empty, otherwise returns the contents of this
     * LRStruct enclosed in parentheses.
     */
    public String toString()  {
        return _head.toString(this);
    }

    /**
     * Inserts dat to the front of this LRStruct.
     * post condition: getFirst() now returns dat.
     * @param dat data to be inserted.
     * @return this LRStruct
     */
    public final LRStruct insertFront(Object dat)	{
	return _head.insertFront(this, dat);
    }

    /**
     * Removes and returns this LRStruct's first.
     */
    public final Object removeFront()	{
	return _head.removeFront(this);
    }

    /**
    * Gets the first data element from this LRStruct
    */
    public final Object getFirst() {
	return _head.getFirst (this);
    }

    /**
     * Sets first data element to a new value.
     * @param dat replaces the existing first for this LRStruct.
     * @throws NoSuchElementException if this LRStruct is empty.
     * @return this LRStruct
     */
    public final LRStruct setFirst(Object dat) {
	return _head.setFirst (this, dat);
    }

    /**
     * Gets the rest of this LRStruct.
     * @throws NoSuchElementException if this LRStruct is empty.
     */
    public final LRStruct getRest() {
	return _head.getRest(this);
    }

    /**
     * Sets a new tail for this LRStruct.
     * post condition: getRest() now returns tail.
     * @throws NoSuchElementException if this LRStruct is empty.
     * @return this LRStruct
     */
    public final LRStruct setRest(LRStruct tail) {
	return _head.setRest(this, tail);
    }

    /**
     * Hook method to execute an algorithm with a given input and return
     * an appropriate output object.
     * @param algo an algorithm (!= null) that operates on this LRStruct.
     * @param inp input object needed by visitor algo.
     * @return output object resulting from the execution of algo.
     */
    public final Object execute(IAlgo algo, Object... inp)	{
        return _head.execute(this, algo, inp);
    }

/* Package access only: */

    /**
     * Initializes this LRStruct with a given head node.
     * @param node != null.
     */
    LRStruct(ANode node)  {
        _head = node;
    }

    /**
     * Changes the head node (i.e. state) of this LRStruct.
     * @param head replaces the existing state of this LRStruct.
     * @return this LRStruct
    */
    final LRStruct setHead (ANode head) {
	 _head = head;
        return this;
    }

    /**
    * Gets the head node (i.e. state) of this LRStruct.
     * @return the head node.
     */
    final ANode getHead () {
        return _head;
    }
}

2. The States

class EmptyNode extends ANode {
/**
* The owner becomes non-empty and 
* has dat as its first element.
*/
LRStruct insertFront(LRStruct owner, Object dat) {
    return owner.setHead(new NENode(dat, new LRStruct(this)));
}

class NENode extends ANode {
    private Object _dat;
    private LRStruct _tail;

/**
* Initializes this NENode to contain dat and a given tail list.
* @param dat the data object to be stored in this NENode.
* @param tail the LRStruct tail of this NENode.
*/
NENode(Object dat, LRStruct tail) {
    _dat = dat;
    _tail = tail;
}

/**
* Inserts a data object at the front of the LRStruct owner.
* @param dat the object to be inserted at the front.
* @param owner the LRS referencing this NENode.
*/
LRStruct insertFront(LRStruct owner, Object dat, ) {
    return owner.setHead(new NENode(dat, new LRStruct(this)));
    /* Details:
    LRStruct coOwner = new LRStruct (this);
    NENode newNode = new NENode (dat, coOwner);
    return owner.setHead (newNode);
    "old" style: owner._head = newNode - cannot be done here.
    */
}


}

class NENode extends ANode {

Object removeFront(LRStruct owner) {
    owner.setHead(_tail.getHead()); // owner._head = _tail._head
    return _dat;
}

// other methods elided...
}