array.h

Go to the documentation of this file.

 
#ifndef ARRAY_H
#define ARRAY_H
 
#include <cstddef>
#include <iostream>
#include <iterator>
#include <type_traits>
#include <utility>
 
namespace dsa
{

    template<typename T, std::size_t N>
    struct Array
    {
        using value_type = T;

        using size_type = std::size_t;

        using difference_type = std::ptrdiff_t;

        using pointer = value_type*;

        using const_pointer = const value_type*;

        using reference = value_type&;

        using const_reference = const value_type&;

        using iterator = value_type*;

        using const_iterator = const value_type*;

        using reverse_iterator = std::reverse_iterator<iterator>;

        using const_reverse_iterator = std::reverse_iterator<const_iterator>;

        [[nodiscard]] constexpr auto at(size_type pos) -> reference
        {
            if (pos >= N)
            {
                throw std::out_of_range("Pos argument outside of container range");
            }
 
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
            return m_data[pos];
        }

        [[nodiscard]] constexpr auto at(size_type pos) const -> const_reference
        {
            if (pos >= N)
            {
                throw std::out_of_range("Pos argument outside of container range");
            }
 
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
            return m_data[pos];
        }

        [[nodiscard]] constexpr auto operator[](size_type pos) -> reference
        {
            // Same semantics as std::array::operator[], no bounds checking
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
            return m_data[pos];
        }

        [[nodiscard]] constexpr auto operator[](size_type pos) const -> const_reference
        {
            // Same semantics as std::array::operator[], no bounds checking
            // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
            return m_data[pos];
        }

        [[nodiscard]] constexpr auto front() -> reference
        {
            return m_data[0];
        }

        [[nodiscard]] constexpr auto front() const -> const_reference
        {
            return m_data[0];
        }

        [[nodiscard]] constexpr auto back() -> reference
        {
            return m_data[N - 1];
        }

        [[nodiscard]] constexpr auto back() const -> const_reference
        {
            return m_data[N - 1];
        }

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

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

        [[nodiscard]] constexpr auto begin() noexcept -> iterator
        {
            return &m_data[0];
        }

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

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

        [[nodiscard]] constexpr auto end() noexcept -> iterator
        {
            return &m_data[N];
        }

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

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

        [[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 const_reverse_iterator(end());
        }

        [[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 const_reverse_iterator(begin());
        }

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

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

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

        void fill(const value_type& value)
        {
            for (size_type i = 0; i < size(); i++)
            {
                // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
                m_data[i] = value;
            }
        }

        constexpr void swap(Array<T, N>& other) noexcept(std::is_nothrow_swappable_v<T>)
        {
            if (*this != other)
            {
                std::swap(m_data, other.m_data);
            }
        }

         // Public for aggregate initialization, same as std::array
         // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays, misc-non-private-member-variables-in-classes)
        value_type m_data[N == 0 ? 1 : N]{};
    };

    template<std::size_t I, typename T, std::size_t N>
    [[nodiscard]] constexpr auto get(Array<T, N>& array) noexcept -> T&
    {
        static_assert(I < N, "Index out of range in dsa::Array::get");
        return array[I];
    }

    template<std::size_t I, typename T, std::size_t N>
    [[nodiscard]] constexpr auto get(const Array<T, N>& array) noexcept -> const T&
    {
        static_assert(I < N, "Index out of range in dsa::Array::get");
        return array[I];
    }

    template<std::size_t I, typename T, std::size_t N>
    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
    [[nodiscard]] constexpr auto get(Array<T, N>&& array) noexcept -> T&&
    {
        static_assert(I < N, "Index out of range in dsa::Array::get");
        return std::move(array[I]);
    }

    template<std::size_t I, typename T, std::size_t N>
    [[nodiscard]] constexpr auto get(const Array<T, N>&& array) noexcept -> const T&&
    {
        static_assert(I < N, "Index out of range in dsa::Array::get");
        return std::move(array[I]);
    }

    template<typename T, std::size_t N>
    void swap(Array<T, N>& lhs, Array<T, N>& rhs) noexcept(noexcept(lhs.swap(rhs)))
    {
        lhs.swap(rhs);
    }

    template<typename T, std::size_t N>
        requires(!std::is_array_v<T>)
    // Intentional use of C-style array: the array bound must be part of the type
    // to enable compile-time size deduction
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
    [[nodiscard]] constexpr auto to_array(T(&array)[N]) -> Array<std::remove_cv_t<T>, N>
    {
        return[&]<std::size_t... I>(std::index_sequence<I...>)
        {
            // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
            return dsa::Array<std::remove_cv_t<T>, N>{array[I]...};
        }(std::make_index_sequence<N>{});
    }

    template<typename T, std::size_t N>
        requires(!std::is_array_v<T> && !std::is_const_v<T>)
    // Intentional use of C-style array: the array bound must be part of the type
    // to enable compile-time size deduction
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-rvalue-reference-param-not-moved)
    [[nodiscard]] constexpr auto to_array(T(&& array)[N]) -> Array<std::remove_cv_t<T>, N>
    {
        return[&]<std::size_t... I>(std::index_sequence<I...>)
        {
            // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
            return dsa::Array<std::remove_cv_t<T>, N>{std::move(array[I])...};
        }(std::make_index_sequence<N>{});
    }

