basic_vector.h

Go to the documentation of this file.

#pragma once

 
#include "fl/stl/int.h"
#include "fl/stl/cstring.h"
#include "fl/stl/compiler_control.h"
#include "fl/stl/memory_resource.h"
#include "fl/stl/noexcept.h"
 
namespace fl {

struct vector_element_ops {
    void (*copy_construct)(void* dst, const void* src);
    void (*move_construct)(void* dst, void* src);
    void (*default_construct)(void* ptr);
    void (*swap_elements)(void* a, void* b);

    void (*destroy_n)(void* first, fl::size count);
};

class vector_basic {
  public:
    // ======= CAPACITY =======
    fl::size size() const FL_NO_EXCEPT { return mSize; }
    bool empty() const FL_NO_EXCEPT { return mSize == 0; }
    fl::size capacity() const FL_NO_EXCEPT { return mCapacity; }
    bool full() const FL_NO_EXCEPT { return mSize >= mCapacity; }
    fl::size element_size() const FL_NO_EXCEPT { return mElementSize; }
 
    // ======= RAW DATA ACCESS =======
    void* data_raw() FL_NO_EXCEPT { return mArray; }
    const void* data_raw() const FL_NO_EXCEPT { return mArray; }
 
    // ======= MEMORY MANAGEMENT =======
    void reserve_impl(fl::size n) FL_NO_EXCEPT;
    void shrink_to_fit_impl() FL_NO_EXCEPT;
 
    // ======= ELEMENT OPERATIONS =======
    void push_back_copy_impl(const void* element) FL_NO_EXCEPT;
    void push_back_move_impl(void* element) FL_NO_EXCEPT;
    void pop_back_impl() FL_NO_EXCEPT;
    void clear_impl() FL_NO_EXCEPT;

    void erase_impl(fl::size index) FL_NO_EXCEPT;

    void erase_range_impl(fl::size first_index, fl::size count) FL_NO_EXCEPT;

    void insert_copy_impl(fl::size index, const void* element) FL_NO_EXCEPT;

    void insert_move_impl(fl::size index, void* element) FL_NO_EXCEPT;

    void resize_impl(fl::size n) FL_NO_EXCEPT;

    void resize_value_impl(fl::size n, const void* value) FL_NO_EXCEPT;

    void swap_impl(vector_basic& other) FL_NO_EXCEPT;
 
    // ======= DESTRUCTOR =======
    ~vector_basic() FL_NO_EXCEPT;
 
  protected:
    // ======= CONSTRUCTION (only callable by vector<T>) =======

    vector_basic(fl::size elementSize, memory_resource* resource,
                 const vector_element_ops* ops) FL_NO_EXCEPT
        : mElementSize(elementSize)
        , mResource(resource)
        , mOps(ops)
        , mInlineOffset(0)
        , mInlineCapacity(0) {}

    vector_basic(void* inlineBuffer, fl::size inlineCapacity,
                 fl::size elementSize, memory_resource* resource,
                 const vector_element_ops* ops)
 FL_NO_EXCEPT : mElementSize(elementSize)
        , mResource(resource)
        , mOps(ops)
        , mInlineOffset(static_cast<fl::size>(
              static_cast<char*>(inlineBuffer) -
              static_cast<char*>(static_cast<void*>(this))))
        , mInlineCapacity(inlineCapacity) {
        // Start with data in inline buffer
        mArray = inlineBuffer;
        mCapacity = inlineCapacity;
    }
 
    // Deleted copy/move — vector<T> handles these
    vector_basic(const vector_basic&) FL_NO_EXCEPT = delete;
    vector_basic(vector_basic&&) FL_NO_EXCEPT = delete;
    vector_basic& operator=(const vector_basic&) FL_NO_EXCEPT = delete;
    vector_basic& operator=(vector_basic&&) FL_NO_EXCEPT = delete;
 
    // ======= HELPERS FOR DERIVED CLASSES =======

    void copy_from(const vector_basic& other) FL_NO_EXCEPT;

    void move_from(vector_basic& other) FL_NO_EXCEPT;

    void move_assign(vector_basic& other) FL_NO_EXCEPT;
 
    // ======= DATA MEMBERS =======
    void* mArray = nullptr;
    fl::size mSize = 0;
    fl::size mCapacity = 0;
    fl::size mElementSize;
    memory_resource* mResource;
    const vector_element_ops* mOps;  // nullptr → trivially copyable
 
    // Inline buffer support (offset trick from basic_string).
    // Store offset from `this` to the inline buffer, not a raw pointer.
    // This survives trivial relocation (bitwise copy by containers) because
    // the offset is relative to `this` which updates with the object.
    fl::size mInlineOffset;
    fl::size mInlineCapacity;  // 0 = no inline buffer
 
    // ======= HELPER METHODS =======

    void* inlineBufferPtr() FL_NO_EXCEPT {
        return static_cast<char*>(static_cast<void*>(this)) + mInlineOffset;
    }
    const void* inlineBufferPtr() const FL_NO_EXCEPT {
        return static_cast<const char*>(static_cast<const void*>(this)) + mInlineOffset;
    }

    bool isInline() const FL_NO_EXCEPT {
        return mInlineCapacity > 0 && mArray == inlineBufferPtr();
    }

    bool hasInlineBuffer() const FL_NO_EXCEPT {
        return mInlineCapacity > 0;
    }

    void* element_ptr(fl::size index) FL_NO_EXCEPT {
        return static_cast<char*>(mArray) + index * mElementSize;
    }
    const void* element_ptr(fl::size index) const FL_NO_EXCEPT {
        return static_cast<const char*>(mArray) + index * mElementSize;
    }
 
