datastorage.cpp

游戏框架

// ***************************************************************
//  DataStorage   version:  1.0
//  -------------------------------------------------------------
//	File Name:	DataStorage.cpp
//	Created:	2007/07/18
//	Modified:	2007/07/18   16:47
//	Author:		William.Liang
//  Msn:		[e-mail]
//  Email:		[e-mail], [e-mail]
//	Description:
//
//	Purpose:	
//  -------------------------------------------------------------
//  license:
//
//  The contents of this file are subject to the Mozilla Public
//  License Version 1.1 (the "License"); you may not use this file
//  except in compliance with the License. You may obtain a copy
//  of the License at http://www.mozilla.org/MPL/ Software dis-
//  tributed under the License is distributed on an "AS IS" 
//  basis, WITHOUT WARRANTY OF ANY KIND, either express or im-
//  plied. See the License for the specific language governing
//  rights and limitations under the License.
//
//  The Initial Developer of the Original Code is William.Liang .
//  Copyright (C) 2007 - All Rights Reserved.
// ***************************************************************
#include "StdAfx.h"
#include "DataStorage.h"

//////////////////////////////////////////////////////////////////////////

//************************************
// <p>Description: 构造函数</p>
//************************************
CDataStorage::CDataStorage(void)
{
	m_dwDataSize=0;
	m_dwBufferSize=0;
	m_dwInsertPos=0;
	m_dwTerminalPos=0;
	m_dwDataQueryPos=0;
	m_dwDataPacketCount=0;
	m_pDataStorageBuffer=NULL;
}

//************************************
// <p>Description: 析构函数</p>
//************************************
CDataStorage::~CDataStorage(void)
{
	SafeDeleteArray(m_pDataStorageBuffer);
	return;
}

//************************************
// <p>Description: 负荷信息</p>
// <p>Parameters:  </p>
// <p>    tagBurthenInfo & BurthenInfo</p>
//
// <p>Returns:   bool</p>
//************************************
bool CDataStorage::GetBurthenInfo(tagBurthenInfo & BurthenInfo)
{
	//设置变量
	BurthenInfo.dwDataSize=m_dwDataSize;
	BurthenInfo.dwBufferSize=m_dwBufferSize;
	BurthenInfo.dwDataPacketCount=m_dwDataPacketCount;

	return true;
}

