数据库操作集

/********************************************************************
 author  :   Clark/陈泽丹
 created :   2014-4-1
 purpose :   缓冲器
*********************************************************************/
#pragma once


//数据库类型标记
struct MEMENTO_TRANS_TYPE
{
	//只有BYTE大小
	enum 
	{
	};
};


//缓冲器
class DisposableBuf
{
public:
	size_t GetUsedSize()
	{
		return m_nonius_pos;
	}
	BYTE* CreateNoniusMemento(){ return mp_buf; }
	void Clear()
	{ 
		memset(mp_source, 0, m_size);
		m_nonius_pos = 0; 
		mp_buf = mp_source;
	}

protected:
	DisposableBuf( BYTE* _p_buf, size_t _buf_size ):mp_buf(_p_buf), mp_source(_p_buf), m_nonius_pos(0), m_size(_buf_size){}
	virtual ~DisposableBuf(){ mp_buf = NULL; }
	BOOL CanGoto( size_t _piece )
	{
		if( (m_nonius_pos + _piece) <= m_size )
			return TRUE;
		return FALSE;
	}
	void Goto( size_t _piece )
	{
		mp_buf += _piece;
		m_nonius_pos += _piece;
	}

protected:
	BYTE			*mp_buf;

private:
	BYTE			*mp_source;
	size_t			m_nonius_pos;
	size_t			m_size;
};


//--入栈缓冲器
class PushBufHelper;
struct IWriteMemento
{
	virtual BOOL WriteMemento( PushBufHelper& _push_buf ) = NULL;
};
class PushBufHelper: public DisposableBuf
{
public:
	PushBufHelper( BYTE* _p_buf, size_t _buf_size ):DisposableBuf(_p_buf, _buf_size){}
	BOOL Push( BYTE* _p_send, size_t _piece )
	{
		if( NULL != _p_send && CanGoto(_piece) )
		{
			memcpy(mp_buf, _p_send, _piece);
			Goto(_piece);
			return TRUE;
		}
		return FALSE;
	}
	BOOL Push( IWriteMemento* _p_write )
	{
		if( NULL != _p_write )
		{
			return _p_write->WriteMemento( *this );
		}
		return FALSE;
	}
};


//--出栈缓冲器
class PopBufHelper;
struct IReadMemento
{
	virtual BOOL ReadMemento( PopBufHelper& _pop_buf ) = NULL;
};
class PopBufHelper: public DisposableBuf
{
public:
	PopBufHelper( BYTE* _p_buf, size_t _buf_size ):DisposableBuf(_p_buf, _buf_size){}
	BOOL Pop( BYTE* _p_recv, size_t _piece )
	{
		if( NULL != _p_recv && CanGoto(_piece) )
		{
			memcpy(_p_recv, mp_buf, _piece);
			Goto(_piece);
			return TRUE;
		}
		return FALSE;
	}
	BOOL Pop( IReadMemento* _p_read )
	{
		if( NULL != _p_read )
		{
			return _p_read->ReadMemento(*this);
		}
		return FALSE; 
	}
};

/********************************************************************
 author  :   Clark/陈泽丹
 created :   2014-4-1
 purpose :   数据存贮流程框架
*********************************************************************/
#pragma once
#include "BufHelper.h"
#include "MapMementoTrans.h"




