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

/***********************************************************
版权声明：
文 件 名：  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] = '';
        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;
}