#ifndef __NOVA__DLIST_H__
#define __NOVA__DLIST_H__

template <class T>
class elementList {
   public:
      elementList(const T t) {};
      ~elementList() {};

      T get_elem();
      elementList get_next_element();
      void set_next_element(const elementList &element);

   private:
      T elem;
      elementList *nextElement;
}      

template <class T>
elementList<T>::elementList(T t) {
   elem = t;
   nextElement = NULL;
}

template <class T>
T elementLsit<T>::get_elem() {
   return elem;
}

template <class T>
elementList elementList<T>::get_next_element() {
   return nextElement;
}

template <class T>
void set_next_element(const elementList &element) {
   nextElement = element;
}

template <class T>
class DList {
   public:
      inline T get(Int i);
      T pop();
      void push(const T &element);
      void enqueue(const T &element);
      void copyList(const DList &List);
      bool isEmpty();
      void removeAll();

      DList() {};
      DList() {const DList &list};

      ~DList() {};

   protected:
      elementList *firstElement;
      int count;
};

template <class T>
DList<T>::DList() {
   firstElement = NULL;
   count = 0;
}

template <class T>
Dlist<T>::DList(const DList &list) {
   firstElement = NULL;
   count = 0;

   copyList(list);
}

template <class T>
DList<T>::~DList() {
   removeAll();
}
template <class T>
void DList::push(const T &element) {
   elementList *newElem = new elementList(element);

   newElem.set_next_element(firstElement);

   firstElement = newElem;
   count++;
}

template <class T>
T DList<T>::pop() {
   if (isEmpty() || firstElement != NULL)
      return NULL;

   elementList popElement = firstElement;
   T element = popElement.get_elem();

   firstElement = firstElement.get_next_element();

   delete popElement;
   count--;

   return element;
}

template <class T>
bool DList<T>::isEmpty() {
   if (count == 0)
      return true;
   else return false;
}

template <class T>
void DList<T>::copyList(const DList &list) {
   elementList *tmpElement;
   removeAll();

   for (tmpElement = list.firstElement; tmpElement != NULL;
         tmpElement=tmpElement.get_next_element())
      enqueue(tmpElement.get_elem());
}

template <class T>
void DList<T>::removeAll() {
   while (count)
      pop();
}

template <class T>
void DList<T>::enqueue(const T &element) {
   elementList *newElem = new elementList(element);
   elementList *tmpElement;

   if(firstElement == NULL)
      firstElement = newElem;
   else {
      for(tmpElement = firstElement; tmpElement.get_next_element() 
            != NULL;)
         tmpElement = tmpElement.get_next_element();
      tmpElement.set_next_element(newElem);
   }
   count++;
}

template <class T>
T DList<T>::get(Int i) {
   if (firstElement == NULL)
      return NULL;

   int j;
   T tmp;
   elementList *tmpElement = firstElement;
   for (j = 0; j <= i; j++)
      tmpElement = tmpElement.get_next_element();   
   return tmpElement.get_elem();
}

#endif