wip

Author: BrennanConroy

include/signalrclient/http_client.h

@@ -13,48 +13,46 @@
 
 namespace signalr
 {
-    enum class http_method
-    {
-        GET,
-        POST
-    };
-
     class http_request final
     {
     public:
-        http_method get_method() const;
+        enum class method
+        {
+            GET,
+            POST
+        };
+
+        method get_method() const noexcept;
 
-        const std::map<std::string, std::string>& get_headers() const;
+        const std::map<std::string, std::string>& get_headers() const noexcept;
 
-        const std::string& get_content() const;
+        const std::string& get_content() const noexcept;
 
-        std::chrono::seconds get_timeout() const;
+        std::chrono::seconds get_timeout() const noexcept;
     private:
         friend class negotiate;
 
-        http_method m_method;
+        method m_method;
         std::map<std::string, std::string> m_headers;
         std::string m_content;
         std::chrono::seconds m_timeout;
 
         http_request()
-            : m_method(http_method::GET), m_timeout(std::chrono::seconds(120))
+            : m_method(method::GET), m_timeout(std::chrono::seconds(120))
         { }
 
-        void set_timeout(std::chrono::seconds timeout);
-        void set_content(const std::string& body);
-        void set_content(std::string&& body);
-        void set_headers(const std::map<std::string, std::string>& headers);
-        void set_method(http_method method);
+        void set_timeout(std::chrono::seconds timeout) noexcept;
+        void set_content(std::string body) noexcept;
+        void set_headers(std::map<std::string, std::string> headers) noexcept;
+        void set_method(method method) noexcept;
     };
 
     class http_response final
     {
     public:
         http_response() {}
         http_response(http_response&& rhs) noexcept : m_status_code(rhs.m_status_code), m_content(std::move(rhs.m_content)) {}
-        http_response(int code, const std::string& content) : m_status_code(code), m_content(content) {}
-        http_response(int code, std::string&& content) : m_status_code(code), m_content(std::move(content)) {}
+        http_response(int code, std::string content) : m_status_code(code), m_content(std::move(content)) {}
         http_response(const http_response& rhs) : m_status_code(rhs.m_status_code), m_content(rhs.m_content) {}
 
         http_response& operator=(const http_response& rhs)
@@ -76,8 +74,8 @@ namespace signalr
     private:
         friend class negotiate;
 
-        int get_status_code() const;
-        const std::string& get_content() const;
+        int get_status_code() const noexcept;
+        const std::string& get_content() const noexcept;
 
         int m_status_code = 0;
         std::string m_content;
@@ -86,7 +84,7 @@ namespace signalr
     class http_client
     {
     public:
-        virtual void send(const std::string& url, http_request& request,
+        virtual void send(const std::string& url, const http_request& request,
             std::function<void(const http_response&, std::exception_ptr)> callback, cancellation_token token) = 0;
 
         virtual ~http_client() {}

include/signalrclient/signalr_value.h

@@ -33,79 +33,54 @@ namespace signalr
         };
 
         /**
-         * Create an object representing a value_type::null value.
+         * Create an object representing a value::type::null value.
          */
         SIGNALRCLIENT_API value();
 
         /**
-         * Create an object representing a value_type::null value.
+         * Create an object representing a value::type::null value.
          */
         SIGNALRCLIENT_API value(std::nullptr_t);
 
         /**
-         * Create an object representing a default value for the given value_type.
+         * Create an object representing a default value for the given value::type.
          */
         SIGNALRCLIENT_API value(type t);
 
         /**
-         * Create an object representing a value_type::boolean with the given bool value.
+         * Create an object representing a value::type::boolean with the given bool value.
          */
         SIGNALRCLIENT_API value(bool val);
 
         /**
-         * Create an object representing a value_type::float64 with the given double value.
+         * Create an object representing a value::type::float64 with the given double value.
          */
         SIGNALRCLIENT_API value(double val);
 
         /**
-         * Create an object representing a value_type::string with the given string value.
+         * Create an object representing a value::type::string with the given string value.
          */
-        SIGNALRCLIENT_API value(const std::string& val);
+        SIGNALRCLIENT_API value(std::string val);
 
         /**
-         * Create an object representing a value_type::string with the given string value.
-         */
-        SIGNALRCLIENT_API value(std::string&& val);
-
-        /**
-         * Create an object representing a value_type::string with the given string value.
+         * Create an object representing a value::type::string with the given string value.
          */
         SIGNALRCLIENT_API value(const char* val);
 
         /**
-         * Create an object representing a value_type::string with the given string value.
-         */
-        SIGNALRCLIENT_API value(const char* val, size_t length);
-
-        /**
-         * Create an object representing a value_type::array with the given vector of value's.
-         */
-        SIGNALRCLIENT_API value(const std::vector<value>& val);
-
-        /**
-         * Create an object representing a value_type::array with the given vector of value's.
-         */
-        SIGNALRCLIENT_API value(std::vector<value>&& val);
-
-        /**
-         * Create an object representing a value_type::map with the given map of string-value's.
-         */
-        SIGNALRCLIENT_API value(const std::map<std::string, value>& map);
-
-        /**
-         * Create an object representing a value_type::map with the given map of string-value's.
+         * Create an object representing a value::type::array with the given vector of value's.
          */
-        SIGNALRCLIENT_API value(std::map<std::string, value>&& map);
+        SIGNALRCLIENT_API value(std::vector<value> val);
 
         /**
-         * Create an object representing a value_type::binary with the given array of byte's.
+         * Create an object representing a value::type::map with the given map of string-value's.
          */
-        SIGNALRCLIENT_API value(const std::vector<uint8_t>& bin);
+        SIGNALRCLIENT_API value(std::map<std::string, value> map);
 
         /**
-         * Create an object representing a value_type::binary with the given array of byte's.
+         * Create an object representing a value::type::binary with the given array of byte's.
          */
-        SIGNALRCLIENT_API value(std::vector<uint8_t>&& bin);
+        SIGNALRCLIENT_API value(std::vector<uint8_t> bin);
 
         /**
          * Copies an existing value.
@@ -120,7 +95,7 @@ namespace signalr
         /**
          * Cleans up the resources associated with the value.
          */
-        SIGNALRCLIENT_API ~value();
+        SIGNALRCLIENT_API ~value() noexcept;
 
         /**
          * Copies an existing value.
@@ -135,70 +110,70 @@ namespace signalr
         /**
          * True if the object stored is a Key-Value pair.
          */
-        SIGNALRCLIENT_API bool is_map() const;
+        SIGNALRCLIENT_API bool is_map() const noexcept;
 
         /**
          * True if the object stored is a double.
          */
-        SIGNALRCLIENT_API bool is_double() const;
+        SIGNALRCLIENT_API bool is_double() const noexcept;
 
         /**
          * True if the object stored is a string.
          */
-        SIGNALRCLIENT_API bool is_string() const;
+        SIGNALRCLIENT_API bool is_string() const noexcept;
 
         /**
          * True if the object stored is empty.
          */
-        SIGNALRCLIENT_API bool is_null() const;
+        SIGNALRCLIENT_API bool is_null() const noexcept;
 
         /**
          * True if the object stored is an array of signalr::value's.
          */
-        SIGNALRCLIENT_API bool is_array() const;
+        SIGNALRCLIENT_API bool is_array() const noexcept;
 
         /**
          * True if the object stored is a bool.
          */
-        SIGNALRCLIENT_API bool is_bool() const;
+        SIGNALRCLIENT_API bool is_bool() const noexcept;
 
         /**
          * True if the object stored is a binary blob.
          */
-        SIGNALRCLIENT_API bool is_binary() const;
+        SIGNALRCLIENT_API bool is_binary() const noexcept;
 
         /**
-         * Returns the stored object as a double. This will throw if the underlying object is not a signalr::type::float64.
+         * Returns the stored object as a double. This will throw if the underlying object is not a signalr::value::type::float64.
          */
         SIGNALRCLIENT_API double as_double() const;
 
         /**
-         * Returns the stored object as a bool. This will throw if the underlying object is not a signalr::type::boolean.
+         * Returns the stored object as a bool. This will throw if the underlying object is not a signalr::value::type::boolean.
          */
         SIGNALRCLIENT_API bool as_bool() const;
 
         /**
-         * Returns the stored object as a string. This will throw if the underlying object is not a signalr::type::string.
+         * Returns the stored object as a string. This will throw if the underlying object is not a signalr::value::type::string.
          */
         SIGNALRCLIENT_API const std::string& as_string() const;
 
         /**
-         * Returns the stored object as an array of signalr::value's. This will throw if the underlying object is not a signalr::type::array.
+         * Returns the stored object as an array of signalr::value's. This will throw if the underlying object is not a signalr::value::type::array.
          */
         SIGNALRCLIENT_API const std::vector<value>& as_array() const;
 
         /**
-         * Returns the stored object as a map of property name to signalr::value. This will throw if the underlying object is not a signalr::type::map.
+         * Returns the stored object as a map of property name to signalr::value. This will throw if the underlying object is not a signalr::value::type::map.
          */
         SIGNALRCLIENT_API const std::map<std::string, value>& as_map() const;
 
         /**
-         * Returns the stored object as an array of bytes. This will throw if the underlying object is not a signalr::type::binary.
+         * Returns the stored object as an array of bytes. This will throw if the underlying object is not a signalr::value::type::binary.
          */
         SIGNALRCLIENT_API const std::vector<uint8_t>& as_binary() const;
 
         /**
-         * Returns the signalr::type that represents the stored object.
+         * Returns the signalr::value::type that represents the stored object.
          */
         SIGNALRCLIENT_API type type() const;
 
@@ -216,7 +191,7 @@ namespace signalr
 
             // constructor of types in union are not implicitly called
             // this is expected as we only construct a single type in the union once we know
-            // what that type is when constructing the signalr_value type.
+            // what that type is when constructing the signalr::value type.
 #pragma warning (push)
 #pragma warning (disable: 4582)
             storage() {}

src/signalrclient/connection_impl.cpp

@@ -304,8 +304,8 @@ namespace signalr
         }
 
         auto http_client = m_http_client_factory(m_signalr_client_config);
-        std::shared_ptr<signalr::http_client> s(std::move(http_client));
-        start_negotiate_internal(url, 0, transport_started, std::move(s));
+        std::shared_ptr<signalr::http_client> shared_client(std::move(http_client));
+        start_negotiate_internal(url, 0, transport_started, std::move(shared_client));
     }
 
     void connection_impl::start_negotiate_internal(const std::string& url, int redirect_count,

src/signalrclient/default_http_client.cpp

@@ -18,15 +18,15 @@ namespace signalr
        : m_config(config) 
     { }
 
-    void default_http_client::send(const std::string& url, http_request& request,
+    void default_http_client::send(const std::string& url, const http_request& request,
         std::function<void(const http_response&, std::exception_ptr)> callback, cancellation_token token)
     {
         web::http::method method;
-        if (request.get_method() == http_method::GET)
+        if (request.get_method() == http_request::method::GET)
         {
             method = U("GET");
         }
-        else if (request.get_method() == http_method::POST)
+        else if (request.get_method() == http_request::method::POST)
         {
             method = U("POST");
         }

src/signalrclient/default_http_client.h

@@ -14,7 +14,7 @@ namespace signalr
     public:
        explicit default_http_client(const signalr_client_config& config = {}) noexcept;
 
-        void send(const std::string& url, http_request& request,
+        void send(const std::string& url, const http_request& request,
             std::function<void(const http_response&, std::exception_ptr)> callback, cancellation_token token) override;
 
     private:

src/signalrclient/handshake_protocol.cpp

@@ -13,9 +13,10 @@ namespace signalr
     {
         std::string write_handshake(const std::unique_ptr<hub_protocol>& protocol)
         {
+            auto protocol_value = signalr::value(protocol->name());
             auto map = std::map<std::string, signalr::value>
             {
-                { "protocol", signalr::value(protocol->name()) },
+                { "protocol", std::move(protocol_value) },
                 { "version", signalr::value((double)protocol->version()) }
             };