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

#ifndef _Node_hpp_
#define _Node_hpp_

#include "Visitor.hpp"

template<typename Type>
class Node
{
private:
	Type value;
protected:
	Node<Type>* next;
	Node<Type>* previous;
public:
	Node() {}
	Node(const Type& value) : value(value) {}
	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(Node<Type>* next) { this->next = next; }
	void setPrevious(Node<Type>* previous) { this->previous = previous; }
	Node<Type>* getNext(void) const { return next; }
	Node<Type>* getPrevious(void) const { return previous; }
	virtual bool contains(const Type& value, Node<Type>* end, bool forward);
	virtual void remove(const Type& value, Node<Type>* end, bool forward);
	virtual void accept(Visitor<Type>* visitor, Node<Type>* end, bool forward);
};

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

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

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

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

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

	delete next;

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

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

	delete previous;

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

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

	if (value == this->value) return true; else return another->contains(value, end, forward);
}

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

	if (value == this->value)
	{
		next->previous = previous;
		previous->next = next;

		delete this;
	}
	else another->remove(value, end, forward);
}

template<typename Type>
void Node<Type>::accept(Visitor<Type>* visitor, Node<Type>* end, bool forward)
{
	Node<Type>* another = forward ? next : previous;

	visitor->visit(value);
	another->accept(visitor, end, forward);
}

#endif // _Node_hpp_