Add create() hook to connection factories

This will allow the user to either establish the connection themselves
(using the handle c-tor) and/or configure the connection post-creation.

2 files changed, 38 insertions, 18 deletions

diff --git a/odb/pgsql/connection-factory.cxx b/odb/pgsql/connection-factory.cxx
index c9e758d..d725ef0 100644
--- a/odb/pgsql/connection-factory.cxx
+++ b/odb/pgsql/connection-factory.cxx
@@ -45,6 +45,12 @@ namespace odb
     // connection_pool_factory
     //
 
+    connection_pool_factory::pooled_connection_ptr connection_pool_factory::
+    create ()
+    {
+      return pooled_connection_ptr (new (shared) pooled_connection (*db_));
+    }
+
     connection_pool_factory::
     ~connection_pool_factory ()
     {
@@ -83,8 +89,8 @@ namespace odb
         //
         if (max_ == 0 || in_use_ < max_)
         {
-          shared_ptr<pooled_connection> c (
-            new (shared) pooled_connection (*db_, this));
+          shared_ptr<pooled_connection> c (create ());
+          c->pool_ = this;
           in_use_++;
           return c;
         }
@@ -107,11 +113,7 @@ namespace odb
         connections_.reserve (min_);
 
         for (size_t i (0); i < min_; ++i)
-        {
-          connections_.push_back (
-            shared_ptr<pooled_connection> (
-              new (shared) pooled_connection (*db_, 0)));
-        }
+          connections_.push_back (create ());
       }
     }
 
@@ -131,8 +133,7 @@ namespace odb
       in_use_--;
 
       if (keep)
-        connections_.push_back (
-          shared_ptr<pooled_connection> (inc_ref (c)));
+        connections_.push_back (pooled_connection_ptr (inc_ref (c)));
 
       if (waiters_ != 0)
         cond_.signal ();
@@ -145,8 +146,17 @@ namespace odb
     //
 
     connection_pool_factory::pooled_connection::
-    pooled_connection (database_type& db, connection_pool_factory* pool)
-        : connection (db), pool_ (pool)
+    pooled_connection (database_type& db)
+        : connection (db), pool_ (0)
+    {
+      callback_.arg = this;
+      callback_.zero_counter = &zero_counter;
+      shared_base::callback_ = &callback_;
+    }
+
+    connection_pool_factory::pooled_connection::
+    pooled_connection (database_type& db, PGconn* handle)
+        : connection (db, handle), pool_ (0)
     {
       callback_.arg = this;
       callback_.zero_counter = &zero_counter;
diff --git a/odb/pgsql/connection-factory.hxx b/odb/pgsql/connection-factory.hxx
index 8a7b9c8..936a488 100644
--- a/odb/pgsql/connection-factory.hxx
+++ b/odb/pgsql/connection-factory.hxx
@@ -105,13 +105,12 @@ namespace odb
       connection_pool_factory (const connection_pool_factory&);
       connection_pool_factory& operator= (const connection_pool_factory&);
 
-    private:
+    protected:
       class pooled_connection: public connection
       {
       public:
-        // NULL pool value indicates that the connection is not in use.
-        //
-        pooled_connection (database_type&, connection_pool_factory*);
+        pooled_connection (database_type&);
+        pooled_connection (database_type&, PGconn*);
 
       private:
         static bool
@@ -121,19 +120,30 @@ namespace odb
         friend class connection_pool_factory;
 
         shared_base::refcount_callback callback_;
+
+        // NULL pool value indicates that the connection is not in use.
+        //
         connection_pool_factory* pool_;
       };
 
       friend class pooled_connection;
-      typedef std::vector<details::shared_ptr<pooled_connection> > connections;
 
-    private:
+      typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;
+      typedef std::vector<pooled_connection_ptr> connections;
+
+      // This function is called whenever the pool needs to create a new
+      // connection.
+      //
+      virtual pooled_connection_ptr
+      create ();
+
+    protected:
       // Return true if the connection should be deleted, false otherwise.
       //
       bool
       release (pooled_connection*);
 
-    private:
+    protected:
       const std::size_t max_;
       const std::size_t min_;