Vector.h

Go to the documentation of this file.

 
#pragma once
 
#include "Iterator.h"
 
// clang-format off
#include <algorithm>        // std::copy, std::move, std::equal, std::lexicographical_compare_three_way
#include <compare>          // std::strong_ordering / operator<=>
#include <concepts>         // std::invocable, std::input_iterator (Listener concept, iterator-pair ctor)
#include <cstddef>          // std::size_t, std::ptrdiff_t
#include <cstdint>          // std::uint8_t (EventType underlying type)
#include <cstring>          // std::memcpy (trivial-type fast path in insert/erase/push_back)
#include <functional>       // std::function (ListenerFn storage)
#include <initializer_list> // std::initializer_list ctor/assign
#include <iterator>         // std::reverse_iterator, iterator tag dispatch
#include <limits>           // std::numeric_limits (overflow checks in growCapacity)
#include <memory>           // std::allocator, std::allocator_traits
#include <optional>         // (reserved: nullable return values)
#include <span>             // std::span (as_span())
#include <stdexcept>        // std::out_of_range, std::length_error
#include <type_traits>      // std::is_trivially_copyable, etc.
#include <utility>          // std::move, std::forward, std::exchange
// clang-format on
 
// A std::vector-like dynamic array with configurable growth policy,
// custom allocator support, and optional modification-event notifications.
// Requires C++20 (concepts, <=>, std::span, [[no_unique_address]]).
 
namespace VectorPro {
 
template <typename F, typename VectorType>
concept Listener = std::invocable<F, const VectorType&, typename VectorType::EventData>;
 
namespace detail {
 
template <typename ListenerFn, bool Enabled> struct ListenerStore {
    ListenerFn* listeners_ = nullptr;
    std::size_t lsize_ = 0;
    std::size_t lcap_ = 0;
};
 
template <typename ListenerFn> struct ListenerStore<ListenerFn, false> {};
 
} // namespace detail
 
template <typename T, typename Allocator = std::allocator<T>, std::size_t GrowthNum = 2,
          std::size_t GrowthDen = 1, bool EnableEvents = false>
    requires std::destructible<T>
class Vector {
  public:
    // Standard container type aliases
    using allocator_type = Allocator;
    using value_type = T;
    using pointer = typename std::allocator_traits<Allocator>::pointer;
    using const_pointer = typename std::allocator_traits<Allocator>::const_pointer;
    using reference = T&;
    using const_reference = const T&;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
 
    // Validates the compile-time growth policy.
    static_assert(GrowthNum != 0, "VectorPro::Vector: GrowthNum must not be zero");
    static_assert(GrowthDen != 0, "VectorPro::Vector: GrowthDen must not be zero");
    static_assert(GrowthNum > GrowthDen,
                  "VectorPro::Vector: GrowthNum must be greater than GrowthDen to ensure growth");
 
    enum class EventType : std::uint8_t {
        PUSHBACK,    
        EMPLACEBACK, 
        POPBACK,     
        INSERT,      
        REMOVE,      
        ERASE,       
        CLEAR,       
        SHRINK,      
        RESERVE      
    };
 
    struct EventData {
        EventType type;      
        std::size_t index;   
        std::size_t oldSize; 
        std::size_t newSize; 
    };
 
    using ListenerFn = std::function<void(const Vector&, EventData)>;
    using ListenerHandle = std::size_t;
 
    // Iterator type aliases.
    using iterator = VectorPro::Iterator<T>;
    using const_iterator = VectorPro::Iterator<const T>;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
  private:
    // Core storage state.
    [[no_unique_address]] Allocator alloc_;
    pointer data_ = nullptr;
    std::size_t vsize_ = 0;
    std::size_t vcap_ = 0;
 
    // Registered event listeners. Empty (zero size) when EnableEvents is false.
    [[no_unique_address]] detail::ListenerStore<ListenerFn, EnableEvents> listenerStore_;
 
    // Default capacity used for the first allocation.
    static constexpr std::size_t INITIAL_CAP = 8;
 
  public:
    explicit Vector(std::size_t count, const T& value = {});
 
    Vector(std::initializer_list<T> init);
 
    template <std::input_iterator It> Vector(It first, It last);
 
    explicit Vector(const Allocator& alloc = Allocator{});
 
    ~Vector() noexcept;
 
    Vector(const Vector& other);
 
    Vector& operator=(const Vector& other);
 
    Vector(Vector&& other) noexcept;
 
    Vector& operator=(Vector&& other) noexcept;
 
    void push_back(const T& value);
 
    void push_back(T&& value);
 
    template <typename... Args>
        requires std::constructible_from<T, Args...>
    void emplace_back(Args&&... args);
 
    [[nodiscard]] iterator insert(const_iterator pos, const T& value);
 