//数据存贮流程框架
template< class _KEY_TYPE, class _VAL_TYPE >
class MapMemento: public IWriteMemento, public IReadMemento
{
public:
	typedef hash_map< _KEY_TYPE, _VAL_TYPE >				MAP_TYPE;
	MapMemento( MAP_TYPE& _map_data ):mp_map_data(&_map_data){}

protected:
	// 全部保存
	BOOL WriteMemento( PushBufHelper& _buf )
	{
		//已用过的长度
		const size_t USED_LEN = _buf.GetUsedSize();

		//写入类型标志,标志既用于识别类型也用于说明该内存是初始化过的（因为合服的问题，数据初始化值可能有异常）
		BYTE type_sign = MapMementoWriteTrans<_KEY_TYPE, _VAL_TYPE>::QueryInterfaceType();
		if( !_buf.Push( &type_sign, sizeof(type_sign) ) )
			return FALSE;

		//记录长度空间的游标位置
		BYTE *p_nonius = _buf.CreateNoniusMemento();
		WORD write_size = 0;
		if( !_buf.Push( (BYTE*)&write_size, sizeof(write_size) ) )
			return FALSE;
		
		//写值
		auto FailedInItemWrite = [&_buf]( pair< _KEY_TYPE const, _VAL_TYPE >& _item ) -> bool
		{
			if( MapMementoWriteTrans<_KEY_TYPE, _VAL_TYPE>::IsDefaultVal(_item.second) )
			{
				return false;
			}
			MapMementoWriteTrans<_KEY_TYPE, _VAL_TYPE> write_memento(_item);
			if( write_memento.WriteMemento( _buf ) )
			{
				return false;
			}
			else
			{
				char Error[1024];
				_snprintf_s( Error, sizeof(Error) - 1, "保存数据超过容纳空间" );
				TRACELN(Error);
				return true;
			}
		};
		MAP_TYPE::iterator it = find_if( mp_map_data->begin(), mp_map_data->end(), FailedInItemWrite );

		//填写长度
		write_size = _buf.GetUsedSize() - ( sizeof(type_sign) + sizeof(write_size) + USED_LEN );
		memcpy(p_nonius, (BYTE*)&write_size, sizeof(write_size));
		if( mp_map_data->end() != it )
			return FALSE;
		return TRUE;
	}

	// 全部加载
	BOOL ReadMemento( PopBufHelper& _buf )
	{
		//已用过的长度
		const size_t USED_LEN = _buf.GetUsedSize();

		//清空
		mp_map_data->clear();

		//判断标志
		BYTE type_sign = 0;
		if( !_buf.Pop( &type_sign, sizeof(type_sign) ) )
			return FALSE;
		if( MapMementoReadTrans<_KEY_TYPE, _VAL_TYPE>::QueryInterfaceType() != type_sign )
			return FALSE;

		//读取长度
		WORD context_len = 0;
		if( !_buf.Pop( (BYTE*)&context_len, sizeof(context_len) ) )
			return FALSE;

		//总长度
		size_t total_len = USED_LEN + sizeof(type_sign) + sizeof(context_len) + context_len;

		//读各项值
		while( total_len > _buf.GetUsedSize() )
		{
			pair<_KEY_TYPE, _VAL_TYPE> item;
			//创建缓冲区辅助器和类型转换器
			MapMementoReadTrans<_KEY_TYPE, _VAL_TYPE> read_memento(item);
			if( read_memento.ReadMemento(  _buf ) )
			{
				if( !MapMementoReadTrans<_KEY_TYPE, _VAL_TYPE>::IsDefaultVal(item.second) )
				{
					mp_map_data->insert( item );
				}
			}
			else
			{
				char Error[1024];
				_snprintf_s( Error, sizeof(Error) - 1, "读取数据超过供及空间" );
				TRACELN(Error);
				break;
			}
		};
		if( total_len > _buf.GetUsedSize() )
			return FALSE;
		return TRUE;
	}

private:
	MAP_TYPE*												mp_map_data;
};



template< class _KEY_TYPE, class _VAL_TYPE >
class UseDefaultMap
{
public:
	//设值
	void Set( _KEY_TYPE _key, _VAL_TYPE _val )
	{
		if( MapMementoWriteTrans<_KEY_TYPE, _VAL_TYPE>::IsDefaultVal(_val) )
		{
			m_data_map.erase( _key );
		}
		else
		{
			m_data_map[_key] = _val;
		}
	}

	//取值
	void Get( _KEY_TYPE _key, _VAL_TYPE& _val )
	{
		hash_map< _KEY_TYPE, _VAL_TYPE >::iterator it = m_data_map.find(_key);
		if( m_data_map.end() != it )
		{
			_val = m_data_map[_key];
		}
		else
		{
			MapMementoWriteTrans<_KEY_TYPE, _VAL_TYPE>::GetDefaultVal( _val );
		}
	}

	MapMemento<_KEY_TYPE, _VAL_TYPE>  CreateMemento()
	{
		MapMemento<_KEY_TYPE, _VAL_TYPE> ret(m_data_map);
		return ret;
	}

private:
	hash_map< _KEY_TYPE, _VAL_TYPE >				m_data_map;
};

/********************************************************************
 author  :   Clark/陈泽丹
 created :   2014-4-1
 purpose :   备忘器
*********************************************************************/
#pragma once
#include "BufHelper.h"
#include "string"





//--------------------------------------------------------------------------
//写数据
template< class _KEY_TYPE, class _VAL_TYPE >
struct MapMementoWriteTrans{};

