virtualsavefile.cpp

mcgs的数据导出源代码

CVirtualSaveFileBlock* CVirtualSaveFile::SvrCreateNewSaveBlock( DWORD dwPos, DWORD dwAllocSize, bool bLoad, MCGSDATETIME timeBegin, MCGSDATETIME timeEnd )
{
	CVirtualSaveFileBlock *pSaveBlock = new CVirtualSaveFileBlock( dwPos, dwAllocSize, bLoad, this, timeBegin, timeEnd );
	ARRAYADD( m_arraySaveBlock, pSaveBlock );
	return pSaveBlock;
}

bool McgsIfTimeCross( COleDateTime& time1, COleDateTime& time2, COleDateTime& time3, COleDateTime& time4 );

long CVirtualSaveFile::SvrGetSaveFile(CString strGroupName, 
								STRINGARRAY& arrayFieldNames,
								COleDateTime& tBegin,
								COleDateTime& tEnd,
								CArray<CList<COleVariant,COleVariant>*,CList<COleVariant,COleVariant>*>& listValueBuffer
								)
{
	mfCheckLoad();
	long lngReturn = 0;

	DWORD dwS = GetTickCount();  
	int iCount = ARRAYSIZE( m_arraySaveBlock );
	if((CVirtualInfoFile::m_wInvRead & MCGS_READDATA_N2O) != MCGS_READDATA_N2O)
	{
		for ( int i = 0; i < iCount; i++ )
		{
			if ( McgsIfTimeCross( tBegin, tEnd, m_arraySaveBlock[i] -> SvrGetStartTime(), m_arraySaveBlock[i] -> SvrGetEndTime() ))
			{
				lngReturn += m_arraySaveBlock[i]->SvrGetBlock( strGroupName, arrayFieldNames, tBegin, tEnd, listValueBuffer );
				//lzlzlz 2003.6.20
				if(CVirtualInfoFile::SvrIsStopGettingData() == true)
				{
					//已经满足要求
					break;
				}
			}
		}
	}
	else
	{
		for ( int i = iCount - 1; i >= 0; i-- )
		{
			if ( McgsIfTimeCross( tBegin, tEnd, m_arraySaveBlock[i] -> SvrGetStartTime(), m_arraySaveBlock[i] -> SvrGetEndTime() ))
			{
				lngReturn += m_arraySaveBlock[i]->SvrGetBlock( strGroupName, arrayFieldNames, tBegin, tEnd, listValueBuffer );
				//lzlzlz 2003.6.20
				if(CVirtualInfoFile::SvrIsStopGettingData() == true)
				{
					//已经满足要求
					break;
				}
			}
		}

	}
	DWORD dwE = GetTickCount();    
	TRACE(_T("Seek Records Time %d\n"), dwE - dwS);

	return lngReturn;
}

FILE_ERROR CVirtualSaveFile::SvrReadBlock( DWORD dwPos, BYTEARRAY& buff )
{
	long lngSize1 = 0;
	long lngSize2 = 0;
	BOOL bOpen = FALSE;
	TRY
	{
		bOpen = m_file.Open( m_strFileName, CFile::modeRead );
		if ( bOpen == FALSE )
		{
			return S_FILE_READ_FAIL;
		}

	}
	CATCH( CFileException, e ) 
	{
		e->Delete();
		TRACE( _T("file %s open fail\n"), m_strFileName);
		return S_FILE_READ_FAIL;
	}
	END_CATCH

	TRY
	{
		m_file.Seek( dwPos, CFile::begin  );
		m_file.Read( &lngSize1, sizeof(long) );
		m_file.Read( &lngSize2, sizeof(long) );
	}
	CATCH( CFileException, e ) 
	{
		e->Delete();
		TRACE( _T("file %s Read fail\n"), m_strFileName);
		return S_FILE_READ_FAIL;
	}
	END_CATCH
	if ( lngSize1 != lngSize2 || lngSize1 == 0 )
	{
		ASSERT( FALSE );
		return S_FILE_FILE_EXIST;
	}

	ARRAYRESIZE( buff, lngSize1 );
#ifdef _MCGS_OLEDATETIME_
	long lngPos = ((long)dwPos) + 14*sizeof(long);
#else
	long lngPos = ((long)dwPos) + 4*sizeof(long);
#endif
	TRY
	{
		m_file.Seek( (DWORD)lngPos, CFile::begin );
		m_file.Read( ARRAYDATA(buff), ARRAYSIZE(buff) );
		m_file.Close();
	}
	CATCH( CFileException, e ) 
	{
		e->Delete();
		TRACE( _T("file %s Read fail 2\n"), m_strFileName);
		return S_FILE_READ_FAIL;
	}
	END_CATCH

/*	COwnerArchive ar( COwnerArchive::storing );
	ar.SvrWrite( buffTime );
	ar.SvrSeekToBegin();
	ar.SvrChangeMode( COwnerArchvie::load );
	ar >> timeBegin;
	ar >> timeEnd;
*/

	return S_FILE_OK;
}

