Class allocator_slab

src/fl/stl/allocator.h:695–800

// STL-compatible slab allocator
template <typename T, fl::size SLAB_SIZE = FASTLED_DEFAULT_SLAB_SIZE>
class allocator_slab {
public:
    // Type definitions required by STL
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;
    using size_type = fl::size;
    using difference_type = fl::ptrdiff_t;

    // Rebind allocator to type U
    template <typename U>
    struct rebind {
        using other = typename fl::conditional<
            fl::is_same<U, void>::value,
            allocator_slab<char, SLAB_SIZE>,
            allocator_slab<U, SLAB_SIZE>
        >::type;
    };

    // Default constructor
    allocator_slab() FL_NOEXCEPT {}

    // Copy constructor
    allocator_slab(const allocator_slab& other) FL_NOEXCEPT {
        FASTLED_UNUSED(other);
    }

    // Copy assignment
    allocator_slab& operator=(const allocator_slab& other) FL_NOEXCEPT {
        FASTLED_UNUSED(other);
        return *this;
    }

    // Template copy constructor
    template <typename U>
    allocator_slab(const allocator_slab<U, SLAB_SIZE>& other) FL_NOEXCEPT {
        FASTLED_UNUSED(other);
    }

    // Destructor
    ~allocator_slab() FL_NOEXCEPT {}

private:
    // Get the shared process-wide allocator instance.
    // Uses a DLL-exported registry to ensure all DLLs in the process share
    // the same SlabAllocator for a given (block_size, slab_size) pair.
    static SlabAllocator<T, SLAB_SIZE>& get_allocator() FL_NOEXCEPT {
        constexpr fl::size block_size = sizeof(T) > sizeof(void*) ? sizeof(T) : sizeof(void*);
        void* ptr = detail::slab_allocator_registry_get(block_size, SLAB_SIZE);
        if (ptr) {
            return *static_cast<SlabAllocator<T, SLAB_SIZE>*>(ptr);
        }
        // First time for this (block_size, slab_size) pair - create and register
        static SlabAllocator<T, SLAB_SIZE> allocator;
        detail::slab_allocator_registry_set(block_size, SLAB_SIZE, &allocator);
        return allocator;