package linear;


/**
 * <p>Materialien zu den zentralen
 * Abiturpruefungen im Fach Informatik ab 2012 in
 * Nordrhein-Westfalen.</p>
 * <p>Klasse List</p>
 * <p>Objekte der Klasse List verwalten beliebig viele,
 * linear angeordnete Objekte. Auf hoechstens ein Listenobjekt,
 * aktuelles Objekt genannt, kann jeweils zugegriffen werden.
 * Wenn eine Liste leer ist, vollstaendig durchlaufen wurde oder
 * das aktuelle Objekt am Ende der Liste geloescht wurde, gibt es
 * kein aktuelles Objekt. Das erste oder das letzte Objekt einer
 * Liste koennen durch einen Auftrag zum aktuellen Objekt gemacht werden.
 * Außerdem kann das dem aktuellen Objekt folgende Listenobjekt
 * zum neuen aktuellen Objekt werden. Das aktuelle Objekt kann gelesen,
 * veraendert oder geloescht werden. Ausserdem kann vor dem aktuellen
 * Objekt ein Listenobjekt eingefügt werden.
</p>
 *
 * <p>NW-Arbeitsgruppe: Materialentwicklung zum Zentralabitur
 * im Fach Informatik</p>
 *
 * @version 2011-01-05
 */

public class List
{
	public Node first;
	private Node last;
	private Node current;

    /**
     * Eine leere Liste wird erzeugt.
     */
    public List() {
        first = null;
        last = null;
        current = null;
    }

    /**
     * Die Anfrage liefert den Wert true, wenn die Liste
     * keine Objekte enthaelt, sonst liefert sie den Wert false.
     * @return true, wenn die Liste leer ist, sonst false
     */
    public boolean isEmpty() {
        return first == null;
    }

    /**
     * Die Anfrage liefert den Wert true, wenn es ein
     * aktuelles Objekt gibt, sonst
     * liefert sie den Wert false.
     * @return true, falls Zugriff moeglich, sonst false
     */
    public boolean hasAccess() {
        return current != null;
    }

    /**
     * Falls die Liste nicht leer ist, es ein aktuelles
     * Objekt gibt und dieses nicht das letzte Objekt der
     * Liste ist, wird das dem aktuellen Objekt in der Liste
     * folgende Objekt zum aktuellen Objekt, andernfalls gibt
     * es nach Ausführung des Auftrags kein aktuelles Objekt,
     * d.h. hasAccess() liefert den Wert false.
     */
    public void next() {
        if (current != null)
        {
            current = current.getNext();
        }
    }

    /**
     * Falls die Liste nicht leer ist, wird das erste
     * Objekt der Liste aktuelles Objekt.
     * Ist die Liste leer, geschieht nichts.
     */
    public void toFirst() {
    	current = first;
    }

    /**
     * Falls die Liste nicht leer ist, wird das
     * letzte Objekt der Liste aktuelles Objekt.
     * Ist die Liste leer, geschieht nichts.
     */
    public void toLast() {
    	current = last;
    }

    /**
     * Falls es ein aktuelles Objekt gibt
     * (hasAccess() == true), wird das aktuelle Objekt
     * zurueckgegeben, andernfalls (hasAccess()== false)
     * gibt die Anfrage den Wert null zurueck.
     * @return Inhaltsobjekt
     */
    public Object getObject() {
        if (current != null)
            return current.getValue();
        else
            return null;
    }

    /**
     * Falls es ein aktuelles Objekt gibt (hasAccess() == true)
     * und pObject ungleich null ist, wird das aktuelle Objekt
     * durch pObject ersetzt. Sonst bleibt die Liste unveraendert.
     * @param pObject Inhaltsobjekt
     */
    public void setObject(Object pObject) {
        if (pObject != null && (current != null))
            current.setValue(pObject);
    }

