Removing templateness of connection

Author: hamidr

includes/connection.hpp

@@ -11,30 +11,29 @@
 
 namespace async_redis
 {
-  template<typename InputOutputHandler>
   class connection
   {
-    using async_socket    = network::async_socket<InputOutputHandler>;
-    using tcp_socket      = network::tcp_socket<InputOutputHandler>;
-    using unix_socket     = network::unix_socket<InputOutputHandler>;
+    using async_socket    = network::async_socket;
+    using tcp_socket      = network::tcp_socket;
+    using unix_socket     = network::unix_socket;
 
   public:
     using parser_t        = parser::redis_response::parser;
     using reply_cb_t      = std::function<void (parser_t)>;
 
-    connection(InputOutputHandler &event_loop)
+    connection(event_loop::event_loop_ev& event_loop)
       : event_loop_(event_loop) {
     }
 
-    void connect(typename async_socket::connect_handler_t handler, const std::string& ip, int port)
+    void connect(async_socket::connect_handler_t handler, const std::string& ip, int port)
     {
       if (!socket_ || !socket_->is_valid())
         socket_ = std::make_unique<tcp_socket>(event_loop_);
 
       socket_->template async_connect<tcp_socket>(0, handler, ip, port);
     }
 
-    void connect(typename async_socket::connect_handler_t handler, const std::string& path)
+    void connect(async_socket::connect_handler_t handler, const std::string& path)
     {
       if (!socket_ || !socket_->is_valid())
         socket_ = std::make_unique<unix_socket>(event_loop_);
@@ -116,7 +115,7 @@ namespace async_redis
     std::unique_ptr<async_socket> socket_;
     std::queue<std::tuple<reply_cb_t, parser_t>> req_queue_;
 
-    InputOutputHandler& event_loop_;
+    event_loop::event_loop_ev& event_loop_;
     enum { max_data_size = 1024 };
     char data_[max_data_size];
   };

includes/monitor.hpp

@@ -10,9 +10,9 @@ namespace async_redis
   template<typename InputOutputHandler>
   class monitor
   {
-    using async_socket    = network::async_socket<InputOutputHandler>;
-    using tcp_socket      = network::tcp_socket<InputOutputHandler>;
-    using unix_socket     = network::unix_socket<InputOutputHandler>;
+    using async_socket    = network::async_socket;
+    using tcp_socket      = network::tcp_socket;
+    using unix_socket     = network::unix_socket;
 
   public:
     enum EventState {

includes/network/async_socket.hpp

@@ -10,6 +10,7 @@
 #include <arpa/inet.h>
 
 #include <string>
+#include <event_loop/event_loop_ev.h>
 
 namespace async_redis {
   namespace network
@@ -22,20 +23,20 @@ namespace async_redis {
     class connect_socket_exception : socket_excetion {};
     class nonblocking_socket_exception : socket_excetion {};
 
-    template <typename InputOutputHanler>
     class async_socket
     {
     public:
-      using socket_identifier_t  = typename InputOutputHanler::socket_identifier_t;
+
+      using socket_identifier_t  = event_loop::event_loop_ev::socket_identifier_t;
       using recv_cb_t         = std::function<void (ssize_t)>;
       using ready_cb_t        = std::function<void (ssize_t)>;
       using connect_handler_t = std::function<void (bool)>;
 
-      async_socket(InputOutputHanler& io)
+      async_socket(event_loop::event_loop_ev& io)
         : io_(io)
       { }
 
-      async_socket(InputOutputHanler &io, int fd)
+      async_socket(event_loop::event_loop_ev &io, int fd)
         : io_(io)
       {
         fd_ = fd;
@@ -180,7 +181,7 @@ namespace async_redis {
 
     private:
       bool is_connected_ = false;
-      InputOutputHanler& io_;
+      event_loop::event_loop_ev& io_;
       socket_identifier_t id_;
       int fd_ = -1;
     };

includes/network/tcp_socket.hpp

@@ -5,19 +5,18 @@
 namespace async_redis {
   namespace network
   {
-    template<typename InputOutputHanler>
-    class tcp_socket : public async_socket<InputOutputHanler>
+    class tcp_socket : public async_socket
     {
 
     public:
-      tcp_socket(InputOutputHanler& io)
-        : async_socket<InputOutputHanler>(io)
+      tcp_socket(event_loop::event_loop_ev& io)
+        : async_socket(io)
       {
         this->create_socket(AF_INET);
       }
 
-      tcp_socket(InputOutputHanler& io, int fd)
-        : async_socket<InputOutputHanler>(io, fd)
+      tcp_socket(event_loop::event_loop_ev& io, int fd)
+        : async_socket(io, fd)
       {}
 
       bool bind(const string& host, int port)

includes/network/unix_socket.hpp

@@ -5,21 +5,20 @@
 namespace async_redis {
   namespace network
   {
-    template<typename InputOutputHanler>
-    class unix_socket : public async_socket<InputOutputHanler>
+    class unix_socket : public async_socket
     {
     public:
 
       inline
-      unix_socket(InputOutputHanler &io)
-        : async_socket<InputOutputHanler>(io)
+      unix_socket(event_loop::event_loop_ev &io)
+        : async_socket(io)
       {
         this->create_socket(AF_UNIX);
       }
 
       inline
-      unix_socket(InputOutputHanler &io, int fd)
-        : async_socket<InputOutputHanler>(io, fd)
+      unix_socket(event_loop::event_loop_ev &io, int fd)
+        : async_socket(io, fd)
       {}
 
       int connect(const string& path) {

includes/redis_client.hpp

@@ -15,21 +15,20 @@ namespace async_redis
   template<typename InputOutputHandler>
   class redis_client
   {
-    using connection_t = connection<InputOutputHandler>;
-    using reply_cb_t   = typename connection_t::reply_cb_t;
-    using connect_cb_t = typename async_redis::network::async_socket<InputOutputHandler>::connect_handler_t;
+    using reply_cb_t   = connection::reply_cb_t;
+    using connect_cb_t = network::async_socket::connect_handler_t;
 
   public:
     class connect_exception : std::exception {};
-    using parser_t = typename connection_t::parser_t;
+    using parser_t = connection::parser_t;
 
     redis_client(InputOutputHandler &eventIO, int n = 1)
       : ev_loop_(eventIO)
     {
       conn_pool_.reserve(n);
 
       for (int i = 0; i < conn_pool_.capacity(); ++i)
-        conn_pool_.push_back(std::make_unique<connection_t>(ev_loop_));
+        conn_pool_.push_back(std::make_unique<connection>(ev_loop_));
     }
 
     bool is_connected() const
@@ -140,7 +139,7 @@ namespace async_redis
       pipelined_cbs_.push_back(std::move(reply));
     }
 
-    connection_t& get_connection()
+    connection& get_connection()
     {
       auto &con = conn_pool_[con_rr_ctr_++];
       if (con_rr_ctr_ == conn_pool_.size())
@@ -173,7 +172,7 @@ namespace async_redis
     std::string pipeline_buffer_;
     bool pipelined_state_ = false;
     std::vector<reply_cb_t> pipelined_cbs_;
-    std::vector<std::unique_ptr<connection_t>> conn_pool_;
+    std::vector<std::unique_ptr<connection>> conn_pool_;
     int con_rr_ctr_ = 0;
     int connected_called_ = 0;
     bool is_connected_ = false;

includes/sentinel.hpp

@@ -16,12 +16,12 @@ namespace async_redis {
     template<typename InputOutputHandler>
     class sentinel
     {
-      using socket_t     = ::async_redis::network::tcp_socket<InputOutputHandler>;
+      using socket_t     = ::async_redis::network::tcp_socket;
       using connect_cb_t = typename socket_t::connect_handler_t;
 
       using redis_resp_t = ::async_redis::parser::redis_response;
       using monitor_t    = monitor<InputOutputHandler>;
-      using connection_t = connection<InputOutputHandler>;
+      using connection_t = connection;
 
 
     public: