container.cpp

mcgs的数据导出源代码

// Container.cpp: implementation of the CContainer class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Data_Trans.h"
#include "Container.h"

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

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

CContainer::CContainer(CByteArray* pValue,CArray<int,int>* pIDs)
{
	if ( NULL == pValue || NULL == pIDs)
	{
		return;
	}

	if (pValue->GetSize() == 0) 
	{			
		return;
	}

	BYTE* pBuff = pValue->GetData();
	int iSize = pValue->GetSize();
	int iPos = -1;
	int iEnd = iSize / 4;
	for (int i=0;i<iSize / 4 ;i++)
	{
		iEnd = i;
		if (-1 == ((int*)pBuff)[i])
		{
			if ( i < iSize / 4 - 4 )
			{	  
				if ((int)'s' == ((int*)pBuff)[i + 1] &&
					(int)'g' == ((int*)pBuff)[i + 2] &&
					(int)'c' == ((int*)pBuff)[i + 3] &&
					(int)'m' == ((int*)pBuff)[i + 4] )
				{								   
					iPos = i + 5;
					break;
				}
			}
		}
	}

	pIDs->SetSize(iEnd);	
	for (i=0;i<iEnd;i++)
	{
		(*pIDs)[i] = ((int*)pBuff)[i];
	}

	if ( -1 != iPos && iPos < iSize / 4)
	{
		BEGINTRY
			CMemFile theFile;
			theFile.Write(pBuff + iPos * 4 , iSize - iPos * 4);
			theFile.SeekToBegin();
			CArchive ar(&theFile,CArchive::load);
			m_IntIndex.Serialize(ar);
			m_IntArray.Serialize(ar);
			ASSERT(m_IntIndex.GetSize() == m_IntArray.GetSize());
			m_StrIndex.Serialize(ar);
			m_StrArray.Serialize(ar);
			ASSERT(m_StrIndex.GetSize() == m_StrArray.GetSize());
			m_MemIndex.Serialize(ar);
			m_MemSize.Serialize(ar);
			ASSERT(m_MemSize.GetSize() == m_MemIndex.GetSize());
			m_MemArray.SetSize(m_MemSize.GetSize());
			for (int k = 0 ; k < m_MemSize.GetSize() ; k ++)
			{
				m_MemArray[k] = new BYTE[m_MemSize[k]];
				ar.Read(m_MemArray[k],m_MemSize[k]);
			}	
			ar.Close();			
		ERRRETURN;
		ENDTRY;
	}
}

BOOL CContainer::SvrAppend(CByteArray & value,CArray<int,int>& IDs)
{
	ASSERT(value.GetSize() == 0);
	BYTE* pBuff = NULL;
	int iSize = 0;
#ifdef _DEBUG
	int iIDSize = IDs.GetSize() / 4;
	int* pB = IDs.GetData();
	for (int io = 0;io < iIDSize;io++)
	{						 		
		if ( -1 == pB[io])
		{
			ASSERT(FALSE);
		}
	}
#endif
	BEGINTRY		
		CMemFile theFile;
		CArchive ar(&theFile,CArchive::store);
		ASSERT(m_IntIndex.GetSize() == m_IntArray.GetSize());
		m_IntIndex.Serialize(ar);
		m_IntArray.Serialize(ar);
		ASSERT(m_StrIndex.GetSize() == m_StrArray.GetSize());
		m_StrIndex.Serialize(ar);
		m_StrArray.Serialize(ar);
		ASSERT(m_MemSize.GetSize() == m_MemIndex.GetSize() && 
			m_MemArray.GetSize() == m_MemIndex.GetSize() );
		m_MemIndex.Serialize(ar);
		m_MemSize.Serialize(ar);
		for (int k = 0 ; k < m_MemSize.GetSize() ; k ++)
		{				
			ar.Write(m_MemArray[k],m_MemSize[k]);
		}	
		ar.Close();
		theFile.SeekToBegin();
		iSize = theFile.GetLength();
		ASSERT(iSize != 0);
		pBuff = new BYTE[iSize];
		theFile.Read(pBuff,iSize);
	ERRRETURN;
	ENDTRY;

	if ( 0 == iSize) 
	{
		ASSERT(FALSE);
		delete [] pBuff;
		return FALSE;
	}

	ASSERT(value.GetSize() == 0 );
	int iPos = IDs.GetSize();
	ASSERT(sizeof(int) == 4);
	value.SetSize(IDs.GetSize() * 4 + 20 + iSize);
	BYTE* pVoid = value.GetData();
	for (int i=0;i<IDs.GetSize();i++)
	{
		((int*)pVoid)[i] = IDs[i];
	}
	((int*)pVoid)[iPos] = -1;
	((int*)pVoid)[iPos + 1] = (int)'s';
	((int*)pVoid)[iPos + 2] = (int)'g';
	((int*)pVoid)[iPos + 3] = (int)'c';
	((int*)pVoid)[iPos + 4] = (int)'m';

	memcpy(pVoid + iPos * 4 + 20,pBuff,iSize);


	if ( NULL != pBuff)
	{
		delete [] pBuff;
	}

	return TRUE;
}

