USCiLab cereal json 序列化

cereal json 序列化

https://blog.csdn.net/sunnyloves/article/details/51373793?utm_source=blogxgwz8

http://uscilab.github.io/cereal/

https://github.com/USCiLab/cereal

#include <iostream>
#include <fstream>
#include <string>
#include "cereal/archives/binary.hpp"
#include "cereal/archives/xml.hpp"
#include "cereal/archives/json.hpp"
#include "cereal/types/unordered_map.hpp"
#include "cereal/types/memory.hpp"
#include "cereal/types/string.hpp"  //一定要包含此文件，否则无法将std::string序列化为二进制形式，
#include <Winsock2.h>

#include <cereal/types/vector.hpp>
using namespace std;

struct MyRecord
{
    int x, y;
    float z;

    template <class Archive>
    void serialize(Archive & ar)
    {
        ar(x, y, z);
    }

    friend std::ostream& operator<<(std::ostream& os, const MyRecord& mr);
};

std::ostream& operator<<(std::ostream& os, const MyRecord& mr)
{
    os << "MyRecord(" << mr.x << ", " << mr.y << "," << mr.z << ")\n";
    return os;
}

struct SomeData
{
    int32_t id;
    std::shared_ptr<std::unordered_map<uint32_t, MyRecord>> data;

    SomeData(int32_t id_ = ) : id(id_), data(new std::unordered_map<uint32_t, MyRecord>)
    {

    }

    template <class Archive>
    void save(Archive & ar) const
    {
        ar(id, data);
    }

    template <class Archive>
    void load(Archive & ar)
    {
        ar(id, data);
    }

    void push(uint32_t, const MyRecord& mr)
    {
        data->insert(std::make_pair(, mr));
    }

    void print()
    {
        std::cout << "ID : " << id << "\n";
        if (data->empty())
            return;
        for (auto& item : *data)
        {
            std::cout << item.first << "\t" << item.second << "\n";
        }
    }
};

void Serialization_XML()
{
    {
        std::ofstream os("my.xml");

        cereal::XMLOutputArchive archive(os);

        int age = ;
        std::string name = "lizheng";

        //#define CEREAL_NVP(T) ::cereal::make_nvp(#T, T)
        archive(CEREAL_NVP(age), cereal::make_nvp("Name", name));

        //os.close();  //注意：这里不能显示关闭ofstream，否则序列化无法写入到文件
    }

    {
        std::ifstream is("my.xml");
        cereal::XMLInputArchive archive(is);

        int age;
        std::string name;

        archive(age, name);
        std::cout << "Age: " << age << "\n" << "Name: " << name << "\n";
    }
}

struct  testxxx
{
public :
    int age;

    string name;

    template<class Archive>
    void serialize(Archive & ar)
    {
        ar(CEREAL_NVP(age));
        ar(CEREAL_NVP(name));
    }

};

class MyClass
{
public: //function declarations
    MyClass( )
    {

    }
    MyClass(string x,int y,bool z)
    {
        this->x = x;
        this->y = y;
        this->z = z;
        //this->obj1 = obj1;

    }
    template<class Archive> // public serialization (normal)
    void serialize(Archive & ar)
    {
        ar(CEREAL_NVP(x));
        ar(CEREAL_NVP(y));
        ar(CEREAL_NVP(z));
        ar(CEREAL_NVP(listobj1));
        //ar(x, y, z,obj1);
    }

 // member variables
    string x;
    int y;
    bool z;

    std::vector<testxxx> listobj1;
};

