ownerarchive.cpp

国家环保总局污染源在线通讯协议的简化版

// OwnerArchive.cpp: implementation of the COwnerArchive class.
///	设备驱动模版
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "OwnerArchive.h"

#ifdef MCGSSET_ESET
#include "conio.h"
#endif //MCGSSET_ESET

#ifdef MCGS_WCE_EMU
#endif //MCGS_WCE_EMU

#ifdef MCGS_WCE
//#include "ddkio.h"
#endif //MCGS_WCE

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

COwnerArchive::COwnerArchive(ARCHIVESTATUS c)
{
	m_dwBufferSize = 0;//当前使用
	m_status = c;
}

COwnerArchive::~COwnerArchive()
{
	
}

void COwnerArchive::SvrChangeMode(ARCHIVESTATUS c)
{
	if (!(m_status == c))
	{
		m_status = c;
		SvrSeekToBegin();		
	}		
}

bool COwnerArchive::IsStoring()
{ 
	return m_status == storing;
}

void COwnerArchive::SvrSeekToBegin()
{
	if (m_dwBufferSize > 0)
	{
		ARRAYRESIZE(m_vectorBuffer,m_dwBufferSize);
	}
	m_dwBufferSize = 0;
}

DWORD COwnerArchive::SvrGetBufferSize()
{
	return m_dwBufferSize;
}

DWORD COwnerArchive::SvrGetRealBufferSize()
{
	DWORD n_Size = m_vectorBuffer.GetSize();
	return n_Size;
}

bool COwnerArchive::mfCheckBuffer(int iCount)
{ 
	if (COwnerArchive::load == m_status)
	{
		//如果是装载状态
		return (int)ARRAYSIZE(m_vectorBuffer) >= (int)(m_dwBufferSize + iCount);
	}
	else
	{
		//如果是保存状态
		if ((int)ARRAYSIZE(m_vectorBuffer) >= (int)(m_dwBufferSize + iCount))
		{
			return true;
		}
		else
		{
			//分配一下内存空间
			if (ARRAYSIZE(m_vectorBuffer) + OWNERARCHIVE_BUFFER_INC_SIZE >= (int)(m_dwBufferSize + iCount))
			{
				DWORD dwOldSize = ARRAYSIZE(m_vectorBuffer);
				ARRAYRESIZE(m_vectorBuffer,OWNERARCHIVE_BUFFER_INC_SIZE + dwOldSize);
			}
			else
			{
				ARRAYRESIZE(m_vectorBuffer,m_dwBufferSize + iCount);
				//只能直接分配
			}
		}
	}
	return true;
}

bool COwnerArchive::SvrWrite(const unsigned char* pBuff,int iCount)
{
	if (m_status == load)
	{
		SvrChangeMode(storing);
	}	
	if (false == mfCheckBuffer(iCount)) 
	{
		ASSERT(FALSE);
		return false;
	}

	for (int i = 0 ; i < iCount ; i ++)
	{
		m_vectorBuffer[m_dwBufferSize + i] = pBuff[i];
	}

	m_dwBufferSize += iCount;

	return true;
}

bool COwnerArchive::SvrRead(unsigned char* pBuff,int iCount)
{
	if (m_status == storing)
	{
		SvrChangeMode(load);
	}
	if (false == mfCheckBuffer(iCount)) 
	{
		ASSERT(FALSE);
		return false;
	}

	for (int i = 0 ; i < iCount ; i ++)
	{
		pBuff[i] = m_vectorBuffer[m_dwBufferSize + i];
	}

	m_dwBufferSize += iCount;

	return true;
}

#ifdef MCGSSET_ESET
bool COwnerArchive::SvrWrite(BYTEARRAY& Buff)
{
	int iSize = ARRAYSIZE(Buff);
	if (false == mfCheckBuffer(iSize)) 
	{
		ASSERT(FALSE);
		return false;
	}
	memcpy(ARRAYDATA(m_vectorBuffer) + m_dwBufferSize,ARRAYDATA(Buff) , ARRAYSIZE(Buff));
	m_dwBufferSize += iSize;
	return true;
}

