pool_allocator.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Copyright (c) 2026 Daniel Polo
 
#ifndef IT_D4NP_MEMORYPOOL_POOL_ALLOCATOR_HPP_
#define IT_D4NP_MEMORYPOOL_POOL_ALLOCATOR_HPP_
 
#include <it/d4np/memorypool/memory_pool.hpp>
 
#include <cstddef>
#include <limits>
#include <new>
#include <type_traits>
 
namespace it::d4np::memorypool {
 
template <typename T>
class PoolAllocator {
public:
    using value_type = T;
 
    // Propagation traits — ADR-0018 §4. All three `false`: memory routing
    // is tied to (n, T) and to the pool a pointer came from, never to
    // allocator-identity propagation across container copy / move / swap.
    using propagate_on_container_copy_assignment = std::false_type;
    using propagate_on_container_move_assignment = std::false_type;
    using propagate_on_container_swap = std::false_type;
    // Stateful: two adapters are interchangeable only if they share a pool.
    using is_always_equal = std::false_type;
 
    explicit PoolAllocator(Pool& pool) noexcept : pool_(&pool) {}
 
    template <typename U>
    PoolAllocator(const PoolAllocator<U>& other) noexcept : pool_(other.pool_) {}
 
    [[nodiscard]] T* allocate(std::size_t n) {
        if (routes_to_pool(n)) {
            void* const block = pool_->try_allocate();
            if (block == nullptr) {
                throw std::bad_alloc{};
            }
            return static_cast<T*>(block);
        }
        return allocate_fallback(n);
    }
 
    void deallocate(T* ptr, std::size_t n) noexcept {
        if (routes_to_pool(n)) {
            pool_->deallocate(ptr);
            return;
        }
        deallocate_fallback(ptr);
    }
 
    template <typename U>
    [[nodiscard]] bool operator==(const PoolAllocator<U>& rhs) const noexcept {
        return pool_ == rhs.pool_;
    }
 
    template <typename U>
    [[nodiscard]] bool operator!=(const PoolAllocator<U>& rhs) const noexcept {
        return !(*this == rhs);
    }
 
private:
    // Rebound specialisations are mutual friends so the converting ctor and
    // operator== can read each other's private back-reference.
    template <typename U>
    friend class PoolAllocator;
 
    [[nodiscard]] bool routes_to_pool(std::size_t n) const noexcept {
        return n == 1U && sizeof(T) <= pool_->block_size() && alignof(T) <= alignof(std::max_align_t);
    }
 
    [[nodiscard]] static T* allocate_fallback(std::size_t n) {
        if (n > (std::numeric_limits<std::size_t>::max() / sizeof(T))) {
            // n * sizeof(T) would overflow size_t — ADR-0009 §3 guard,
            // applied here to the fallback path.
            throw std::bad_alloc{};
        }
        const std::size_t bytes = n * sizeof(T);
        // Over-aligned ::operator new so the fallback honours alignof(T)
        // even for over-aligned T (the case routes_to_pool excludes from
        // the pool). cppcoreguidelines-owning-memory misreads the returned
        // storage as a leaked resource; deallocate_fallback closes it.
        // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
        return static_cast<T*>(::operator new(bytes, std::align_val_t{alignof(T)}));
    }
 
    static void deallocate_fallback(T* ptr) noexcept {
        // Matching aligned ::operator delete for the over-aligned new
        // above — C++17 [expr.delete] requires the same alignment argument.
        // The T* -> void* conversion to the deallocation function is
        // implicit and unambiguous, so no explicit cast is needed.
        // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
        ::operator delete(ptr, std::align_val_t{alignof(T)});
    }
 
    Pool* pool_;
};
 
}  // namespace it::d4np::memorypool
 
#endif  // IT_D4NP_MEMORYPOOL_POOL_ALLOCATOR_HPP_