Network Stream Class

// File  : ListT.h
// Author: S�nke Freter + Hans Hamm alias Sendel
// Date  : 24.04.2003      
// What  : Linked List Template Class
//////////////////////////////////////////////////////////////////////

#ifndef _LISTT_H__
#define _LISTT_H__

#include <stdio.h>
#include "stack.h"

template <class type>
class ListT
{

protected:
	struct node_t
	{
		type		item;
		node_t *	next;
	};
	int m_Count;
	node_t *	m_Head;
	node_t *	m_Current;
	node_t *	m_Tail;

	Stack *		m_pStack_Settings;

	//void	push(type pItemToPush); || type	pop(); || type	pop(type pItemToPop);
	int help;

public:

	void	push(type pItemToPush);
	type	pop();
	type	pop(type pItemToPop);
	
	type 	getFirst();
	type 	getNext();
	void	pushSettings();
	void	popSettings();

	void	clear();
	int		getSize();
	type	operator[](int i);

	ListT*	getCopy();

	ListT();
	~ListT();

};


template <class type> 
ListT<type>::ListT()
{
	m_Tail		= NULL;
	m_Head		= NULL;
	m_Current	= NULL;
	m_Count		= 0;

	m_pStack_Settings = NULL;
}

template <class type> 
ListT<type>::~ListT()
{
	clear();
	SAVEDELETE(m_pStack_Settings);
}

template <class type> 
ListT<type>*	ListT<type>::getCopy(){
	ListT *tmp = new ListT();
	memmove(tmp, this, sizeof(ListT));
	
	node_t *	current = m_Tail;
	while( current )
	{
		tmp->push( current->item );
		current = current->next;
	}
	return tmp;
}

template <class type> 
void ListT<type>::push(type pItemToPush)
{
	// Neuen Knoten anlegen
	node_t *pNode = new node_t;
	pNode->item = pItemToPush;
		
	if (m_Head == NULL)  // nur 1 Element
	{
		m_Head		 = pNode;		
		m_Head->next = NULL;  // Neuen Zeiger auf Null zeigen lassen
		m_Tail = m_Head; // dann ist Head == Tail
	}
	else
	{
		m_Head->next = pNode; // alten Zeiger umbiegen
		m_Head		 = pNode;		
		m_Head->next = NULL;  // Neuen Zeiger auf Null zeigen lassen
	}
		m_Count++;
}

template <class type> 
type ListT<type>::pop() // von Tail 
{
	if (m_Tail != NULL)
	{
		node_t *pNode = m_Tail;			// den letzen Knoten merken
		type pItem = pNode->item;		// das Element merken
		if (m_Tail == m_Head)
		{
			m_Head = NULL;
		}
		m_Tail = m_Tail->next;			// einen weiter gehen
		
		SAVEDELETE(pNode);				// den Knoten l�schen
		m_Count--;						// einer Weniger in der ListTe!
		return pItem;					// Element zur�ckgeben
	}
	return NULL;
}

template <class type> 
type ListT<type>::pop(type pItemToPop)  // von Tail
{

	node_t * pNode = m_Tail;

	if (pNode == NULL)
	{
		return NULL;
	}

	if (pNode->next == NULL)
	{
		if (pNode->item == pItemToPop)
		{
			return pop();
		}
		else
		{
			return NULL;
		}
	}
	if (pNode->item == pItemToPop)
	{
		return pop();
	}

	while (pNode->next != NULL)
	{
		if (pNode->next->item == pItemToPop)
		{
			node_t *tmpNode =  pNode->next;
			type pItem = tmpNode->item;
			pNode->next = tmpNode->next;
			SAVEDELETE(tmpNode);
			m_Count--;
			return pItem;
		}
		pNode = pNode->next;
	}

	return NULL;	
}

template <class type> 
type  ListT<type>::getFirst()
{
	m_Current = m_Tail;
	if (m_Current != NULL)
	{
		return m_Current->item;
	}
	return NULL;
}

template <class type> 
type  ListT<type>::getNext()
{
	if (m_Current != NULL)
	{
		m_Current = m_Current->next;
		if (m_Current != NULL)
		{
			return m_Current->item;
		}
	}
	return NULL;
}

template <class type> 
void ListT<type>::pushSettings()
{
	if(m_pStack_Settings == NULL){
		m_pStack_Settings = new Stack();
	}
	m_pStack_Settings->push(m_Current);
}

template <class type> 
void ListT<type>::popSettings()
{
	if(m_pStack_Settings == NULL) return;

	typetmp = m_pStack_Settings->pop();
	if(tmp){
		m_Current = (node_t*)tmp;
	}
}

template <class type> 
void ListT<type>::clear()
{
	while (getFirst() != NULL)
	{
		pop();
	}
}

template <class type> 
int ListT<type>::getSize()
{
	return m_Count;
}

template <class type> 
type ListT<type>::operator [](int i)
{
	type tmp;
	tmp = getFirst();
	for (int t=0; t<i; t++)
	{
		tmp = getNext();
	}
	return tmp;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////



#endif