array.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_ARRAY_ARRAY_HPP
#define TETL_ARRAY_ARRAY_HPP
 
#include <etl/_config/all.hpp>
 
#include <etl/_algorithm/equal.hpp>
#include <etl/_algorithm/fill_n.hpp>
#include <etl/_algorithm/lexicographical_compare.hpp>
#include <etl/_algorithm/swap_ranges.hpp>
#include <etl/_array/c_array.hpp>
#include <etl/_contracts/check.hpp>
#include <etl/_cstddef/size_t.hpp>
#include <etl/_iterator/begin.hpp>
#include <etl/_iterator/data.hpp>
#include <etl/_iterator/end.hpp>
#include <etl/_iterator/prev.hpp>
#include <etl/_iterator/rbegin.hpp>
#include <etl/_iterator/rend.hpp>
#include <etl/_iterator/reverse_iterator.hpp>
#include <etl/_iterator/size.hpp>
#include <etl/_tuple/is_tuple_like.hpp>
#include <etl/_tuple/tuple_element.hpp>
#include <etl/_tuple/tuple_size.hpp>
#include <etl/_type_traits/conditional.hpp>
#include <etl/_type_traits/is_nothrow_swappable.hpp>
#include <etl/_type_traits/remove_cv.hpp>
#include <etl/_utility/index_sequence.hpp>
#include <etl/_utility/move.hpp>
#include <etl/_utility/unreachable.hpp>
 
namespace etl {
template <typename Type, size_t Size>
struct array {
    using value_type             = Type;
    using size_type              = size_t;
    using difference_type        = ptrdiff_t;
    using pointer                = Type*;
    using const_pointer          = Type const*;
    using reference              = Type&;
    using const_reference        = Type const&;
    using iterator               = Type*;
    using const_iterator         = Type const*;
    using reverse_iterator       = typename etl::reverse_iterator<iterator>;
    using const_reverse_iterator = typename etl::reverse_iterator<const_iterator>;

    [[nodiscard]] constexpr auto operator[](size_type const pos) noexcept -> reference
    {
        if constexpr (Size == 0) {
            etl::unreachable();
        } else {
            TETL_PRECONDITION_SAFE(pos < Size);
            return _buf[pos];
        }
    }

    [[nodiscard]] constexpr auto operator[](size_type const pos) const noexcept -> const_reference
    {
        if constexpr (Size == 0) {
            etl::unreachable();
        } else {
            TETL_PRECONDITION_SAFE(pos < Size);
            return _buf[pos];
        }
    }

    [[nodiscard]] constexpr auto front() noexcept -> reference { return *begin(); }

    [[nodiscard]] constexpr auto front() const noexcept -> const_reference { return *begin(); }

    [[nodiscard]] constexpr auto back() noexcept -> reference { return *etl::prev(end()); }

    [[nodiscard]] constexpr auto back() const noexcept -> const_reference { return *etl::prev(end()); }

    [[nodiscard]] constexpr auto data() noexcept -> pointer { return begin(); }

    [[nodiscard]] constexpr auto data() const noexcept -> const_pointer { return begin(); }

    [[nodiscard]] constexpr auto begin() noexcept -> iterator
    {
        if constexpr (Size == 0) {
            return nullptr;
        } else {
            return etl::begin(_buf);
        }
    }

    [[nodiscard]] constexpr auto begin() const noexcept -> const_iterator
    {
        if constexpr (Size == 0) {
            return nullptr;
        } else {
            return etl::begin(_buf);
        }
    }

    [[nodiscard]] constexpr auto cbegin() const noexcept -> const_iterator { return begin(); }

    [[nodiscard]] constexpr auto end() noexcept -> iterator
    {
        if constexpr (Size == 0) {
            return nullptr;
        } else {
            return etl::end(_buf);
        }
    }

    [[nodiscard]] constexpr auto end() const noexcept -> const_iterator
    {
        if constexpr (Size == 0) {
            return nullptr;
        } else {
            return etl::end(_buf);
        }
    }

    [[nodiscard]] constexpr auto cend() const noexcept -> const_iterator { return end(); }

    [[nodiscard]] constexpr auto rbegin() noexcept -> reverse_iterator { return reverse_iterator(end()); }

    [[nodiscard]] constexpr auto rbegin() const noexcept -> const_reverse_iterator
    {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] constexpr auto crbegin() const noexcept -> const_reverse_iterator { return rbegin(); }

