change the way to set disconnection handlers: remove the setter so that the handler can only be set when calling the connect() member functions. This remove the need of a mutex, increasing the performance and reducing code complexity. The same has been done for the receive handlers of internal classes, introducing possible better performance.

Author: Cylix

README.md

@@ -38,21 +38,20 @@ To build the tests, it is necessary to install `google_tests`. Just run the `ins
 
 ### Methods
 
-#### void connect(const std::string& host = "127.0.0.1", unsigned int port = 6379)
+#### void connect(const std::string& host = "127.0.0.1", unsigned int port = 6379, const disconnection_handler& handler = nullptr)
 Connect to the Redis Server. Connection is done synchronously.
 Throws redis_error in case of failure or if client if already connected.
 
+Also set the disconnection handler which is called whenever a disconnection has occurred.
+Disconnection handler is an `std::function<void(redis_client&)>`.
+
 #### void disconnect(void)
 Disconnect client from remote host.
 Throws redis_error if client is not connected to any server.
 
 #### bool is_connected(void)
 Returns whether the client is connected or not.
 
-#### void set_disconnection_handler(const disconnection_handler& handler)
-Set the disconnection handler which is called whenever a disconnection has occurred.
-Disconnection handler is an `std::function<void(redis_client&)>`.
-
 #### void send(const std::vector<std::string>& redis_cmd, const reply_callback& callback = nullptr)
 Send a command and set the callback which has to be called when the reply has been received.
 If `nullptr` is passed as callback, command is executed and no callback will be called.
@@ -78,13 +77,11 @@ sigint_handler(int) {
 
 int
 main(void) {
-  client.set_disconnection_handler([] (cpp_redis::redis_client&) {
+  client.connect("127.0.0.1", 6379, [] (cpp_redis::redis_client&) {
     std::cout << "client disconnected (disconnection handler)" << std::endl;
     should_exit = true;
   });
 
-  client.connect();
-
   client.send({"SET", "hello", "world"}, [] (cpp_redis::reply& reply) {
     std::cout << reply.as_string() << std::endl;
   });
@@ -103,21 +100,20 @@ main(void) {
 
 ### Methods
 
-#### void connect(const std::string& host = "127.0.0.1", unsigned int port = 6379)
+#### void connect(const std::string& host = "127.0.0.1", unsigned int port = 6379, const disconnection_handler& handler = nullptr)
 Connect to the Redis Server. Connection is done synchronously.
 Throws redis_error in case of failure or if client if already connected.
 
+Also set the disconnection handler which is called whenever a disconnection has occurred.
+Disconnection handler is an `std::function<void(redis_subscriber&)>`.
+
 #### void disconnect(void)
 Disconnect client from remote host.
 Throws redis_error if client is not connected to any server.
 
 #### bool is_connected(void)
 Returns whether the client is connected or not.
 
-#### void set_disconnection_handler(const disconnection_handler& handler)
-Set the disconnection handler which is called whenever a disconnection has occurred.
-Disconnection handler is an `std::function<void(redis_subscriber&)>`.
-
 #### void subscribe(const std::string& channel, const subscribe_callback& callback)
 Subscribe to the given channel and call subscribe_callback each time a message is published in this channel.
 subscribe_callback is an `std::function<void(const std::string&, const std::string&)>`.
@@ -145,31 +141,29 @@ cpp_redis::redis_subscriber sub;
 
 void
 sigint_handler(int) {
-    std::cout << "disconnected (sigint handler)" << std::endl;
-    sub.disconnect();
-    should_exit = true;
+  std::cout << "disconnected (sigint handler)" << std::endl;
+  sub.disconnect();
+  should_exit = true;
 }
 
 int
 main(void) {
-    sub.set_disconnection_handler([] (cpp_redis::redis_subscriber&) {
-        std::cout << "sub disconnected (disconnection handler)" << std::endl;
-        should_exit = true;
-    });
-
-    sub.connect();
+  sub.connect("127.0.0.1", 6379, [](cpp_redis::redis_subscriber&) {
+    std::cout << "sub disconnected (disconnection handler)" << std::endl;
+    should_exit = true;
+  });
 
-    sub.subscribe("some_chan", [] (const std::string& chan, const std::string& msg) {
-        std::cout << "MESSAGE " << chan << ": " << msg << std::endl;
-    });
-    sub.psubscribe("*", [] (const std::string& chan, const std::string& msg) {
-        std::cout << "PMESSAGE " << chan << ": " << msg << std::endl;
-    });
+  sub.subscribe("some_chan", [] (const std::string& chan, const std::string& msg) {
+    std::cout << "MESSAGE " << chan << ": " << msg << std::endl;
+  });
+  sub.psubscribe("*", [] (const std::string& chan, const std::string& msg) {
+    std::cout << "PMESSAGE " << chan << ": " << msg << std::endl;
+  });
 
-    signal(SIGINT, &sigint_handler);
-    while (not should_exit);
+  signal(SIGINT, &sigint_handler);
+  while (not should_exit);
 
-    return 0;
+  return 0;
 }
 ```
 

