streambuf.h

用到内存的序列化和反序列化

// StreamBuf.h: interface for the CStreamBuf class.
// luoxin 04-05-19
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_STREAMBUF_H__331CDA77_E7B6_41CE_A080_3B2C4B088DE8__INCLUDED_)
#define AFX_STREAMBUF_H__331CDA77_E7B6_41CE_A080_3B2C4B088DE8__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "Exlibrarydef.h"
#include "afxtempl.h"

/************************************************************************/
//							CStreamBufException
/************************************************************************/

class ExLIBRARYEXT CStreamBufException : public CException
{
	DECLARE_DYNAMIC(CStreamBufException)
public:
	enum { none, endOfBuf, errFormat};
	CStreamBufException(int cause = CStreamBufException::none):m_cause(cause){}

	int m_cause;
};

inline void ThrowStreamBufException(int cause)
	{THROW(new CStreamBufException(cause));}

#define ThrowSBException_ErrFormat()	ThrowStreamBufException(CStreamBufException::errFormat)
#define ThrowSBException_EndOfBuf()		ThrowStreamBufException(CStreamBufException::endOfBuf)

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

/************************************************************************/
//							CStreamBuf
/************************************************************************/
class ExLIBRARYEXT CStreamBuf  
{
public:
	enum SBIO{SBIOIn, SBIOOut};	//向CStreamBuf写入，从CStreamBuf读取

	//当pBuf为NULL时，就是用来计算需要的BUFFER长度，最后可以用GetDataSize()得到需要的长度
	CStreamBuf(PVOID pBuf, DWORD dwBufSize, SBIO io);
	virtual ~CStreamBuf(){}

	SBIO GetIOState()const;
	BOOL IsLoading()const;
	BOOL IsStoring()const;

	UINT Read(void* lpBuf, UINT nMax);
	UINT Write(const void* lpBuf, UINT nMax);
	void SkipReadTo(const void* lpFind, UINT nSize);	//从当前位置开始找到第一个与lpFind指向的内容一致的地方的结尾，将当前读取指针移动到这个地方后面一个位置

	DWORD GetLeftBufSize()const;
	DWORD GetDataSize()const;

	UINT WriteLineANSI(LPCTSTR lpszString);				//转换成为ANSI字符集写入
	UINT ReadLineANSI(LPTSTR lpszString, UINT nMax);	//以ANSI字符集方式读入，并转换成为相应字符集
	
public:
	// insertion operations
	CStreamBuf& operator<<(BYTE by);
	CStreamBuf& operator<<(WORD w);
	CStreamBuf& operator<<(LONG l);
	CStreamBuf& operator<<(DWORD dw);
	CStreamBuf& operator<<(float f);
	CStreamBuf& operator<<(double d);
	CStreamBuf& operator<<(ULONGLONG qw);
	CStreamBuf& operator<<(LONGLONG qws);
	CStreamBuf& operator<<(REFGUID guid);
	CStreamBuf& operator<<(const CString& string);

	CStreamBuf& operator<<(int i);
	CStreamBuf& operator<<(short w);
	CStreamBuf& operator<<(char ch);
	CStreamBuf& operator<<(unsigned u);
	CStreamBuf& operator<<(bool b);
	CStreamBuf& operator<<(const RECT& rc);
#ifdef _NATIVE_WCHAR_T_DEFINED
	CStreamBuf& operator<<(wchar_t ch);
#endif

	// extraction operations
	CStreamBuf& operator>>(BYTE& by);
	CStreamBuf& operator>>(WORD& w);
	CStreamBuf& operator>>(DWORD& dw);
	CStreamBuf& operator>>(LONG& l);
	CStreamBuf& operator>>(float& f);
	CStreamBuf& operator>>(double& d);
	CStreamBuf& operator>>(ULONGLONG& qw);
	CStreamBuf& operator>>(LONGLONG& qws);
	CStreamBuf& operator>>(GUID& guid);
	CStreamBuf& operator>>(CString& string);
	
	CStreamBuf& operator>>(int& i);
	CStreamBuf& operator>>(short& w);
	CStreamBuf& operator>>(char& ch);
	CStreamBuf& operator>>(unsigned& u);
	CStreamBuf& operator>>(bool& b);
	CStreamBuf& operator>>(RECT& rc);
#ifdef _NATIVE_WCHAR_T_DEFINED
	CStreamBuf& operator>>(wchar_t& ch);
#endif
	
protected:
	PBYTE const m_pBufEnd;
	PBYTE	m_pBufCur;
	SBIO	m_IO;
	
