Refactor the protocol and handshake (#14)

Author: BrennanConroy

include/signalrclient/signalr_value.h

@@ -58,6 +58,11 @@ namespace signalr
          */
         value(std::string&& val);
 
+        /**
+         * Create an object representing a value_type::string with the given string value.
+         */
+        value(const char* val);
+
         /**
          * Create an object representing a value_type::array with the given vector of value's.
          */

src/signalrclient/CMakeLists.txt

@@ -4,8 +4,11 @@ set (SOURCES
   connection_impl.cpp
   default_http_client.cpp
   default_websocket_client.cpp
+  handshake_protocol.cpp
   hub_connection.cpp
   hub_connection_impl.cpp
+  json_helpers.cpp
+  json_hub_protocol.cpp
   logger.cpp
   negotiate.cpp
   signalr_client_config.cpp

src/signalrclient/connection_impl.cpp

@@ -283,7 +283,7 @@ namespace signalr
         auto transport = connection->m_transport_factory->create_transport(
             transport_type::websockets, connection->m_logger, connection->m_signalr_client_config);
 
-        transport->on_receive([disconnect_cts, connect_request_done, connect_request_lock, logger, weak_connection, callback](const std::string& message, std::exception_ptr exception)
+        transport->on_receive([disconnect_cts, connect_request_done, connect_request_lock, logger, weak_connection, callback](std::string&& message, std::exception_ptr exception)
             {
                 if (exception == nullptr)
                 {
@@ -298,7 +298,7 @@ namespace signalr
                     auto connection = weak_connection.lock();
                     if (connection)
                     {
-                        connection->process_response(message);
+                        connection->process_response(std::move(message));
                     }
                 }
                 else
@@ -433,19 +433,19 @@ namespace signalr
             });
     }
 
-    void connection_impl::process_response(const std::string& response)
+    void connection_impl::process_response(std::string&& response)
     {
         m_logger.log(trace_level::messages,
             std::string("processing message: ").append(response));
 
-        invoke_message_received(response);
+        invoke_message_received(std::move(response));
     }
 
-    void connection_impl::invoke_message_received(const std::string& message)
+    void connection_impl::invoke_message_received(std::string&& message)
     {
         try
         {
-            m_message_received(message);
+            m_message_received(std::move(message));
         }
         catch (const std::exception &e)
         {
@@ -618,7 +618,7 @@ namespace signalr
         return m_connection_id;
     }
 
-    void connection_impl::set_message_received(const std::function<void(const std::string&)>& message_received)
+    void connection_impl::set_message_received(const std::function<void(std::string&&)>& message_received)
     {
         ensure_disconnected("cannot set the callback when the connection is not in the disconnected state. ");
         m_message_received = message_received;

src/signalrclient/connection_impl.h

@@ -42,7 +42,7 @@ namespace signalr
         connection_state get_connection_state() const noexcept;
         std::string get_connection_id() const noexcept;
 
-        void set_message_received(const std::function<void(const std::string&)>& message_received);
+        void set_message_received(const std::function<void(std::string&&)>& message_received);
         void set_disconnected(const std::function<void()>& disconnected);
         void set_client_config(const signalr_client_config& config);
 
@@ -53,7 +53,7 @@ namespace signalr
         std::shared_ptr<transport> m_transport;
         std::unique_ptr<transport_factory> m_transport_factory;
 
-        std::function<void(const std::string&)> m_message_received;
+        std::function<void(std::string&&)> m_message_received;
         std::function<void()> m_disconnected;
         signalr_client_config m_signalr_client_config;
 
@@ -72,14 +72,14 @@ namespace signalr
             const std::string& url, std::function<void(std::exception_ptr)> callback);
         void start_negotiate(const std::string& url, int redirect_count, std::function<void(std::exception_ptr)> callback);
 
-        void process_response(const std::string& response);
+        void process_response(std::string&& response);
 
         void shutdown(std::function<void(std::exception_ptr)> callback);
 
         bool change_state(connection_state old_state, connection_state new_state);
         connection_state change_state(connection_state new_state);
         void handle_connection_state_change(connection_state old_state, connection_state new_state);
-        void invoke_message_received(const std::string& message);
+        void invoke_message_received(std::string&& message);
 
         static std::string translate_connection_state(connection_state state);
         void ensure_disconnected(const std::string& error_message) const;

src/signalrclient/handshake_protocol.cpp

@@ -0,0 +1,36 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#include "stdafx.h"
+#include "handshake_protocol.h"
+#include "json_helpers.h"
+#include "signalrclient/signalr_exception.h"
+
+namespace signalr
+{
+    namespace handshake
+    {
+        std::string write_handshake(std::shared_ptr<hub_protocol>& protocol)
+        {
+            auto map = std::map<std::string, signalr::value>
+            {
+                { "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;
+        }
+
+        std::tuple<std::string, signalr::value> parse_handshake(const std::string& response)
+        {
+            auto pos = response.find(record_separator);
+            if (pos == std::string::npos)
+            {
+                throw signalr_exception("incomplete message received");
+            }
+            auto message = response.substr(0, pos);
+            auto result = web::json::value::parse(utility::conversions::to_string_t(message));
+            auto remaining_data = response.substr(pos + 1);
+            return std::forward_as_tuple(remaining_data, createValue(result));
+        }
+    }
+}

src/signalrclient/handshake_protocol.h

@@ -0,0 +1,17 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#pragma once
+
+#include "signalrclient/signalr_value.h"
+#include "hub_protocol.h"
+#include <memory>
+
+namespace signalr
+{
+    namespace handshake
+    {
+        std::string write_handshake(std::shared_ptr<hub_protocol>&);
+        std::tuple<std::string, signalr::value> parse_handshake(const std::string&);
+    }
+}