C++序列化方法 参考google protobuf

参考google protobuf而得来的一种更简化的序列化方法，现在只实现了基础类型的序列化，但是可以很容易扩展来支持各种STL容器，扩展容易，使用方便。而且支持在现有的代码上扩展。只需要给现有的累写一个序列化方法就可以使用。

下面列出4个文件内容

WHBSerial.h

/**
* nWHBSerial
*
* Author: Wang Haibo
* Date: 2015.5.6
*/


#ifndef _WHBSerial_H_
#define _WHBSerial_H_


namespace WHBSerialN {


enum RealType {
REALTYPE_BYTE1 = 0,
REALTYPE_BYTE2 = 1,
REALTYPE_BYTE4 = 2,
REALTYPE_BYTE8 = 3,
REALTYPE_BYTEN = 4,
REALTYPE_GROUP = 5,
};


enum SerialErrorFlag
{
Serial_Succ = 0,
Serial_Error = 0x01,
Serial_EnterGroupFailed = 0x02,
};




typedef signed char sc_t;
typedef signed short ss_t;
typedef signed int si_t;
typedef signed long sl_t;
typedef signed long long sll_t;


typedef unsigned char uc_t;
typedef unsigned short us_t;
typedef unsigned int ui_t;
typedef unsigned long ul_t;
typedef unsigned long long ull_t;


static const ui_t VARINT32_BYTE_LEN = 5;


static const ui_t TAG_MASK = 0X7;
static const ui_t TAG_BITES_LEN = 3;
static const ui_t TAG_GROUP_END = REALTYPE_GROUP;


static const ui_t MAX_VARINT_BYTE1 = 0X80;
static const ui_t MAX_VARINT_BYTE2 = 0X4000;
static const ui_t MAX_VARINT_BYTE3 = 0X200000;
static const ui_t MAX_VARINT_BYTE4 = 0X10000000;


typedef uc_t* buf_type;


class WHBSerial
{
public:
//construct destruct
inline WHBSerial() : m_cur_buf(0), m_end_buf(0), m_flag(0) {}
inline WHBSerial(void* buf, ui_t len) {init(buf, len);}
public:
inline void init(void* buf, ui_t len) {m_cur_buf = (buf_type)buf; m_end_buf = (buf_type)buf + len; m_flag = 0;}
inline buf_type get_cur_buf() const { return m_cur_buf; }
public:
inline bool has_error() const { return m_flag != 0; }
inline bool has_group_enter_error() const { return (m_flag & Serial_EnterGroupFailed) != 0; }
inline bool no_error() const { return !has_error(); }
protected:
inline ui_t make_tag(RealType real_type, ui_t index) { return (index << TAG_BITES_LEN) + real_type; }
inline void set_error() { m_flag |= Serial_Error; }
inline void set_group_enter_error() { m_flag |= Serial_EnterGroupFailed; }
inline void clear_group_enter_error() { m_flag &=  ~(uc_t(Serial_EnterGroupFailed)); }
protected:
buf_type m_cur_buf;
buf_type m_end_buf;
uc_t m_flag;
};
} // namespace WHBSerial


#endif // _NWHBSerial_H_

WHBSerialTo.h

/**
* WHBSerialTo
*
* Author: Wang Haibo
* Date: 2015.5.6
* Desc: serial a struct to stream
* Restriction: first, the index must in order ASC; second only unsigned and real are implement
*/


#ifndef WHBSerialTo_H_
#define WHBSerialTo_H_


#include "WHBSerial.h"
#include <vector>


