// OwnerArchive.cpp: implementation of the COwnerArchive class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Data_Trans.h"
#include "OwnerArchive.h"

#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;
	m_dwMaxLength = 0;
}

COwnerArchive::~COwnerArchive()
{

}

void COwnerArchive::operator<<(COleDateTime& time)
{
	(*this) << time.GetYear();
	(*this) << time.GetMonth();
	(*this) << time.GetDay();
	(*this) << time.GetHour();
	(*this) << time.GetMinute();
	(*this) << time.GetSecond();

	
}

void COwnerArchive::operator>>(COleDateTime& time)
{
	int iYear, iMonth, iDay, iHour, iMinute, iSecond;
	(*this) >> iYear;
	(*this) >> iMonth;
	(*this) >> iDay;
	(*this) >> iHour;
	(*this) >> iMinute;
	(*this) >> iSecond;
	time = COleDateTime ( iYear, iMonth, iDay, iHour, iMinute, iSecond );
}

void COwnerArchive::operator<<(CString& value)
{	
#ifdef E_MCGSRUN
	DWORD dwSize = STRLENGTH(value);
#else //E_MCGSRUN
	DWORD dwSize = lstrlen((LPCTSTR)value);
#endif //E_MCGSRUN
	
#if defined(_UNICODE) 
	//雙字節(jié)處理
	BYTE* pBuff = new BYTE[dwSize * 2 + 1];
	
	dwSize = WideCharToMultiByte(CP_ACP,0,(LPCTSTR)value,-1,(char*)pBuff,dwSize * 2+1,NULL,NULL);
	(*this) << dwSize;
	SvrWrite(pBuff,dwSize);
	delete [] pBuff;
#else 
	(*this) << dwSize;
#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
}

#ifdef E_MCGSRUN
#else
void COwnerArchive::operator >> (LOGFONT& value)
{
#if defined(_UNICODE)
	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
}
#endif //E_MCGSRUN

/*
void 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;
}
*/
void COwnerArchive::operator>>(CString& value)
{
#ifdef MCGS_WCE
	DWORD dwStrLength = 0;
	(*this) >> dwStrLength;

	int iCount = dwStrLength;

	if (false == mfCheckBuffer(iCount+1)) 
	{
		//不能快捷選取
		BYTE* pBuff = new BYTE[dwStrLength + 1];
		pBuff[dwStrLength] = 0;
		SvrRead((unsigned char *)pBuff,dwStrLength);
		value = pBuff;
		delete pBuff;
	}
	else
	{
		BYTE bTemp = *(ARRAYDATA(m_vectorBuffer)+m_dwBufferSize + iCount);
		*(ARRAYDATA(m_vectorBuffer)+m_dwBufferSize + iCount) = 0;
		value = ARRAYDATA(m_vectorBuffer)+m_dwBufferSize;
		*(ARRAYDATA(m_vectorBuffer)+m_dwBufferSize + iCount) = bTemp;		
		m_dwBufferSize += iCount;
	}
#else //MCGS_WCE
	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;
#endif //MCGS_WCE

}

#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;
}
#ifndef MFC_PERSIST
bool COwnerArchive::SvrWrite(CByteArray& 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(CByteArray& 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;
}
#endif //MFC_PERSIST
#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

bool COwnerArchive::SvrWrite(const unsigned char* pBuff,int iCount)
{
	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 (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;
}

bool COwnerArchive::mfCheckBuffer(int iCount)
{ 
	if (COwnerArchive::load == m_status)
	{
		//如果是裝載狀態(tài)
		return (int)ARRAYSIZE(m_vectorBuffer) >= (int)(m_dwBufferSize + iCount);
	}
	else
	{
		//如果是保存狀態(tài)
		if ((int)ARRAYSIZE(m_vectorBuffer) >= (int)(m_dwBufferSize + iCount))
		{
			return true;
		}
		else
		{
			//分配一下內(nèi)存空間
			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;
}