Range-v3
Range algorithms, views, and actions for the Standard Library
Iterator

Description

Iterator functionality.

Modules

 Iterator Concepts
 

Classes

struct  ranges::advance_fn
 
struct  ranges::back_insert_iterator< Container >
 
struct  ranges::back_inserter_fn
 
struct  ranges::basic_iterator< Cur >
 
struct  ranges::basic_mixin< T >
 
struct  ranges::common_iterator< I, S >
 
struct  ranges::contiguous_iterator_tag
 
struct  ranges::default_sentinel_t
 
struct  ranges::distance_compare_fn
 
struct  ranges::distance_fn
 
struct  ranges::enumerate_fn
 
struct  ranges::front_insert_iterator< Container >
 
struct  ranges::front_inserter_fn
 
struct  ranges::get_cursor_fn
 Get a cursor from a basic_iterator. More...
 
struct  ranges::incrementable_traits< T >
 
struct  ranges::incrementable_traits< T const >
 
struct  ranges::indirectly_readable_traits< T >
 
struct  ranges::indirectly_readable_traits< common_iterator< I, S > >
 
struct  ranges::indirectly_readable_traits< T const >
 
struct  ranges::insert_iterator< Container >
 
struct  ranges::inserter_fn
 
struct  ranges::is_indirectly_movable< I, O >
 
struct  ranges::is_indirectly_swappable< T, U >
 
struct  ranges::is_nothrow_indirectly_movable< I, O >
 
struct  ranges::is_nothrow_indirectly_swappable< T, U >
 
struct  ranges::iter_distance_compare_fn
 
struct  ranges::iter_distance_fn
 
struct  ranges::iter_enumerate_fn
 
struct  ranges::iter_size_fn
 
struct  ranges::make_move_iterator_fn
 
struct  ranges::make_move_sentinel_fn
 
struct  ranges::make_ostream_joiner_fn
 
struct  ranges::make_reverse_iterator_fn
 
struct  ranges::move_into_fn
 
struct  ranges::move_iterator< I >
 
struct  ranges::move_sentinel< S >
 
struct  ranges::next_fn
 
struct  ranges::ostream_iterator< T, Char, Traits >
 
struct  ranges::ostream_joiner< Delim, Char, Traits >
 
struct  ranges::ostreambuf_iterator< Char, Traits >
 
struct  ranges::prev_fn
 
struct  ranges::unreachable_sentinel_t
 

Typedefs

template<typename I >
using ranges::iter_common_reference_t = common_reference_t< iter_reference_t< I >, iter_value_t< I > & >
 
template<typename T >
using ranges::iter_difference_t = typename incrementable_traits< uncvref_t< T > >::difference_type
 
template<typename R >
using ranges::iter_reference_t = detail::iter_reference_t_< R >
 
template<typename I >
using ranges::iter_rvalue_reference_t = detail::iter_rvalue_reference_t< I >
 
template<typename R >
using ranges::iter_value_t = detail::iter_value_t_< uncvref_t< R > >
 

Functions

template<typename Cur , typename Cur2 >
constexpr bool ranges::operator!= (basic_iterator< Cur > const &left, basic_iterator< Cur2 > const &right)
 
template<typename Cur , typename S >
constexpr bool ranges::operator!= (basic_iterator< Cur > const &left, S const &right)
 
template<typename I1 , typename I2 , typename S1 , typename S2 >
bool ranges::operator!= (common_iterator< I1, S1 > const &x, common_iterator< I2, S2 > const &y)
 
template<typename S , typename Cur >
constexpr bool ranges::operator!= (S const &left, basic_iterator< Cur > const &right)
 
template<typename Cur >
constexpr basic_iterator< Cur > ranges::operator+ (basic_iterator< Cur > left, typename basic_iterator< Cur >::difference_type n)
 
template<typename Cur >
constexpr basic_iterator< Cur > ranges::operator+ (typename basic_iterator< Cur >::difference_type n, basic_iterator< Cur > right)
 
