reverse_iterator.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ITERATOR_REVERSE_ITERATOR_HPP__
#define NEFORCE_CORE_ITERATOR_REVERSE_ITERATOR_HPP__

 
#include "NeForce/core/algorithm/iterator.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename Iterator>
class reverse_iterator {
    static_assert(is_ranges_bid_iter_v<Iterator>, "reverse iterator requires bidirectional iterator.");
 
public:
    using iterator_category = iter_category_t<Iterator>; 
    using value_type = iter_value_t<Iterator>;           
    using difference_type = iter_difference_t<Iterator>; 
    using pointer = iter_pointer_t<Iterator>;            
    using reference = iter_reference_t<Iterator>;        
 
private:
    Iterator current; 
 
public:
    constexpr reverse_iterator() = default;

    constexpr explicit reverse_iterator(Iterator x) noexcept(is_nothrow_move_constructible_v<Iterator>) :
    current(_NEFORCE move(x)) {}

    template <typename U>
#ifdef NEFORCE_STANDARD_20
        requires(!same_as<U, Iterator> && convertible_to<const U&, Iterator>)
#endif // NEFORCE_STANDARD_20
    constexpr explicit reverse_iterator(const reverse_iterator<U>& x) noexcept(
            is_nothrow_constructible_v<Iterator, const U&>) :
    current(x.current) {
    }

    template <typename U>
#ifdef NEFORCE_STANDARD_20
        requires(!same_as<U, Iterator> && convertible_to<const U&, Iterator> && assignable_from<Iterator&, const U&>)
#endif // NEFORCE_STANDARD_20
    constexpr reverse_iterator&
    operator=(const reverse_iterator<U>& x) noexcept(is_nothrow_assignable<reverse_iterator&, const U&>::value) {
        current = x.current;
        return *this;
    }
 
    NEFORCE_CONSTEXPR20 ~reverse_iterator() noexcept = default; 

    NEFORCE_NODISCARD constexpr reference operator*() const
            noexcept(is_nothrow_copy_assignable<Iterator>::value && noexcept(*--(_NEFORCE declval<Iterator&>()))) {
        Iterator iter = current;
        return *--iter;
    }

    NEFORCE_NODISCARD constexpr pointer operator->() const
            noexcept(is_nothrow_copy_constructible<Iterator>::value && noexcept(--(_NEFORCE declval<Iterator&>())) &&
                     is_nothrow_arrow<Iterator&, pointer>::value)
#ifdef NEFORCE_STANDARD_20
        requires(is_pointer_v<Iterator> || requires(const Iterator it) { it.operator->(); })
#endif // NEFORCE_STANDARD_20
    {
        Iterator tmp = current;
        --tmp;
        return _NEFORCE to_pointer(tmp);
    }

    constexpr reverse_iterator& operator++() noexcept(noexcept(--current)) {
        --current;
        return *this;
    }

    constexpr reverse_iterator operator++(int) noexcept(is_nothrow_copy_constructible_v<Iterator> &&
                                                        noexcept(--current)) {
        reverse_iterator tmp = *this;
        --current;
        return tmp;
    }

    constexpr reverse_iterator& operator--() noexcept(noexcept(++current)) {
        ++current;
        return *this;
    }

    constexpr reverse_iterator operator--(int) noexcept(is_nothrow_copy_constructible_v<Iterator> &&
                                                        noexcept(++current)) {
        reverse_iterator tmp = *this;
        ++current;
        return tmp;
    }

    constexpr reverse_iterator operator+(const difference_type n) const
            noexcept(noexcept(reverse_iterator(current - n))) {
        return reverse_iterator(current - n);
    }

    constexpr reverse_iterator& operator+=(const difference_type n) noexcept(noexcept(current -= n)) {
        current -= n;
        return *this;
    }

    constexpr reverse_iterator operator-(const difference_type n) const
            noexcept(noexcept(reverse_iterator(current + n))) {
        return reverse_iterator(current + n);
    }

    constexpr reverse_iterator& operator-=(const difference_type n) noexcept(noexcept(current += n)) {
        current += n;
        return *this;
    }

    constexpr reference operator[](const difference_type n) const
            noexcept(noexcept(_NEFORCE declcopy<reference>(reverse_iterator(current - n)))) {
        return *(*this + n);
    }

