#ifndef ___DOUBLE_LINKED_LIST__
#define ___DOUBLE_LINKED_LIST__

template <typename T>
class dnode
{
public:
	T data;
	dnode<T>* prev, * next;

	dnode() { prev = next = NULL; }
	dnode(const T elem) { data = elem; prev = next = NULL; }
};

template <typename T>
class Itr
{
private:
	dnode<T>* current;

public:
	Itr() { current = NULL; }
	Itr(dnode<T>* ptr) { current = ptr; }

	Itr<T>& operator++(); //pre-increment ++i
	Itr<T> operator++(int); //post-increment i++
	Itr<T>& operator--(); //pre-decrement --i
	Itr<T> operator--(int); //post-decrement i--
	T       operator*() const { return current->data; };
	T& operator*() { return current->data; };
	const dnode<T>* operator->() const { return current; };
	dnode<T>* operator->() { return current; };
};

template <typename T>
Itr<T>& Itr<T>::operator++() //pre-increment ++i
{
	if (current != NULL)
		current = current->next;
	//Itr<T> rlt(current);
	//return rlt;
	return *this;
}

template <typename T>
Itr<T> Itr<T>::operator++(int) //post-increment i++
{
	Itr<T> rlt(current);
	if (current != NULL)
		current = current->next;
	return rlt;
}

template <typename T>
Itr<T>& Itr<T>::operator--() //pre-decrement --i
{
	if (current != NULL)
		current = current->prev;
	//Itr<T> rlt(current);
	//return rlt;
	return *this;
}

template <typename T>
Itr<T> Itr<T>::operator--(int) //post-decrement i--
{
	Itr<T> rlt(current);
	if (current != NULL)
		current = current->prev;
	return rlt;
}


template <typename T>
class DList
{
private:
	dnode<T>* front, * rear;
	
public:
	DList();
	~DList();

	bool isEmpty() const;
	bool isFull() const;

	const Iter<T> operator[](int) const;
	Iter<T>& operator[](int);

	const Iter<T> find(const T &elem) const;
	Iter<T>& find(const T & elem);

	const Itr<T> begin() const { return Itr(front); }
	Itr<T>& begin() const { return Itr(front); }
	
	const Itr<T> end() const { return Itr(rear); }
	Itr<T>& end() const { return Itr(rear); }

	void insertBeforeNode(const T& elem, Iter<T> iterator);
	void insertAfterNode(const T& elem, Iter<T> iterator);

	void remove(Itr<T> iterator);

};

#endif