/**********************************************************************
* Copyright (C) 2015 - tx7do - All Rights Reserved
*
* 文件名称:        JsonSerializer.h
* 摘    要:        Json序列化工具
*
* 作    者:        yanglinbo, 
* 修    改:        查看文件最下方.
* 
***********************************************************************/

#ifndef __JsonSerializer_H__
#define __JsonSerializer_H__


#include <assert.h>
#include <vector>
#include <json/json.h>


typedef signed __int8           int8;
typedef unsigned __int8         uint8;
typedef signed __int16          int16;
typedef unsigned __int16        uint16;
typedef signed __int32          int32;
typedef unsigned __int32        uint32;
typedef signed __int64          int64;
typedef unsigned __int64        uint64;


class JsonSerializer
{
public:
    JsonSerializer();
    virtual~JsonSerializer();

    JsonSerializer& operator=(const JsonSerializer& other)
    {
        return *this;
    }

public:
    /// 序列化
    virtual const char* serialized() = 0;

    /// 反序列化
    virtual bool deserialize(const char* data, size_t size) = 0;

public:
    /// 清除缓存
    void clearBuffer();

    void resetReadPos() { readPos = 0; }
    void resetWritePos() { writePos = 0; }
    void resetPosition() { resetReadPos(); resetWritePos(); }

    /// 刷新json字符串
    const char* flush();

    /// 刷新成风格化的json字符串
    const std::string& style_flush();

    /// 是否具有该键
    bool isKeyValid(const std::string& key) const;
    bool isKeyValid(const char* key) const;

    /// 获取json字符串
    const std::string& getString() const { return document; }

public:
    /// 当开关打开的时候,所有的数据序列化为数组.
    void toArray() { bToArray = true; }

    /// 当开关打开的时候,序列化的json字符串将被zip压缩.解序列化之前,将会被zip解压缩.
    void enableZip() {  bEnableZip = true; }

public:
    void append(const std::string& key, const int8& value);

    void append(const std::string& key, const int16& value);

    void append(const std::string& key, const int32& value);

    void append(const std::string& key, const int64& value);

    void append(const std::string& key, const uint8& value);

    void append(const std::string& key, const uint16& value);

    void append(const std::string& key, const uint32& value);

    void append(const std::string& key, const uint64& value);

    /// 
    void append(const std::string& key, const float& value);

#ifdef _VECTOR_
    template <typename T>
        void append(const std::string& key, const std::vector<T>& value)
    {
        Json::Value arrayObj;

        if (!value.empty())
        {
            typename std::vector<T>::const_iterator iter    = value.begin();
            typename std::vector<T>::const_iterator& iEnd    = value.end();
            for (; iter != iEnd; ++iter)
            {
                arrayObj.append( *iter );
            }
        }
        else
        {
            arrayObj.resize(0);
        }

        if (bToArray || key.empty())
        {
            root.append(arrayObj);
        }
        else
        {
            root[key] = arrayObj;
        }

        if (bFlushNow) flush();
    }

    template <typename T>
        void appendEx(const std::string& key, std::vector<T>& value)
    {
        Json::Value arrayObj;

        if (!value.empty())
        {
            typename std::vector<T>::iterator iter    = value.begin();
            typename std::vector<T>::iterator& iEnd    = value.end();
            for (; iter != iEnd; ++iter)
            {
                T& current_value = *iter;
                current_value.clearBuffer();
                current_value.serialized();
                arrayObj.append( current_value.root );
            }
        }
        else
        {
            arrayObj.resize(0);
        }

        if (bToArray || key.empty())
        {
            root.append(arrayObj);
        }
        else
        {
            root[key] = arrayObj;
        }

        if (bFlushNow) flush();
    }

    template <typename V>
        bool read(const std::string& key, std::vector<V>& value)
    {
        Json::Value& arrayObj = bToArray ? root[readPos++] : root[key];

        value.clear();
        Json::Value::iterator iter = arrayObj.begin();
        Json::Value::iterator iEnd = arrayObj.end();
        for (; iter!=iEnd; ++iter)
        {
            value.push_back(readValue(*iter, V()));
        }
        return true;
    }

