Is it possible to provide serialization and deserialization of single file header c++ structs (classes)

[romanholidaypancakes]

and support common stl types(std::vector,std::string, etc
In some scenarios, such as games, we don't want to expose metadata, such as:

struct hero{
int hp;
std::string name;
....
}

If using json then the field names will be kept in the binary file.

[mwalcott3]

I'm sorry I don't entirely understand the question.

Common stl types should automatically be supported. And custom containers written with an stl style api should also work.

If you are asking to drop the field names an serialize into an array then that is possible by using glz::array instead of glz::object

struct V3
{
   double x{3.14};
   double y{2.7};
   double z{6.5};

   bool operator==(const V3& rhs) const { return (x == rhs.x) && (y == rhs.y) && (z == rhs.z); }
};

template <>
struct glz::meta<V3>
{
   static constexpr auto value = array(&V3::x, &V3::y, &V3::z);
};

// Here is some test code using this in a boost ut suite
 "user array"_test = [] {
    V3 v3{9.1, 7.2, 1.9};
    std::string buffer{};
    glz::write_json(v3, buffer);
    expect(buffer == "[9.1,7.2,1.9]");

    expect(glz::read_json(v3, "[42.1,99.2,55.3]") == glz::error_code::none);
    expect(v3.x == 42.1 && v3.y == 99.2 && v3.z == 55.3);
 };

Technically we could try to do this form of serialization without a meta on aggregate types if we used a similar trick to https://github.com/apolukhin/magic_get

But in general we need the meta until we have static reflection.

[romanholidaypancakes]

such as this: struct-pack, it can still be serialized and deserialized without storing any metadata

[mwalcott3]

Thanks for liking to that (cool lib), I understand what you are talking about. The fact that they have a limit on members makes me think they are using a similar approach to (https://www.youtube.com/watch?v=UlNUNxLtBI0) to perform static reflection but Id want to look at the source to check.

I'm a fan of the idea but I would only want to use it in binary serialization/deserialization because while we could use it for json Id prefer to wait for full static reflection in c++ because I would like automatic serialization to/from json to include keys and that would be a breaking change. On that topic binary with the default use_cx_tags = true would also be a breaking change (Not sure why that wasn't index based, possibly to allow reordering of keys, or inserting new keys in the middle).

Ill talk it over with @stephenberry but it not get merged in because something similar got removed from vireo (glaze precursor) and issues like binary/json/seek mismatch and the like. Might only be able to use this for binary read/write with use_cx_tags = false.

[stephenberry]

While we could have automatic serialization to glz::array from plain old data type structs, we are looking forward to reflection where we would prefer C++ structs to be handled as objects. So, it seems like the best path forward is to require the user to use glz::array in glz::meta explicitly.