    /**
     * Ein neues Objekt pObject wird am Ende der Liste eingefuegt.
     * Das aktuelle Objekt bleibt unveraendert. Wenn die Liste
     * leer ist, wird das Objekt pObject in die Liste eingefuegt
     * und es gibt weiterhin kein aktuelles Objekt
     * (hasAccess() == false). Falls pObject gleich null ist,
     * bleibt die Liste unveraendert.
     *@param pObject Inhaltsobject
     */
    public void append(Object pObject) {
    	if(pObject == null){
    		return;
    	}
        Node newNode = new Node(pObject);
    	if(first == null){
    		first = newNode;
    		last = newNode;
    		return;
    	}
        last.setNext(newNode);
        newNode.setPrevious(last);
        last = newNode;
    }

    /**
     *Falls es ein aktuelles Objekt gibt (hasAccess() == true),
     *wird ein neues Objekt vor dem aktuellen Objekt in die
     *Liste eingefuegt. Das aktuelle Objekt bleibt unveraendert.
     *Wenn die Liste leer ist, wird pObject in die Liste eingefuegt
     *und es gibt weiterhin kein aktuelles Objekt
     *(hasAccess() == false). Falls es kein aktuelles Objekt gibt
     *(hasAccess() == false) und die Liste nicht leer ist oder
     *pObject gleich null ist, bleibt die Liste unveraendert.
     *@param pObject Inhaltsobjekt
     */
    public void insert(Object pObject) {
    	if(pObject == null){
    		return;
    	}
    	Node newNode = new Node(pObject);
    	if(first == null){
    		first = newNode;
    		last = newNode;
    		return;
    	}
    	if(current == null){
    		return;
    	}
    	Node previous = current.getPrevious();
    	if(previous != null)
    		previous.setNext(newNode);
    	else
    		first = newNode;
    	newNode.setPrevious(previous);
    	newNode.setNext(current);
    	current.setPrevious(newNode);
    }

    /**
     * Die Liste pList wird an die Liste angehaengt. Anschliessend
     * wird pList eine leere Liste. Das aktuelle Objekt bleibt unveraendert.
     * Falls pList null oder eine leere Liste ist, bleibt die Liste
     * unveraendert.
     * @param pList Liste
     */
    public void concat(List pList) {
    	if(pList == null || pList.first == null){
    		return;
    	}
    	if(this.first == null){
            first = pList.first;
            last = pList.last;
            current = null;
        }
        else {
            this.last.setNext(pList.first);
            pList.first.setPrevious(this.last);
            this.last = pList.last;
        }
    	pList.first = null;
    	pList.last = null;
    	pList.current = null;
    }

    /**
     * Falls es ein aktuelles Objekt gibt (hasAccess() == true),
     * wird das aktuelle Objekt geloescht und das Objekt hinter
     * dem gelaeschten Objekt wird zum aktuellen Objekt. Wird das
     * Objekt, das am Ende der Liste steht, geloescht, gibt es kein
     * aktuelles Objekt mehr (hasAccess() == false). Wenn die Liste
     * leer ist oder es kein aktuelles Objekt gibt (hasAccess() == false),
     * bleibt die Liste unveraendert.
     */
    public void remove() {
    	if(first != null && current != null){
    		Node previous = current.getPrevious();
    		Node next = current.getNext();
    		if(current == first){
    			first = next;
    		}
    		else{
    			previous.setNext(next);
    		}
    		if(current == last){
    			last = previous;
    		}
    		else{
    			next.setPrevious(previous);
    		}
    		current = next;
    	}
    }

    /**
     * NUR ZU DARSTELLUNGSZWECKEN!!!
     * KEINE OFFIZIELLE METHODE DES ZENTRALABITURS!!!
     * @return
     */
	public Node getCurrentNode() {
		return this.current;
	}

    /**
     * NUR ZU DARSTELLUNGSZWECKEN!!!
     * KEINE OFFIZIELLE METHODE DES ZENTRALABITURS!!!
     * @return
     */
	public Node getFirstNode(){
		return this.first;
	}

    /**
     * NUR ZU DARSTELLUNGSZWECKEN!!!
     * KEINE OFFIZIELLE METHODE DES ZENTRALABITURS!!!
     * @return
     */
	public Node getTailNode(){
		return this.last;
	}


}