iterator.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ALGORITHM_ITERATOR_HPP__
#define NEFORCE_CORE_ALGORITHM_ITERATOR_HPP__

 
#include "NeForce/core/exception/breakpoint.hpp"
#include "NeForce/core/typeinfo/concepts.hpp"
NEFORCE_BEGIN_NAMESPACE__

 
#ifndef NEFORCE_STANDARD_17
NEFORCE_BEGIN_INNER__
 
template <typename Ptr>
constexpr enable_if_t<is_pointer_v<Ptr>, iter_pointer_t<Ptr>> __to_pointer_aux(Ptr iter) {
    return iter;
}
 
template <typename Iterator>
constexpr enable_if_t<!is_pointer_v<Iterator>, iter_pointer_t<Iterator>> __to_pointer_aux(Iterator iter) {
    return iter.operator->();
}
 
NEFORCE_END_INNER__
#endif // NEFORCE_STANDARD_17

template <typename Iterator>
constexpr iter_pointer_t<Iterator> to_pointer(Iterator iter) {
#ifdef NEFORCE_STANDARD_17
    if constexpr (is_pointer_v<Iterator>) {
        return iter;
    } else {
        return iter.operator->();
    }
#else
    return inner::__to_pointer_aux(iter);
#endif
}
 
 
#ifndef NEFORCE_STANDARD_17
NEFORCE_BEGIN_INNER__
 
template <typename Iterator, typename Distance>
constexpr enable_if_t<is_rnd_iter_v<Iterator>> __advance_aux(Iterator& i, Distance n) {
    i += n;
}
 
template <typename Iterator, typename Distance>
constexpr enable_if_t<!is_rnd_iter_v<Iterator> && is_ranges_bid_iter_v<Iterator>> __advance_aux(Iterator& i,
                                                                                                Distance n) {
    for (; n < 0; ++n) {
        --i;
    }
    for (; 0 < n; --n) {
        ++i;
    }
}
 
template <typename Iterator, typename Distance>
constexpr enable_if_t<!is_rnd_iter_v<Iterator> && !is_ranges_bid_iter_v<Iterator>> __advance_aux(Iterator& i,
                                                                                                 Distance n) {
    NEFORCE_DEBUG_VERIFY__(is_signed_v<Distance> && n >= 0, "negative advance of non-bidirectional iterator");
    for (; 0 < n; --n) {
        ++i;
    }
}
 
NEFORCE_END_INNER__
#endif // NEFORCE_STANDARD_17

template <typename Iterator, typename Distance>
constexpr void advance(Iterator& i, Distance n) {
    static_assert(is_iter_v<Iterator>, "Iterator must be iterator");
    static_assert(is_arithmetic_v<Distance>, "Distance must be arithmetic");
 
#ifdef NEFORCE_STANDARD_17
    if constexpr (is_rnd_iter_v<Iterator>) {
        i += n;
    } else {
        if constexpr (is_signed_v<Distance> && !is_bid_iter_v<Iterator>) {
            NEFORCE_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) {
    NEFORCE_DEBUG_VERIFY(n <= 0, "negative advance in previous operation function.");
    _NEFORCE advance(iter, n);
    return iter;
}

template <typename Iterator>
constexpr Iterator next(Iterator iter, iter_difference_t<Iterator> n = 1) {
    NEFORCE_DEBUG_VERIFY(n >= 0, "positive advance in next operation function.");
    _NEFORCE advance(iter, n);
    return iter;
}
 
 
#ifndef NEFORCE_STANDARD_17
NEFORCE_BEGIN_INNER__
 
template <typename Iterator>
constexpr enable_if_t<is_rnd_iter_v<Iterator>, iter_difference_t<Iterator>> __distance_aux(Iterator first,
                                                                                           Iterator last) {
    return last - first;
}
 
template <typename Iterator>
constexpr enable_if_t<!is_rnd_iter_v<Iterator>, iter_difference_t<Iterator>> __distance_aux(Iterator first,
                                                                                            Iterator last) {
    iter_difference_t<Iterator> n = 0;
    while (first != last) {
        ++first;
        ++n;
    }
    return n;
}
 
NEFORCE_END_INNER__
#endif // NEFORCE_STANDARD_17

template <typename Iterator>
constexpr iter_difference_t<Iterator> distance(Iterator first, Iterator last) {
    static_assert(is_iter_v<Iterator>, "Iterator must be iterator");
 
#ifdef NEFORCE_STANDARD_17
    if constexpr (is_ranges_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
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ALGORITHM_ITERATOR_HPP__