Use nullptr to represent JSON Null.

This change removes the need for a separate memory allocation for null and default-contructed json::values.

Author: ras0219-msft

Release/include/cpprest/json.h

@@ -46,7 +46,6 @@ namespace json
     {
         class _Value;
         class _Number;
-        class _Null;
         class _Boolean;
         class _String;
         class _Object;
@@ -738,6 +737,8 @@ namespace json
         friend class web::json::details::_Array;
         friend class web::json::details::JSON_Parser;
 
+        inline size_t serialize_size() const;
+
         /// <summary>
         /// INTERNAL USE ONLY
         /// Used by the JSON_Parser to create json::values.
@@ -1490,20 +1491,6 @@ namespace json
             friend class web::json::value;
         };
 
-        class _Null final : public _Value
-        {
-        public:
-            virtual std::unique_ptr<_Value> _copy_value() override
-            {
-                return utility::details::make_unique<_Null>();
-            }
-            virtual json::value::value_type type() const override { return json::value::Null; }
-            virtual void serialize_impl(utf8string& str) const override {
-                str.append("null");
-            }
-            virtual size_t serialize_size() const override { return 4; }
-        };
-
         class _Number final : public _Value
         {
         public:
@@ -1670,7 +1657,7 @@ namespace json
                     size_t valueSize = elem.second.size() * 20; // Multipler by each object/array element
                     if (valueSize == 0)
                     {
-                        valueSize = elem.second.m_value->serialize_size();
+                        valueSize = elem.second.serialize_size();
                     }
                     reserveSize += valueSize;
                 }
@@ -1769,7 +1756,10 @@ namespace json
 
     inline void value::serialize(std::string& outstr) const
     {
-        m_value->serialize_impl(outstr);
+        if (m_value)
+            m_value->serialize_impl(outstr);
+        else
+            outstr.append("null");
     }
 
     /// <summary>
@@ -1778,7 +1768,7 @@ namespace json
     /// <returns>The number of children. 0 for all non-composites.</returns>
     inline size_t value::size() const
     {
-        return m_value->size();
+        return m_value ? m_value->size() : 0;
     }
 
     /// <summary>
@@ -1788,13 +1778,18 @@ namespace json
     /// <returns>True if the field exists, false otherwise.</returns>
     inline bool value::has_field(const std::string& key) const
     {
-        return m_value->has_field(key);
+        return m_value ? m_value->has_field(key) : false;
+    }
+
+    inline size_t value::serialize_size() const
+    {
+        return m_value ? m_value->serialize_size() : 4;
     }
 
     inline value::value(std::unique_ptr<details::_Value> v)
         : m_value(std::move(v))
 #ifdef ENABLE_JSON_VALUE_VISUALIZER
-        , m_kind(m_value->type())
+        , m_kind(m_value ? m_value->type() : json::value::Null)
 #endif
     {}
 

Release/src/json/json.cpp

@@ -35,7 +35,7 @@ void json::keep_object_element_order(bool keep_order)
 }
 
 web::json::value::value() :
-    value(utility::details::make_unique<web::json::details::_Null>())
+    value(std::unique_ptr<web::json::details::_Value>())
 { }
 
 web::json::value::value(int32_t v) :
@@ -71,14 +71,17 @@ web::json::value::value(std::string v, bool has_escape_chars) :
 { }
 
 web::json::value::value(const value &other) :
-    value(other.m_value->_copy_value())
+    value(other.m_value ? other.m_value->_copy_value() : std::unique_ptr<json::details::_Value>(nullptr))
 { }
 
 web::json::value &web::json::value::operator=(const value &other)
 {
     if(this != &other)
     {
-        m_value = std::unique_ptr<details::_Value>(other.m_value->_copy_value());
+        if (other.m_value)
+            m_value = other.m_value->_copy_value();
+        else
+            m_value.reset();
 #ifdef ENABLE_JSON_VALUE_VISUALIZER
         m_kind = other.m_kind;
 #endif
@@ -114,41 +117,57 @@ web::json::value web::json::value::array(std::vector<value> elements)
 
 const web::json::number& web::json::value::as_number() const
 {
+    if (!m_value)
+        throw json_exception("not a number");
     return m_value->as_number();
 }
 
 double web::json::value::as_double() const
 {
+    if (!m_value)
+        throw json_exception("not a number");
     return m_value->as_double();
 }
 
 int web::json::value::as_integer() const
 {
+    if (!m_value)
+        throw json_exception("not a number");
     return m_value->as_integer();
 }
 
 bool web::json::value::as_bool() const
 {
+    if (!m_value)
+        throw json_exception("not a boolean");
     return m_value->as_bool();
 }
 
 json::array& web::json::value::as_array()
 {
+    if (!m_value)
+        throw json_exception("not an array");
     return m_value->as_array();
 }
 
 const json::array& web::json::value::as_array() const
 {
+    if (!m_value)
+        throw json_exception("not an array");
     return m_value->as_array();
 }
 
 json::object& web::json::value::as_object()
 {
+    if (!m_value)
+        throw json_exception("not an object");
     return m_value->as_object();
 }
 
 const json::object& web::json::value::as_object() const
 {
+    if (!m_value)
+        throw json_exception("not an object");
     return m_value->as_object();
 }
 
@@ -199,7 +218,7 @@ bool web::json::details::_String::has_escape_chars(const _String &str)
     });
 }
 
-web::json::value::value_type json::value::type() const { return m_value->type(); }
+web::json::value::value_type json::value::type() const { return m_value ? m_value->type() : json::value::Null; }
 
 bool json::value::is_integer() const
 {

Release/src/json/json_serialization.cpp

@@ -165,6 +165,8 @@ void web::json::details::_Number::serialize_impl(std::string& stream) const
 
 const std::string& web::json::value::as_string() const
 {
+    if (!m_value)
+        throw json_exception("not a string");
     return m_value->as_string();
 }
 
@@ -175,7 +177,7 @@ std::string json::value::serialize() const
 #endif
 
     std::string ret;
-    ret.reserve(m_value->serialize_size());
-    m_value->serialize_impl(ret);
+    ret.reserve(serialize_size());
+    serialize(ret);
     return ret;
 }