Different JSONs - the same class

[Bolderaysky]

Sometimes it's useful to generate json with different fields from the same class/structure, for example:

struct Thing {
  std::string a;
  std::uint64_t b;
};

Thing obj;
obj.a = "Hello, World";
obj.b = 42;

// Potentially, creating one of 3 jsons: '{ "a":42 }', '{ "b": "Hello, World"}', or both together: '{ "a": 42, "b": "Hello, World"}'

As far as I see, it's not currently possible to generate different JSONs from the same class/object. If it's not possible, how it potentially could look:

struct Thing {

        std::string a;
        std::uint64_t b;
};

struct meta_1 {

        using T = Thing;
        static constexpr auto value = glz::object("a", &T::a);
};

struct meta_2 {

    using T = Thing;
    static constexpr auto value = glz::object("b", &T::b);

};

Thing obj;
obj.a = "Hello, World";
obj.b = 42;

std::string buf;

glz::write<meta_1>(obj, buf);
expect(buf == R"({"a":"Hello, World"})");

glz::write<meta_2>(obj, buf);
expect(buf == R"({"b":42})");

If user didn't specify struct with metadata explicitly, glz::meta specialization or inline struct glaze can be used as before. This way, it would easily allow to serialize or deserialize different interfaces or parts of interfaces with the same class, making glaze much more flexible

[jbbjarnason]

Is std::optional an option for you? (around a and b)

otherwise you could do something like

struct Thing_a : Thing {};
struct Thing_b : Thing {};

template <>
struct glz::meta<Thing_a> {
  static constexpr auto value{ glz::object("a", &Thing_a::a) };
};
glz::write(Thing_a{.a="foo"});
// etc

[stephenberry]

It seems like this is particularly useful for writing JSON, as reading JSON keys are already optional. Have you looked at glz::obj, which lets you write out different combinations of parameters.

auto meta1 = glz::obj("a", &T::a);
glz::write_json(meta1, buf);

auto meta2 = glz::obj("b", &T::b);
glz::write_json(meta2, buf);

That should give you the behavior you want.

[justend29]

@Bolderaysky, I totally agree with the suggestions by @jbbjarnason and @stephenberry.

I do what you're requesting in my own code, too.
Although it's not using the "same" class, my preferred solution to provide the representation alternatives you talk about would be using separate classes to wrap the single data class. This is just like the meta_1 & meta_2.
As compared to using optionals, it extends to more complex representations, and as compared with glz::obj (which rocks), it's not inline, meaning keeping consistent representations throughout the code is easier with standard glaze functions.
Furthermore, having separate wrapping structures means you can change the semantics of these wrappers to actually match the JSON interface it exposes (only provide get_a(), for example). This allows your C++ & JSON interfaces to mimic each other.

Shown below is a complete example of how one could create these wrappers using inheritance or composition. The C++ interfaces were not tailored, but I hope this is useful to you and others for the representation portion.

#include <cassert>
#include <cstdint>
#include <string>

#include <glaze/core/common.hpp>
#include <glaze/core/meta.hpp>
#include <glaze/json/write.hpp>

struct Thing {
  std::string a{};
  std::uint64_t b{};
};

namespace inherit {

struct Internal_thing final : Thing {
  struct glaze {
    static constexpr auto value = glz::object(&Thing::a, &Thing::b);
  };
};

struct Freemium_thing final : Thing {
  struct glaze {
    static constexpr auto value = glz::object(&Thing::b);
  };
};

struct Paid_thing final : Thing {
  struct glaze {
    static constexpr auto value = glz::object(&Thing::a);
  };
};

} // namespace inherit

namespace compose {

struct Internal_thing {
  Thing t{}; // could be a ref if Internal_thing is only for interface
  struct glaze {
    static constexpr auto value = glz::object(
        "a", [](auto &&self) -> decltype(auto) { return self.t.a; }, //
        "b", [](auto &&self) -> decltype(auto) { return self.t.b; });
  };
};

struct Freemium_thing {
  Thing t{}; // could be a ref if Fremium_thing is only for interface
  struct glaze {
    static constexpr auto value = glz::object(
        "b", [](auto &&self) -> decltype(auto) { return self.t.b; });
  };
};

struct Paid_thing {
  Thing t{}; // could be a ref if Paid_thing is only for interface
  struct glaze {
    static constexpr auto value = glz::object(
        "a", [](auto &&self) -> decltype(auto) { return self.t.a; });
  };
};

} // namespace compose

int main() {
  {
    // I know exactly what interface I want, and I have an instance of that...
    {
      // with inherited versions:
      const inherit::Internal_thing internal_thing{"one", 2};
      const inherit::Freemium_thing freemium_thing{"one", 2};
      const inherit::Paid_thing paid_thing{"one", 2};
      assert(glz::write_json(internal_thing) == R"({"a":"one","b":2})");
      assert(glz::write_json(freemium_thing) == R"({"b":2})");
      assert(glz::write_json(paid_thing) == R"({"a":"one"})");
    }

    {
      // with composed versions:
      const compose::Internal_thing internal_thing{{"one", 2}};
      const compose::Freemium_thing freemium_thing{{"one", 2}};
      const compose::Paid_thing paid_thing{{"one", 2}};
      assert(glz::write_json(internal_thing) == R"({"a":"one","b":2})");
      assert(glz::write_json(freemium_thing) == R"({"b":2})");
      assert(glz::write_json(paid_thing) == R"({"a":"one"})");
    }
  }

  // I already have a Thing and I want to present it with a given interface...
  {
    {
      // with inherited versions (via construction):
      const Thing given{"one", 2};
      const compose::Internal_thing internal_thing{given};
      const compose::Freemium_thing freemium_thing{given};
      const compose::Paid_thing paid_thing{given};
      assert(glz::write_json(internal_thing) == R"({"a":"one","b":2})");
      assert(glz::write_json(freemium_thing) == R"({"b":2})");
      assert(glz::write_json(paid_thing) == R"({"a":"one"})");
    }

    {
      // with inherited versions (via casting (less type-safe)):
      const Thing given{"one", 2};
      const auto &internal_thing =
          static_cast<const inherit::Internal_thing &>(given);
      const auto &freemium_thing =
          static_cast<const inherit::Freemium_thing &>(given);
      const auto &paid_thing = static_cast<const inherit::Paid_thing &>(given);
      assert(glz::write_json(internal_thing) == R"({"a":"one","b":2})");
      assert(glz::write_json(freemium_thing) == R"({"b":2})");
      assert(glz::write_json(paid_thing) == R"({"a":"one"})");
    }

    {
      // with composed versions:
      const Thing given{"one", 2};
      const compose::Internal_thing internal_thing{given};
      const compose::Freemium_thing freemium_thing{given};
      const compose::Paid_thing paid_thing{given};
      assert(glz::write_json(internal_thing) == R"({"a":"one","b":2})");
      assert(glz::write_json(freemium_thing) == R"({"b":2})");
      assert(glz::write_json(paid_thing) == R"({"a":"one"})");
    }
  }
}

[Bolderaysky]

Yeah, @stephenberry and @justend29 both right, glz::write_json does what I meant. I didn't test it yet, but it looks like solution with inheritance can be easily adapted to work with reading as well, which is cool.

Closing as solved.