Nested Structure Variant with Deduction of Tagged Object Types

[jimmylim0823]

I had a look at variant_handling example, but wasn't able to go around in the case of nested structure.
https://github.com/stephenberry/glaze/blob/main/docs/variant-handling.md

My structure looks something like this and I have no idea how to access a member of the substructure when declaring tag as std::string_view.

struct common_struct {
    std::string key;
    std::string value;
};
struct info_struct_a {
    std::string a;
    std::string b;
};
struct info_struct_b {
    float c;
    int d;
};
struct data_a {
    common_struct info_common;
    std::vector<info_struct_a> info;
};
struct data_b {
    common_struct info_common;
    std::vector<info_struct_b> info;
    int other_id;
};
using data_variant = std::variant<data_a, data_b>;
template<>
struct glz::meta<data_variant> {
    static constexpr std::string_view tag = "info_common.key"; // TODO: substructure's member as tag
    static constexpr auto ids = std::array{"a", "b"};
};

I also tried using std::vector<std::variant<info_struct_a, info_struct_b>> (and the other way around too) for info member of a data_common structure and ignore missing key other_id error and let the glaze deduce the type, but this didn't worked out.
Can anybody help me out with this?

[stephenberry]

Can you provide an example input JSON document for this structure that you are trying to decode?

Is the key actually supposed to be within a sub-object in the JSON or do you only want it a sub-object (common_struct) in C++?

[jimmylim0823]

{"info_common":{"key":"a","value":"val_a"},"info":[{"a":"foo_0", "b":"bar_0"},{"a":"foo_1","b":"bar_1"}]}

{"info_common":{"key":"b","value":"val_b"},"info":[{"c":"1.1, "d":2},{"c":3.3,"d":4}], "other_id":5}

I will be receiving message of either type while the message will arrive to the same socket simultaneously without order or notice. That's why I would want to recieve json message as a variant type as I would not be aware of the type unless I have already read part of the message. Structure of info_common is homogenous across message, and there will be few possible keys (here its either a or b), though structure of other part of the data is dependent on what the value of key is.

To sum up, if a key is known, rest of the structure is deterministic, but we don't know which key(structure) will arrive and the key is a member's member.

[stephenberry]

Thanks for the additional details.

Glaze cannot decode variants from sub-keys. Support may be added in the future, but I'm wary about adding too much complexity to variant handling, which is already complex. However, there are various solutions to this problem.

1. Use JSON Pointer access for switching logic on your key

std::string s = R"({"info_common":{"key":"a","value":"val_a"},"info":[{"a":"foo_0", "b":"bar_0"},{"a":"foo_1","b":"bar_1"}]})";
std::string key = glz::get_as_json<std::string, "/info_common/key">(s);

// This lets you avoid variants if you don't want them
if (key == "a") {
   // read into data_a
}
else if (key == "b") {
   // read into data_b
}

Note that you can still use a std::variant and just set the active member to the appropriate type

data_variant var{};
if (key == "a") {
   var = data_a{};
   auto ec = glz::read_json(std::get<0>(var), s);
}

2. Use partial reading

struct header {
   common_struct info_common{};
};

template <>
struct glz::meta< header > {
   static constexpr auto partial_read = true;
};

Now you can call read_json on this header type and it will just decode the info_common for you. This way you can then make decisions about how to parse the rest of the document.

See JSON Pointer syntax documentation and Partial Reading documentation for more details

[jimmylim0823]

Thanks so much! I did knew partial reading was a stuff but never heard of JSON Pointer syntax which I decided to use.