Description

Iterator functionality.

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< detail::projected_< I, Proj > >

struct	ranges::incrementable_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::readable_traits< T >

struct	ranges::readable_traits< common_iterator< I, S > >

struct	ranges::readable_traits< T const >

struct	ranges::sentinel_tag

struct	ranges::sized_sentinel_tag

struct	ranges::unreachable_sentinel_t

Typedefs
template<typename Fun , typename... Is>
using	ranges::indirect_result_t = detail::enable_if_t<(bool) and_v<(bool) readable< Is >... >, invoke_result_t< Fun, iter_reference_t< Is >... > >

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< 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 > >

template<typename Rng >
using	ranges::iterator_tag_of = std::enable_if_t< input_iterator< Rng >, detail::if_then_t< contiguous_iterator< Rng >, ranges::contiguous_iterator_tag, detail::if_then_t< random_access_iterator< Rng >, std::random_access_iterator_tag, detail::if_then_t< bidirectional_iterator< Rng >, std::bidirectional_iterator_tag, detail::if_then_t< forward_iterator< Rng >, std::forward_iterator_tag, std::input_iterator_tag > >> >>

template<typename I , typename Proj >
using	ranges::projected = typename detail::select_projected_< Proj >::template apply< I >

template<typename S , typename I >
using	ranges::sentinel_tag_of = std::enable_if_t< sentinel_for< S, I >, detail::if_then_t< sized_sentinel_for< S, I >, sized_sentinel_tag, sentinel_tag > >

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

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

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

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

template<typename Cur >
constexpr auto	ranges::operator+ (basic_iterator< Cur > left, typename basic_iterator< Cur >::difference_type n) -> basic_iterator< Cur > requires detail::random_access_cursor< Cur >

template<typename Cur >
constexpr auto	ranges::operator+ (typename basic_iterator< Cur >::difference_type n, basic_iterator< Cur > right) -> basic_iterator< Cur > requires detail::random_access_cursor< Cur >

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

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

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

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

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

template<typename Left , typename Right >
constexpr auto	ranges::operator< (basic_iterator< Left > const &left, basic_iterator< Right > const &right) -> bool requires detail::sized_sentinel_for_cursor< Right, Left >

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

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

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

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

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

template<typename Left , typename Right >
constexpr auto	ranges::operator> (basic_iterator< Left > const &left, basic_iterator< Right > const &right) -> bool requires detail::sized_sentinel_for_cursor< Right, Left >

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

Variables
constexpr advance_fn	ranges::advance {}

constexpr back_inserter_fn	ranges::back_inserter {}

template<typename I >
concept	ranges::bidirectional_iterator

template<typename I >
concept	ranges::contiguous_iterator

template<typename I >
concept	ranges::contiguous_iterator_ = std::is_lvalue_reference<iter_reference_t<I>>::value && same_as<iter_value_t<I>, uncvref_t<iter_reference_t<I>>> && derived_from<detail::iter_concept_t<I>, ranges::contiguous_iterator_tag>

constexpr default_sentinel_t	ranges::default_sentinel {}

constexpr distance_fn	ranges::distance {}

constexpr distance_compare_fn	ranges::distance_compare {}

constexpr enumerate_fn	ranges::enumerate {}

template<typename I >
concept	ranges::forward_iterator

constexpr front_inserter_fn	ranges::front_inserter {}

constexpr get_cursor_fn	ranges::get_cursor {}

template<typename I >
concept i	ranges::i = n

template<typename I >
concept	ranges::incrementable

template<typename F , typename I1 , typename I2 >
concept	ranges::indirect_binary_predicate_

template<typename F , typename I1 , typename I2 >
concept	ranges::indirect_binary_predicate_frag_ = predicate<F &, iter_value_t<I1> &, iter_value_t<I2> &> && predicate<F &, iter_value_t<I1> &, iter_reference_t<I2>> && predicate<F &, iter_reference_t<I1>, iter_value_t<I2> &> && predicate<F &, iter_reference_t<I1>, iter_reference_t<I2>> && predicate<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>

template<typename F , typename I1 , typename I2 = I1>
concept	ranges::indirect_relation

