reverse_iterator.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_ITERATOR_REVERSE_ITERATOR_HPP
#define TETL_ITERATOR_REVERSE_ITERATOR_HPP
 
#include <etl/_iterator/iterator_traits.hpp>
#include <etl/_memory/addressof.hpp>
 
namespace etl {

template <typename Iter>
struct reverse_iterator {
    using iterator_type     = Iter;
    using value_type        = typename iterator_traits<Iter>::value_type;
    using difference_type   = typename etl::iterator_traits<Iter>::difference_type;
    using reference         = typename etl::iterator_traits<Iter>::reference;
    using pointer           = typename etl::iterator_traits<Iter>::pointer;
    using iterator_category = typename etl::iterator_traits<Iter>::iterator_category;

    constexpr reverse_iterator()
        : _current()
    {
    }

    constexpr explicit reverse_iterator(Iter x)
        : _current(x)
    {
    }

    template <typename Other>
    constexpr reverse_iterator(reverse_iterator<Other> const& other)
        : _current(other.base())
    {
    }

    template <typename Other>
    constexpr auto operator=(reverse_iterator<Other> const& other) -> reverse_iterator&
    {
        _current = other.base();
        return *this;
    }

    [[nodiscard]] constexpr auto base() const -> Iter { return _current; }

    constexpr auto operator*() const -> reference
    {
        auto tmp = _current;
        return *--tmp;
    }

    constexpr auto operator->() const -> pointer { return etl::addressof(operator*()); }

    constexpr auto operator++() -> reverse_iterator&
    {
        --_current;
        return *this;
    }

    constexpr auto operator++(int) -> reverse_iterator
    {
        auto tmp(*this);
        --_current;
        return tmp;
    }

    constexpr auto operator--() -> reverse_iterator&
    {
        ++_current;
        return *this;
    }

    constexpr auto operator--(int) -> reverse_iterator
    {
        auto tmp(*this);
        ++_current;
        return tmp;
    }

    constexpr auto operator+(difference_type n) const -> reverse_iterator { return reverse_iterator(_current - n); }

    constexpr auto operator+=(difference_type n) -> reverse_iterator&
    {
        _current -= n;
        return *this;
    }

    constexpr auto operator-(difference_type n) const -> reverse_iterator { return reverse_iterator(_current + n); }

    constexpr auto operator-=(difference_type n) -> reverse_iterator&
    {
        _current += n;
        return *this;
    }

    constexpr auto operator[](difference_type n) const -> reference { return *(*this + n); }
 
private:
    Iter _current;
};

template <typename Iter>
[[nodiscard]] constexpr auto make_reverse_iterator(Iter i) noexcept -> etl::reverse_iterator<Iter>
{
    return etl::reverse_iterator<Iter>(i);
}

template <typename Iter1, typename Iter2>
[[nodiscard]] constexpr auto
operator==(etl::reverse_iterator<Iter1> const& lhs, etl::reverse_iterator<Iter2> const& rhs) -> bool
{
    return lhs.base() == rhs.base();
}

template <typename Iter1, typename Iter2>
[[nodiscard]] constexpr auto
operator!=(etl::reverse_iterator<Iter1> const& lhs, etl::reverse_iterator<Iter2> const& rhs) -> bool
{
    return lhs.base() != rhs.base();
}

template <typename Iter1, typename Iter2>
[[nodiscard]] constexpr auto operator<(etl::reverse_iterator<Iter1> const& lhs, etl::reverse_iterator<Iter2> const& rhs)
    -> bool
{
    return lhs.base() < rhs.base();
}

template <typename Iter1, typename Iter2>
[[nodiscard]] constexpr auto
operator<=(etl::reverse_iterator<Iter1> const& lhs, etl::reverse_iterator<Iter2> const& rhs) -> bool
{
    return lhs.base() <= rhs.base();
}

template <typename Iter1, typename Iter2>
[[nodiscard]] constexpr auto operator>(etl::reverse_iterator<Iter1> const& lhs, etl::reverse_iterator<Iter2> const& rhs)
    -> bool
{
    return lhs.base() > rhs.base();
}

template <typename Iter1, typename Iter2>
[[nodiscard]] constexpr auto
operator>=(etl::reverse_iterator<Iter1> const& lhs, etl::reverse_iterator<Iter2> const& rhs) -> bool
{
    return lhs.base() >= rhs.base();
}

template <typename Iter>
[[nodiscard]] constexpr auto
operator+(typename reverse_iterator<Iter>::difference_type n, reverse_iterator<Iter> const& it)
    noexcept(noexcept(it.base() - n)) -> reverse_iterator<Iter>
{
    return reverse_iterator<Iter>(it.base() - n);
}

template <typename Iterator1, typename Iterator2>
constexpr auto operator-(reverse_iterator<Iterator1> const& lhs, reverse_iterator<Iterator2> const& rhs)
    noexcept(noexcept(rhs.base() - lhs.base())) -> decltype(rhs.base() - lhs.base())
{
    return rhs.base() - lhs.base();
}
 
} // namespace etl
 
#endif // TETL_ITERATOR_REVERSE_ITERATOR_HPP