Change Json library (#18)

Author: BrennanConroy

src/signalrclient/CMakeLists.txt

@@ -21,10 +21,12 @@ set (SOURCES
   websocket_transport.cpp
   ../../third_party_code/cpprestsdk/uri.cpp
   ../../third_party_code/cpprestsdk/uri_builder.cpp
+  ../../third_party_code/jsoncpp/jsoncpp.cpp
 )
 
 include_directories(
-    ../../third_party_code/cpprestsdk)
+    ../../third_party_code/cpprestsdk
+    ../../third_party_code/jsoncpp)
 
 add_library (signalrclient SHARED ${SOURCES})
 

src/signalrclient/handshake_protocol.cpp

@@ -17,7 +17,8 @@ namespace signalr
                 { "protocol", signalr::value(protocol->name()) },
                 { "version", signalr::value((double)protocol->version()) }
             };
-            return utility::conversions::to_utf8string(createJson(signalr::value(std::move(map))).serialize()) + record_separator;
+
+            return Json::writeString(getJsonWriter(), createJson(signalr::value(std::move(map)))) + record_separator;
         }
 
         std::tuple<std::string, signalr::value> parse_handshake(const std::string& response)
@@ -28,9 +29,17 @@ namespace signalr
                 throw signalr_exception("incomplete message received");
             }
             auto message = response.substr(0, pos);
-            auto result = web::json::value::parse(utility::conversions::to_string_t(message));
+
+            Json::Value root;
+            auto reader = getJsonReader();
+            std::string errors;
+
+            if (!reader->parse(message.c_str(), message.c_str() + message.size(), &root, &errors))
+            {
+                throw signalr_exception(errors);
+            }
             auto remaining_data = response.substr(pos + 1);
-            return std::forward_as_tuple(remaining_data, createValue(result));
+            return std::forward_as_tuple(remaining_data, createValue(root));
         }
     }
 }

src/signalrclient/json_helpers.cpp

@@ -3,78 +3,105 @@
 
 #include "stdafx.h"
 #include "json_helpers.h"
+#include <cmath>
 
 namespace signalr
 {
-    signalr::value createValue(const web::json::value& v)
+    signalr::value createValue(const Json::Value& v)
     {
         switch (v.type())
         {
-        case web::json::value::Boolean:
-            return signalr::value(v.as_bool());
-        case web::json::value::Number:
-            return signalr::value(v.as_double());
-        case web::json::value::String:
-            return signalr::value(utility::conversions::to_utf8string(v.as_string()));
-        case web::json::value::Array:
+        case Json::ValueType::booleanValue:
+            return signalr::value(v.asBool());
+        case Json::ValueType::realValue:
+        case Json::ValueType::intValue:
+        case Json::ValueType::uintValue:
+            return signalr::value(v.asDouble());
+        case Json::ValueType::stringValue:
+            return signalr::value(v.asString());
+        case Json::ValueType::arrayValue:
         {
-            auto& array = v.as_array();
             std::vector<signalr::value> vec;
-            for (auto& val : array)
+            for (auto& val : v)
             {
                 vec.push_back(createValue(val));
             }
             return signalr::value(std::move(vec));
         }
-        case web::json::value::Object:
+        case Json::ValueType::objectValue:
         {
-            auto& obj = v.as_object();
             std::map<std::string, signalr::value> map;
-            for (auto& val : obj)
+            for (const auto& val : v.getMemberNames())
             {
-                map.insert({ utility::conversions::to_utf8string(val.first), createValue(val.second) });
+                map.insert({ val, createValue(v[val]) });
             }
             return signalr::value(std::move(map));
         }
-        case web::json::value::Null:
+        case Json::ValueType::nullValue:
         default:
             return signalr::value();
         }
     }
 
-    web::json::value createJson(const signalr::value& v)
+    Json::Value createJson(const signalr::value& v)
     {
         switch (v.type())
         {
         case signalr::value_type::boolean:
-            return web::json::value(v.as_bool());
+            return Json::Value(v.as_bool());
         case signalr::value_type::float64:
-            return web::json::value(v.as_double());
+        {
+            auto value = v.as_double();
+            double intPart;
+            // Workaround for 1.0 being output as 1.0 instead of 1
+            // because the server expects certain values to be 1 instead of 1.0 (like protocol version)
+            if (std::modf(value, &intPart) == 0)
+            {
+                return Json::Value((int)intPart);
+            }
+            return Json::Value(v.as_double());
+        }
         case signalr::value_type::string:
-            return web::json::value(utility::conversions::to_string_t(v.as_string()));
+            return Json::Value(v.as_string());
         case signalr::value_type::array:
         {
             const auto& array = v.as_array();
-            auto vec = std::vector<web::json::value>();
+            Json::Value vec(Json::ValueType::arrayValue);
             for (auto& val : array)
             {
-                vec.push_back(createJson(val));
+                vec.append(createJson(val));
             }
-            return web::json::value::array(vec);
+            return vec;
         }
         case signalr::value_type::map:
         {
             const auto& obj = v.as_map();
-            auto o = web::json::value::object();
+            Json::Value object(Json::ValueType::objectValue);
             for (auto& val : obj)
             {
-                o[utility::conversions::to_string_t(val.first)] = createJson(val.second);
+                object[val.first] = createJson(val.second);
             }
-            return o;
+            return object;
         }
         case signalr::value_type::null:
         default:
-            return web::json::value::null();
+            return Json::Value(Json::ValueType::nullValue);
         }
     }
+
+    Json::StreamWriterBuilder getJsonWriter()
+    {
+        auto writer = Json::StreamWriterBuilder();
+        writer["commentStyle"] = "None";
+        writer["indentation"] = "";
+        return writer;
+    }
+
+    std::unique_ptr<Json::CharReader> getJsonReader()
+    {
+        auto builder = Json::CharReaderBuilder();
+        Json::CharReaderBuilder::strictMode(&builder.settings_);
+        std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
+        return reader;
+    }
 }

