dakcomptrlist.cpp

DarkATLSmtp(SMTP COM 组件原创代码),注册后可在Delphi中发邮件。

// DakComPtrList.cpp: implementation of the CDakComPtrList class.
//作者：高越 邮箱：[e-mail]
//QQ：1738387 (本人只接受技术探讨以及软件项目合作事宜，其他误扰)
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "DakComPtrList.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDakComPtrList::CDakComPtrList()
{
	m_pArrPtrNode=NULL;
}

CDakComPtrList::~CDakComPtrList()
{
	ReleaseArr();
}

CDakComPtrList::CDakComPtrList(long nBlockSize)
{
	AllocNewNodes(nBlockSize,NULL);
}

void CDakComPtrList::ReleaseArr(void)
{
	if(m_pArrPtrNode)
	{
		free(m_pArrPtrNode);
		m_pArrPtrNode=NULL;
	}
}

DAKPOSITION CDakComPtrList::AddTail(LPVOID newElement)
{
	DAKPOSITION pos=GetTailPosition();
	pos=AllocNewNodes(1,pos);
	LPPTRNODE pNode=(LPPTRNODE)pos;
	if(pNode)
		pNode->pData=newElement;
	return pos;
}

DAKPOSITION CDakComPtrList::AddHead(LPVOID newElement)
{
	DAKPOSITION pos=AllocNewNodes(1,NULL);
	LPPTRNODE pNode=(LPPTRNODE)pos;
	if(pNode)
		pNode->pData=newElement;
	return pos;
}

DAKPOSITION CDakComPtrList::InsertBefore(DAKPOSITION position,LPVOID newElement)
{
	DAKPOSITION pos=NULL;
	if(position==NULL)
		return pos;
	LPPTRNODE posImport=(LPPTRNODE)position;
	pos=AllocNewNodes(1,(DAKPOSITION)posImport->pPrev);
	LPPTRNODE pNode=(LPPTRNODE)pos;
	if(pNode)
		pNode->pData=newElement;
	return pos;
}

DAKPOSITION CDakComPtrList::InsertAfter(DAKPOSITION position,LPVOID newElement)
{
	DAKPOSITION pos=NULL;
	if(position==NULL)
		return pos;
	pos=AllocNewNodes(1,position);
	LPPTRNODE pNode=(LPPTRNODE)pos;
	if(pNode)
		pNode->pData=newElement;
	return pos;
}


DAKPOSITION CDakComPtrList::AllocNewNodes(long nNodeCount,DAKPOSITION posAfterNode)
{
	LPPTRNODE pNewNodeList=NULL;
	if(nNodeCount<=0)
		return (DAKPOSITION)pNewNodeList;
	LPPTRNODE pPrevNode=(LPPTRNODE)posAfterNode;
	LPPTRNODE pPrevNextNode=NULL;
	if(pPrevNode)
		pPrevNextNode=pPrevNode->pNext;
	else
		pPrevNextNode=m_pArrPtrNode;
	LPPTRNODE pLastNewNode=NULL;
	long nNodeTotalCount=GetCount();
	for(long i=0;i<nNodeCount;i++)
	{
		LPPTRNODE pNewNode=(LPPTRNODE)calloc(1,sizeof(PTRNODE));
		if(pNewNode==NULL)
			return (DAKPOSITION)pNewNodeList;
		if(i==0)
			pNewNodeList=pNewNode;
		if((m_pArrPtrNode==NULL||nNodeTotalCount<=0)&&i==0)
		{
			ReleaseArr();
			m_pArrPtrNode=pNewNode;
		}
		//change the prev node's pNext pointer
		if(pPrevNode)
			pPrevNode->pNext=pNewNode;
		//change the last new node's pNext pointer
		if(pLastNewNode)
			pLastNewNode->pNext=pNewNode;
		pNewNode->pPrev=pPrevNode;
		pNewNode->pNext=NULL;
		pNewNode->pData=NULL;
		//change the pPrevNode and pNewNodeTemp pointer for loop
		pPrevNode=pNewNode;
		pLastNewNode=pNewNode;
	}
	//set the last node's pNext be NULL,because the node is end.
	if(pLastNewNode)
		pLastNewNode->pNext=pPrevNextNode;
	//if posAfterNode is NULL,it prove the new nodes be ahead of the list.
	//and we must change the old top of list node's pPrev be the new node 
	//at the end of list.
	if(posAfterNode==NULL)
	{
		if(pLastNewNode->pNext)
			pLastNewNode->pNext->pPrev=pLastNewNode;
		//if the new nodes is ahead of the other nodes,then
		//we will change the first pointer of list.
		m_pArrPtrNode=pNewNodeList;
	}
	//now we should make new nodes connect.
	return (DAKPOSITION)pNewNodeList;
}

CDakComPtrList::LPPTRNODE CDakComPtrList::FindNodeByIndex(long nIndex)
{
	LPPTRNODE pNodeReturn=NULL;
	if(nIndex<0||m_pArrPtrNode==NULL)
		return pNodeReturn;
	long nNodeCount=GetCount();
	if(nNodeCount<=0||nIndex>nNodeCount-1)
		return pNodeReturn;
	LPPTRNODE pNodeTemp=m_pArrPtrNode;
	int nIndexTemp=0;
	while(pNodeTemp!=NULL)
	{
		if(nIndexTemp==nIndex)
			break;
		pNodeTemp=pNodeTemp->pNext;
		nIndexTemp++;
	}	
	pNodeReturn=pNodeTemp;
	return pNodeReturn;
}

