Class vector_basic

src/fl/stl/basic_vector.h:39–186

Type-erased vector base class. Holds all vector logic. vector inherits this and provides the element type info. VectorN inherits vector and provides the inline buffer. This class cannot be constructed directly — only through vector .

/// VectorN<T, N> inherits vector<T> and provides the inline buffer.
/// This class cannot be constructed directly — only through vector<T>.
class vector_basic {
  public:
    // ======= CAPACITY =======
    fl::size size() const FL_NOEXCEPT { return mSize; }
    bool empty() const FL_NOEXCEPT { return mSize == 0; }
    fl::size capacity() const FL_NOEXCEPT { return mCapacity; }
    bool full() const FL_NOEXCEPT { return mSize >= mCapacity; }
    fl::size element_size() const FL_NOEXCEPT { return mElementSize; }

    // ======= RAW DATA ACCESS =======
    void* data_raw() FL_NOEXCEPT { return mArray; }
    const void* data_raw() const FL_NOEXCEPT { return mArray; }

    // ======= MEMORY MANAGEMENT =======
    void reserve_impl(fl::size n) FL_NOEXCEPT;
    void shrink_to_fit_impl() FL_NOEXCEPT;

    // ======= ELEMENT OPERATIONS =======
    void push_back_copy_impl(const void* element) FL_NOEXCEPT;
    void push_back_move_impl(void* element) FL_NOEXCEPT;
    void pop_back_impl() FL_NOEXCEPT;
    void clear_impl() FL_NOEXCEPT;

    /// Erase element at index. Shifts subsequent elements left.
    void erase_impl(fl::size index) FL_NOEXCEPT;

    /// Erase range [first_index, first_index + count).
    void erase_range_impl(fl::size first_index, fl::size count) FL_NOEXCEPT;

    /// Insert element at index by copy. Shifts subsequent elements right.
    void insert_copy_impl(fl::size index, const void* element) FL_NOEXCEPT;

    /// Insert element at index by move. Shifts subsequent elements right.
    void insert_move_impl(fl::size index, void* element) FL_NOEXCEPT;

    /// Resize to n elements. New elements are default-constructed (zeroed for trivial).
    void resize_impl(fl::size n) FL_NOEXCEPT;

    /// Resize to n elements. New elements are copy-constructed from value.
    void resize_value_impl(fl::size n, const void* value) FL_NOEXCEPT;

    /// Swap contents with another vector_basic.
    void swap_impl(vector_basic& other) FL_NOEXCEPT;

    // ======= DESTRUCTOR =======
    ~vector_basic() FL_NOEXCEPT;

  protected:
    // ======= CONSTRUCTION (only callable by vector<T>) =======

    /// Heap-only vector (no inline buffer).
    vector_basic(fl::size elementSize, memory_resource* resource,
                 const vector_element_ops* ops) FL_NOEXCEPT
        : mElementSize(elementSize)
        , mResource(resource)
        , mOps(ops)
        , mInlineOffset(0)
        , mInlineCapacity(0) {}