refactor

include/sqlpp11/connection_pool.h

@@ -133,8 +133,6 @@ namespace sqlpp
     typename Connection = typename std::enable_if<std::is_class<Connection_config::connection>::value, Connection_config::connection>::type>
   class connection_pool_t
   {
-    friend pool_connection<Connection_config, Connection_validator, Connection>;
-
   private:
     std::mutex connection_pool_mutex;
     const std::shared_ptr<Connection_config> config;
@@ -142,6 +140,55 @@ namespace sqlpp
     std::stack<std::unique_ptr<Connection>> free_connections;
     Connection_validator connection_validator;
 
+  public:
+    connection_pool_t(const std::shared_ptr<Connection_config>& config, size_t pool_size)
+      : config(config), maximum_pool_size(pool_size), connection_validator(Connection_validator()) {}
+    ~connection_pool_t() = default;
+    connection_pool_t(const connection_pool_t&) = delete;
+    connection_pool_t(connection_pool_t&& other)
+      : config(std::move(other.config)), maximum_pool_size(std::move(other.maximum_pool_size)),
+      connection_validator(std::move(other.connection_validator)) {}
+    connection_pool_t& operator=(const connection_pool_t&) = delete;
+    connection_pool_t& operator=(connection_pool_t&&) = delete;
+
+    template <typename Pool_connection = pool_connection<Connection_config, Connection_validator, Connection, connection_pool_t>>
+    auto get_connection()
+      -> Pool_connection
+    {
+      std::lock_guard<std::mutex> lock(connection_pool_mutex);
+      while (true)
+      {
+        try
+        {
+          if (!free_connections.empty())
+          {
+            auto connection = std::move(free_connections.top());
+            free_connections.pop();
+            connection_validator.validate(connection.get());
+
+            return Pool_connection(std::move(connection), this);
+          }
+          else
+          {
+            break;
+          }
+        }
+        catch (const sqlpp::exception&)
+        {
+          throw sqlpp::exception("Failed to retrieve a valid connection.");
+        }
+      }
+
+      try
+      {
+        return Pool_connection(std::move(std::make_unique<Connection>(config)), this);
+      }
+      catch (const sqlpp::exception&)
+      {
+        throw sqlpp::exception("Failed to spawn a new connection.");
+      }
+    }
+    
     void free_connection(std::unique_ptr<Connection>& connection)
     {
       std::lock_guard<std::mutex> lock(connection_pool_mutex);
@@ -163,54 +210,6 @@ namespace sqlpp
       }
     }
 
-  public:
-    connection_pool_t(const std::shared_ptr<Connection_config>& config, size_t pool_size)
-      : config(config), maximum_pool_size(pool_size), connection_validator(Connection_validator()) {}
-    ~connection_pool_t() = default;
-    connection_pool_t(const connection_pool_t&) = delete;
-    connection_pool_t(connection_pool_t&& other)
-      : config(std::move(other.config)), maximum_pool_size(std::move(other.maximum_pool_size)),
-      connection_validator(std::move(other.connection_validator)) {}
-    connection_pool_t& operator=(const connection_pool_t&) = delete;
-    connection_pool_t& operator=(connection_pool_t&&) = delete;
-
-    auto get_connection()
-      -> pool_connection<Connection_config, Connection_validator, Connection> 
-    {
-      std::lock_guard<std::mutex> lock(connection_pool_mutex);
-      while (true)
-      {
-        try
-        {
-          if (!free_connections.empty())
-          {
-            auto connection = std::move(free_connections.top());
-            free_connections.pop();
-            connection_validator.validate(connection.get());
-
-            return pool_connection<Connection_config, Connection_validator, Connection>(std::move(connection), this);
-          }
-          else
-          {
-            break;
-          }
-        }
-        catch (const sqlpp::exception&)
-        {
-          throw sqlpp::exception("Failed to retrieve a valid connection.");
-        }
-      }
-
-      try
-      {
-        return pool_connection<Connection_config, Connection_validator, Connection>(std::move(std::make_unique<Connection>(config)), this);
-      }
-      catch (const sqlpp::exception&)
-      {
-        throw sqlpp::exception("Failed to spawn a new connection.");
-      }
-    }
-
     template<typename Query, typename Lambda>
     void operator()(Query query, Lambda callback)
     {

include/sqlpp11/pool_connection.h

@@ -34,8 +34,7 @@
 
 namespace sqlpp
 {
-  template <typename Connection_config, typename Connection_validator, typename Connection,
+  template <typename Connection_config, typename Connection_validator, typename Connection, typename Connection_pool>
-    typename Connection_pool = connection_pool_t<Connection_config, Connection_validator, Connection>>
   struct pool_connection : public sqlpp::connection
   {
   private:
@@ -90,11 +89,11 @@ namespace sqlpp
       return _impl->prepare(t);
     }
 
-    template<typename Query, typename Lambda,
+    template<typename Query, typename Lambda, typename Result = decltype(pool_connection()(Query())),
       typename std::enable_if<is_invocable<Lambda>::value ||
       is_invocable<Lambda, sqlpp::exception>::value ||
-      is_invocable<Lambda, sqlpp::exception, decltype(pool_connection()(Query()))>::value &&
+      is_invocable<Lambda, sqlpp::exception, Result>::value &&
-      !is_invocable<Lambda, sqlpp::exception, decltype(pool_connection()(Query())), pool_connection>::value, int>::type = 0>
+      !is_invocable<Lambda, sqlpp::exception, Result, pool_connection>::value, int>::type = 0>
     void operator()(Query query, Lambda callback)
     {
         try
@@ -103,12 +102,12 @@ namespace sqlpp
       }
       catch (const std::exception& e)
       {
-        invoke_callback(sqlpp::exception(sqlpp::exception::query_error, e.what()), pool_connection(), decltype(pool_connection()(Query()))(), callback);
+        invoke_callback(sqlpp::exception(sqlpp::exception::query_error, e.what()), pool_connection(), Result(), callback);
       }
     }
 
-    template<typename Query, typename Lambda,
+    template<typename Query, typename Lambda, typename Result = decltype(pool_connection()(Query())),
-      typename std::enable_if<is_invocable<Lambda, sqlpp::exception, decltype(pool_connection()(Query())), pool_connection>::value, int>::type = 0>
+      typename std::enable_if<is_invocable<Lambda, sqlpp::exception, Result, pool_connection>::value, int>::type = 0>
       void operator()(Query query, Lambda callback)
     {
       static_assert(false, "Direct query with pool connection forbids callback with parameter of type connection.");