//读数据
template< class _KEY_TYPE, class _VAL_TYPE >
struct MapMementoReadTrans{};


//--------------------------------------------------------------------------
//check
struct VbosVesion{};
struct TransByteCheckDBData
{
	static const BYTE QueryInterfaceType();
	static BOOL IsDefaultVal( const VbosVesion& _val );
	static void GetDefaultVal( VbosVesion& _val );
};
template<>
class MapMementoWriteTrans< BYTE, VbosVesion >: public TransByteCheckDBData, public IWriteMemento
{
public:
	MapMementoWriteTrans( const pair< BYTE const, VbosVesion >& _item );
	virtual BOOL WriteMemento( PushBufHelper& _dest_buf );
};
template<>
class MapMementoReadTrans< BYTE, VbosVesion >: public TransByteCheckDBData, public IReadMemento
{
public:
	MapMementoReadTrans( pair< BYTE, VbosVesion >& _item );
	virtual BOOL ReadMemento( PopBufHelper& _src_buf );
};



//--------------------------------------------------------------------------
//check
struct ItaGDataVesion{};
struct TransByteCheckItaGDBData
{
	static const BYTE QueryInterfaceType();
	static BOOL IsDefaultVal( const ItaGDataVesion& _val );
	static void GetDefaultVal( ItaGDataVesion& _val );
};
template<>
class MapMementoWriteTrans< BYTE, ItaGDataVesion >: public TransByteCheckItaGDBData, public IWriteMemento
{
public:
	MapMementoWriteTrans( const pair< BYTE const, ItaGDataVesion >& _item );
	virtual BOOL WriteMemento( PushBufHelper& _dest_buf );
};
template<>
class MapMementoReadTrans< BYTE, ItaGDataVesion >: public TransByteCheckItaGDBData, public IReadMemento
{
public:
	MapMementoReadTrans( pair< BYTE, ItaGDataVesion >& _item );
	virtual BOOL ReadMemento( PopBufHelper& _src_buf );
};


//--------------------------------------------------------------------------
//word存贮
struct TransWordWord
{
	static const BYTE QueryInterfaceType();
	static BOOL IsDefaultVal( const WORD& _val );
	static void GetDefaultVal( WORD& _val );
};
template<>
class MapMementoWriteTrans< WORD, WORD >: public TransWordWord, public IWriteMemento
{
public:
	MapMementoWriteTrans( const pair< WORD const, WORD >& _item ):mp_item(&_item){}
	virtual BOOL WriteMemento( PushBufHelper& _dest_buf );
private:
	const pair< WORD const, WORD >* mp_item;
};
template<>
class MapMementoReadTrans< WORD, WORD >: public TransWordWord, public IReadMemento
{
public:
	MapMementoReadTrans( pair< WORD, WORD >& _item ):mp_item(&_item){}
	virtual BOOL ReadMemento( PopBufHelper& _src_buf );
private:
	pair< WORD, WORD >* mp_item;
};

//--------------------------------------------------------------------------
//dword存贮
struct TransDWordWord
{
	static const BYTE QueryInterfaceType();
	static BOOL IsDefaultVal( const DWORD& _val );
	static void GetDefaultVal( DWORD& _val );
};
template<>
class MapMementoWriteTrans< WORD, DWORD >: public TransDWordWord, public IWriteMemento
{
public:
	MapMementoWriteTrans( const pair< WORD const, DWORD >& _item ):mp_item(&_item){}
	virtual BOOL WriteMemento( PushBufHelper& _dest_buf );
private:
	const pair< WORD const, DWORD >* mp_item;
};
template<>
class MapMementoReadTrans< WORD, DWORD >: public TransDWordWord, public IReadMemento
{
public:
	MapMementoReadTrans( pair< WORD, DWORD >& _item ):mp_item(&_item){}
	virtual BOOL ReadMemento( PopBufHelper& _src_buf );
private:
	pair< WORD, DWORD >* mp_item;
};

