SDI (Sound Device Interface)--A library for Auditory Display

/******************************************************************************
SDI 1.0
    A library for Auditory Display
Copyright 2004 Dong Lin

This file is part of SDI.

    SDI is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    SDI is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with SDI; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

Last Updated : Apr.15th, 2004

For any question, suggestion or failure report, please contact me by:
e-mail: jonathan1983@126.com
*******************************************************************************/
/******************************************************************

File Name: utillib.cpp

Description:
	Implementation of link operation functions.
Note:


********************************************************************/

#include "Stdafx.h"
#include "utillib.h"

//////////////////////////////////////////////////////////////////////
BOOL listAddAfter(LISTHEADER* pCur, LISTHEADER* pNew)
{
	if(pCur==NULL || pNew==NULL)
		return FALSE;
	LISTHEADER* p;
	p=pCur->pNext;
	pCur->pNext=pNew;
	pNew->pNext=p;		// NULL, if pCur is at the tail
	pNew->pPrev=pCur;
	if(p != NULL)
		p->pPrev=pNew;
	return TRUE;
}

BOOL listAddBefore(LISTHEADER* pCur, LISTHEADER* pNew)
{
	if(pCur==NULL || pNew==NULL)
		return FALSE;
	LISTHEADER* p;
	p=pCur->pPrev;
	pCur->pPrev=pNew;
	pNew->pNext=pCur;
	pNew->pPrev=p;
	if(p != NULL)
		p->pNext=pNew;
	return TRUE;
}

BOOL listRemoveItem(LISTHEADER* pRemove)
{
	if(pRemove==NULL)
		return FALSE;
	if(pRemove->pPrev != NULL)	// Not Removing the head
		pRemove->pPrev->pNext=pRemove->pNext;
	if(pRemove->pNext != NULL)	// Not Removing the tail
		pRemove->pNext->pPrev=pRemove->pPrev;
	listInitHead(pRemove);
	return TRUE;
}

///////////////////////////////////////////////////////////////////
BOOL listInitHead(LISTHEADER* pHead)
{
	if(pHead==NULL)
		return FALSE;
	pHead->pNext=pHead->pPrev=NULL;
	return TRUE;
}

BOOL listDestroy(LISTHEADER* pHead)
{
	return TRUE;
}

//////////////////////////////////////////////////////////////////
BOOL listAddTail(LISTHEADER* pHead, LISTHEADER* pNew)
{
	if(pHead==NULL || pNew==NULL)
		return FALSE;
	LISTHEADER* p=pHead;
	while(NULL != p->pNext)
		p=p->pNext;
	listAddAfter(p,pNew);
	return TRUE;
}

LISTHEADER* listRemoveTail(LISTHEADER* pHead)
{
	if(pHead==NULL)
		return NULL;
	LISTHEADER *p=pHead, *t;
	while(p->pNext != NULL)
		p=p->pNext;
	t=p->pPrev;
	listRemoveItem(p);
	return t;
}
//////////////////////////////////////////////////////////////////

BOOL listAddHead(LISTHEADER* pHead, LISTHEADER* pNew)
{
	return listAddBefore(pHead,pNew);
}

LISTHEADER* listRemoveHead(LISTHEADER* pHead)
{
	LISTHEADER* p=pHead->pNext;
	listRemoveItem(pHead);
	return p;
}

///////////////////////////////////////////////////////////////////
ULONG listGetCount(LISTHEADER* pHead)
{
	if(pHead == NULL)
		return 0;
	LISTHEADER* p=pHead;
	ULONG n=0;
	while(p=p->pNext)
		n++;
	return n;
}

ULONG listGetIndexHead(LISTHEADER* pItem)
{
	ULONG n=0;
	LISTHEADER* p=pItem;
	while(p->pPrev != NULL)
	{
		p=p->pPrev;
		n++;
	}
	return n;
}
ULONG listGetIndexTail(LISTHEADER* pItem)
{
	ULONG n=0;
	LISTHEADER* p=pItem;
	while(p->pNext != NULL)
	{
		p=p->pNext;
		n++;
	}
	return n;
}

LISTHEADER* listGetHead(LISTHEADER* pItem)
{
	LISTHEADER* p=pItem;
	while(p->pPrev != NULL)
		p=p->pPrev;
	return p;
}

LISTHEADER* listGetTail(LISTHEADER* pItem)
{
	LISTHEADER* p=pItem;
	while(p->pNext != NULL)
		p=p->pNext;
	return p;
}

LISTHEADER* listGetItem(LISTHEADER* pHead, ULONG nIndex)
{
	ULONG n=0;
	LISTHEADER* p=pHead;
	while(p->pNext != NULL)
	{
		if(n==nIndex)
			break;
		p=p->pNext;
		n++;
	}
	return p;
}