rapidjson 封装

// test.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <vector>
#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/writer.h"
#include "rapidjson/error/en.h"
// https://blog.csdn.net/GreedySnaker/article/details/121456666
// http://www.manongjc.com/detail/55-jqcebstmopyyrwl.html

namespace LiJson{
template<typename T>
void json_to_value(const rapidjson::Value& dom, T* value) {
    value->Read(dom);
}
template<typename T>
void json_to_value(const rapidjson::Value& dom, std::vector<T>* value) {
    if (dom.IsArray()) {
        auto arr = dom.GetArray();
        for (int i = 0; i < arr.Size(); i++)
        {
            T tmp;
            json_to_value(arr[i], &tmp);
            value->push_back(tmp);
        }
    }
}
template<>
void json_to_value(const rapidjson::Value& dom, int32_t* value) {
    *value = (dom.IsInt()) ? dom.GetInt() : 0;
}
template<>
void json_to_value(const rapidjson::Value& dom, uint32_t* value) {
    *value = (dom.IsUint()) ? dom.GetUint() : 0;
}
template<>
void json_to_value(const rapidjson::Value& dom, int64_t* value) {
    *value = dom.IsInt64() ? dom.GetInt64() : 0;
}
template<>
void json_to_value(const rapidjson::Value& dom, uint64_t* value) {
    *value = dom.IsUint64() ? dom.GetUint64() : 0;
}
template<>
void json_to_value(const rapidjson::Value& dom, double* value) {
    *value = dom.IsDouble() ? dom.GetDouble() : 0;
}
template<>
void json_to_value(const rapidjson::Value& dom, std::string* value) {
    *value = dom.IsString() ? dom.GetString() : "";
}
template<>
void json_to_value(const rapidjson::Value& dom, bool* value) {
    *value = dom.IsBool() ? dom.GetBool() : false;
}

template<typename T>
void json_to_value(const rapidjson::Value& dom, std::string name, T* value) {
    if (!dom.HasMember(name.c_str())) {
        return;
    };
    value->Read(dom[name.c_str()]);
}

template<typename T>
void json_to_value(const rapidjson::Value& dom, std::string name, std::vector<T>* value) {
    if (!dom.HasMember(name.c_str())) {
        return;
    }
    const rapidjson::Value& jsonShape = dom[name.c_str()];
    if (jsonShape.IsArray()) {
        json_to_value(jsonShape, value);
    }
}

template<>
void json_to_value(const rapidjson::Value& dom, std::string name, int32_t* value) {
    *value = (dom.HasMember(name.c_str()) && dom[name.c_str()].IsInt()) ? dom[name.c_str()].GetInt() : 0;
}
template<>
void json_to_value(const rapidjson::Value& dom, std::string name, uint32_t* value) {
    *value = (dom.HasMember(name.c_str()) && dom[name.c_str()].IsUint()) ? dom[name.c_str()].GetUint() : 0;
}
template<>
void json_to_value(const rapidjson::Value& dom, std::string name, int64_t* value) {
    *value = (dom.HasMember(name.c_str()) && dom[name.c_str()].IsInt64()) ? dom[name.c_str()].GetInt64() : 0;
}
template<>
void json_to_value(const rapidjson::Value& dom, std::string name, uint64_t* value) {
    *value = (dom.HasMember(name.c_str()) && dom[name.c_str()].IsUint64()) ? dom[name.c_str()].GetUint64() : 0;
}
template<>
void json_to_value(const rapidjson::Value& dom, std::string name, double* value) {
    *value = (dom.HasMember(name.c_str()) && dom[name.c_str()].IsDouble()) ? dom[name.c_str()].GetDouble() : 0;
}
template<>
void json_to_value(const rapidjson::Value& dom, std::string name, std::string* value) {
    *value = (dom.HasMember(name.c_str()) && dom[name.c_str()].IsString()) ? dom[name.c_str()].GetString() : "";
}
template<>
void json_to_value(const rapidjson::Value& dom, std::string name, bool* value) {
    *value = (dom.HasMember(name.c_str()) && dom.IsBool()) ? dom[name.c_str()].GetBool() : false;
}

template<typename T>
void value_to_json(const T* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    value->Write(writer);
}

template<typename T>
void value_to_json(const std::vector<T>* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.StartArray();
    for (auto it : *value) {
        it.Write(writer);
    }
    writer.EndArray();
}
template<>
void value_to_json(const int32_t* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.Int(*value);
}
template<>
void value_to_json(const int64_t* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.Int64(*value);
}
template<>
void value_to_json(const uint32_t* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.Uint(*value);
}
template<>
void value_to_json(const uint64_t* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.Uint64(*value);
}
template<>
void value_to_json(const double* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.Double(*value);
}
template<>
void value_to_json(const std::string* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.String(value->c_str());
}
template<>
void value_to_json(const bool* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.Bool(*value);
}
template<>
void value_to_json(const std::vector<int32_t>* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.StartArray();
    for (auto it : *value) {
        writer.Int(it);
    }
    writer.EndArray();
}
template<>
void value_to_json(const std::vector < int64_t>* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.StartArray();
    for (auto it : *value) {
        writer.Int64(it);
    }
    writer.EndArray();
}
template<>
void value_to_json(const std::vector < uint32_t>* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.StartArray();
    for (auto it : *value) {
        writer.Uint(it);
    }
    writer.EndArray();
}
template<>
void value_to_json(const std::vector < uint64_t>* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.StartArray();
    for (auto it : *value) {
        writer.Uint64(it);
    }
    writer.EndArray();
}
template<>
void value_to_json(const std::vector<double>* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.StartArray();
    for (auto it : *value) {
        writer.Double(it);
    }
    writer.EndArray();
}
template<>
void value_to_json(const std::vector < std::string>* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.StartArray();
    for (auto it : *value) {
        writer.String(it.c_str());
    }
    writer.EndArray();
}
template<>
void value_to_json(const std::vector<bool>* value, std::string name, rapidjson::Writer<rapidjson::StringBuffer>& writer) {
    writer.Key(name.c_str());
    writer.StartArray();
    for (auto it : *value) {
        writer.Bool(it);
    }
    writer.EndArray();
}

template<typename T>
std::string Serializable(T& value) {
    std::string rs;

    rapidjson::StringBuffer s;
    rapidjson::Writer<rapidjson::StringBuffer> writer(s);

    value.Write(writer);

    return s.GetString();
}
template<typename T>
bool UnSerializable(T& value, const std::string& strJson) {
    rapidjson::Document dom;
    dom.Parse(strJson.c_str());
    if (dom.HasParseError()) {
        return false;
    }
    value.Read(dom);
    
    return true;
}
};
struct tagTmp2{
    int32_t a1;
    std::string b1;

