Class deque

src/fl/stl/deque.h:14–777

template <typename T>
class deque {
private:
    T* mData = nullptr;
    fl::size mCapacity = 0;
    fl::size mSize = 0;
    fl::size mFront = 0;  // Index of the front element
    memory_resource* mResource = default_memory_resource();

    static const fl::size kInitialCapacity = 8;

    void ensure_capacity(fl::size min_capacity) {
        if (mCapacity >= min_capacity) {
            return;
        }

        fl::size new_capacity = mCapacity == 0 ? kInitialCapacity : mCapacity * 2;
        while (new_capacity < min_capacity) {
            new_capacity *= 2;
        }

        T* new_data = static_cast<T*>(mResource->allocate(new_capacity * sizeof(T)));
        if (!new_data) {
            return; // Allocation failed
        }

        // Copy existing elements to new buffer in linear order
        for (fl::size i = 0; i < mSize; ++i) {
            fl::size old_idx = (mFront + i) % mCapacity;
            new (&new_data[i]) T(fl::move(mData[old_idx]));
            mData[old_idx].~T();
        }

        if (mData) {
            mResource->deallocate(mData, mCapacity * sizeof(T));
        }

        mData = new_data;
        mCapacity = new_capacity;
        mFront = 0; // Reset front to 0 after reallocation
    }

    fl::size get_index(fl::size logical_index) const {
        return (mFront + logical_index) % mCapacity;
    }

public:
    // Iterator implementation (RandomAccessIterator)
    class iterator {
    public:
        typedef T value_type;
        typedef T& reference;
        typedef T* pointer;
        typedef fl::size difference_type;
        typedef fl::random_access_iterator_tag iterator_category;

    private:
        deque* mDeque;
        fl::size mIndex;