reverse_iterator.hpp

Go to the documentation of this file.

#ifndef BSL_REVERSE_ITERATOR_HPP
#define BSL_REVERSE_ITERATOR_HPP

#include "cstdint.hpp"

// TODO
// - We need to implement the remianing functions that are part of the
//   reverse 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 Iter>
    class reverse_iterator final
    {
    public:
        using value_type = typename Iter::value_type;
        using size_type = bsl::uintmax;
        using difference_type = bsl::uintmax;
        using reference_type = typename Iter::value_type &;
        using const_reference_type = typename Iter::value_type const &;
        using pointer_type = typename Iter::value_type *;
        using const_pointer_type = typename Iter::value_type const *;

        explicit constexpr reverse_iterator(Iter const &i) noexcept    // --
            : m_i{i}
        {}

        [[nodiscard]] constexpr Iter
        base() const noexcept
        {
            return m_i;
        }

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

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

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

        [[nodiscard]] constexpr size_type
        index() const noexcept
        {
            if (m_i.index() == 0U) {
                return m_i.size();
            }

            return m_i.index() - 1U;
        }

        [[nodiscard]] constexpr bool
        empty() const noexcept
        {
            return m_i.empty();
        }

        [[nodiscard]] constexpr bool
        is_end() const noexcept
        {
            return 0U == m_i.index();
        }

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

            if (m_i.index() == 0U) {
                return nullptr;
            }

            return &m_i.data()[m_i.index() - 1U];    // PRQA S 4024 // NOLINT
        }

        [[maybe_unused]] constexpr reverse_iterator &
        operator++() noexcept
        {
            --m_i;
            return *this;
        }

        [[maybe_unused]] constexpr reverse_iterator &
        operator--() noexcept
        {
            ++m_i;
            return *this;
        }

    private:
        Iter m_i;
    };

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

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

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

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

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

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

    template<typename Iter>
    constexpr reverse_iterator<Iter>
    make_reverse_iterator(Iter const &i) noexcept
    {
        return {i};
    }
}

#endif