normal_iterator.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_ITERATOR_NORMAL_ITERATOR_HPP__
#define MSTL_CORE_ITERATOR_NORMAL_ITERATOR_HPP__

 
#include "MSTL/core/typeinfo/type_traits.hpp"
MSTL_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>
MSTL_NODISCARD constexpr bool operator ==(
    const normal_iterator<LeftIter>& lhs,
    const normal_iterator<RightIter>& rhs) noexcept { 
    return lhs.base() == rhs.base(); 
}

template <typename Iterator>
MSTL_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>
MSTL_NODISCARD constexpr bool operator !=(
    const normal_iterator<LeftIter>& lhs,
    const normal_iterator<RightIter>& rhs) noexcept { 
    return lhs.base() != rhs.base(); 
}

template <typename Iterator>
MSTL_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>
MSTL_NODISCARD constexpr bool operator <(
    const normal_iterator<LeftIter>& lhs,
    const normal_iterator<RightIter>& rhs) noexcept { 
    return lhs.base() < rhs.base(); 
}

template <typename Iterator>
MSTL_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>
MSTL_NODISCARD constexpr bool operator >(
    const normal_iterator<LeftIter>& lhs,
    const normal_iterator<RightIter>& rhs) noexcept { 
    return lhs.base() > rhs.base(); 
}

template <typename Iterator>
MSTL_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>
MSTL_NODISCARD constexpr bool operator <=(
    const normal_iterator<LeftIter>& lhs,
    const normal_iterator<RightIter>& rhs) noexcept { 
    return lhs.base() <= rhs.base(); 
}

template <typename Iterator>
MSTL_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>
MSTL_NODISCARD constexpr bool operator >=(
    const normal_iterator<LeftIter>& lhs,
    const normal_iterator<RightIter>& rhs) noexcept { 
    return lhs.base() >= rhs.base(); 
}

template <typename Iterator>
MSTL_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>
MSTL_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>
MSTL_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>
MSTL_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
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_ITERATOR_NORMAL_ITERATOR_HPP__