130 size_t total_created{0};
160 void safe_dec_borrowed_and_live() noexcept;
162 [[nodiscard]]
bool should_reset_on_acquire() const noexcept;
164 [[nodiscard]]
bool should_reset_on_release() const noexcept;
166 [[noreturn]] static
void throw_invalid_size();
168 [[noreturn]] static
void throw_factory_null_pre_fill();
170 [[noreturn]] static
void throw_factory_null();
172 [[noreturn]] static
void throw_not_shared_owned();
174 [[noreturn]]
void throw_exhausted(
size_t pool_size) const;
182 size_t live_count_{0};
183 size_t total_created_{0};
199 template <
typename T>
266 [[nodiscard]] std::unique_ptr<T, typename ObjectPool<T>::PoolDeleter>
get();
276 [[nodiscard]] std::shared_ptr<T>
get_shared();
285 [[nodiscard]] T*
borrow();
306 [[nodiscard]]
size_t size()
const;
311 std::unique_ptr<T> acquire();
313 void release(std::unique_ptr<T> obj) noexcept;
317 std::vector<std::unique_ptr<T>> pool_;
326 template <
typename T>
330 factory_callback_(std::move(factory_callback)),
331 reset_callback_(std::move(reset_callback)) {
332 pool_.reserve(initial_size);
333 for (
size_t i = 0; i < initial_size; ++i) {
334 auto obj = factory_callback_();
341 reset_callback_(*obj);
344 pool_.emplace_back(std::move(obj));
351 template <
typename T>
353 std::weak_ptr<ObjectPool<T>> weak_self = this->weak_from_this();
356 throw_not_shared_owned();
359 std::unique_ptr<T> obj = acquire();
362 if (should_reset_on_acquire() && reset_callback_) {
363 reset_callback_(*obj);
366 release(std::move(obj));
370 return {obj.release(),
PoolDeleter{std::move(weak_self)}};
373 template <
typename T>
375 std::weak_ptr<ObjectPool<T>> weak_self = this->weak_from_this();
378 throw_not_shared_owned();
381 std::unique_ptr<T> obj = acquire();
384 if (should_reset_on_acquire() && reset_callback_) {
385 reset_callback_(*obj);
388 release(std::move(obj));
392 return {obj.release(),
PoolDeleter{std::move(weak_self)}};
395 template <
typename T>
397 std::unique_ptr<T> obj = acquire();
400 if (should_reset_on_acquire() && reset_callback_) {
401 reset_callback_(*obj);
404 release(std::move(obj));
408 return obj.release();
411 template <
typename T>
417 std::unique_ptr<T> u(ptr);
418 release(std::move(u));
421 template <
typename T>
423 std::lock_guard lock(mutex_);
424 return {pool_.size(), borrowed_, total_created_, max_size_};
427 template <
typename T>
429 std::lock_guard lock(mutex_);
433 template <
typename T>
435 return [] {
return std::make_unique<T>(); };
438 template <
typename T>
439 inline std::unique_ptr<T> ObjectPool<T>::acquire() {
440 std::unique_lock lock(mutex_);
443 std::unique_ptr<T> obj = std::move(pool_.back());
449 if VUNLIKELY (max_size_ > 0 && live_count_ >= max_size_) {
450 throw_exhausted(pool_.size());
459 std::unique_ptr<T> new_obj;
461 new_obj = factory_callback_();
464 throw_factory_null();
477 template <
typename T>
478 inline void ObjectPool<T>::release(std::unique_ptr<T> obj) noexcept {
483 if (should_reset_on_release() && reset_callback_) {
485 reset_callback_(*obj);
487 safe_dec_borrowed_and_live();
493 std::lock_guard lock(mutex_);
500 pool_.emplace_back(std::move(obj));
502 if (live_count_ > 0) {
509 template <
typename T>
515 if (
auto sp = weak_pool.lock()) {
516 std::unique_ptr<T> u(ptr);
517 sp->release(std::move(u));
Type-independent base of ObjectPool that owns counters, mutex and policy state.
Definition: object_pool.h:106
size_t total_created_
Definition: object_pool.h:183
size_t borrowed() const
Returns the number of objects currently checked out of the pool.
bool should_reset_on_release() const noexcept
size_t live_count_
Definition: object_pool.h:182
size_t max_size() const noexcept
Returns the configured upper bound on live objects.
static void throw_factory_null_pre_fill()
Policy
Decides when (or whether) the user-supplied ResetCallback runs.
Definition: object_pool.h:116
@ kPolicyRelease
Reset on the return-to-pool path.
Definition: object_pool.h:118
std::mutex mutex_
Definition: object_pool.h:179
size_t total_created() const
Returns the cumulative number of objects ever produced by the factory.
Thread-safe recycling pool for instances of T with RAII acquisition.
Definition: object_pool.h:200
std::shared_ptr< T > get_shared()
Acquires an object wrapped in a shared_ptr with automatic return.
Definition: object_pool.h:374
T * borrow()
Acquires an object as a raw pointer; the caller owns the return path.
Definition: object_pool.h:396
ObjectPool(FactoryCallback factory_callback=get_default_factory(), size_t initial_size=0, size_t max_size=0, ResetCallback reset_callback=nullptr, Policy policy=kPolicyRelease)
Constructs the pool and optionally pre-warms the free list.
Definition: object_pool.h:327
void give_back(T *ptr)
Returns an object obtained from borrow() back to the pool.
Definition: object_pool.h:412
size_t size() const
Returns the number of objects currently idle on the free list.
Definition: object_pool.h:428
std::unique_ptr< T, typename ObjectPool< T >::PoolDeleter > get()
Acquires an object wrapped in a unique_ptr with automatic return.
Definition: object_pool.h:352
Stats stats() const
Captures a thread-safe snapshot of pool statistics.
Definition: object_pool.h:422
Pool-backed type-erased callables: copyable vlink::Function and move-only vlink::MoveFunction.
Cross-platform macros for visibility, branch hints, copy prevention, singletons and string helpers.
#define VUNLIKELY(...)
Short alias for VLINK_UNLIKELY.
Definition: macros.h:292
#define VLINK_EXPORT
Definition: macros.h:81
#define VLIKELY(...)
Short alias for VLINK_LIKELY.
Definition: macros.h:284
#define VLINK_DISALLOW_COPY_AND_ASSIGN(classname)
Deletes the copy constructor and copy-assignment operator of classname.
Definition: macros.h:174
Point-in-time snapshot of internal pool counters.
Definition: object_pool.h:127
Custom deleter installed on every RAII handle handed out by get / get_shared.
Definition: object_pool.h:230
std::weak_ptr< ObjectPool< T > > weak_pool
Weak reference to the parent pool.
Definition: object_pool.h:237
void operator()(T *ptr) const noexcept
Returns ptr to the pool, or deletes it when the pool is gone.
Definition: object_pool.h:510