    template<typename T, std::size_t N>
    auto operator<<(std::ostream& out, const Array<T, N>& array) -> std::ostream&
    {
        for (size_t i = 0; i < N; i++)
        {
            out << array[i] << ' ';
        }
 
        return out;
    }

    template<typename T, std::size_t N>
    [[nodiscard]] constexpr auto operator==(const Array<T, N>& lhs, const Array<T, N>& rhs)
        noexcept(noexcept(*lhs.begin() == *rhs.begin())) -> bool
    {
        auto lhs_iter = lhs.cbegin();
        auto rhs_iter = rhs.cbegin();
 
        for (size_t i = 0; i < N; i++)
        {
            if (*lhs_iter != *rhs_iter)
            {
                return false;
            }
 
            lhs_iter++;
            rhs_iter++;
        }
 
        return true;
    }

    template<typename T, std::size_t N>
    [[nodiscard]] constexpr auto operator<=>(const Array<T, N>& lhs, const Array<T, N>& rhs)
        noexcept(noexcept(*lhs.begin() == *rhs.begin())) -> std::compare_three_way_result_t<T>
    {
        auto lhs_iter = lhs.cbegin();
        auto rhs_iter = rhs.cbegin();
 
        for (size_t i = 0; i < N; i++)
        {
            auto cmp = *lhs_iter <=> *rhs_iter;
            if (cmp != 0)
            {
                return cmp;
            }
 
            lhs_iter++;
            rhs_iter++;
        }
 
        return std::compare_three_way_result_t<T>::equivalent;
    }
}
 
namespace std
{
    /*
    * These are explicit specializations of standard templates 'tuple_size' and 'tuple_element'
    * for a user-defined type dsa::Array. This is allowed by C++ standard and required
    * to enable structured bindings and tuple-like behaviour.
    *
    * No new symbols or modification of standard library behaviour was introduced,
    * only providing valid specialization for user-defined type.
    */
    // NOLINTBEGIN(cert-dcl58-cpp)


    template<typename T, std::size_t N>
    struct tuple_size <dsa::Array<T, N>> : std::integral_constant<std::size_t, N>
    {
    };


    template<std::size_t I, typename T, std::size_t N>
    struct tuple_element<I, dsa::Array<T, N>>
    {
        using type = T;
    };
 
    namespace ranges
    {
        /*
        * These are explicit specializations of range semantics for a user-defined type dsa::Array
        * specifically to be recognized as 'borrowed range' or 'view'
        */


        template<typename T, std::size_t N>
        inline constexpr bool enable_borrowed_range<dsa::Array<T, N>> = true;


        template<typename T, std::size_t N>
        inline constexpr bool enable_view<dsa::Array<T, N>> = true;


        template<typename T, std::size_t N>
        inline constexpr bool enable_view<const dsa::Array<T, N>> = true;
    }
 
    // NOLINTEND(cert-dcl58-cpp)
}
 
#endif // !ARRAY_H