hxarray.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 hxarray_concept_ = requires(T_& x_) {
    sizeof(T_);
    x_.~T_();
};
#else
#define hxarray_concept_ typename
#endif

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

    using const_iterator = const T_*;

    using value_t = T_;

    explicit hxarray(void) noexcept;

    explicit hxarray(const T_& x_) noexcept;

    hxarray(const hxarray& x_) noexcept;

    hxarray(hxarray&& x_) noexcept;

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

    template<typename other_value_t_>
    hxarray(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_>, hxarray<T_, capacity_> >())
    explicit hxarray(range_t_& range_) noexcept;

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

    ~hxarray(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 hxarray& x_) noexcept;

    void operator=(hxarray&& 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_);

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

    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 this->data() + this->capacity(); }

    using hxallocator<T_, capacity_>::data;

    hxinline hxattr_nodiscard bool empty(void) const { return this->size() == 0; }

    const T_* end(void) const { return this->data() + this->capacity(); }
 
    T_* end(void) { return this->data() + this->capacity(); }

    hxattr_nodiscard bool equal(const hxarray& x_) const;

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

    hxinline hxattr_nodiscard bool full(void) const { return this->capacity() != 0; }

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

    hxattr_nodiscard hxhash_t hash(void) const;

    void insertion_sort(void) noexcept;

    hxattr_nodiscard bool less(const hxarray& x_) const;

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

    void memcpy(const hxarray& 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 reserve(hxsize_t size_,
            hxsystem_allocator_t allocator_=hxsystem_allocator_current,
            hxalignment_t alignment_=hxalignment) noexcept;

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

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

    void sort(void) noexcept;

    void swap(hxarray& 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;
};

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

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

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