	DWORD m_dwDataSize;
};

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

#define CheckStreamBufSize(DataTYPE)	if(m_pBufCur&&GetLeftBufSize()<sizeof(DataTYPE))ThrowSBException_EndOfBuf();

inline CStreamBuf::CStreamBuf(PVOID pBuf, DWORD dwBufSize, SBIO io):
m_pBufCur((PBYTE)pBuf),m_pBufEnd((PBYTE)pBuf+dwBufSize),m_IO(io),m_dwDataSize(NULL)
{
}

inline CStreamBuf::SBIO CStreamBuf::GetIOState()const
	{return m_IO;}
inline BOOL CStreamBuf::IsLoading() const
	{return m_IO==SBIOOut;}
inline BOOL CStreamBuf::IsStoring() const
	{return m_IO==SBIOIn;}
inline DWORD CStreamBuf::GetLeftBufSize()const
	{ASSERT(m_pBufCur);ASSERT(m_pBufEnd>=m_pBufCur);
	return (m_pBufEnd-m_pBufCur);}
inline DWORD CStreamBuf::GetDataSize()const
	{return m_dwDataSize;}

//////////////////////////////////////////////////////////////////////////

inline CStreamBuf& CStreamBuf::operator<<(int i)
	{ return CStreamBuf::operator<<((LONG)i); }
inline CStreamBuf& CStreamBuf::operator<<(unsigned u)
	{ return CStreamBuf::operator<<((LONG)u); }
inline CStreamBuf& CStreamBuf::operator<<(short w)
	{ return CStreamBuf::operator<<((WORD)w); }
inline CStreamBuf& CStreamBuf::operator<<(char ch)
	{ return CStreamBuf::operator<<((BYTE)ch); }
inline CStreamBuf& CStreamBuf::operator<<(bool b)
	{ return CStreamBuf::operator <<((BYTE)(b ? 1 : 0)); }
inline CStreamBuf& CStreamBuf::operator<<(LONGLONG qws)
	{ return CStreamBuf::operator<<((ULONGLONG)qws); }
inline CStreamBuf& CStreamBuf::operator<<(const RECT& rc)
	{*this<<rc.left<<rc.right<<rc.top<<rc.bottom;return *this;}
#ifdef _NATIVE_WCHAR_T_DEFINED
inline CStreamBuf& CStreamBuf::operator<<(wchar_t ch)
	{ return CStreamBuf::operator<<((WORD)ch); }
#endif

#define SBWriteToBuf(DataType, DataName)\
{	ASSERT(IsStoring());\
	if(m_pBufCur){\
		*(UNALIGNED DataType*)m_pBufCur = DataName;\
		m_pBufCur += sizeof(DataType);\
	}\
	m_dwDataSize += sizeof(DataType);\
	return *this; \
}
 
#define SBCheckAndWriteToBuf(DataType, DataName) {CheckStreamBufSize(DataType);SBWriteToBuf(DataType, DataName)}

inline CStreamBuf& CStreamBuf::operator<<(BYTE by)
	{ SBCheckAndWriteToBuf(BYTE, by);}
inline CStreamBuf& CStreamBuf::operator<<(ULONGLONG qw)
	{ SBCheckAndWriteToBuf(ULONGLONG, qw);}
inline CStreamBuf& CStreamBuf::operator<<(WORD w)
	{ SBCheckAndWriteToBuf(WORD, w);}
inline CStreamBuf& CStreamBuf::operator<<(LONG l)
	{ SBCheckAndWriteToBuf(LONG, l);}
inline CStreamBuf& CStreamBuf::operator<<(DWORD dw)
	{ SBCheckAndWriteToBuf(DWORD, dw);}
inline CStreamBuf& CStreamBuf::operator<<(float f)
	{ CheckStreamBufSize(float);
	if(m_pBufCur){*(UNALIGNED _EXL_BYTE_FLOAT*)m_pBufCur = *(_EXL_BYTE_FLOAT*)&f; m_pBufCur += sizeof(float);}
	m_dwDataSize += sizeof(float); return *this;}
inline CStreamBuf& CStreamBuf::operator<<(double d)
	{ CheckStreamBufSize(double);
	if(m_pBufCur){*(UNALIGNED _EXL_BYTE_DOUBLE*)m_pBufCur = *(_EXL_BYTE_DOUBLE*)&d; m_pBufCur += sizeof(double); }
	m_dwDataSize += sizeof(double);return *this; }