    [[nodiscard]] constexpr auto rend() noexcept -> reverse_iterator { return reverse_iterator(begin()); }

    [[nodiscard]] constexpr auto rend() const noexcept -> const_reverse_iterator
    {
        return const_reverse_iterator(begin());
    }

    [[nodiscard]] constexpr auto crend() const noexcept -> const_reverse_iterator { return rend(); }

    [[nodiscard]] constexpr auto empty() const noexcept -> bool { return begin() == end(); }

    [[nodiscard]] constexpr auto size() const noexcept -> size_type { return Size; }

    [[nodiscard]] constexpr auto max_size() const noexcept -> size_type { return Size; }

    constexpr auto fill(const_reference value) -> void { etl::fill_n(begin(), Size, value); }

    constexpr auto swap(array& other) noexcept(is_nothrow_swappable_v<Type>) -> void
    {
        etl::swap_ranges(begin(), end(), other.begin());
    }

    friend constexpr auto swap(array& lhs, array& rhs) noexcept(noexcept(lhs.swap(rhs))) -> void { lhs.swap(rhs); }

    friend constexpr auto operator==(array const& lhs, array const& rhs) -> bool
    {
        return etl::equal(lhs.begin(), lhs.end(), rhs.begin());
    }

    friend constexpr auto operator<(array const& lhs, array const& rhs) -> bool
    {
        return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
    }
 
    friend constexpr auto operator<=(array const& lhs, array const& rhs) -> bool { return !(rhs < lhs); }
 
    friend constexpr auto operator>(array const& lhs, array const& rhs) -> bool { return rhs < lhs; }
 
    friend constexpr auto operator>=(array const& lhs, array const& rhs) -> bool { return !(lhs < rhs); }

    // NOLINTNEXTLINE(readability-identifier-naming)
    TETL_NO_UNIQUE_ADDRESS conditional_t<Size == 0, empty_c_array, c_array<Type, Size + size_t{Size == 0}>> _buf;
};

template <typename T, typename... U>
array(T, U...) -> array<T, 1 + sizeof...(U)>;

template <typename T, size_t N>
struct tuple_size<array<T, N>> : integral_constant<size_t, N> { };

template <typename T, etl::size_t Size>
inline constexpr auto is_tuple_like<etl::array<T, Size>> = true;

template <size_t I, typename T>
struct tuple_element;
 
template <size_t I, typename T, size_t N>
struct tuple_element<I, array<T, N>> {
    using type = T;
};

template <size_t Index, typename T, size_t Size>
[[nodiscard]] constexpr auto get(array<T, Size>& array) noexcept -> T&
{
    static_assert(Index < Size, "array index out of range");
    return array[Index];
}

template <size_t Index, typename T, size_t Size>
[[nodiscard]] constexpr auto get(array<T, Size> const& array) noexcept -> T const&
{
    static_assert(Index < Size, "array index out of range");
    return array[Index];
}

template <size_t Index, typename T, size_t Size>
[[nodiscard]] constexpr auto get(array<T, Size>&& array) noexcept -> T&&
{
    static_assert(Index < Size, "array index out of range");
    return etl::move(array[Index]);
}

template <size_t Index, typename T, size_t Size>
[[nodiscard]] constexpr auto get(array<T, Size> const&& array) noexcept -> T const&&
{
    static_assert(Index < Size, "array index out of range");
    return etl::move(array[Index]);
}

template <typename T, size_t N>
[[nodiscard]] constexpr auto to_array(T (&a)[N]) -> array<remove_cv_t<T>, N>
{
    return [&]<etl::size_t... I>(etl::index_sequence<I...> /*i*/) {
        return etl::array<etl::remove_cv_t<T>, N>{{a[I]...}};
    }(etl::make_index_sequence<N>{});
}

template <typename T, size_t N>
[[nodiscard]] constexpr auto to_array(T (&&a)[N])
{
    return [&]<etl::size_t... I>(etl::index_sequence<I...> /*i*/) {
        return etl::array<etl::remove_cv_t<T>, N>{{etl::move(a[I])...}};
    }(etl::make_index_sequence<N>{});
}
 
template <typename T>
inline constexpr auto is_etl_array = false;
 
template <typename T, size_t Size>
inline constexpr auto is_etl_array<array<T, Size>> = true;
 
} // namespace etl
 
#endif // TETL_ARRAY_ARRAY_HPP