LosaDev source snapshot 2019
This commit is contained in:
LosaDev committed
commit
c198676e97
20588 files changed
+8812878
No files matched your search
@@ -0,0 +1,166 @@
|
||||
// QueryData.cpp: implementation of the CQueryData class.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "../stdafx.h"
|
||||
#include "cSerialize.h"
|
||||
#include "QueryData.h"
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Construction/Destruction
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
CQueryData::CQueryData()
|
||||
{
|
||||
memset( m_szReturnBuf, 0, sizeof( m_szReturnBuf ) );
|
||||
m_iReturnLength = 0;
|
||||
|
||||
m_pBuffer = NULL;
|
||||
CQuery::Clear();
|
||||
}
|
||||
|
||||
CQueryData::~CQueryData()
|
||||
{
|
||||
CQuery::Clear();
|
||||
}
|
||||
|
||||
void CQueryData::GetFields(cSerialize& fieldTypes)
|
||||
{
|
||||
if(GetFieldSize() == 0)
|
||||
return;
|
||||
|
||||
if(m_pBuffer)
|
||||
{
|
||||
uint32 index = sizeof(int);
|
||||
|
||||
fieldTypes.Reset();
|
||||
fieldTypes.SetBuffer( (uint8*)(m_pBuffer + index), GetFieldSize() );
|
||||
}
|
||||
}
|
||||
|
||||
void CQueryData::GetResults(vVALUETYPE& valueTypes)
|
||||
{
|
||||
valueTypes.clear();
|
||||
|
||||
if(GetResultSize() == 0)
|
||||
return;
|
||||
|
||||
if(m_pBuffer)
|
||||
{
|
||||
uint32 index = sizeof(int) + GetFieldSize();
|
||||
for(int32 n = 0 ; n < GetResultSize() ; n += sizeof(ValueType) )
|
||||
{
|
||||
ValueType* type = (ValueType*)(m_pBuffer + index + n);
|
||||
valueTypes.push_back( *type );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CQueryData::GetReturns(char* buffer, int &size)
|
||||
{
|
||||
if(m_pBuffer)
|
||||
{
|
||||
uint32 index = sizeof(int) + GetFieldSize() + GetResultSize();
|
||||
size = GetReturnSize();
|
||||
memcpy( buffer, m_pBuffer + index, size );
|
||||
}
|
||||
}
|
||||
|
||||
void CQueryData::SetReturnData( const void *pData, int iSize )
|
||||
{
|
||||
memcpy( &m_szReturnBuf[m_iReturnLength], pData, iSize );
|
||||
m_iReturnLength += iSize;
|
||||
|
||||
if( m_iReturnLength >= MAX_BUFFER )
|
||||
{
|
||||
//LOG.PrintTimeAndLog( 0, "CQueryData::SetReturnData Return Size : %d", m_iReturnLength );
|
||||
}
|
||||
}
|
||||
|
||||
void CQueryData::SetBuffer(const char *buffer)
|
||||
{
|
||||
memcpy(&m_queryHeader,buffer,sizeof(QueryHeader));
|
||||
buffer+= sizeof(QueryHeader);
|
||||
m_pBuffer = new char[m_queryHeader.nQueryBufferSize];
|
||||
memcpy(m_pBuffer,buffer,m_queryHeader.nQueryBufferSize);
|
||||
}
|
||||
|
||||
void CQueryData::SetBuffer(uint8 *buffer)
|
||||
{
|
||||
memcpy(&m_queryHeader,buffer,sizeof(QueryHeader));
|
||||
buffer+= sizeof(QueryHeader);
|
||||
m_pBuffer = new char[m_queryHeader.nQueryBufferSize];
|
||||
memcpy(m_pBuffer,buffer,m_queryHeader.nQueryBufferSize);
|
||||
}
|
||||
|
||||
void CQueryData::SetData(
|
||||
unsigned int nIndex,
|
||||
int nResult_Type,
|
||||
int nMsgType,
|
||||
int nQueryType,
|
||||
int queryId,
|
||||
cSerialize& fieldTypes,
|
||||
vVALUETYPE& valueTypes,
|
||||
int nSetValue)
|
||||
{
|
||||
CQuery::Clear();
|
||||
//헤더
|
||||
m_queryHeader.nIndex = nIndex;
|
||||
m_queryHeader.nResult_Type = nResult_Type;
|
||||
m_queryHeader.nMsgType = nMsgType;
|
||||
m_queryHeader.nQueryType = nQueryType;
|
||||
m_queryHeader.fieldLength = fieldTypes.GetLength();
|
||||
m_queryHeader.resultLength = sizeof(ValueType) * valueTypes.size();
|
||||
m_queryHeader.nValueTypeCnt = 0;
|
||||
m_queryHeader.returnLength = m_iReturnLength;
|
||||
m_queryHeader.nSetValue = nSetValue;
|
||||
m_queryHeader.queryId = queryId;
|
||||
m_queryHeader.databaseId = 1;
|
||||
m_queryHeader.nQueryBufferSize = sizeof(queryId) + m_queryHeader.fieldLength + m_queryHeader.resultLength + m_queryHeader.returnLength;
|
||||
|
||||
//버퍼 메모리 할당.
|
||||
if(m_queryHeader.nQueryBufferSize != 0)
|
||||
{
|
||||
m_pBuffer = new char[m_queryHeader.nQueryBufferSize];
|
||||
//데이터.
|
||||
int nSize = 0; //버퍼의 위치
|
||||
int nlen = 0;
|
||||
if(0 != queryId)
|
||||
{
|
||||
nlen = sizeof(queryId); //카피할 데이터 사이즈
|
||||
memcpy(&m_pBuffer[nSize], &queryId, nlen); //쿼리 내용
|
||||
}
|
||||
if(fieldTypes.GetLength() > 0)
|
||||
{
|
||||
nSize += nlen;
|
||||
nlen = m_queryHeader.fieldLength;
|
||||
memcpy(&m_pBuffer[nSize], fieldTypes.GetBuffer(), nlen); // 필드 타입
|
||||
}
|
||||
if(valueTypes.size() > 0)
|
||||
{
|
||||
nSize += nlen;
|
||||
nlen = m_queryHeader.resultLength;
|
||||
memcpy(&m_pBuffer[nSize], &valueTypes[0], nlen); // 결과 타입
|
||||
}
|
||||
if(m_iReturnLength > 0)
|
||||
{
|
||||
nSize += nlen;
|
||||
memcpy(&m_pBuffer[nSize], m_szReturnBuf, m_iReturnLength); //돌려받을 데이터.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CQueryData::Copy( CQueryData &queryData )
|
||||
{
|
||||
if(m_pBuffer)
|
||||
{
|
||||
delete []m_pBuffer;
|
||||
}
|
||||
|
||||
m_pBuffer = new char[queryData.GetBufferSize()];
|
||||
if(m_pBuffer)
|
||||
{
|
||||
m_queryHeader = queryData.m_queryHeader;
|
||||
memcpy( m_pBuffer, queryData.m_pBuffer, m_queryHeader.nQueryBufferSize );
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
#pragma once
|
||||
|
||||
#include "../network/Packet.h"
|
||||
|
||||
// 변수의 타입과 사이즈
|
||||
enum VariableType
|
||||
{
|
||||
vChar = 100,
|
||||
vWChar,
|
||||
vTimeStamp,
|
||||
vLONG,
|
||||
vINT64,
|
||||
vSHORT,
|
||||
vWrong
|
||||
};
|
||||
|
||||
struct ValueType
|
||||
{
|
||||
VariableType type; // 어떤 타입의 데이터인가
|
||||
int size; // 사이즈는?
|
||||
ValueType()
|
||||
{
|
||||
type = vWrong;
|
||||
size = 0;
|
||||
}
|
||||
};
|
||||
|
||||
typedef vector<ValueType> vVALUETYPE;
|
||||
|
||||
class cSerialize;
|
||||
|
||||
// CQuery의 헤더
|
||||
struct QueryHeader
|
||||
{
|
||||
QueryHeader()
|
||||
{
|
||||
nMsgType = -1;
|
||||
nQueryType = -1;
|
||||
fieldLength = 0;
|
||||
resultLength = 0;
|
||||
returnLength = -1;
|
||||
nValueTypeCnt = -1;
|
||||
nSetValue = -1;
|
||||
nQueryBufferSize= -1;
|
||||
nIndex = 0;
|
||||
nResult_Type = 0;
|
||||
queryId = 0;
|
||||
databaseId = 0;
|
||||
}
|
||||
int nMsgType; // 메세지 타입, DB서버에서 사용하기보다 나중에 게임서버가 결과를 받아서 처리할때 필요
|
||||
int nQueryType; // 쿼리의 타입 (insert = 0, delete = 1, select = 2, update = 3)
|
||||
int fieldLength; // 쿼리 부분 사이즈
|
||||
int resultLength; // 결과 부분 사이즈
|
||||
int returnLength; // 다시 되돌려 받아야 하는 데이터의 사이즈
|
||||
int nValueTypeCnt; // 결과값의 갯수
|
||||
int nSetValue; // MoveNext : 한테이블에 몇개의 변수?
|
||||
int nQueryBufferSize; // 버퍼의 사이즈 (실제 데이터)
|
||||
unsigned int nIndex; // 쿼리 주인의 고유 인덱스.
|
||||
int nResult_Type; // 결과 에러시 행동.
|
||||
int queryId; // 실행하고자 하는 쿼리번호
|
||||
int databaseId; // 디비구분
|
||||
};
|
||||
|
||||
class CQuery
|
||||
{
|
||||
protected:
|
||||
QueryHeader m_queryHeader; // 쿼리헤더
|
||||
char *m_pBuffer; // 쿼리내용, 결과데이터타입들, 다시 돌려받아야할 데이터
|
||||
public:
|
||||
void Clear()
|
||||
{
|
||||
memset(&m_queryHeader,0,sizeof(QueryHeader));
|
||||
if(m_pBuffer != NULL)
|
||||
{
|
||||
delete[] m_pBuffer;
|
||||
m_pBuffer = NULL;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class CQueryData : public CQuery
|
||||
{
|
||||
public://GET
|
||||
//HEADER
|
||||
int GetMsgType() { return m_queryHeader.nMsgType; }
|
||||
int GetQueryType() { return m_queryHeader.nQueryType; }
|
||||
int GetFieldSize() { return m_queryHeader.fieldLength; }
|
||||
int GetResultSize() { return m_queryHeader.resultLength; }
|
||||
int GetValueCnt() { return m_queryHeader.nValueTypeCnt; }
|
||||
int GetReturnSize() { return m_queryHeader.returnLength; }
|
||||
int GetSetValue() { return m_queryHeader.nSetValue; }
|
||||
int GetBufferSize() { return m_queryHeader.nQueryBufferSize; }
|
||||
unsigned int GetIndex() { return m_queryHeader.nIndex; }
|
||||
int GetResultType() { return m_queryHeader.nResult_Type; }
|
||||
int GetQueryID() { return m_queryHeader.queryId; }
|
||||
int GetDatabaseID() { return m_queryHeader.databaseId; }
|
||||
|
||||
//DATA
|
||||
QueryHeader *GetHeader(){ return &m_queryHeader; }
|
||||
char *GetBuffer() { return m_pBuffer; }
|
||||
|
||||
void GetFields(cSerialize& fieldTypes);
|
||||
void GetResults(vVALUETYPE& valueTypes);
|
||||
void GetReturns(char* buffer, int &size);
|
||||
|
||||
public:
|
||||
//SET
|
||||
void SetData(
|
||||
unsigned int nIndex,
|
||||
int nResult_Type,
|
||||
int nMsgType,
|
||||
int nQueryType,
|
||||
int queryId,
|
||||
cSerialize& fieldTypes,
|
||||
vVALUETYPE& valueTypes,
|
||||
int nSetValue = 1);
|
||||
void SetBuffer(const char *buffer);
|
||||
void SetBuffer(uint8 *buffer);
|
||||
|
||||
protected:
|
||||
//돌려받기 위해 저장하는 데이터
|
||||
char m_szReturnBuf[ MAX_BUFFER ];
|
||||
int m_iReturnLength;
|
||||
|
||||
public:
|
||||
void SetReturnData( const void *pData, int iSize );
|
||||
void Copy( CQueryData &queryData );
|
||||
|
||||
public:
|
||||
CQueryData();
|
||||
virtual ~CQueryData();
|
||||
};
|
||||
@@ -0,0 +1,224 @@
|
||||
// QueryResultData.cpp: implementation of the QueryResultData class.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "../stdafx.h"
|
||||
#include "QueryResultData.h"
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
// Construction/Destruction
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
CQueryResultData::CQueryResultData()
|
||||
{
|
||||
m_pBuffer = NULL;
|
||||
CQueryResult::Clear();
|
||||
InitPos();
|
||||
}
|
||||
CQueryResultData::~CQueryResultData()
|
||||
{
|
||||
CQueryResult::Clear();
|
||||
}
|
||||
|
||||
void CQueryResultData::GetValue(bool &value,int len)
|
||||
{
|
||||
if(m_nValuePos + len > m_queryResultHeader.nResultBufferSize)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer OVER!!");
|
||||
return;
|
||||
}
|
||||
if(m_pBuffer == NULL)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer NULL POINTER!!");
|
||||
return;
|
||||
}
|
||||
memcpy(&value,&m_pBuffer[m_nValuePos],len);
|
||||
m_nValuePos += len;
|
||||
}
|
||||
|
||||
void CQueryResultData::GetValue(int &value,int len)
|
||||
{
|
||||
if(m_nValuePos + len > m_queryResultHeader.nResultBufferSize)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer OVER!!");
|
||||
return;
|
||||
}
|
||||
if(m_pBuffer == NULL)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer NULL POINTER!!");
|
||||
return;
|
||||
}
|
||||
memcpy(&value,&m_pBuffer[m_nValuePos],len);
|
||||
m_nValuePos += len;
|
||||
}
|
||||
|
||||
void CQueryResultData::GetValue(long &value,int len)
|
||||
{
|
||||
if(m_nValuePos + len > m_queryResultHeader.nResultBufferSize)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer OVER!!");
|
||||
return;
|
||||
}
|
||||
if(m_pBuffer == NULL)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer NULL POINTER!!");
|
||||
return;
|
||||
}
|
||||
memcpy(&value,&m_pBuffer[m_nValuePos],len);
|
||||
m_nValuePos += len;
|
||||
}
|
||||
|
||||
void CQueryResultData::GetValue(DWORD &value,int len)
|
||||
{
|
||||
if(m_nValuePos + len > m_queryResultHeader.nResultBufferSize)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer OVER!!");
|
||||
return;
|
||||
}
|
||||
if(m_pBuffer == NULL)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer NULL POINTER!!");
|
||||
return;
|
||||
}
|
||||
memcpy(&value,&m_pBuffer[m_nValuePos],len);
|
||||
m_nValuePos += len;
|
||||
}
|
||||
|
||||
void CQueryResultData::GetValue(char *value,int len)
|
||||
{
|
||||
if((m_nValuePos + len) > m_queryResultHeader.nResultBufferSize)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer OVER!!");
|
||||
return;
|
||||
}
|
||||
if(m_pBuffer == NULL)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer NULL POINTER!!");
|
||||
return;
|
||||
}
|
||||
memcpy(value,&m_pBuffer[m_nValuePos],len);
|
||||
m_nValuePos += len;
|
||||
}
|
||||
|
||||
void CQueryResultData::GetValue(__int64 &value,int len)
|
||||
{
|
||||
if(m_nValuePos + len > m_queryResultHeader.nResultBufferSize)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer OVER!!");
|
||||
return;
|
||||
}
|
||||
if(m_pBuffer == NULL)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer NULL POINTER!!");
|
||||
return;
|
||||
}
|
||||
memcpy(&value,&m_pBuffer[m_nValuePos],len);
|
||||
m_nValuePos += len;
|
||||
}
|
||||
|
||||
void CQueryResultData::GetValue(short &value,int len)
|
||||
{
|
||||
if(m_nValuePos + len > m_queryResultHeader.nResultBufferSize)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer OVER!!");
|
||||
return;
|
||||
}
|
||||
if(m_pBuffer == NULL)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer NULL POINTER!!");
|
||||
return;
|
||||
}
|
||||
memcpy(&value,&m_pBuffer[m_nValuePos],len);
|
||||
m_nValuePos += len;
|
||||
}
|
||||
|
||||
void CQueryResultData::GetValue(ioHashString &value,int len)
|
||||
{
|
||||
if(m_nValuePos + len > m_queryResultHeader.nResultBufferSize)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer OVER!![0x%x]", GetMsgType() );
|
||||
return;
|
||||
}
|
||||
if(m_pBuffer == NULL)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer NULL POINTER!!");
|
||||
return;
|
||||
}
|
||||
|
||||
char szBuf[MAX_PATH] = "";
|
||||
if( len < MAX_PATH )
|
||||
{
|
||||
memcpy(szBuf,&m_pBuffer[m_nValuePos],len);
|
||||
value = szBuf;
|
||||
m_nValuePos += len;
|
||||
}
|
||||
//else
|
||||
//LOG.PrintTimeAndLog(0,"Result GetValue Size Error!![0x%x] : %d", GetMsgType(), len );
|
||||
}
|
||||
|
||||
void CQueryResultData::GetValue(BYTE &value,int len)
|
||||
{
|
||||
if(m_nValuePos + len > m_queryResultHeader.nResultBufferSize)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer OVER!![0x%x]", GetMsgType() );
|
||||
return;
|
||||
}
|
||||
if(m_pBuffer == NULL)
|
||||
{
|
||||
//LOG.PrintTimeAndLog(0,"Result Buffer NULL POINTER!!");
|
||||
return;
|
||||
}
|
||||
memcpy(&value,&m_pBuffer[m_nValuePos],len);
|
||||
m_nValuePos += len;
|
||||
}
|
||||
|
||||
bool CQueryResultData::IsExist()
|
||||
{
|
||||
if( m_nValuePos < m_queryResultHeader.nResultBufferSize )
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
void CQueryResultData::SetBuffer(const char *buffer)
|
||||
{
|
||||
memcpy(&m_queryResultHeader,buffer,sizeof(QueryResultHeader));
|
||||
buffer += sizeof(QueryResultHeader);
|
||||
m_pBuffer = new char[m_queryResultHeader.nResultBufferSize];
|
||||
memset(m_pBuffer,0,m_queryResultHeader.nResultBufferSize);
|
||||
memcpy(m_pBuffer,buffer,m_queryResultHeader.nResultBufferSize);
|
||||
}
|
||||
|
||||
void CQueryResultData::SetBuffer(uint8 *buffer)
|
||||
{
|
||||
memcpy(&m_queryResultHeader,buffer,sizeof(QueryResultHeader));
|
||||
buffer += sizeof(QueryResultHeader);
|
||||
m_pBuffer = new char[m_queryResultHeader.nResultBufferSize];
|
||||
memset(m_pBuffer,0,m_queryResultHeader.nResultBufferSize);
|
||||
memcpy(m_pBuffer,buffer,m_queryResultHeader.nResultBufferSize);
|
||||
}
|
||||
|
||||
void CQueryResultData::SetResultData(
|
||||
unsigned int nIndex,
|
||||
int nMsgType,
|
||||
int nResultType,
|
||||
char *pResultData,
|
||||
int nResultSize,
|
||||
int resultCount )
|
||||
{
|
||||
CQueryResult::Clear();
|
||||
m_queryResultHeader.nIndex = nIndex;
|
||||
m_queryResultHeader.nMsgType = nMsgType;
|
||||
m_queryResultHeader.nQueryResultType = nResultType;
|
||||
m_queryResultHeader.nResultBufferSize = nResultSize;
|
||||
m_queryResultHeader.resultCount = resultCount;
|
||||
|
||||
if(nResultSize != 0)
|
||||
{
|
||||
m_pBuffer = new char[nResultSize];
|
||||
memset(m_pBuffer,0,nResultSize);
|
||||
memcpy(m_pBuffer, pResultData, nResultSize);
|
||||
}
|
||||
else
|
||||
m_pBuffer = NULL;
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
#pragma once
|
||||
|
||||
struct QueryResultHeader
|
||||
{
|
||||
QueryResultHeader()
|
||||
{
|
||||
nMsgType = -1;
|
||||
nQueryResultType = -1;
|
||||
nResultBufferSize = 0;
|
||||
resultCount = 0;
|
||||
nIndex = 0;
|
||||
}
|
||||
int nMsgType;
|
||||
int nQueryResultType;
|
||||
int nResultBufferSize;
|
||||
int resultCount;
|
||||
unsigned int nIndex;
|
||||
};
|
||||
|
||||
class CQueryResult
|
||||
{
|
||||
protected:
|
||||
QueryResultHeader m_queryResultHeader;
|
||||
char *m_pBuffer;
|
||||
|
||||
public:
|
||||
void Clear()
|
||||
{
|
||||
memset(&m_queryResultHeader,0,sizeof(QueryResultHeader));
|
||||
if(m_pBuffer != NULL)
|
||||
{
|
||||
delete[] m_pBuffer;
|
||||
m_pBuffer = NULL;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class CQueryResultData : public CQueryResult
|
||||
{
|
||||
int m_nValuePos;
|
||||
public:
|
||||
//HEADER
|
||||
int GetMsgType() { return m_queryResultHeader.nMsgType; }
|
||||
int GetResultType() { return m_queryResultHeader.nQueryResultType; }
|
||||
int GetResultBufferSize() { return m_queryResultHeader.nResultBufferSize; }
|
||||
int GetResultCount() { return m_queryResultHeader.resultCount; }
|
||||
unsigned int GetIndex() { return m_queryResultHeader.nIndex; }
|
||||
|
||||
//DATA
|
||||
void GetValue(bool &vlaue,int len);
|
||||
void GetValue(int &vlaue,int len);
|
||||
void GetValue(long &vlaue,int len);
|
||||
void GetValue(DWORD &vlaue,int len);
|
||||
void GetValue(char *vlaue,int len);
|
||||
void GetValue(__int64 &value,int len);
|
||||
void GetValue(short &value,int len);
|
||||
void GetValue(ioHashString &value,int len);
|
||||
void GetValue( BYTE &value, int len );
|
||||
|
||||
bool IsExist();
|
||||
|
||||
QueryResultHeader *GetHeader(){ return &m_queryResultHeader; }
|
||||
char *GetBuffer(){ return m_pBuffer; }
|
||||
|
||||
public://SET
|
||||
void SetResultData(
|
||||
unsigned int nIndex,
|
||||
int nMsgType,
|
||||
int nResultType,
|
||||
char *pResultData,
|
||||
int nResultSize,
|
||||
int resultCount);
|
||||
void SetBuffer(const char *buffer);
|
||||
void SetBuffer(uint8 *buffer);
|
||||
|
||||
public:
|
||||
void InitPos(){ m_nValuePos = 0; }
|
||||
|
||||
public:
|
||||
CQueryResultData();
|
||||
virtual ~CQueryResultData();
|
||||
};
|
||||
@@ -0,0 +1,186 @@
|
||||
#pragma once
|
||||
|
||||
#include <list>
|
||||
#include <vector>
|
||||
#include "cBuffer.h"
|
||||
|
||||
|
||||
// ÃÖ´ë¹öÆÛ±æÀÌ
|
||||
const uint32 G_MAXSTORAGELENGTH = 1024 * 32;
|
||||
|
||||
class cSerialize
|
||||
{
|
||||
public:
|
||||
cSerialize(void)
|
||||
{
|
||||
m_storage.Create(G_MAXSTORAGELENGTH);
|
||||
|
||||
m_temporary = NULL;
|
||||
m_offset = 0;
|
||||
m_maxLength = 0;
|
||||
}
|
||||
|
||||
public:
|
||||
void Reset()
|
||||
{
|
||||
m_storage.Erase();
|
||||
}
|
||||
|
||||
uint8* GetBuffer() { return m_storage.GetBuffer(); }
|
||||
uint32 GetLength() { return m_storage.GetLength(); }
|
||||
|
||||
public:
|
||||
void operator<<(const uint8 value) { m_storage.Append(reinterpret_cast<const uint8*>(&value), sizeof(value)); }
|
||||
void operator<<(const uint16 value) { m_storage.Append(reinterpret_cast<const uint8*>(&value), sizeof(value)); }
|
||||
void operator<<(const uint32 value) { m_storage.Append(reinterpret_cast<const uint8*>(&value), sizeof(value)); }
|
||||
void operator<<(const uint64 value) { m_storage.Append(reinterpret_cast<const uint8*>(&value), sizeof(value)); }
|
||||
void operator<<(const float value) { m_storage.Append(reinterpret_cast<const uint8*>(&value), sizeof(value)); }
|
||||
void operator<<(const double value) { m_storage.Append(reinterpret_cast<const uint8*>(&value), sizeof(value)); }
|
||||
|
||||
public:
|
||||
void Write( const uint8 value ) { m_storage.Append( reinterpret_cast<const uint8*>(&value), sizeof(value) ); }
|
||||
void Write( const uint16 value ){ m_storage.Append( reinterpret_cast<const uint8*>(&value), sizeof(value) ); }
|
||||
void Write( const uint32 value ){ m_storage.Append( reinterpret_cast<const uint8*>(&value), sizeof(value) ); }
|
||||
void Write( const uint64 value ){ m_storage.Append( reinterpret_cast<const uint8*>(&value), sizeof(value) ); }
|
||||
void Write( const float value ) { m_storage.Append( reinterpret_cast<const uint8*>(&value), sizeof(value) ); }
|
||||
void Write( const double value ){ m_storage.Append( reinterpret_cast<const uint8*>(&value), sizeof(value) );}
|
||||
void Write( const int value ) { m_storage.Append( reinterpret_cast<const uint8*>(&value), sizeof(value) ); }
|
||||
void Write( const int64 value ) { m_storage.Append( reinterpret_cast<const uint8*>(&value), sizeof(value) ); }
|
||||
|
||||
void Write( const uint8* value, uint32 length, BOOL saveLength = FALSE )
|
||||
{
|
||||
if( saveLength )
|
||||
Write( static_cast<uint16>(length) );
|
||||
m_storage.Append( value, length );
|
||||
}
|
||||
void Write( const char* value, uint32 length, BOOL saveLength = FALSE )
|
||||
{
|
||||
if( saveLength )
|
||||
Write( static_cast<uint16>(length) );
|
||||
m_storage.Append( value, length );
|
||||
}
|
||||
template<typename TD>
|
||||
void Write( std::vector<TD>& vcList, BOOL saveLength = TRUE )
|
||||
{
|
||||
if( saveLength )
|
||||
Write( static_cast<uint32>(vcList.size()) );
|
||||
|
||||
for( std::vector<TD>::iterator it = vcList.begin() ; it != vcList.end() ; ++it )
|
||||
{
|
||||
Write( *it );
|
||||
}
|
||||
}
|
||||
template<typename TD>
|
||||
void Write( std::list<TD>& vcList, BOOL saveLength = TRUE )
|
||||
{
|
||||
if( saveLength )
|
||||
Write( static_cast<uint32>(vcList.size()) );
|
||||
|
||||
for( std::list<TD>::iterator it = vcList.begin() ; it != vcList.end() ; ++it )
|
||||
{
|
||||
Write( *it );
|
||||
}
|
||||
}
|
||||
template<typename TD>
|
||||
void Read( const uint8* pBuffer, std::vector<TD>& vcList )
|
||||
{
|
||||
uint32 nLength = 0;
|
||||
CopyMemory( &nLength, pBuffer, sizeof(nLength) );
|
||||
|
||||
vcList.clear();
|
||||
vcList.reserve( nLength );
|
||||
|
||||
TD data;
|
||||
pBuffer += sizeof(nLength);
|
||||
for( uint32 i = 0 ; i < nLength ; i++ )
|
||||
{
|
||||
CopyMemory( &data, pBuffer+sizeof(TD)*i, sizeof(TD) );
|
||||
vcList.push_back( data );
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
void SetBuffer( uint8* pBuffer, uint32 maxLength )
|
||||
{
|
||||
m_temporary = pBuffer;
|
||||
m_maxLength = maxLength;
|
||||
m_offset = 0;
|
||||
}
|
||||
BOOL GetStringLength(uint16& length)
|
||||
{
|
||||
CopyMemory( &length, m_temporary+m_offset, sizeof(length) );
|
||||
m_offset += sizeof(uint16);
|
||||
return (m_offset <= m_maxLength) ? TRUE : FALSE;
|
||||
}
|
||||
BOOL GetUInt(uint8& data)
|
||||
{
|
||||
CopyMemory( &data, m_temporary+m_offset, sizeof(data) );
|
||||
m_offset += sizeof(data);
|
||||
return (m_offset <= m_maxLength) ? TRUE : FALSE;
|
||||
}
|
||||
BOOL GetUInt(uint16& data)
|
||||
{
|
||||
CopyMemory( &data, m_temporary+m_offset, sizeof(data) );
|
||||
m_offset += sizeof(data);
|
||||
return (m_offset <= m_maxLength) ? TRUE : FALSE;
|
||||
}
|
||||
BOOL GetUInt(uint32& data)
|
||||
{
|
||||
CopyMemory( &data, m_temporary+m_offset, sizeof(data) );
|
||||
m_offset += sizeof(data);
|
||||
return (m_offset <= m_maxLength) ? TRUE : FALSE;
|
||||
}
|
||||
BOOL GetUInt(uint64& data)
|
||||
{
|
||||
CopyMemory( &data, m_temporary+m_offset, sizeof(data) );
|
||||
m_offset += sizeof(data);
|
||||
return (m_offset <= m_maxLength) ? TRUE : FALSE;
|
||||
}
|
||||
BOOL GetFloat(float& data)
|
||||
{
|
||||
CopyMemory( &data, m_temporary+m_offset, sizeof(data) );
|
||||
m_offset += sizeof(data);
|
||||
return (m_offset <= m_maxLength) ? TRUE : FALSE;
|
||||
}
|
||||
BOOL GetDouble(double& data)
|
||||
{
|
||||
CopyMemory( &data, m_temporary+m_offset, sizeof(data) );
|
||||
m_offset += sizeof(data);
|
||||
return (m_offset <= m_maxLength) ? TRUE : FALSE;
|
||||
}
|
||||
BOOL GetString(const uint32 length, TCHAR* buffer, const uint32 size)
|
||||
{
|
||||
if( length < size )
|
||||
{
|
||||
CopyMemory( buffer, m_temporary+m_offset, length );
|
||||
buffer[length/sizeof(TCHAR)] = NULL;
|
||||
m_offset += length;
|
||||
return (m_offset <= m_maxLength) ? TRUE : FALSE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
BOOL GetString(TCHAR* buffer, const uint32 size)
|
||||
{
|
||||
uint16 length;
|
||||
if(!GetStringLength(length)) return FALSE;
|
||||
|
||||
if( length < size )
|
||||
{
|
||||
CopyMemory( buffer, m_temporary+m_offset, length );
|
||||
buffer[length/sizeof(TCHAR)] = NULL;
|
||||
m_offset += length;
|
||||
return (m_offset <= m_maxLength) ? TRUE : FALSE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
const uint8* GetExtra() { return (m_offset <= m_maxLength) ? (m_temporary + m_offset) : NULL; }
|
||||
const uint32 GetExtraLength() { return (m_offset <= m_maxLength) ? (m_maxLength - m_offset) : 0; }
|
||||
|
||||
private:
|
||||
uint8* m_temporary;
|
||||
uint32 m_offset, m_maxLength;
|
||||
|
||||
cBuffer m_storage;
|
||||
};
|
||||
|
||||
Reference in new issue
Block a user