myqueue.cpp

常用的队列类

/**************************************************************************************** 
 MyQueue.cpp: implementation of the CSIsmgInterface class.
  Lib         : GW4 Terminal_Module   
  Platform    : Solaris

  Written     : 2005/06	 wanggang
  Revision    : 1.0

  modify by   : huangchangyong
  modify date : 2007/12/11
  	
  Copyright (C) 2005 Sxit Co.Ltd                All rights reserved.
****************************************************************************************/

#include "MyQueue.h"

CQueueNode::CQueueNode(INT32 iSize)
{
	iNodeSize = iSize;
	nContent  = malloc(iNodeSize);
	this->prevNode = NULL;
	this->nextNode = NULL;	
}

CQueueNode::~CQueueNode()
{
	if(nContent != NULL)
	{
		free(nContent);
	}
	this->prevNode = NULL;
	this->nextNode = NULL;
}

CMyQueue::CMyQueue()
{
	m_qHeader   = NULL;
	m_qTailer   = NULL;
	m_iCurrSum  = 0;
	m_iMaxSum   = 0;
	m_iMemUsed  = 0;

	pthread_mutex_init(&m_lUsedMutex,NULL);
}

CMyQueue::~CMyQueue()
{
	RemoveAll();
	pthread_mutex_destroy(&m_lUsedMutex);
}

INT32 CMyQueue::RemoveAll()
{
	CQueueNode*  cTemp;
	pthread_mutex_lock(&m_lUsedMutex);
	while(this->m_qHeader != NULL)
	{
		cTemp = m_qHeader;
		m_qHeader = m_qHeader->nextNode;
		delete(cTemp);
	}
	m_qTailer	= NULL;
	pthread_mutex_unlock(&m_lUsedMutex);
	return 0;
}

INT32 CMyQueue::InitQueue(INT32 iMaxSum,INT32 iMaxSize)
{
	m_iMaxSum  = iMaxSum;
	m_iNodeSize = iMaxSize;
	return 0;
}

INT32 CMyQueue::GetFreeSum()
{
	return (this->m_iMaxSum - this->m_iCurrSum);
}

INT32 CMyQueue::GetUsedSum()
{
	return this->m_iCurrSum;
}

INT32 CMyQueue::InsertNode(void *nContent,INT32 iSize)
{	
	INT32 iNodeSize;

	if(m_iCurrSum >= m_iMaxSum)
		return -1;

	if(nContent == NULL||iSize <= 0)
		return -2;

	pthread_mutex_lock(&m_lUsedMutex);

	iNodeSize = iSize > m_iNodeSize ? m_iNodeSize : iSize;

	CQueueNode* cNode = new CQueueNode(iNodeSize);

	memset(cNode->nContent,0,iNodeSize);
	memcpy(cNode->nContent,nContent,iNodeSize);

	if(m_qHeader == NULL)
	{
		m_qHeader = cNode;		
		m_qTailer = cNode;
	}
	else
	{
		m_qTailer->nextNode = cNode;
		cNode->prevNode = m_qTailer;
		m_qTailer = m_qTailer->nextNode;
	}

	m_iCurrSum++;
	
	m_iMemUsed += iNodeSize;

	pthread_mutex_unlock(&m_lUsedMutex);

	return 0;
}

INT32 CMyQueue::InsertHead(void* nContent,INT32 iSize)
{
	INT32 iNodeSize;
	
	if(m_iCurrSum >= m_iMaxSum)
		return -1;
	
	if(nContent == NULL||iSize <= 0)
		return -2;
	
	pthread_mutex_lock(&m_lUsedMutex);
	
	iNodeSize = iSize > m_iNodeSize ? m_iNodeSize : iSize;
	
	CQueueNode* cNode = new CQueueNode(iNodeSize);
	
	memset(cNode->nContent, 0, iNodeSize);	
	memcpy(cNode->nContent, nContent, iNodeSize);
	
	if(m_qHeader == NULL)
	{
		m_qHeader = cNode;		
		m_qTailer = cNode;
	}
	else
	{
		cNode->nextNode = m_qHeader;
		m_qHeader->prevNode = cNode;
		m_qHeader = cNode;
	}
	
	m_iCurrSum++;
	
	m_iMemUsed += iNodeSize;
	
	pthread_mutex_unlock(&m_lUsedMutex);
	
	return 0;
}

INT32 CMyQueue::GetDelNode(void* nContent,INT32 iSize)
{
	INT32			iReturn;
	INT32			iNodeSize;
	CQueueNode*		cNode;

	if(nContent == NULL||iSize <= 0)
		return -1;

	pthread_mutex_lock(&m_lUsedMutex);

	if(m_qHeader == NULL)
	{
		iReturn = -2;
	}
	else
	{
		memset(nContent,0,iSize);

		iNodeSize = ((m_qHeader->iNodeSize > iSize) ? iSize : (m_qHeader->iNodeSize));
		
		memcpy(nContent, m_qHeader->nContent, iNodeSize);
		
		cNode = m_qHeader;
		if(m_qHeader == m_qTailer)
		{
			m_qHeader = NULL;
			m_qTailer = NULL;		
		}
		else
		{
			m_qHeader = m_qHeader->nextNode;
			m_qHeader->prevNode = NULL;
		}

		m_iMemUsed -= sizeof(cNode);

		delete( cNode );

		m_iCurrSum--;

		iReturn = 0;
	}

	pthread_mutex_unlock(&m_lUsedMutex);

	return iReturn ;
}

/*
INT32 CMyQueue::DeleteNode(CQueueNode* pNode,void* nContent,INT32 iSize)
{
	INT32	iReturn;
	CQueueNode* cHead;
    cHead = m_qHeader;
	if(pNode == NULL)
		return -1;

//	pthread_mutex_lock(&m_lUsedMutex);
	while(cHead != pNode&&cHead != NULL)
	{
		cHead = cHead->nextNode;
	}
	
	if(cHead == pNode)
	{
		memset(nContent,0,iSize);
		memcpy(nContent,cHead->nContent,iSize);
		if(cHead == m_qHeader)								//删除的是头节点
		{
			if(m_qHeader == m_qTailer)
			{
				m_qHeader = NULL;
				m_qTailer = NULL;
			}else
			{
				m_qHeader = m_qHeader->nextNode;
				m_qHeader->prevNode = NULL;
			}
		}
		else											   //如果删除的不是头节点
		{
			cHead = pNode->prevNode;
			cHead->nextNode = pNode->nextNode;

			if(pNode != m_qTailer)							//不是尾节点
			{
				cHead = pNode->nextNode;
				cHead->prevNode = pNode->prevNode;
			}
			else											//是尾节点	
			{		
				if(m_qHeader != m_qTailer)
					m_qTailer = cHead;
				else
				{
					m_qTailer = NULL;
					m_qHeader = NULL;
				}
			}
		}
		
		delete(pNode);
		this->m_iCurrSum--;
        this->m_qIterator = m_qHeader;
		iReturn = 0;
	}
	else if(cHead == NULL)
	{
		iReturn = -2;
	}
	else
	{
		iReturn = -3;
	}
//	pthread_mutex_unlock(&m_lUsedMutex);

	WriteClassLogFile(
						m_cCfgParam.sLogLevel,
						2,
						SYS_DEBUG_LOG_FLAG,
						"UMO Interface : SEQUENCE :SEQUENCE[%d]",
						iReturn
					);

	return iReturn;
}
*/