///////    File: List.C    ///////
#include "List.h"

template <class T>
inline int List<T>::equal(T& r, T& s)
{  return( r == s );  }


// If your compiler has trouble with the static member End,
//   consider replacing End by NULL in the template List<T>
template <class T>
Item<T>* List<T>::End = NULL; 

template <class T>
List<T>::~List() {   free();  }

template <class T>
void List<T>::free() // private method
{       Item<T>* n, *p = head;
        while (p)
        {   n = p->next;
            delete p;
            p=n;
        }
}

template <class T>
int List<T>::shorten(int n)
{     while (n-- && head)
      {   Item<T>* tmp=head;
          head = head->next;
          delete(tmp);
      }
      return(- ++n);
}

template <class T>
int List<T>::remove(T& c)
{  Item<T> *tmp, *p = head;
   int count = 0;
      while (p->next)      // treat all but head cell
      {  if ( equal((p->next)->value(), c) )
         {   count++;
             tmp = p->next;
             p->next = tmp->next;
             delete(tmp); // free up store
         }
         else
                p = p->next;
      }
      if ( equal(head->value(), c) ) // treat head cell
      {  tmp = head;
         head = head->next;
         delete(tmp);
         count++;
      }
      return(count);        // number of items removed
}

template <class T>
void List<T>::remove(Item<T>* z)      // del list cell
{   Item<T>* tmp;
    if ( head == z )                  // treat head cell
    {   tmp = head;
        head = head->next;
        delete(tmp);
        return;
    }
    Item<T>* p = head;
    while (p->next)                   // treat other cells
        if ( p->next == z )
        {   tmp=p->next;
            p->next=(p->next)->next;
            delete(tmp);              // free up store
            return;
        }
        else p= p->next;
    return;                           // no entry is 0
}

template <class T>
int List<T>::put_on(T& c)
{  Item<T>* tmp = new Item<T>(c,head);
      if ( tmp )
      {  head = tmp;
         return(0);
      }
      else return(-1); // failed
}

// insert after entry e
template <class T>
int List<T>::insert(T& c, Item<T>* e)
{  Item<T>* tmp = new Item<T>(c,next(e));
      if ( tmp )
      {  if (e) e->next = tmp;
         else head = tmp;
         return(0);
      }
      else return(-1); // failed
}

template <class T>
Item<T>* List<T>::last()
{  Item<T>* p = head;
      while( p && p->next ) p =  p->next; 
      return(p);
}

template <class T>
Item<T>* List<T>::find(T& c)
{   for( Item<T>* p = head; p ; p = p->next )
       if( equal(p->value(), c) )
           return(p);
    return(NULL);  // c not on list
}

template <class T>
int List<T>::substitute(T& r, T& s)
{   for( Item<T>* p = head; p ; p = p->next )
       if( equal(p->value(), s) )
       {   p->value(r);
           return(0);
       }
    return(-1);  // s not on list
}

// display from p to end
template <class T>
void List<T>::display(ostream& out, Item<T>* p) const
{   out << "(";
    while ( p )
    {    out << p->value();   // call overloaded <<
         if ( p = p->next ) out << " : ";
    }
    out << ")\n";
}

template <class T>
int ListIterator<T>::operator()(T& n)
{    pre = cur;
     if ( pre )
     {    cur = pre->next;
          n = pre->value();
          return(1);
     }
     else  return(0);
}

template <class T>
void ListIterator<T>::del()
{    l.remove( pre );        }