// Null Node
//
// Douglas Thrift
//
// $Id$

#ifndef _NullNode_hpp_
#define _NullNode_hpp_

template<typename Type>
class NullNode
{
private:
	Type value;
	NullNode<Type>* next;
	NullNode<Type>* previous;
	bool null;
public:
	NullNode() : null(true) {}
	NullNode(const Type& value) : value(value), null(false) {}
	void setValue(const Type& value) { this->value = value; }
	const Type& getValue(void) const { return value; }
	void addNext(const Type& value);
	void addPrevious(const Type& value);
	void removeNext(void);
	void removePrevious(void);
	void setNext(NullNode<Type>* next) { this->next = next; }
	void setPrevious(NullNode<Type>* previous) { this->previous = previous; }
	NullNode<Type>* getNext(void) const { return next; }
	NullNode<Type>* getPrevious(void) const { return next; }
	bool contains(const Type& value, NullNode<Type>* end, bool forward = true);
	void remove(const Type& value, NullNode<Type>* end, bool forward = true);
};

template<typename Type>
void NullNode<Type>::addNext(const Type& value)
{
	NullNode<Type>* behind = next;

	next = new NullNode<Type>(value);
	next->previous = this;
	next->next = behind;
	behind->previous = next;
}

template<typename Type>
void NullNode<Type>::addPrevious(const Type& value)
{
	NullNode<Type>* ahead = previous;

	previous = new NullNode<Type>(value);
	previous->next = this;
	previous->previous = ahead;
	ahead->next = previous;
}

template<typename Type>
void NullNode<Type>::removeNext(void)
{
	NullNode<Type>* behind = next->next;

	delete next;

	next = behind;
	next->previous = this;
}

template<typename Type>
void NullNode<Type>::removePrevious(void)
{
	NullNode<Type>* ahead = previous->previous;

	delete previous;

	previous = ahead;
	previous->next = this;
}

template<typename Type>
bool NullNode<Type>::contains(const Type& value, NullNode<Type>* end, bool forward)
{
	NullNode<Type>* another = forward ? next : previous;

	if (null && end == this)
	{
		return false;
	}
	else if (!null && value == this->value)
	{
		return true;
	}
	else return another->contains(value, end);
}

template<typename Type>
void NullNode<Type>::remove(const Type& value, NullNode<Type>* end, bool forward)
{
	NullNode<Type>* another = forward ? next : previous;

	if (!null && value == this->value)
	{
		next->previous = previous;
		previous->next = next;
		
		delete this;
	}
	else if (end != this) another->remove(value, end, forward);
}

#endif // _NullNode_hpp_