namespace WHBSerialN {


static const sc_t MAX_INT_8 = 0X7F;
static const ss_t MAX_INT_16 = 0X7FFF;
static const si_t MAX_INT_32 = 0X7FFFFFFF;


static const sc_t MIN_INT_8 = (-128);
static const ss_t MIN_INT_16 = (-32768);
static const si_t MIN_INT_32 = (-2147483647 - 1);


static const uc_t MAX_UINT_8 = 0XFF;
static const us_t MAX_UINT_16 = 0XFFFF;
static const ui_t MAX_UINT_32 = 0XFFFFFFFF;


class WHBSerialTo : public WHBSerial
{
public:
//construct deconstruct
inline WHBSerialTo() { }
inline WHBSerialTo(void* buf, ui_t len) : WHBSerial(buf, len){ }
public:
//bool
inline void var(ui_t index, bool value, bool _default = false){if(value != _default)write(index, value);}
//char
inline void var(ui_t index, char value, char _default = 0){if(value != _default)write(index, value);}
//singed
inline void var(ui_t index, sc_t value, sc_t _default = 0){if(value != _default)write(index, value);}
inline void var(ui_t index, ss_t value, ss_t _default = 0){if(value != _default)write(index, value);}
inline void var(ui_t index, si_t value, si_t _default = 0){if(value != _default)write(index, value);}
inline void var(ui_t index, sl_t value, sl_t _default = 0){if(value != _default)write(index, value);}
inline void var(ui_t index, sll_t value, sll_t _default = 0){if(value != _default)write(index, value);}
//unsigned
inline void var(ui_t index, uc_t value, uc_t _default = 0){if(value != _default)write(index, value);}
inline void var(ui_t index, us_t value, us_t _default = 0){if(value != _default)write(index, value);}
inline void var(ui_t index, ui_t value, ui_t _default = 0){if(value != _default)write(index, value);}
inline void var(ui_t index, ul_t value, ul_t _default = 0){if(value != _default)write(index, value);}
inline void var(ui_t index, ull_t value, ull_t _default = 0){if(value != _default)write(index, value);}
//real
inline void var(ui_t index, float value, float _default = 0.0f) { if(value != _default)write(index, value);}
inline void var(ui_t index, double value, double _default = 0.0) { if(value != _default)write(index, value);}


//bool
inline void vars(ui_t index, const bool* values, ui_t num, bool _default = false){write_vars_with_tag(index, values, num, _default);}
//char
inline void vars(ui_t index, const char* values, ui_t num, char _default = 0){write_vars_with_tag(index, values, num, _default);}
//signed
inline void vars(ui_t index, const sc_t* values, ui_t num, sc_t _default = 0){write_vars_with_tag(index, values, num, _default);}
inline void vars(ui_t index, const ss_t* values, ui_t num, ss_t _default = 0){write_vars_with_tag(index, values, num, _default);}
inline void vars(ui_t index, const si_t* values, ui_t num, si_t _default = 0){write_vars_with_tag(index, values, num, _default);}
inline void vars(ui_t index, const sl_t* values, ui_t num, sl_t _default = 0){write_vars_with_tag(index, values, num, _default);}
inline void vars(ui_t index, const sll_t* values, ui_t num, sll_t _default = 0){write_vars_with_tag(index, values, num, _default);}
//unsigned
inline void vars(ui_t index, const uc_t* values, ui_t num, uc_t _default = 0){write_vars_with_tag(index, values, num, _default);}
inline void vars(ui_t index, const us_t* values, ui_t num, us_t _default = 0){write_vars_with_tag(index, values, num, _default);}
inline void vars(ui_t index, const ui_t* values, ui_t num, ui_t _default = 0){write_vars_with_tag(index, values, num, _default);}
inline void vars(ui_t index, const ul_t* values, ui_t num, ul_t _default = 0){write_vars_with_tag(index, values, num, _default);}
inline void vars(ui_t index, const ull_t* values, ui_t num, ull_t _default = 0){write_vars_with_tag(index, values, num, _default);}
//real
inline void vars(ui_t index, const float* values, ui_t num, float _default = 0.0f){write_vars_with_tag(index, values, num, _default);}
inline void vars(ui_t index, const double* values, ui_t num, double _default = 0.0){write_vars_with_tag(index, values, num, _default);}


inline void bytes(ui_t index, const void* value, ui_t len);


inline void group_begin(ui_t index){write_tag(REALTYPE_GROUP, index); }
inline void group_end(){write_fixed(static_cast<uc_t>(REALTYPE_GROUP)); }
private:
//bool
inline void write(ui_t index, bool value){write_tag(REALTYPE_BYTE1, index); write_fixed(value);}
//char
inline void write(ui_t index, char value){write_tag(REALTYPE_BYTE1, index); write_fixed(value);}
//signed
inline void write(ui_t index, sc_t value){write_tag(REALTYPE_BYTE1, index); write_fixed(value);}
inline void write(ui_t index, ss_t value){write_svar_with_tag(index, value);}
inline void write(ui_t index, si_t value){write_svar_with_tag(index, value);}
inline void write(ui_t index, sl_t value){write_svar_with_tag(index, value);}
inline void write(ui_t index, sll_t value){write_svar_with_tag(index, value);}
//unsigned
inline void write(ui_t index, uc_t value){write_tag(REALTYPE_BYTE1, index); write_fixed(value);}
inline void write(ui_t index, us_t value){write_uvar_with_tag(index, value);}
inline void write(ui_t index, ui_t value){write_uvar_with_tag(index, value);}
inline void write(ui_t index, ul_t value){write_uvar_with_tag(index, value);}
inline void write(ui_t index, ull_t value){write_uvar_with_tag(index, value);}
//real
inline void write(ui_t index, float value) { write_tag(REALTYPE_BYTE4, index); write_fixed(value);}
inline void write(ui_t index, double value) { write_tag(REALTYPE_BYTE8, index);write_fixed(value);}
private:
template<typename _Ty>
inline void write_fixed(_Ty value);
inline void write_fixed(const void* value, ui_t size);
inline void write_tag(RealType real_type, ui_t index);
inline void write_var32_no_tag(ui_t value);
inline void write_svar_with_tag(ui_t index, ss_t value);
inline void write_svar_with_tag(ui_t index, si_t value);
inline void write_svar_with_tag(ui_t index, sl_t value);
inline void write_svar_with_tag(ui_t index, sll_t value);


inline void write_uvar_with_tag(ui_t index, us_t value);
inline void write_uvar_with_tag(ui_t index,