BOOL CVirtualSaveFile::SvrOpenFile( )
{
/*	BOOL bOpen = FALSE;
	try
	{
		bOpen = m_file.Open( m_strFileName, CFile::modeCreate|CFile::modeReadWrite|CFile::modeNoTruncate );
	}
	catch( CException* e)
	{
		e->Delete();
		TRACE( _T("file %s open fail\n"), m_strFileName);
		return FALSE;
	}
	if ( bOpen == TRUE )
		m_bOpen = true;
	else
		m_bOpen = false;
*/
	return TRUE;
}

BOOL CVirtualSaveFile::SvrCloseFile( )
{
//	m_file.Close();
//	m_bOpen = false;
	return TRUE;
}

BOOL CVirtualSaveFile::SvrDelFile( )
{
	DeleteFile( m_strFileName );
	return TRUE;
}

//////////////////////////////////////////////////////////////////////
// CVirtualSaveFileBlock Class
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
DWORD CVirtualSaveFileBlock::m_dwAllocSize = 4 * 1024; //(4k)
//	XZQ	2003.12.24
CByteArray	CVirtualSaveFileBlock::m_arrayRunCode;
CVirtualSaveFileBlock::CVirtualSaveFileBlock( DWORD dwFilePos, DWORD dwSize, bool bLoad, CVirtualSaveFile* pSaveFile, MCGSDATETIME timeStart, MCGSDATETIME timeEnd  )
{
	if(m_dwAllocSize == 0)	//只读一次
	{
		m_dwAllocSize = SvrGetAllocSaveBlockSize();
	}
	ARRAYRESIZE( m_buff, 0 );
	m_dwFilePos = dwFilePos;
	m_timeStart = timeStart;
	m_timeEnd = timeEnd;
	m_pSaveFile = pSaveFile;
	m_bLoad = bLoad;
	m_strGroupName = _T("");
	m_lSingleBlockSize = 0;
}

CVirtualSaveFileBlock::~CVirtualSaveFileBlock()
{

}

DWORD CVirtualSaveFileBlock::SvrGetAllocSaveBlockSize()
{
	//直接返回4096
	return 4096;
}

void CVirtualSaveFileBlock::mfReleaseGroupVar( BYTEARRAY& buff, CString & strField, COleDateTime& timeReturn  )
{
	long lngSize = 0;
	COwnerArchive ar(COwnerArchive::storing);
	ar.SvrWrite( buff ); 
	ar.SvrSeekToBegin();
	ar.SvrChangeMode( COwnerArchive::load );
#ifdef _MCGS_OLEDATETIME_	
	ar >> timeReturn;
#else
	//lzlzlz
	time_t t;
	ar >> t;
	timeReturn = COleDateTime(t);
#endif
}

FILE_ERROR CVirtualSaveFileBlock::SvrNetDBReadData( COleDateTime& timeBegin, long& lngRecNum, BYTEARRAY& buffReturn )
{
	if ( m_timeEnd > timeBegin )
	{
		int bLoad = m_bLoad;
		if ( bLoad == false )
		{
			SvrLoadBlock();
		}
		long lngPos = 0;
		BYTEARRAY buff;
		COleDateTime time;
		while( lngPos < ARRAYSIZE(m_buff) )
		{	
			mfReadRecord( m_buff, lngPos, buff );
			mfReleaseGroupVar ( buff, CString( MCGS_TIME_FIELD ), time );
			if ( time > timeBegin )
			{
				buffReturn.Append( buff );
				lngRecNum++;
				if ( lngRecNum >= 30 )
					return S_FILE_OK;
			}
		}

	}
	return S_FILE_OK;
}

