Fixed issue with smart pointer traits specialization when converting from JSON null.

Author: danielaparker

ChangeLog.md

@@ -1,3 +1,9 @@
+v0.146.1
+--------
+
+Fixed issue with `json_type_traits` specializations of `std::shared_ptr<T>` and 
+`std::unique_ptr<T>` when converting from JSON null.
+
 v0.146.0
 --------
 

doc/Examples.md

@@ -1051,24 +1051,31 @@ int main()
     val.field8 = std::unique_ptr<std::string>(nullptr);
 
     std::string buf;
-    encode_json(val, buf);
-
-    json j = decode_json<json>(buf);
-    assert(j.contains("field1"));
-    assert(j.contains("field2"));
-    assert(j.contains("field3"));
-    assert(j.contains("field4"));
-    assert(j.contains("field5"));
-    assert(j.contains("field6"));
-    assert(!j.contains("field7"));
-    assert(!j.contains("field8"));
-
-    assert(j["field1"].as<std::string>() == std::string("Field 1"));
-    assert(j["field2"].as<std::string>() == std::string("Field 2"));
-    assert(j["field3"].is_null());
-    assert(j["field4"].is_null());
-    assert(j["field5"].as<std::string>() == std::string("Field 5"));
-    assert(j["field6"].as<std::string>() == std::string("Field 6"));
+    encode_json(val, buf, indenting::indent);
+
+    std::cout << buf << "\n";
+
+    auto other = decode_json<ns::smart_pointer_test>(buf);
+
+    assert(*other.field1 == *val.field1);
+    assert(*other.field2 == *val.field2);
+    assert(!other.field3);
+    assert(!other.field4);
+    assert(*other.field5 == *val.field5);
+    assert(*other.field6 == *val.field6);
+    assert(!other.field7);
+    assert(!other.field8);
+}
+```
+Output:
+```
+{
+    "field1": "Field 1",
+    "field2": "Field 2",
+    "field3": null,
+    "field4": null,
+    "field5": "Field 5",
+    "field6": "Field 6"
 }
 ```
 

doc/ref/json_type_traits.md

@@ -711,46 +711,52 @@ using namespace jsoncons; // for convenience
 
 int main()
 {
-        ns::smart_pointer_and_optional_test1 val;
-        val.field1 = std::make_shared<std::string>("Field 1"); 
-        val.field2 = jsoncons::make_unique<std::string>("Field 2"); 
-        val.field3 = "Field 3";
-        val.field4 = std::shared_ptr<std::string>(nullptr);
-        val.field5 = std::unique_ptr<std::string>(nullptr);
-        val.field6 = std::optional<std::string>();
-        val.field7 = std::make_shared<std::string>("Field 7"); 
-        val.field8 = jsoncons::make_unique<std::string>("Field 8"); 
-        val.field9 = "Field 9";
-        val.field10 = std::shared_ptr<std::string>(nullptr);
-        val.field11 = std::unique_ptr<std::string>(nullptr);
-        val.field12 = std::optional<std::string>();
-
-        std::string buf;
-        encode_json(val, buf);
-
-        json j = decode_json<json>(buf);
-        assert(j.contains("field1"));
-        assert(j.contains("field2"));
-        assert(j.contains("field3"));
-        assert(j.contains("field4"));
-        assert(j.contains("field5"));
-        assert(j.contains("field6"));
-        assert(j.contains("field7"));
-        assert(j.contains("field8"));
-        assert(j.contains("field9"));
-        CHECK(!j.contains("field10"));
-        CHECK(!j.contains("field11"));
-        CHECK(!j.contains("field12"));
-
-        assert(j["field1"].as<std::string>() == std::string("Field 1"));
-        assert(j["field2"].as<std::string>() == std::string("Field 2"));
-        assert(j["field3"].as<std::string>() == std::string("Field 3"));
-        assert(j["field4"].is_null());
-        assert(j["field5"].is_null());
-        assert(j["field6"].is_null());
-        assert(j["field7"].as<std::string>() == std::string("Field 7"));
-        assert(j["field8"].as<std::string>() == std::string("Field 8"));
-        assert(j["field9"].as<std::string>() == std::string("Field 9"));
+    ns::smart_pointer_and_optional_test val;
+    val.field1 = std::make_shared<std::string>("Field 1"); 
+    val.field2 = jsoncons::make_unique<std::string>("Field 2"); 
+    val.field3 = "Field 3";
+    val.field4 = std::shared_ptr<std::string>(nullptr);
+    val.field5 = std::unique_ptr<std::string>(nullptr);
+    val.field6 = std::optional<std::string>();
+    val.field7 = std::make_shared<std::string>("Field 7"); 
+    val.field8 = jsoncons::make_unique<std::string>("Field 8"); 
+    val.field9 = "Field 9";
+    val.field10 = std::shared_ptr<std::string>(nullptr);
+    val.field11 = std::unique_ptr<std::string>(nullptr);
+    val.field12 = std::optional<std::string>();
+
+    std::string buf;
+    encode_json(val, buf, indenting::indent);
+    std::cout << buf << "\n";
+
+    auto other = decode_json<ns::smart_pointer_and_optional_test>(buf);
+
+    assert(*other.field1 == *val.field1);
+    assert(*other.field2 == *val.field2);
+    assert(*other.field3 == *val.field3);
+    assert(!other.field4);
+    assert(!other.field5);
+    assert(!other.field6);
+    assert(*other.field7 == *val.field7);
+    assert(*other.field8 == *val.field8);
+    assert(*other.field9 == *val.field9);
+    assert(!other.field10);
+    assert(!other.field11);
+    assert(!other.field12);
+}
+```
+Output:
+```
+{
+    "field1": "Field 1",
+    "field2": "Field 2",
+    "field3": "Field 3",
+    "field4": null,
+    "field5": null,
+    "field6": null,
+    "field7": "Field 7",
+    "field8": "Field 8",
+    "field9": "Field 9"
 }
 ```
 