string Utf8ToGb32(const char * lpszUft8Text)
{
    int nUnicodeBufLen = MultiByteToWideChar(CP_UTF8, , lpszUft8Text, -, , );
    if (nUnicodeBufLen == )
        return ("");

    WCHAR* pUnicodeBuf = new WCHAR[nUnicodeBufLen];
    if (pUnicodeBuf == )
        return ("");

    MultiByteToWideChar(CP_UTF8, , lpszUft8Text, -, pUnicodeBuf, nUnicodeBufLen);

    int nGb32BufLen = WideCharToMultiByte(CP_ACP, , pUnicodeBuf, -, , , NULL, NULL);
    if (nGb32BufLen == )
    {
        delete[] pUnicodeBuf;
        return ("");
    }

    char* pGb32Buf = new char[nGb32BufLen];
    if (pGb32Buf == )
    {
        delete[] pUnicodeBuf;
        return ("");
    }

    WideCharToMultiByte(CP_ACP, , pUnicodeBuf, -, pGb32Buf, nGb32BufLen, NULL, NULL);

    string strGb32 = pGb32Buf;

    delete[] pUnicodeBuf;
    delete[] pGb32Buf;

    return strGb32;
}

void Serialization_JSON()
{
    ////string json_str = "";
    //MyClass data("hello", 6, true);
    ////std::stringstream os;
    //{
    //    std::ofstream os("my.json");
    //    cereal::JSONOutputArchive archive_out(os);
    //    archive_out(cereal::make_nvp("MyClass", data));
    //}
    //string json_str = os.str();
    //cout << json_str << endl;

    //// deserialize
    ////std::stringstream is(json_str);
    //MyClass data_new;
    //{
    //    std::ifstream is("my.json");
    //    cereal::JSONInputArchive archive_in(is);
    //    //archive_in(data_new);
    //    archive_in(cereal::make_nvp("MyClass", data_new));
    //    //cout << data_new.y << endl;
    //}

    //

     //写入json
    {
        std::ofstream os("my.json");
        cereal::JSONOutputArchive archive_out(os);

        MyClass data("hello", , true);
        testxxx obj1;
        obj1.age = ;
        obj1.name = "xiao mmksdfsd";

        data.listobj1.push_back(obj1);
        obj1.age = ;
        obj1.name = "11123xiao mmksdfsd";
        data.listobj1.push_back(obj1);
        archive_out(cereal::make_nvp("MyClass", data));//MyClass 是json中要读取出的名字
    }

    //从json中读出
    {
        std::ifstream is("my.json");
        cereal::JSONInputArchive archive_in(is);

        MyClass data_new;
        archive_in(cereal::make_nvp("MyClass", data_new));

        string xxxx = Utf8ToGb32(data_new.x.c_str());//MyClass 是json中要读取出的名字

        int cc = ;
    }
}

void Serialization_Binary()
{
    {
        std::ofstream os("my.binary", std::ios::binary);
        cereal::BinaryOutputArchive archive(os);

        int age = ;
        std::string name = "lizheng";

        archive(CEREAL_NVP(age), CEREAL_NVP(name));
    }
    {
        std::ifstream is("my.binary", std::ios::binary);
        cereal::BinaryInputArchive archive(is);

        int age;
        std::string name;

        archive(age, name);
        std::cout << "Age: " << age << "\n" << "Name: " << name << "\n";
    }
}

void Serialization_Obj()
{
    {
        std::ofstream os("obj.cereal", std::ios::binary);
        cereal::BinaryOutputArchive archive(os);

        MyRecord mr = { , , 3.0 };

        SomeData myData();
        myData.push(, mr);

        archive(myData);
    }
    {
        std::ifstream is("obj.cereal", std::ios::binary);
        cereal::BinaryInputArchive archive(is);

        SomeData myData;
        archive(myData);
        myData.print();
    }
}

int main()
{
    //Serialization_XML();     std::cout << "----------------------\n";

    Serialization_JSON();    std::cout << "----------------------\n";

    //Serialization_Binary();  std::cout << "----------------------\n";

    Serialization_Obj();     std::cout << "----------------------\n";

    getchar();
    return ;
}

json文件:

{
    "MyClass": {
        "x": "hello",
        "y": ,
        "z": true,
        "listobj1": [
            {
                "age": ,
                "name": "xiao mmksdfsd"
            },
            {
                "age": ,
                "name": "11123xiao mmksdfsd"
            }
        ]
    }
}