virtualsavefile.cpp

mcgs的数据导出源代码

// VirtualSaveFile.cpp: implementation of the CVirtualSaveFile class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "VirtualSaveFile.h"
//lzlzlz
#include "VirtualInfoFile.h"
#include "Data_Trans.h"

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

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

CVirtualSaveFile::CVirtualSaveFile( CString strFileName, 								   
								   MCGSDATETIME timeStart, 
								   MCGSDATETIME timeEnd )
{
	//lzlzlz
	m_pInfoFile = NULL;
	m_dwFilePos = 0;
	m_bLoadFile = false;
	m_bOpen = false;
	m_strFileName = strFileName;
	m_pCurSaveBlock = NULL;
	m_timeStart = timeStart;
	m_timeEnd = timeEnd;

	m_lSingleFileSize = 0;
	m_dwAllocSize = 0;
	m_lSingleBlockSize = 0;
}

CVirtualSaveFile::~CVirtualSaveFile()
{
	for ( int i = 0; i < ARRAYSIZE(m_arraySaveBlock); i++ )
	{
		if ( m_arraySaveBlock[i] != NULL )
		{
			delete m_arraySaveBlock[i];
		}
	}
	ARRAYCLEAR( m_arraySaveBlock );
}

DWORD CVirtualSaveFile::SvrGetSaveBlockNum()
{
	//直接返回 8。上位机组态部分在这里写的太乱了
	//导致下载下来得东西乱七八糟得。zzm 2003 11 11
	//发行在即，先固定大小了。
	return 8;
}

DWORD CVirtualSaveFile::SvrGetBlockSize()
{
	//直接返回4096
	return 4096;
}

BOOL CVirtualSaveFile::SvrUnloadBlocks ( )
{
	/*
	for ( int i = 0; i < ARRAYSIZE(m_arraySaveBlock); i++ )
	{
		m_arraySaveBlock[i]->SvrUnloadBlock();
	}
	*/

	for ( int i = 0; i < ARRAYSIZE(m_arraySaveBlock); i++ )
	{
		if ( m_arraySaveBlock[i] != NULL )
		{
			delete m_arraySaveBlock[i];
		}
	}
	ARRAYCLEAR( m_arraySaveBlock );

	m_bLoadFile = false;
	return TRUE;
}

FILE_ERROR CVirtualSaveFile::SvrNetDBReadData( COleDateTime& time, long& lngRecNum, BYTEARRAY& buff )
{
	mfCheckLoad();
	if ( lngRecNum >= 30 ) return S_FILE_OK;
	for ( int i = 0; i < ARRAYSIZE(m_arraySaveBlock); i++ )
	{
		m_arraySaveBlock[i]->SvrNetDBReadData( time, lngRecNum, buff );
		if ( lngRecNum >= 30 ) return S_FILE_OK;
	}
	return S_FILE_OK;
}

FILE_ERROR CVirtualSaveFile::SvrQueryLastSaveTime( COleDateTime& time )
{
	if ( m_pCurSaveBlock != NULL )
		time = m_pCurSaveBlock->SvrGetEndTime();
	return S_FILE_OK;
}