    template <typename V>
        bool readEx(const std::string& key, std::vector<V>& value)
    {
        Json::Value& arrayObj = bToArray ? root[readPos++] : root[key];

        value.clear();
        V vObj;
        Json::Value::iterator iter = arrayObj.begin();
        Json::Value::iterator iEnd = arrayObj.end();
        for (; iter!=iEnd; ++iter)
        {
            Json::Value& current_value = *iter;
            vObj.clearBuffer();
            vObj.root = current_value;
            vObj.deserialize(NULL, 0);
            value.push_back(vObj);
        }
        return true;
    }
#endif

#ifdef _LIST_
    template <typename T>
        void append(const std::string& key, const std::list<T>& value)
    {
        Json::Value arrayObj;

        if (!value.empty())
        {
            typename std::list<T>::const_iterator iter    = value.begin();
            typename std::list<T>::const_iterator& iEnd    = value.end();
            for (; iter != iEnd; ++iter)
            {
                arrayObj.append(*iter);
            }
        }
        else
        {
            arrayObj.resize(0);
        }

        if (bToArray || key.empty())
        {
            root.append(arrayObj);
        }
        else
        {
            root[key] = arrayObj;
        }

        if (bFlushNow) flush();
    }
    template <typename V>
        bool read(const std::string& key, std::list<V>& value)
    {
        Json::Value& arrayObj = bToArray ? root[readPos++] : root[key];

        value.clear();
        Json::Value::const_iterator iter = arrayObj.begin();
        Json::Value::const_iterator iEnd = arrayObj.end();
        for (; iter!=iEnd; ++iter)
        {
            value.push_back(read(*iter));
        }
    }
#endif

#ifdef _MAP_
    template <typename K, typename V>
        void append(const std::string& key, const std::map<K, V>& value)
    {
        Json::Value arrayObj;

        typename std::map<K, V>::const_iterator iter    = value.begin();
        typename std::map<K, V>::const_iterator& iEnd    = value.end();
        for (; iter != iEnd; ++iter)
        {
            arrayObj[iter->first] = (iter->second);
        }

        if (bToArray || key.empty())
        {
            root.append(arrayObj);
        }
        else
        {
            root[key] = arrayObj;
        }

        if (bFlushNow) flush();
    }
    template <typename K, typename V>
        bool read(const std::string& key, std::map<K, V>& value)
    {
        Json::Value arrayObj = root[key];

        value.clear();
    }
#endif

#ifdef _XSTRING_
    void append(const std::string& key, const std::string& value)
    {
        if (bToArray || key.empty())
        {
            root.append(value);
        }
        else
        {
            root[key] = value;
        }

        if (bFlushNow) flush();
    }
#endif

    void append(const std::string& key, JsonSerializer& value);

public:
    bool parse(const char* str, size_t size);

    bool read(const std::string& key, bool& value);

    bool read(const std::string& key, int8& value);
    int8 readValue(const Json::Value& v, int8 def=0) const;

    bool read(const std::string& key, int16& value);
    int16 readValue(const Json::Value& v, int16 def=0) const;

    bool read(const std::string& key, int32& value);
    int32 readValue(const Json::Value& v, int32 def=0) const;

    bool read(const std::string& key, int64& value);
    int64 readValue(const Json::Value& v, int64 def=0) const;

    bool read(const std::string& key, uint8& value);
    uint8 readValue(const Json::Value& v, uint8 def=0) const;

    bool read(const std::string& key, uint16& value);
    uint16 readValue(const Json::Value& v, uint16 def=0) const;

    bool read(const std::string& key, uint32& value);
    uint32 readValue(const Json::Value& v, uint32 def=0) const;

    bool read(const std::string& key, uint64& value);
    uint64 readValue(const Json::Value& v, uint64 def=0) const;

