Use std::vector for 'send' and 'on' to make it clear there can be multiple arguments/parameters (#65)

Author: BrennanConroy

README.md

@@ -77,9 +77,9 @@ Output will be in `build.release/bin/`
 std::promise<void> start_task;
 signalr::hub_connection connection = signalr::hub_connection_builder::create("http://localhost:5000/hub").build();
 
-connection.on("Echo", [](const signalr::value& m)
+connection.on("Echo", [](const std::vector<signalr::value>& m)
 {
-    std::cout << m.as_array()[0].as_string() << std::endl;
+    std::cout << m[0].as_string() << std::endl;
 });
 
 connection.start([&start_task](std::exception_ptr exception) {
@@ -89,9 +89,8 @@ connection.start([&start_task](std::exception_ptr exception) {
 start_task.get_future().get();
 
 std::promise<void> send_task;
-std::vector<signalr::value> arr { "Hello world" };
-signalr::value arg(arr);
-connection.invoke("Echo", arg, [&send_task](const signalr::value& value, std::exception_ptr exception) {
+std::vector<signalr::value> args { "Hello world" };
+connection.invoke("Echo", args, [&send_task](const signalr::value& value, std::exception_ptr exception) {
     send_task.set_value();
 });
 

include/signalrclient/hub_connection.h

@@ -24,7 +24,7 @@ namespace signalr
     class hub_connection
     {
     public:
-        typedef std::function<void __cdecl (const signalr::value&)> method_invoked_handler;
+        typedef std::function<void __cdecl (const std::vector<signalr::value>&)> method_invoked_handler;
 
         SIGNALRCLIENT_API ~hub_connection();
 
@@ -48,9 +48,9 @@ namespace signalr
 
         SIGNALRCLIENT_API void __cdecl on(const std::string& event_name, const method_invoked_handler& handler);
 
-        SIGNALRCLIENT_API void invoke(const std::string& method_name, const signalr::value& arguments = signalr::value(), std::function<void(const signalr::value&, std::exception_ptr)> callback = [](const signalr::value&, std::exception_ptr) {}) noexcept;
+        SIGNALRCLIENT_API void invoke(const std::string& method_name, const std::vector<signalr::value>& arguments = std::vector<signalr::value>(), std::function<void(const signalr::value&, std::exception_ptr)> callback = [](const signalr::value&, std::exception_ptr) {}) noexcept;
 
-        SIGNALRCLIENT_API void send(const std::string& method_name, const signalr::value& arguments = signalr::value(), std::function<void(std::exception_ptr)> callback = [](std::exception_ptr) {}) noexcept;
+        SIGNALRCLIENT_API void send(const std::string& method_name, const std::vector<signalr::value>& arguments = std::vector<signalr::value>(), std::function<void(std::exception_ptr)> callback = [](std::exception_ptr) {}) noexcept;
 
     private:
         friend class hub_connection_builder;

samples/HubConnectionSample/HubConnectionSample.cpp

@@ -20,8 +20,7 @@ class logger : public signalr::log_writer
 
 void send_message(signalr::hub_connection& connection, const std::string& message)
 {
-    std::vector<signalr::value> arr { std::string("c++"), message };
-    signalr::value args(arr);
+    std::vector<signalr::value> args { std::string("c++"), message };
 
     // if you get an internal compiler error uncomment the lambda below or install VS Update 4
     connection.invoke("Send", args, [](const signalr::value& value, std::exception_ptr exception)
@@ -55,9 +54,9 @@ void chat()
         .with_logging(std::make_shared <logger>(), signalr::trace_level::verbose)
         .build();
 
-    connection.on("Send", [](const signalr::value & m)
+    connection.on("Send", [](const std::vector<signalr::value>& m)
     {
-        std::cout << std::endl << m.as_array()[0].as_string() << std::endl << "Enter your message: ";
+        std::cout << std::endl << m[0].as_string() << std::endl << "Enter your message: ";
     });
 
     std::promise<void> task;

src/signalrclient/hub_connection.cpp

@@ -63,7 +63,7 @@ namespace signalr
         return m_pImpl->on(event_name, handler);
     }
 
-    void hub_connection::invoke(const std::string& method_name, const signalr::value& arguments, std::function<void(const signalr::value&, std::exception_ptr)> callback) noexcept
+    void hub_connection::invoke(const std::string& method_name, const std::vector<signalr::value>& arguments, std::function<void(const signalr::value&, std::exception_ptr)> callback) noexcept
     {
         if (!m_pImpl)
         {
@@ -74,7 +74,7 @@ namespace signalr
         return m_pImpl->invoke(method_name, arguments, callback);
     }
 
-    void hub_connection::send(const std::string& method_name, const signalr::value& arguments, std::function<void(std::exception_ptr)> callback) noexcept
+    void hub_connection::send(const std::string& method_name, const std::vector<signalr::value>& arguments, std::function<void(std::exception_ptr)> callback) noexcept
     {
         if (!m_pImpl)
         {

src/signalrclient/hub_connection_impl.cpp

@@ -85,7 +85,7 @@ namespace signalr
         });
     }
 
-    void hub_connection_impl::on(const std::string& event_name, const std::function<void(const signalr::value &)>& handler)
+    void hub_connection_impl::on(const std::string& event_name, const std::function<void(const std::vector<signalr::value>&)>& handler)
     {
         if (event_name.length() == 0)
         {
@@ -441,14 +441,8 @@ namespace signalr
         return true;
     }
 
-    void hub_connection_impl::invoke(const std::string& method_name, const signalr::value& arguments, std::function<void(const signalr::value&, std::exception_ptr)> callback) noexcept
+    void hub_connection_impl::invoke(const std::string& method_name, const std::vector<signalr::value>& arguments, std::function<void(const signalr::value&, std::exception_ptr)> callback) noexcept
     {
-        if (!arguments.is_array())
-        {
-            callback(signalr::value(), std::make_exception_ptr(signalr_exception("arguments should be an array")));
-            return;
-        }
-
         const auto& callback_id = m_callback_manager.register_callback(
             create_hub_invocation_callback(m_logger, [callback](const signalr::value& result) { callback(result, nullptr); },
                 [callback](const std::exception_ptr e) { callback(signalr::value(), e); }));
@@ -457,20 +451,14 @@ namespace signalr
             [callback](const std::exception_ptr e){ callback(signalr::value(), e); });
     }
 
-    void hub_connection_impl::send(const std::string& method_name, const signalr::value& arguments, std::function<void(std::exception_ptr)> callback) noexcept
+    void hub_connection_impl::send(const std::string& method_name, const std::vector<signalr::value>& arguments, std::function<void(std::exception_ptr)> callback) noexcept
     {
-        if (!arguments.is_array())
-        {
-            callback(std::make_exception_ptr(signalr_exception("arguments should be an array")));
-            return;
-        }
-
         invoke_hub_method(method_name, arguments, "",
             [callback]() { callback(nullptr); },
             [callback](const std::exception_ptr e){ callback(e); });
     }
 
-    void hub_connection_impl::invoke_hub_method(const std::string& method_name, const signalr::value& arguments,
+    void hub_connection_impl::invoke_hub_method(const std::string& method_name, const std::vector<signalr::value>& arguments,
         const std::string& callback_id, std::function<void()> set_completion, std::function<void(const std::exception_ptr)> set_exception) noexcept
     {
         try

src/signalrclient/hub_connection_impl.h

@@ -31,10 +31,10 @@ namespace signalr
         hub_connection_impl(const hub_connection_impl&) = delete;
         hub_connection_impl& operator=(const hub_connection_impl&) = delete;
 
-        void on(const std::string& event_name, const std::function<void(const signalr::value &)>& handler);
+        void on(const std::string& event_name, const std::function<void(const std::vector<signalr::value>&)>& handler);
 
-        void invoke(const std::string& method_name, const signalr::value& arguments, std::function<void(const signalr::value&, std::exception_ptr)> callback) noexcept;
-        void send(const std::string& method_name, const signalr::value& arguments, std::function<void(std::exception_ptr)> callback) noexcept;
+        void invoke(const std::string& method_name, const std::vector<signalr::value>& arguments, std::function<void(const signalr::value&, std::exception_ptr)> callback) noexcept;
+        void send(const std::string& method_name, const std::vector<signalr::value>& arguments, std::function<void(std::exception_ptr)> callback) noexcept;
 
         void start(std::function<void(std::exception_ptr)> callback) noexcept;
         void stop(std::function<void(std::exception_ptr)> callback) noexcept;
@@ -54,7 +54,7 @@ namespace signalr
         std::shared_ptr<connection_impl> m_connection;
         logger m_logger;
         callback_manager m_callback_manager;
-        std::unordered_map<std::string, std::function<void(const signalr::value&)>, case_insensitive_hash, case_insensitive_equals> m_subscriptions;
+        std::unordered_map<std::string, std::function<void(const std::vector<signalr::value>&)>, case_insensitive_hash, case_insensitive_equals> m_subscriptions;
         bool m_handshakeReceived;
         std::shared_ptr<completion_event> m_handshakeTask;
         std::function<void(std::exception_ptr)> m_disconnected;
@@ -69,7 +69,7 @@ namespace signalr
 
         void process_message(std::string&& message);
 
-        void invoke_hub_method(const std::string& method_name, const signalr::value& arguments, const std::string& callback_id,
+        void invoke_hub_method(const std::string& method_name, const std::vector<signalr::value>& arguments, const std::string& callback_id,
             std::function<void()> set_completion, std::function<void(const std::exception_ptr)> set_exception) noexcept;
         bool invoke_callback(completion_message* completion);
     };

src/signalrclient/hub_protocol.h

@@ -32,17 +32,17 @@ namespace signalr
     struct invocation_message : hub_invocation_message
     {
         invocation_message(const std::string& invocation_id, const std::string& target,
-            const signalr::value& args, const std::vector<std::string>& stream_ids = std::vector<std::string>())
+            const std::vector<signalr::value>& args, const std::vector<std::string>& stream_ids = std::vector<std::string>())
             : hub_invocation_message(invocation_id, signalr::message_type::invocation), target(target), arguments(args), stream_ids(stream_ids)
         { }
 
         invocation_message(std::string&& invocation_id, std::string&& target,
-            signalr::value&& args, std::vector<std::string>&& stream_ids = std::vector<std::string>())
+            std::vector<signalr::value>&& args, std::vector<std::string>&& stream_ids = std::vector<std::string>())
             : hub_invocation_message(invocation_id, signalr::message_type::invocation), target(target), arguments(args), stream_ids(stream_ids)
         { }
 
         std::string target;
-        signalr::value arguments;
+        std::vector<signalr::value> arguments;
         std::vector<std::string> stream_ids;
     };
 

src/signalrclient/messagepack_hub_protocol.cpp

@@ -210,8 +210,8 @@ namespace signalr
             packer.pack_str((uint32_t)invocation->target.length());
             packer.pack_str_body(invocation->target.data(), (uint32_t)invocation->target.length());
 
-            packer.pack_array((uint32_t)invocation->arguments.as_array().size());
-            for (auto& val : invocation->arguments.as_array())
+            packer.pack_array((uint32_t)invocation->arguments.size());
+            for (auto& val : invocation->arguments)
             {
                 pack_messagepack(val, packer);
             }
@@ -357,8 +357,17 @@ namespace signalr
                     throw signalr_exception("reading 'arguments' as array failed");
                 }
 
+                std::vector<signalr::value> args;
+                auto size = msgpack_obj_index->via.array.size;
+                auto arg_array_index = msgpack_obj_index->via.array.ptr;
+                for (uint32_t i = 0; i < size; ++i)
+                {
+                    args.emplace_back(createValue(*arg_array_index));
+                    ++arg_array_index;
+                }
+
                 vec.emplace_back(std::unique_ptr<hub_message>(
-                    new invocation_message(std::move(invocation_id), std::move(target), createValue(*msgpack_obj_index))));
+                    new invocation_message(std::move(invocation_id), std::move(target), std::move(args))));
 
                 if (num_elements_of_message > 5)
                 {