seems like dump msvc does not handle ipp+enable_if+enum. yay, come one, it is 2017 dude.

Author: Simon Ninon

includes/cpp_redis/impl/redis_client.ipp

@@ -105,13 +105,6 @@ class redis_client {
   redis_client& blpop(const std::vector<std::string>& keys, int timeout, const reply_callback_t& reply_callback = nullptr);
   redis_client& brpop(const std::vector<std::string>& keys, int timeout, const reply_callback_t& reply_callback = nullptr);
   redis_client& brpoplpush(const std::string& src, const std::string& dst, int timeout, const reply_callback_t& reply_callback = nullptr);
-  template <typename T, typename... Ts>
-  redis_client& client_kill(const std::string& host, int port, const T& arg, const Ts&... args);
-  redis_client& client_kill(const std::string& host, int port);
-  template <typename... Ts>
-  redis_client& client_kill(const char* host, int port, const Ts&... args);
-  template <typename T, typename... Ts>
-  redis_client& client_kill(const T&, const Ts&...);
   redis_client& client_list(const reply_callback_t& reply_callback = nullptr);
   redis_client& client_getname(const reply_callback_t& reply_callback = nullptr);
   redis_client& client_pause(int timeout, const reply_callback_t& reply_callback = nullptr);
@@ -319,31 +312,101 @@ class redis_client {
   // redis_client& hscan(const reply_callback_t& reply_callback = nullptr) key cursor [match pattern] [count count]
   // redis_client& zscan(const reply_callback_t& reply_callback = nullptr) key cursor [match pattern] [count count]
 
+public:
+  //! client kill
+  template <typename T, typename... Ts>
+  inline redis_client&
+  client_kill(const T& arg, const Ts&... args) {
+    static_assert(helpers::is_different_types<T, Ts...>::value, "Should only have one distinct value per filter type");
+    static_assert(!(std::is_class<T>::value && std::is_same<T, typename helpers::back<T, Ts...>::type>::value), "Should have at least one filter");
+
+    std::vector<std::string> redis_cmd({"CLIENT", "KILL"});
+    reply_callback_t reply_cb = nullptr;
+    client_kill_impl<T, Ts...>(redis_cmd, reply_cb, arg, args...);
+
+    return send(redis_cmd, reply_cb);
+  }
+
+  template <typename T, typename... Ts>
+  inline redis_client&
+  client_kill(const std::string& host, int port, const T& arg, const Ts&... args) {
+    static_assert(helpers::is_different_types<T, Ts...>::value, "Should only have one distinct value per filter type");
+    std::vector<std::string> redis_cmd({"CLIENT", "KILL"});
+
+    //! If we have other type than lambda, then it's a filter
+    if (!std::is_class<T>::value) {
+      redis_cmd.emplace_back("ADDR");
+    }
+
+    redis_cmd.emplace_back(host + ":" + std::to_string(port));
+    reply_callback_t reply_cb = nullptr;
+    client_kill_impl<T, Ts...>(redis_cmd, reply_cb, arg, args...);
+
+    return send(redis_cmd, reply_cb);
+  }
+
+  inline redis_client&
+  client_kill(const std::string& host, int port) {
+    return client_kill(host, port, reply_callback_t(nullptr));
+  }
+
+  template <typename... Ts>
+  inline redis_client&
+  client_kill(const char* host, int port, const Ts&... args) {
+    return client_kill(std::string(host), port, args...);
+  }
+
 private:
-  //! client kill impl
+  //! client kill internal impl
   template <typename T>
   typename std::enable_if<std::is_same<T, enum type>::value>::type
-  client_kill_unpack_arg(std::vector<std::string>& redis_cmd, reply_callback_t&, enum type type);
+  client_kill_unpack_arg(std::vector<std::string>& redis_cmd, reply_callback_t&, enum type type) {
+    redis_cmd.emplace_back("TYPE");
+    std::string type_string;
+
+    switch (type) {
+    case type::normal: type_string = "normal"; break;
+    case type::master: type_string = "master"; break;
+    case type::pubsub: type_string = "pubsub"; break;
+    case type::slave: type_string = "slave"; break;
+    }
+
+    redis_cmd.emplace_back(type_string);
+  }
 
   template <typename T>
   typename std::enable_if<std::is_same<T, bool>::value>::type
-  client_kill_unpack_arg(std::vector<std::string>& redis_cmd, reply_callback_t&, bool skip);
+  client_kill_unpack_arg(std::vector<std::string>& redis_cmd, reply_callback_t&, bool skip) {
+    redis_cmd.emplace_back("SKIPME");
+    redis_cmd.emplace_back(skip ? "yes" : "no");
+  }
 
   template <typename T>
   typename std::enable_if<std::is_integral<T>::value>::type
-  client_kill_unpack_arg(std::vector<std::string>& redis_cmd, reply_callback_t&, uint64_t id);
+  client_kill_unpack_arg(std::vector<std::string>& redis_cmd, reply_callback_t&, uint64_t id) {
+    redis_cmd.emplace_back("ID");
+    redis_cmd.emplace_back(std::to_string(id));
+  }
 
   template <typename T>
   typename std::enable_if<std::is_class<T>::value>::type
-  client_kill_unpack_arg(std::vector<std::string>&, reply_callback_t& reply_callback, const T& cb);
+  client_kill_unpack_arg(std::vector<std::string>&, reply_callback_t& reply_callback, const T& cb) {
+    reply_callback = cb;
+  }
 
   template <typename T, typename... Ts>
   void
-  client_kill_impl(std::vector<std::string>& redis_cmd, reply_callback_t& reply, const T& arg, const Ts&... args);
+  client_kill_impl(std::vector<std::string>& redis_cmd, reply_callback_t& reply, const T& arg, const Ts&... args) {
+    static_assert(!std::is_class<T>::value, "Reply callback should be in the end of the argument list");
+    client_kill_unpack_arg<T>(redis_cmd, reply, arg);
+    client_kill_impl(redis_cmd, reply, args...);
+  };
 
   template <typename T>
   void
-  client_kill_impl(std::vector<std::string>& redis_cmd, reply_callback_t& reply, const T& arg);
+  client_kill_impl(std::vector<std::string>& redis_cmd, reply_callback_t& reply, const T& arg) {
+    client_kill_unpack_arg<T>(redis_cmd, reply, arg);
+  };
 
 private:
   //! receive & disconnection handlers
@@ -376,5 +439,3 @@ class redis_client {
 };
 
 } // namespace cpp_redis
-
-#include <cpp_redis/impl/redis_client.ipp>