    [[nodiscard]] iterator insert(const_iterator pos, T&& value);
 
    template <std::input_iterator It> iterator insert(const_iterator pos, It first, It last);
 
    template <typename... Args>
        requires std::constructible_from<T, Args...>
    [[nodiscard]] iterator emplace(const_iterator pos, Args&&... args);
 
    template <typename Predicate>
        requires std::predicate<Predicate, const T&>
    [[nodiscard]] std::size_t remove_if(Predicate pred);
 
    void pop_back();
 
    [[nodiscard]] iterator erase(const_iterator pos);
 
    [[nodiscard]] iterator erase(const_iterator first, const_iterator last);
 
    void clear() noexcept;
 
    void reserve(std::size_t newCap);
 
    void shrink_to_fit();
 
    template <typename F>
        requires EnableEvents &&
                 Listener<F, Vector<T, Allocator, GrowthNum, GrowthDen, EnableEvents>>
    [[nodiscard]] ListenerHandle subscribe(F&& listeners);
 
    void unsubscribe(ListenerHandle handle)
        requires EnableEvents;
 
    [[nodiscard]] bool operator==(const Vector& other) const
        noexcept(noexcept(std::declval<const T&>() == std::declval<const T&>()));
 
    [[nodiscard]] auto operator<=>(const Vector& other) const
        noexcept(noexcept(std::declval<const T&>() <=> std::declval<const T&>()));
 
    [[nodiscard]] std::span<T> as_span() noexcept;
    [[nodiscard]] std::span<const T> as_span() const noexcept;
 
    [[nodiscard]] pointer data_ptr() noexcept;
    [[nodiscard]] const_pointer data_ptr() const noexcept;
 
    [[nodiscard]] reference at(std::size_t index);
 
    [[nodiscard]] const_reference at(std::size_t index) const;
 
    [[nodiscard]] reference front();
    [[nodiscard]] const_reference front() const;
 
    [[nodiscard]] reference back();
    [[nodiscard]] const_reference back() const;
 
    [[nodiscard]] reference operator[](std::size_t index) noexcept;
 
    [[nodiscard]] const_reference operator[](std::size_t index) const noexcept;
 
    [[nodiscard]] bool contains(const T& value) const
        noexcept(noexcept(std::declval<const T&>() == std::declval<const T&>()));
 
    [[nodiscard]] iterator find(const T& value) noexcept(noexcept(std::declval<const T&>() ==
                                                                  std::declval<const T&>()));
 
    [[nodiscard]] const_iterator find(const T& value) const
        noexcept(noexcept(std::declval<const T&>() == std::declval<const T&>()));
 
    void swap(Vector& other) noexcept;
 
    [[nodiscard]] bool empty() const noexcept;
    [[nodiscard]] std::size_t size() const noexcept;
    [[nodiscard]] std::size_t capacity() const noexcept;
 
    [[nodiscard]] iterator begin() noexcept;
    [[nodiscard]] iterator end() noexcept;
    [[nodiscard]] const_iterator begin() const noexcept;
    [[nodiscard]] const_iterator end() const noexcept;
    [[nodiscard]] const_iterator cbegin() const noexcept;
    [[nodiscard]] const_iterator cend() const noexcept;
    [[nodiscard]] reverse_iterator rbegin() noexcept;
    [[nodiscard]] reverse_iterator rend() noexcept;
    [[nodiscard]] const_reverse_iterator rbegin() const noexcept;
    [[nodiscard]] const_reverse_iterator rend() const noexcept;
    [[nodiscard]] const_reverse_iterator crbegin() const noexcept;
    [[nodiscard]] const_reverse_iterator crend() const noexcept;
 
  private:
    void release() noexcept;
 
    void copyBufferFrom(const Vector& other);
 
    [[nodiscard]] std::size_t growCapacity() const noexcept;
 
    void reallocate(std::size_t newCap);
 
    void grow_and_push_back(const T& value);
 
    void grow_and_push_back(T&& value);
 
    void notify(EventData data);
};
 
template <typename T, typename Allocator, std::size_t GrowthNum, std::size_t GrowthDen,
          bool EnableEvents>
void swap(Vector<T, Allocator, GrowthNum, GrowthDen, EnableEvents>& a,
          Vector<T, Allocator, GrowthNum, GrowthDen, EnableEvents>& b) noexcept;
 
template <typename T, typename Allocator = std::allocator<T>, std::size_t GrowthNum = 2,
          std::size_t GrowthDen = 1>
using ObservableVector = Vector<T, Allocator, GrowthNum, GrowthDen, true>;
 
} // namespace VectorPro
 
namespace rain {
using namespace VectorPro;
}
 
#include "Vector.tpp"