template<typename Cur , typename S >
constexpr basic_iterator< Cur >::difference_type ranges::operator- (basic_iterator< Cur > const &left, S const &right)
 
template<typename Cur >
constexpr basic_iterator< Cur > ranges::operator- (basic_iterator< Cur > left, typename basic_iterator< Cur >::difference_type n)
 
template<typename Cur2 , typename Cur >
constexpr basic_iterator< Cur >::difference_type ranges::operator- (basic_iterator< Cur2 > const &left, basic_iterator< Cur > const &right)
 
template<typename I1 , typename I2 , typename S1 , typename S2 >
iter_difference_t< I2 > ranges::operator- (common_iterator< I1, S1 > const &x, common_iterator< I2, S2 > const &y)
 
template<typename S , typename Cur >
constexpr basic_iterator< Cur >::difference_type ranges::operator- (S const &left, basic_iterator< Cur > const &right)
 
template<typename Left , typename Right >
constexpr bool ranges::operator< (basic_iterator< Left > const &left, basic_iterator< Right > const &right)
 
template<typename Left , typename Right >
constexpr bool ranges::operator<= (basic_iterator< Left > const &left, basic_iterator< Right > const &right)
 
template<typename Cur , typename Cur2 >
constexpr bool ranges::operator== (basic_iterator< Cur > const &left, basic_iterator< Cur2 > const &right)
 
template<typename Cur , typename S >
constexpr bool ranges::operator== (basic_iterator< Cur > const &left, S const &right)
 
template<typename I1 , typename I2 , typename S1 , typename S2 >
bool ranges::operator== (common_iterator< I1, S1 > const &x, common_iterator< I2, S2 > const &y)
 
template<typename S , typename Cur >
constexpr bool ranges::operator== (S const &left, basic_iterator< Cur > const &right)
 
template<typename Left , typename Right >
constexpr bool ranges::operator> (basic_iterator< Left > const &left, basic_iterator< Right > const &right)
 
template<typename Left , typename Right >
constexpr bool ranges::operator>= (basic_iterator< Left > const &left, basic_iterator< Right > const &right)
 

Variables

constexpr advance_fn ranges::advance {}
 
constexpr back_inserter_fn ranges::back_inserter {}
 
constexpr default_sentinel_t ranges::default_sentinel {}
 
constexpr distance_fn ranges::distance {}
 
constexpr distance_compare_fn ranges::distance_compare {}
 
constexpr enumerate_fn ranges::enumerate {}
 
constexpr front_inserter_fn ranges::front_inserter {}
 
constexpr get_cursor_fn ranges::get_cursor {}
 
constexpr inserter_fn ranges::inserter {}
 
template<typename I , typename O >
constexpr bool ranges::is_indirectly_movable_v
 
template<typename T , typename U >
constexpr bool ranges::is_indirectly_swappable_v
 
template<typename I , typename O >
constexpr bool ranges::is_nothrow_indirectly_movable_v
 
template<typename T , typename U >
constexpr bool ranges::is_nothrow_indirectly_swappable_v
 
constexpr iter_distance_fn ranges::iter_distance {}
 
constexpr iter_distance_compare_fn ranges::iter_distance_compare {}
 
constexpr iter_enumerate_fn ranges::iter_enumerate {}
 
constexpr _iter_move_::fn ranges::iter_move {}
 
constexpr iter_size_fn ranges::iter_size {}
 
constexpr _iter_swap_::fn iter_swap {}
 
constexpr make_move_iterator_fn ranges::make_move_iterator {}
 
constexpr make_move_sentinel_fn ranges::make_move_sentinel {}
 
constexpr make_ostream_joiner_fn ranges::make_ostream_joiner {}
 
constexpr make_reverse_iterator_fn ranges::make_reverse_iterator {}
 
constexpr move_into_fn ranges::move_into {}
 
constexpr next_fn ranges::next {}
 
constexpr prev_fn ranges::prev {}
 
constexpr adl_uncounted_recounted_detail::recounted_fn ranges::recounted {}
 
constexpr adl_uncounted_recounted_detail::uncounted_fn ranges::uncounted {}
 