  private:
    void ensure_capacity(fl::size n) FL_NO_EXCEPT;

    void grow_to(fl::size new_capacity) FL_NO_EXCEPT;
    void uninitialized_move_n_impl(void* dst, void* src, fl::size count) const FL_NO_EXCEPT;
 
    // ======= TRIVIAL ELEMENT HELPERS (memcpy/memmove) =======
    void trivial_copy(void* dst, const void* src, fl::size count) const FL_NO_EXCEPT;
    void trivial_move_left(void* dst, const void* src, fl::size count) const FL_NO_EXCEPT;
    void trivial_default_construct(void* ptr, fl::size count) const FL_NO_EXCEPT;
    void trivial_swap(void* a, void* b) const FL_NO_EXCEPT;
};
 
// ======= OPS TABLE HELPERS =======
 
namespace detail {
 
// SFINAE: detect if T is default-constructible
template <typename T, typename = void>
struct has_default_ctor : fl::false_type {};
 
template <typename T>
struct has_default_ctor<T, decltype(void(T()))> : fl::true_type {};
 
// SFINAE: detect if T is copy-constructible
template <typename T, typename = void>
struct has_copy_ctor : fl::false_type {};
 
template <typename T>
struct has_copy_ctor<T, decltype(void(T(fl::declval<const T&>())))> : fl::true_type {};
 
// Default construct: available when T has default ctor
template <typename T>
void vector_default_construct(void* ptr) FL_NO_EXCEPT {
    new (ptr) T();
}
 
template <typename T>
constexpr typename fl::enable_if<has_default_ctor<T>::value, void(*)(void*)>::type
get_default_construct_fn() FL_NO_EXCEPT {
    return &vector_default_construct<T>;
}
 
// Default construct: nullptr when T has no default ctor
template <typename T>
constexpr typename fl::enable_if<!has_default_ctor<T>::value, void(*)(void*)>::type
get_default_construct_fn() FL_NO_EXCEPT {
    return nullptr;
}
 
// Copy construct: available when T has copy ctor
template <typename T>
void vector_copy_construct(void* dst, const void* src) FL_NO_EXCEPT {
    new (dst) T(*static_cast<const T*>(src));
}
 
template <typename T>
constexpr typename fl::enable_if<has_copy_ctor<T>::value, void(*)(void*, const void*)>::type
get_copy_construct_fn() FL_NO_EXCEPT {
    return &vector_copy_construct<T>;
}
 
// Copy construct: nullptr when T is not copyable
template <typename T>
constexpr typename fl::enable_if<!has_copy_ctor<T>::value, void(*)(void*, const void*)>::type
get_copy_construct_fn() FL_NO_EXCEPT {
    return nullptr;
}
 
// SFINAE: detect if T is move-constructible
template <typename T, typename = void>
struct has_move_ctor : fl::false_type {};
 
template <typename T>
struct has_move_ctor<T, decltype(void(T(fl::declval<T&&>())))> : fl::true_type {};
 
// SFINAE: detect if T is swappable (needs move-constructible + move-assignable)
template <typename T, typename = void>
struct is_swappable : fl::false_type {};
 
template <typename T>
struct is_swappable<T, decltype(void(
    fl::declval<T&>() = fl::declval<T&&>()
))> : has_move_ctor<T> {};
 
// Move construct: available
template <typename T>
void vector_move_construct(void* dst, void* src) FL_NO_EXCEPT {
    new (dst) T(static_cast<T&&>(*static_cast<T*>(src)));
}
 
template <typename T>
constexpr typename fl::enable_if<has_move_ctor<T>::value, void(*)(void*, void*)>::type
get_move_construct_fn() FL_NO_EXCEPT {
    return &vector_move_construct<T>;
}
 
template <typename T>
constexpr typename fl::enable_if<!has_move_ctor<T>::value, void(*)(void*, void*)>::type
get_move_construct_fn() FL_NO_EXCEPT {
    return nullptr;
}
 
// Swap: available when swappable
template <typename T>
void vector_swap_elements(void* a, void* b) FL_NO_EXCEPT {
    T& ta = *static_cast<T*>(a);
    T& tb = *static_cast<T*>(b);
    T tmp(static_cast<T&&>(ta));
    ta = static_cast<T&&>(tb);
    tb = static_cast<T&&>(tmp);
}
 
template <typename T>
constexpr typename fl::enable_if<is_swappable<T>::value, void(*)(void*, void*)>::type
get_swap_fn() FL_NO_EXCEPT {
    return &vector_swap_elements<T>;
}
 
template <typename T>
constexpr typename fl::enable_if<!is_swappable<T>::value, void(*)(void*, void*)>::type
get_swap_fn() FL_NO_EXCEPT {
    return nullptr;
}
 
template <typename T>
void vector_destroy_n(void* first, fl::size count) FL_NO_EXCEPT {
    T* p = static_cast<T*>(first);
    for (fl::size i = 0; i < count; ++i) {
        p[i].~T();
    }
}
 
} // namespace detail
 
// ======= OPS TABLE GENERATOR =======

template <typename T>
const vector_element_ops* vector_element_ops_for() FL_NO_EXCEPT {
    // Trivially copyable types use the fast path (mOps == nullptr)
    if (fl::is_trivially_copyable<T>::value) {
        return nullptr;
    }
 
    static constexpr vector_element_ops ops = {
        detail::get_copy_construct_fn<T>(),       // copy_construct
        detail::get_move_construct_fn<T>(),       // move_construct
        detail::get_default_construct_fn<T>(),    // default_construct
        detail::get_swap_fn<T>(),                 // swap_elements
        &detail::vector_destroy_n<T>              // destroy_n
    };
    return &ops;
}
 
} // namespace fl