Fix any, embedded object, array, and struct serialization (#94)

* add embedded object serialization tests (failing)

* Add empty object tests (failing)

* test for deserializing null field object (failing)

* Fix embedded object deserialization

* Fix serializing empty objects on nlohmann

* Fix nullptr_t handling in `any`

* Add test for de/serializing struct embedded in `object`

* Remove extraneous `get()` from `any`

* fix compiler errors and warnings on gcc

* add `any = dap::null` assignment test

* Remove extraneous template

include/dap/any.h

@@ -23,6 +23,8 @@ namespace dap {
 
 template <typename T>
 struct TypeOf;
+class Deserializer;
+class Serializer;
 
 // any provides a type-safe container for values of any of dap type (boolean,
 // integer, number, array, variant, any, null, dap-structs).
@@ -47,6 +49,7 @@ class any {
   inline any& operator=(any&& rhs) noexcept;
   template <typename T>
   inline any& operator=(const T& val);
+  inline any& operator=(const std::nullptr_t& val);
 
   // get() returns the contained value of the type T.
   // If the any does not contain a value of type T, then get() will assert.
@@ -58,6 +61,9 @@ class any {
   inline bool is() const;
 
  private:
+  friend class Deserializer;
+  friend class Serializer;
+
   static inline void* alignUp(void* val, size_t alignment);
   inline void alloc(size_t size, size_t align);
   inline void free();
@@ -142,8 +148,15 @@ any& any::operator=(const T& val) {
   return *this;
 }
 
+any& any::operator=(const std::nullptr_t&) {
+  reset();
+  return *this;
+}
+
 template <typename T>
 T& any::get() const {
+  static_assert(!std::is_same<T, std::nullptr_t>(),
+                "Cannot get nullptr from 'any'.");
   assert(is<T>());
   return *reinterpret_cast<T*>(value);
 }

include/dap/serialization.h

@@ -177,8 +177,18 @@ class Serializer {
 
   // deserialize() encodes the given string.
   inline bool serialize(const char* v);
+ protected:
+  static inline const TypeInfo* get_any_type(const any&);
+  static inline const void* get_any_val(const any&);
 };
 
+inline const TypeInfo* Serializer::get_any_type(const any& a){
+  return a.type;
+}
+const void* Serializer::get_any_val(const any& a) {
+  return a.value;
+}
+
 template <typename T, typename>
 bool Serializer::serialize(const T& object) {
   return TypeOf<T>::type()->serialize(this, &object);

src/any_test.cpp

@@ -42,6 +42,10 @@ namespace {
 template <typename T>
 struct TestValue {};
 
+template <>
+struct TestValue<dap::null> {
+  static const dap::null value;
+};
 template <>
 struct TestValue<dap::integer> {
   static const dap::integer value;
@@ -67,6 +71,7 @@ struct TestValue<dap::AnyTestObject> {
   static const dap::AnyTestObject value;
 };
 
+const dap::null TestValue<dap::null>::value = nullptr;
 const dap::integer TestValue<dap::integer>::value = 20;
 const dap::boolean TestValue<dap::boolean>::value = true;
 const dap::number TestValue<dap::number>::value = 123.45;
@@ -152,7 +157,24 @@ TEST(Any, TestObject) {
 template <typename T>
 class AnyT : public ::testing::Test {
  protected:
-  void check(const dap::any& any, const T& expect) {
+  template <typename T0,
+            typename = std::enable_if<std::is_same<T, T0>::value &&
+                                      !std::is_same<T0, dap::null>::value>>
+  void check_val(const dap::any& any, const T0& expect) {
+    ASSERT_EQ(any.is<T>(), any.is<T0>());
+    ASSERT_EQ(any.get<T>(), expect);
+  }
+
+  // Special case for Null assignment, as we can assign nullptr_t to any but
+  // can't `get()` it
+  template <typename = dap::null>
+  void check_val(const dap::any& any, const dap::null& expect) {
+    ASSERT_EQ(nullptr, expect);
+    ASSERT_TRUE(any.is<dap::null>());
+  }
+
+  void check_type(const dap::any& any) {
+    ASSERT_EQ(any.is<dap::null>(), (std::is_same<T, dap::null>::value));
     ASSERT_EQ(any.is<dap::integer>(), (std::is_same<T, dap::integer>::value));
     ASSERT_EQ(any.is<dap::boolean>(), (std::is_same<T, dap::boolean>::value));
     ASSERT_EQ(any.is<dap::number>(), (std::is_same<T, dap::number>::value));
@@ -161,8 +183,6 @@ class AnyT : public ::testing::Test {
               (std::is_same<T, dap::array<dap::string>>::value));
     ASSERT_EQ(any.is<dap::AnyTestObject>(),
               (std::is_same<T, dap::AnyTestObject>::value));
-
-    ASSERT_EQ(any.get<T>(), expect);
   }
 };
 TYPED_TEST_SUITE_P(AnyT);
@@ -170,27 +190,31 @@ TYPED_TEST_SUITE_P(AnyT);
 TYPED_TEST_P(AnyT, CopyConstruct) {
   auto val = TestValue<TypeParam>::value;
   dap::any any(val);
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }
 
 TYPED_TEST_P(AnyT, MoveConstruct) {
   auto val = TestValue<TypeParam>::value;
   dap::any any(std::move(val));
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }
 
 TYPED_TEST_P(AnyT, Assign) {
   auto val = TestValue<TypeParam>::value;
   dap::any any;
   any = val;
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }
 
 TYPED_TEST_P(AnyT, MoveAssign) {
   auto val = TestValue<TypeParam>::value;
   dap::any any;
   any = std::move(val);
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }
 
 TYPED_TEST_P(AnyT, RepeatedAssign) {
@@ -199,7 +223,8 @@ TYPED_TEST_P(AnyT, RepeatedAssign) {
   dap::any any;
   any = str;
   any = val;
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }
 
 TYPED_TEST_P(AnyT, RepeatedMoveAssign) {
@@ -208,7 +233,8 @@ TYPED_TEST_P(AnyT, RepeatedMoveAssign) {
   dap::any any;
   any = std::move(str);
   any = std::move(val);
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }
 
 REGISTER_TYPED_TEST_SUITE_P(AnyT,
@@ -219,7 +245,8 @@ REGISTER_TYPED_TEST_SUITE_P(AnyT,
                             RepeatedAssign,
                             RepeatedMoveAssign);
 
-using AnyTypes = ::testing::Types<dap::integer,
+using AnyTypes = ::testing::Types<dap::null,
+                                  dap::integer,
                                   dap::boolean,
                                   dap::number,
                                   dap::string,

src/json_serializer_test.cpp

@@ -58,9 +58,60 @@ struct JSONObjectNoFields {};
 
 DAP_STRUCT_TYPEINFO(JSONObjectNoFields, "json-object-no-fields");
 
+struct SimpleJSONTestObject {
+  boolean b;
+  integer i;
+};
+DAP_STRUCT_TYPEINFO(SimpleJSONTestObject,
+                    "simple-json-test-object",
+                    DAP_FIELD(b, "b"),
+                    DAP_FIELD(i, "i"));
+
 }  // namespace dap
 
-TEST(JSONSerializer, SerializeDeserialize) {
+class JSONSerializer : public testing::Test {
+ protected:
+  static dap::object GetSimpleObject() {
+    return dap::object({{"one", dap::integer(1)},
+                        {"two", dap::number(2)},
+                        {"three", dap::string("three")},
+                        {"four", dap::boolean(true)}});
+  }
+  void TEST_SIMPLE_OBJECT(const dap::object& obj) {
+    NESTED_TEST_FAILED = true;
+    auto ref_obj = GetSimpleObject();
+    ASSERT_EQ(obj.size(), ref_obj.size());
+    ASSERT_TRUE(obj.at("one").is<dap::integer>());
+    ASSERT_TRUE(obj.at("two").is<dap::number>());
+    ASSERT_TRUE(obj.at("three").is<dap::string>());
+    ASSERT_TRUE(obj.at("four").is<dap::boolean>());
+
+    ASSERT_EQ(ref_obj.at("one").get<dap::integer>(),
+              obj.at("one").get<dap::integer>());
+    ASSERT_EQ(ref_obj.at("two").get<dap::number>(),
+              obj.at("two").get<dap::number>());
+    ASSERT_EQ(ref_obj.at("three").get<dap::string>(),
+              obj.at("three").get<dap::string>());
+    ASSERT_EQ(ref_obj.at("four").get<dap::boolean>(),
+              obj.at("four").get<dap::boolean>());
+    NESTED_TEST_FAILED = false;
+  }
+  template <typename T>
+  void TEST_SERIALIZING_DESERIALIZING(const T& encoded, T& decoded) {
+    NESTED_TEST_FAILED = true;
+    dap::json::Serializer s;
+    ASSERT_TRUE(s.serialize(encoded));
+    dap::json::Deserializer d(s.dump());
+    ASSERT_TRUE(d.deserialize(&decoded));
+    NESTED_TEST_FAILED = false;
+  }
+  bool NESTED_TEST_FAILED = false;
+#define _ASSERT_PASS(NESTED_TEST) \
+  NESTED_TEST;                    \
+  ASSERT_FALSE(NESTED_TEST_FAILED);
+};
+
+TEST_F(JSONSerializer, SerializeDeserialize) {
   dap::JSONTestObject encoded;
   encoded.b = true;
   encoded.i = 32;
@@ -92,9 +143,124 @@ TEST(JSONSerializer, SerializeDeserialize) {
   ASSERT_EQ(encoded.inner.i, decoded.inner.i);
 }
 
-TEST(JSONSerializer, SerializeObjectNoFields) {
+TEST_F(JSONSerializer, SerializeObjectNoFields) {
   dap::JSONObjectNoFields obj;
   dap::json::Serializer s;
   ASSERT_TRUE(s.serialize(obj));
   ASSERT_EQ(s.dump(), "{}");
 }
+
+TEST_F(JSONSerializer, SerializeDeserializeObject) {
+  dap::object encoded = GetSimpleObject();
+  dap::object decoded;
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded));
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeEmbeddedObject) {
+  dap::object encoded;
+  dap::object decoded;
+  // object nested inside object
+  dap::object encoded_embed_obj = GetSimpleObject();
+  dap::object decoded_embed_obj;
+  encoded["embed_obj"] = encoded_embed_obj;
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  ASSERT_TRUE(decoded["embed_obj"].is<dap::object>());
+  decoded_embed_obj = decoded["embed_obj"].get<dap::object>();
+  _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded_embed_obj));
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeEmbeddedStruct) {
+  dap::object encoded;
+  dap::object decoded;
+  // object nested inside object
+  dap::SimpleJSONTestObject encoded_embed_struct;
+  encoded_embed_struct.b = true;
+  encoded_embed_struct.i = 50;
+  encoded["embed_struct"] = encoded_embed_struct;
+
+  dap::object decoded_embed_obj;
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  ASSERT_TRUE(decoded["embed_struct"].is<dap::object>());
+  decoded_embed_obj = decoded["embed_struct"].get<dap::object>();
+  ASSERT_TRUE(decoded_embed_obj.at("b").is<dap::boolean>());
+  ASSERT_TRUE(decoded_embed_obj.at("i").is<dap::integer>());
+
+  ASSERT_EQ(encoded_embed_struct.b, decoded_embed_obj["b"].get<dap::boolean>());
+  ASSERT_EQ(encoded_embed_struct.i, decoded_embed_obj["i"].get<dap::integer>());
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeEmbeddedIntArray) {
+  dap::object encoded;
+  dap::object decoded;
+  // array nested inside object
+  dap::array<dap::integer> encoded_embed_arr = {1, 2, 3, 4};
+  dap::array<dap::any> decoded_embed_arr;
+
+  encoded["embed_arr"] = encoded_embed_arr;
+
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  // TODO: Deserializing array should infer basic member types
+  ASSERT_TRUE(decoded["embed_arr"].is<dap::array<dap::any>>());
+  decoded_embed_arr = decoded["embed_arr"].get<dap::array<dap::any>>();
+  ASSERT_EQ(encoded_embed_arr.size(), decoded_embed_arr.size());
+  for (std::size_t i = 0; i < decoded_embed_arr.size(); i++) {
+    ASSERT_TRUE(decoded_embed_arr[i].is<dap::integer>());
+    ASSERT_EQ(encoded_embed_arr[i], decoded_embed_arr[i].get<dap::integer>());
+  }
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeEmbeddedObjectArray) {
+  dap::object encoded;
+  dap::object decoded;
+
+  dap::array<dap::object> encoded_embed_arr = {GetSimpleObject(),
+                                               GetSimpleObject()};
+  dap::array<dap::any> decoded_embed_arr;
+
+  encoded["embed_arr"] = encoded_embed_arr;
+
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  // TODO: Deserializing array should infer basic member types
+  ASSERT_TRUE(decoded["embed_arr"].is<dap::array<dap::any>>());
+  decoded_embed_arr = decoded["embed_arr"].get<dap::array<dap::any>>();
+  ASSERT_EQ(encoded_embed_arr.size(), decoded_embed_arr.size());
+  for (std::size_t i = 0; i < decoded_embed_arr.size(); i++) {
+    ASSERT_TRUE(decoded_embed_arr[i].is<dap::object>());
+    _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded_embed_arr[i].get<dap::object>()));
+  }
+}
+
+TEST_F(JSONSerializer, DeserializeSerializeEmptyObject) {
+  auto empty_obj = "{}";
+  dap::object decoded;
+  dap::json::Deserializer d(empty_obj);
+  ASSERT_TRUE(d.deserialize(&decoded));
+  dap::json::Serializer s;
+  ASSERT_TRUE(s.serialize(decoded));
+  ASSERT_EQ(s.dump(), empty_obj);
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeEmbeddedEmptyObject) {
+  dap::object encoded_empty_obj;
+  dap::object encoded = {{"empty_obj", encoded_empty_obj}};
+  dap::object decoded;
+
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  ASSERT_TRUE(decoded["empty_obj"].is<dap::object>());
+  dap::object decoded_empty_obj = decoded["empty_obj"].get<dap::object>();
+  ASSERT_EQ(encoded_empty_obj.size(), decoded_empty_obj.size());
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeObjectWithNulledField) {
+  auto thing = dap::any(dap::null());
+  dap::object encoded;
+  encoded["nulled_field"] = dap::null();
+  dap::json::Serializer s;
+  ASSERT_TRUE(s.serialize(encoded));
+  dap::object decoded;
+  auto dump = s.dump();
+  dap::json::Deserializer d(dump);
+  ASSERT_TRUE(d.deserialize(&decoded));
+  ASSERT_TRUE(encoded["nulled_field"].is<dap::null>());
+}

src/nlohmann_json_serializer.cpp

@@ -91,6 +91,18 @@ bool NlohmannDeserializer::deserialize(dap::any* v) const {
     *v = dap::integer(json->get<int64_t>());
   } else if (json->is_string()) {
     *v = json->get<std::string>();
+  } else if (json->is_object()) {
+    dap::object obj;
+    if (!deserialize(&obj)) {
+      return false;
+    }
+    *v = obj;
+  } else if (json->is_array()) {
+    dap::array<any> arr;
+    if (!deserialize(&arr)) {
+      return false;
+    }
+    *v = arr;
   } else if (json->is_null()) {
     *v = null();
   } else {
@@ -169,6 +181,9 @@ bool NlohmannSerializer::serialize(const dap::string& v) {
 }
 
 bool NlohmannSerializer::serialize(const dap::object& v) {
+  if (!json->is_object()) {
+    *json = nlohmann::json::object();
+  }
   for (auto& it : v) {
     NlohmannSerializer s(&(*json)[it.first]);
     if (!s.serialize(it.second)) {
@@ -187,11 +202,19 @@ bool NlohmannSerializer::serialize(const dap::any& v) {
     *json = (double)v.get<dap::number>();
   } else if (v.is<dap::string>()) {
     *json = v.get<dap::string>();
+  } else if (v.is<dap::object>()) {
+    // reachable if dap::object nested is inside other dap::object
+    return serialize(v.get<dap::object>());
   } else if (v.is<dap::null>()) {
   } else {
+    // reachable if array or custom serialized type is nested inside other
+    auto type = get_any_type(v);
+    auto value = get_any_val(v);
+    if (type && value) {
+      return type->serialize(this, value);
+    }
     return false;
   }
-
   return true;
 }
 

src/rapid_json_serializer.cpp

@@ -98,6 +98,18 @@ bool RapidDeserializer::deserialize(dap::any* v) const {
     *v = dap::string(json()->GetString());
   } else if (json()->IsNull()) {
     *v = null();
+  } else if (json()->IsObject()) {
+    dap::object obj;
+    if (!deserialize(&obj)) {
+      return false;
+    }
+    *v = obj;
+  } else if (json()->IsArray()){
+    dap::array<any> arr;
+    if (!deserialize(&arr)){
+      return false;
+    }
+    *v = arr;
   } else {
     return false;
   }
@@ -203,8 +215,17 @@ bool RapidSerializer::serialize(const dap::any& v) {
   } else if (v.is<dap::string>()) {
     auto s = v.get<dap::string>();
     json()->SetString(s.data(), static_cast<uint32_t>(s.length()), allocator);
+  } else if (v.is<dap::object>()) {
+    // reachable if dap::object nested is inside other dap::object
+    return serialize(v.get<dap::object>());
   } else if (v.is<dap::null>()) {
   } else {
+    // reachable if array or custom serialized type is nested inside other dap::object
+    auto type = get_any_type(v);
+    auto value = get_any_val(v);
+    if (type && value) {
+      return type->serialize(this, value);
+    }
     return false;
   }