/* teht8_3.cpp M 2.30.3 */
/*
         3) Peri tehtävän 2 listasta 2-suuntainen lista.
            Onnistuuko kunnolla? Ei ilman templatea!
*/

#include <iostream.h>

template <class TYPE>
class elem {
public:
  TYPE data;
  elem *next_elem;
  virtual int add(elem *n) { next_elem = n; return 0; }
  elem(TYPE &d)    { data = d; next_elem = NULL; }
};


template <class TYPE,class ELEM>
class base_list {
protected:
  ELEM *first_elem;
  ELEM *last_elem;
  elem<TYPE> *cursor;          // Sijainti listassa
  TYPE out_data;
  int no_elem()    { cursor = first_elem = last_elem = NULL;
                     out_data = 0; return 0;                                 }
public:
  int delete_all();
  base_list()      { no_elem();                                              }
  ~base_list()     { delete_all();                                           }

  int  out()       { return ( cursor == NULL );                              }
  int  tobegin()   { cursor = first_elem;   return out();                    }
  int  forward()   { if ( !cursor ) return 1;
                     out_data = cursor->data;
                     cursor = cursor->next_elem; return 0;                   }
  int  toend()     { cursor = last_elem; return out();                       }
  const TYPE &current()   { return cursor ? cursor->data : out_data;         }
  const TYPE &first()     { tobegin(); return current();                     }
  const TYPE &next()      { forward(); return current();                     }
  const TYPE &last()      { toend();   return current();                     }
  int  empty()     { return ( first_elem == NULL );                          }
  int  add(TYPE p) { ELEM *n = new ELEM(p);
                     if ( !n ) return 1;
                     if ( first_elem ) last_elem->add(n);
                     else first_elem = n;
                     last_elem = n; return 0;
                   }
}; /* base_list<TYPE,ELEM> */

template <class TYPE,class ELEM>
int base_list<TYPE,ELEM>::delete_all()
{
  elem<TYPE> *e;
  tobegin();
  while ( cursor ) { e = cursor; forward(); delete e; }
  return no_elem();
}

/****************************************************************************/
template <class TYPE>
class single_elem : public elem<TYPE> {
public:
  single_elem(TYPE &d) : elem<TYPE>(d) {};
}

template <class TYPE>
class list : public base_list<TYPE,single_elem<TYPE> > {
public:
  list() : base_list<TYPE,single_elem<TYPE> >  () {};
};

/****************************************************************************/
template <class TYPE>
class double_elem : public elem<TYPE>  {
public:
  double_elem *previous_elem;
  double_elem(TYPE &d) : elem<TYPE>(d) { previous_elem = NULL;};
  int add(elem<TYPE> *n) {
    ((double_elem<TYPE> *)n)->previous_elem = this; next_elem = n; return 0; }
}

template <class TYPE>
class dlist : public base_list<TYPE,double_elem<TYPE> > {
public:
  dlist() : base_list<TYPE,double_elem<TYPE> >  () {};
  int  backward()  { if ( !cursor ) return 1;
                     out_data = cursor->data;
                     cursor = ((double_elem<TYPE> *)cursor)->previous_elem;
                     return 0;                                               }
  const TYPE &previous() { backward(); return current();                     }
};

#define VIIVA "------------------------------------------------------------\n"
/****************************************************************************/
int main(void)
{
  cout << VIIVA;

  dlist<char> lc; lc.add('a'); lc.add('b'); lc.add('c'); lc.add('d');

  for (char c=lc.first(); !lc.out(); c=lc.next() )
    cout << c << " ";

  cout << c << "\n" << VIIVA;

  for (lc.tobegin(); !lc.out(); lc.forward() )
    cout << lc.current() << " ";

  cout << lc.current() << "\n" << VIIVA;
#if 1
  for (c=lc.last(); !lc.out(); c=lc.previous() )
    cout << c << " ";

  cout << c << "\n" << VIIVA;

  for (lc.toend(); !lc.out(); lc.backward() )
    cout << lc.current() << " ";

  cout << lc.current() << "\n" << VIIVA;
#endif
  return 0;
}