    NEFORCE_NODISCARD constexpr const Iterator& base() const noexcept { return current; }
};

template <typename Iterator1, typename Iterator2>
NEFORCE_NODISCARD constexpr bool
operator==(const reverse_iterator<Iterator1>& x,
           const reverse_iterator<Iterator2>& y) noexcept(noexcept(_NEFORCE declcopy<bool>(x.base() == y.base())))
#ifdef NEFORCE_STANDARD_20
    requires requires {
        { x.base() == y.base() } -> convertible_to<bool>;
    }
#endif // NEFORCE_STANDARD_20
{
    return x.base() == y.base();
}

template <typename Iterator1, typename Iterator2>
NEFORCE_NODISCARD constexpr bool
operator!=(const reverse_iterator<Iterator1>& x,
           const reverse_iterator<Iterator2>& y) noexcept(noexcept(_NEFORCE declcopy<bool>(x.base() != y.base())))
#ifdef NEFORCE_STANDARD_20
    requires requires {
        { x.base() != y.base() } -> convertible_to<bool>;
    }
#endif // NEFORCE_STANDARD_20
{
    return x.base() != y.base();
}

template <typename Iterator1, typename Iterator2>
NEFORCE_NODISCARD constexpr bool
operator<(const reverse_iterator<Iterator1>& x,
          const reverse_iterator<Iterator2>& y) noexcept(noexcept(_NEFORCE declcopy<bool>(x.base() > y.base())))
#ifdef NEFORCE_STANDARD_20
    requires requires {
        { x.base() > y.base() } -> convertible_to<bool>;
    }
#endif
{
    return x.base() > y.base();
}

template <typename Iterator1, typename Iterator2>
NEFORCE_NODISCARD constexpr bool
operator>(const reverse_iterator<Iterator1>& x,
          const reverse_iterator<Iterator2>& y) noexcept(noexcept(_NEFORCE declcopy<bool>(x.base() < y.base())))
#ifdef NEFORCE_STANDARD_20
    requires requires {
        { x.base() < y.base() } -> convertible_to<bool>;
    }
#endif // NEFORCE_STANDARD_20
{
    return x.base() < y.base();
}

template <typename Iterator1, typename Iterator2>
NEFORCE_NODISCARD constexpr bool
operator<=(const reverse_iterator<Iterator1>& x,
           const reverse_iterator<Iterator2>& y) noexcept(noexcept(_NEFORCE declcopy<bool>(x.base() >= y.base())))
#ifdef NEFORCE_STANDARD_20
    requires requires {
        { x.base() >= y.base() } -> convertible_to<bool>;
    }
#endif // NEFORCE_STANDARD_20
{
    return x.base() >= y.base();
}

template <typename Iterator1, typename Iterator2>
NEFORCE_NODISCARD constexpr bool
operator>=(const reverse_iterator<Iterator1>& x,
           const reverse_iterator<Iterator2>& y) noexcept(noexcept(_NEFORCE declcopy<bool>(x.base() <= y.base())))
#ifdef NEFORCE_STANDARD_20
    requires requires {
        { x.base() <= y.base() } -> convertible_to<bool>;
    }
#endif // NEFORCE_STANDARD_20
{
    return x.base() <= y.base();
}

template <typename Iterator1, typename Iterator2>
NEFORCE_NODISCARD constexpr decltype(auto)
operator-(const reverse_iterator<Iterator1>& x,
          const reverse_iterator<Iterator2>& y) noexcept(noexcept(y.base() - x.base())) {
    return y.base() - x.base();
}

template <typename Iterator>
constexpr reverse_iterator<Iterator> operator+(iter_difference_t<Iterator> n,
                                               const reverse_iterator<Iterator>& x) noexcept(noexcept(x + n)) {
    return x + n;
}

template <typename Iterator>
NEFORCE_NODISCARD constexpr reverse_iterator<Iterator>
make_reverse_iterator(Iterator it) noexcept(is_nothrow_move_constructible_v<Iterator>) {
    return reverse_iterator<Iterator>(_NEFORCE move(it));
}
 // ReverseIterator
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ITERATOR_REVERSE_ITERATOR_HPP__