fable: Enable serializing and deserializing into refs

Author: cassava

fable/include/fable/schema/boolean.hpp

@@ -45,6 +45,8 @@ class Boolean : public Base<Boolean> {
   void from_conf(const Conf& c) override;
   Json serialize(const Type& x) const;
   Type deserialize(const Conf& c) const;
+  void serialize_into(Json& j, const Type& x) const;
+  void deserialize_into(const Conf& c, Type& x) const;
   void reset_ptr() override;
 
  private:

fable/include/fable/schema/confable.hpp

@@ -93,6 +93,10 @@ class FromConfable : public Base<FromConfable<T>> {
     return tmp;
   }
 
+  void serialize_into(Json& j, const Type& x) const { x.to_json(j); }
+
+  void deserialize_into(const Conf& c, Type& x) const { x.from_conf(c); }
+
   void reset_ptr() override {
     ptr_ = nullptr;
     schema_.reset_ptr();

fable/include/fable/schema/const.hpp

@@ -81,6 +81,15 @@ class Const : public Base<Const<T, P>> {
     return constant_;
   }
 
+  void serialize_into(Json& j, const Type& x) const {
+    prototype_.serialize_into(j, x);
+  }
+
+  void deserialize_into(const Conf& c, Type& x) const {
+    validate(c);
+    x = constant_;
+  }
+
   void reset_ptr() override {}
 
  private:

fable/include/fable/schema/custom.hpp

@@ -84,6 +84,12 @@ class CustomDeserializer : public schema::Interface {
 
   friend void to_json(Json& j, const CustomDeserializer& b) { b.impl_->to_json(j); }
 
+  // TODO: Implement or explain why we don't need the following methods:
+  // - serialize
+  // - serialize_into
+  // - deserialize
+  // - deserialize_into
+
  private:
   std::shared_ptr<schema::Interface> impl_{nullptr};
   std::function<void(CustomDeserializer*, const Conf&)> from_conf_fn_{};

fable/include/fable/schema/duration.hpp

@@ -136,6 +136,10 @@ class Duration : public Base<Duration<T, Period>> {
 
   Type deserialize(const Conf& c) const { return Type(c.get<T>()); }
 
+  void serialize_into(Json& j, const Type& x) const { j = x.count(); }
+
+  void deserialize_into(const Conf& c, Type& x) const { x = deserialize(c); }
+
   void reset_ptr() override { ptr_ = nullptr; }
 
  private:

fable/include/fable/schema/enum.hpp

@@ -93,6 +93,10 @@ class Enum : public Base<Enum<T>> {
     }
   }
 
+  void serialize_into(Json& j, const Type& x) const { j = mapping_to_.at(x); }
+
+  void deserialize_into(const Conf& c, Type& x) const { x = deserialize(c); }
+
   void reset_ptr() override { ptr_ = nullptr; }
 
  private:

fable/include/fable/schema/factory.hpp

@@ -292,6 +292,10 @@ class FactoryBase : public Base<CRTP> {
 
   Json serialize(const Type& x) const { return x; }
 
+  void serialize_into(Json& j, const Type& x) const { j = serialize(x); }
+
+  void deserialize_into(const Conf& c, Type& x) const { x = deserialize(c); }
+
   void from_conf(const Conf& c) override {
     throw std::logic_error("FactoryBase::from_conf() should not be used");
   }

fable/include/fable/schema/ignore.hpp

@@ -43,6 +43,8 @@ namespace schema {
  */
 class Ignore : public Base<Ignore> {
  public:  // Constructors
+  using Type = struct {};
+
   Ignore() : Base(JsonType::object, "ignored") {}
   explicit Ignore(std::string desc, JsonType t = JsonType::object) : Base(t, std::move(desc)) {}
 
@@ -58,6 +60,11 @@ class Ignore : public Base<Ignore> {
   void to_json(Json& j) const override { j = nullptr; }
   void from_conf(const Conf&) override {}
   void reset_ptr() override {}
+
+  Json serialize(const Type&) const { return nullptr; }
+  Type deserialize(const Conf&) const { return {}; }
+  void serialize_into(Json&, const Type&) const {}
+  void deserialize_into(const Conf&, Type&) const {}
 };
 
 }  // namespace schema

fable/include/fable/schema/json.hpp

@@ -75,6 +75,12 @@ class FromJson : public Base<FromJson<T>> {
 
   void reset_ptr() override { ptr_ = nullptr; }
 
+  // TODO: Implement or explain why we don't need the following methods:
+  // - serialize
+  // - serialize_into
+  // - deserialize
+  // - deserialize_into
+
  private:
   Type* ptr_{nullptr};
 };

fable/include/fable/schema/map.hpp

@@ -155,21 +155,29 @@ class Map : public Base<Map<T, P>> {
     }
   }
 
-  Json serialize(const Type& xm) const {
+  Json serialize(const Type& x) const {
     Json j;
-    for (const auto& kv : xm) {
-      j[kv.first] = prototype_.serialize(kv.second);
-    }
+    serialize_into(j, x);
     return j;
   }
 
   Type deserialize(const Conf& c) const {
     Type tmp;
+    deserialize_into(c, tmp);
+    return tmp;
+  }
+
+  void serialize_into(Json& j, const Type& x) const {
+    for (const auto& kv : x) {
+      j[kv.first] = prototype_.serialize(kv.second);
+    }
+  }
+
+  void deserialize_into(const Conf& c, Type& x) const {
     for (auto& i : c->items()) {
       const auto key = i.key();
-      tmp.insert(std::make_pair(key, deserialize_item(c, key)));
+      x.insert(std::make_pair(key, deserialize_item(c, key)));
     }
-    return tmp;
   }
 
   T deserialize_item(const Conf& c, const std::string& key) const {