vbf_compressedpersist.cpp

数据压缩的实例

#include "stdafx.h"
#include "VBF_CompressedPersist.h"

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


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//1:modeRead
//2:modeWrite | modeCreate
//3:modeWrite
/*
template <class TYPE> 
int CCompressedPersist<TYPE>::GetFlagType(TYPE*,unsigned int nOpenFlags)
{
	ASSERT(FALSE);//此函数模版必须特化
	return 0;
}
template <> 
int CCompressedPersist<CFile>::GetFlagType(CFile*,unsigned int nOpenFlags)
{

	if(nOpenFlags == CFile::modeRead) return MODE_READ;
	if(nOpenFlags == (CFile::modeWrite | CFile::modeCreate) ) return MODE_CREATE;
	if(nOpenFlags == CFile::modeWrite) return MODE_WRITE;
	return 0;
}

template <> 
int CCompressedPersist<IStream>::GetFlagType(IStream*,unsigned int nOpenFlags)
{
	if(nOpenFlags == STGM_READ) return MODE_READ;
	if(nOpenFlags == (STGM_CREATE|STGM_WRITE) ) return MODE_CREATE;
	if(nOpenFlags == STGM_WRITE) return MODE_WRITE;	
	return 0;
}

template <> 
int CCompressedPersist<CVBF_Stream>::GetFlagType(CVBF_Stream*,unsigned int nOpenFlags)
{
	if(nOpenFlags == STGM_READ) return MODE_READ;
	if(nOpenFlags == (STGM_CREATE|STGM_WRITE) ) return MODE_CREATE;
	if(nOpenFlags == STGM_WRITE) return MODE_WRITE;	
	return 0;
}
*/
template <class TYPE> 
void CCompressedPersist<TYPE>::Write(TYPE* pPersist,const void* lpBuf, UINT nCount )
{
	ASSERT(FALSE);//此函数模版必须特化
}

template <> 
void CCompressedPersist<CFile>::Write(CFile* pFile,const void* lpBuf, UINT nCount )
{
	pFile->Write(lpBuf, nCount );
}
template <> 
void CCompressedPersist<CMemFile>::Write(CMemFile* pFile,const void* lpBuf, UINT nCount )
{
	pFile->Write(lpBuf, nCount );
}
/*
template <> 
void CCompressedPersist<CVBF_Stream>::Write(CVBF_Stream* pStream,const void* lpBuf, UINT nCount )
{
	pStream->Write(lpBuf, nCount );
}
*/
template <> 
void CCompressedPersist<IStream>::Write(IStream* pStream,const void* lpBuf, UINT nCount )
{
	pStream->Write(lpBuf,nCount,NULL);
}

template <class TYPE> 
UINT CCompressedPersist<TYPE>::Read(TYPE* pPersist,void* lpBuf, UINT nCount )
{
	ASSERT(FALSE);//此函数模版必须特化
	return 0;
}
template <> 
UINT CCompressedPersist<CFile>::Read(CFile* pFile,void* lpBuf, UINT nCount )
{
	return pFile->Read(lpBuf,nCount);
}
template <> 
UINT CCompressedPersist<CMemFile>::Read(CMemFile* pFile,void* lpBuf, UINT nCount )
{
	return pFile->Read(lpBuf,nCount);
}
template <> 
UINT CCompressedPersist<IStream>::Read(IStream* pStream,void* lpBuf, UINT nCount )
{
	ULONG cbRead;
	pStream->Read(lpBuf,nCount,&cbRead);
	return cbRead;
}
/*
template <> 
UINT CCompressedPersist<CVBF_Stream>::Read(CVBF_Stream* pStream,void* lpBuf, UINT nCount )
{
	return pStream->Read(lpBuf,nCount);
}
*/
template <class TYPE> 
LONG CCompressedPersist<TYPE>::Seek(TYPE* pPersist,LONG lOff, DWORD nFrom )
{
	ASSERT(FALSE);//此函数模版必须特化
	return 0;
}
template <> 
LONG CCompressedPersist<CFile>::Seek(CFile* pFile,LONG lOff, DWORD nFrom )
{
	return pFile->Seek(lOff,nFrom);
}
template <> 
LONG CCompressedPersist<CMemFile>::Seek(CMemFile* pFile,LONG lOff, DWORD nFrom )
{
	return pFile->Seek(lOff,nFrom);
}
template <> 
LONG CCompressedPersist<IStream>::Seek(IStream* pStream,LONG lOff, DWORD nFrom )
{
	ULARGE_INTEGER libNewPosition;

	DWORD dwOrigin = nFrom;
	LARGE_INTEGER liOffset;	
	LISet32(liOffset, lOff);
	HRESULT h = pStream->Seek(liOffset,dwOrigin,&libNewPosition);
	if(h == S_OK) return libNewPosition.LowPart;
	else return 0;
}
/*
template <> 
LONG CCompressedPersist<CVBF_Stream>::Seek(CVBF_Stream* pStream,LONG lOff, DWORD nFrom )
{
	return pStream->Seek(lOff,nFrom);
}
*/
template <class TYPE> 
DWORD CCompressedPersist<TYPE>::GetLength( TYPE* pPersist ) 
{
	ASSERT(FALSE);//此函数模版必须特化
	return 0;
}
template <> 
DWORD CCompressedPersist<CFile>::GetLength( CFile* pFile ) 
{
	return pFile->GetLength();
}
template <> 
DWORD CCompressedPersist<CMemFile>::GetLength( CMemFile* pFile ) 
{
	return pFile->GetLength();
}
template <> 
DWORD CCompressedPersist<IStream>::GetLength( IStream* pStream ) 
{
	STATSTG statstg;
	pStream->Stat(&statstg, STATFLAG_DEFAULT);
	ULARGE_INTEGER& size = statstg.cbSize;
	return (DWORD)size.LowPart;
}
/*
template <> 
DWORD CCompressedPersist<CVBF_Stream>::GetLength( CVBF_Stream* pStream ) 
{
	return pStream->GetLength();
}

*/