    void Read(const rapidjson::Value& dom) {
        LiJson::json_to_value(dom, "a1", &a1);
        LiJson::json_to_value(dom, "b1", &b1);
        //    json_to_array(dom,"vecInt",vecInt);
    }
};

struct tagTmp{
    int32_t a;
    std::string b;
    tagTmp2 c;
    std::vector<int> vecInt;

    void Read(const rapidjson::Value& dom) {
        LiJson::json_to_value(dom, "a", &a);
        LiJson::json_to_value(dom, "b", &b);
        LiJson::json_to_value(dom, "c", &c);
        LiJson::json_to_value(dom,"vecInt",&vecInt);
    }
};

struct Questions {
    std::string question;
    int         image_id;
    int         question_id;

    void Read(const rapidjson::Value& dom) {
        LiJson::json_to_value(dom, "question", &question);
        LiJson::json_to_value(dom, "image_id", &image_id);
        LiJson::json_to_value(dom, "question_id", &question_id);
    }
    void Write(rapidjson::Writer<rapidjson::StringBuffer>& writer) const{
        writer.StartObject();
        LiJson::value_to_json(&question, "question", writer);
        LiJson::value_to_json(&image_id, "image_id", writer);
        LiJson::value_to_json(&question_id, "question_id", writer);
        writer.EndObject();
    }
};

struct License {
    std::vector<Questions> questions;

    void Read(const rapidjson::Value& dom) {
        LiJson::json_to_value(dom, "questions", &questions);
    }
    void Write(rapidjson::Writer<rapidjson::StringBuffer>& writer) const{
        writer.StartObject();
        LiJson::value_to_json(&questions, "questions", writer);
        writer.EndObject();
    }
};
struct Info {
    std::string description;
    License license;
    std::vector<int> vecInt;
    void Read(const rapidjson::Value& dom) {
        LiJson::json_to_value(dom, "description", &description);
        LiJson::json_to_value(dom, "license", &license);
        LiJson::json_to_value(dom, "vecInt", &vecInt);
    }
    void Write(rapidjson::Writer<rapidjson::StringBuffer>& writer)const {
        writer.StartObject();
        LiJson::value_to_json(&description, "description", writer);
        LiJson::value_to_json(&license, "license", writer);
        LiJson::value_to_json(&vecInt, "vecInt", writer);
        writer.EndObject();
    }
};

using namespace std;
using namespace rapidjson;
std::string toString(const Document& d)
{
    StringBuffer buffer;
    Writer<StringBuffer> writer(buffer);
    d.Accept(writer);
    std::string str = buffer.GetString();
    return str;
}

//
void test() {

    std::string str = "{\"a\":5, \"b\":\"dd\",\"vecInt\":[5,3,2,1]}";
    str =
    "{\"description\": \"This is v1.0 of the VQA dataset.\","
    "    \"license\": "
    "{\"questions\":["
    "{\"question\": \"What is the table made of?\"," 
        "\"image_id\": 350623," 
        "\"question_id\": 3506232}," 
    "{\"question\": \"Is the food napping on the table?\","
        "\"image_id\": 350623," 
        "\"question_id\": 3506230}]}" 
    "} ";
    rapidjson::Document dom;
    struct Info info;
    for (int i = 0; i < 5; i++) {
        info.vecInt.push_back(i);
    }
    LiJson::UnSerializable(info, str);
   

    str = "";
    str = LiJson::Serializable(info);
    cout << str << endl;
     
}
int main()
{
    Document d;
    Document::AllocatorType& allocator = d.GetAllocator();
    d.SetObject();
    d.AddMember("id", 10086, allocator);

    d.AddMember("name", "中国移动", allocator);
    d.AddMember("login", true, allocator);
    string str = toString(d);
    cout << str << endl;

    test();

    std::cout << "Hello World!" << endl;;
}