//************************************
// <p>Description: 插入数据</p>
// <p>Parameters:  </p>
// <p>    WORD wIdentifier</p>
// <p>    void * const pBuffer</p>
// <p>    WORD wDataSize</p>
//
// <p>Returns:   bool</p>
//************************************
bool CDataStorage::AddData(WORD wIdentifier, void * const pBuffer, WORD wDataSize)
{
	//初始化数据
	tagDataHead DataHead;
	DataHead.wDataSize=wDataSize;
	DataHead.wIdentifier=wIdentifier;
	DataHead.dwInsertTime=(DWORD)time(NULL)/1000L;
	DWORD dwCopySize=sizeof(DataHead)+wDataSize;

	bool	bMustAllocMemory = false;
	try{
		if ((m_dwDataSize+dwCopySize)>m_dwBufferSize) bMustAllocMemory = true;
		else if ((m_dwInsertPos==m_dwTerminalPos)&&((m_dwInsertPos+dwCopySize)>m_dwBufferSize)) 
		{
			if (m_dwDataQueryPos>=dwCopySize) m_dwInsertPos=0;
			else bMustAllocMemory = true;
		}
		else if ((m_dwInsertPos<m_dwTerminalPos)&&((m_dwInsertPos+dwCopySize)>m_dwDataQueryPos)) bMustAllocMemory = true;
	}
	catch(...){
		return false;
	}

	if(bMustAllocMemory){
		try
		{
			//申请内存
			DWORD dwNewBufferSize=m_dwBufferSize+__max(m_dwBufferSize/2L,(wDataSize+sizeof(tagDataHead))*10L);
			BYTE * pNewQueueServiceBuffer=new BYTE [dwNewBufferSize];
			if (pNewQueueServiceBuffer==NULL) return false;

			//拷贝数据
			if (m_pDataStorageBuffer!=NULL) 
			{
				_ASSERT(m_dwTerminalPos>=m_dwDataSize);
				_ASSERT(m_dwTerminalPos>=m_dwDataQueryPos);
				DWORD dwPartOneSize=m_dwTerminalPos-m_dwDataQueryPos;
				if (dwPartOneSize>0L) CopyMemory(pNewQueueServiceBuffer,m_pDataStorageBuffer+m_dwDataQueryPos,dwPartOneSize);
				if (m_dwDataSize>dwPartOneSize) 
				{
					_ASSERT((m_dwInsertPos+dwPartOneSize)==m_dwDataSize);
					CopyMemory(pNewQueueServiceBuffer+dwPartOneSize,m_pDataStorageBuffer,m_dwInsertPos);
				}
			}

			//调整变量
			m_dwDataQueryPos=0L;
			m_dwInsertPos=m_dwDataSize;
			m_dwTerminalPos=m_dwDataSize;
			m_dwBufferSize=dwNewBufferSize;
			SafeDeleteArray(m_pDataStorageBuffer);
			m_pDataStorageBuffer=pNewQueueServiceBuffer;
		}
		catch (...) { return false; }
	}

	//try
	//{
	//	//效验缓冲区
	//	if ((m_dwDataSize+dwCopySize)>m_dwBufferSize) throw 0;
	//	else if ((m_dwInsertPos==m_dwTerminalPos)&&((m_dwInsertPos+dwCopySize)>m_dwBufferSize)) 
	//	{
	//		if (m_dwDataQueryPos>=dwCopySize) m_dwInsertPos=0;
	//		else throw 0;
	//	}
	//	else if ((m_dwInsertPos<m_dwTerminalPos)&&((m_dwInsertPos+dwCopySize)>m_dwDataQueryPos)) throw 0;
	//}
	//catch (...)
	//{
	//	try
	//	{
	//		//申请内存
	//		DWORD dwNewBufferSize=m_dwBufferSize+__max(m_dwBufferSize/2L,(wDataSize+sizeof(tagDataHead))*10L);
	//		BYTE * pNewQueueServiceBuffer=new BYTE [dwNewBufferSize];
	//		if (pNewQueueServiceBuffer==NULL) return false;

	//		//拷贝数据
	//		if (m_pDataStorageBuffer!=NULL) 
	//		{
	//			_ASSERT(m_dwTerminalPos>=m_dwDataSize);
	//			_ASSERT(m_dwTerminalPos>=m_dwDataQueryPos);
	//			DWORD dwPartOneSize=m_dwTerminalPos-m_dwDataQueryPos;
	//			if (dwPartOneSize>0L) CopyMemory(pNewQueueServiceBuffer,m_pDataStorageBuffer+m_dwDataQueryPos,dwPartOneSize);
	//			if (m_dwDataSize>dwPartOneSize) 
	//			{
	//				_ASSERT((m_dwInsertPos+dwPartOneSize)==m_dwDataSize);
	//				CopyMemory(pNewQueueServiceBuffer+dwPartOneSize,m_pDataStorageBuffer,m_dwInsertPos);
	//			}
	//		}

	//		//调整变量
	//		m_dwDataQueryPos=0L;
	//		m_dwInsertPos=m_dwDataSize;
	//		m_dwTerminalPos=m_dwDataSize;
	//		m_dwBufferSize=dwNewBufferSize;
	//		SafeDeleteArray(m_pDataStorageBuffer);
	//		m_pDataStorageBuffer=pNewQueueServiceBuffer;
	//	}
	//	catch (...) { return false; }
	//}

	try
	{
		//拷贝数据
		CopyMemory(m_pDataStorageBuffer+m_dwInsertPos,&DataHead,sizeof(DataHead));
		if (wDataSize>0) 
		{
			_ASSERT(pBuffer!=NULL);
			CopyMemory(m_pDataStorageBuffer+m_dwInsertPos+sizeof(DataHead),pBuffer,wDataSize);
		}

		//调整数据
		m_dwDataPacketCount++;
		m_dwDataSize+=dwCopySize;
		m_dwInsertPos+=dwCopySize;
		m_dwTerminalPos=__max(m_dwTerminalPos,m_dwInsertPos);

		return true;
	}
	catch (...) { }

	return false;
}