DAKPOSITION CDakComPtrList::GetHeadPosition(void)
{
	long nIndex=0;
	return (DAKPOSITION)FindIndex(nIndex);
}

DAKPOSITION CDakComPtrList::GetTailPosition(void)
{
	long nNodeCount=GetCount();
	if(nNodeCount<=0)
		return NULL;
	return (DAKPOSITION)FindIndex(nNodeCount-1);
}

DAKPOSITION CDakComPtrList::FindIndex(long nIndex)
{
	return (DAKPOSITION)FindNodeByIndex(nIndex);
}

LPVOID CDakComPtrList::GetHead(void)
{
	return GetAt(GetHeadPosition());
}

LPVOID CDakComPtrList::GetTail(void)
{
	return GetAt(GetTailPosition());
}

LPVOID CDakComPtrList::GetAt(DAKPOSITION position)
{
	LPPTRNODE pNodeTemp=(LPPTRNODE)position;
	LPVOID pReturn=NULL;
	if(pNodeTemp==NULL)
		return pReturn;
	return pNodeTemp->pData;
}

//Input: 
//	pos - a DAKPOSITION type value that's position of node
//	newElement - a LPVOID type value that's a new data of user
//Return: 
//	return a LPVOID pointer of user's data that is pointer of old node's data.
//Remark:
//	No content.
LPVOID CDakComPtrList::SetAt(DAKPOSITION pos,LPVOID newElement)
{
	LPPTRNODE pNodeTemp=(LPPTRNODE)pos;
	LPVOID pReturn=NULL;
	if(pNodeTemp==NULL)
		return pReturn;
	pReturn=pNodeTemp->pData;
	pNodeTemp->pData=newElement;
	return pReturn;
}

LPVOID CDakComPtrList::RemoveAt(DAKPOSITION position)
{
	LPPTRNODE pNodeTemp=(LPPTRNODE)position;
	LPVOID pReturn=NULL;
	if(pNodeTemp==NULL)
		return pReturn;
	if(pNodeTemp->pPrev)
		pNodeTemp->pPrev->pNext=pNodeTemp->pNext;
	else
	{
		if(pNodeTemp->pNext)
			pNodeTemp->pNext->pPrev=NULL;
	}
	if(pNodeTemp->pNext)
		pNodeTemp->pNext->pPrev=pNodeTemp->pPrev;
	else
	{
		if(pNodeTemp->pPrev)
			pNodeTemp->pPrev->pNext=NULL;
	}
	if(pNodeTemp->pPrev==NULL)
		m_pArrPtrNode=pNodeTemp->pNext;
	pReturn=pNodeTemp->pData;
	free((LPVOID)pNodeTemp);
	return pReturn;
}

LPVOID CDakComPtrList::RemoveHead(void)
{
	return RemoveAt(GetHeadPosition());
}

LPVOID CDakComPtrList::RemoveTail(void)
{
	return RemoveAt(GetTailPosition());
}

LPVOID CDakComPtrList::GetNext(DAKPOSITION position)
{
	LPVOID pReturn=NULL;
	LPPTRNODE pNodeTemp=(LPPTRNODE)position;
	if(pNodeTemp==NULL)
		return pReturn;
	return pNodeTemp->pNext?pNodeTemp->pNext->pData:NULL;
}

LPVOID CDakComPtrList::GetPrev(DAKPOSITION position)
{
	LPVOID pReturn=NULL;
	LPPTRNODE pNodeTemp=(LPPTRNODE)position;
	if(pNodeTemp==NULL)
		return pReturn;
	return pNodeTemp->pPrev?pNodeTemp->pPrev->pData:NULL;
}

void CDakComPtrList::RemoveAll(void)
{
	ReleaseArr();
}


long CDakComPtrList::GetCount(void)
{
	long nReturn=0;
	if(m_pArrPtrNode==NULL)
		return nReturn;
	LPPTRNODE pNodTemp=m_pArrPtrNode;
	if(pNodTemp==NULL)
		return nReturn;
	while(pNodTemp)
	{
		nReturn++;
		pNodTemp=pNodTemp->pNext;
	}
	return nReturn;
}

DAKPOSITION CDakComPtrList::Find(LPVOID searchValue,DAKPOSITION startAfter)
{
	DAKPOSITION posReturn=NULL;
	LPPTRNODE pNodTemp=m_pArrPtrNode;
	if(pNodTemp==NULL)
		return posReturn;
	while(pNodTemp!=NULL)
	{
		if(pNodTemp->pData==searchValue)
		{
			posReturn=(DAKPOSITION)pNodTemp;
			break;
		}
		pNodTemp=pNodTemp->pNext;
	}	
	return posReturn;
}


BOOL CDakComPtrList::IsEmpty(void)
{
	long nNodeCount=GetCount();
	if(nNodeCount<=0)
		ReleaseArr();
	if(m_pArrPtrNode==NULL)
		return TRUE;
	return FALSE;
}