用来序列化通用的数据类型

/***********************************************************

版权声明：

文 件 名： cstandardserialize.cpp

创 建 人：

创建日期：

说 明： 用来序列化通用的数据类型

版 本 号：

修改记录： 防止内存越界

***********************************************************/

#include "stdafx.h"

#include "StandardSerialize.h"

CStandardSerialize::CStandardSerialize(char * apBuffer,long alBufLen, ENUM_TYPE abyType)

{

mpBuffer = apBuffer;

mbyType = abyType;

mlBufLen = alBufLen;

mlDataLen = 0;

}

CStandardSerialize::~CStandardSerialize()

{

}

long CStandardSerialize::getDataLen()

{

return mlDataLen;

}

int CStandardSerialize::Serialize(bool& abValue)

{

if (mlBufLen < (mlDataLen+1))

throw(-1);

if (mbyType == LOAD)//读取

{

memcpy(&abValue,mpBuffer + mlDataLen, 1);

}

else //存储

{

memcpy(mpBuffer + mlDataLen, &abValue, 1);

}

mlDataLen += 1;

return 1;

}

int CStandardSerialize::Serialize(int& aiValue)

{

if (mlBufLen < (mlDataLen+4))

throw(-1);

if (mbyType == LOAD)//读取

{

memcpy(&aiValue,mpBuffer + mlDataLen, 4);

}

else //存储

{

memcpy(mpBuffer + mlDataLen, &aiValue, 4);

}

mlDataLen += 4;

return 1;

}

int CStandardSerialize::Serialize(BYTE& abyValue)

{

if (mlBufLen < (mlDataLen+1))

throw(-1);

if (mbyType == LOAD)//读取

{

memcpy(&abyValue,mpBuffer + mlDataLen, 1);

}

else //存储

{

memcpy(mpBuffer + mlDataLen, &abyValue, 1);

}

mlDataLen += 1;

return 1;

}

/****************************************************************

函 数 名：int Serialize(short& asValue);

功能描述：序列化WORD类型的值

输入参数：WORD awValue(既可以作为输入，也可以作为输出)

输出参数：

返 回 值：int 1=成功；－1＝失败(throw，有外部捕获)

创建日期：2002-5-27

创 建 者：Siwen

****************************************************************/

int CStandardSerialize::Serialize(short& asValue)

{

if (mlBufLen < (mlDataLen+2))

throw(-1);

if (mbyType == LOAD)//读取

{

memcpy(&asValue,mpBuffer + mlDataLen, 2);

}

else //存储

{

memcpy(mpBuffer + mlDataLen, &asValue, 2);

}

mlDataLen += 2;

return 1;

}

int CStandardSerialize::Serialize(WORD& awValue)

{

if (mlBufLen < (mlDataLen+2))

throw(-1);

if (mbyType == LOAD)//读取

{

memcpy(&awValue,mpBuffer + mlDataLen, 2);

}

else //存储

{

memcpy(mpBuffer + mlDataLen, &awValue, 2);

}

mlDataLen += 2;

return 1;

}

int CStandardSerialize::Serialize(long& alValue)

{

if (mlBufLen < (mlDataLen+4))

throw(-1);

if (mbyType == LOAD)//读取

{

memcpy(&alValue,mpBuffer + mlDataLen, 4);

}

else //存储

{

memcpy(mpBuffer + mlDataLen, &alValue, 4);

}

mlDataLen += 4;

return 1;

}

int CStandardSerialize::Serialize(unsigned long& aulValue)

{

if (mlBufLen < (mlDataLen+4))

throw(-1);

if (mbyType == LOAD)//读取

{

memcpy(&aulValue,mpBuffer + mlDataLen, 4);

}

else //存储

{

memcpy(mpBuffer + mlDataLen, &aulValue, 4);

}

mlDataLen += 4;

return 1;

}

int CStandardSerialize::Serialize(__int64& aiValue)