examples/src/examples.cpp

@@ -435,9 +435,9 @@ int main()
 
         json_accessor_examples();
 
-        json_traits_macros_examples();
-
         run_cbor_typed_array_examples();
+
+        json_traits_macros_examples();
     }
     catch (const std::exception& e)
     {

examples/src/json_traits_macros_examples.cpp

@@ -293,24 +293,20 @@ namespace {
         val.field8 = std::unique_ptr<std::string>(nullptr);
 
         std::string buf;
-        encode_json(val, buf);
-
-        json j = decode_json<json>(buf);
-        assert(j.contains("field1"));
-        assert(j.contains("field2"));
-        assert(j.contains("field3"));
-        assert(j.contains("field4"));
-        assert(j.contains("field5"));
-        assert(j.contains("field6"));
-        assert(!j.contains("field7"));
-        assert(!j.contains("field8"));
-
-        assert(j["field1"].as<std::string>() == std::string("Field 1"));
-        assert(j["field2"].as<std::string>() == std::string("Field 2"));
-        assert(j["field3"].is_null());
-        assert(j["field4"].is_null());
-        assert(j["field5"].as<std::string>() == std::string("Field 5"));
-        assert(j["field6"].as<std::string>() == std::string("Field 6"));
+        encode_json(val, buf, indenting::indent);
+
+        std::cout << buf << "\n";
+
+        auto other = decode_json<ns::smart_pointer_test>(buf);
+
+        assert(*other.field1 == *val.field1);
+        assert(*other.field2 == *val.field2);
+        assert(!other.field3);
+        assert(!other.field4);
+        assert(*other.field5 == *val.field5);
+        assert(*other.field6 == *val.field6);
+        assert(!other.field7);
+        assert(!other.field8);
     }
 
     void json_type_traits_book_examples()

examples_boost/interprocess_allocator/interprocess_allocator.cpp

@@ -0,0 +1,20 @@
+// interprocess_allocator.cpp : This file contains the 'main' function. Program execution begins and ends there.
+//
+
+#include <iostream>
+
+int main()
+{
+    std::cout << "Hello World!\n";
+}
+
+// Run program: Ctrl + F5 or Debug > Start Without Debugging menu
+// Debug program: F5 or Debug > Start Debugging menu
+
+// Tips for Getting Started: 
+//   1. Use the Solution Explorer window to add/manage files
+//   2. Use the Team Explorer window to connect to source control
+//   3. Use the Output window to see build output and other messages
+//   4. Use the Error List window to view errors
+//   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
+//   6. In the future, to open this project again, go to File > Open > Project and select the .sln file

examples_boost/interprocess_allocator2/shared_memory.cpp

@@ -0,0 +1,107 @@
+#include <boost/interprocess/managed_shared_memory.hpp>
+#include <boost/interprocess/containers/vector.hpp>
+#include <boost/interprocess/allocators/allocator.hpp>
+#include <boost/interprocess/containers/string.hpp>
+#include <cstdlib> //std::system
+#include <jsoncons/json.hpp>
+
+using namespace jsoncons;
+
+typedef boost::interprocess::allocator<int,
+        boost::interprocess::managed_shared_memory::segment_manager> shmem_allocator;
+
+struct boost_sorted_policy : public sorted_policy
+{
+    template <class T, class Allocator>
+    using sequence_container_type = boost::interprocess::vector<T,Allocator>;
+
+    template <class CharT, class CharTraits, class Allocator>
+    using key_storage = boost::interprocess::basic_string<CharT, CharTraits, Allocator>;
+
+    template <class CharT, class CharTraits, class Allocator>
+    using string_storage = boost::interprocess::basic_string<CharT, CharTraits, Allocator>;
+};
+
+typedef basic_json<char,boost_sorted_policy,shmem_allocator> shm_json;
+
+int main(int argc, char *argv[])
+{
+   typedef std::pair<double, int> MyType;
+
+   if(argc == 1){  //Parent process
+      //Remove shared memory on construction and destruction
+      struct shm_remove
+      {
+         shm_remove() { boost::interprocess::shared_memory_object::remove("MySharedMemory"); }
+         ~shm_remove(){ boost::interprocess::shared_memory_object::remove("MySharedMemory"); }
+      } remover;
+
+      //Construct managed shared memory
+      boost::interprocess::managed_shared_memory segment(boost::interprocess::create_only, 
+                                                         "MySharedMemory", 65536);
+
+      //Initialize shared memory STL-compatible allocator
+      const shmem_allocator allocator(segment.get_segment_manager());
+
+      // Create json value with all dynamic allocations in shared memory
+
+      shm_json* j = segment.construct<shm_json>("my json")(shm_json::array(allocator));
+      j->push_back(10);
+
+      shm_json o(allocator);
+      //o.try_emplace("category", "reference",allocator);
+      //o.try_emplace("author", "Nigel Rees",allocator);
+      //o.try_emplace("title", "Sayings of the Century",allocator);
+      //o.try_emplace("price", 8.95, allocator);
+      o.insert_or_assign("category", "reference");
+      o.insert_or_assign("author", "Nigel Rees");
+      o.insert_or_assign("title", "Sayings of the Century");
+      o.insert_or_assign("price", 8.95);
+
+      j->push_back(o);
+
+      shm_json a = shm_json::array(2,shm_json::object(allocator),allocator);
+      a[0]["first"] = 1;
+
+      j->push_back(a);
+
+      std::pair<shm_json*, boost::interprocess::managed_shared_memory::size_type> res;
+      res = segment.find<shm_json>("my json");
+
+      std::cout << "Parent:" << std::endl;
+      std::cout << pretty_print(*(res.first)) << std::endl;
+
+      //Launch child process
+      std::string s(argv[0]); s += " child ";
+      if(0 != std::system(s.c_str()))
+         return 1;
+
+
+      //Check child has destroyed all objects
+      if(segment.find<MyType>("my json").first)
+         return 1;
+   }
+   else{
+      //Open managed shared memory
+      boost::interprocess::managed_shared_memory segment(boost::interprocess::open_only, 
+                                                         "MySharedMemory");
+
+      std::pair<shm_json*, boost::interprocess::managed_shared_memory::size_type> res;
+      res = segment.find<shm_json>("my json");
+
+      if (res.first != nullptr)
+      {
+          std::cout << "Child:" << std::endl;
+          std::cout << pretty_print(*(res.first)) << std::endl;
+      }
+      else
+      {
+          std::cout << "Result is null" << std::endl;
+      }
+
+      //We're done, delete all the objects
+      segment.destroy<shm_json>("my json");
+   }
+   return 0;
+}
+

include/jsoncons/config/version.hpp

@@ -11,7 +11,7 @@
 
 #define JSONCONS_VERSION_MAJOR 0
 #define JSONCONS_VERSION_MINOR 146
-#define JSONCONS_VERSION_PATCH 0
+#define JSONCONS_VERSION_PATCH 1
 
 namespace jsoncons {
 

include/jsoncons/json_type_traits.hpp

@@ -879,7 +879,7 @@ namespace detail
 
         static std::shared_ptr<ValueType> as(const Json& j) 
         {
-            return std::make_shared<ValueType>(j.template as<ValueType>());
+            return j.is_null() ? std::shared_ptr<ValueType>(nullptr) : std::make_shared<ValueType>(j.template as<ValueType>());
         }
 
         static Json to_json(const std::shared_ptr<ValueType>& ptr) 
@@ -909,7 +909,7 @@ namespace detail
 
         static std::unique_ptr<ValueType> as(const Json& j) 
         {
-            return jsoncons::make_unique<ValueType>(j.template as<ValueType>());
+            return j.is_null() ? std::unique_ptr<ValueType>(nullptr) : jsoncons::make_unique<ValueType>(j.template as<ValueType>());
         }
 
         static Json to_json(const std::unique_ptr<ValueType>& ptr) 

tests/src/json_traits_macro_tests.cpp

@@ -1208,7 +1208,8 @@ TEST_CASE("JSONCONS_N_MEMBER_TRAITS pointer and optional test")
         val.field12 = jsoncons::optional<std::string>();
 
         std::string buf;
-        encode_json(val, buf);
+        encode_json(val, buf, indenting::indent);
+        //std::cout << buf << "\n";
 
         json j = decode_json<json>(buf);
         CHECK(j.contains("field1"));
@@ -1233,5 +1234,20 @@ TEST_CASE("JSONCONS_N_MEMBER_TRAITS pointer and optional test")
         CHECK(j["field7"].as<std::string>() == std::string("Field 7"));
         CHECK(j["field8"].as<std::string>() == std::string("Field 8"));
         CHECK(j["field9"].as<std::string>() == std::string("Field 9"));
+
+        auto other = decode_json<ns::smart_pointer_and_optional_test1>(buf);
+
+        CHECK(*other.field1 == *val.field1);
+        CHECK(*other.field2 == *val.field2);
+        CHECK(*other.field3 == *val.field3);
+        CHECK_FALSE(other.field4);
+        CHECK_FALSE(other.field5);
+        CHECK_FALSE(other.field6);
+        CHECK(*other.field7 == *val.field7);
+        CHECK(*other.field8 == *val.field8);
+        CHECK(*other.field9 == *val.field9);
+        CHECK_FALSE(other.field10);
+        CHECK_FALSE(other.field11);
+        CHECK_FALSE(other.field12);
     }
 }