//************************************
// <p>Description: 获取数据</p>
// <p>Parameters:  </p>
// <p>    tagDataHead & DataHead</p>
// <p>    void * pBuffer</p>
// <p>    WORD wBufferSize</p>
//
// <p>Returns:   bool</p>
//************************************
bool CDataStorage::GetData(tagDataHead & DataHead, void * pBuffer, WORD wBufferSize)
{
	//效验变量
	_ASSERT(m_dwDataSize>0L);
	_ASSERT(m_dwDataPacketCount>0);
	_ASSERT(m_pDataStorageBuffer!=NULL);
	if (m_dwDataSize==0L) return false;
	if (m_dwDataPacketCount==0L) return false;

	//调整参数
	if (m_dwDataQueryPos==m_dwTerminalPos)
	{
		m_dwDataQueryPos=0L;
		m_dwTerminalPos=m_dwInsertPos;
	}

	//获取数据指针
	_ASSERT(m_dwBufferSize>=(m_dwDataQueryPos+sizeof(tagDataHead)));
	// 由m_dwDataQueryPos控制，返回指定位置的起始指针
	tagDataHead * pDataHead=(tagDataHead *)(m_pDataStorageBuffer+m_dwDataQueryPos);
	_ASSERT(wBufferSize>=pDataHead->wDataSize);

	//获取包大小
	WORD wPacketSize=sizeof(DataHead)+pDataHead->wDataSize;
	_ASSERT(m_dwBufferSize>=(m_dwDataQueryPos+wPacketSize));

	//判断缓冲
	WORD wCopySize=0;
	_ASSERT(wBufferSize>=pDataHead->wDataSize);
	if (wBufferSize>=pDataHead->wDataSize) wCopySize=pDataHead->wDataSize;

	//拷贝数据
	DataHead=*pDataHead;
	if (DataHead.wDataSize>0)
	{
		if (wBufferSize<pDataHead->wDataSize) DataHead.wDataSize=0;
		// 拷贝数据队列中的当前项的数据缓冲（pDataHead+1为排除数据项头说明的偏移）至返回缓冲区
		else CopyMemory(pBuffer,pDataHead+1,DataHead.wDataSize);
	}

	//效验参数
	_ASSERT(wPacketSize<=m_dwDataSize);
	_ASSERT(m_dwBufferSize>=(m_dwDataQueryPos+wPacketSize));

	//设置变量
	m_dwDataPacketCount--;
	m_dwDataSize-=wPacketSize;
	m_dwDataQueryPos+=wPacketSize;

	return true;
}

//************************************
// <p>Description: 删除数据</p>
// <p>Parameters:  </p>
// <p>    bool bFreeMemroy</p>
//
// <p>Returns:   void</p>
//************************************
void CDataStorage::RemoveData(bool bFreeMemroy)
{
	//设置变量
	m_dwDataSize=0;
	m_dwInsertPos=0;
	m_dwTerminalPos=0;
	m_dwDataQueryPos=0;
	m_dwDataPacketCount=0;

	//删除内存
	if (bFreeMemroy==true) 
	{
		m_dwBufferSize=0;
		SafeDeleteArray(m_pDataStorageBuffer);
	}

	return;
}

//////////////////////////////////////////////////////////////////////////