templates

include/signalrclient/converters.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include "signalr_value.h"
+#include <stdexcept>
+
+namespace signalr
+{
+    template <typename T>
+    class is_map
+    {
+    public:
+        static const bool value = false;
+    };
+
+    template <typename T>
+    class is_map<std::map<std::string, T>>
+    {
+    public:
+        static const bool value = true;
+    };
+
+    template <typename T>
+    class is_vector
+    {
+    public:
+        static const bool value = false;
+    };
+
+    template <typename T>
+    class is_vector<std::vector<T>>
+    {
+    public:
+        static const bool value = true;
+    };
+
+    template <typename T, std::enable_if_t<!is_map<std::enable_if_t<!is_vector<T>::value, T>>::value, int> = 0>
+    T convert_value(const signalr::value& value)
+    {
+        static_assert(false, "type conversion not defined");
+        throw std::runtime_error("failed");
+    }
+
+    template <>
+    inline int convert_value<int>(const signalr::value& value)
+    {
+        if (value.is_double())
+        {
+            return (int)value.as_double();
+        }
+        throw std::runtime_error("not type");
+    }
+
+    template <>
+    inline std::string convert_value<std::string>(const signalr::value& value)
+    {
+        if (value.is_string())
+        {
+            return value.as_string();
+        }
+        throw std::runtime_error("not type");
+    }
+
+    template <typename T>
+    typename std::enable_if_t<is_map<T>::value, T> convert_value(const signalr::value& value)
+    {
+        if (value.is_map())
+        {
+            T map{};
+            for (auto& v : value.as_map())
+            {
+                map.insert(std::make_pair(v.first, convert_value<typename T::mapped_type>(v.second)));
+            }
+            return map;
+        }
+        throw std::runtime_error("not type");
+    }
+
+    template <typename T>
+    typename std::enable_if_t<is_vector<T>::value, T> convert_value(const signalr::value& value)
+    {
+        if (value.is_array())
+        {
+            T vec{};
+            for (auto& v : value.as_array())
+            {
+                vec.push_back(convert_value<typename T::value_type>(v));
+            }
+            return vec;
+        }
+        throw std::runtime_error("not type");
+    }
+}

include/signalrclient/hub_connection.h

@@ -12,6 +12,7 @@
 #include "log_writer.h"
 #include "signalr_client_config.h"
 #include "signalr_value.h"
+#include "converters.h"
 
 namespace signalr
 {
@@ -21,6 +22,24 @@ namespace signalr
     class hub_connection_builder;
     class hub_protocol;
 
+    /*template <typename T, int = 0>
+    T convert_value(const signalr::value& value);*/
+
+    /*template <typename T, std::enable_if_t<!is_map<std::enable_if_t<!is_vector<T>::value, T>>::value, int> = 0>
+    T convert_value(const signalr::value& value);
+
+    template <>
+    int convert_value<int>(const signalr::value& value);
+
+    template <>
+    std::string convert_value<std::string>(const signalr::value& value);
+
+    template <typename T>
+    typename std::enable_if_t<is_map<T>::value, T> convert_value(const signalr::value& value);
+
+    template <typename T>
+    typename std::enable_if_t<is_vector<T>::value, T> convert_value(const signalr::value& value);*/
+
     class hub_connection
     {
     public:
@@ -48,6 +67,18 @@ namespace signalr
 
         SIGNALRCLIENT_API void __cdecl on(const std::string& event_name, const method_invoked_handler& handler);
 
+        template <typename T>
+        SIGNALRCLIENT_API void on(const std::string& event_name, std::function<void(T)> handler)
+        {
+            return on(event_name, [handler](const std::vector<signalr::value>& args)
+                {
+                    handler(convert_value<T>(args[0]));
+                });
+        }
+
+        /*template <typename T>
+        SIGNALRCLIENT_API void on(const std::string& event_name, std::function<void (T)> handler);*/
+
         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 std::vector<signalr::value>& arguments = std::vector<signalr::value>(), std::function<void(std::exception_ptr)> callback = [](std::exception_ptr) {}) noexcept;
@@ -63,4 +94,4 @@ namespace signalr
 
         std::shared_ptr<hub_connection_impl> m_pImpl;
     };
-}
+}