List

#ifndef _DBLINK_H
#define _DBLINK_H

template<typename Type>

class DBLink
{
public:
	DBLink() 
	{
		Init();
	}

	DBLink(const DBLink &link) 
	{
		Init();
		operator=(link);
	}

	const DBLink& operator= (const DBLink &link)
	{
		if (this != &link)
		{
			Clear();
			

			for (Const_Iterator it = link.Begin(); it != link.End(); it++)
			{
				push_back(*it);
			}
		}

		return (*this);
	}
public:
	void Reserve()
	{
		Node *pNodeTemp = m_pFirst;

		while(pNodeTemp != NULL)
		{ 
			Node *pTemppPrev = pNodeTemp->pPrev;
			
			pNodeTemp->pPrev = pNodeTemp->pNext;
			pNodeTemp->pNext = pTemppPrev;
			
			pNodeTemp = pNodeTemp->pPrev;
		}

		pNodeTemp = m_pFirst;
		m_pFirst = m_pEnd;
		m_pEnd = pNodeTemp;
	}

	void push_back(const Type& tValue)
	{
		m_pEnd->pPrev = m_pEnd->pPrev->pNext = new Node(tValue, m_pEnd->pPrev, m_pEnd);
		m_iLen++;
	}

	void pop_back()
	{
		Erase(--End());
	}

	~DBLink()
	{
		Clear();
		delete m_pFirst;
		delete m_pEnd;
	}


public:
	void Clear()
	{
		while(m_iLen)
		{
			pop_back();
		}
	}
private:
	typedef struct _Node
	{
		Type   tData;
		_Node *pPrev;
		_Node *pNext;
		_Node(const Type& t = Type(), _Node *p = NULL, _Node *n = NULL) : 
                       tData(t), pPrev(p), pNext(n)
		{
			
		}
	}Node;

public:
	class Const_Iterator
	{
	public:
		Const_Iterator() : m_pNode(NULL)
		{
			
		}

		explicit Const_Iterator(Node *pNode) : m_pNode(pNode)
		{
			
		}

	public:
		const Type& operator*() const
		{
			return m_pNode->tData;
		}

		bool operator==(const Const_Iterator &it)
		{
			return (it.m_pNode == m_pNode);
		}

		bool operator!=(const Const_Iterator &it)
		{
			return !(*this == it);
		}

		const Const_Iterator & operator++()
		{
			m_pNode = m_pNode->pNext;
			return (*this);
		}

		const Const_Iterator  operator++(int)
		{
			Const_Iterator old = *this;
			++(*this);
			return old;
		}
	protected:
		Node *m_pNode;
	};

	class Iterator : public Const_Iterator
	{
	public:
		friend DBLink<typename Type>;
		Iterator()
		{

		}

		Type& operator*() 
		{
			return m_pNode->tData;
		}

		const Type& operator*() const
		{
			return m_pNode->tData;
		}

		explicit Iterator(Node *pNode) : Const_Iterator(pNode)
		{

		}

		Iterator& operator++()
		{
			m_pNode = m_pNode->pNext;
			return (*this);
		}

		Iterator operator++(int)
		{
			Iterator old(m_pNode);
			++(*this);
			return old;
		}

		Iterator& operator--()
		{
			m_pNode = m_pNode->pPrev;
			return (*this);
		}
	};

public:
	const Const_Iterator Begin() const
	{
		return Const_Iterator(m_pFirst->pNext);
	}

	const Const_Iterator End() const 
	{
		return Const_Iterator(m_pEnd);
	}

	Iterator Begin()
	{
		return Iterator(m_pFirst->pNext);
	}

	Iterator End()
	{
		return Iterator(m_pEnd);
	}

	Iterator Erase(Iterator it)
	{
		Node *p = it.m_pNode;
		Iterator retval(p->pNext);
		
		p->pPrev->pNext = p->pNext;
		p->pNext->pPrev = p->pPrev;

		delete p;
		m_iLen--;
		
		return retval;
	}

private:
	void Init()
	{
		m_pFirst = new Node();
		m_pEnd = new Node();

		m_pFirst->pNext = m_pEnd;
		m_pEnd->pPrev = m_pFirst;

		m_iLen = 0;
	}
private:
	Node *m_pFirst;
	Node *m_pEnd;
	int m_iLen;
};

#endif