//--------------------------------------------------------------------------
//字符串存贮
struct DbStr
{
	DbStr( char* _p_txt = "" );
	DbStr& operator = (DbStr& _left);
	char txt[256];
};
struct TransWordDbStr
{
	static const BYTE QueryInterfaceType();
	static BOOL IsDefaultVal( const DbStr& _val );
	static void GetDefaultVal( DbStr& _val );
};
template<>
class MapMementoWriteTrans< WORD, DbStr >: public TransWordDbStr, public IWriteMemento
{
public:
	MapMementoWriteTrans( const pair< WORD const, DbStr >& _item ):mp_item(&_item){}
	virtual BOOL WriteMemento( PushBufHelper& _dest_buf );
private:
	const pair< WORD const, DbStr >* mp_item;
};
template<>
class MapMementoReadTrans< WORD, DbStr >: public TransWordDbStr, public IReadMemento
{
public:
	MapMementoReadTrans( pair< WORD, DbStr >& _item ):mp_item(&_item){}
	virtual BOOL ReadMemento( PopBufHelper& _src_buf );
private:
	pair< WORD, DbStr >* mp_item;
};

#include "stdafx.h"
#include "MapMementoTrans.h"



const BYTE TransByteCheckDBData::QueryInterfaceType()
{
	return MEMENTO_TRANS_TYPE::VBOS_SAVE_VERSION; //验证码
}
BOOL TransByteCheckDBData::IsDefaultVal( const VbosVesion& _val ){ return TRUE; }
void TransByteCheckDBData::GetDefaultVal( VbosVesion& _val ){}
MapMementoWriteTrans< BYTE, VbosVesion >::MapMementoWriteTrans( const pair< BYTE const, VbosVesion >& _item ){}
BOOL MapMementoWriteTrans< BYTE, VbosVesion >::WriteMemento( PushBufHelper& _dest_buf ){ return TRUE; }
MapMementoReadTrans< BYTE, VbosVesion >::MapMementoReadTrans( pair< BYTE, VbosVesion >& _item ){}
BOOL MapMementoReadTrans< BYTE, VbosVesion >::ReadMemento( PopBufHelper& _src_buf ){ return TRUE; }



const BYTE TransByteCheckItaGDBData::QueryInterfaceType()
{
	return MEMENTO_TRANS_TYPE::ITS_W_DB_VERSION; //验证码
}
BOOL TransByteCheckItaGDBData::IsDefaultVal( const ItaGDataVesion& _val ){ return TRUE; }
void TransByteCheckItaGDBData::GetDefaultVal( ItaGDataVesion& _val ){}
MapMementoWriteTrans< BYTE, ItaGDataVesion >::MapMementoWriteTrans( const pair< BYTE const, ItaGDataVesion >& _item ){}
BOOL MapMementoWriteTrans< BYTE, ItaGDataVesion >::WriteMemento( PushBufHelper& _dest_buf ){ return TRUE; }
MapMementoReadTrans< BYTE, ItaGDataVesion >::MapMementoReadTrans( pair< BYTE, ItaGDataVesion >& _item ){}
BOOL MapMementoReadTrans< BYTE, ItaGDataVesion >::ReadMemento( PopBufHelper& _src_buf ){ return TRUE; }

//--------------------------------------------------------------------------
//word型
const BYTE TransWordWord::QueryInterfaceType()
{
	return MEMENTO_TRANS_TYPE::VBOS_W_W_VERSION;
}
BOOL TransWordWord::IsDefaultVal( const WORD& _val )
{
	return ( 0 == _val );
}
void TransWordWord::GetDefaultVal( WORD& _val )
{
	_val = 0;
}
BOOL MapMementoWriteTrans< WORD, WORD >::WriteMemento( PushBufHelper& _dest_buf ) 
{
	//记录Key值
	if( !_dest_buf.Push( (BYTE*)&(mp_item->first), sizeof(mp_item->first) ) )
		return FALSE;
	//记录内容
	if( !_dest_buf.Push( (BYTE*)&(mp_item->second), sizeof(mp_item->second) ) )
		return FALSE;
	return TRUE;
}
BOOL MapMementoReadTrans< WORD, WORD >::ReadMemento( PopBufHelper& _src_buf )
{
	//读取Key值
	if( !_src_buf.Pop( (BYTE*)&(mp_item->first), sizeof(mp_item->first) ) )
		return FALSE;
	//读取Key值
	if( !_src_buf.Pop( (BYTE*)&(mp_item->second), sizeof(mp_item->second) ) )
		return FALSE;
	return TRUE;
}


