// List.hpp : Doubly linked list template (single internal iterator)
//
// 08.09.1998 / DH - First release
//
// Copyright (c) 1998 Daniel Hartmeier. All rights reserved.

#ifndef __List__
#define __List__

// -------------------------------------------------------------------

template<class T>
class List
  {
    public:
      List();
      virtual ~List();
      virtual void Append(T *element); // Append an element at the end of the list (leaving focus unchanged)
      virtual void Insert(T *element); // Insert an element before the actual element (focus unchanged)
      virtual T *Remove();             // Remove the element in focus (focus to the next element, or to the previous if at the end of the list)
      virtual T *Actual();
      virtual T *First();
      virtual T *Next();
      virtual T *Previous();
      virtual T *Last();
      virtual T *Set(T *element);      // Set focus to the supplied element (if found), return focussed element (possibly unchanged)
    protected:
    private:
      struct structure
        {
          T         *element;
          structure *previous, *next;
        };
      structure *first, *last, *actual;
  };

// -------------------------------------------------------------------

template<class T>
List<T>::List()
  {
    first = new structure;
    first->element  = 0;
    first->previous = first;
    first->next     = first;
    last   = first;
    actual = first;
  }

template<class T>
List<T>::~List()
  {
    actual = last;
    while (actual != first)
      {
        last = actual;
        actual = actual->previous;
        delete last; last = 0;
      }
    actual = 0;
    delete first; first = 0;
  }

template<class T>
void List<T>::Append(T *element)
  {
    last->next = new structure;
    last->next->element  = element;
    last->next->previous = last;
    last->next->next     = first;
    last = last->next;
    return;
  }

template<class T>
void List<T>::Insert(T *element)
  {
    structure* s = new structure;
    s->element  = element;
    s->previous = actual->previous;
    s->next     = actual;
    actual->previous->next = s;
    actual->previous       = s;
    return;
  }

template<class T>
T *List<T>::Remove()
  {
    if (actual == first) return 0;
    actual->previous->next = actual->next;
    actual->next->previous = actual->previous;
    structure* old = actual;
    if (actual == last) { actual = actual->previous; last = actual->next; }
    else                { actual = actual->next; }
    delete old;
    return actual->element;
  }

template<class T>
T *List<T>::Actual() { return actual->element; }

template<class T>
T *List<T>::First() { actual = first->next; return actual->element; }

template<class T>
T *List<T>::Last() { actual = last; return actual->element; }

template<class T>
T *List<T>::Next()
  {
    if (actual == last) return 0;
    actual = actual->next;
    return actual->element;
  }

template<class T>
T *List<T>::Previous()
  {
    if (actual == first) return 0;
    actual = actual->previous;
    return actual->element;
  }

template<class T>
T *List<T>::Set(T *element)
  {
    structure* s = first->next;
    while ((s->element != element) && (s != first)) s = s->next;
    if (s->element == element) actual = s;
    return actual->element;
  }

// -------------------------------------------------------------------

#endif