//lzlzlz
FILE_ERROR CVirtualSaveFileBlock::SvrAppendRecord( MCGSDATETIME& time, BYTEARRAY& buff )
{
#ifdef _MCGS_OLEDATETIME_
	int iHeadSize = 14;
#else
	int iHeadSize = 4;
#endif
	//应该是+8，而不是+4 zzm
	if ( ARRAYSIZE( buff ) + ARRAYSIZE(m_buff) + (long)(iHeadSize*sizeof(long) + 8 ) <= (long)m_dwAllocSize )
	{
		long lngPos = ARRAYSIZE( m_buff );
		ARRAYRESIZE( m_buff, ARRAYSIZE( buff ) + ARRAYSIZE( m_buff ) + sizeof(long) );
		long lngBuffSize = ARRAYSIZE( buff );
		memcpy ( ARRAYDATA(	m_buff ) + lngPos, &lngBuffSize, sizeof(long) );
		memcpy ( ARRAYDATA( m_buff ) + lngPos + sizeof(long), ARRAYDATA( buff ), ARRAYSIZE ( buff ) );
		if ( time < m_timeStart ) m_timeStart = time;
		if ( time > m_timeEnd ) m_timeEnd = time;
		return S_FILE_OK;
	}

	return S_FILE_WITHOUT_ENOUGN_SPACE;
}