src/signalrclient/json_helpers.h

@@ -4,13 +4,17 @@
 #pragma once
 
 #include "signalrclient/signalr_value.h"
-#include <cpprest/json.h>
+#include <json/json.h>
+#include <memory>
 
 namespace signalr
 {
     static constexpr char record_separator = '\x1e';
 
-    signalr::value createValue(const web::json::value& v);
+    signalr::value createValue(const Json::Value& v);
 
-    web::json::value createJson(const signalr::value& v);
+    Json::Value createJson(const signalr::value& v);
+
+    Json::StreamWriterBuilder getJsonWriter();
+    std::unique_ptr<Json::CharReader> getJsonReader();
 }

src/signalrclient/json_hub_protocol.cpp

@@ -6,12 +6,13 @@
 #include "message_type.h"
 #include "json_helpers.h"
 #include "signalrclient/signalr_exception.h"
+#include "json/json.h"
 
 namespace signalr
 {
     std::string signalr::json_hub_protocol::write_message(const signalr::value& hub_message) const
     {
-        return utility::conversions::to_utf8string(createJson(hub_message).serialize()) + record_separator;
+        return Json::writeString(getJsonWriter(), createJson(hub_message)) + record_separator;
     }
 
     std::vector<signalr::value> json_hub_protocol::parse_messages(const std::string& message) const
@@ -34,8 +35,16 @@ namespace signalr
 
     signalr::value json_hub_protocol::parse_message(const std::string& message) const
     {
-        auto result = web::json::value::parse(utility::conversions::to_string_t(message));
-        auto value = createValue(result);
+        Json::Value root;
+        auto reader = getJsonReader();
+        std::string errors;
+
+        if (!reader->parse(message.c_str(), message.c_str() + message.size(), &root, &errors))
+        {
+            throw signalr_exception(errors);
+        }
+
+        auto value = createValue(root);
 
         if (!value.is_map())
         {

src/signalrclient/negotiate.cpp

@@ -5,6 +5,7 @@
 #include "negotiate.h"
 #include "url_builder.h"
 #include "signalrclient/signalr_exception.h"
+#include "json_helpers.h"
 
 namespace signalr
 {
@@ -54,65 +55,72 @@ namespace signalr
 
                 try
                 {
-                    auto negotiation_response_json = web::json::value::parse(utility::conversions::to_string_t(http_response.content));
+                    Json::Value negotiation_response_json;
+                    auto reader = getJsonReader();
+                    std::string errors;
+
+                    if (!reader->parse(http_response.content.c_str(), http_response.content.c_str() + http_response.content.size(), &negotiation_response_json, &errors))
+                    {
+                        throw signalr_exception(errors);
+                    }
 
                     negotiation_response response;
 
-                    if (negotiation_response_json.has_field(_XPLATSTR("error")))
+                    if (negotiation_response_json.isMember("error"))
                     {
-                        response.error = utility::conversions::to_utf8string(negotiation_response_json[_XPLATSTR("error")].as_string());
+                        response.error = negotiation_response_json["error"].asString();
                         callback(std::move(response), nullptr);
                         return;
                     }
 
                     int server_negotiate_version = 0;
-                    if (negotiation_response_json.has_field(_XPLATSTR("negotiateVersion")))
+                    if (negotiation_response_json.isMember("negotiateVersion"))
                     {
-                        server_negotiate_version = negotiation_response_json[_XPLATSTR("negotiateVersion")].as_integer();
+                        server_negotiate_version = negotiation_response_json["negotiateVersion"].asInt();
                     }
 
-                    if (negotiation_response_json.has_field(_XPLATSTR("connectionId")))
+                    if (negotiation_response_json.isMember("connectionId"))
                     {
-                        response.connectionId = utility::conversions::to_utf8string(negotiation_response_json[_XPLATSTR("connectionId")].as_string());
+                        response.connectionId = negotiation_response_json["connectionId"].asString();
                     }
 
-                    if (negotiation_response_json.has_field(_XPLATSTR("connectionToken")))
+                    if (negotiation_response_json.isMember("connectionToken"))
                     {
-                        response.connectionToken = utility::conversions::to_utf8string(negotiation_response_json[_XPLATSTR("connectionToken")].as_string());
+                        response.connectionToken = negotiation_response_json["connectionToken"].asString();
                     }
 
                     if (server_negotiate_version <= 0)
                     {
                         response.connectionToken = response.connectionId;
                     }
 
-                    if (negotiation_response_json.has_field(_XPLATSTR("availableTransports")))
+                    if (negotiation_response_json.isMember("availableTransports"))
                     {
-                        for (auto transportData : negotiation_response_json[_XPLATSTR("availableTransports")].as_array())
+                        for (const auto& transportData : negotiation_response_json["availableTransports"])
                         {
                             available_transport transport;
-                            transport.transport = utility::conversions::to_utf8string(transportData[_XPLATSTR("transport")].as_string());
+                            transport.transport = transportData["transport"].asString();
 
-                            for (auto format : transportData[_XPLATSTR("transferFormats")].as_array())
+                            for (const auto& format : transportData["transferFormats"])
                             {
-                                transport.transfer_formats.push_back(utility::conversions::to_utf8string(format.as_string()));
+                                transport.transfer_formats.push_back(format.asString());
                             }
 
                             response.availableTransports.push_back(transport);
                         }
                     }
 
-                    if (negotiation_response_json.has_field(_XPLATSTR("url")))
+                    if (negotiation_response_json.isMember("url"))
                     {
-                        response.url = utility::conversions::to_utf8string(negotiation_response_json[_XPLATSTR("url")].as_string());
+                        response.url = negotiation_response_json["url"].asString();
 
-                        if (negotiation_response_json.has_field(_XPLATSTR("accessToken")))
+                        if (negotiation_response_json.isMember("accessToken"))
                         {
-                            response.accessToken = utility::conversions::to_utf8string(negotiation_response_json[_XPLATSTR("accessToken")].as_string());
+                            response.accessToken = negotiation_response_json["accessToken"].asString();
                         }
                     }
 
-                    if (negotiation_response_json.has_field(_XPLATSTR("ProtocolVersion")))
+                    if (negotiation_response_json.isMember("ProtocolVersion"))
                     {
                         callback({}, std::make_exception_ptr(
                             signalr_exception("Detected a connection attempt to an ASP.NET SignalR Server. This client only supports connecting to an ASP.NET Core SignalR Server. See https://aka.ms/signalr-core-differences for details.")));

test/signalrclienttests/connection_impl_tests.cpp

@@ -554,10 +554,7 @@ TEST(connection_impl_start, start_fails_if_negotiate_response_is_invalid)
         mre.get();
         ASSERT_TRUE(false); // exception not thrown
     }
-    catch (const std::exception & e)
-    {
-        ASSERT_STREQ("* Line 1, Column 28 Syntax error: Malformed token", e.what());
-    }
+    catch (const std::runtime_error&) { }
 }
 
 TEST(connection_impl_start, negotiate_follows_redirect)