//-------------------------------------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TDualPtrList 模板类
// = Version	:   ver2.0
// = Author		:   wlw
// = CreateDate	:   2002-09-09
// = Description:   TDualPtrList 声明  双向循环链表,提高了单向链表反向遍历和随机访问的速度
// = Maintainers: 
//                  
//-------------------------------------------------------------------------------------------------------+
#ifndef _TDUALPTRLIST_H_
#define _TDUALPTRLIST_H_

#ifndef _TLIST_H_
#include "TList.h"
#endif

#ifndef _TTABLE_H_
#include "TTable.h"
#endif

#ifndef _TDLISTNODE_H_
#include "TDListNode.h"
#endif

template<class T> class TDualPtrList : public TList< T >
{
public:
	TDualPtrList(long initLength = 0);
	TDualPtrList(const TTable<T>& table);
	TDualPtrList(const TDualPtrList<T>& table);

	TDualPtrList<T>&operator =(const TDualPtrList<T>& table);
	TDualPtrList<T>&operator =(const TTable<T>& table);

	virtual ~TDualPtrList();

	virtual const T& GetAt(long index)const;
	virtual const T* GetPre(const T* p)const;

	virtual void MoveTo(long index);
	virtual void MoveToPre();

	virtual void InsertAfterCur(const T& t);
	virtual void DelCur();
	virtual void Clear();

	virtual void DetachAfterCur();
	virtual long Conbine(TList<T>& list, long from = 0);

	virtual void Arrange(bool bIncrease = true);
	virtual void Arrange(int (*cmp)(const T&,const T&));
	virtual void ReverseList();
	virtual void Rotate(long iFrom, long iTo);
};

template<class T>
TDualPtrList<T>& TDualPtrList<T>::operator = (const TDualPtrList<T>& table)
{
	this->DeepCopy(table);
	return *this;
}

template<class T>
TDualPtrList<T>& TDualPtrList<T>::operator = (const TTable<T>& table)
{
	this->DeepCopy(table);
	return *this;
}

template<class T>
void TDualPtrList<T>::Clear()
{
	this->tail->next = NULL;
	TDListNode<T>*p = (TDListNode<T>*)(this->head->next);
	while(p != NULL)
	{
		TDListNode<T> *pn = (TDListNode<T>*)(p->next);
		delete p;
		p = pn;
	}
	this->curPos = this->tail = this->head->next = this->head;
	((TDListNode<T>*)this->head)->pre = this->head;
	this->length = 0;
	this->cur = -1;
}

template<class T>
const T* TDualPtrList<T>::GetPre(const T*p)const
{
	return (p == NULL || p == ((const T*)(this->head->next))) ? NULL : (const T*)(((const TDListNode<T>*)p)->pre);
}

template<class T>
const T& TDualPtrList<T>::GetAt(long index)const
{
	TListNode<T>*p = this->curPos;
	long i = this->cur;
	for (; i < index; i++, p = p->next)
	{
		;
	}
	for (; i > index; i--, p = ((TDListNode<T>*)p)->pre)
	{
		;
	}
	return p->data;
}

template<class T>
void TDualPtrList<T>::ReverseList()
{
	if (this->length < 2)
	{
		return;
	}

	TListNode<T>*p,*next = this->head->next,*pre = this->head;
	for (long i = 0; i < this->length; i++)
	{
		p = next;
		next = p->next;
		p->next = pre;
		((TDListNode<T>*)pre)->pre = p;
		pre = p;
	}

	p = this->head->next;
	this->head->next = this->tail;
	((TDListNode<T>*)this->tail)->pre = this->head;
	this->tail = p;
}	
	
template<class T>
void TDualPtrList<T>::Arrange(bool bIncrease)
{
	if (this->GetLength() < 2)
	{
		return;
	}
	if (bIncrease)
	{
		this->MoveToFirst();
		this->MoveToNext();
		while(!this->IsBegin())
		{
			T temp = this->GetCurData();
			long i = this->GetCur();
			TListNode<T>* pos = this->GetCurPos();
			MoveToPre();
			if (this->GetCurData() > temp)
			{
				while(!this->IsBegin() && this->GetCurData() > temp)
				{
					MoveToPre();
				}

				InsertAfterCur(temp);
				this->curPos = pos;
				this->cur = i + 1;
				DelCur();
			}
			else
			{
				this->MoveToNext();
			}
			this->MoveToNext();
		}
	}
	else
	{
		this->MoveToFirst();
		this->MoveToNext();
		while(!this->IsBegin())
		{
			T temp = this->GetCurData();
			long i = this->GetCur();
			TListNode<T>*pos = this->GetCurPos();
			MoveToPre();
			if (this->GetCurData() < temp)
			{
				while(!this->IsBegin() && this->GetCurData() < temp)
				{
					MoveToPre();
				}
				InsertAfterCur(temp);
				this->curPos = pos;
				this->cur = i + 1;
				DelCur();
			}
			else
			{
				this->MoveToNext();
			}
			this->MoveToNext();
		}
	}
}

