/** SimpleList Class * Author: David D. Riley * Date: June, 2004 * *	class invariant *		A SimpleList object... *			* is a container of zero or more other objects arranged in a linear order *			* maintains an iterator that conceptually is positioned   *				either in front of the first item, behind the  *				last item or between two consecutive list items.   *				(The iterator can be thought of as an integer that  *				counts the number of items preceding its position.)  */public class SimpleList <E> extends java.util.AbstractCollection<E> implements java.util.Iterator<E>{	protected class ListCell<E> {		private E content;		public ListCell<E> next;			public ListCell(E e) {			content = e;			next = null;		}	}	private ListCell<E> anchor;	private ListCell<E> prevCell, preprevCell;	private int privateCount;	/**	post:   this is empty (i.e. size() == 0)     *          and iterator == 0  (i.e. the iterator has zero items before it)     *          and preprevvCell == null	     */	public SimpleList()  {        super();		anchor = new ListCell<E>(null);		prevCell = anchor;        reset();	}  	/**	post:   iterator == 0  (i.e. positioned before all items in the list)     *          and  preprevCell== null      */	public void reset() {        preprevCell = null;		prevCell = anchor;	} 	/**	post:   hasNext()  implies     *              (iterator == iterator@pre + 1       *              and result == item immediately following iterator@pre     *              and preprevCell is positioned at iterator@pre)     *          and not hasNext() implies NoSuchElementException is thrown      */	public E next()  {		if (hasNext())  {            preprevCell = prevCell;			prevCell = prevCell.next;            return prevCell.content;        } else            throw new java.util.NoSuchElementException("The iterator is positioned off the list when next() is called.");	}  	/** post:   result == ( iterator != size() )        *              (i.e. result is false exactly when iterator is      *              positioned at the rear of this list)       */	public boolean hasNext()  {		return (prevCell.next != null);	} 	/**	post:   this == this@pre with e inserted at the iterator@pre position      *          and  size() = size()@pre + 1     *          and  iterator == iterator@pre + 1     *          and  preprevCell == null        */	public boolean add(E e)  {		ListCell<E> newCell = new ListCell<E>(e);		newCell.next = prevCell.next;		prevCell.next = newCell;        preprevCell = null;        prevCell = prevCell.next;		privateCount++;        return true;	} 	/**	post:   (prepevCell@pre != null)  implies     *              (this == this@pre with the item preceding iterator@pre removed       *              and  size() == size()@pre - 1     *              and iterator == iterator@pre - 1     *              and preprevCell == null)      *              and  (preprevcell@pre==null) implies an IllegalStateException is thrown      */	public void remove()  {		if (preprevCell != null)  {			preprevCell.next = preprevCell.next.next;			privateCount--;			prevCell = preprevCell;			            preprevCell = null;		}  else             throw new IllegalStateException("The remove operation is legal only immediately after an item() call.");	} 	/**	post:   result == the number of items in this list */	public int size()  {		return privateCount;	}	/**	post:   result == this     *          and  iterator == 0  (i.e. positioned before all items in the list)     *  note:   This method is required to properly extend AbstractCollection     *          and in turn to make the shortened form of the for statement work.     */	public java.util.Iterator<E> iterator()  {        reset();		return this;	}}