template<typename F , typename I1 , typename I2 >
concept	ranges::indirect_relation_ = relation<F &, iter_value_t<I1> &, iter_value_t<I2> &> && relation<F &, iter_value_t<I1> &, iter_reference_t<I2>> && relation<F &, iter_reference_t<I1>, iter_value_t<I2> &> && relation<F &, iter_reference_t<I1>, iter_reference_t<I2>> && relation<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>

template<typename F , typename I1 , typename I2 = I1>
concept	ranges::indirect_strict_weak_order

template<typename F , typename I1 , typename I2 >
concept	ranges::indirect_strict_weak_order_ = strict_weak_order<F &, iter_value_t<I1> &, iter_value_t<I2> &> && strict_weak_order<F &, iter_value_t<I1> &, iter_reference_t<I2>> && strict_weak_order<F &, iter_reference_t<I1>, iter_value_t<I2> &> && strict_weak_order<F &, iter_reference_t<I1>, iter_reference_t<I2>> && strict_weak_order<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>

template<typename F , typename I >
concept	ranges::indirect_unary_predicate

template<typename F , typename I >
concept	ranges::indirect_unary_predicate_ = predicate<F &, iter_value_t<I> &> && predicate<F &, iter_reference_t<I>> && predicate<F &, iter_common_reference_t<I>>

template<typename I1 , typename I2 , typename C , typename P1 = identity, typename P2 = identity>
concept	ranges::indirectly_comparable

template<typename I , typename O >
concept	ranges::indirectly_copyable

template<typename I , typename O >
concept	ranges::indirectly_copyable_ = writable<O, iter_reference_t<I>>

template<typename I , typename O >
concept	ranges::indirectly_copyable_storable

template<typename I , typename O >
concept	ranges::indirectly_copyable_storable_ = writable<O, iter_value_t<I> const &> && copyable<iter_value_t<I>> && constructible_from<iter_value_t<I>, iter_reference_t<I>> && assignable_from<iter_value_t<I> &, iter_reference_t<I>>

template<typename I , typename O >
concept	ranges::indirectly_movable

template<typename I , typename O >
concept	ranges::indirectly_movable_ = writable<O, iter_rvalue_reference_t<I>>

template<typename I , typename O >
concept	ranges::indirectly_movable_storable

template<typename I , typename O >
concept	ranges::indirectly_movable_storable_ = writable<O, iter_value_t<I>> && movable<iter_value_t<I>> && constructible_from<iter_value_t<I>, iter_rvalue_reference_t<I>> && assignable_from<iter_value_t<I> &, iter_rvalue_reference_t<I>>

template<typename F , typename I >
concept	ranges::indirectly_regular_unary_invocable

template<typename F , typename I >
concept	ranges::indirectly_regular_unary_invocable_ = regular_invocable<F &, iter_value_t<I> &> && regular_invocable<F &, iter_reference_t<I>> && regular_invocable<F &, iter_common_reference_t<I>> && common_reference_with< invoke_result_t<F &, iter_value_t<I> &>, invoke_result_t<F &, iter_reference_t<I>>>

template<typename I1 , typename I2 = I1>
concept	ranges::indirectly_swappable

template<typename F , typename I >
concept	ranges::indirectly_unary_invocable

template<typename I >
concept	ranges::input_iterator

template<typename I >
concept	ranges::input_or_output_iterator

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 {}

template<typename I1 , typename I2 , typename Out , typename C = less, typename P1 = identity, typename P2 = identity>
concept	ranges::mergeable

constexpr move_into_fn	ranges::move_into {}

template<typename I >
concept i	ranges::n

constexpr next_fn	ranges::next {}

template<typename Out , typename T >
concept	ranges::output_iterator

template<typename I >
concept	ranges::permutable

constexpr prev_fn	ranges::prev {}

template<typename C , typename I1 , typename P1 , typename I2 , typename P2 >
concept	ranges::projected_indirect_relation_ = indirect_relation<C, projected<I1, P1>, projected<I2, P2>>

template<typename C , typename I1 , typename P1 , typename I2 , typename P2 >
concept	ranges::projected_indirect_strict_weak_order_ = indirect_strict_weak_order<C, projected<I1, P1>, projected<I2, P2>>

template<typename I >
concept	ranges::random_access_iterator

template<typename I >
concept	ranges::readable