    bool read(const std::string& key, float& value);
    float readValue(const Json::Value& v, float def=0) const;

    bool read(const std::string& key, char* value);

#ifdef _XSTRING_
    bool read(const std::string& key, std::string& value)
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asCString();

        return true;
    }
    std::string readValue(const Json::Value& v, std::string def="") const
    {
        try
        {
            return v.asCString();
        }
        catch ()
        {
            TRACE("Json读取未知异常.\n");
            return def;
        }
        return def;
    }
#endif

    bool read(const std::string& key, time_t& value);

    template <typename T>
    void readObj(const std::string& key, T& value)
    {
        Json::Value& obj = (bToArray || key.empty()) ? root[readPos++] : root[key];
        value.root = obj;
        value.deserialize();
    }

private:
    size_t get_temp_buffer_size(const size_t src_length);

public:
    Json::FastWriter    writer;
    Json::Reader        reader;
    Json::Value            root;

    std::string            document;        ///< json字符串

    bool                bFlushNow;        ///< 立即刷新json字符串
    bool                bEnableZip;        ///< 将json字符串压缩/解压缩成zip格式
    bool                bToArray;        ///< 序列化成数组

    std::vector<uint8>    zipBuffer;

    int                    readPos;        ///< 数组读取索引
    int                    writePos;        ///< 数组写入索引
};


#define OUTPUT_JSON_LEN(MSG) printf("字符串长度:%d\n", MSG.getString().length());
#define OUTPUT_STYLE_JSON(MSG) printf(MSG.style_flush().c_str());
#define OUTPUT_JSON(MSG) printf(MSG.getString().c_str());

#define TEST_SERIALIZE(MSG) MSG.serialized(); OUTPUT_JSON_LEN(MSG); OUTPUT_STYLE_JSON(MSG);


#endif

JsonSerializer.cpp

/**********************************************************************
* Copyright (C) 2015 - tx7do - All Rights Reserved
*
* 文件名称:        JsonSerializer.cpp
* 摘    要:        Json序列化工具
*
* 作    者:        yanglinbo, 
* 修    改:        查看文件最下方.
* 
***********************************************************************/

#include "Stdafx.h"
#include "JsonSerializer.h"
#include <json/json.h>
#include <zip.h>
#include <unzip.h>

#ifdef _DEBUG
#    pragma comment(lib, "json_vc71_libmtd.lib")
#    pragma comment(lib, "zlib1d.lib")
#else
#    pragma comment(lib, "json_vc71_libmt.lib")
#    pragma comment(lib, "zlib1.lib")
#endif

JsonSerializer::JsonSerializer() : bFlushNow(false)
, bEnableZip(false)
, bToArray(false)
, readPos(0)
, writePos(0)
{
    //writer = new Json::FastWriter;
    //reader = new Json::Reader;
    //root = new Json::Value;
}

JsonSerializer::~JsonSerializer()
{
    //safe_delete(writer);
    //safe_delete(reader);
    //safe_delete(root);
}

void JsonSerializer::clearBuffer()
{
    root.clear();
    flush();
    document.clear();

    resetPosition();
}

const char* JsonSerializer::flush()
{
    document.clear();
    document = writer.write(root);
    if (bEnableZip)
    {
        if (zipBuffer.size() < document.length())
        {
            zipBuffer.resize(document.length());
        }

        uLong comprLen = (uLong) zipBuffer.size();
        int err = compress(&zipBuffer[0], &comprLen, (const Bytef*)document.c_str(), (uLong)document.length());
        //TRACE("压缩长度:%d\n", comprLen);
        document.assign((const char*)&zipBuffer[0], comprLen);
    }
    return document.c_str();
}

const std::string& JsonSerializer::style_flush()
{
    flush();
    Json::StyledWriter style_writer;
    Json::Reader style_reader;
    style_reader.parse( document, root );
    document = style_writer.write( root );
    return document;
}

