custom read/write

[moxxxim]

Hi.
I cannot figure out how to use lambdas or std::function for custom read/write. I don't want to clutter my class with helper functions for serialization, so I don't want to use member function approach. But I don't understand, what function signature should have my lambda, and what return type (if any).

Code looks like this:

// Only Inner::Type value should be serialized. And then default value of Inner object for serialized Inner::Type value will be created on deserialization.
class Inner
{
public:
  enum class Type
  {
      Type1,
      Type2,
      Type3,    
  };

  Inner(Type aType);
  Type GetType() const;

private:
  Type type;
};

class Outer
{
  std::string name;
  Inner in;
};

template <>
struct glz::meta<Outer>
{
    using T = Outer;
    static constexpr auto value = object(
    &T::name,
    "valueType", glz::custom <read1, write2> ); // "valueType" would be serialized value of type Inner::Type (probably as a string representation).
};

// I'm trying to use this signatures for read and write.
void MyRead(Inner& in, const std::string& str);
std::string MyWrite(const Inner& in);

I keep getting the following error, but it's description is not of much help:

static_assert failed: 'IMPORTANT: If you have two arguments in your lambda (e.g. [](my_struct&, const std::string& input)) you must make all the arguments concrete types. None of the inputs can be auto. Also, you probably cannot define these lambdas within a local struct glaze, but instead need to use glz::meta outside your class so that your lambda can operate on a defined class.'

[stephenberry]

Here is a working example on compiler explorer: https://godbolt.org/z/vE7Efaan9

I implemented the read/write as lambdas, but they could be member functions or std::functions, but this is the fastest approach.

Let me know if you have more questions. I've pasted the code below as well for future reference:

#include "glaze/glaze.hpp"

// Only Inner::Type value should be serialized. And then default value of Inner
// object for serialized Inner::Type value will be created on deserialization.
class Inner {
   public:
    enum class Type {
        Type1,
        Type2,
        Type3,
    };

    Inner() = default;
    Inner(Type aType) : type(aType) {}
    Type GetType() const { return type; }

   private:
    Type type{};
};

template <>
struct glz::meta<Inner::Type> {
    using enum Inner::Type;
    static constexpr auto value = enumerate(Type1, Type2, Type3);
};

struct Outer {
    std::string name;
    Inner in;
};

template <>
struct glz::meta<Outer> {
    using T = Outer;
    static constexpr auto read = [](auto& self) {
        self.in = Inner{};  // when reading we set to the default value
    };
    static constexpr auto write = [](auto& self) {
        return self.in.GetType();  // when writing, we write the active type
    };
    static constexpr auto value = object(
        &T::name, "valueType",
        glz::custom<read, write>);  // "valueType" would be serialized value of
                                    // type Inner::Type (probably as a string
                                    // representation).
};

#include <iostream>

int main() {
    Outer outer{"outer", Inner::Type::Type2};
    std::cout << glz::write_json(outer).value_or("error") << '\n';
}

[moxxxim]

Great! It works.
Thank you.
I just changed a little read lambda to take in serialized string:

    static constexpr auto read = [](Outer& self, const std::string& str ) {
        self.in = Inner{};
        // do here with str
    };

[stephenberry]

Excellent!