array.hpp

Go to the documentation of this file.

#ifndef BSL_ARRAY_HPP
#define BSL_ARRAY_HPP

#include "contiguous_iterator.hpp"
#include "cstdint.hpp"
#include "cstring.hpp"
#include "is_constant_evaluated.hpp"
#include "is_fundamental.hpp"
#include "numeric_limits.hpp"
#include "reverse_iterator.hpp"

namespace bsl
{
    template<typename T, bsl::uintmax N>
    class array final
    {
        static_assert(N != 0, "arrays of size 0 are not supported");

    public:
        T m_data[N];    // NOLINT

        using value_type = T;
        using size_type = bsl::uintmax;
        using difference_type = bsl::uintmax;
        using reference_type = T &;
        using const_reference_type = T const &;
        using pointer_type = T *;
        using const_pointer_type = T const *;
        using iterator_type = contiguous_iterator<T>;
        using const_iterator_type = contiguous_iterator<T const>;
        using reverse_iterator_type = reverse_iterator<iterator_type>;
        using const_reverse_iterator_type = reverse_iterator<const_iterator_type>;

        [[nodiscard]] constexpr pointer_type
        at_if(size_type const index) noexcept
        {
            if (index >= N) {
                return nullptr;
            }

            return &m_data[index];    // PRQA S 4024 // NOLINT
        }

        [[nodiscard]] constexpr const_pointer_type
        at_if(size_type const index) const noexcept
        {
            if (index >= N) {
                return nullptr;
            }

            return &m_data[index];    // NOLINT
        }

        [[nodiscard]] constexpr reference_type
        front() noexcept
        {
            return *this->at_if(0U);
        }

        [[nodiscard]] constexpr const_reference_type
        front() const noexcept
        {
            return *this->at_if(0U);
        }

        [[nodiscard]] constexpr pointer_type
        front_if() noexcept
        {
            return this->at_if(0U);
        }

        [[nodiscard]] constexpr const_pointer_type
        front_if() const noexcept
        {
            return this->at_if(0U);
        }

        [[nodiscard]] constexpr reference_type
        back() noexcept
        {
            return *this->at_if(N - 1U);
        }

        [[nodiscard]] constexpr const_reference_type
        back() const noexcept
        {
            return *this->at_if(N - 1U);
        }

        [[nodiscard]] constexpr pointer_type
        back_if() noexcept
        {
            return this->at_if(N - 1U);
        }

        [[nodiscard]] constexpr const_pointer_type
        back_if() const noexcept
        {
            return this->at_if(N - 1U);
        }

        [[nodiscard]] constexpr pointer_type
        data() noexcept
        {
            return m_data;    // NOLINT
        }

        [[nodiscard]] constexpr const_pointer_type
        data() const noexcept
        {
            return m_data;    // NOLINT
        }

        [[nodiscard]] constexpr iterator_type
        begin() noexcept
        {
            return iterator_type{this->front_if(), N, 0U};
        }

        [[nodiscard]] constexpr const_iterator_type
        begin() const noexcept
        {
            return const_iterator_type{this->front_if(), N, 0U};
        }

        [[nodiscard]] constexpr const_iterator_type
        cbegin() const noexcept
        {
            return const_iterator_type{this->front_if(), N, 0U};
        }

        [[nodiscard]] constexpr iterator_type
        iter(size_type const i) noexcept
        {
            return iterator_type{this->front_if(), N, i};
        }

        [[nodiscard]] constexpr const_iterator_type
        iter(size_type const i) const noexcept
        {
            return const_iterator_type{this->front_if(), N, i};
        }

        [[nodiscard]] constexpr const_iterator_type
        citer(size_type const i) const noexcept
        {
            return const_iterator_type{this->front_if(), N, i};
        }

        [[nodiscard]] constexpr iterator_type
        end() noexcept
        {
            return iterator_type{this->front_if(), N, N};
        }

        [[nodiscard]] constexpr const_iterator_type
        end() const noexcept
        {
            return const_iterator_type{this->front_if(), N, N};
        }

        [[nodiscard]] constexpr const_iterator_type
        cend() const noexcept
        {
            return const_iterator_type{this->front_if(), N, N};
        }

        [[nodiscard]] constexpr reverse_iterator_type
        rbegin() noexcept
        {
            return reverse_iterator_type{this->end()};
        }

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

        [[nodiscard]] constexpr const_reverse_iterator_type
        crbegin() const noexcept
        {
            return const_reverse_iterator_type{this->cend()};
        }

        [[nodiscard]] constexpr reverse_iterator_type
        riter(size_type const i) noexcept
        {
            size_type const ai{(i >= N) ? N : (i + 1U)};
            return reverse_iterator_type{this->iter(ai)};
        }

        [[nodiscard]] constexpr const_reverse_iterator_type
        riter(size_type const i) const noexcept
        {
            size_type const ai{(i >= N) ? N : (i + 1U)};
            return const_reverse_iterator_type{this->iter(ai)};
        }

        [[nodiscard]] constexpr const_reverse_iterator_type
        criter(size_type const i) const noexcept
        {
            size_type const ai{(i >= N) ? N : (i + 1U)};
            return const_reverse_iterator_type{this->citer(ai)};
        }

        [[nodiscard]] constexpr reverse_iterator_type
        rend() noexcept
        {
            return reverse_iterator_type{this->begin()};
        }

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

        [[nodiscard]] constexpr const_reverse_iterator_type
        crend() const noexcept
        {
            return const_reverse_iterator_type{this->cbegin()};
        }

        [[nodiscard]] static constexpr bool
        empty() noexcept
        {
            return false;
        }

        [[nodiscard]] static constexpr size_type
        size() noexcept
        {
            return N;
        }

        [[nodiscard]] static constexpr size_type
        max_size() noexcept
        {
            return numeric_limits<size_type>::max() / sizeof(T);
        }

        [[nodiscard]] static constexpr size_type
        size_bytes() noexcept
        {
            return N * sizeof(T);
        }
    };

    template<typename T, bsl::uintmax N>
    constexpr bool
    operator==(bsl::array<T, N> const &lhs, bsl::array<T, N> const &rhs) noexcept
    {
        if (is_fundamental<T>::value && !is_constant_evaluated()) {
            return bsl::builtin_memcmp(lhs.data(), rhs.data(), lhs.size_bytes()) == 0;
        }

        for (bsl::uintmax i{}; i < lhs.size(); ++i) {
            if (*lhs.at_if(i) != *rhs.at_if(i)) {
                return false;
            }
        }

        return true;
    }

    template<typename T, bsl::uintmax N>
    constexpr bool
    operator!=(bsl::array<T, N> const &lhs, bsl::array<T, N> const &rhs) noexcept
    {
        return !(lhs == rhs);
    }

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

#endif