typed_pool.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Copyright (c) 2026 Daniel Polo
 
#ifndef IT_D4NP_MEMORYPOOL_TYPED_POOL_HPP_
#define IT_D4NP_MEMORYPOOL_TYPED_POOL_HPP_
 
#include <it/d4np/memorypool/memory_pool.hpp>
 
#include <cstddef>
#include <new>
#include <optional>
#include <type_traits>
#include <utility>
 
namespace it::d4np::memorypool {
 
template <typename T>
class TypedPool {
    static_assert(!std::is_void_v<T>, "TypedPool<T>: T must be an object type; use Pool for raw void* blocks");
    static_assert(!std::is_reference_v<T>, "TypedPool<T>: T must be an object type, not a reference");
    static_assert(alignof(T) <= alignof(std::max_align_t),
                  "TypedPool<T>: over-aligned types are not supported — the pool guarantees "
                  "alignof(std::max_align_t) only (ADR-0009 §5, ADR-0017 §2)");
 
public:
    static constexpr std::size_t block_size() noexcept {
        // UPPER_CASE per readability-identifier-naming.ConstexprVariableCase.
        constexpr std::size_t FLOOR = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);
        constexpr std::size_t ALIGN = alignof(std::max_align_t);
        return ((FLOOR + ALIGN - 1U) / ALIGN) * ALIGN;
    }
 
    explicit TypedPool(std::size_t block_count) : pool_(block_size(), block_count) {}
 
    [[nodiscard]] static std::optional<TypedPool> make(std::size_t block_count) {
        std::optional<Pool> pool = Pool::make(block_size(), block_count);
        if (!pool.has_value()) {
            return std::nullopt;
        }
        return {TypedPool{std::move(*pool)}};
    }
 
    [[nodiscard]] T* allocate() {
        return static_cast<T*>(pool_.allocate());
    }
 
    [[nodiscard]] T* try_allocate() noexcept {
        return static_cast<T*>(pool_.try_allocate());
    }
 
    void deallocate(T* block) noexcept {
        pool_.deallocate(block);
    }
 
    template <typename... Args>
    [[nodiscard]] T* construct(Args&&... args) {
        void* const raw = pool_.allocate();
        try {
            // Placement new constructs in pool-owned storage — it does not
            // allocate, so it transfers no ownership in the gsl sense.
            // cppcoreguidelines-owning-memory misreads the `T*` return as a
            // freshly allocated resource; the slot is owned by the pool and
            // released through ::destroy / ::deallocate.
            // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
            return ::new (raw) T(std::forward<Args>(args)...);
        } catch (...) {
            pool_.deallocate(raw);
            throw;
        }
    }
 
    void destroy(T* obj) noexcept {
        if (obj == nullptr) {
            return;
        }
        obj->~T();
        pool_.deallocate(obj);
    }
 
    [[nodiscard]] memory_pool_t* native_handle() noexcept {
        return pool_.native_handle();
    }
 
    [[nodiscard]] std::size_t metadata_bytes() const noexcept {
        return pool_.metadata_bytes();
    }
 
private:
    explicit TypedPool(Pool&& pool) noexcept : pool_(std::move(pool)) {}
 
    Pool pool_;
};
 
}  // namespace it::d4np::memorypool
 
#endif  // IT_D4NP_MEMORYPOOL_TYPED_POOL_HPP_