bool COwnerArchive::SvrRead(BYTEARRAY& Buff)
{
	int iSize = ARRAYSIZE(Buff); 
	if (false == mfCheckBuffer(iSize)) 
	{
		ASSERT(FALSE);
		return false;
	}
	
	memcpy(ARRAYDATA(Buff),ARRAYDATA(m_vectorBuffer) + m_dwBufferSize , iSize);
	m_dwBufferSize += iSize;
	return true;
}
#else

bool COwnerArchive::SvrWrite(BYTEARRAY& Buff)
{
	int iSize = (int)ARRAYSIZE(Buff);
	if (false == mfCheckBuffer(iSize)) 
	{
		ASSERT(FALSE);
		return false;
	}
	memcpy(ARRAYDATA(m_vectorBuffer) + m_dwBufferSize,ARRAYDATA(Buff),ARRAYSIZE(Buff));
	m_dwBufferSize += iSize;
	return true;
}

bool COwnerArchive::SvrRead(BYTEARRAY& Buff)
{
	int iSize = (int)ARRAYSIZE(Buff); 
	if (false == mfCheckBuffer(iSize)) 
	{
		ASSERT(FALSE);
		return false;
	}
	
	memcpy(ARRAYDATA(Buff),ARRAYDATA(m_vectorBuffer) + m_dwBufferSize ,iSize);
	m_dwBufferSize += iSize;
	return true;
}
#endif //MCGSSET_ESET

void COwnerArchive::Write(const void* pBuff,int iCount)
{
	SvrWrite((const unsigned char*)pBuff,iCount);
}

void COwnerArchive::Read(void* pBuff,int iCount)
{
	SvrRead((unsigned char*)pBuff,iCount);
}

COwnerArchive& COwnerArchive::operator<<(BYTE value)
{ 
	SvrWrite((const unsigned char*)&value,sizeof(BYTE));
	return *this;
}

COwnerArchive& COwnerArchive::operator>>(BYTE& value)
{ 
	SvrRead((unsigned char*)&value,sizeof(BYTE));
	return *this;
}

COwnerArchive& COwnerArchive::operator<<(char value)
{
	SvrWrite((const unsigned char*)&value,sizeof(char));
	return *this;
}

COwnerArchive& COwnerArchive::operator>>(char& value)
{ 
	SvrRead((unsigned char*)&value,sizeof(char));
	return *this;
}

COwnerArchive& COwnerArchive::operator<<(int value)
{ 
	SvrWrite((const unsigned char*)&value,sizeof(int));
	return *this;
}

COwnerArchive& COwnerArchive::operator>>(int& value)
{ 
	SvrRead((unsigned char*)&value,sizeof(int));
	return *this;
}

COwnerArchive& COwnerArchive::operator<<(long value)
{ 
	SvrWrite((const unsigned char*)&value,sizeof(long));
	return *this;
}

COwnerArchive& COwnerArchive::operator>>(long& value)
{ 
	SvrRead((unsigned char*)&value,sizeof(long));
	return *this;
}

COwnerArchive& COwnerArchive::operator<<(WORD value)
{ 
	SvrWrite((const unsigned char*)&value,sizeof(WORD));
	return *this;
}

COwnerArchive& COwnerArchive::operator>>(WORD& value)
{ 
	SvrRead((unsigned char*)&value,sizeof(WORD));
	return *this;
}

COwnerArchive& COwnerArchive::operator<<(DWORD value)
{ 
	SvrWrite((const unsigned char*)&value,sizeof(DWORD));
	return *this;
}

COwnerArchive& COwnerArchive::operator>>(DWORD& value)
{ 
	SvrRead((unsigned char*)&value,sizeof(DWORD));
	return *this;
}

COwnerArchive& COwnerArchive::operator<<(float value)
{ 
	SvrWrite((const unsigned char*)&value,sizeof(float));
	return *this;
}

