Best practice for nested (recursive) serialization with an stl interface?

[emmenlau]

Thanks for the awesome library, its highly appreciated. I've read through the examples but could not find exactly what I need.

I'd like to have structs with a pure stl interface, so methods serialize and deserialize should not expose the class nlohmann::json. The structs will be stored in a nested data structure (no loops). Is it possible to serialize this recursively into a std::string, with a pure stl interface? I do not necessarily need the interface to return std::string, any pure stl interface (for example streams, or return by argument) is fine for me.

I've tried with something like

// inside struct S:
std::string serialize() {
    nlohmann::json j;
    j["a"] = "hello";
    j["b"] = "world";
    return j.dump(4);
}

// outside serialization of a vector of structs:
std::string serialize() {
    nlohmann::json j;
    for (const auto& s : _structs) {
        j[s.name] = s.serialize();
    }
    return j.dump(4);
}

but when I use this, the json in the array values seems fully escaped, not nicely formatted. Here is an example how the nested structures will get formatted with this approach:

{
    "s1": "null",
    "s2": "{\n    \"a\": \"hello\",\n    \"b\": \"world\"\n}"
}

I have tested that this would work much better recursive if serialize() returns an object of type nlohmann::json, so I guess that is the standard approach? But is it also possible to hide the json library from the interface?

[nlohmann]

The canonic approach that this library offers is to define a to_json function in the namespace of struct S - not a member function, nothing that even needs to be exposed in the same header. So you can define S just as you would do anyway and could have another header that just extends the namespace, defines to_json and that's it. You would also get any nested serialization for free: things like std::vector<S> or std::map<std::string, S> would serialize to JSON without any additional code.

The effect that you describe can be explained by the fact that you serialize JSON values to a string, but then store these values as strings in another JSON value - and quotes are then escaped in the second serialization step. You could "fix" this by deserializing the value again:

std::string serialize() {
    nlohmann::json j;
    for (const auto& s : _structs) {
        j[s.name] = json::parse(s.serialize()); // added parse call here
    }
    return j.dump(4);
}