constexpr unreachable_sentinel_t ranges::unreachable {}
 

Function Documentation

◆ operator!=() [1/4]

template<typename Cur , typename Cur2 >
constexpr bool ranges::operator!= ( basic_iterator< Cur > const &  left,
basic_iterator< Cur2 > const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sentinel_for_cursor<Cur2, Cur>

◆ operator!=() [2/4]

template<typename Cur , typename S >
constexpr bool ranges::operator!= ( basic_iterator< Cur > const &  left,
S const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sentinel_for_cursor<S, Cur>

◆ operator!=() [3/4]

template<typename I1 , typename I2 , typename S1 , typename S2 >
bool ranges::operator!= ( common_iterator< I1, S1 > const &  x,
common_iterator< I2, S2 > const &  y 
)

#include <range/v3/iterator/common_iterator.hpp>

Precondition
requires sentinel_for<S1, I2> && sentinel_for<S2, I1>

◆ operator!=() [4/4]

template<typename S , typename Cur >
constexpr bool ranges::operator!= ( S const &  left,
basic_iterator< Cur > const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sentinel_for_cursor<S, Cur>

◆ operator+() [1/2]

template<typename Cur >
constexpr basic_iterator<Cur> ranges::operator+ ( basic_iterator< Cur >  left,
typename basic_iterator< Cur >::difference_type  n 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::random_access_cursor<Cur>

◆ operator+() [2/2]

template<typename Cur >
constexpr basic_iterator<Cur> ranges::operator+ ( typename basic_iterator< Cur >::difference_type  n,
basic_iterator< Cur >  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::random_access_cursor<Cur>

◆ operator-() [1/5]

template<typename Cur , typename S >
constexpr basic_iterator<Cur>::difference_type ranges::operator- ( basic_iterator< Cur > const &  left,
S const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sized_sentinel_for_cursor<S, Cur>

◆ operator-() [2/5]

template<typename Cur >
constexpr basic_iterator<Cur> ranges::operator- ( basic_iterator< Cur >  left,
typename basic_iterator< Cur >::difference_type  n 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::random_access_cursor<Cur>

◆ operator-() [3/5]

template<typename Cur2 , typename Cur >
constexpr basic_iterator<Cur>::difference_type ranges::operator- ( basic_iterator< Cur2 > const &  left,
basic_iterator< Cur > const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sized_sentinel_for_cursor<Cur2, Cur>

◆ operator-() [4/5]

template<typename I1 , typename I2 , typename S1 , typename S2 >
iter_difference_t<I2> ranges::operator- ( common_iterator< I1, S1 > const &  x,
common_iterator< I2, S2 > const &  y 
)

#include <range/v3/iterator/common_iterator.hpp>

Precondition
requires sized_sentinel_for<I1, I2> && sized_sentinel_for<S1, I2> && sized_sentinel_for<S2, I1>

◆ operator-() [5/5]

template<typename S , typename Cur >
constexpr basic_iterator<Cur>::difference_type ranges::operator- ( S const &  left,
basic_iterator< Cur > const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sized_sentinel_for_cursor<S, Cur>

◆ operator<()

template<typename Left , typename Right >
constexpr bool ranges::operator< ( basic_iterator< Left > const &  left,
basic_iterator< Right > const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sized_sentinel_for_cursor<Right, Left>

◆ operator<=()

template<typename Left , typename Right >
constexpr bool ranges::operator<= ( basic_iterator< Left > const &  left,
basic_iterator< Right > const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sized_sentinel_for_cursor<Right, Left>

◆ operator==() [1/4]

template<typename Cur , typename Cur2 >
constexpr bool ranges::operator== ( basic_iterator< Cur > const &  left,
basic_iterator< Cur2 > const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sentinel_for_cursor<Cur2, Cur>

◆ operator==() [2/4]

template<typename Cur , typename S >
constexpr bool ranges::operator== ( basic_iterator< Cur > const &  left,
S const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sentinel_for_cursor<S, Cur>

◆ operator==() [3/4]

template<typename I1 , typename I2 , typename S1 , typename S2 >
bool ranges::operator== ( common_iterator< I1, S1 > const &  x,
common_iterator< I2, S2 > const &  y 
)

#include <range/v3/iterator/common_iterator.hpp>

Precondition
requires sentinel_for<S1, I2> && sentinel_for<S2, I1> && (!equality_comparable_with<I1, I2>) //
requires sentinel_for<S1, I2> && sentinel_for<S2, I1> && equality_comparable_with<I1, I2>

◆ operator==() [4/4]

template<typename S , typename Cur >
constexpr bool ranges::operator== ( S const &  left,
basic_iterator< Cur > const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sentinel_for_cursor<S, Cur>

◆ operator>()

template<typename Left , typename Right >
constexpr bool ranges::operator> ( basic_iterator< Left > const &  left,
basic_iterator< Right > const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sized_sentinel_for_cursor<Right, Left>

◆ operator>=()

template<typename Left , typename Right >
constexpr bool ranges::operator>= ( basic_iterator< Left > const &  left,
basic_iterator< Right > const &  right 
)
constexpr

#include <range/v3/iterator/basic_iterator.hpp>

Precondition
requires detail::sized_sentinel_for_cursor<Right, Left>

Variable Documentation

◆ advance

constexpr advance_fn ranges::advance {}
constexpr

◆ back_inserter

constexpr back_inserter_fn ranges::back_inserter {}
constexpr

◆ distance

constexpr distance_fn ranges::distance {}
constexpr

◆ distance_compare

constexpr distance_compare_fn ranges::distance_compare {}
constexpr

◆ enumerate

constexpr enumerate_fn ranges::enumerate {}
related

◆ front_inserter

constexpr front_inserter_fn ranges::front_inserter {}
constexpr

◆ get_cursor

constexpr get_cursor_fn ranges::get_cursor {}
constexpr

◆ inserter

constexpr inserter_fn ranges::inserter {}
constexpr

◆ is_indirectly_movable_v

template<typename I , typename O >
constexpr bool ranges::is_indirectly_movable_v
constexpr

#include <range/v3/iterator/access.hpp>

Initial value:
=
decltype(detail::is_indirectly_movable_<I, O>(nullptr, nullptr))::value

◆ is_indirectly_swappable_v

template<typename T , typename U >
constexpr bool ranges::is_indirectly_swappable_v
constexpr

#include <range/v3/iterator/access.hpp>

Initial value:
=
decltype(detail::is_indirectly_swappable_<T, U>(nullptr, nullptr))::value

◆ is_nothrow_indirectly_movable_v

template<typename I , typename O >
constexpr bool ranges::is_nothrow_indirectly_movable_v
constexpr

#include <range/v3/iterator/access.hpp>

Initial value:
=
decltype(detail::is_nothrow_indirectly_movable_<I, O>(nullptr))::value

◆ is_nothrow_indirectly_swappable_v

template<typename T , typename U >
constexpr bool ranges::is_nothrow_indirectly_swappable_v
constexpr

#include <range/v3/iterator/access.hpp>

Initial value:
=
decltype(detail::is_nothrow_indirectly_swappable_<T, U>(0))::value

◆ iter_distance

constexpr iter_distance_fn ranges::iter_distance {}
constexpr

◆ iter_distance_compare

constexpr iter_distance_compare_fn ranges::iter_distance_compare {}
constexpr

◆ iter_enumerate

constexpr iter_enumerate_fn ranges::iter_enumerate {}
constexpr

◆ iter_size

constexpr iter_size_fn ranges::iter_size {}
constexpr

◆ iter_swap

constexpr _iter_swap_::fn iter_swap {}
constexpr

◆ make_ostream_joiner

constexpr make_ostream_joiner_fn ranges::make_ostream_joiner {}
constexpr

◆ move_into

constexpr move_into_fn ranges::move_into {}
constexpr

◆ next

constexpr next_fn ranges::next {}
constexpr

◆ prev

constexpr prev_fn ranges::prev {}
constexpr