contiguous_iterator.hpp

Go to the documentation of this file.

#ifndef BSL_CONTIGUOUS_ITERATOR_HPP
#define BSL_CONTIGUOUS_ITERATOR_HPP

#include "cstdint.hpp"

// TODO
// - We need to implement the remianing functions that are part of the
//   contiguous iterator specification. Specifically, the increment and
//   decrement by "n" functions as they all require the safe_int class
//   to be effective at preventing wrapping, overruns and underruns.
//   Currently we only support the ++/-- functions as those are simple
//   to implement without the need for safe_int. Also note that we would
//   need some extra logic to ensure the iterator stays in-bounds.
//

namespace bsl
{
    template<typename T>
    class contiguous_iterator final
    {
        constexpr contiguous_iterator() noexcept    // --
            : m_ptr{}, m_count{}, m_i{}
        {}

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

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

            if (m_i > count) {
                m_i = count;
            }
        }

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

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

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

        [[nodiscard]] constexpr size_type
        index() const noexcept
        {
            return m_i;
        }

        [[nodiscard]] constexpr bool
        empty() const noexcept
        {
            return nullptr == this->data();
        }

        [[nodiscard]] constexpr bool
        is_end() const noexcept
        {
            return this->index() == this->size();
        }

        [[nodiscard]] constexpr pointer_type
        get_if() noexcept
        {
            if (nullptr == m_ptr) {
                return nullptr;
            }

            if (m_i == m_count) {
                return nullptr;
            }

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

        [[maybe_unused]] constexpr contiguous_iterator &
        operator++() noexcept
        {
            if (nullptr == m_ptr) {
                return *this;
            }

            if (m_count == m_i) {
                return *this;
            }

            ++m_i;
            return *this;
        }

        [[maybe_unused]] constexpr contiguous_iterator &
        operator--() noexcept
        {
            if (nullptr == m_ptr) {
                return *this;
            }

            if (0U == m_i) {
                return *this;
            }

            --m_i;
            return *this;
        }

    private:
        pointer_type m_ptr;
        size_type m_count;
        size_type m_i;
    };

    template<typename T>
    [[nodiscard]] constexpr bool
    operator==(contiguous_iterator<T> const &lhs, contiguous_iterator<T> const &rhs) noexcept
    {
        return (lhs.data() == rhs.data()) && (lhs.index() == rhs.index());
    }

    template<typename T>
    [[nodiscard]] constexpr bool
    operator!=(contiguous_iterator<T> const &lhs, contiguous_iterator<T> const &rhs) noexcept
    {
        return !(lhs == rhs);
    }

    template<typename T>
    [[nodiscard]] constexpr bool
    operator<(contiguous_iterator<T> const &lhs, contiguous_iterator<T> const &rhs) noexcept
    {
        return lhs.index() < rhs.index();
    }

    template<typename T>
    [[nodiscard]] constexpr bool
    operator<=(contiguous_iterator<T> const &lhs, contiguous_iterator<T> const &rhs) noexcept
    {
        return lhs.index() <= rhs.index();
    }

    template<typename T>
    [[nodiscard]] constexpr bool
    operator>(contiguous_iterator<T> const &lhs, contiguous_iterator<T> const &rhs) noexcept
    {
        return lhs.index() > rhs.index();
    }

    template<typename T>
    [[nodiscard]] constexpr bool
    operator>=(contiguous_iterator<T> const &lhs, contiguous_iterator<T> const &rhs) noexcept
    {
        return lhs.index() >= rhs.index();
    }
}

#endif