ObjectPool.hpp

#ifndef INTNS_MEMORY_OBJECTPOOL_HPP
#define INTNS_MEMORY_OBJECTPOOL_HPP
 
#include <cassert>
#include <deque>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
 
namespace intns::memory {
template <typename Policy, typename T>
concept AcquireHook = requires(T& obj) {
  { Policy::on_acquire(obj) } noexcept;
};
 
template <typename Policy, typename T>
concept ReleaseHook = requires(T& obj) {
  { Policy::on_release(obj) } noexcept;
};
 
template <typename U>
struct NoOpPoolPolicy {
  static void on_acquire(U&) noexcept {}
  static void on_release(U&) noexcept {}
};
 
template <typename T, typename AcquirePolicy = NoOpPoolPolicy<T>,
          typename ReleasePolicy = AcquirePolicy>
  requires AcquireHook<AcquirePolicy, T> && ReleaseHook<ReleasePolicy, T>
class ObjectPool {
  static_assert(std::is_default_constructible_v<T>,
                "T must be default constructible");
  static_assert(std::is_move_constructible_v<T>,
                "T must be move constructible");
 
 public:
  using queue_type = std::deque<T>;
  using size_type = size_t;
  using value_type = T;
 
  ObjectPool() = default;
  ~ObjectPool() = default;
 
  ObjectPool(queue_type&& src) : objects_(std::move(src)) {}
 
  ObjectPool(size_type init_size,
             std::optional<size_type> limit = std::nullopt);
 
  [[nodiscard]] value_type take();
 
  [[nodiscard]] std::optional<value_type> try_take();
 
  void add(value_type&& back);
 
  [[nodiscard]] bool try_add(value_type&& back);
 
  void reserve(size_type target_size) { reserve_impl<true>(target_size); }
 
  [[nodiscard]] bool try_reserve(size_type target_size) {
    return reserve_impl<false>(target_size);
  }
 
  void shrink_to_fit() {
    std::scoped_lock<std::mutex> lock(mutex_);
    objects_.shrink_to_fit();
  }
 
  size_type capacity() const {
    std::scoped_lock<std::mutex> lock(mutex_);
    return objects_.capacity();
  }
 
  [[nodiscard]] size_type size() const {
    std::scoped_lock<std::mutex> lock(mutex_);
    return objects_.size();
  }
 
  [[nodiscard]] bool empty() const {
    std::scoped_lock<std::mutex> lock(mutex_);
    return objects_.empty();
  }
 
  [[nodiscard]] std::optional<size_type> size_limit() const noexcept {
    std::scoped_lock<std::mutex> lock(mutex_);
    return size_limit_;
  }
 
  void set_size_limit(std::optional<size_type> limit) noexcept {
    std::scoped_lock<std::mutex> lock(mutex_);
    size_limit_ = limit;
  }
 
 private:
  template <bool ThrowOnError>
  [[nodiscard]] bool reserve_impl(size_type target_size);
 
  // The internal queue object
  queue_type objects_;
 
  // Mutex for thread safety
  mutable std::mutex mutex_;
 
  // Customizable size limit object, unlimited unless specified
  std::optional<size_type> size_limit_ = std::nullopt;
};
 
template <typename Pool>
class PoolLease {
  using value_type = typename Pool::value_type;
 
 public:
  PoolLease(Pool& p) : pool_(&p), obj_(p.take()) {}
 
  PoolLease(PoolLease&& o) noexcept
      : pool_(o.pool_), obj_(std::move(o.obj_)), active_(o.active_) {
    o.active_ = false;
  }
 
  PoolLease(const PoolLease&) = delete;
  PoolLease& operator=(const PoolLease&) = delete;
 
  ~PoolLease() {
    if (active_) {
      pool_->add(std::move(obj_));
    }
  }
 
  [[nodiscard]] auto& get() noexcept { return obj_; }
 
  [[nodiscard]] value_type* operator->() noexcept { return &obj_; }
 
  [[nodiscard]] const auto& get() const noexcept { return obj_; }
 
  [[nodiscard]] const value_type* operator->() const noexcept { return &obj_; }
 
  [[nodiscard]] value_type release() noexcept {
    active_ = false;
    return std::move(obj_);
  }
 
 private:
  // Pointer to the pool from which the object was leased
  Pool* pool_;
 
  // The object being managed by this lease
  value_type obj_;
 
  // Indicates whether the lease is still active
  bool active_ = true;
};
 
}  // namespace intns::memory
 
#include "ObjectPool.tpp"
 
#endif  // NSLIB_MEMORY_OBJECTPOOL_HPP