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 "hxsort.hpp"
#include "hxinitializer_list.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_type = 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;

    ~hxarray(void) noexcept;

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

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

    hxattr_nodiscard bool equal(const hxarray& x_) const;

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

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

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

    hxattr_nodiscard const T_* get(hxsize_t index_) const;

    hxattr_nodiscard T_* get(hxsize_t index_);

    void insertion_sort(void) noexcept;

    hxattr_nodiscard bool less(const hxarray& x_) const;

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

    void memcpy(const hxarray& x_);

    void memset(int byte_=0x00);

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

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

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

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

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

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

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