objectspool.h

one template to manage objects alloc ans fr

			//	pNode->data.~T();
				::DestructObject(&(pNode->data));
				m_LstCount --;
				return ;
			}
			return ;
		}
		void RemoveTail()
		{
			LPNODE pNode = m_LstTail;
			if(pNode)
			{
				if(pNode == m_LstHead)
				{
					//只有一个节点
					m_LstHead = 0;
					m_LstTail = 0;
				}
				else
				{
					m_LstTail = pNode->lpPre_Lst;
					m_LstTail->lpNext_Lst = 0;
				}
				pNode->bInUse = false;
		//		pNode->data.~T();
				::DestructObject(&(pNode->data));
				m_LstCount --;
				return ;
			}
			return ;
		}
		void RemoveAll()
		{
			LPNODE pNode = m_LstHead;
			if(pNode && pNode == m_LstTail)
			{
				m_LstHead = 0;
				m_LstTail = 0;
				pNode->bInUse = false;
			//	pNode->data.~T();
				::DestructObject(&(pNode->data));
				m_LstCount --;
				return;
			}
			while(pNode)
			{
				pNode->bInUse = false;
			//	pNode->data.~T();
				::DestructObject(&(pNode->data));
				m_LstCount --;
				pNode = pNode->lpNext_Lst;
			}
			m_LstHead = 0;
			m_LstTail = 0;
		}
		void FreeAll()
		{
			RemoveAll();
			LPNODE pNode = m_SpoolHead;
			while(pNode)
			{
				LPNODE pTmp = pNode->lpNext_Spool;
				::DestructObject(&(pNode->data));
				free(pNode);
				m_SpoolCount --;
				pNode = pTmp;
			}
			m_SpoolHead = 0;
			m_SpoolTail = 0;
		}
		LPTPOS GetHeadPosition() const
		{return (LPTPOS)m_LstHead;}
		LPTPOS GetTailPosition() const
		{return (LPTPOS)m_LstTail;}
		T& GetNext(LPTPOS& rPosition)
		{
			LPNODE pNode = (LPNODE)rPosition;
			rPosition = (LPTPOS)pNode->lpNext_Lst;
			return pNode->data;
		}
		T GetNext(LPTPOS& rPosition) const
		{
			LPNODE pNode = (LPNODE)rPosition;
			rPosition = (LPTPOS)pNode->lpNext_Lst;
			return pNode->data;
		}
		T& GetPrev(LPTPOS& rPosition)
		{
			LPNODE pNode = (LPNODE)rPosition;
			rPosition = (LPTPOS)(pNode->lpPre_Lst);
			return pNode->data;
		}
		T GetPrev(LPTPOS& rPosition) const
		{
			LPNODE pNode = (LPNODE)rPosition;
			rPosition = (LPTPOS)(pNode->lpPre_Lst);
			return pNode->data;
		}
		// getting/modifying an element at a given position
		T& GetAt(LPTPOS position)
		{
			return ((LPNODE)position)->data;
		}
		T GetAt(LPTPOS position) const
		{
			return ((LPNODE)position)->data;
		}
		void SetAt(LPTPOS position, const T &newElement)
		{
			LPNODE pNode = (LPNODE)position;
			pNode->data.~T();
		//	new(&((LPNODE)rPosition->data)) T;
			::ConstructObject(&(pNode->data));
			pNode->data = newElement;
		}
		void RemoveAt(LPTPOS position)
		{
			LPNODE pNode = (LPNODE)position;
			LPNODE pPre = pNode->lpPre_Lst,
				   pNext = pNode->lpNext_Lst;
		//	pNode->data.~T();
			::DestructObject(&(pNode->data));
			pNode->bInUse = false;
			if(pNode == m_LstHead && pNode == m_LstTail)
			{m_LstHead = 0;m_LstTail = 0;m_LstCount --;}
			else if(pNode == m_LstHead)
			{m_LstHead = pNext;m_LstHead->lpPre_Lst = 0;m_LstCount --;}
			else if(pNode == m_LstTail)
			{m_LstTail = pPre;m_LstTail->lpNext_Lst = 0;m_LstCount --;}
			else
			{
				if(pPre)
					pPre->lpNext_Lst = pNext;
				if(pNext)
					pNext->lpPre_Lst = pPre;
				m_LstCount --;
			}
		
		}
		// inserting before or after a given position
		LPTPOS InsertBefore(LPTPOS position, const T &newElement)
		{
			LPNODE pNode = (LPNODE)position,pNewItem = 0;
			if(pNode)
			{
				if(pNode == m_LstHead)
				{
					return AddHead(newElement);
				}
				else
				{
					if(!(pNewItem = AllocNodeFromSpool(pNode))) return 0;
					LPNODE pPre = pNode->lpPre_Lst;
					::ConstructObject(&(pNewItem->data));
					pNewItem->data = newElement;
					//pNodePre<-pNewItem->pNode
					pNewItem->lpPre_Lst = pNode->lpPre_Lst;
					pNewItem->lpNext_Lst = pNode;
					//pNodePre->pNewItem
					if(pPre) pPre->lpNext_Lst = pNewItem;
					//pNewItem<-pNode
					pNode->lpPre_Lst = pNewItem;
					m_LstCount ++;
					return (LPTPOS)pNewItem;
				}
			}
			return 0;
		}
		LPTPOS InsertAfter(LPTPOS position, const T &newElement)
		{
			LPNODE pNode = (LPNODE)position,pNewItem = 0;
			if(pNode)
			{
				if(pNode == m_LstTail)
				{
					return AddTail(newElement);
				}
				else
				{
					if(!(pNewItem = AllocNodeFromSpool(pNode))) return 0;
					LPNODE pNext = pNode->lpNext_Lst;
					::ConstructObject(&(pNewItem->data));
					pNewItem->data = newElement;
					//pNode<-pNewItem->pNodeNext
					pNewItem->lpPre_Lst = pNode;
					pNewItem->lpNext_Lst = pNode->lpNext_Lst;
					//pNewItem<-pNodeNext
					if(pNext) pNext->lpPre_Lst = pNewItem;
					//pNode->pNewItem
					pNode->lpNext_Lst = pNewItem;
					m_LstCount ++;
					return (LPTPOS)pNewItem;
				}
			}
			return 0;
		}
