You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
232 lines
5.3 KiB
232 lines
5.3 KiB
#include <windows.h>
|
|
|
|
#include "list.h"
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Description:
|
|
// this implements a simple C++ list class routine that will let us build
|
|
// up a list of an arbitrary long number of items. An item can be any
|
|
// simple type or structure.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CList::CList()
|
|
{
|
|
m_pListHead=m_pListCurr=m_pListTail=NULL;
|
|
}
|
|
|
|
CList::~CList()
|
|
{
|
|
RemoveAll();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Description:
|
|
// Add an item to the list. The length of the item is assumed correct
|
|
// for the passed in item. Items are added to the end of the list.
|
|
//
|
|
// Arguments:
|
|
// pData - pointer to the data to add
|
|
// nBytes - the number of bytes of pData
|
|
//
|
|
// Returns: TRUE if the data is succesfully added, otherwise FALSE.
|
|
// a-anilk; Just donot absolutely Duplicate Entries
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
CList::Add(PVOID pData, UINT nBytes)
|
|
{
|
|
PLIST tmp;
|
|
|
|
if ((nBytes == 0) || (pData == NULL))
|
|
return FALSE;
|
|
|
|
tmp=new LIST;
|
|
|
|
if (NULL == tmp)
|
|
return FALSE;
|
|
|
|
tmp->pData=new BYTE[nBytes];
|
|
|
|
if (NULL == tmp->pData)
|
|
{
|
|
delete tmp;
|
|
return FALSE;
|
|
}
|
|
|
|
// Donot add duplicate entries that come one after another...
|
|
if ( m_pListHead != NULL )
|
|
{
|
|
if (! memcmp(m_pListHead->pData, pData, nBytes ) )
|
|
{
|
|
delete [] tmp->pData; // raid 113787
|
|
delete tmp;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
CopyMemory(tmp->pData,pData,nBytes);
|
|
|
|
tmp->nBytes=nBytes;
|
|
tmp->next=NULL;
|
|
tmp->prev=m_pListTail;
|
|
|
|
if (IsEmpty())
|
|
{
|
|
m_pListHead=tmp;
|
|
}
|
|
else
|
|
{
|
|
if (m_pListTail != NULL)
|
|
m_pListTail->next=tmp;
|
|
}
|
|
|
|
m_pListTail=tmp;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Description:
|
|
// Remove all the items from the list.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
CList::RemoveAll()
|
|
{
|
|
while(!IsEmpty())
|
|
RemoveHead(NULL);
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Description:
|
|
// Remove just the item at the head of the list. If the passed in buffer
|
|
// is not NULL, it will overwrite the buffer with the contents of the data.
|
|
// This code assumes the passed in pData buffer is large enough for the
|
|
// stored data item. If the passed in pData is NULL, then the head item
|
|
// is simply discarded.
|
|
//
|
|
// Arguments:
|
|
// pData - a buffer to overwrite with the head item. Can be NULL.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
CList::RemoveHead(PVOID pData)
|
|
{
|
|
PLIST tmp;
|
|
|
|
if (!IsEmpty())
|
|
{
|
|
// make sure m_pListCurr is always NULL or someplace valid
|
|
|
|
if (m_pListCurr == m_pListHead)
|
|
m_pListCurr=m_pListHead->next;
|
|
|
|
tmp=m_pListHead;
|
|
m_pListHead=m_pListHead->next;
|
|
|
|
if (tmp->pData != NULL)
|
|
{
|
|
if (pData != NULL)
|
|
CopyMemory(pData,tmp->pData,tmp->nBytes);
|
|
|
|
delete[] (tmp->pData);
|
|
}
|
|
|
|
delete tmp;
|
|
|
|
if (!IsEmpty())
|
|
m_pListHead->prev=NULL;
|
|
else
|
|
m_pListTail=NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Description:
|
|
// RemoveHead(NULL, NULL) <=> RemoveHead(NULL)
|
|
//
|
|
// RemoveHead(pData,NULL) <=> RemoveHead(pData)
|
|
//
|
|
// RemoveHead(NULL,&nBytes) - sets nBytes to the size of the data in the
|
|
// head of the list, nothing is removed
|
|
//
|
|
// RemoveHead(pData,&nBytes)- copies the data in the head of the list into
|
|
// pData up to the min of the size of data in the
|
|
// head of the list or nBytes. The head of the
|
|
// list is removed.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
CList::RemoveHead(PVOID pData, PUINT pnBytes)
|
|
{
|
|
PLIST tmp;
|
|
UINT nBytes;
|
|
|
|
if (pnBytes == NULL)
|
|
{
|
|
RemoveHead(pData);
|
|
return;
|
|
}
|
|
|
|
if (pData == NULL)
|
|
{
|
|
// they just want the size, so return it.
|
|
|
|
if (IsEmpty())
|
|
*pnBytes=0;
|
|
else
|
|
*pnBytes=m_pListHead->nBytes;
|
|
|
|
return;
|
|
}
|
|
|
|
if (IsEmpty())
|
|
{
|
|
*pnBytes=0;
|
|
return;
|
|
}
|
|
|
|
// make sure m_pListCurr is always NULL or someplace valid
|
|
|
|
if (m_pListCurr == m_pListHead)
|
|
m_pListCurr=m_pListHead->next;
|
|
|
|
tmp=m_pListHead;
|
|
m_pListHead=m_pListHead->next;
|
|
|
|
//
|
|
// only copy the min size of the two
|
|
//
|
|
|
|
nBytes=min((*pnBytes),tmp->nBytes);
|
|
|
|
if (tmp->pData != NULL)
|
|
{
|
|
CopyMemory(pData,tmp->pData,nBytes);
|
|
|
|
*pnBytes=nBytes;
|
|
|
|
delete[] (tmp->pData);
|
|
}
|
|
else
|
|
*pnBytes=0;
|
|
|
|
delete tmp;
|
|
|
|
if (!IsEmpty())
|
|
m_pListHead->prev=NULL;
|
|
else
|
|
m_pListTail=NULL;
|
|
}
|
|
|
|
|
|
|