/* File: dynlist.H     Copyright glh 10/12/92 */
#ifndef DYNLISTH
#define DYNLISTH
#include <stdlib.h>
#include <iostream.h>
#include <assert.h>

typedef enum {false, true} Boolean;

// forward declaration for iterator class
template <class Type> class DynListIterator;

template<class T>
class DynList {
  friend class DynListIterator<T>;
  protected:
    int length, size;
    T* element;
  public:
    inline DynList();
    inline DynList(const T&);
    DynList(const DynList<T>&);
    inline ~DynList();
    DynList<T>& operator=(const DynList<T>&);
    friend ostream& operator<<(ostream&, const DynList<T>&);
    Boolean Insert(const T&, int);
    Boolean Append(const T&);
    Boolean Replace(const T&, int);
    T& Retrieve(int) const;
    Boolean Delete(int);  
    inline int Length() const;
    inline Boolean Empty() const;
    inline void MakeEmpty();
};

template<class T>
inline DynList<T>::DynList() 
{size = 2; element = new T[size]; length = 0;}

template<class T>
inline DynList<T>::DynList(const T& elm) 
{size = 2; element = new T[size]; element[0]=elm; length=1;}

template<class T>
inline DynList<T>::~DynList() {delete [] element;}

template<class T>
inline int DynList<T>::Length() const {return length;} 

template<class T>
inline Boolean DynList<T>::Empty() const 
{return length == 0 ? true : false;}

template<class T>
inline void DynList<T>::MakeEmpty() {length=0;} 

template<class T>
class DynListIterator {
  private:
    int current;
    const DynList<T>* list;
  public:
    inline DynListIterator(const DynList<T>&);
    inline int Reset();
    inline int Current() const;
    inline int operator++(); //prefix 
    inline int operator++(int); //postfix
};

template<class T>
inline DynListIterator<T>::DynListIterator(const DynList<T>& lst) 
{lst.length==0 ? current=0 : current=1; list = &lst;}

template<class T>
inline int DynListIterator<T>::Current() const {return current;}

template<class T>
inline int DynListIterator<T>::Reset()
{return list->length == 0 ? current=0 : current=1;}

template<class T>
inline int DynListIterator<T>::operator++() {return ++current;}

template<class T>
inline int DynListIterator<T>::operator++(int) {return ++current;}

#endif