bool JsonSerializer::isKeyValid(const std::string& key) const
{
    return !root[key].isNull();
}

bool JsonSerializer::isKeyValid(const char* key) const
{
    return !root[key].isNull();
}

void JsonSerializer::append(const std::string& key, const int8& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const int16& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const int32& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const int64& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const uint8& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const uint16& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const uint32& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const uint64& value)
{
    if (bToArray || key.empty())
    {
        root.append(value);
    }
    else
    {
        root[key] = value;
    }
    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, const float& value)
{
    char buffer[64] = {0};

#if _MSC_VER > 1310
    int result = _snprintf_s(buffer, sizeof (buffer), "%.2f", value);
#else
    int result = _snprintf(buffer, sizeof (buffer), "%.2f", value);
#endif
    if (result==sizeof(buffer) || result<0)
    {
        buffer[sizeof(buffer)-1] = 0;
    }

    if (bToArray || key.empty())
    {
        root.append(buffer);
    }
    else
    {
        root[key] = buffer;
    }

    if (bFlushNow) flush();
}

void JsonSerializer::append(const std::string& key, JsonSerializer& value)
{
    value.serialized();

    if (bToArray || key.empty())
    {
        root.append(value.root);
    }
    else
    {
        root[key] = value.root;
    }

    if (bFlushNow) flush();
}