long CVirtualSaveFileBlock::SvrGetBlock( CString strGroupName,
								STRINGARRAY& arrayFieldNames,
								COleDateTime& tBegin,
								COleDateTime& tEnd,
								CArray<CList<COleVariant,COleVariant>*,CList<COleVariant,COleVariant>*>& listValueBuffer
								)
{
	if(listValueBuffer.GetSize() <= 0)	
	{
		//岂有此理，什么都不要，你进来作甚么
		return 0;
	}

	if(CVirtualInfoFile::SvrIsStopGettingData() == true)
	{
		//已经获取了需要的记录数目，停止获取
		return 0;
	}
	
	DWORD dwS = GetTickCount();

	m_strGroupName = strGroupName;
	int bLoad = m_bLoad;
	if ( bLoad == false )
	{
		SvrLoadBlock();
	}

	DWORD dwE1 = GetTickCount();
	//TRACE(_T("Load one block time %d\n"), dwE1 - dwS);
	
	BYTEARRAY buff, buffDest;
	COleDateTime time,tLast = tBegin;

	SYSTEMTIME sysTime;
	tBegin.GetAsSystemTime(sysTime);
	time_t tLast1 = CTime(sysTime).GetTime();

	CArray<CList<COleVariant,COleVariant>*,CList<COleVariant,COleVariant>*> listValueBufferInv;	

	BOOL bO2N_Dec = CVirtualInfoFile::m_wInvRead == (MCGS_READDATA_O2N | MCGS_READDATA_DEC);
	BOOL bAllocTemp = ((CVirtualInfoFile::m_wInvRead & MCGS_READDATA_N2O) 
		== MCGS_READDATA_N2O) || bO2N_Dec;
	//是否只统计记录数目
	BOOL bOnlyCount = (CVirtualInfoFile::m_wInvRead & MCGS_READDATA_ONLYCOUNT) == 
		MCGS_READDATA_ONLYCOUNT;

	if(bAllocTemp == TRUE)
	{
		//两种情况下分配临时数组
		//1.逆序读取
		//2.顺序读取，并且降序输出
		int iCount = listValueBuffer.GetSize();
		for(int i = 0; i< iCount; i++)
		{
			listValueBufferInv.Add(new CList<COleVariant,COleVariant>);
		}
	}
	
	long lngNum = 0, lngPos = 0;
	while( lngPos < ARRAYSIZE(m_buff) )
	{	
		mfReadRecord( m_buff, lngPos, buff );
		if(bOnlyCount == TRUE)
		{
#ifndef _MCGS_OLEDATETIME_		
			time_t t;
			memcpy(&t, buff.GetData(), sizeof(time_t));
			time = COleDateTime(t);
#endif
			if(time < tBegin || time > tEnd)
			{
				continue;
			}
			//需要记录最新记录的时间
			CVirtualInfoFile::m_tIniEndTime = time;	
			//只获取记录数目
			lngNum++;
			CVirtualInfoFile::m_iTotalReadRecords++;

			continue;
		}
		if(bAllocTemp == FALSE)
		{
			if(mfGetFieldBuffEx ( buff, listValueBuffer, arrayFieldNames,
				tBegin,tEnd, tLast, tLast1) == true)
			{
				lngNum++;
				CVirtualInfoFile::m_iTotalReadRecords++;
			}

			if(CVirtualInfoFile::SvrIsStopGettingData() == true)
			{
				//已经获取了需要的记录数目，停止获取
				break;
			}
		}
		else
		{
			//逆序情况下，先全部顺序读出来
			if(mfGetFieldBuffEx ( buff, listValueBufferInv, arrayFieldNames,
				tBegin,tEnd, tLast, tLast1) == true)
			{
				lngNum++;
				CVirtualInfoFile::m_iTotalReadRecords++;
			}
		}
	}
	
	if(bAllocTemp == TRUE)	
	{
		//加入到listValueBuffer中
		CVirtualInfoFile::m_iTotalReadRecords -= lngNum;
		int iSize = listValueBuffer.GetSize();

		CArray<POSITION, POSITION> aryPos;
		for(int j = 0; j < iSize; j++)
		{
			if(bO2N_Dec == FALSE)
			{
				aryPos.Add(listValueBufferInv[j]->GetTailPosition());
			}
			else
			{
				aryPos.Add(listValueBufferInv[j]->GetHeadPosition());
			}
		}

		DWORD wAsc = CVirtualInfoFile::m_wInvRead & MCGS_READDATA_ASC;
		while(aryPos[0] != NULL)
		{
			for(int j = 0; j < iSize; j++)
			{
				if(bO2N_Dec == FALSE)
				{
					if( wAsc == MCGS_READDATA_ASC)
					{
						listValueBuffer[j]->AddHead(listValueBufferInv[j]->GetPrev(aryPos[j]));
					}
					else
					{
						listValueBuffer[j]->AddTail(listValueBufferInv[j]->GetPrev(aryPos[j]));
					}
				}
				else
				{
					//顺序读取，降序输出
					listValueBuffer[j]->AddHead(listValueBufferInv[j]->GetNext(aryPos[j]));
				}
			}
			CVirtualInfoFile::m_iTotalReadRecords++;
			if(CVirtualInfoFile::SvrIsStopGettingData() == true)
			{
				//已经获取了需要的记录数目，停止获取
				break;
			}
		}

		for(int i = 0; i< iSize; i++)
		{
			delete listValueBufferInv[i];
			listValueBufferInv[i] = NULL; 
		}
	}

	//lzlzlz 2003.6.25
	long lngSize = listValueBuffer[0]->GetCount();
	long lSize = ARRAYSIZE(listValueBuffer);
	for ( int i = 0; i < lSize; i++ )
	{
		//ASSERT ( listValueBuffer[i]->GetCount() == lngSize );
	}

	if ( bLoad == false )
	{
		SvrUnloadBlock();
	}
	
	DWORD dwE2 = GetTickCount();
	TRACE(_T("Seek one block time %d(count: %d)\n"), dwE2 - dwE1,lngNum);
	
	return lngNum;
}


FILE_ERROR CVirtualSaveFileBlock::SvrLoadBlock( )
{
	if ( m_pSaveFile == NULL ) 
	{
		return S_FILE_OPERATOR_INVALID;
	}
	if(m_pSaveFile->SvrReadBlock( m_dwFilePos, m_buff ) == S_FILE_OK)
	{
		m_bLoad = true;
		return S_FILE_OK;
	}
	else
	{
		m_bLoad = false;
		return S_FILE_READ_FAIL;
	}
}

FILE_ERROR CVirtualSaveFileBlock::SvrUnloadBlock( )
{
	ARRAYRESIZE( m_buff, 0 );
	m_bLoad = false;
	return S_FILE_OK;	
}

int CVirtualSaveFileBlock::mfInStr( STRINGARRAY& strArray, CString& str )
{
	long lngPos = -1;
	for ( int i = 0; i < ARRAYSIZE(strArray); i++ )
	{
		if ( strArray[i].CompareNoCase(str) == 0 )
		{
			lngPos = i;