examples/redis_client.cpp

@@ -15,13 +15,11 @@ sigint_handler(int) {
 
 int
 main(void) {
-  client.set_disconnection_handler([] (cpp_redis::redis_client&) {
+  client.connect("127.0.0.1", 6379, [] (cpp_redis::redis_client&) {
     std::cout << "client disconnected (disconnection handler)" << std::endl;
     should_exit = true;
   });
 
-  client.connect();
-
   client.send({"SET", "hello", "world"}, [] (cpp_redis::reply& reply) {
     std::cout << reply.as_string() << std::endl;
   });

examples/redis_subscriber.cpp

@@ -15,13 +15,11 @@ sigint_handler(int) {
 
 int
 main(void) {
-  sub.set_disconnection_handler([] (cpp_redis::redis_subscriber&) {
+  sub.connect("127.0.0.1", 6379, [](cpp_redis::redis_subscriber&) {
     std::cout << "sub disconnected (disconnection handler)" << std::endl;
     should_exit = true;
   });
 
-  sub.connect();
-
   sub.subscribe("some_chan", [] (const std::string& chan, const std::string& msg) {
     std::cout << "MESSAGE " << chan << ": " << msg << std::endl;
   });

includes/cpp_redis/network/redis_connection.hpp

@@ -24,21 +24,17 @@ class redis_connection {
 
 public:
   //! handle connection
-  void connect(const std::string& host = "127.0.0.1", unsigned int port = 6379);
+  typedef std::function<void(redis_connection&)> disconnection_handler_t;
+  typedef std::function<void(redis_connection&, reply&)> reply_callback_t;
+  void connect(const std::string& host = "127.0.0.1", unsigned int port = 6379,
+               const disconnection_handler_t& disconnection_handler = nullptr,
+               const reply_callback_t& reply_callback = nullptr);
   void disconnect(void);
   bool is_connected(void);
 
-  //! disconnection handler
-  typedef std::function<void(redis_connection&)> disconnection_handler_t;
-  void set_disconnection_handler(const disconnection_handler_t& handler);
-
   //! send cmd
   void send(const std::vector<std::string>& redis_cmd);
 
-  //! receive handler
-  typedef std::function<void(redis_connection&, reply&)> reply_callback_t;
-  void set_reply_callback(const reply_callback_t& handler);
-
 private:
   //! receive & disconnection handlers
   bool tcp_client_receive_handler(network::tcp_client&, const std::vector<char>& buffer);
@@ -58,10 +54,6 @@ class redis_connection {
 
   //! reply builder
   builders::reply_builder m_builder;
-
-  //! thread safety
-  std::mutex m_disconnection_handler_mutex;
-  std::mutex m_reply_callback_mutex;
 };
 
 } //! network

includes/cpp_redis/network/tcp_client.hpp

@@ -30,24 +30,17 @@ class tcp_client {
   bool is_connected(void);
 
   //! handle connection & disconnection
-  void connect(const std::string& host, unsigned int port);
+  typedef std::function<void(tcp_client&)> disconnection_handler_t;
+  typedef std::function<bool(tcp_client&, const std::vector<char>& buffer)> receive_handler_t;
+  void connect(const std::string& host, unsigned int port,
+               const disconnection_handler_t& disconnection_handler = nullptr,
+               const receive_handler_t& receive_handler = nullptr);
   void disconnect(void);
 
   //! send data
   void send(const std::string& buffer);
   void send(const std::vector<char>& buffer);
 
-  //! set receive callback
-  //! called each time some data has been received
-  //! Returns true if everything is ok, false otherwise (trigger disconnection)
-  typedef std::function<bool(tcp_client&, const std::vector<char>& buffer)> receive_handler_t;
-  void set_receive_handler(const receive_handler_t& handler);
-
-  //! set disconnection callback
-  //! called each time a disconnection has been detected
-  typedef std::function<void(tcp_client&)> disconnection_handler_t;
-  void set_disconnection_handler(const disconnection_handler_t& handler);
-
 private:
   //! make boost asio async read and write operations
   void async_read(void);
@@ -77,8 +70,6 @@ class tcp_client {
 
   //! thread safety
   std::mutex m_write_buffer_mutex;
-  std::mutex m_receive_handler_mutex;
-  std::mutex m_disconnection_handler_mutex;
 };
 
 } //! network

includes/cpp_redis/redis_client.hpp

@@ -13,7 +13,7 @@ namespace cpp_redis {
 class redis_client {
 public:
   //! ctor & dtor
-  redis_client(void);
+  redis_client(void) = default;
   ~redis_client(void);
 
   //! copy ctor & assignment operator
@@ -22,14 +22,12 @@ class redis_client {
 
 public:
   //! handle connection
-  void connect(const std::string& host = "127.0.0.1", unsigned int port = 6379);
+  typedef std::function<void(redis_client&)> disconnection_handler_t;
+  void connect(const std::string& host = "127.0.0.1", unsigned int port = 6379,
+               const disconnection_handler_t& disconnection_handler = nullptr);
   void disconnect(void);
   bool is_connected(void);
 
-  //! disconnection handler
-  typedef std::function<void(redis_client&)> disconnection_handler_t;
-  void set_disconnection_handler(const disconnection_handler_t& handler);
-
   //! send cmd
   typedef std::function<void(reply&)> reply_callback_t;
   void send(const std::vector<std::string>& redis_cmd, const reply_callback_t& callback = nullptr);
@@ -53,7 +51,6 @@ class redis_client {
   disconnection_handler_t m_disconnection_handler;
 
   //! thread safety
-  std::mutex m_disconnection_handler_mutex;
   std::mutex m_callbacks_mutex;
 };
 

includes/cpp_redis/redis_subscriber.hpp

@@ -13,7 +13,7 @@ namespace cpp_redis {
 class redis_subscriber {
 public:
     //! ctor & dtor
-    redis_subscriber(void);
+    redis_subscriber(void) = default;
     ~redis_subscriber(void);
 
     //! copy ctor & assignment operator
@@ -22,14 +22,12 @@ class redis_subscriber {
 
 public:
     //! handle connection
-    void connect(const std::string& host = "127.0.0.1", unsigned int port = 6379);
+    typedef std::function<void(redis_subscriber&)> disconnection_handler_t;
+    void connect(const std::string& host = "127.0.0.1", unsigned int port = 6379,
+                 const disconnection_handler_t& disconnection_handler = nullptr);
     void disconnect(void);
     bool is_connected(void);
 
-    //! disconnection handler
-    typedef std::function<void(redis_subscriber&)> disconnection_handler_t;
-    void set_disconnection_handler(const disconnection_handler_t& handler);
-
     //! subscribe - unsubscribe
     typedef std::function<void(const std::string&, const std::string&)> subscribe_callback_t;
     void subscribe(const std::string& channel, const subscribe_callback_t& callback);
@@ -56,7 +54,6 @@ class redis_subscriber {
     disconnection_handler_t m_disconnection_handler;
 
     //! thread safety
-    std::mutex m_disconnection_handler_mutex;
     std::mutex m_psubscribed_channels_mutex;
     std::mutex m_subscribed_channels_mutex;
 };

sources/network/redis_connection.cpp

@@ -7,22 +7,24 @@ namespace network {
 redis_connection::redis_connection(void)
 : m_reply_callback(nullptr)
 , m_disconnection_handler(nullptr)
-{
-  auto disconnection_handler = std::bind(&redis_connection::tcp_client_disconnection_handler, this, std::placeholders::_1);
-  m_client.set_disconnection_handler(disconnection_handler);
-
-  auto receive_handler = std::bind(&redis_connection::tcp_client_receive_handler, this, std::placeholders::_1, std::placeholders::_2);
-  m_client.set_receive_handler(receive_handler);
-}
+{}
 
 redis_connection::~redis_connection(void) {
   if (is_connected())
     disconnect();
 }
 
 void
-redis_connection::connect(const std::string& host, unsigned int port) {
-  m_client.connect(host, port);
+redis_connection::connect(const std::string& host, unsigned int port,
+                          const disconnection_handler_t& client_disconnection_handler,
+                          const reply_callback_t& client_reply_callback)
+{
+  m_reply_callback = client_reply_callback;
+  m_disconnection_handler = client_disconnection_handler;
+
+  auto disconnection_handler = std::bind(&redis_connection::tcp_client_disconnection_handler, this, std::placeholders::_1);
+  auto receive_handler = std::bind(&redis_connection::tcp_client_receive_handler, this, std::placeholders::_1, std::placeholders::_2);
+  m_client.connect(host, port, disconnection_handler, receive_handler);
 }
 
 void
@@ -50,20 +52,6 @@ redis_connection::send(const std::vector<std::string>& redis_cmd) {
   m_client.send(build_command(redis_cmd));
 }
 
-void
-redis_connection::set_disconnection_handler(const disconnection_handler_t& handler) {
-  std::lock_guard<std::mutex> lock(m_disconnection_handler_mutex);
-
-  m_disconnection_handler = handler;
-}
-
-void
-redis_connection::set_reply_callback(const reply_callback_t& handler) {
-  std::lock_guard<std::mutex> lock(m_reply_callback_mutex);
-
-  m_reply_callback = handler;
-}
-
 bool
 redis_connection::tcp_client_receive_handler(network::tcp_client&, const std::vector<char>& buffer) {
   try {
@@ -74,8 +62,6 @@ redis_connection::tcp_client_receive_handler(network::tcp_client&, const std::ve
   }
 
   while (m_builder.reply_available()) {
-    std::lock_guard<std::mutex> lock(m_reply_callback_mutex);
-
     auto reply = m_builder.get_front();
     m_builder.pop_front();
 
@@ -88,8 +74,6 @@ redis_connection::tcp_client_receive_handler(network::tcp_client&, const std::ve
 
 void
 redis_connection::tcp_client_disconnection_handler(network::tcp_client&) {
-  std::lock_guard<std::mutex> lock(m_disconnection_handler_mutex);
-
   if (m_disconnection_handler)
     m_disconnection_handler(*this);
 }