hxvector.hpp

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: © 2017-2026 Adrian Johnston.
// SPDX-License-Identifier: MIT
// This file is licensed under the MIT license found in the LICENSE.md file.

 
#include "libhatchet.h"
 
// HX_USE_MACROS_WITH_MODULE allows including macros alongside the module.
#if HX_USE_MACROS_WITH_MODULE
#error Header does not provide macros alone.
#endif
 
#include "hxallocator.hpp"
#include "hxsort.hpp"
#include "hxinitializer_list.hpp"
 
HX_NS_BEGIN_
 
#if HX_CPLUSPLUS >= 202002L

template<typename T_>
concept hxvector_concept_ = requires(T_& x_) {
    sizeof(T_);
    { x_.~T_() };
};
#else
#define hxvector_concept_ typename
#endif

// Internal. Extends the array using placement new when assigned to.
template<typename array_t_>
class hxarray_back_inserter_ {
public:
    // Internal. Extends the array using placement new when assigned to.
    template<typename arg_t_>
    typename array_t_::value_type& operator=(arg_t_&& arg_) {
        return m_x_.push_back(hxforward<arg_t_>(arg_));
    }
private:
    friend array_t_;
    hxarray_back_inserter_(array_t_& x_) : m_x_(x_) { }
#if HX_CPLUSPLUS >= 201703L
    // Copy elision is C++17.
    hxarray_back_inserter_(const hxarray_back_inserter_& x_) = delete;
#endif
    // No address-of operator. It wouldn't be what was expected.
    void operator&(void) const = delete;
    array_t_& m_x_;
};

template<hxvector_concept_ T_, hxsize_t capacity_=hxallocator_dynamic_capacity>
class hxvector : private hxallocator<T_, capacity_> {
public:
    using iterator = T_*;

    using const_iterator = const T_*;

    using value_type = T_;

    explicit hxvector(void);

    explicit hxvector(hxsize_t size_) noexcept;

    explicit hxvector(hxsize_t size_, const T_& x_) noexcept;

    hxvector(const hxvector& x_) noexcept;

    template <hxsize_t capacity_x_>
    hxvector(const hxvector<T_, capacity_x_>& x_) noexcept;

    hxvector(hxvector&& x_) noexcept;

    template<typename other_value_t_, hxsize_t array_length_>
    hxvector(const other_value_t_(&array_)[array_length_]) noexcept;

    template <typename other_value_t_>
    hxvector(std::initializer_list<other_value_t_> x_) noexcept;

    ~hxvector(void) noexcept;

    void operator=(const hxvector& x_) noexcept;

    template <hxsize_t capacity_x_>
    void operator=(const hxvector<T_, capacity_x_>& x_) noexcept;

    void operator=(hxvector&& x_) noexcept;

    template<typename other_value_t_, hxsize_t array_length_>
    void operator=(const other_value_t_(&array_)[array_length_]) noexcept;

    const T_& operator[](hxsize_t index_) const;

    T_& operator[](hxsize_t index_);

    void operator+=(const T_& x_) noexcept;

    void operator+=(T_&& x_) noexcept;

    template <hxsize_t capacity_x_>
    void operator+=(const hxvector<T_, capacity_x_>& x_) noexcept;

    template <hxsize_t capacity_x_>
    void operator+=(hxvector<T_, capacity_x_>&& x_) noexcept;

    hxarray_back_inserter_<hxvector<T_, capacity_>> operator*(void);

    hxvector& operator++(void) { return *this; }

    hxvector& operator++(int) { return *this; }

    template<typename callable_t_>
    hxattr_nodiscard bool all_of(callable_t_&& callable_) const;

    template<typename callable_t_>
    bool all_of(callable_t_&& callable_);

    template<typename callable_t_>
    hxattr_nodiscard bool any_of(callable_t_&& callable_) const;

    template<typename callable_t_>
    bool any_of(callable_t_&& callable_);

    template <typename iter_t_>
    void assign(iter_t_ begin_, iter_t_ end_) noexcept;
 
#if HX_CPLUSPLUS >= 202002L
    template <typename range_t_>
    void assign_range(range_t_& range_) noexcept;

    template <typename range_t_>
    requires(!hxis_lvalue_reference<range_t_>::value)
    void assign_range(range_t_&& range_) noexcept;
#endif

    const T_& back(void) const;

    T_& back(void);

    const T_* begin(void) const { return this->data(); }

    T_* begin(void) { return this->data(); }

    hxattr_nodiscard const T_* binary_search(const T_& value_) const;

    hxattr_nodiscard T_* binary_search(const T_& value_);

    hxattr_nodiscard hxsize_t capacity(void) const;

    const T_* cbegin(void) const { return this->data(); }

