// --------------------------------------------------------------------------
// Linear Containers
// A. Fischer June 12, 2001						    	     file: linear.hpp
// --------------------------------------------------------------------------
#pragma once

#include <iostream>
#include "container.hpp"
#include "cell.hpp"
using namespace std;

template <class T>
class Linear: public Container<T> {
  protected: // -------------------------------------------------------------
  	Cell<T>* head;		 // This is a dummy header for the list.

  private:   // -------------------------------------------------------------
	Cell<T>* here;    	 // Cursor for traversing the container.
	Cell<T>* prior;   	 // Trailing pointer for traversing the container.

  protected: // -------------------------------------------------------------
  	        Linear(): head(new Cell<T>), here( NULL ), prior( head ) {}
	virtual ~Linear ();
	        void  reset()	 		{ prior = head; here = head->next; }
  	        bool  end() const 		{ return here == NULL; }
	        void  operator ++();
	virtual void  insert( Cell<T>* cp );
	virtual void  focus() = 0;
			Cell<T>* remove();
			bool    operator<  ( Cell<T>* cp ) { return cp->data->key() < here->data->key(); }
			bool    operator<  ( KeyType k ){ return *here->data < k; }
			bool    operator== ( KeyType k ){ return *here->data == k; }

  public:	// --------------------------------------------------------------
			void  put(T * ep)	{ if (ep) insert( new Cell<T>(ep) ); }
			T*    pop();
  	        T*    peek() 		{ focus(); return *here; }
	virtual ostream& print( ostream& out );
};

template <class T>
inline ostream& operator<<(ostream& out, Linear<T>& s) {return s.print(out); }

// ========================================================================
// Implementation of template methods
// ------------------------------------------------------------------------
template <class T>
Linear<T>::~Linear () {
	for (reset(); !end(); ++*this) {
		delete prior->data;
		delete prior;
	}
	delete prior->data;
	delete prior;
}
// ------------------------------ Move index to next item in the container.
template <class T>
void
Linear<T>::operator ++() {
	if (!end() ){
		prior = here;
		here = here->next;
	}
}
// ---------------- Put an item into the container between prior and here.
// ------------- Assumes that here and prior have been positioned already.
template <class T>
void
Linear<T>::insert(Cell<T>* cp) {
	cp->next = here;
	here = prior->next = cp;
}
// ---------------- Take an item out of the container. Like pop or dequeue.
// -- Assumes that here and prior have been positioned to the desired item.
template <class T>
Cell<T>*
Linear<T>::remove() {
	if (! here ) return NULL;
	Cell<T>* temp = here; 					// Grab cell to remove.
	here = prior->next = temp->next;	// Link around it.
	return temp;
}
// ------------------------------------ Remove a Cell<T> and return its T.
template <class T>
T*
Linear<T>::pop(){
	focus();				 // Set here and prior for deletion point.
	Cell<T>* temp = remove();   // Remove first real cell on list.
	if (!temp) return NULL;  // Check for empty condition.
	T* answer = *temp;	 // Using cast coercion from Cell<T> to T.
	delete temp;             // Take contents out of cell, delete Cell<T>.
	return answer;			 // Return data item.
}
// ---------------------------------------- Print the container's contents.
template <class T>
ostream&
Linear<T>::print (ostream& out ) {
	out << "  <[\n";
  	for (reset(); !end(); ++*this)  out << "\t" <<*here;
  	return out << "  ]>\n";
};