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 "hxrange.hpp"
#include "hxinitializer_list.hpp"
#include "hxsort.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_t& 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_t = 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;
 
#if HX_CPLUSPLUS >= 202002L
    template<hxrange_concept_ range_t_>
    requires(!hxis_same<hxremove_cvref_t<range_t_>, hxvector<T_, capacity_> >())
    explicit hxvector(range_t_& range_) noexcept;

    template<hxrange_concept_ range_t_>
    requires(!hxis_lvalue_reference<range_t_>()
            && !hxis_same<hxremove_cvref_t<range_t_>, hxvector<T_, capacity_> >())
    explicit hxvector(range_t_&& range_) noexcept;
#endif

    ~hxvector(void) noexcept;
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto and_then(
        this self_t_&& self_, hxsize_t index_, callable_t_&& callable_)
        -> hxremove_cvref_t<decltype(
            hxforward<callable_t_>(callable_)(
                hxforward_like<self_t_>(hxdeclval<T_&>())))>;

    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto and_then(
        this self_t_&& self_, const T_* it_, callable_t_&& callable_)
        -> hxremove_cvref_t<decltype(
            hxforward<callable_t_>(callable_)(hxforward_like<self_t_>(
                hxdeclval<const T_&>())))>;
#endif // HX_CPLUSPLUS >= 202302L

    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<hxrange_concept_ range_t_>
    void add_range(range_t_& range_) noexcept;

    template<hxrange_concept_ range_t_,
        hxenable_if_t<!hxis_lvalue_reference<range_t_>(), int> = 0>
    void add_range(range_t_&& range_) noexcept;

    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;

    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;

    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_; }

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

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

    void erase(hxsize_t index_) noexcept;

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

    void erase_unordered(const T_* it_) 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 hxhash_t hash(void) const;

    template<typename ref_t_>
    void insert(const T_* it_, 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);
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto or_else(
        this self_t_&& self_, hxsize_t index_, callable_t_&& callable_)
        -> decltype(self_.end());

    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto or_else(
        this self_t_&& self_, const T_* it_, callable_t_&& callable_)
        -> decltype(self_.end());
#endif // HX_CPLUSPLUS >= 202302L

    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;
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename... args_t_>
    hxattr_nodiscard T_ value_or(
        this self_t_&& self_, hxsize_t index_, args_t_&&... args_);

    template<typename self_t_, typename... args_t_>
    hxattr_nodiscard T_ value_or(
        this self_t_&& self_, const T_* it_, args_t_&&... args_);
#endif // HX_CPLUSPLUS >= 202302L
 
private:
    void destruct_(T_* begin_, T_* end_) noexcept;
    void* push_back_unconstructed_(void);
 
    T_* m_end_;
};

template<typename T_, hxsize_t capacity_x_>
class hxkey_equal_t<hxvector<T_, capacity_x_> > {
public:
    template<hxsize_t capacity_y_>
    hxattr_nodiscard hxinline hxattr_flatten
    bool operator()(
            const hxvector<T_, capacity_x_>& x_, const hxvector<T_, capacity_y_>& y_) const {
        return x_.equal(y_);
    }
};

template<typename T_, hxsize_t capacity_x_>
class hxkey_less_t<hxvector<T_, capacity_x_> > {
public:
    template<hxsize_t capacity_y_>
    hxattr_nodiscard hxinline hxattr_flatten
    bool operator()(
            const hxvector<T_, capacity_x_>& x_, const hxvector<T_, capacity_y_>& y_) const {
        return x_.less(y_);
    }
};

template<typename T_, hxsize_t capacity_x_>
class hxkey_hash_t<hxvector<T_, capacity_x_> > {
public:
    hxattr_nodiscard hxinline hxattr_flatten
    hxhash_t operator()(const hxvector<T_, capacity_x_>& x_) const { return x_.hash(); }
};
 
#include "detail/hxvector.inl"
HX_NS_END_