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 {

fable/include/fable/schema/number.hpp

@@ -86,6 +86,8 @@ class Number : public Base<Number<T>> {
   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/number_impl.hpp

@@ -209,6 +209,12 @@ Json Number<T>::serialize(const T& x) const { return x; }
 template <typename T>
 T Number<T>::deserialize(const Conf& c) const { return c.get<T>(); }
 
+template <typename T>
+void Number<T>::serialize_into(Json& j, const T& x) const { j = x; }
+
+template <typename T>
+void Number<T>::deserialize_into(const Conf& c, T& x) const { x = c.get<T>(); }
+
 template <typename T>
 void Number<T>::reset_ptr() { ptr_ = nullptr; }
 

fable/include/fable/schema/optional.hpp

@@ -133,6 +133,10 @@ class Optional : public Base<Optional<T, P>> {
     return prototype_.deserialize(c);
   }
 
+  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 reset_ptr() override { ptr_ = nullptr; }
 
  private:

fable/include/fable/schema/passthru.hpp

@@ -82,6 +82,10 @@ class Passthru : public Base<Passthru<P>> {
 
   Type deserialize(const Conf& c) const { return c; }
 
+  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 reset_ptr() override { ptr_ = nullptr; }
 
  private:

fable/include/fable/schema/path.hpp

@@ -215,6 +215,10 @@ class Path : public Base<Path<T>> {
 
   Type deserialize(const Conf& c) const;
 
+  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 reset_ptr() override { ptr_ = nullptr; }
 
  private:

fable/include/fable/schema/string.hpp

@@ -249,6 +249,8 @@ class String : public Base<String> {
   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 { j = serialize(x); }
+  void deserialize_into(const Conf& c, Type& x) const { x = deserialize(c); }
   void reset_ptr() override;
 
  private:

fable/include/fable/schema/struct.hpp

@@ -207,6 +207,12 @@ class Struct : public Base<Struct> {
   void to_json(Json& j) const override;
   void from_conf(const Conf& c) override;
 
+  // TODO: Implement or explain why we don't need the following methods:
+  // - serialize
+  // - serialize_into
+  // - deserialize
+  // - deserialize_into
+
  private:
   void set_properties(const std::map<std::string, Box>& props);
 

fable/include/fable/schema/variant.hpp

@@ -111,6 +111,12 @@ class Variant : public Interface {
     schemas_[index].from_conf(c);
   }
 
+  // TODO: Implement or explain why we don't need the following methods:
+  // - serialize
+  // - serialize_into
+  // - deserialize
+  // - deserialize_into
+
   void reset_ptr() override;
 
  private:

fable/include/fable/schema/vector.hpp

@@ -125,26 +125,21 @@ class Vector : public Base<Vector<T, P>> {
   using Interface::to_json;
   void to_json(Json& j) const override {
     assert(ptr_ != nullptr);
-    j = serialize(*ptr_);
+    if (j.type() != JsonType::array) {
+      j = Json::array();
+    }
+    serialize_into(j, *ptr_);
   }
 
   void from_conf(const Conf& c) override {
     assert(ptr_ != nullptr);
     assert(c->type() == this->type_);
-
-    if (!option_extend_) {
-      ptr_->clear();
-    }
-
-    ptr_->reserve(c->size() + ptr_->size());
-    fill(*ptr_, c);
+    deserialize_into(c, *ptr_);
   }
 
   Json serialize(const Type& xs) const {
     Json j = Json::array();
-    for (const auto& x : xs) {
-      j.emplace_back(prototype_.serialize(x));
-    }
+    serialize_into(j, xs);
     return j;
   }
 
@@ -155,6 +150,23 @@ class Vector : public Base<Vector<T, P>> {
     return vec;
   }
 
+  void serialize_into(Json& j, const Type& xs) const {
+    for (const auto& x : xs) {
+      j.emplace_back(prototype_.serialize(x));
+    }
+  }
+
+  void deserialize_into(const Conf& c, Type& x) const {
+    auto size = c->size();
+    if (option_extend_) {
+      size += x.size();
+    } else {
+      x.clear();
+    }
+    x.reserve(size);
+    fill(x, c);
+  }
+
   void reset_ptr() override { ptr_ = nullptr; }
 
  private:

fable/src/fable/schema/boolean.cpp

@@ -53,8 +53,12 @@ void Boolean::from_conf(const Conf& c) {
 
 Json Boolean::serialize(const Type& x) const { return x; }
 
+void Boolean::serialize_into(Json& j, const Type& x) const { j = x; }
+
 Boolean::Type Boolean::deserialize(const Conf& c) const { return c.get<Type>(); }
 
+void Boolean::deserialize_into(const Conf& c, Type& x) const { x = c.get<Type>(); }
+
 void Boolean::reset_ptr() { ptr_ = nullptr; }
 
 }  // namespace schema