//--------------------------------------------------------------------------
//dword型
const BYTE TransDWordWord::QueryInterfaceType()
{
	return MEMENTO_TRANS_TYPE::VBOS_W_DW_VERSION;
}
BOOL TransDWordWord::IsDefaultVal( const DWORD& _val )
{
	return ( 0 == _val );
}
void TransDWordWord::GetDefaultVal( DWORD& _val )
{
	_val = 0;
}
BOOL MapMementoWriteTrans< WORD, DWORD >::WriteMemento( PushBufHelper& _dest_buf ) 
{
	//记录Key值
	if( !_dest_buf.Push( (BYTE*)&(mp_item->first), sizeof(mp_item->first) ) )
		return FALSE;
	//记录内容
	if( !_dest_buf.Push( (BYTE*)&(mp_item->second), sizeof(mp_item->second) ) )
		return FALSE;
	return TRUE;
}
BOOL MapMementoReadTrans< WORD, DWORD >::ReadMemento( PopBufHelper& _src_buf )
{
	//读取Key值
	if( !_src_buf.Pop( (BYTE*)&(mp_item->first), sizeof(mp_item->first) ) )
		return FALSE;
	//读取Key值
	if( !_src_buf.Pop( (BYTE*)&(mp_item->second), sizeof(mp_item->second) ) )
		return FALSE;
	return TRUE;
}


//--------------------------------------------------------------------------
//字符串型
DbStr::DbStr( char* _p_txt )
{
	if( NULL == _p_txt )
	{
		strcpy( txt, "" );
	}
	else
	{
		size_t len = strlen(_p_txt);
		if( len >= sizeof(txt) )
		{
			strcpy( txt, "" );
		}
		else
		{
			memcpy( txt, _p_txt, len );
			txt[len] = '\0';
		}
	}
}
DbStr& DbStr::operator = (DbStr& _left)
{
	memcpy( txt, _left.txt, sizeof(txt)-1 );
	txt[sizeof(txt)-1] = '\0';
	return *this;
}

//---------------------------------------------------------------
const BYTE TransWordDbStr::QueryInterfaceType()
{
	return MEMENTO_TRANS_TYPE::VBOS_W_S_VERSION;
}
BOOL TransWordDbStr::IsDefaultVal( const DbStr& _val )
{
	if( 0 == strcmp(_val.txt, "") )
		return TRUE;
	else
		return FALSE;
}
void TransWordDbStr::GetDefaultVal( DbStr& _val )
{
	strcpy( _val.txt, "" );
}
BOOL MapMementoWriteTrans< WORD, DbStr >::WriteMemento( PushBufHelper& _dest_buf )
{
	//记录Key值
	if( !_dest_buf.Push( (BYTE*)&(mp_item->first), sizeof(mp_item->first) ) )
		return FALSE;
	//记录长度
	BYTE len = strlen(mp_item->second.txt);
	if( !_dest_buf.Push( (BYTE*)&len, sizeof(len) ) )
		return FALSE;
	//记录内容
	if( !_dest_buf.Push( (BYTE*)&(mp_item->second), len ) )
		return FALSE;
	return TRUE;
}
BOOL MapMementoReadTrans< WORD, DbStr >::ReadMemento( PopBufHelper& _src_buf )
{
	//读取Key值
	if( !_src_buf.Pop( (BYTE*)&(mp_item->first), sizeof(mp_item->first) ) )
		return FALSE;
	//读取长度
	BYTE len = 0;
	if( !_src_buf.Pop( (BYTE*)&len, sizeof(len) ) )
		return FALSE;
	//读取内容
	char txt[1024];
	if( !_src_buf.Pop( (BYTE*)&txt, len ) )
		return FALSE;
	if( len < 1024 )
		txt[len] = '\0';
	else
		txt[1023] = '\0';
	DbStr temp(txt);
	mp_item->second = temp;
	return TRUE;
}

/********************************************************************
 author  :   Clark/陈泽丹
 created :   2014-4-1
 purpose :   数据存贮流程框架
*********************************************************************/
#pragma once
#include "BufHelper.h"
#include "VctMementoTrans.h"