COwnerArchive& COwnerArchive::operator>>(float& value)
{ 
	SvrRead((unsigned char*)&value,sizeof(float));
	return *this;
}

COwnerArchive& COwnerArchive::operator<<(double value)
{ 
	SvrWrite((const unsigned char*)&value,sizeof(double));
	return *this;
}

COwnerArchive& COwnerArchive::operator>>(double& value)
{ 
	SvrRead((unsigned char*)&value,sizeof(double));
	return *this;
}

COwnerArchive& COwnerArchive::operator<<(bool value)
{
	char c = value == true ? 1 : 0;
	SvrWrite((const unsigned char*)&c,sizeof(char));
	return *this;
}

COwnerArchive& COwnerArchive::operator>>(bool& value)
{
	char c;
	SvrRead((unsigned char*)&c,sizeof(char));
	value = c == 1 ? true : false;
	return *this;
}

COwnerArchive& COwnerArchive::operator<<(COwnerObject& value)
{
	SvrChangeMode(storing);
	value.Serialize(*this);
	return *this;
}

COwnerArchive& COwnerArchive::operator>>(COwnerObject& value)
{
	SvrChangeMode(load);
	value.Serialize(*this);
	return *this;
}

COwnerArchive& COwnerArchive::operator<<(CStdString& value)
{	
#ifdef E_MCGSRUN
	DWORD dwSize = STRLENGTH(value);
#else //E_MCGSRUN
	DWORD dwSize = lstrlen((LPCTSTR)value);
#endif //E_MCGSRUN
	
	(*this) << dwSize;
#if defined(MCGS_WCE) 
	//双字节处理
	BYTE* pBuff = new BYTE[dwSize + 1];
	
	WideCharToMultiByte(CP_ACP,0,(LPCTSTR)value,-1,(char*)pBuff,dwSize+1,NULL,NULL);
	SvrWrite(pBuff,dwSize);
	delete [] pBuff;
#else 
#ifdef E_MCGSRUN
	SvrWrite((const unsigned char *)STRPTR(value), STRLENGTH(value));
#else //E_MCGSRUN
	SvrWrite((const unsigned char *)(LPCTSTR)value, lstrlen((LPCTSTR)value) * sizeof(TCHAR));
#endif //E_MCGSRUN
#endif //MCGS_WCE

	return *this;
}

COwnerArchive& COwnerArchive::operator>>(CStdString& value)
{
	DWORD dwStrLength = 0;
	(*this) >> dwStrLength;
	BYTE* pBuff = new BYTE[dwStrLength + 1];

	pBuff[dwStrLength] = 0;
	SvrRead((unsigned char *)pBuff,dwStrLength);
#ifdef E_MCGSRUN
	value = (TCHAR*)pBuff;
#else //E_MCGSRUN
	value = pBuff;
#endif //E_MCGSRUN
	delete pBuff;

	return *this;
}



#ifdef E_MCGSRUN
#else
COwnerArchive& COwnerArchive::operator >> (LOGFONT& value)
{
#if defined(MCGS_WCE)
	LOGFONTA c;
	SvrRead((unsigned char*)&c,sizeof(c));
    value.lfHeight = c.lfHeight;
    value.lfWidth = c.lfWidth;
    value.lfEscapement = c.lfEscapement;
    value.lfOrientation = c.lfOrientation;
    value.lfWeight = c.lfWeight;
    value.lfItalic = c.lfItalic;
    value.lfUnderline = c.lfUnderline;
    value.lfStrikeOut = c.lfStrikeOut;
    value.lfCharSet = c.lfCharSet;
    value.lfOutPrecision = c.lfOutPrecision;
    value.lfClipPrecision = c.lfClipPrecision;
    value.lfQuality = c.lfQuality;
    value.lfPitchAndFamily = c.lfPitchAndFamily;
	MultiByteToWideChar(CP_ACP,0,c.lfFaceName,-1,value.lfFaceName,LF_FACESIZE);
#else
	SvrRead((unsigned char*)&value,sizeof(value));
#endif
	return *this;
}
#endif //E_MCGSRUN