objectspool.h

one template to manage objects alloc ans fr

//ObjectSpool.h
#ifndef _TEMPLATE_OptionalQueueLst_Ex_8857546436374443243u
#define _TEMPLATE_OptionalQueueLst_Ex_8857546436374443243u
//#include <new.h>
//#include <io.h>
//#include <fcntl.h>
#include "SynMutex.h"
#include "SynSamphare.h"
//#define OBJECT_SPOOL_OPTION_LARGEMEMREQUEST
template<class TYPE>
inline void ConstructObject(TYPE* pElements)
{
	// first do bit-wise zero initialization
//	memset((void*)pElements, 0, sizeof(TYPE));

	// then call the constructor(s)
	::new((void*)pElements) TYPE;
}
template<class TYPE>
inline void DestructObject(TYPE* pElements)
{
	pElements->~TYPE();
}
template <class T> 
class ObjectsSpool
{
	public:
		ObjectsSpool(){m_ptrBase = 0;m_iObjectCount = 0;}
		virtual ~ObjectsSpool(){}
	protected:
		typedef struct _tagObjNode
		{
			public:
				_tagObjNode(){bInUse = false;lpNext = 0;}
				~_tagObjNode()
				{
					bInUse = false;
				}
			public:
				T					tObject;
				bool				bInUse;
				_tagObjNode			*lpNext;
		} OBJNODE, *LPOBJNODE;
		LPOBJNODE      m_ptrBase;
		unsigned long  m_iObjectCount;
	//	void * m_WRMutex;
	public:
		unsigned long GetObjectCount(){return m_iObjectCount;}
		void TraceBaseToEnd(unsigned long &ulSum,unsigned long &ulFree,unsigned long &ulUsed)
		{
			ulSum = 0;
			ulFree = 0;
			ulUsed = 0;
			unsigned long i = 0;
			LPOBJNODE pIdx = m_ptrBase;
			while(pIdx)
			{
				i ++;
				ulSum ++;
				if(pIdx->bInUse)
					ulUsed ++;
				else
					ulFree ++;
				pIdx = pIdx->lpNext;
			}
		}
	public:
		void FreeAll()
		{
			LPOBJNODE pIdx = m_ptrBase,pTmp;
			while(pIdx)
			{
				pTmp = pIdx;
				pIdx = pIdx->lpNext;
				delete pTmp;
			}
		}
		bool __new(T *tBuf[],unsigned int iCount,T *tCompare = 0)
		{
			bool bRet = _Obj_new(tBuf,iCount,tCompare);
			return bRet;
		}
		bool __delete(T *tBuf[],unsigned int iCount)
		{
			bool bRet = _Obj_delete(tBuf,iCount);
			return bRet;
		}
	protected:
		bool IsObjectInSpool(T *ptrObj,LPOBJNODE &ptrRet)
		{
			LPOBJNODE pIdx = m_ptrBase;
			while(pIdx)
			{
				if((&(pIdx->tObject) == ptrObj) && pIdx->bInUse)
				{
					ptrRet = pIdx;
					return true;
				}
				pIdx = pIdx->lpNext;
			}
			return false;
		}
		virtual bool _Obj_new(T *tBuf[],unsigned int iCount,T *tCompare = 0)
		{
			bool bRet = true;
			LPOBJNODE pIdx = m_ptrBase,pPreIdx = 0;
			unsigned int i = -1,j = 0;
			while(pIdx)
			{
				if(!pIdx->bInUse)
				{
					i++;
					if(i < iCount)
					{
						tBuf[i] = &(pIdx->tObject);
						//new(&(pIdx->tObject)) T;
						ConstructObject(&(pIdx->tObject));
						pIdx->bInUse = true;
						if(iCount == 1)
							return true;
					}
					else
						return true;
				}
				pPreIdx = pIdx;
				pIdx = pIdx->lpNext;
			}
			i ++;
			for(j = i; j < iCount; j ++)
			{
				LPOBJNODE pNode = new OBJNODE();
				if(!pNode){bRet = false;break;}
				pNode->bInUse = true;
				tBuf[j] = &(pNode->tObject);
				if(pPreIdx)
					pPreIdx->lpNext = pNode;
				else
					m_ptrBase = pNode;
				pPreIdx = pNode;
				m_iObjectCount ++;
			}
			if(!bRet)
			{
				for(i = 0; i < j ;i ++)
				{
					if(IsObjectInSpool(tBuf[i],pIdx))
					{
						pIdx->bInUse = false;
					}
				}
				return false;
			}
			return true;
		}
		virtual bool _Obj_delete(T *tBuf[],unsigned int iCount)
		{
			bool bRet = false;
			LPOBJNODE pIdx = 0;
			for(unsigned int i = 0; i < iCount ;i ++)
			{
				if(IsObjectInSpool(tBuf[i],pIdx))
				{
				//	pIdx->tObject.~T();
					DestructObject(&(pIdx->tObject));
					pIdx->bInUse = false;
					bRet = true;
				}
			}
			return bRet;
		}
};
typedef struct _tagPosition {} TPOSITION,*LPTPOS; 
template <class T> 
class CBeltList //链表
{
	public:
		CBeltList()
		{m_SpoolHead = 0;m_SpoolTail = 0;m_LstHead = 0;
		m_LstTail = 0;
		m_SpoolCount = 0;m_LstCount = 0;}
		~CBeltList(){}
	protected:
		typedef struct _tagNode
		{
			public:
				_tagNode()
				{bInUse = false;lpNext_Lst = 0;lpPre_Lst = 0;
				 lpNext_Spool = 0;lpPre_Spool = 0;}
				~_tagNode(){bInUse = false;}
			public:
				T			data;		//数据域
				bool		bInUse;     //标识节点是否空闲
				_tagNode	*lpNext_Lst;//标识当前节点的下一个节点
				_tagNode    *lpPre_Lst; //标识当前节点的前一个节点
				_tagNode    *lpNext_Spool;//标识对象池中当前对象的下一个对象
				_tagNode    *lpPre_Spool;//标识对象池中当前对象的前一个对象
		} NODE, *LPNODE;
		LPNODE   m_SpoolHead, m_SpoolTail; //对象池链的首尾指针 
		LPNODE   m_LstHead,m_LstTail;      //数据链的首尾指针
		int  m_SpoolCount,m_LstCount;      //对象池链的长度，数据链的长度
	public:
		int GetSpoolCount() const
		{return m_SpoolCount;}
		int GetLstCount() const
		{return m_LstCount;}
		bool IsSpoolEmpty() const
		{return (m_SpoolCount<=0);}
		bool IsLstEmpty() const
		{return (m_LstCount<=0);}
		LPTPOS AddHead(const T &newElement) //从头添加对象
		{
			/*
			if(!m_SpoolHead)   //判断池中是否为空
			{
			    //为空，申请创建节点对象
				if(!(m_SpoolHead = (LPNODE)malloc(sizeof(NODE)))) return 0;
				::ConstructObject(m_SpoolHead);
				m_SpoolTail = m_SpoolHead;
				m_LstHead = m_SpoolHead;
				m_LstTail = m_LstHead;
				//构造数据对象
				::ConstructObject(&(m_LstHead->data));
				m_LstHead->data = newElement;
				m_SpoolHead->bInUse = true;
				m_SpoolCount ++;
				m_LstCount ++;
				return (LPTPOS)m_SpoolHead;
			}
			else
			{
				//不空，则从池中搜索一空闲节点对象，将该对象
				//指针插入到数据链中。否则申请创建新的节点
				//对象，做池链的续尾操作和数据链的插入操作。
				LPNODE pNode = m_SpoolHead;
				while(pNode)
				{
					if(!pNode->bInUse)
					{
						::ConstructObject(&(pNode->data));
						pNode->data = newElement;
						pNode->bInUse = true;
						if(!m_LstHead)
						{
							pNode->lpPre_Lst = 0;
							pNode->lpNext_Lst = 0;
							m_LstHead = pNode;m_LstTail = pNode;
						}
						else
						{
							pNode->lpNext_Lst = m_LstHead;
							m_LstHead->lpPre_Lst = pNode;
							m_LstHead = pNode;
							pNode->lpPre_Lst = 0;
						}
						m_LstCount ++;
						return (LPTPOS)pNode;
					}
					pNode = pNode->lpNext_Spool;
				}
		//		if(!(pNode = new NODE)) return 0;
				if(!(pNode = (LPNODE)malloc(sizeof(NODE)))) return 0;
				::ConstructObject(pNode);
				pNode->lpNext_Spool = 0;
				pNode->lpPre_Spool = m_SpoolTail;
				m_SpoolTail->lpNext_Spool = pNode;
				m_SpoolTail = pNode;
				::ConstructObject(&(pNode->data));
				pNode->data = newElement;
				pNode->bInUse = true;
				pNode->lpNext_Lst = m_LstHead;
				m_LstHead->lpPre_Lst = pNode;
				m_LstHead = pNode;
				pNode->lpPre_Lst = 0;
				m_LstCount ++;
				m_SpoolCount ++;
				return (LPTPOS)pNode;
			}
			*/
			LPNODE pNode = AllocNodeFromSpool_Ex(NULL);
			if(!pNode) return 0;
			::ConstructObject(&(pNode->data));
			if(!m_LstHead)
			{
				pNode->lpPre_Lst = 0;
				pNode->lpNext_Lst = 0;
				m_LstHead = pNode;m_LstTail = pNode;
			}
			else
			{
				pNode->lpNext_Lst = m_LstHead;
				m_LstHead->lpPre_Lst = pNode;
				m_LstHead = pNode;
				pNode->lpPre_Lst = 0;
			}
			pNode->data = newElement;
			pNode->bInUse = true;
			m_LstCount ++;
			return (LPTPOS)pNode;
			
		}
		LPTPOS AddTail(const T &newElement)
		{
			/*
			if(!m_SpoolHead)
			{
		//		if(!(m_SpoolHead = new NODE)) return 0;
				if(!(m_SpoolHead = (LPNODE)malloc(sizeof(NODE)))) return 0;
				ConstructObject(m_SpoolHead);
				m_SpoolTail = m_SpoolHead;
				m_LstHead = m_SpoolHead;
				m_LstTail = m_LstHead;
				::ConstructObject(&(m_LstTail->data));
				m_LstTail->data = newElement;
				m_SpoolHead->bInUse = true;
				m_SpoolCount ++;
				m_LstCount ++;
				return (LPTPOS)m_SpoolHead;
			}
			else
			{
			/*	LPNODE pNode = m_SpoolTail;
				while(pNode)
				{
					if(!pNode->bInUse)
					{
				//		new (&pNode->data) T;
						::ConstructObject(&(pNode->data));
						pNode->data = newElement;
						pNode->bInUse = true;
						if(!m_LstTail)
						{
							pNode->lpPre_Lst = 0;
							pNode->lpNext_Lst = 0;
							m_LstHead = pNode;m_LstTail = pNode;
						}
						else
						{
							pNode->lpNext_Lst = 0;
							pNode->lpPre_Lst = m_LstTail;
							m_LstTail->lpNext_Lst = pNode;
							m_LstTail = pNode;
						}
						m_LstCount ++;
						return (LPTPOS)pNode;
					}
					pNode = pNode->lpPre_Spool;
				}
		//		if(!(pNode = new NODE)) return 0;
				if(!(pNode = (LPNODE)malloc(sizeof(NODE)))) return 0;
				::ConstructObject(pNode);
				pNode->lpNext_Spool = 0;
				pNode->lpPre_Spool = m_SpoolTail;
				m_SpoolTail->lpNext_Spool = pNode;
				m_SpoolTail = pNode;
			//	new (&pNode->data) T;
				::ConstructObject(&(pNode->data));
				pNode->data = newElement;
				pNode->bInUse = true;
				pNode->lpNext_Lst = 0;
				pNode->lpPre_Lst = m_LstTail;
				m_LstTail->lpNext_Lst = pNode;
				m_LstTail = pNode;
				m_LstCount ++;
				m_SpoolCount ++;
				return (LPTPOS)pNode;
			}
			*/
			LPNODE pNode = AllocNodeFromSpool_Ex(NULL);
			if(!pNode) return 0;
			::ConstructObject(&(pNode->data));
			if(!m_LstTail)
			{
				pNode->lpPre_Lst = 0;
				pNode->lpNext_Lst = 0;
				m_LstHead = pNode;m_LstTail = pNode;
			}
			else
			{
				pNode->lpNext_Lst = 0;
				pNode->lpPre_Lst = m_LstTail;
				m_LstTail->lpNext_Lst = pNode;
				m_LstTail = pNode;
			}
			pNode->data = newElement;
			pNode->bInUse = true;
			m_LstCount ++;
			return (LPTPOS)pNode;
		}
		T& GetHead()
		{return m_LstHead->data;}
		T GetHead() const
		{return m_LstHead->data;}
		T& GetTail()
		{return m_LstTail->data;}
		T GetTail() const
		{return m_LstTail->data;}
		void RemoveHead()
		{
			LPNODE pNode = m_LstHead;
			if(pNode)
			{
				if(pNode == m_LstTail)
				{
					//只有一个节点
					m_LstHead = 0;
					m_LstTail = 0;
				}
				else
				{
					m_LstHead = pNode->lpNext_Lst;
					m_LstHead->lpPre_Lst = 0;
				}
				pNode->bInUse = false;