fable: Complete (de)?serialize(_into)? method implementations

There are four functions used in templates for types:

    serialize
    serialize_into
    deserialize
    deserialize_into

But they can't be implemented on all types.

This commit either implements them or explains why they can't
be implemented.

Author: cassava

fable/include/fable/schema/custom.hpp

@@ -87,11 +87,16 @@ 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
+  // NOTE: The following methods cannot be implemented because
+  // CustomDeserializer does not have an associated type:
+  //
+  //     Json serialize(const Type&) const;
+  //     void serialize_into(Json&, const Type&) const;
+  //     Type deserialize(const Conf&) const;
+  //     void deserialize_into(const Conf&, Type&) const;
+  //
+  // This means that `CustomDeserializer` cannot be used as a prototype schema
+  // directly, for example with `optional`. Use `Confable` instead.
 
  private:
   std::shared_ptr<schema::Interface> impl_{nullptr};

fable/include/fable/schema/json.hpp

@@ -59,26 +59,43 @@ class FromJson : public Base<FromJson<T>> {
     return j;
   }
 
-  bool validate(const Conf& c, std::optional<SchemaError>& err) const override { return this->validate_type(c, err); }
+  bool validate(const Conf& c, std::optional<SchemaError>& err) const override {
+    return this->validate_type(c, err);
+  }
 
   using Interface::to_json;
   void to_json(Json& j) const override {
     assert(ptr_ != nullptr);
-    j = static_cast<const Type&>(*ptr_);
+    serialize_into(j, *ptr_);
   }
 
   void from_conf(const Conf& c) override {
     assert(ptr_ != nullptr);
-    *ptr_ = c.get<Type>();
+    deserialize_into(c, *ptr_);
   }
 
   void reset_ptr() override { ptr_ = nullptr; }
 
-  // TODO: Implement or explain why we don't need the following methods:
-  // - serialize
-  // - serialize_into
-  // - deserialize
-  // - deserialize_into
+  [[nodiscard]] Json serialize(const Type& x) const {
+    Json j;
+    serialize_into(j, x);
+    return j;
+  }
+
+  void serialize_into(Json& j, const Type& x) const {
+    to_json(j, x);
+  }
+
+  template<typename = std::enable_if<std::is_default_constructible_v<Type>>>
+  [[nodiscard]] Type deserialize(const Conf& c) const {
+    Type x;
+    deserialize_into(c, x);
+    return x;
+  }
+
+  void deserialize_into(const Conf& c, Type& x) const {
+    from_json(*c, x);
+  }
 
  private:
   Type* ptr_{nullptr};

fable/include/fable/schema/struct.hpp

@@ -206,11 +206,16 @@ 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
+  // NOTE: The following methods cannot be implemented because
+  // Struct does not have an associated type:
+  //
+  //     Json serialize(const Type&) const;
+  //     void serialize_into(Json&, const Type&) const;
+  //     Type deserialize(const Conf&) const;
+  //     void deserialize_into(const Conf&, Type&) const;
+  //
+  // This means that `Struct` cannot be used as a prototype schema
+  // directly, for example with `optional`. Use `Confable` instead.
 
  private:
   void set_properties(const std::map<std::string, Box>& props);