#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "oblist.h"

DBObject::DBObject()
{ 
}

ObList::ObList()
{ 
	m_pNodeHead	=NULL;
	m_pNodeTail	=NULL;
	m_nCount	=0;
}
ObList::~ObList()
{
	RemoveAll();
	assert(m_nCount == 0);
}

Node* ObList::NewNode()
{
	Node* pNode=new Node;
	pNode->data=NULL;
	pNode->pPrev=NULL;
	pNode->pNext=NULL;

	return pNode;
}
void ObList::RemoveHead()
{
	assert(m_pNodeHead != NULL); 

	Node* pOldNode = m_pNodeHead;

	m_pNodeHead = pOldNode->pNext;
	if (m_pNodeHead != NULL)
		m_pNodeHead->pPrev = NULL;
	else
		m_pNodeTail = NULL;

	delete pOldNode;
	m_nCount--;
}
void ObList::RemoveTail()
{
	assert(m_pNodeTail != NULL);

	Node* pOldNode = m_pNodeTail;

	m_pNodeTail = pOldNode->pPrev;
	if (m_pNodeTail != NULL)
		m_pNodeTail->pNext = NULL;
	else
		m_pNodeHead = NULL;

	delete pOldNode;
	m_nCount--;
}
void ObList::RemoveAll()
{
	while(m_pNodeTail)
		RemoveTail();
	m_pNodeHead = NULL;
}
void ObList::RemoveAt(Node* node)
{
	Node* pOldNode = node;

	if (pOldNode == m_pNodeHead)
		m_pNodeHead = pOldNode->pNext;
	else
		pOldNode->pPrev->pNext = pOldNode->pNext;

	if (pOldNode == m_pNodeTail)
		m_pNodeTail = pOldNode->pPrev;
	else
		pOldNode->pNext->pPrev = pOldNode->pPrev;

	delete pOldNode;
	m_nCount--;
}
void ObList::RemoveAt(int nIndex)
{
	Node* pOldNode = GetAt(nIndex);
	if(pOldNode)
		RemoveAt(pOldNode);
}
void ObList::AddHead(void* newElement)
{
	Node* pNewNode = NewNode();
	pNewNode->data = newElement;
	if (m_pNodeHead != NULL)
	{
		m_pNodeHead->pPrev = pNewNode;
		pNewNode->pNext  = m_pNodeHead;
	}
	else
		m_pNodeTail = pNewNode;

	m_pNodeHead = pNewNode;
	m_nCount++;
}

void ObList::AddTail(void* newElement)
{
	Node* pNewNode = NewNode();
	pNewNode->data = newElement;
	if (m_pNodeTail != NULL)
	{
		m_pNodeTail->pNext = pNewNode;
		pNewNode->pPrev  = m_pNodeTail;
	}
	else
		m_pNodeHead = pNewNode;

	m_pNodeTail = pNewNode;
	m_nCount++;
}

Node* ObList::GetNext(Node* node)
{
	if (node == NULL)
		return NULL;
	else
		return node->pNext;
} 
Node* ObList::GetPrev(Node* node) 
{
	if (node == NULL)
		return NULL;
	else
		return node->pPrev;
}

Node* ObList::GetAt(int nIndex)
{
	if (nIndex >= m_nCount || nIndex < 0)
		return NULL;  

	Node* pNode = m_pNodeHead;
	while (nIndex--)
		pNode = pNode->pNext;

	return pNode;
}
void ObList::SetAt(int nIndex,void* newElement)
{
	if (nIndex >= m_nCount || nIndex < 0)
		return ;  

	Node* pNode = m_pNodeHead;
	while (nIndex--)
		pNode = pNode->pNext;
	
	pNode->data=newElement;
}

Node* ObList::InsertBefore(Node* node, void* newElement)
{
	if (node == NULL || node->pPrev == NULL)
	{
		AddHead(newElement); 
		return m_pNodeHead;
	}

	Node* pOldNode = node;
	Node* pNewNode = NewNode();
	pNewNode->data = newElement;

	pOldNode->pPrev->pNext = pNewNode;
	pNewNode->pPrev=pOldNode->pPrev;

	pOldNode->pPrev = pNewNode;
	pNewNode->pNext = pOldNode;

	m_nCount++;
	return pNewNode;
}
Node* ObList::InsertAfter(Node* node, void* newElement)
{
	if (node == NULL || node->pNext == NULL)
	{
		AddTail(newElement);
		return m_pNodeTail;
	}

	Node* pOldNode = node;
	Node* pNewNode = NewNode();
	pNewNode->data = newElement;

	pOldNode->pNext->pPrev = pNewNode;
	pNewNode->pNext=pOldNode->pNext;

	pOldNode->pNext = pNewNode;
	pNewNode->pPrev = pOldNode;

	m_nCount++;
	return pNewNode;
}

Node* ObList::FindAfter(void* searchValue, Node* startAfter/* = NULL*/) 
{
	Node* pNode = startAfter;
	if (pNode == NULL)pNode = m_pNodeHead;

	for (; pNode != NULL; pNode = pNode->pNext)
		if (pNode->data == searchValue)
			return pNode;
	return NULL;
}
Node* ObList::FindBefore(void* searchValue, Node* startBefore/* = NULL*/) 
{
	Node* pNode = startBefore;
	if (pNode == NULL)pNode = m_pNodeTail;

	for (; pNode != NULL; pNode = pNode->pPrev)
		if (pNode->data == searchValue)
			return pNode;
	return NULL;
}
void ObList::AddHead(ObList* pNewList)
{
	assert(pNewList != NULL);

	Node* node = pNewList->GetTail();
	while (node != NULL)
	{
		AddHead(node->data);
		node=pNewList->GetPrev(node);
	}
}
void ObList::AddTail(ObList* pNewList)
{
	assert(pNewList != NULL);

	Node* node = pNewList->GetHead();
	while (node != NULL)
	{
		AddHead(node->data);
		node=pNewList->GetNext(node);
	}
}
ObList& ObList::operator = (ObList& list)
{
	Copy(list);
	return *this;
}	
ObList& ObList::Copy(ObList& list)
{
	Node *p,*q,*r;
	Node *pHead;

	if(m_pNodeHead)RemoveAll();
	pHead=list.GetHead();
	if(!pHead)return *this;

	m_pNodeHead=NewNode();
	
	m_pNodeHead->data=pHead->data;

	m_pNodeTail=m_pNodeHead;
	p=m_pNodeHead;
	r=NULL;
	q=pHead->pNext;
	while(q)
	{
		r=NewNode();
		r->data=q->data;
		r->pPrev=p;
		p->pNext=r;
		m_pNodeTail=r;
		p=p->pNext;
		q=q->pNext;
	}
	return *this;
}