//lzlzlz
FILE_ERROR CVirtualSaveFile::SvrAppendRecord ( MCGSDATETIME& time, BYTEARRAY& buff )
{
	FILE_ERROR err = S_FILE_OK;
	if ( m_pCurSaveBlock != NULL )
	{
		err = m_pCurSaveBlock->SvrAppendRecord( time, buff );
		//penghong add 为了处理保存数据大于我们默认的块的大小
		if (err == S_FILE_WITHOUT_ENOUGN_SPACE \
			&& m_pCurSaveBlock->SvrGetSize() == 0)
		{
			TRACE(_T("此次保存数据量大于1页数据\n"));
			//AfxMessageBox(_T("此次保存数据量大于1页数据\n"));
			return S_FILE_WITHOUT_ENOUGN_SPACE;
		}
		//penghong add 为了处理保存数据大于我们默认的块的大小
	}
	if ( m_pCurSaveBlock == NULL || err == S_FILE_WITHOUT_ENOUGN_SPACE )
	{
		if ( m_pCurSaveBlock != NULL )
		{
			

		/*	TRY
			{
				m_file.Open( m_strFileName, CFile::modeRead );
				dwPos = m_file.GetLength();
				m_file.Close();
			}
			CATCH( CFileException, e)
			{
				e->Delete();
				TRACE( _T("file %s open fail\n"), m_strFileName);
				return S_FILE_WRITE_ERROR;
			}
			END_CATCH*/

		}

		DWORD dwAllockSize = 0;
		if(m_dwAllocSize == 0)
		{
			dwAllockSize = CVirtualSaveFileBlock::SvrGetAllocSaveBlockSize();
			m_dwAllocSize = dwAllockSize;
		}
		else
		{
			dwAllockSize = m_dwAllocSize;
		}
		long lFileSize = 0;
		if( m_lSingleFileSize == 0)
		{
			lFileSize = (long)SvrGetSaveBlockNum();
			m_lSingleFileSize = lFileSize;
		}
		else
		{
			lFileSize = m_lSingleFileSize;
		}
		if ( ARRAYSIZE(m_arraySaveBlock) >= lFileSize )
		{
			m_pCurSaveBlock = NULL;
			return S_FILE_WITHOUT_ENOUGN_SPACE;
		}
		CVirtualSaveFileBlock *pSaveBlock = SvrCreateNewSaveBlock( m_dwFilePos, dwAllockSize, true, time,time );

		if ( time < m_timeStart ) m_timeStart = time;
		if ( time > m_timeEnd ) m_timeEnd = time;
		
		m_pCurSaveBlock = pSaveBlock;
		//pSaveBlock -> SvrInit();
		return m_pCurSaveBlock->SvrAppendRecord( time, buff );
	}
	else if ( err != S_FILE_OK )
	{
		return err;
	}
	else
	{

		if ( time < m_timeStart ) m_timeStart = time;
		if ( time > m_timeEnd ) m_timeEnd = time;
		return S_FILE_OK;
	}
}

//先采用不定长制，即一个块紧跟另一个块
//协议xxxx--xxxx--tttt--tttt---data---tail
//xxxx为data长度
//tttt为起始时间和结束时间
//data不带压缩
//tail为8个'X'

