span.hpp

Go to the documentation of this file.

#ifndef BSL_SPAN_HPP
#define BSL_SPAN_HPP

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

namespace bsl
{
    template<typename T>
    class span final    // NOLINT
    {
    public:
        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>;

        constexpr span() noexcept = default;

        constexpr span(pointer_type const ptr, size_type const count) noexcept    // --
            : m_ptr{ptr}, m_count{count}
        {
            if ((nullptr == m_ptr) || (0U == m_count)) {
                *this = span{};
            }
        }

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

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

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

            return &m_ptr[index];    // NOLINT
        }

        [[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 pointer_type
        back_if() noexcept
        {
            return this->at_if((m_count > 0U) ? (m_count - 1U) : 0U);
        }

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

        [[nodiscard]] constexpr pointer_type
        data() noexcept
        {
            return m_ptr;
        }

        [[nodiscard]] constexpr const_pointer_type
        data() const noexcept
        {
            return m_ptr;
        }

        [[nodiscard]] constexpr iterator_type
        begin() noexcept
        {
            return iterator_type{m_ptr, m_count, 0U};
        }

        [[nodiscard]] constexpr const_iterator_type
        begin() const noexcept
        {
            return const_iterator_type{m_ptr, m_count, 0U};
        }

        [[nodiscard]] constexpr const_iterator_type
        cbegin() const noexcept
        {
            return const_iterator_type{m_ptr, m_count, 0U};
        }

        [[nodiscard]] constexpr iterator_type
        iter(size_type const i) noexcept
        {
            return iterator_type{m_ptr, m_count, i};
        }

        [[nodiscard]] constexpr const_iterator_type
        iter(size_type const i) const noexcept
        {
            return const_iterator_type{m_ptr, m_count, i};
        }

        [[nodiscard]] constexpr const_iterator_type
        citer(size_type const i) const noexcept
        {
            return const_iterator_type{m_ptr, m_count, i};
        }

        [[nodiscard]] constexpr iterator_type
        end() noexcept
        {
            return iterator_type{m_ptr, m_count, m_count};
        }

        [[nodiscard]] constexpr const_iterator_type
        end() const noexcept
        {
            return const_iterator_type{m_ptr, m_count, m_count};
        }

        [[nodiscard]] constexpr const_iterator_type
        cend() const noexcept
        {
            return const_iterator_type{m_ptr, m_count, m_count};
        }

        [[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 >= m_count) ? m_count : (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 >= m_count) ? m_count : (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 >= m_count) ? m_count : (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]] constexpr bool
        empty() const noexcept
        {
            return 0U == m_count;
        }

        [[nodiscard]] constexpr size_type
        size() const noexcept
        {
            return m_count;
        }

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

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

        [[nodiscard]] constexpr span<T>
        first(size_type const count = npos) noexcept
        {
            return this->subspan(0U, count);
        }

        [[nodiscard]] constexpr span<T>
        first(size_type const count = npos) const noexcept
        {
            return this->subspan(0U, count);
        }

        [[nodiscard]] constexpr span<T>
        last(size_type count = npos) noexcept
        {
            if (count > this->size()) {
                count = this->size();
            }

            return this->subspan(this->size() - count, count);
        }

        [[nodiscard]] constexpr span<T>
        last(size_type count = npos) const noexcept
        {
            if (count > this->size()) {
                count = this->size();
            }

            return this->subspan(this->size() - count, count);
        }

        [[nodiscard]] constexpr span<T>
        subspan(size_type const pos, size_type const count = npos) noexcept
        {
            if ((nullptr == m_ptr) || (pos >= m_count)) {
                return {};
            }

            return span<T>{&m_ptr[pos], min_of(count, m_count - pos)};    // NOLINT
        }

        [[nodiscard]] constexpr span<T>
        subspan(size_type const pos, size_type const count = npos) const noexcept
        {
            if ((nullptr == m_ptr) || (pos >= m_count)) {
                return {};
            }

            return span<T>{&m_ptr[pos], min_of(count, m_count - pos)};    // NOLINT
        }

    private:
        pointer_type m_ptr;
        size_type m_count;
    };

    template<typename T>
    constexpr bool
    operator==(span<T> const &lhs, span<T> const &rhs) noexcept
    {
        if (lhs.size() != rhs.size()) {
            return false;
        }

        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>
    constexpr bool
    operator!=(span<T> const &lhs, span<T> const &rhs) noexcept
    {
        return !(lhs == rhs);
    }
}

#endif