template<class T>
void TDualPtrList<T>::Arrange(int (*cmp)(const T&,const T&))
{
	if (this->GetLength() < 2)
	{
		return;
	}
	this->MoveToFirst();
	this->MoveToNext();
	while(!this->IsBegin())
	{
		T temp = this->GetCurData();
		long i = this->GetCur();
		TListNode<T>* pos = this->GetCurPos();
		MoveToPre();
		if (cmp(this->GetCurData(),temp) > 0)
		{
			while(!this->IsBegin() && cmp(this->GetCurData(),temp) > 0)
			{
				MoveToPre();
			}
			InsertAfterCur(temp);
			this->curPos = pos;
			this->cur = i + 1;
			DelCur();
		}
		else
		{
			this->MoveToNext();
		}
		this->MoveToNext();
	}
}

template<class T>
void TDualPtrList<T>::InsertAfterCur(const T& t)
{
    TDListNode<T>* p = new TDListNode<T>;
	p->data = t;
	p->next = this->curPos->next;
	this->curPos->next = p;
	p->pre = this->curPos;
	((TDListNode<T>*)(p->next))->pre = p;
	this->length++;
	this->cur++;
	if (this->curPos == this->tail)
	{
		this->tail = p;
	}
	this->curPos = p;
}

template<class T>
void TDualPtrList<T>::DelCur()
{
	TDListNode<T>* p = (TDListNode<T>*)this->curPos;
	MoveToPre();
	this->curPos->next = p->next;
	((TDListNode<T>*)(p->next))->pre = this->curPos;
	if (p == this->tail)
	{
		this->tail = this->curPos;
	}
	delete p;
	this->length--;
}

template<class T>
TDualPtrList<T>::TDualPtrList(long initLength)
{
	delete this->head;
	this->head = this->tail = new TDListNode<T>;
	this->head->next = this->head;
	((TDListNode<T>*)this->head)->pre = this->head;
	this->curPos = this->head;
	this->Realloc(initLength);
}

template<class T>
TDualPtrList<T>::TDualPtrList(const TTable<T>&table)
{
	delete this->head;
	this->head = this->tail = new TDListNode<T>;
	this->head->next = this->head;
	((TDListNode<T>*)this->head)->pre = this->head;
	this->curPos = this->head;
	this->DeepCopy(table);
}

template<class T>
TDualPtrList<T>::TDualPtrList(const TDualPtrList<T>&table)
{
	delete this->head;
	this->head = this->tail = new TDListNode<T>;
	this->head->next = this->head;
	((TDListNode<T>*)this->head)->pre = this->head;
	this->curPos = this->head;
	this->DeepCopy(table);
}

template<class T>
TDualPtrList<T>::~TDualPtrList()
{
	if (this->head == NULL)
	{
		return;
	}

	Clear();

	TDListNode<T>* p = (TDListNode<T>*)this->head;
	delete p;
	this->head = NULL;
}

template<class T>
void TDualPtrList<T>::MoveToPre()
{
	this->curPos = ((TDListNode<T>*)this->curPos)->pre;
	this->cur--;
	if (this->curPos == this->tail)
	{
		this->cur = this->length - 1;
	}
}

template<class T>
void TDualPtrList<T>::MoveTo(long index)
{
	if (this->IsValidIndex(index))
	{
		if (index == 0)
		{
			this->curPos = this->head->next;
			this->cur = 0;
		}
		else if (index == this->GetLastIndex())
		{
			this->curPos = this->tail;
			this->cur = index;
		}
		else if (index >= this->cur)
		{
			while(this->GetCur() != index)
			{
				this->MoveToNext();
			}
		}
		else
		{
			while(this->GetCur() != index)
			{
				MoveToPre();
			}
		}
	}
	else
	{
		this->cur = -1;
		this->curPos = this->head;
	}
}

template<class T>
long TDualPtrList<T>::Conbine(TList<T>&lstConbine,long from)
{
	if (lstConbine.IsValidIndex(from))
	{
		TListNode<T>*first, *last;
		lstConbine.MoveTo(from);
		first = lstConbine.GetCurPos();
		lstConbine.MoveToLast();
		last = lstConbine.GetCurPos();
		this->length += lstConbine.GetLength() - from;
		lstConbine.DetachAfter(from - 1);
		this->tail->next = first;
		((TDListNode<T>*)first)->pre = this->tail;
		this->tail = last;
		this->tail->next = this->head;
		((TDListNode<T>*)this->head)->pre = this->tail;
	}
	return this->length;
}

template<class T>
void TDualPtrList<T>::Rotate(long iFrom,long iTo)
{
	if (iFrom != iTo)
	{
		long iNewZero = (iFrom - iTo + this->GetLength()) % this->GetLength();
		MoveTo(iNewZero - 1 + this->GetLength() % this->GetLength());
		TListNode<T>* newTail = this->GetCurPos();
		MoveTo(iNewZero);

		//形成环路
		this->tail->next = this->head->next;
		((TDListNode<T>*)this->head->next)->pre = this->tail;

		//更新this->head
		this->head->next = this->curPos;
		((TDListNode<T>*)this->curPos)->pre = this->head;
		this->cur = 0;

		//更新tail
		this->tail = newTail;
		this->tail->next = this->head;
		((TDListNode<T>*)this->head)->pre = this->tail;
	}
}

template<class T>
void TDualPtrList<T>::DetachAfterCur()
{
	this->curPos->next = this->head;
	((TDListNode<T>*)this->head)->pre = this->curPos;
	this->tail = this->curPos;
	this->length = this->cur + 1;
}


#endif