template<typename I >
concept	ranges::readable_ = common_reference_with<iter_reference_t<I> &&, iter_value_t<I> &> && common_reference_with<iter_reference_t<I> &&, iter_rvalue_reference_t<I> &&> && common_reference_with<iter_rvalue_reference_t<I> &&, iter_value_t<I> const &>

constexpr adl_uncounted_recounted_detail::recounted_fn	ranges::recounted {}

template<typename S , typename I >
concept	ranges::sentinel_for

template<typename S , typename I >
concept	ranges::sized_sentinel_for

template<typename I , typename C = less, typename P = identity>
concept	ranges::sortable

constexpr adl_uncounted_recounted_detail::uncounted_fn	ranges::uncounted {}

constexpr unreachable_sentinel_t	ranges::unreachable {}

template<typename I >
concept	ranges::weakly_incrementable

template<typename I >
concept	ranges::weakly_incrementable_ = concepts::type<iter_difference_t<I>> && detail::signed_integer_like_<iter_difference_t<I>>

template<typename I , typename Tag >
concept	ranges::with_category_ = derived_from<detail::iter_concept_t<I>, Tag>

template<typename Out , typename T >
concept	ranges::writable

Variable Documentation

◆ advance

constexpr advance_fn ranges::advance {}

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

See also: advance_fn

◆ back_inserter

constexpr back_inserter_fn ranges::back_inserter {}

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

See also: back_inserter_fn

◆ bidirectional_iterator

template<typename I >

concept ranges::bidirectional_iterator

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

Initial value:

=
        requires(   I  i )      
        (
            --i,
            i--,
            concepts::requires_<same_as<I&, decltype(--i)>>,
            concepts::requires_<same_as<I, decltype(i--)>>
        ) &&
        forward_iterator<I> &&
         ranges::with_category_ < I, std::bidirectional_iterator_tag >

◆ contiguous_iterator

template<typename I >

concept ranges::contiguous_iterator

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

Initial value:

=
        random_access_iterator<I> &&
         ranges::contiguous_iterator_ < I >

◆ distance

constexpr distance_fn ranges::distance {}

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

See also: distance_fn

◆ distance_compare

constexpr distance_compare_fn ranges::distance_compare {}

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

See also: distance_compare_fn

◆ enumerate

constexpr enumerate_fn ranges::enumerate {}

See also: enumerate_fn

◆ forward_iterator

template<typename I >

concept ranges::forward_iterator

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

Initial value:

=
        input_iterator<I> && incrementable<I> &&
        sentinel_for<I, I> &&
         ranges::with_category_ < I, std::forward_iterator_tag >

◆ front_inserter

constexpr front_inserter_fn ranges::front_inserter {}

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

See also: front_inserter_fn

◆ get_cursor

constexpr get_cursor_fn ranges::get_cursor {}

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

See also: get_cursor_fn

◆ incrementable

template<typename I >

concept ranges::incrementable

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

Initial value:

=
        regular<I> && weakly_incrementable<I> &&
        requires(   I  i )      
        (
            concepts::requires_<same_as<I, decltype(i++)>>
        )

◆ indirect_binary_predicate_

template<typename F , typename I1 , typename I2 >

concept ranges::indirect_binary_predicate_

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

Initial value:

=
        readable<I1> && readable<I2> &&
        copy_constructible<F> &&
         ranges::indirect_binary_predicate_frag_ < F, I1, I2 >

◆ indirect_relation

template<typename F , typename I1 , typename I2 = I1>

concept ranges::indirect_relation

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

Initial value:

=
        readable<I1> && readable<I2> &&
        copy_constructible<F> &&
         ranges::indirect_relation_ < F, I1, I2 >

◆ indirect_strict_weak_order

template<typename F , typename I1 , typename I2 = I1>

concept ranges::indirect_strict_weak_order

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

Initial value:

=
        readable<I1> && readable<I2> &&
        copy_constructible<F> &&
         ranges::indirect_strict_weak_order_ < F, I1, I2 >

◆ indirect_unary_predicate

template<typename F , typename I >

concept ranges::indirect_unary_predicate

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

Initial value:

=
        readable<I> &&
        copy_constructible<F> &&
         ranges::indirect_unary_predicate_ < F, I >

◆ indirectly_comparable

template<typename I1 , typename I2 , typename C , typename P1 = identity, typename P2 = identity>

concept ranges::indirectly_comparable

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

Initial value:

=

