Initial revision

[irc/gameservirc.git] / gameserv / list.h

#ifndef LIST_H
#define LIST_H

#include <iostream.h>
#include <cassert>
#include "listnode.h"
#include "aClient.h"

template <class T>
class List {
    public:
	List();		//constructor
	~List();	//deconstructor
	void insertAtFront( const T & );
	void insertAtBack( T *&);
	bool removeFromFront( T & );
	bool removeFromBack( T & );
	bool remove( T * );
	bool isEmpty() const;
	void print() const;
        ListNode < T > *First() { return firstPtr; };
	ListNode < T > *Last() { return lastPtr; };
    private:
	ListNode < T > *firstPtr;
	ListNode < T > *lastPtr;

	ListNode < T > *getNewNode ( const T &  );
};

template <class T>
List<T>::List() : firstPtr (0), lastPtr (0) {}

template <class T>
List<T>::~List()
{
    if (!isEmpty())
    {
	cout << "Destroying Nodes" << endl;

	ListNode<T> *currentPtr = firstPtr, *tempPtr;

	while (currentPtr != 0) 
	{
	    tempPtr = currentPtr;
	    currentPtr = currentPtr->next;
//	    if (!tempPtr->getData()->stats || tempPtr->getData()->stats->started == 0)
		delete tempPtr;
//	    else
//	        tempPtr->getData()->stats->started = 0;
	}
	cout << "All Nodes destroyed" << endl;
    }
}

template<class T>
void List<T>::insertAtFront( const T &value )
{
    ListNode<T> *newPtr = getNewNode ( value );


    if (isEmpty())
	firstPtr = lastPtr = newPtr;
    else
    {
	newPtr->Next = firstPtr;
	firstPtr->prev = newPtr;
	firstPtr = newPtr;
    }
}

template<class T>
void List<T>::insertAtBack(T *&value )
{
    ListNode<T> *newPtr = getNewNode(*value);

    if (isEmpty())
    {
	firstPtr = lastPtr = newPtr;
    }
    else
    {
	newPtr->prev = lastPtr;
	lastPtr->next = newPtr;
	lastPtr = newPtr;
    }
}


template <class T>
bool List<T>::removeFromFront( T &value )
{
    if ( isEmpty())
	return false;
    else
    {
	ListNode<T> *tempPtr = firstPtr;

	if ( firstPtr == lastPtr )
	    firstPtr = lastPtr = 0;
	else
	    firstPtr = firstPtr->next;

	value = tempPtr->getData();
	delete tempPtr;
	return true;
    }
}

template <class T>
bool List<T>::removeFromBack( T &value )
{
    if ( isEmpty() )
	return false;
    else
    {
	ListNode<T> *tempPtr = lastPtr;

	if ( firstPtr == lastPtr )
	    lastPtr = firstPtr = 0;
	else
	    lastPtr = lastPtr->prev;

	value = tempPtr->getData();
	delete tempPtr;
	return true;

    }
}

template <class T>
bool List<T>::isEmpty() const
   { return firstPtr == 0; }

template <class T>
ListNode<T> *List<T>::getNewNode( const T &value)
{
    ListNode<T> *ptr = new ListNode<T>(value);

    assert( ptr != 0);

    return ptr;
}

template <class T>
void List<T>::print() const
{
    if (isEmpty())
    {
	cout << "Empty list" << endl;
	return;
    }

    ListNode<T> *currentPtr;
    currentPtr = firstPtr;
    while (currentPtr)
    {
	cout << "aClient: " << *currentPtr->getData();

        if (currentPtr->getData()->stats)
	    cout << "  Player Name:" << currentPtr->getData()->stats->name;
	cout << endl;
	currentPtr = currentPtr->next;
    }

    cout << endl;
}

template <class T>
bool List<T>::remove(T *remPtr)
{
    ListNode<T> *newPtr = firstPtr;
    T *testPtr;

    while (newPtr)
    {
	testPtr = newPtr->getData();
	if (testPtr == remPtr)
	{
	    if (firstPtr == lastPtr)
	    {
		firstPtr = lastPtr = 0;	
		delete newPtr;
		return true;
	    }
	    else if (newPtr != lastPtr && newPtr != firstPtr)
	    {
		newPtr->prev->next = newPtr->next;
		newPtr->next->prev = newPtr->prev;
		delete newPtr;
		return true;
	    }
	    else if (newPtr == lastPtr)
	    {
		lastPtr = newPtr->prev;
		lastPtr->next = 0;
		delete newPtr;
		return true;
	    }
	    else if (newPtr == firstPtr)
	    {
		firstPtr = newPtr->next;
		firstPtr->prev = 0;
		delete newPtr;
		return true;
	    }
	}
	newPtr = newPtr->next;
    }
    return false;
}
#endif