Is there a good way to detect which types support writing / reading to json?

[joshuamaiche]

I have a use-case where I need to compile-time check if a type will cause compilation errors when calling write_json(). I saw the write_json_supported concept, and it seemed perfect:

template <typename T>
std::string Serialize(const T& obj)
{
    std::string retVal;
    if constexpr(glz::write_json_supported<T>)
    {
        retVal = glz::write_json(obj).value_or("error");
    }
    return retVal;
}

This correctly filters out structs that aren't aggregate initializable:

struct SerializableStruct {
    int val;
};

struct NonSerializableStruct {
    NonSerializableStruct() : val{3} {}
    int val;
};

// "SerializableStruct: {"val":2}"
std::cout << "SerializableStruct: " << Serialize(SerializableStruct{2}) << '\n';
// "NonSerializableStruct: "
std::cout << "NonSerializableStruct: " << Serialize(NonSerializableStruct{}) << '\n';

However, this doesn't filter out aggregate initializable structs whose members cannot be serialized:

struct TrickyStruct {
    SerializableStruct s1;
    NonSerializableStruct s2;
};

// Error
std::cout << "TrickyStruct: " << Serialize(TrickyStruct{}) << '\n';

I'm working around this by manually having a type trait to specify which types to serialize, but I'm wondering: is there a way in Glaze to automatically know what types support write_json()?

[stephenberry]

The issue with aggregate initializable structs is that we're using the compiler to detect the number of elements. You can add a static_assert(glz::reflect<TrickyStruct>::size == 2). This will compile time error if Glaze cannot detect the correct number of elements and therefore won't serialize as expected. There currently is no way to automate this because the 2 would have to be deduced by the compiler, which would be the same as the left hand side. But, you can add your own static_asserts to check.

[joshuamaiche]

Thanks for the info; definitely excited for reflection to help with a lot of this.

When you say you'll have a count up only to the non-serializable field, is this a different mechanism than glz::reflect<T>::size? Because glz::reflect<TrickyStruct>::size will return 2, even though one of its fields is the NonSerializableStruct type.

[stephenberry]

You're right! My bad. The issue isn't with the counting. Now that I'm thinking about this more I'm going to experiment with a solution.

[stephenberry]

Okay, here is a check you can use to see if all members in your struct are writable:

template <class T>
inline constexpr bool check_all_members_write_supported = [] {
   bool supported = true;
   glz::for_each<glz::reflect<T>::size>([&](auto I) {
      if constexpr (not glz::write_json_supported<glz::field_t<T, I>>) {
         supported = false;
      }
   });
   return supported;
}();

This check passes as intended:

static_assert(not check_all_members_write_supported<TrickyStruct>);

We are iterating through each type in our struct and making sure that each field passes write_json_supported. I'm not going to immediately build this into Glaze, because it will have a bit of compile time overhead. But, I hope it helps you or gives you more ideas of how to check fields.

[joshuamaiche]

Thanks, that code was a huge help! I was able to tweak it to make it recursive, to accommodate a struct that might not have serializable data multiple levels down:

struct SuperTrickyStruct {
    SerializableStruct s1;
    TrickyStruct s2;
};

Here's my changes, in case it helps someone else:

template <class T>
inline constexpr bool check_all_members_write_supported = glz::write_json_supported<T>;

template <class T>
    requires glz::detail::reflectable<T>
inline constexpr bool check_all_members_write_supported<T> = [] {
    bool supported = true;
    glz::for_each<glz::reflect<T>::size>([&](auto I) {
        if constexpr (not check_all_members_write_supported<glz::field_t<T, I>>) {
            supported = false;
        }
    });
    return supported;
}();

Notable changes beyond making the check recursive:

• Only run the recursive code when glz::detail::reflectable is satisfied, otherwise the code won't compile for something like NonSerializableStruct.
• In the case where the type doesn't satisfy glz::detail::reflectable, return glz::write_json_supported<T>. This allows something like NonSerializableStruct to return false, while something like int will return true.

Now the only types that have to be manually marked up are types with enormous arrays, since those will crash the compiler. This is way less code to mark up, so it's a huge win for me!

Thanks again, @stephenberry !

[stephenberry]

Fantastic! And, nice tweaks!

[stephenberry]

Note that the main branch has been updated in preparation for v5.0.0 of Glaze which turns glz::write_json_supported<T> into glz::write_supported<glz::JSON, T>. This more generic approach makes user defined formats possible and reduces duplicate code in Glaze. When the new version is released you'll have to make these changes.

[joshuamaiche]

Thanks for the heads up; that's a welcome change!