ranges::projected_indirect_relation_ < C, I1, P1, I2, P2 >

◆ indirectly_copyable

template<typename I , typename O >

concept ranges::indirectly_copyable

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

Initial value:

=

readable<I> && ranges::indirectly_copyable_ < I, O >

◆ indirectly_copyable_storable

template<typename I , typename O >

concept ranges::indirectly_copyable_storable

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

Initial value:

=
        indirectly_copyable<I, O> &&
         ranges::indirectly_copyable_storable_ < I, O >

◆ indirectly_movable

template<typename I , typename O >

concept ranges::indirectly_movable

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

Initial value:

=

readable<I> && ranges::indirectly_movable_ < I, O >

◆ indirectly_movable_storable

template<typename I , typename O >

concept ranges::indirectly_movable_storable

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

Initial value:

=
        indirectly_movable<I, O> &&
         ranges::indirectly_movable_storable_ < I, O >

◆ indirectly_regular_unary_invocable

template<typename F , typename I >

concept ranges::indirectly_regular_unary_invocable

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

Initial value:

=
        readable<I> &&
        copy_constructible<F> &&
         ranges::indirectly_regular_unary_invocable_ < F, I >

◆ indirectly_swappable

template<typename I1 , typename I2 = I1>

concept ranges::indirectly_swappable

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

Initial value:

=
        readable<I1> && readable<I2> &&
        requires(   I1 const  i1 ,   I2 const  i2 )      
        (
            ranges::iter_swap(i1, i2),
            ranges::iter_swap(i1, i1),
            ranges::iter_swap(i2, i2),
            ranges::iter_swap(i2, i1)
        )

◆ indirectly_unary_invocable

template<typename F , typename I >

concept ranges::indirectly_unary_invocable

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

Initial value:

=
        detail::indirectly_unary_invocable_<F, I> &&
        copy_constructible<F>

◆ input_iterator

template<typename I >

concept ranges::input_iterator

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

Initial value:

=
        input_or_output_iterator<I> && readable<I> &&
         ranges::with_category_ < I, std::input_iterator_tag >

◆ input_or_output_iterator

template<typename I >

concept ranges::input_or_output_iterator

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

Initial value:

=
        weakly_incrementable<I> &&
        detail::dereferenceable_<I&>

◆ inserter

constexpr inserter_fn ranges::inserter {}

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

See also: inserter_fn

◆ is_indirectly_movable_v

template<typename I , typename O >

constexpr bool ranges::is_indirectly_movable_v

#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

#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

#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

#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 {}

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

See also: iter_distance_fn

◆ iter_distance_compare

constexpr iter_distance_compare_fn ranges::iter_distance_compare {}

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

See also: iter_distance_compare_fn

◆ iter_enumerate

constexpr iter_enumerate_fn ranges::iter_enumerate {}

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

See also: iter_enumerate_fn

◆ iter_size

constexpr iter_size_fn ranges::iter_size {}

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

See also: iter_size_fn

◆ iter_swap

constexpr _iter_swap_::fn iter_swap {}

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

>iter_swap::fn

◆ make_ostream_joiner

constexpr make_ostream_joiner_fn ranges::make_ostream_joiner {}

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

See also: make_ostream_joiner_fn

◆ mergeable

template<typename I1 , typename I2 , typename Out , typename C = less, typename P1 = identity, typename P2 = identity>

concept ranges::mergeable

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

Initial value:

=
        input_iterator<I1> &&
        input_iterator<I2> &&
        weakly_incrementable<Out> &&
        indirectly_copyable<I1, Out> &&
        indirectly_copyable<I2, Out> &&
         ranges::projected_indirect_strict_weak_order_ < C, I1, P1, I2, P2 >

◆ move_into

constexpr move_into_fn ranges::move_into {}

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

See also: move_into_fn

◆ next

constexpr next_fn ranges::next {}

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

See also: next_fn

◆ output_iterator

template<typename Out , typename T >

concept ranges::output_iterator

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

Initial value:

=
        input_or_output_iterator<Out> && writable<Out, T> &&
        requires(   Out  o ,   T &&  t )      
        (
            *o++ = ((decltype( t )&&)  t )
        )

◆ permutable

template<typename I >

concept ranges::permutable

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

Initial value:

=
        forward_iterator<I> &&
        indirectly_swappable<I, I> &&
        indirectly_movable_storable<I, I>

