/* File: sl_list.C      Copyright glh 9/15/92 */
#include "sl_list.H"

template<class T>
SlList<T>::SlList(const T& elm) 
{
  tail->next = tail = new SlNode<T>(elm);
  length = 1;
}

template<class T>
SlList<T>::SlList(const SlList<T>& lst) 
{
  if (lst.Length() == 0) {
    length = 0;  tail = NULL;
  }
  else {
    tail->next = tail = new SlNode<T>(lst.Retrieve(1));
    for (int i=2; i<=lst.length; i++)
      Append(lst.Retrieve(i));
  }
}

template<class T>
SlList<T>& SlList<T>::operator=(const SlList<T>& lst)
{
  if (this != &lst) {  // check for assigning list to itself before deleting
    MakeEmpty();
    for (int i=1; i<=lst.length; i++)
      Append(lst.Retrieve(i));
  }
  return *this;
}

template<class T>
void SlList<T>::Insert(const T& elm, int pos)
{
  assert((pos > 0) && (pos <= length));
  SlNode<T>* prev_node;
  SlNode<T>* current_node;
  prev_node = current_node = tail->next;
  SlNode<T>* new_node = new SlNode<T>(elm);  // create the new node
  if (pos == 1) {
    new_node->next = tail->next;   tail->next = new_node;
  }
  else {
    current_node = current_node->next;
    for (int i=2; i<pos; i++) {  // traverse list
      prev_node = current_node;   current_node = current_node->next;
    }
    prev_node->next = new_node;  // splice the new node into the list
    new_node->next = current_node;
  }
  length++;
}

template<class T>
void SlList<T>::Append(const T& elm)
{
  SlNode<T>* new_node = new SlNode<T>(elm);
  if (tail == NULL) {  //empty list
    tail = new_node;
    tail->next = tail;
  }
  else {
    new_node->next = tail->next;
    tail->next = new_node;
    tail = new_node;
  }
  length++;
}

template<class T>
T& SlList<T>::Retrieve(int pos) const
{
  assert((pos > 0) && (pos <= length));
  SlNode<T>* temp = tail->next;
  for (int i=1; i<pos; i++)  // traverse list
    temp = temp->next;
  return temp->data;
}

template<class T>
void SlList<T>::Delete(int pos)
{
  assert((pos > 0) && (pos <= length));
  SlNode<T>* prev_node;
  SlNode<T>* current_node;
  prev_node = current_node = tail->next;
  if (pos == 1) {
    if (length == 1)  // deleting only node in list
      tail = NULL;
    else
      tail->next = current_node->next;
  }
  else {  // traverse list
    current_node = current_node->next;
    for (int i=2; i<pos; i++) {  
      prev_node = current_node;   current_node = current_node->next;
    }
    prev_node->next = current_node->next;
    if (current_node == tail)  // deleting the tail node
      tail = prev_node;
  }
  delete current_node;
  length--;
}

template<class T>
void SlList<T>::MakeEmpty()
{ 
  SlNode<T>* temp = NULL;
  while (temp != tail) {
    temp = tail->next;
    tail->next = temp->next;
    delete temp;
  }
  delete tail;
  length = 0;   tail=NULL;
}

template<class T>
ostream& operator<<(ostream& os, const SlList<T>& lst)
{
  SlNode<T>* temp = lst.tail->next;
  os << "(";
  if (lst.length != 0)
    for (int i=0; i<lst.length; i++) {
      os << temp->data;
      if (i != lst.length-1)
        os << ",";
      temp = temp->next;
    }
  os << ")";
  return os;
}

/* 
    for (int i=0; i<lst.length-1; i++) {
      os << temp->data << ",";
      temp = temp->next;
    }
    os << temp->data;
  }
*/

template<class T>
SlListIterator<T>::SlListIterator(const SlList<T>* lst) 
{
  if (lst->length == 0)
    current=0; 
  else
    current=1;
  list=lst;
}

template<class T>
int SlListIterator<T>::Reset() 
{
  if (list->length == 0)
    current=0; 
  else 
    current=1;
  return current;
}

template<class T>
int SlListIterator<T>::operator++()
{
  if (current == list->length || list->length == 0)
    return 0;
  return(++current);
}

template<class T>
int SlListIterator<T>::operator++(int)
{
  if (current == list->length || list->length == 0)
    return 0;
  return(++current);
}