normal_iterator.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ITERATOR_NORMAL_ITERATOR_HPP__
#define NEFORCE_CORE_ITERATOR_NORMAL_ITERATOR_HPP__

 
#include "NeForce/core/typeinfo/type_traits.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename Iterator>
class normal_iterator {
public:
    using iterator_type = Iterator;                      
    using iterator_category = iter_category_t<Iterator>; 
    using value_type = iter_value_t<Iterator>;           
    using difference_type = iter_difference_t<Iterator>; 
    using reference = iter_reference_t<Iterator>;        
    using pointer = iter_pointer_t<Iterator>;            
 
private:
    Iterator current_{}; 
 
public:
    constexpr normal_iterator() noexcept(is_nothrow_default_constructible_v<Iterator>) {}

    explicit constexpr normal_iterator(const Iterator& iter) noexcept(is_nothrow_copy_constructible_v<Iterator>) :
    current_(iter) {}

    template <typename Iter, enable_if_t<is_convertible_v<Iter, Iterator>, int> = 0>
    constexpr normal_iterator(const normal_iterator<Iter>& other) noexcept(is_nothrow_copy_constructible_v<Iterator>) :
    current_(other.base()) {}

    constexpr reference operator*() const noexcept { return *current_; }

    constexpr pointer operator->() const noexcept { return current_; }

    constexpr normal_iterator& operator++() noexcept(noexcept(++current_)) {
        ++current_;
        return *this;
    }

    constexpr normal_iterator operator++(int) noexcept(noexcept(current_++)) { return normal_iterator(current_++); }

    constexpr normal_iterator& operator--() noexcept(noexcept(--current_)) {
        --current_;
        return *this;
    }

    constexpr normal_iterator operator--(int) noexcept(noexcept(current_--)) { return normal_iterator(current_--); }

    constexpr reference operator[](difference_type n) const noexcept { return current_[n]; }

    constexpr normal_iterator& operator+=(difference_type n) noexcept(noexcept(current_ += n)) {
        current_ += n;
        return *this;
    }

    constexpr normal_iterator operator+(difference_type n) const noexcept(noexcept(current_ + n)) {
        return normal_iterator(current_ + n);
    }

    constexpr normal_iterator& operator-=(difference_type n) noexcept(noexcept(current_ -= n)) {
        current_ -= n;
        return *this;
    }

    constexpr normal_iterator operator-(difference_type n) const noexcept(noexcept(current_ - n)) {
        return normal_iterator(current_ - n);
    }

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

template <typename LeftIter, typename RightIter>
NEFORCE_NODISCARD constexpr bool operator==(const normal_iterator<LeftIter>& lhs,
                                            const normal_iterator<RightIter>& rhs) noexcept {
    return lhs.base() == rhs.base();
}

template <typename Iterator>
NEFORCE_NODISCARD constexpr bool operator==(const normal_iterator<Iterator>& lhs,
                                            const normal_iterator<Iterator>& rhs) noexcept {
    return lhs.base() == rhs.base();
}

template <typename LeftIter, typename RightIter>
NEFORCE_NODISCARD constexpr bool operator!=(const normal_iterator<LeftIter>& lhs,
                                            const normal_iterator<RightIter>& rhs) noexcept {
    return lhs.base() != rhs.base();
}

template <typename Iterator>
NEFORCE_NODISCARD constexpr bool operator!=(const normal_iterator<Iterator>& lhs,
                                            const normal_iterator<Iterator>& rhs) noexcept {
    return lhs.base() != rhs.base();
}

template <typename LeftIter, typename RightIter>
NEFORCE_NODISCARD constexpr bool operator<(const normal_iterator<LeftIter>& lhs,
                                           const normal_iterator<RightIter>& rhs) noexcept {
    return lhs.base() < rhs.base();
}

template <typename Iterator>
NEFORCE_NODISCARD constexpr bool operator<(const normal_iterator<Iterator>& lhs,
                                           const normal_iterator<Iterator>& rhs) noexcept {
    return lhs.base() < rhs.base();
}

template <typename LeftIter, typename RightIter>
NEFORCE_NODISCARD constexpr bool operator>(const normal_iterator<LeftIter>& lhs,
                                           const normal_iterator<RightIter>& rhs) noexcept {
    return lhs.base() > rhs.base();
}

template <typename Iterator>
NEFORCE_NODISCARD constexpr bool operator>(const normal_iterator<Iterator>& lhs,
                                           const normal_iterator<Iterator>& rhs) noexcept {
    return lhs.base() > rhs.base();
}

template <typename LeftIter, typename RightIter>
NEFORCE_NODISCARD constexpr bool operator<=(const normal_iterator<LeftIter>& lhs,
                                            const normal_iterator<RightIter>& rhs) noexcept {
    return lhs.base() <= rhs.base();
}

template <typename Iterator>
NEFORCE_NODISCARD constexpr bool operator<=(const normal_iterator<Iterator>& lhs,
                                            const normal_iterator<Iterator>& rhs) noexcept {
    return lhs.base() <= rhs.base();
}

template <typename LeftIter, typename RightIter>
NEFORCE_NODISCARD constexpr bool operator>=(const normal_iterator<LeftIter>& lhs,
                                            const normal_iterator<RightIter>& rhs) noexcept {
    return lhs.base() >= rhs.base();
}

template <typename Iterator>
NEFORCE_NODISCARD constexpr bool operator>=(const normal_iterator<Iterator>& lhs,
                                            const normal_iterator<Iterator>& rhs) noexcept {
    return lhs.base() >= rhs.base();
}

template <typename LeftIter, typename RightIter>
NEFORCE_NODISCARD constexpr auto operator-(const normal_iterator<LeftIter>& lhs,
                                           const normal_iterator<RightIter>& rhs) noexcept
        -> decltype(lhs.base() - rhs.base()) {
    return lhs.base() - rhs.base();
}

template <typename Iterator>
NEFORCE_NODISCARD constexpr typename normal_iterator<Iterator>::difference_type
operator-(const normal_iterator<Iterator>& lhs, const normal_iterator<Iterator>& rhs) noexcept {
    return lhs.base() - rhs.base();
}

template <typename Iterator>
NEFORCE_NODISCARD constexpr normal_iterator<Iterator> operator+(iter_difference_t<normal_iterator<Iterator>> n,
                                                                const normal_iterator<Iterator>& iter) noexcept {
    return normal_iterator<Iterator>(iter.base() + n);
}
 // NormalIterators
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ITERATOR_NORMAL_ITERATOR_HPP__