数据库操作集

最新推荐文章于 2021-09-29 11:38:21 发布
最新推荐文章于 2021-09-29 11:38:21 发布
阅读量800 收藏
点赞数
分类专栏： erlang 软件工程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaodan007/article/details/22829803
版权 
/********************************************************************
 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; 
}


xiaodan007
关注
专栏目录
ABAQUS 错误整理及解决方法
张子轩的博客
04-03 3万+
本文欲整理我在使用ABAQUS过程中遇到的错误，分析其原因并解决，仅供参考。
oracle数据库升级导致的数据库对象不可用或无效解决办法
czl8897098的博客
11-05 2426
前端时间，公司集体升级数据库版本，由于数据库的版本与服务器版本不对应导致升级失败，而我又没有提前对服务器进行数据备份，升级失败后导致，数据库无法使用，虽然可以连接进行查询查询操作，但是无法进行复杂的数据库操作（比如数据导出操作，表结构修改。。。），通过  selectobject_type,object_id,object_name   from user_objects  where st
识别无效对象和不可用对象
wbj19890107的专栏
03-13 2258
---------- pl/sql对象和视图可能变得“无效(invaid)”；索引可能变得“不可用(unusable)” 根据对象无效的原因，下次访问时，对象可能自动变得有效。 而对于不可用索引而言，无法采用自动方式，必须通过重新生成才能变得有效。 如果某个过程对象（如存储的pl/sql函数或视图）变为无效，那么dba不必执行任何操作。首次访问这个对象时，oracle会尝试进行重新编译，而
DB使用的一些错误
wuwei178的博客
09-29 1389
OSError: [WinError 126] 找不到指定的模块。 参考博客：OSError: [WinError 126] 找不到指定的模块————Shapely - 程序员大本营 1.找到shapely下的dll文件： 路径和箭头指示的那里对应 2.将dll文件复制粘贴到Library/bin下： 运行程序，成功解决。 OSError: [WinError 123] 文件名、目录名或卷标语法不正确。: 'workspace\\SegDetectorModel-seg_detec.
ROM的定义
cumao2792的博客
09-13 1448
Definition: Read Only Memory (ROM) is computer memory that can permanently store data and applications within it. There are various types of ROM with names like EPROM (Eraseable ROM) or EEPROM (Elect...
基于Java的数据库操作工具集设计源码
最新发布
10-04
该项目是一款基于Java开发的数据库操作工具集源码，包含57个文件，涵盖42个Java源文件、2个PNG图片文件、2个JavaScript文件、1个Git忽略文件、1个LICENSE文件、1个Markdown文件、1个XML文件、1个CSS文件、1个EOT字体...
MySQL数据库操作显示数据库创建数据库删除数据库查看数据库的字符集显示表创建表表选项删除。。。.pdf
06-16
MySQL数据库是广泛应用于网站...总结起来，MySQL数据库操作涉及对数据库和数据表的全面管理，包括创建、删除、查看、选择以及修改等操作。了解并熟练掌握这些基础操作，是成为一名合格的数据库管理员或开发者的基础。
Oracle 数据库操作技巧集
09-11
Oracle数据库是全球广泛...Oracle数据库操作技巧集旨在提供全面的指导，帮助用户更好地管理和优化数据库，提升工作效率，保障系统的稳定运行。在实际工作中，不断实践和学习新的技术，是成为Oracle数据库大师的关键。
修改数据库字符集修改数据库字符集.doc
06-04
总的来说，修改数据库字符集是一项涉及多步骤且可能影响系统稳定性的操作，需要对数据库有深入理解并遵循最佳实践。在数据库维护和升级过程中，字符集的适配是不容忽视的一个环节，它确保了数据的正确存储和跨语言...
易语言-数据库操作模块
06-29
在易语言中，数据库操作是常见且重要的功能，尤其是在开发需要存储和检索数据的应用时。本模块专注于易语言中的数据库操作，特别是针对SQLite数据库的源码实现。 SQLite是一个轻量级、开源的嵌入式数据库，广泛应用...
RAM和ROM的区别
Sunshine_Dawn的博客
01-26 3408
RAM-RamdomAccessMemory易挥发性随机存取存储器，高速存取，读写时间相等，且与地址无关，如计算机内存等。 ROM-Read Only Memory只读存储器。断电后信息不丢失，如计算机启动用的BIOS芯片。存取速度很低，（较RAM而言）且不能改写。由于不能改写信息，不能升级，现已很少使用。ROM和RAM是计算机内存储器的两种型号， 1、ROM表示的是只读存储器，即：它只能读出信
设计模式总结－Memento模式
Derekjiang的笔记簿
10-21 927
一、Memento模式的目的：memento是一个保存另外一个对象内部状态拷贝的对象.这样以后就可以将该对象恢复到原先保存的状态.二、Memento模式的简单例子：下面的例子来源于Jdon网站的《GoF设计模式系列》的《Memento模式》，虽然简单却形象地表明了Memento模式的应用public class Originator { 　　private int number;
ROM（read-only-memory）
LYR 的博客
05-09 1947
ROM是只读存储器（Read-Only Memory）的简称，是一种只能读出事先所存数据的固态半导体存储器。其特性是一旦储存资料就无法再将之改变或删除。通常用在不需经常变更资料的电子或电脑系统中，并且资料不会因为电源关闭而消失 ROM 是只读存储器，不像随机存储器能快速方便地改写存储内容。ROM所存数据稳定 ，断电后所存数据也不会改变。 部分 ROM 可读可写，当时效率肯定 不然 随机读写的效率高 改写ROM可利用高电压（或者紫外线）将资料编程写入，因此写的效率要低的多。 ROM 的主要分类： 我.
android获取全部ram和rom,ROM与RAM的那点事,超详细解说
weixin_36211536的博客
05-27 398
该楼层疑似违规已被系统折叠隐藏此楼查看此楼以下部分内容来自网络整合系统启动时会先给硬件分配内存，这里分配的内存是不可见的，就像参数1G RAM ，实际可用最多只有700多M一样 就像 剩余600M/总内存780M 那200多不见了的就是送硬件了以我的为例，可200多M的RAM到底哪去了??看下面的代码(如何看到下面的代码？ADB dmesg就行了)下面代码有些是英语缩写 我也不知道是什么硬...
Memento
weixin_30432579的博客
08-05 103
Memento 提供了保存对象状态的能力，似乎没有什么好说的。 C＃code1//Memento23//Intent:"Withoutviolatingencapsulation,captureandexternalizean4//object'sinternalstatesothatanobjectcanberestoredtothis...
Read Only Memory - ROM
weixin_42167911的博客
12-07 457
In this article we introduce 4 main types of ROM - Mask ROM, PROM, (E)EPROM, Flash Memory
ROM （read only memory）
dazhi_100的专栏
06-20 2114
PC器材 　　英文简称ROM。ROM所存数据，一般是装入整机前事先写好的，整机工作过程中只能读出，而不像随机存储器那样能快速地、方便地加以改写。ROM所存数据稳定，断电后所存数据也不会改变；其结构较简单，读出较方便，因而常用于存储各种固定程序和数据。除少数品种的只读存储器（如字符发生器）可以通用之外，不同用户所需只读存储器的内容不同。为便于使 用和大批 量 生产 ，进一步发展了可编程只读存储
ZeroMQ线程通讯
xiaodan007的专栏
06-12 2546
源代码示例: git clone git://github.com/imatix/zguide.git
新大陆计划
xiaodan007的专栏
05-28 1729
-module(res_prc). -behaviour(gen_fsm). -export([create/1]). -export([init/1, recv_prc/2]). -export([send_evt/2]). -record ( obj_data, { link = 0, data = [] } ). %% 初始化锁
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值