bool JsonSerializer::parse(const char* str, size_t size)
{
    if (bEnableZip)
    {
        uLong uncomprLen = (uLong)get_temp_buffer_size(size + 1);
        if (zipBuffer.size() < uncomprLen)
        {
            zipBuffer.resize(uncomprLen);
        }
        Byte* uncompr = &zipBuffer[0];

        ZeroMemory(uncompr, uncomprLen);
        int err = uncompress(uncompr, &uncomprLen, (const Byte*)str, (uLong)size);

        str = (const char*) uncompr;
        size = uncomprLen;
    }

    if (!reader.parse(str, str+size, root, false))
    {
        std::string strError = reader.getFormatedErrorMessages();
        TRACE("解析错误:[%s]\n", strError.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, bool& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asBool();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, int8& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, int16& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, int32& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, int64& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asInt64();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, uint8& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asUInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, uint16& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asUInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, uint32& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asUInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, uint64& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asUInt64();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, float& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;
        if (v.isString())
        {
            const char* str = 0;
            str = v.asCString();
            if (str == NULL) return false;

            char temp = 0;
#if _MSC_VER > 1310
            sscanf_s(str, " %g", &value, &temp);
#else
            sscanf(str, " %g", &value, &temp);
#endif
            return true;
        }
        else if (v.isDouble())
        {
            value = v.asFloat();
            return true;
        }
        else if (v.isInt())
        {
            value = (float) v.asInt();
        }
        else if (v.isUInt())
        {
            value = (float) v.asUInt();
        }
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, TCHAR* value)
{
    if (value == NULL) return false;

    try
    {
        const char* str = NULL;
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        str = v.asCString();

        if (str == NULL) return false;

        strncpy(value, str, strlen(str));
        //value[str.length()+1] = '\0';.
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

bool JsonSerializer::read(const std::string& key, time_t& value)
{
    try
    {
        Json::Value& v = (bToArray || key.empty()) ? root[readPos++] : root[key];
        if (v.isNull()) return false;

        value = v.asInt();
    }
    catch (std::exception& e)
    {
        TRACE("[%s]Json读取异常: %s.\n", key.c_str(), e.what());
        return false;
    }
    catch ()
    {
        TRACE("[%s]Json读取未知异常.\n", key.c_str());
        return false;
    }

    return true;
}

size_t JsonSerializer::get_temp_buffer_size(const size_t src_length)
{
    const size_t MB = 1024 * 1024;
    if (src_length < 1*MB)
    {
        return 1*MB;
    }
    else if ((src_length >= 1*MB) && (src_length < 8*MB))
    {
        return 8*MB;
    }
    else
    {
        return 16*MB;
    }
}

int8 JsonSerializer::readValue(const Json::Value& v, int8 def/*=0*/) const
{
    try
    {
        return v.asInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

int16 JsonSerializer::readValue(const Json::Value& v, int16 def/*=0*/) const
{
    try
    {
        return v.asInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

int32 JsonSerializer::readValue(const Json::Value& v, int32 def/*=0*/) const
{
    try
    {
        return v.asInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

int64 JsonSerializer::readValue(const Json::Value& v, int64 def/*=0*/) const
{
    try
    {
        return v.asInt64();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

uint8 JsonSerializer::readValue(const Json::Value& v, uint8 def/*=0*/) const
{
    try
    {
        return v.asUInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

uint16 JsonSerializer::readValue(const Json::Value& v, uint16 def/*=0*/) const
{
    try
    {
        return v.asUInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

uint32 JsonSerializer::readValue(const Json::Value& v, uint32 def/*=0*/) const
{
    try
    {
        return v.asUInt();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

uint64 JsonSerializer::readValue(const Json::Value& v, uint64 def/*=0*/) const
{
    try
    {
        return v.asUInt64();
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

float JsonSerializer::readValue(const Json::Value& v, float def/*=0*/) const
{
    try
    {
        float value = 0;

        if (v.isString())
        {
            const char* str = 0;
            str = v.asCString();
            if (str == NULL) return false;

            char temp = 0;
#if _MSC_VER > 1310
            sscanf_s(str, " %g", &value, &temp);
#else
            sscanf(str, " %g", &value, &temp);
#endif
            return value;
        }
        else if (v.isNumeric())
        {
            value = v.asFloat();
            return value;
        }
    }
    catch ()
    {
        TRACE("Json读取未知异常.\n");
        return def;
    }
    return def;
}

struct TestData1 : public JsonSerializer
{
    time_t        nServerTime;

    TestData1()
    {
        clear();
    }

    void clear()
    {
        nServerTime = 0;
    }

    /// 序列化
    virtual const char* serialized()
    {
        clearBuffer();
        append(_T("time"), nServerTime);
        return flush();
    }

    /// 反序列化
    virtual bool deserialize(const char* str, size_t size)
    {
        if (str != NULL && size != 0)
        {
            if (!parse(str, size)) return false;
        }

        read(_T("time"), nServerTime);

        return true;
    }
};

void test1()
{
    // 序列化
    TestData1 data1;
    data1.nServerTime = time(0);
    data1.serialized();
    OUTPUT_STYLE_JSON(data1);

    // 反序列化
    TestData1 data2;
    std::string strJson = "{\"time\" : 1481207292 }";
    data2.deserialize(strJson.c_str(), strJson.length());
    printf("time :%d\n", data2.nServerTime);
}

struct TestData2 : public JsonSerializer
{
    time_t        nServerTime;
    std::vector<int32> arrInt;
    std::string strTest;

    TestData2()
    {
        clear();
    }

    void clear()
    {
        nServerTime = 0;
        arrInt.clear();
        strTest.clear();
    }

    /// 序列化
    virtual const char* serialized()
    {
        clearBuffer();
        append(_T("time"), nServerTime);
        append(_T("ints"), arrInt);
        append(_T("str"), strTest);
        return flush();
    }

    /// 反序列化
    virtual bool deserialize(const char* str, size_t size)
    {
        if (str != NULL && size != 0)
        {
            if (!parse(str, size)) return false;
        }

        read(_T("time"), nServerTime);
        read(_T("ints"), arrInt);
        read(_T("str"), strTest);

        return true;
    }
};

void test2()
{
    // 序列化
    TestData2 data1;
    data1.nServerTime = time(0);
    data1.arrInt.push_back(1);
    data1.arrInt.push_back(2);
    data1.arrInt.push_back(3);
    data1.arrInt.push_back(4);
    data1.strTest = "序列化字符串";

    data1.serialized();
    OUTPUT_STYLE_JSON(data1);
}