Class allocator_inlined

src/fl/stl/allocator.h:805–1040

// Falls back to the base allocator for additional elements
template <typename T, fl::size N, typename BaseAllocator = fl::allocator<T>>
class allocator_inlined {
private:

    // Inlined storage block
    struct InlinedStorage {
        FL_ALIGN_AS(T) u8 data[N * sizeof(T)];
        
        InlinedStorage() FL_NOEXCEPT {
            fl::memset(data, 0, sizeof(data));
        }
    };
    
    InlinedStorage mInlinedStorage;
    BaseAllocator mBaseAllocator;
    fl::size mInlinedUsed = 0;
    fl::bitset_fixed<N> mFreeBits;  // Track free slots for inlined memory only
    fl::size mActiveAllocations = 0;  // Track current active allocations

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 = allocator_inlined<U, N, typename BaseAllocator::template rebind<U>::other>;
    };

    // Default constructor
    allocator_inlined() FL_NOEXCEPT = default;

    // Copy constructor
    allocator_inlined(const allocator_inlined& other) FL_NOEXCEPT {
        // Copy inlined data
        mInlinedUsed = other.mInlinedUsed;
        for (fl::size i = 0; i < mInlinedUsed; ++i) {
            new (&get_inlined_ptr()[i]) T(other.get_inlined_ptr()[i]);
        }
        
        // Copy free bits
        mFreeBits = other.mFreeBits;
        
        // Note: Heap allocations are not copied, only inlined data
        
        // Copy active allocations count
        mActiveAllocations = other.mActiveAllocations;
    }

    // Copy assignment
    allocator_inlined& operator=(const allocator_inlined& other) FL_NOEXCEPT {
        if (this != &other) {
            clear();