//数据存贮流程框架
template< class _VAL_TYPE >
class VctMemento: public IWriteMemento, public IReadMemento
{
public:
	VctMemento( vector< _VAL_TYPE >& _vct_data ):mp_vct_data(&_vct_data){}

protected:
	// 全部保存
	BOOL WriteMemento( PushBufHelper& _buf )
	{
		//已用过的长度
		const size_t USED_LEN = _buf.GetUsedSize();

		//写入类型标志,标志既用于识别类型也用于说明该内存是初始化过的（因为合服的问题，数据初始化值可能有异常）
		BYTE type_sign = VctMementoWriteTrans< _VAL_TYPE >::QueryInterfaceType();
		if( !_buf.Push( &type_sign, sizeof(type_sign) ) )
			return FALSE;

		//记录长度空间的游标位置
		BYTE *p_nonius = _buf.CreateNoniusMemento();
		WORD write_size = 0;
		if( !_buf.Push( (BYTE*)&write_size, sizeof(write_size) ) )
			return FALSE;

		//写值
		auto FailedIn_valWrite = [&_buf]( _VAL_TYPE& _val ) -> bool
		{
			if( VctMementoWriteTrans<_VAL_TYPE>::IsDefaultVal(_val) )
			{
				return false;
			}
			VctMementoWriteTrans<_VAL_TYPE> write_memento(_val);
			if( write_memento.WriteMemento( _buf ) )
			{
				return false;
			}
			else
			{
				char Error[1024];
				_snprintf_s( Error, sizeof(Error) - 1, "VctMementoWriteTrans 保存数据超过容纳空间 %d ", _buf.GetUsedSize() );
				TRACEERR(Error);
				return true;
			}
		};
		vector< _VAL_TYPE >::iterator it = find_if( mp_vct_data->begin(), mp_vct_data->end(), FailedIn_valWrite );

		//填写长度
		write_size = _buf.GetUsedSize() - ( sizeof(type_sign) + sizeof(write_size) + USED_LEN );
		memcpy(p_nonius, (BYTE*)&write_size, sizeof(write_size));
		if( mp_vct_data->end() != it )
			return FALSE;
		return TRUE;
	}

	// 全部加载
	BOOL ReadMemento( PopBufHelper& _buf )
	{
		//已用过的长度
		const size_t USED_LEN = _buf.GetUsedSize();

		//清空
		mp_vct_data->clear();

		//判断标志
		BYTE type_sign = 0;
		if( !_buf.Pop( &type_sign, sizeof(type_sign) ) )
			return FALSE;
		if( VctMementoReadTrans<_VAL_TYPE>::QueryInterfaceType() != type_sign )
			return FALSE;

		//读取长度
		WORD context_len = 0;
		if( !_buf.Pop( (BYTE*)&context_len, sizeof(context_len) ) )
			return FALSE;

		//总长度
		size_t total_len = USED_LEN + sizeof(type_sign) + sizeof(context_len) + context_len;

		//读各项值
		while( total_len > _buf.GetUsedSize() )
		{
			_VAL_TYPE _val;
			//创建缓冲区辅助器和类型转换器
			VctMementoReadTrans<_VAL_TYPE> read_memento(_val);
			if( read_memento.ReadMemento(_buf) )
			{
				if( !VctMementoReadTrans<_VAL_TYPE>::IsDefaultVal(_val) )
				{
					mp_vct_data->push_back(_val);
				}
			}
			else
			{
				char Error[1024];
				_snprintf_s( Error, sizeof(Error) - 1, "读取数据超过供及空间" );
				TRACEERR(Error);
				break;
			}
		};
		if( total_len > _buf.GetUsedSize() )
			return FALSE;
		return TRUE;
	}

private:
	vector< _VAL_TYPE >*	mp_vct_data;
};

/********************************************************************
 author  :   Clark/陈泽丹
 created :   2014-4-1
 purpose :   备忘器
*********************************************************************/
#pragma once
#include "BufHelper.h"



//--------------------------------------------------------------------------
//写数据
template< class _VAL_TYPE >
class VctMementoWriteTrans
{
public:
	VctMementoWriteTrans( _VAL_TYPE& _item ):mp_item(&_item){}
	static const BYTE QueryInterfaceType()
	{
		return _VAL_TYPE::QueryInterfaceType();
	}
	static BOOL IsDefaultVal( const _VAL_TYPE& _val )
	{
		return _VAL_TYPE::IsDefaultVal(_val);
	}
	static void GetDefaultVal( _VAL_TYPE& _val )
	{
		return _VAL_TYPE::GetDefaultVal(_val);
	}
	virtual BOOL WriteMemento( PushBufHelper& _dest_buf )
	{
		IWriteMemento *p_write = static_cast<IWriteMemento*>(mp_item);
		return p_write->WriteMemento(_dest_buf);
	}

private:
	_VAL_TYPE* mp_item;
};