protected:
	LPNODE AllocNodeFromSpool(LPNODE pStart)
	{
		if(!pStart) pStart = m_SpoolHead;
		LPNODE pLeft = pStart->lpPre_Spool,
			   pRight = pStart->lpNext_Spool,
			   pReturn = 0;
		while(1)
		{
			if(!pLeft && !pRight)
				break;
			if(pLeft)
			{
				if(!pLeft->bInUse)
				{
					pReturn = pLeft;
					break;
				}
				pLeft = pLeft->lpPre_Spool;
			}
			if(pRight)
			{
				if(!pRight->bInUse)
				{
					pReturn = pRight;
					break;
				}
				pRight = pRight->lpNext_Spool;
			}
		}
		if(!pReturn)
		{
			if(!(pReturn = (LPNODE)malloc(sizeof(NODE)))) return 0;
			::ConstructObject(pReturn);
			pReturn->lpPre_Spool = m_SpoolTail;
			pReturn->lpNext_Spool = 0;
			m_SpoolTail->lpNext_Spool = pReturn;
			m_SpoolTail = pReturn;
			m_SpoolCount ++;
		}
		pReturn->bInUse = true;
		return pReturn;
	}
	LPNODE AllocNodeFromSpool_Ex(LPNODE pStart)
	{
		LPNODE pLeft = NULL,
			   pRight = NULL,
			   pReturn = NULL;
		if(!m_SpoolHead)   //判断池中是否为空
		{
			//为空，申请创建节点对象
			if(!(m_SpoolHead = (LPNODE)malloc(sizeof(NODE)))) return 0;
			::ConstructObject(m_SpoolHead);
			m_SpoolTail = m_SpoolHead;
			m_SpoolHead->bInUse = true;
			m_SpoolCount ++;
			return m_SpoolHead;
		}
		if(!pStart)
		{
			pLeft = m_SpoolTail;
			pRight = m_SpoolHead;
		}
		else
		{
			pLeft = pStart->lpPre_Spool;
			pRight = pStart->lpNext_Spool;
		}
#ifdef _DEBUG
		int i=0;
#endif
		while(1)
		{
#ifdef _DEBUG
			i ++;
#endif
			if(!pLeft && !pRight)
				break;
			if(pLeft)
			{
				if(!pLeft->bInUse)
				{
					pReturn = pLeft;
					break;
				}
				pLeft = pLeft->lpPre_Spool;
			}
			if(pRight)
			{
				if(!pRight->bInUse)
				{
					pReturn = pRight;
					break;
				}
				pRight = pRight->lpNext_Spool;
			}
		}
		if(!pReturn)
		{
			if(!(pReturn = (LPNODE)malloc(sizeof(NODE)))) return 0;
			::ConstructObject(pReturn);
			pReturn->lpPre_Spool = m_SpoolTail;
			pReturn->lpNext_Spool = 0;
			m_SpoolTail->lpNext_Spool = pReturn;
			m_SpoolTail = pReturn;
			m_SpoolCount ++;
		}
		pReturn->bInUse = true;
		return pReturn;
	}
};
template <class T> 
class CDataPipe_BeltList
{
public:
	CDataPipe_BeltList(){}
	virtual ~CDataPipe_BeltList(){}
protected:
	CBeltList< T > m_pipe;
	CSynMutex m_Mutex;
	CSynSamphare m_SamPhare;
public:
	bool AddData( const T &data)
	{
		m_Mutex.Lock();
		m_pipe.AddTail( data );
		m_SamPhare.AddUse();
		m_Mutex.UnLock();
		return true;
	}
	bool GetData(T &dataRet)
	{
RETRY:
		m_SamPhare.WaitUse();
		m_Mutex.Lock();
		if(m_pipe.GetLstCount() <= 0)
		{
			m_Mutex.UnLock();
			goto RETRY;
		}
		dataRet = m_pipe.GetHead();
		m_pipe.RemoveHead();
		m_Mutex.UnLock();
		return true;
	}
};
template <class T> 
class CDataPipe_BeltList_Ex
{
public:
	CDataPipe_BeltList_Ex(){}
	virtual ~CDataPipe_BeltList_Ex(){}
protected:
	CBeltList< T > m_pipe;
	CSynMutex m_Mutex;
	CSynSamphare m_Sema;
public:
	bool AddData( T *Arydata,int iArySize)
	{
		m_Mutex.Lock();
		for(int i=0;i<iArySize;i++)
		{
			m_pipe.AddTail( Arydata[i] );
		}
		m_Sema.AddUse();
		m_Mutex.UnLock();
		return true;
	}
	bool GetData(T *AryGet,int iArySize,int &iGetCount,int &iListCount,int &iSpoolCount)
	{
RETRY:
		m_Sema.WaitUse();
		m_Mutex.Lock();
		int iGet = iArySize,i = 0;
		iGetCount = 0;
		int iAll = m_pipe.GetLstCount();
		if(iAll <= 0)
		{
			m_Mutex.UnLock();
			goto RETRY;
		}
		if(iGet > iAll)
			iGet = iAll;
		T *pEnd = AryGet;
		LPTPOS pos = m_pipe.GetHeadPosition(),pos2 = NULL;
		while(pos)
		{
			pos2 = pos;
			T &item = m_pipe.GetNext(pos);
			i ++;
			if(i > iGet)
			{
				i --;
				break;
			}
			else
			{
				*pEnd = item;
				pEnd ++;
				m_pipe.RemoveAt(pos2);
			}
		}
		iGetCount = i;
		iListCount = m_pipe.GetLstCount();
		iSpoolCount = m_pipe.GetSpoolCount();
		int iSemaVal = m_Sema.GetCurtvalue();
		for(int j=0;j<iSemaVal;j++)
		{
			m_Sema.TryWaitUse();
		}
		m_Mutex.UnLock();
		return true;
	}
};
#endif