◆ prev

constexpr prev_fn ranges::prev {}

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

See also: prev_fn

◆ random_access_iterator

template<typename I >

concept ranges::random_access_iterator

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

Initial value:

=
        
requires(  CPP_arg_2  i + n ( (I) i ),  CPP_arg_2  i + n ( (iter_difference_t< I >) n ),  CPP_arg_2  i + n ( (iter_reference_t< I >&) ))     n + i

◆ readable

template<typename I >

concept ranges::readable

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

Initial value:

=
        requires(   uncvref_t<I> const &  i ,   detail::readable_types_t< I >  )      
        (
            
            concepts::requires_<same_as<decltype(*i), iter_reference_t< I >>>,
            
            concepts::requires_<same_as<decltype(iter_move(i)),
                                        iter_rvalue_reference_t< I >>>
        ) &&
         readable_ < I >

◆ sentinel_for

template<typename S , typename I >

concept ranges::sentinel_for

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

Initial value:

=
        semiregular<S> && input_or_output_iterator<I> &&
        detail::weakly_equality_comparable_with_<S, I>

◆ sized_sentinel_for

template<typename S , typename I >

concept ranges::sized_sentinel_for

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

Initial value:

=
        requires(   S const &  s ,   I const &  i ,   iter_difference_t< I >  )      
        (
            s - i,
            i - s,
            concepts::requires_<same_as<iter_difference_t< I >, decltype(s - i)>>,
            concepts::requires_<same_as<iter_difference_t< I >, decltype(i - s)>>
        ) &&
        
        bool(!defer::is_true<disable_sized_sentinel<std::remove_cv_t<S>,
                                                    std::remove_cv_t<I>>> &&
            defer::sentinel_for<S, I>)

◆ sortable

template<typename I , typename C = less, typename P = identity>

concept ranges::sortable

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

Initial value:

=
        permutable<I> &&
         ranges::projected_indirect_strict_weak_order_ < C, I, P, I, P >

◆ weakly_incrementable

template<typename I >

concept ranges::weakly_incrementable

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

Initial value:

=
        semiregular<I> &&
         ranges::weakly_incrementable_ < I > &&
        requires(   I  i )      
        (
            ++i,
            i++,
            concepts::requires_<same_as<I&, decltype(++i)>>
        )

◆ writable

template<typename Out , typename T >

concept ranges::writable

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

Initial value:

=
        requires(   Out &&  o ,   T &&  t ,   iter_reference_t< Out >&  )      
        (
            *o = ((decltype( t )&&)  t ),
            *((decltype( o )&&)  o ) = ((decltype( t )&&)  t ),
            const_cast<iter_reference_t< Out > const &&>(*o) = ((decltype( t )&&)  t ),
            const_cast<iter_reference_t< Out > const &&>(*((decltype( o )&&)  o )) = ((decltype( t )&&)  t )
        )

Description

Classes

Typedefs

Functions

Variables

Variable Documentation

◆ advance

◆ back_inserter

◆ bidirectional_iterator

◆ contiguous_iterator

◆ distance

◆ distance_compare

◆ enumerate

◆ forward_iterator

◆ front_inserter

◆ get_cursor

◆ incrementable

◆ indirect_binary_predicate_

◆ indirect_relation

◆ indirect_strict_weak_order

◆ indirect_unary_predicate

◆ indirectly_comparable

◆ indirectly_copyable

◆ indirectly_copyable_storable

◆ indirectly_movable

◆ indirectly_movable_storable

◆ indirectly_regular_unary_invocable

◆ indirectly_swappable

◆ indirectly_unary_invocable

◆ input_iterator

◆ input_or_output_iterator

◆ inserter

◆ is_indirectly_movable_v

◆ is_indirectly_swappable_v

◆ is_nothrow_indirectly_movable_v

◆ is_nothrow_indirectly_swappable_v

◆ iter_distance

◆ iter_distance_compare

◆ iter_enumerate

◆ iter_size

◆ iter_swap

◆ make_ostream_joiner

◆ mergeable

◆ move_into

◆ next

◆ output_iterator

◆ permutable

◆ prev

◆ random_access_iterator

◆ readable

◆ sentinel_for

◆ sized_sentinel_for

◆ sortable

◆ weakly_incrementable

◆ writable