//读数据
template< class _VAL_TYPE >
class VctMementoReadTrans
{
public:
	VctMementoReadTrans( _VAL_TYPE& _item ):mp_item(&_item){}
	static const BYTE QueryInterfaceType()
	{
		return _VAL_TYPE::QueryInterfaceType();
	}
	static BOOL IsDefaultVal( const _VAL_TYPE& _val )
	{
		return _VAL_TYPE::IsDefaultVal(_val);
	}
	static void GetDefaultVal( _VAL_TYPE& _val )
	{
		return _VAL_TYPE::GetDefaultVal(_val);
	}
	virtual BOOL ReadMemento( PopBufHelper& _dest_buf )
	{
		IReadMemento *p_read = static_cast<IReadMemento*>(mp_item);
		return p_read->ReadMemento(_dest_buf);
	}

private:
	_VAL_TYPE* mp_item;
};



//--------------------------------------------------------------------------
//check
struct RuneVesion{};
struct TransVctByteCheckDBData
{
	static const BYTE QueryInterfaceType();
	static BOOL IsDefaultVal( const RuneVesion& _val );
	static void GetDefaultVal( RuneVesion& _val );
};
template<>
class VctMementoWriteTrans< RuneVesion >: public TransVctByteCheckDBData, public IWriteMemento
{
public:
	VctMementoWriteTrans( const RuneVesion& _item ){}
	virtual BOOL WriteMemento( PushBufHelper& _dest_buf );
};
template<>
class VctMementoReadTrans< RuneVesion >: public TransVctByteCheckDBData, public IReadMemento
{
public:
	VctMementoReadTrans( RuneVesion& _item ){}
	virtual BOOL ReadMemento( PopBufHelper& _src_buf );
};


//OfflinePrize
struct OfflinePrize
{
	OfflinePrize():prize_index(0){}
	WORD prize_index;
};
struct TransVctOfflinePrize
{
	static const BYTE QueryInterfaceType();
	static BOOL IsDefaultVal( const OfflinePrize& _val );
	static void GetDefaultVal( OfflinePrize& _val );
};
template<>
class VctMementoWriteTrans< OfflinePrize >: public TransVctOfflinePrize, public IWriteMemento
{
public:
	VctMementoWriteTrans( const OfflinePrize& _item ):m_item(_item){}
	virtual BOOL WriteMemento( PushBufHelper& _dest_buf );
private:
	OfflinePrize m_item;
};
template<>
class VctMementoReadTrans< OfflinePrize >: public TransVctOfflinePrize, public IReadMemento
{
public:
	VctMementoReadTrans( OfflinePrize& _item ):m_item(&_item){}
	virtual BOOL ReadMemento( PopBufHelper& _src_buf );
private:
	OfflinePrize* m_item;
};

#include "stdafx.h"
#include "VctMementoTrans.h"




const BYTE TransVctByteCheckDBData::QueryInterfaceType()
{
	return MEMENTO_TRANS_TYPE::RUNE_PART_VERSION; //验证码
}
BOOL TransVctByteCheckDBData::IsDefaultVal( const RuneVesion& _val ){ return TRUE; }
void TransVctByteCheckDBData::GetDefaultVal( RuneVesion& _val ){}
BOOL VctMementoWriteTrans< RuneVesion >::WriteMemento( PushBufHelper& _dest_buf ){ return TRUE; }
BOOL VctMementoReadTrans< RuneVesion >::ReadMemento( PopBufHelper& _src_buf ){ return TRUE; }





const BYTE TransVctOfflinePrize::QueryInterfaceType()
{
	return MEMENTO_TRANS_TYPE::VBOS_OLP_VERSION;
}
BOOL TransVctOfflinePrize::IsDefaultVal( const OfflinePrize& _val )
{
	return FALSE;
}
void TransVctOfflinePrize::GetDefaultVal( OfflinePrize& _val )
{
	_val.prize_index = 0;
}
BOOL VctMementoWriteTrans< OfflinePrize >::WriteMemento( PushBufHelper& _dest_buf )
{ 
	_dest_buf.Push( (BYTE*)&(m_item.prize_index), sizeof(m_item.prize_index) );
	return TRUE; 
}
BOOL VctMementoReadTrans< OfflinePrize >::ReadMemento( PopBufHelper& _src_buf )
{ 
	_src_buf.Pop( (BYTE*)&(m_item->prize_index), sizeof(m_item->prize_index) );
	return TRUE; 
}