CContainer::~CContainer()
{			
	BEGINTRY
		ASSERT(m_MemSize.GetSize() < 10);
		for (int i = 0 ; i<m_MemSize.GetSize();i++)
		{
			delete m_MemArray[i];
		}
	ERRRETURN;
	ENDTRY;
}

BOOL CContainer::SvrLookup(int iID, int& value)
{	
	value = 0;
	ASSERT(m_IntArray.GetSize() == m_IntIndex.GetSize());
	ASSERT(m_StrArray.GetSize() == m_StrIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemSize.GetSize());	
	if (m_IntIndex.GetSize() == 0) return TRUE;
	for (int i=0;i<m_IntIndex.GetSize();i++)
	{
		if (iID == m_IntIndex[i])
		{
			value = m_IntArray[i];
			return TRUE;
		}
	}
	return FALSE;
}

BOOL CContainer::SvrLookup(int iID, CString & value)
{		
	ASSERT(m_IntArray.GetSize() == m_IntIndex.GetSize());
	ASSERT(m_StrArray.GetSize() == m_StrIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemSize.GetSize());	
	if (m_StrIndex.GetSize() == 0) return TRUE;
	for (int i=0;i<m_StrIndex.GetSize();i++)
	{
		if (iID == m_StrIndex[i])
		{
			value = m_StrArray[i];
			return TRUE;
		}
	}
	return FALSE;
}

BOOL CContainer::SvrLookup(int iID, CByteArray & value)
{
	ASSERT(m_IntArray.GetSize() == m_IntIndex.GetSize());
	ASSERT(m_StrArray.GetSize() == m_StrIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemSize.GetSize());	
	if (m_MemIndex.GetSize() == 0) return TRUE;
	for (int i=0;i<m_MemIndex.GetSize();i++)
	{
		if (iID == m_MemIndex[i])
		{
			value.SetSize(m_MemSize[i]);
			memcpy(value.GetData(),m_MemArray[i],m_MemSize[i]);			
			return TRUE;
		}
	}
	return FALSE;
}

BOOL CContainer::SvrAdd(int iID, const int value)
{			
	ASSERT(m_IntArray.GetSize() == m_IntIndex.GetSize());
	ASSERT(m_StrArray.GetSize() == m_StrIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemSize.GetSize());	
	for (int i=0;i<m_IntIndex.GetSize();i++)
	{
		if (iID == m_IntIndex[i])
		{
			m_IntArray[i] = value;
			return TRUE;
		}
	}
	m_IntArray.Add(value);
	m_IntIndex.Add(iID);

	ASSERT(m_IntArray.GetSize() == m_IntIndex.GetSize());
	ASSERT(m_StrArray.GetSize() == m_StrIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemSize.GetSize());	
	return TRUE;
}

BOOL CContainer::SvrAdd(int iID, LPCTSTR value)
{
	ASSERT(m_IntArray.GetSize() == m_IntIndex.GetSize());
	ASSERT(m_StrArray.GetSize() == m_StrIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemSize.GetSize());	
	for (int i=0;i<m_StrIndex.GetSize();i++)
	{
		if (iID == m_StrIndex[i])
		{
			m_StrArray[i] = value;
			return TRUE;
		}
	}
	CString str = value;
	m_StrArray.Add(str);
	m_StrIndex.Add(iID);

	ASSERT(m_IntArray.GetSize() == m_IntIndex.GetSize());
	ASSERT(m_StrArray.GetSize() == m_StrIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemSize.GetSize());	
	return TRUE;
}

BOOL CContainer::SvrAdd(int iID, const CByteArray & value)
{
	ASSERT(m_IntArray.GetSize() == m_IntIndex.GetSize());
	ASSERT(m_StrArray.GetSize() == m_StrIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemSize.GetSize());	
	for (int i=0;i<m_MemIndex.GetSize();i++)
	{
		if (iID == m_MemIndex[i])
		{			   
			m_MemSize[i] = value.GetSize();
			delete [] m_MemArray[i];
			BYTE* pBuff = new BYTE[value.GetSize()];
			memcpy(pBuff,value.GetData(),value.GetSize());			
			m_MemArray[i] = pBuff;
			return TRUE;
		}
	}
	BYTE* pBuff = NULL;
	m_MemIndex.Add(iID);
	m_MemSize.Add(value.GetSize());
	pBuff = new BYTE[value.GetSize()];
	memcpy(pBuff,value.GetData(),value.GetSize());
	m_MemArray.Add(pBuff);	

	ASSERT(m_IntArray.GetSize() == m_IntIndex.GetSize());
	ASSERT(m_StrArray.GetSize() == m_StrIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemIndex.GetSize());
	ASSERT(m_MemArray.GetSize() == m_MemSize.GetSize());	
	return TRUE;
}