What is the best practice to serialize variant or variable object?

[krishna116]

Sometime I need serialize variant or variable object, but how to do it and what is the best practice?
For example, below is a piece of c++ code, but how to serialze ServerReply automatically ?

#include <nlohmann/json.hpp>
#include <iostream>
#include <variant>

using namespace nlohmann;

// Serialize user.
struct User
{
    std::size_t id = 0;
    std::string name;
    std::string email;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE(User, id, name, email)
};

// Serialize Message.
struct Message
{
    std::size_t id = 0;
    std::string text;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE(Message, id, text)
};

// How to serialize it automatically?
struct ServerReply
{
    std::variant<User, Message> data;
};

Thank you.

[nlohmann]

You need to provide to_json/from_json functions for class ServerReply, see #2208 for an example.

[krishna116]

Thank you for the advice, I have already implemented to_json/from_json, it is lots of code here, I just think whether there is a more beautiful solution?

struct ServerReply
{
    struct Data
    {
        enum class EntityType : std::size_t
        {
            Empty,
            User,
            Message
        };
        EntityType entityType = EntityType::Empty;
        std::variant<User, Message> entity;
        
        friend void to_json(json& j, const Data& d) 
        {
            j["entityType"]= d.entityType;

            switch(d.entityType)
            {
                case Data::EntityType::User:
                {
                    j["user"]= std::get<User>(d.entity);
                    break;
                }
                case Data::EntityType::Message:
                {
                    j["message"]= std::get<Message>(d.entity);
                    break;
                }
                default:
                {
                    j = nullptr;
                    break;
                }
            }
        }
        friend void from_json(const json& j, Data& d) 
        {
            d.entityType = j["entityType"];

            switch(d.entityType)
            {
                case Data::EntityType::User:
                {
                    d.entity = j["user"].get<User>();
                    break;
                }
                case Data::EntityType::Message:
                {
                    d.entity = j["message"].get<Message>();
                    break;
                }
                default:
                {
                    break;
                }
            }
        }
    };

    Data data;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE(ServerReply, data)
};

int main()
{
    json j1 = ServerReply{{ServerReply::Data::EntityType::Message, Message{1,"hello world"}}};
    std::cout <<j1.dump(2)<<std::endl;

    json j2 = ServerReply{{ServerReply::Data::EntityType::User, User{1,"jack","jack@xxx.org"}}};
    std::cout <<j2.dump(2)<<std::endl;

    return 0;
}

[falbrechtskirchinger]

Thank you for the advice, I have already implemented to_json/from_json, it is lots of code here, I just think whether there is a more beautiful solution?

struct ServerReply
{
    struct Data
    {
        enum class EntityType : std::size_t
        {
            Empty,
            User,
            Message
        };
        EntityType entityType = EntityType::Empty;
        std::variant<User, Message> entity;

EntityType seems redundant. The variant knows which type it is storing. If you need to represent an empty variant use std::monostate.

    friend void to_json(json& j, const Data& d) 
    {
        j["entityType"]= d.entityType;

        switch(d.entityType)
        {
            case Data::EntityType::User:
            {
                j["user"]= std::get<User>(d.entity);
                break;
            }
            case Data::EntityType::Message:
            {
                j["message"]= std::get<Message>(d.entity);
                break;
            }
            default:
            {
                j = nullptr;
                break;
            }
        }
    }
    friend void from_json(const json& j, Data& d) 
    {
        d.entityType = j["entityType"];

        switch(d.entityType)
        {
            case Data::EntityType::User:
            {
                d.entity = j["user"].get<User>();
                break;
            }
            case Data::EntityType::Message:
            {
                d.entity = j["message"].get<Message>();
                break;
            }
            default:
            {
                break;
            }
        }
    }
};

Both function bodies can be re-written using std::visit (see my answer below), resulting in less code and no need to modify should you add/remove types to/from your variant.

[falbrechtskirchinger]

There's no automatic handling of std::variant (yet). You need to provide your own serialization/deserialization functions.
Example: https://godbolt.org/z/369o1j1q9

void to_json(json &j, const ServerReply &sr)
{
    std::visit([&](auto &v) {
        using nlohmann::to_json;
        to_json(j, v);
    }, sr.data);
}

void from_json(const json &j, ServerReply &sr)
{
    std::visit([&](auto &v) {
        using nlohmann::from_json;
        from_json(j, v);
    }, sr.data);
}

[krishna116]

Thank you, It is a nice method.

[j1ah0ng]

I think this example is pretty trivially incorrect: in the from_json deserializer, std::visit over the sr.data field is visiting a default-initialized std::variant, which contains a default-initialized value of the first variant type.

Modifying the attached Godbolt to ser/de an instance of Message (i.e. the second variant instance) raises a sigsegv as expected per the spec.

[gregmarr]

Yes, the "which type is it" handling from this comment is needed unless you already know which type of sr.data should be read and you've activated that type.