inline CStreamBuf& CStreamBuf::operator<<(REFGUID guid)
	{SBCheckAndWriteToBuf(GUID, guid);}

//////////////////////////////////////////////////////////////////////////

inline CStreamBuf& CStreamBuf::operator>>(int& i)
	{ return CStreamBuf::operator>>((LONG&)i); }
inline CStreamBuf& CStreamBuf::operator>>(unsigned& u)
	{ return CStreamBuf::operator>>((LONG&)u); }
inline CStreamBuf& CStreamBuf::operator>>(short& w)
	{ return CStreamBuf::operator>>((WORD&)w); }
inline CStreamBuf& CStreamBuf::operator>>(char& ch)
	{ return CStreamBuf::operator>>((BYTE&)ch); }
inline CStreamBuf& CStreamBuf::operator>>(LONGLONG& qws)
	{ return CStreamBuf::operator>>((ULONGLONG&)qws); }
inline CStreamBuf& CStreamBuf::operator>>(bool& b)
	{ BYTE by; CStreamBuf& ar = CStreamBuf::operator>>(by); b = (by ? true : false); return ar; }
inline CStreamBuf& CStreamBuf::operator>>(RECT& rc)
	{*this>>rc.left>>rc.right>>rc.top>>rc.bottom;return *this;}
#ifdef _NATIVE_WCHAR_T_DEFINED
inline CStreamBuf& CStreamBuf::operator>>(wchar_t& ch)
	{ return CStreamBuf::operator>>((WORD&)ch); }
#endif

#define SBReadFromBuf(DataType, DataName)\
{	ASSERT(IsLoading());\
	if(m_pBufCur){\
		DataName = *(UNALIGNED DataType*)m_pBufCur; m_pBufCur += sizeof(DataType);}\
	m_dwDataSize += sizeof(DataType);\
	return *this;\
}
 
#define SBCheckAndReadFromBuf(DataType, DataName) {CheckStreamBufSize(DataType);SBReadFromBuf(DataType, DataName)}

inline CStreamBuf& CStreamBuf::operator>>(BYTE& by)
	{ SBCheckAndReadFromBuf(BYTE, by);}
inline CStreamBuf& CStreamBuf::operator>>(ULONGLONG& qw)
	{ SBCheckAndReadFromBuf(ULONGLONG, qw);}
inline CStreamBuf& CStreamBuf::operator>>(WORD& w)
	{ SBCheckAndReadFromBuf(WORD, w);}
inline CStreamBuf& CStreamBuf::operator>>(LONG& l)
	{ SBCheckAndReadFromBuf(LONG, l);}
inline CStreamBuf& CStreamBuf::operator>>(DWORD& dw)
	{ SBCheckAndReadFromBuf(DWORD, dw);}
inline CStreamBuf& CStreamBuf::operator>>(float& f)
	{ CheckStreamBufSize(float);
	if(m_pBufCur){*(_EXL_BYTE_FLOAT*)&f = *(UNALIGNED _EXL_BYTE_FLOAT*)m_pBufCur; m_pBufCur += sizeof(float);}
	m_dwDataSize += sizeof(float);return *this; }
inline CStreamBuf& CStreamBuf::operator>>(double& d)
	{ CheckStreamBufSize(double); 
	if(m_pBufCur){*(_EXL_BYTE_DOUBLE*)&d = *(UNALIGNED _EXL_BYTE_DOUBLE*)m_pBufCur; m_pBufCur += sizeof(double);}
	m_dwDataSize += sizeof(double);return *this; }
inline CStreamBuf& CStreamBuf::operator>>(GUID& guid)
	{SBCheckAndReadFromBuf(GUID, guid);}

//////////////////////////////////////////////////////////////////////////
// helper 
//////////////////////////////////////////////////////////////////////////

#define SBReadToArray(ar, array)\
{\
	int nCount; ar>>nCount; array.SetSize(nCount);\
	for(int i=0; i<nCount; i++)ar>>(array[i]);\
}

#define SBWriteFromArray(ar, array)\
{\
	ar<<array.GetSize();for(int i=0; i<array.GetSize(); i++)ar<<(array[i]);\
}


#endif // !defined(AFX_STREAMBUF_H__331CDA77_E7B6_41CE_A080_3B2C4B088DE8__INCLUDED_)