added sqlite connection class (progress)

include/matador/sql/connection_pool.hpp

@@ -0,0 +1,107 @@
+#ifndef QUERY_CONNECTION_POOL_HPP
+#define QUERY_CONNECTION_POOL_HPP
+
+#include <utility>
+#include <queue>
+#include <mutex>
+#include <string>
+#include <unordered_set>
+
+namespace matador::sql {
+
+template < class Connection >
+class connection_pool;
+
+template < class Connection >
+class connection_ptr
+{
+public:
+  connection_ptr(Connection *c, connection_pool<Connection> &pool)
+  : connection_(c), pool_(pool) {}
+  ~connection_ptr();
+  connection_ptr(const connection_ptr &) = delete;
+  connection_ptr& operator=(const connection_ptr &) = delete;
+  connection_ptr(connection_ptr &&) noexcept = default;
+  connection_ptr& operator=(connection_ptr &&) noexcept = default;
+
+  Connection* operator->() { return connection_; }
+  Connection& operator*() { return *connection_; }
+
+  [[nodiscard]] bool valid() const { return connection_ != nullptr; }
+
+private:
+  friend class connection_pool<Connection>;
+
+  Connection *connection_;
+  connection_pool<Connection> &pool_;
+};
+
+template < class Connection >
+class connection_pool
+{
+public:
+  connection_pool(const std::string &db, unsigned int count) {
+    connection_repo_.reserve(count);
+    for (auto i = 0U; i < count; ++i) {
+      connection_repo_.emplace_back(db + std::to_string(i+1));
+      idle_connections_.push(&connection_repo_.back());
+      idle_connections_.back()->open();
+    }
+  }
+
+  connection_ptr<Connection> acquire() {
+    std::lock_guard<std::mutex> guard(mutex_);
+    if (idle_connections_.empty()) {
+      return {nullptr, *this};
+    }
+
+    auto ptr = idle_connections_.front();
+    idle_connections_.pop();
+    inuse_connections_.insert(ptr);
+    return { ptr, *this };
+  }
+
+  void release(Connection *c) {
+    if (c == nullptr) {
+      return;
+    }
+    std::lock_guard<std::mutex> guard(mutex_);
+
+    if (inuse_connections_.erase(c) > 0) {
+      idle_connections_.push(c);
+    }
+  }
+
+  void release(connection_ptr<Connection> &c) {
+    release(c.connection_);
+    c.connection_ = nullptr;
+  }
+  
+  std::size_t size() const { return connection_repo_.size(); }
+  std::size_t idle() const {
+    std::lock_guard<std::mutex> guard(mutex_);
+    return idle_connections_.size();
+  }
+  std::size_t inuse() const {
+    std::lock_guard<std::mutex> guard(mutex_);
+    return inuse_connections_.size();
+  }
+
+private:
+  mutable std::mutex mutex_;
+  std::vector<Connection> connection_repo_;
+  using pointer = Connection*;
+  using connections = std::queue<pointer>;
+  using connection_set = std::unordered_set<pointer>;
+  connections idle_connections_;
+  connection_set inuse_connections_;
+};
+
+template<class Connection>
+connection_ptr<Connection>::~connection_ptr() {
+  pool_.release(connection_);
+}
+
+}
+
+#endif //QUERY_CONNECTION_POOL_HPP