FILE_ERROR CVirtualSaveFile::SvrLoadSaveBlock( bool bCurSaveFile,BOOL bLoadFromExistFile )
{
	TRACE(_T("装载%s\n"),this->m_strFileName);
	DWORD dwS = GetTickCount(); 

	ASSERT(m_bLoadFile == false);
	m_bLoadFile = true;
	BOOL bOpen = FALSE;
	TRY
	{
		bOpen = m_file.Open( m_strFileName, CFile::modeRead );
		if ( bOpen == FALSE )
		{
			
			if(bLoadFromExistFile)
			{
				//文件不存在，说明arrayInfo得信息和磁盘不一致，应该
				//删除这个信息，所以返回bad
				return S_FILE_BE_BAD;
			}
			else
			{
				//这个分支是在创建新得存盘文件，读不到是正常的
				return S_FILE_READ_FAIL;
			}
		}
	}
	CATCH( CFileException,e )
	{
		e->Delete();
		TRACE( _T("file %s open fail\n"), m_strFileName);		
		return S_FILE_BE_BAD;
	}
	END_CATCH

	DWORD dwE1 = GetTickCount(); 	
	TRACE(_T("Open file Time %d\n"), dwE1 - dwS);

	BYTEARRAY buff;
	TRY
	{
		m_file.SeekToBegin();
	}
	CATCH( CFileException,e )
	{
		e->Delete();
		TRACE( _T("file %s seek fail\n"), m_strFileName);		
		return S_FILE_BE_BAD;
	}
	END_CATCH
	DWORD dwSize = 0;
	TRY
	{
		DWORD fileSize =  m_file.GetLength();
		long lFileSize = 0;
		long lBlockSize = 0;
		if( m_lSingleFileSize == 0)
		{
			lFileSize = (long)SvrGetSaveBlockNum();
			m_lSingleFileSize = lFileSize;
		}
		else
		{
			lFileSize = m_lSingleFileSize;
		}
		if(m_lSingleBlockSize == 0)
		{
			lBlockSize = (long)SvrGetBlockSize();
			if(lBlockSize <= 0)
			{
				lBlockSize = 4096;
			}
			m_lSingleBlockSize = lBlockSize;
		}
		else
		{
			lBlockSize = m_lSingleBlockSize;
		}

		if(fileSize < 2*sizeof(DWORD) )
		{
			return S_FILE_BE_BAD;
		}

		m_file.Seek(fileSize - sizeof(DWORD),CFile::begin);
		m_file.Read(&dwSize,sizeof(DWORD));
		m_dwFilePos = dwSize;

		m_file.Seek(fileSize - 2 * sizeof(DWORD),CFile::begin);
		m_file.Read(&dwSize,sizeof(DWORD));
		if(m_dwFilePos != dwSize)
		{
			//最后两个DWORD看来并非长度信息，这是老版本的存盘数据文件
			//扩充这个文件长度到法定大小
			dwSize = fileSize;
			m_dwFilePos = dwSize;
			m_file.SetLength(m_lSingleBlockSize*m_lSingleFileSize + 2 * sizeof(DWORD));
		}

		if(fileSize != m_lSingleBlockSize*m_lSingleFileSize + 2 * sizeof(DWORD))
		{
			return S_FILE_BE_BAD;
		}

		m_file.SeekToBegin();
	}
	CATCH( CFileException,e )
	{
		e->Delete();
		TRACE( _T("file %s getlength fail\n"), m_strFileName);		
		return S_FILE_BE_BAD;
	}
	END_CATCH
	BYTEARRAY buffTime;
	MCGSDATETIME timeBegin, timeEnd;
	long lngPos = 0;
	DWORD dwAllocSize = 0;

	if(m_dwAllocSize == 0)
	{
		dwAllocSize = CVirtualSaveFileBlock::SvrGetAllocSaveBlockSize();
		m_dwAllocSize = dwAllocSize;
	}
	else
	{
		dwAllocSize = m_dwAllocSize;
	}
	while( lngPos < (long)dwSize )
	{
		bool bCheck = true;
		long lngOldPos = lngPos;

		//读字节数目
		long lngRecSize1 = 0;
		long lngRecSize2 = 0;
		lngPos += 2*sizeof(long);
		if ( lngPos > (long)dwSize )
		{
			bCheck = false;
			break;
		}
		TRY
		{
			m_file.Read( &lngRecSize1, sizeof(long) );
			m_file.Read( &lngRecSize2, sizeof(long) );
		}
		CATCH( CFileException,e )
		{
			e->Delete();
			TRACE( _T("file %s open fail\n"), m_strFileName);		
			return S_FILE_BE_BAD;
		}
		END_CATCH

		if ( lngRecSize1 != lngRecSize2 )
		{
			m_file.Close();
			return S_FILE_BE_BAD;
		}
		
		//读时间段
		//lzlzlz
#ifdef _MCGS_OLEDATETIME_
		ARRAYRESIZE( buffTime, 12*sizeof(long) );
#else
		ARRAYRESIZE( buffTime, 2 * sizeof(long) );
#endif
		lngPos += ARRAYSIZE(buffTime);
		if ( lngPos > (long)dwSize )
		{
			bCheck = false;
			break;
		}
		TRY
		{
			m_file.Read( ARRAYDATA(buffTime), ARRAYSIZE(buffTime) );
		}
		CATCH( CFileException,e )
		{
			e->Delete();
			TRACE( _T("file %s open fail\n"), m_strFileName);		
			return S_FILE_BE_BAD;
		}
		END_CATCH

#ifndef _MCGS_OLEDATETIME_		
		memcpy(&timeBegin, buffTime.GetData(), sizeof(time_t));
		memcpy(&timeEnd, buffTime.GetData() + sizeof(time_t), sizeof(time_t));
#else
		int iYear, iMonth, iDay, iHour, iMinute, iSecond;
		BYTE* lPos = buffSrc.GetData();
		memcpy(&iYear, lPos, sizeof(int));
		memcpy(&iMonth, lPos + sizeof(int), sizeof(int));
		memcpy(&iDay, lPos + 2 * sizeof(int), sizeof(int));
		memcpy(&iHour, lPos + 3 * sizeof(int), sizeof(int));
		memcpy(&iMinute, lPos + 4 * sizeof(int), sizeof(int));
		memcpy(&iSecond, lPos + 5 * sizeof(int), sizeof(int));
		timeBegin = COleDateTime ( iYear, iMonth, iDay, iHour, iMinute, iSecond );

		lPos += 6 * sizeof(int);
		memcpy(&iYear, lPos, sizeof(int));
		memcpy(&iMonth, lPos + sizeof(int), sizeof(int));
		memcpy(&iDay, lPos + 2 * sizeof(int), sizeof(int));
		memcpy(&iHour, lPos + 3 * sizeof(int), sizeof(int));
		memcpy(&iMinute, lPos + 4 * sizeof(int), sizeof(int));
		memcpy(&iSecond, lPos + 5 * sizeof(int), sizeof(int));
		timeEnd = COleDateTime ( iYear, iMonth, iDay, iHour, iMinute, iSecond );

#endif

		//忽略数据区
		lngPos += lngRecSize1;		

		if ( lngPos > (long)dwSize )
		{
			bCheck = false;
			break;
		}
		long lngTmp = 0;

		TRY
		{
			lngTmp = m_file.Seek( lngRecSize1, CFile::current );
		}
		CATCH( CFileException,e )
		{
			e->Delete();
			TRACE( _T("file %s seek fail\n"), m_strFileName);		
			return S_FILE_BE_BAD;
		}
		END_CATCH		
		
		//判断结尾标志
		BYTEARRAY buffTail;
		ARRAYRESIZE( buffTail, 8 );
		lngPos += 8;
		if ( lngPos > (long)dwSize )
		{
			bCheck = false;
			break;
		}
		TRY
		{
			m_file.Read( ARRAYDATA(buffTail), 8 );
		}
		CATCH( CFileException,e )
		{
			e->Delete();
			TRACE( _T("file %s READ fail\n"), m_strFileName);		
			return S_FILE_BE_BAD;
		}
		END_CATCH

		for ( int k = 0; k < ARRAYSIZE(buffTail); k++ )
		{
			if ( buffTail[k] != 'X' )
			{
				bCheck = false;
				break;
			}
		}
		if ( bCheck == false )
		{
			break;
		}

#ifdef _DEBUG
	COleVariant vnt1 = COleDateTime(timeBegin);
	COleVariant vnt2 = COleDateTime(timeEnd);
#endif	
		SvrCreateNewSaveBlock( (DWORD)lngOldPos, dwAllocSize, false, timeBegin, timeEnd );
	}
	m_file.Close();

	if ( ARRAYSIZE(m_arraySaveBlock) > 0 && bCurSaveFile )
	{
		m_pCurSaveBlock = m_arraySaveBlock[ARRAYSIZE(m_arraySaveBlock)-1];
		if(S_FILE_OK != m_pCurSaveBlock->SvrLoadBlock())
		{
			/*delete m_pCurSaveBlock;
			m_pCurSaveBlock = NULL;
			ARRAYREMOVE(m_arraySaveBlock,ARRAYSIZE(m_arraySaveBlock)-1);*/
			//彻底废弃掉本文件。
			return S_FILE_BE_BAD;
		}
	}

	DWORD dwE2 = GetTickCount(); 
	TRACE(_T("Load Block Index Time %d\n"), dwE2 - dwE1);

	return S_FILE_OK;
}