{

if (mlBufLen < (mlDataLen+8))

throw(-1);

if (mbyType == LOAD)//读取

{

memcpy(&aiValue,mpBuffer + mlDataLen, 8);

}

else //存储

{

memcpy(mpBuffer + mlDataLen, &aiValue, 8);

}

mlDataLen += 8;

return 1;

}

/*

int CStandardSerialize::Serialize(GUID& aGuidValue)

{

if (mlBufLen < (mlDataLen+16))

throw(-1);

if (mbyType == LOAD)//读取

{

long * lpLongBuffer;

WORD * lpWordBuffer;

lpLongBuffer = (long *)(mpBuffer + mlDataLen);

aGuidValue.Data1 = lpLongBuffer[0];

mlDataLen += 4;

lpWordBuffer = (WORD *)(mpBuffer + mlDataLen);

aGuidValue.Data2 = lpWordBuffer[0];

mlDataLen += 2;

lpWordBuffer = (WORD *)(mpBuffer + mlDataLen);

aGuidValue.Data3 = lpWordBuffer[0];

mlDataLen += 2;

memcpy(aGuidValue.Data4, mpBuffer+mlDataLen, 8);

mlDataLen += 8;

}

else //存储

{

memcpy(mpBuffer + mlDataLen, &(aGuidValue.Data1), 4);

mlDataLen += 4;

memcpy(mpBuffer+mlDataLen, &(aGuidValue.Data2), 2);

mlDataLen += 2;

memcpy(mpBuffer+mlDataLen, &(aGuidValue.Data3), 2);

mlDataLen += 2;

memcpy(mpBuffer + mlDataLen, aGuidValue.Data4, 8);

mlDataLen += 8;

}

return 1;

}

*/

//*****************************************************************************

// 函数： 序列化以0结尾的字符串数据

// 参数： char * apValue 字符串数据

// WORD awBufferLen 容纳此字符串数据的缓存区大小

// 返回值：int 1= 成功； -1 = 失败

// 用法：

//*****************************************************************************

int CStandardSerialize::Serialize(char * apValue,WORD awMaxLen)

{

if (mlBufLen < (mlDataLen+2))

throw(-1);

WORD lwLen = 0;

if (mbyType == LOAD) //读取

{

//首先读取长度

memcpy(&lwLen,mpBuffer + mlDataLen, 2);

mlDataLen += 2;

//读取数据本身

if ((lwLen >= awMaxLen) || ((mlDataLen+lwLen) > mlBufLen))

{

throw(-1);

}

memcpy(apValue, mpBuffer + mlDataLen, lwLen);

apValue[lwLen] = '\0';

mlDataLen += lwLen;

}

else //存储

{

//首先存储长度

lwLen = strlen(apValue);

if ((lwLen >= awMaxLen) || (lwLen+mlDataLen+2 > mlBufLen))

throw(-1);

memcpy(mpBuffer+mlDataLen, &lwLen, 2);

mlDataLen += 2;

//存储数据本身

memcpy(mpBuffer+mlDataLen, apValue, lwLen);

mlDataLen += lwLen;

}

return 1;

}

//*****************************************************************************

// 函数： 序列化数据

// 参数： char * apValue 数据

// WORD& awLen 此数据的真正长度

// WORD awBufferLen 容纳此数据的缓存区大小

// 返回值：int 1= 成功； -1 = 失败

// 用法：

//*****************************************************************************

int CStandardSerialize::Serialize(char * apValue, WORD awLen,WORD aiBufferLen)

{

if ((awLen > aiBufferLen) || (mlBufLen < (mlDataLen+awLen)))

throw (-1);

if (mbyType == LOAD) //读取

{

//因为外部制定了读取长度，所以不需要对数据长度进行序列化

memcpy(apValue, mpBuffer + mlDataLen, awLen);

}

else //存储数据本身

{

memcpy(mpBuffer+mlDataLen, apValue, awLen);

}

mlDataLen += awLen;

return 1;

}