/*
 * FILE: list.cpp - member function implementations for a List ADT
 *                  which uses a linked-list representation
 */

#include "list.h"

template <class item>
node<item>::node( const item& itm, node<item>* ptr )
{
	data = itm;
	link = ptr;
}

template <class item>
list<item>::list()
{
	first = last = curr = prev = NULL;
	count = 0;
}

template <class item>
list<item>::~list()
{
	node<item>* doomed;
	while ( first != NULL )
	{
		doomed = first;
		first = first->link;
		delete doomed;
	}
}

template <class item>
void list<item>::insertFirst( const item& itm )
{
	assert( (first = new node<item>( itm, first )) != NULL );
	if ( last == NULL )
	{
		last = first;
	}
	count++;
   // move curr past the node inserted
   prev = first;
   curr = prev->link;
}

template <class item>
void list<item>::insertLast( const item& itm )
{
	if ( last == NULL )
	{
		insertFirst( itm );
	}
	else
	{
		assert( (last = last->link = new node<item>(itm, NULL)) != NULL );
		count++;
		// move curr past the node inserted node
		prev = last;
		curr = NULL;
	}
}

template <class item>
void list<item>::insertBefore( const item& itm )
{
	if ( size() == 0 || curr == first )		// empty list
	{
		insertFirst( itm );
	}
	else
	{
		assert( (prev->link = new node<item>( itm, curr )) != NULL );
		if ( curr == NULL )
		{
			last = prev->link;
		}
		count++;
		// curr remains just past the inserted node
		// move prev to inserted node
		prev = prev->link;
	}
}

template <class item>
void list<item>::insertAfter( const item& itm )
{
	if ( size() == 0 || curr == last || curr == NULL)
	{
		insertLast( itm );
	}
	else
	{
		assert( (curr->link = new node<item>( itm, curr->link )) != NULL );
		count++;
		// move curr passed inserted node, keep prev 1 before curr
		prev = curr->link;
		curr = prev->link;
	}
}

template <class item>
void list<item>::removeFirst()
{
	assert( size() > 0 );

	node<item>* doomed = first;
	if ( first == last )
	{
		first = last = curr = prev = NULL;
	}
	else
	{
		first = first->link;
		prev = NULL;
		curr = first;
	}
	delete doomed;
	count--;
}

template <class item>
void list<item>::removeLast()
{
	node<item>* doomed = last;
	if ( first == last )
	{
		first = last = curr = prev = NULL;
	}
	else
	{
		node<item>* tmp;
		for ( tmp = first; tmp->link != last; tmp = tmp->link ) ;
		tmp->link = NULL;
		last = prev = tmp;
		curr = NULL;
	}
	delete doomed;
	count--;
}

template <class item>
void list<item>::removeCurrent()
{
	assert( size() > 0 && curr != NULL );

	if ( curr == first )
	{
		removeFirst();
	}
	else if ( curr == last )
	{
		removeLast();
	}
	else
	{
		node<item>* doomed = curr;
		prev->link = curr->link;
		curr = curr->link;
		delete doomed;
		count--;
	}
}

template <class item>
item list<item>::firstValue()
{
	assert( size() > 0 );
	return first->data;
}

template <class item>
item list<item>::lastValue()
{
	assert( size() > 0 );
	return last->data;
}

template <class item>
item list<item>::currentValue()
{
	assert( size() > 0 && curr != NULL );
	return curr->data;
}

template <class item>
int list<item>::size()
{
	return count;
}

template <class item>
void list<item>::start()
{
	prev = NULL;
	curr = first;
}

template <class item>
int list<item>::more()
{
	return (curr != NULL);
}

template <class item>
void list<item>::advance()
{
	prev = curr;
	curr = curr->link;
}

template <class item>
void list<item>::print()
{
	for ( start(); more(); advance() )
	{
		cout << currentValue() << endl;
	}
}

// At this point we include the set of explicit instantiations
// required to force the compiler to generate the list class to
// store specific types as needed by the application using our class

#include "exp.h"