    const T_* cend(void) const { return m_end_; }

    void clear(void) noexcept;

    using hxallocator<T_, capacity_>::data;

    template<typename... args_t_>
    T_& emplace_back(args_t_&&... args_) noexcept;

    template<hxsize_t capacity_x_>
    hxattr_nodiscard bool equal(const hxvector<T_, capacity_x_>& x_) const;

    hxattr_nodiscard bool empty(void) const { return m_end_ == this->data(); }

    const T_* end(void) const { return m_end_; }

    T_* end(void) { return m_end_; }

    void erase(T_* pos_) noexcept hxattr_nonnull(2);

    void erase(hxsize_t index_) noexcept;

    template<typename callable_t_>
    hxsize_t erase_if_unordered(callable_t_&& callable_) noexcept;

    template<typename callable_t_>
    hxsize_t erase_if_heap(callable_t_&& callable_) noexcept;

    void erase_unordered(const T_* pos_) noexcept hxattr_nonnull(2);

    void erase_unordered(hxsize_t index_) noexcept;

    hxattr_nodiscard const T_* find(const T_& value_) const;

    hxattr_nodiscard T_* find(const T_& value_);

    template<typename callable_t_>
    hxattr_nodiscard const T_* find_if(callable_t_&& callable_) const;

    template<typename callable_t_>
    hxattr_nodiscard T_* find_if(callable_t_&& callable_);

    template<typename callable_t_>
    void for_each(callable_t_&& callable_) const;

    template<typename callable_t_>
    void for_each(callable_t_&& callable_);

    const T_& front(void) const;

    T_& front(void);

    hxattr_nodiscard bool full(void) const { return m_end_ == this->data() + this->capacity(); }

    template<typename callable_t_>
    void generate_n(hxsize_t size_, callable_t_&& callable_) noexcept;

    hxattr_nodiscard const T_* get(hxsize_t index_) const;

    hxattr_nodiscard T_* get(hxsize_t index_);

    template<typename ref_t_>
    void insert(const T_* pos_, ref_t_&& x_) noexcept hxattr_nonnull(2);

    template<typename ref_t_>
    void insert(hxsize_t index_, ref_t_&& x_) noexcept;

    void insertion_sort(void) noexcept;

    template<hxsize_t capacity_x_>
    hxattr_nodiscard bool less(const hxvector<T_, capacity_x_>& x_) const;

    void make_heap(void) noexcept;

    hxattr_nodiscard hxsize_t max_size(void) const { return this->capacity(); }

    template <hxsize_t capacity_x_>
    void memcpy(const hxvector<T_, capacity_x_>& x_);

    void memset(int byte_=0x00);

    void pop_back(void) noexcept;

    void pop_heap(void) noexcept;

    template<typename... args_t_>
    T_& push_back(args_t_&&... args_) noexcept;

    template<typename ref_t_>
    T_& push_heap(ref_t_&& arg_) noexcept;

    void reserve(hxsize_t size_,
            hxsystem_allocator_t allocator_=hxsystem_allocator_current,
            hxalignment_t alignment_=hxalignment);

    void resize(hxsize_t size_) noexcept;

    void resize(hxsize_t size_, const T_& x_) noexcept;

    hxattr_nodiscard hxsize_t size(void) const { return m_end_ - this->data(); }

    hxattr_nodiscard hxsize_t size_bytes(void) const { return hxsizeof<T_>() * this->size(); }

    void sort(void) noexcept;

    void swap(hxvector& x_) noexcept;
 
private:
    void destruct_(T_* begin_, T_* end_) noexcept;
    void* push_back_unconstructed_(void);
 
    T_* m_end_;
};
 
// Without the "requires" keyword these end up being ambiguous.
#if HX_CPLUSPLUS >= 202002L

template<typename T_, hxsize_t capacity_x_, hxsize_t capacity_y_>
hxinline hxattr_flatten bool hxkey_equal(const hxvector<T_, capacity_x_>& x_,
        const hxvector<T_, capacity_y_>& y_) {
    return x_.equal(y_);
}

template<typename T_, hxsize_t capacity_x_, hxsize_t capacity_y_>
hxinline hxattr_flatten bool hxkey_less(const hxvector<T_, capacity_x_>& x_,
        const hxvector<T_, capacity_y_>& y_) {
    return x_.less(y_);
}

template<typename T_>
hxinline hxattr_flatten void hxswap(hxvector<T_, hxallocator_dynamic_capacity>& x_,
        hxvector<T_, hxallocator_dynamic_capacity>& y_) noexcept {
    hxswap_memcpy(x_, y_);
}
 
#endif // HX_CPLUSPLUS >= 202002L
#include "detail/hxvector.inl"
HX_NS_END_