tiddictionary.h

五行MMORPG引擎系统V1.0

//tIDDictionary.h
/*/////////////////////////////////////////////////////////////////

	Dictionary类模板
	Entry结构 需要符合
	{
		U32		dwID;		//必须
		Entry*	pHashNext;	//必须
		//...
	}

   李亦
	[e-mail] 4040719
	2006-7-18
/*/////////////////////////////////////////////////////////////////
#ifndef _TIDDICTIONARY_H_
#define _TIDDICTIONARY_H_



#ifndef _DATACHUNKER_H_
#include "core/dataChunker.h"
#endif

#ifndef _PLATFORM_H_
#include "platform/platform.h"
#endif


template<class _T>
class IDDictionary;


//////////////////////////////////////////
//字典条目
template<class _T>
struct IDDictionaryEntry
{
	friend class IDDictionary<_T>;
//private:
	_T			data;
	//U32		dwID;
	IDDictionaryEntry<_T>*	pHashNext;
};


//////////////////////////////////////////
//ID型字典管理
template<class _T>
class IDDictionary
{
protected:
	U32	m_dwAmount;		//单元总数

	
	U32							m_dwHashSize;
	IDDictionaryEntry<_T>	**m_pHashTable;

protected:
	static FreeListChunker< IDDictionaryEntry<_T> >		gs_gameChunker;

   //static void		FreeEntry(Entry *entry);
   //static Entry	*AllocEntry();


	void AddEntry(IDDictionaryEntry<_T>* pEntry);
	void IncAmount(); 
	void DecAmount(); 
	void Resize(const U32 newSize);

public:
   IDDictionary(U32 dwSize);
   ~IDDictionary();

	void FreeHashTable();

   _T*	Insert(U32 dwID);
   void	Remove(U32 dwID);
   _T*	Get(U32 dwID);
};



//////////////////////////////////////////////////////////////
//以下为模板实现

template<class _T>
FreeListChunker< IDDictionaryEntry<_T> >	IDDictionary<_T>::gs_gameChunker;


//////////////////////////////////////////
//template<class _T>
//inline IDDictionary<_T>::Entry *IDDictionary<_T>::AllocEntry()
//{
//   return gs_gameChunker.alloc();
//}


//template<class _T>
//inline void IDDictionary<_T>::FreeEntry(Entry *ent)
//{
//	gs_gameChunker.free(ent);
//}



////////////////////////////////////////////////
//构造/析构函数
template<class _T>
IDDictionary<_T>::IDDictionary(U32 dwSize)
{
	m_dwAmount	 = 0;
   m_pHashTable = NULL;
	m_dwHashSize = 0;
	
	Resize(dwSize);
}


template<class _T>
IDDictionary<_T>::~IDDictionary()
{
	FreeHashTable();
	dFree(m_pHashTable);
	m_dwAmount = 0;
}


template<class _T>
void IDDictionary<_T>::FreeHashTable()
{
	IDDictionaryEntry<_T>	*walk,
									*temp;

   for(U32 i = 0; i < m_dwHashSize; i++)
   {
      for(walk = m_pHashTable[i]; walk;)
      {
         temp = walk;
         walk = temp->pHashNext;
         gs_gameChunker.free(temp);
      }
		m_pHashTable[i] = NULL;
   }
}



template<class _T>
void  IDDictionary<_T>::AddEntry(IDDictionaryEntry<_T>* pEntry)
{
	if(pEntry == NULL)
		return;

	_T *field = pEntry;

	U32 bucket = pEntry->data.dwID % m_dwHashSize;
	field->pHashNext				= m_pHashTable[bucket];
	m_pHashTable[bucket] = field;
	
	IncAmount();
}


template<class _T>
void IDDictionary<_T>::IncAmount()
{
	m_dwAmount++;
	if(m_dwAmount > m_dwHashSize * 2)
	{
		Resize(m_dwHashSize*4 - 1);
	}
}


template<class _T>
void IDDictionary<_T>::Resize(const U32 newSize)
{
   IDDictionaryEntry<_T> *head = NULL, *walk, *temp;
   U32 i;
   U32 dwKey;

	if(m_pHashTable)
	{
		//先把数据备份起来
		for(i = 0; i < m_dwHashSize; i++) 
		{
			walk = m_pHashTable[i];
			while(walk)
			{
				temp = walk->pHashNext;
				walk->pHashNext = head;
				head = walk;
				walk = temp;
			}
		}

		//生成新的Hash空间
		m_pHashTable = (IDDictionaryEntry<_T> **) dRealloc(m_pHashTable, newSize * sizeof(IDDictionaryEntry<_T>*));
	}//if(m_pHashTable)
	else
	{	
		m_pHashTable	= (IDDictionaryEntry<_T> **) dMalloc(newSize * sizeof(IDDictionaryEntry<_T>*));
		head				= NULL;
	}


   for(i = 0; i < newSize; i++) 
	{
      m_pHashTable[i] = 0;
   }

	//重新关联单元
   m_dwHashSize	= newSize;
   walk				= head;
   while(walk) 
	{
      temp = walk;

      walk	= walk->pHashNext;
      dwKey	= temp->data.dwID % newSize;
      temp->pHashNext		= m_pHashTable[dwKey];
      m_pHashTable[dwKey]	= temp;
   }
}


template<class _T>
inline void IDDictionary<_T>::DecAmount()
{
	if(m_dwAmount > 0)
		m_dwAmount--;
}


template<class _T>
void IDDictionary<_T>::Remove(U32 dwID)
{
   //U32 bucket = HashPointer(slotName) % m_dwHashSize;
   U32 bucket = dwID % m_dwHashSize;
   IDDictionaryEntry<_T> **walk = &m_pHashTable[bucket];

   while(*walk && (*walk)->data.dwID != dwID)
      walk = &((*walk)->pHashNext);

   IDDictionaryEntry<_T> *field = *walk;
   if(field)
   {
      *walk = field->pHashNext;
      gs_gameChunker.free(field);
		DecAmount();
   }
   
}




template<class _T>
_T *IDDictionary<_T>::Get(U32 dwID)
{
   //U32 bucket = HashPointer(slotName) % m_dwHashSize;
   U32 bucket = dwID % m_dwHashSize;


   for(IDDictionaryEntry<_T> *walk = m_pHashTable[bucket];walk;walk = walk->pHashNext)
	{
		if(walk->data.dwID == dwID)
		{
			return &walk->data;
		}
	}
	return NULL;
}

template<class _T>
_T *IDDictionary<_T>::Insert(U32 dwID)
{
	_T*	pData = Get(dwID) ;
	if(pData != NULL)
		return pData;

   U32 bucket = dwID % m_dwHashSize;

	IDDictionaryEntry<_T>*	pNew;

	pNew					= gs_gameChunker.alloc();
	pNew->data.dwID			= dwID;
	pNew->pHashNext	= m_pHashTable[bucket];
	m_pHashTable[bucket]	= pNew;

	IncAmount();
	return &pNew->data;
}




#endif //_TIDDICTIONARY_H_