iterator.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_ALGORITHM_ITERATOR_HPP__
#define MSTL_CORE_ALGORITHM_ITERATOR_HPP__

 
#include "MSTL/core/typeinfo/concepts.hpp"
MSTL_BEGIN_NAMESPACE__

 
#ifndef MSTL_STANDARD_17__
MSTL_BEGIN_INNER__
template <typename Ptr, enable_if_t<is_pointer_v<Ptr>, int> = 0>
constexpr iter_pointer_t<Ptr> __to_pointer_aux(Ptr iter) {
    return iter;
}
template <typename Iterator, enable_if_t<!is_pointer_v<Iterator>, int> = 0>
constexpr iter_pointer_t<Iterator> __to_pointer_aux(Iterator iter) {
    return iter.operator->();
}
MSTL_END_INNER__
#endif // MSTL_STANDARD_17__

template <typename Iterator>
constexpr iter_pointer_t<Iterator> to_pointer(Iterator iter) {
#ifdef MSTL_STANDARD_17__
    if constexpr (is_pointer_v<Iterator>) {
        return iter;
    } else {
        return iter.operator ->();
    }
#else
    return _INNER __to_pointer_aux(iter);
#endif
}
 
 
#ifndef MSTL_STANDARD_17__
MSTL_BEGIN_INNER__
template <typename Iterator, typename Distance, enable_if_t<is_rnd_iter_v<Iterator>, int> = 0>
constexpr void __advance_aux(Iterator& i, Distance n) {
    i += n;
}
template <typename Iterator, typename Distance, enable_if_t<!is_rnd_iter_v<Iterator> && is_ranges_bid_iter_v<Iterator>, int> = 0>
constexpr void __advance_aux(Iterator& i, Distance n) {
    for (; n < 0; ++n) --i;
    for (; 0 < n; --n) ++i;
}
template <typename Iterator, typename Distance, enable_if_t<!is_rnd_iter_v<Iterator> && !is_ranges_bid_iter_v<Iterator>, int> = 0>
constexpr void __advance_aux(Iterator& i, Distance n) {
    MSTL_DEBUG_VERIFY__(is_signed_v<Distance> && n >= 0, "negative advance of non-bidirectional iterator");
    for (; 0 < n; --n) ++i;
}
MSTL_END_INNER__
#endif // MSTL_STANDARD_17__

template <typename Iterator, typename Distance, enable_if_t<is_iter_v<Iterator>, int> = 0>
constexpr void advance(Iterator& i, Distance n) {
#ifdef MSTL_STANDARD_17__
    if constexpr (is_rnd_iter_v<Iterator>) {
        i += n;
    } else {
        if constexpr (is_signed_v<Distance> && !is_bid_iter_v<Iterator>) {
            MSTL_DEBUG_VERIFY(n >= 0, "negative advance of non-bidirectional iterator");
        }
        if constexpr (is_signed_v<Distance> && is_bid_iter_v<Iterator>) {
            for (; n < 0; ++n) --i;
        }
        for (; 0 < n; --n) ++i;
    }
#else
    _INNER __advance_aux(i, n);
#endif
}

template <typename Iterator>
constexpr Iterator prev(Iterator iter, iter_difference_t<Iterator> n = -1) {
    MSTL_DEBUG_VERIFY(n <= 0, "negative advance in previous operation function.");
    _MSTL advance(iter, n);
    return iter;
}

template <typename Iterator>
constexpr Iterator next(Iterator iter, iter_difference_t<Iterator> n = 1) {
    MSTL_DEBUG_VERIFY(n >= 0, "positive advance in next operation function.");
    _MSTL advance(iter, n);
    return iter;
}
 
 
#ifndef MSTL_STANDARD_17__
MSTL_BEGIN_INNER__
template <typename Iterator, enable_if_t<is_rnd_iter_v<Iterator>, int> = 0>
constexpr iter_difference_t<Iterator> __distance_aux(Iterator first, Iterator last) {
    return last - first;
}
template <typename Iterator, enable_if_t<!is_rnd_iter_v<Iterator>, int> = 0>
constexpr iter_difference_t<Iterator> __distance_aux(Iterator first, Iterator last) {
    iter_difference_t<Iterator> n = 0;
    while (first != last) { ++first; ++n; }
    return n;
}
MSTL_END_INNER__
#endif // MSTL_STANDARD_17__

template <typename Iterator, enable_if_t<is_iter_v<Iterator>, int> = 0>
constexpr iter_difference_t<Iterator> distance(Iterator first, Iterator last) {
#ifdef MSTL_STANDARD_17__
    if constexpr (is_rnd_iter_v<Iterator>) {
        return last - first;
    } else {
        iter_difference_t<Iterator> n = 0;
        while (first != last) { ++first; ++n; }
        return n;
    }
#else
    return _INNER __distance_aux(first, last);
#endif
}
 // IteratorOperation
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_ALGORITHM_ITERATOR_HPP__