Generic/single read/write wrapper?

[rmanaloto-tastytrade]

Is there a way to register one read and one write method for all my user defined structs?

I have code where I have metadata associated with each user defined type that I've generated that describes a field for a struct (its index in the aggregate, data type and semantic type, like if it is a uint64_t that represents a timestamp, etc...)

It would be somewhat tedious to setup all the glz::meta declarations and I want to piggy back off all of my meta data to generate the json serialization/deserialization

I'm not sure if this exists already, or totally hard to implement

The closest thing I've seen is glz::invoke, but the documentation regarding it is very hard to come by.

Ideally I would like to get access to the index in the aggregate that glaze is iterating on. Or the json element name and I can do the lookup myself when the method is called to read/write the json field.

I"m using a lot of the current reflection tricks out there (similar to glaze's reflection api) to map an aggregate field by index/name to its aggregate struct.

[joshuamaiche]

Is your metadata available at compile-time? Could you specialize glz::meta<T> for types that have metadata?
Example:

template <typename T>
struct MyMeta;

struct MyStruct {
    // Constructor to prevent it from being reflectable by Glaze.
    MyStruct() : val(0) {}
    int val;
};

template<>
struct MyMeta<MyStruct> {
    static constexpr auto value = &MyStruct::val;
};

template <typename T>
concept has_my_meta = requires { MyMeta<T>::value; };

template<has_my_meta T>
struct glz::meta<T> {
    static constexpr auto value = &MyMeta<T>::value;
};

[rmanaloto-tastytrade]

yes all my metadata is available at compile time
im just trying to avoid having to write something like this for every user defined type (especially if i have like 50-100 and growing)

template <typename TAggregate, std::size_t AggregateIndex>
constexpr static readJSONField();

template <typename TAggregate, std::size_t AggregateIndex>
constexpr static writeJSONField();


template<>
struct glz::meta<UserDefinedType1>
{
  using T = UserDefinedType1;
  static inline constexpr auto value = glz::object(
        "timestamp1", readJSONField, writeJSONField,
      , "string1",    readJSONField, writeJSONField,
      , "int1",       readJSONField, writeJSONField
  );
};

template<>
struct glz::meta<UserDefinedType2>
{
  using T = UserDefinedType2;
  static inline constexpr auto value = glz::object(
        "timestamp2", readJSONField, writeJSONField,
      , "string2",    readJSONField, writeJSONField,
      , "float2",     readJSONField, writeJSONField
  );
};

if I can get access to the index, or the field name (I can convert it the index), then I dont have to deal w having to sync up the meta mappings if I have to make changes/additions/deletions

I'd like to just declare it like this really

template<>
struct glz::meta<UserDefinedType1>
{
  using T = UserDefinedType1;
  static inline constexpr auto value = glz::object(
        readJSONField, writeJSONField
  );
};

template<>
struct glz::meta<UserDefinedType2>
{
  using T = UserDefinedType2;
  static inline constexpr auto value = glz::object(
        readJSONField, writeJSONField
  );
};

and I dont want to alter my aggregate structs to have different types for fields so they can have better custom wrappers
I want to basically remove glaze from my core logic just in case i have to swap it out later

[joshuamaiche]

Makes sense to not want Glaze in the core logic, and I get the motivation for avoiding marking up everything--I try to do the same. If you take a look at the glz::meta I specialized in my example, you can see that it's just a one-time definition. I could introduce a MyStruct2, MyStruct3, etc, and as long as they have a MyMeta specialization (which would in your case be the custom metadata you wrote), no additional glz::meta specializations are being written.

Could you post an example of your custom metadata that's used for serialization? It might help me understand how that could be converted into glz::meta.

[rmanaloto-tastytrade]

Sorry been tied up all day
I'll try to provide a better example of what I'm trying to do in a few

but the metadata isn't that complicated. We generate code from a public schema and our structs need to be bit by bit match so things like prices, timestamps, etc... are uint64_t data types
But our generated metadata code provides some sott of compile time lookup map where i can get the metadata information for an aggregate type or for one of its field(s) by aggregate index position
The structures can go several layers deep (aka array/vector-like of user-defined types)

[stephenberry]

I'll just chime in and say what you're desiring should be possible. A bit more direction should help. Using glz::for_each and these tools you can iterate through your types and make compile time choices:

// The type of the field before get_member is applied
template <class T, size_t I>
using elem_t = reflect<T>::template elem<I>;

// The type of the field after get_member is applied
template <class T, size_t I>
using refl_t = reflect<T>::template type<I>;

// The decayed type after get_member is called
template <class T, size_t I>
using field_t = std::remove_cvref_t<refl_t<T, I>>;

You can also call glz::reflect<T>::keys to get all your field names and glz::reflect<T>::size to get the number of fields. This way if can build compile time logic based on key names.

[rmanaloto-tastytrade]

We're using this reflection library which has a very similar api to what chatted
https://github.com/qlibs/reflect

But, my my question/concern is I am inquiring if there is a way reduce the glz::meta mappings per user defined type given that all i really need is the aggregate field index and the type and I will do a lookup on our metadata on what the formatting/serializaiton/deserialization should be for the json field