Iterator

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::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::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 T >
using	ranges::iter_value_t = typename readable_traits< T >::value_type
template<typename T >
using	ranges::iterator_tag_of = concepts::tag_of< meta::list< contiguous_iterator_concept, random_access_iterator_concept, bidirectional_iterator_concept, forward_iterator_concept, input_iterator_concept >, T >
template<typename I , typename Proj >
using	ranges::projected = typename detail::select_projected_< Proj >::template apply< I >
using	ranges::sentinel_tag = concepts::tag< sentinel_for_concept >
template<typename S , typename I >
using	ranges::sentinel_tag_of = concepts::tag_of< meta::list< sized_sentinel_for_concept, sentinel_for_concept >, S, I >
using	ranges::sized_sentinel_tag = concepts::tag< sized_sentinel_for_concept, sentinel_tag >

Functions
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(class F, class I1, class I2=I1)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename F, typename I)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename F, typename I1, typename I2)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename F, typename I1, typename I2=I1)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename I)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename I, typename C=less, typename P=identity)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename I, typename O)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename I0, typename I1, typename Out, typename C=less, typename P0=identity, typename P1=identity)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename I1, typename I2, typename C, typename P1=identity, typename P2=identity)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename I1, typename I2=I1)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename Out, typename T)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
	ranges::CPP_PP_CAT (CPP_PP_DEF_, template(typename S, typename I)) META_CONCEPT CPP_PP_CAT(CPP_PP_DEF_
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 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 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 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 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 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 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 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 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 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 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 {}
concept	ranges::bidirectional_iterator = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( requires (I i) ( --i, i--, concepts::requires_<same_as<I&, decltype(--i)>>, concepts::requires_<same_as<I, decltype(i--)>> ) && forward_iterator<I> && derived_from<detail::iter_concept_t<I> )( requires (I i) ( --i, i--, concepts::requires_<same_as<I&, decltype(--i)>>, concepts::requires_<same_as<I, decltype(i--)>> ) && forward_iterator<I> && derived_from<detail::iter_concept_t<I>, std::bidirectional_iterator_tag> )
concept	ranges::contiguous_iterator = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( random_access_iterator<I> && derived_from<detail::iter_concept_t<I> )( random_access_iterator<I> && derived_from<detail::iter_concept_t<I>, ranges::contiguous_iterator_tag> && std::is_lvalue_reference<iter_reference_t<I>>::value && same_as<iter_value_t<I>, uncvref_t<iter_reference_t<I>>> )
constexpr default_sentinel_t	ranges::default_sentinel {}
constexpr distance_fn	ranges::distance {}
constexpr distance_compare_fn	ranges::distance_compare {}
constexpr enumerate_fn	ranges::enumerate {}
concept	ranges::forward_iterator = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( input_iterator<I> && incrementable<I> && sentinel_for<I )( input_iterator<I> && incrementable<I> && sentinel_for<I, I> && derived_from<detail::iter_concept_t<I>, std::forward_iterator_tag> )
constexpr front_inserter_fn	ranges::front_inserter {}
constexpr get_cursor_fn	ranges::get_cursor {}
concept	ranges::incrementable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( requires (I i) ( concepts::requires_<same_as<I, decltype(i++)>> ) && regular<I> && weakly_incrementable<I> )( requires (I i) ( concepts::requires_<same_as<I, decltype(i++)>> ) && regular<I> && weakly_incrementable<I> )
concept	ranges::indirect_binary_predicate_ = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( readable<I1> && readable<I2> && copy_constructible<F> && predicate<F & )( readable<I1> && readable<I2> && copy_constructible<F> && 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>> )
concept	ranges::indirect_relation = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( readable<I1> && readable<I2> && copy_constructible<F> && relation<F & )( readable<I1> && readable<I2> && copy_constructible<F> && 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>> )
concept	ranges::indirect_strict_weak_order = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( readable<I1> && readable<I2> && copy_constructible<F> && strict_weak_order<F & )( readable<I1> && readable<I2> && copy_constructible<F> && 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>> )
concept	ranges::indirect_unary_predicate = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( readable<I> && copy_constructible<F> && predicate<F & )( readable<I> && copy_constructible<F> && predicate<F &, iter_value_t<I> &> && predicate<F &, iter_reference_t<I>> && predicate<F &, iter_common_reference_t<I>> )
concept	ranges::indirectly_comparable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( indirect_relation<C )( indirect_relation<C, projected<I1, P1>, projected<I2, P2>> )
concept	ranges::indirectly_copyable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( readable<I> && writable<O )( readable<I> && writable<O, iter_reference_t<I>> )
concept	ranges::indirectly_copyable_storable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( indirectly_copyable<I )( indirectly_copyable<I, O> && 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>> )
concept	ranges::indirectly_movable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( readable<I> && writable<O )( readable<I> && writable<O, iter_rvalue_reference_t<I>> )
concept	ranges::indirectly_movable_storable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( indirectly_movable<I )( indirectly_movable<I, O> && 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>> )
concept	ranges::indirectly_regular_unary_invocable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( readable<I> && copy_constructible<F> && regular_invocable<F & )( readable<I> && copy_constructible<F> && 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>>> )
concept	ranges::indirectly_swappable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( requires (I1 && i1, I2 && i2) ( ranges::iter_swap((I1 &&) i1, (I2 &&) i2), ranges::iter_swap((I1 &&) i1, (I1 &&) i1), ranges::iter_swap((I2 &&) i2, (I2 &&) i2), ranges::iter_swap((I2 &&) i2, (I1 &&) i1) ) && readable<I1> && readable<I2> )( requires (I1 && i1, I2 && i2) ( ranges::iter_swap((I1 &&) i1, (I2 &&) i2), ranges::iter_swap((I1 &&) i1, (I1 &&) i1), ranges::iter_swap((I2 &&) i2, (I2 &&) i2), ranges::iter_swap((I2 &&) i2, (I1 &&) i1) ) && readable<I1> && readable<I2> )
concept	ranges::indirectly_unary_invocable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( detail::indirectly_unary_invocable_<F )( detail::indirectly_unary_invocable_<F, I> && copy_constructible<F> )
concept	ranges::input_iterator = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( input_or_output_iterator<I> && readable<I> && derived_from<detail::iter_concept_t<I> )( input_or_output_iterator<I> && readable<I> && derived_from<detail::iter_concept_t<I>, std::input_iterator_tag> )
concept	ranges::input_or_output_iterator = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( requires (I i) ( *i ) && weakly_incrementable<I> )( requires (I i) ( *i ) && weakly_incrementable<I> )
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 {}
concept	ranges::mergeable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( input_iterator<I0> && input_iterator<I1> && weakly_incrementable<Out> && indirectly_copyable<I0 )( input_iterator<I0> && input_iterator<I1> && weakly_incrementable<Out> && indirectly_copyable<I0, Out> && indirectly_copyable<I1, Out> && indirect_strict_weak_order<C, projected<I0, P0>, projected<I1, P1>> )
constexpr move_into_fn	ranges::move_into {}
constexpr next_fn	ranges::next {}
concept	ranges::output_iterator = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( requires (Out o, T &&t) ( *o++ = static_cast<T &&>(t) ) && input_or_output_iterator<Out> && writable<Out )( requires (Out o, T &&t) ( *o++ = static_cast<T &&>(t) ) && input_or_output_iterator<Out> && writable<Out, T> )
concept	ranges::permutable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( forward_iterator<I> && indirectly_swappable<I )( forward_iterator<I> && indirectly_swappable<I, I> && indirectly_movable_storable<I, I> )
constexpr prev_fn	ranges::prev {}
concept	ranges::random_access_iterator = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( requires (I i, iter_difference_t<I> n) ( i + n, n + i, i - n, i += n, i -= n, concepts::requires_<same_as<decltype(i + n), I>>, concepts::requires_<same_as<decltype(n + i), I>>, concepts::requires_<same_as<decltype(i - n), I>>, concepts::requires_<same_as<decltype(i += n), I&>>, concepts::requires_<same_as<decltype(i -= n), I&>>, concepts::requires_<same_as<decltype(i[n]), iter_reference_t<I>>> ) && bidirectional_iterator<I> && totally_ordered<I> && sized_sentinel_for<I )( requires (I i, iter_difference_t<I> n) ( i + n, n + i, i - n, i += n, i -= n, concepts::requires_<same_as<decltype(i + n), I>>, concepts::requires_<same_as<decltype(n + i), I>>, concepts::requires_<same_as<decltype(i - n), I>>, concepts::requires_<same_as<decltype(i += n), I&>>, concepts::requires_<same_as<decltype(i -= n), I&>>, concepts::requires_<same_as<decltype(i[n]), iter_reference_t<I>>> ) && bidirectional_iterator<I> && totally_ordered<I> && sized_sentinel_for<I, I> && derived_from<detail::iter_concept_t<I>, std::random_access_iterator_tag> )
concept	ranges::readable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( common_reference_with<iter_reference_t<I> && )( common_reference_with<iter_reference_t<I> &&, iter_value_t<std::remove_reference_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<std::remove_reference_t<I>> const &> )
constexpr adl_uncounted_recounted_detail::recounted_fn	ranges::recounted {}
concept	ranges::sentinel_for = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( semiregular<S> && input_or_output_iterator<I> && detail::weakly_equality_comparable_with_<S )( semiregular<S> && input_or_output_iterator<I> && detail::weakly_equality_comparable_with_<S, I> )
concept	ranges::sized_sentinel_for = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( requires (S const &s, I const &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)>> ) && (!defer::is_true<disable_sized_sentinel<meta::_t<std::remove_cv<S>>, meta::_t<std::remove_cv<I>>>> && defer::sentinel_for<S, I>) )( requires (S const &s, I const &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)>> ) && (!defer::is_true<disable_sized_sentinel<meta::_t<std::remove_cv<S>>, meta::_t<std::remove_cv<I>>>> && defer::sentinel_for<S, I>) )
concept	ranges::sortable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( permutable<I> && indirect_strict_weak_order<C )( permutable<I> && indirect_strict_weak_order<C, projected<I, P>> )
constexpr adl_uncounted_recounted_detail::uncounted_fn	ranges::uncounted {}
constexpr unreachable_sentinel_t	ranges::unreachable {}
concept	ranges::weakly_incrementable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( requires (I i) ( ++i, i++, concepts::requires_<same_as<I&, decltype(++i)>> ) && concepts::type<iter_difference_t<I>> && detail::signed_integer_like_<iter_difference_t<I>> && semiregular<I> )( requires (I i) ( ++i, i++, concepts::requires_<same_as<I&, decltype(++i)>> ) && concepts::type<iter_difference_t<I>> && detail::signed_integer_like_<iter_difference_t<I>> && semiregular<I> )
concept	ranges::writable = CPP_PP_CAT( CPP_PP_DEF_IMPL_IS_PAREN_, 0 )( requires (Out &&o, T &&t) ( *o = static_cast<T &&>(t), *((Out &&) o) = static_cast<T &&>(t), const_cast<iter_reference_t<Out> const &&>(*o) = static_cast<T &&>(t), const_cast<iter_reference_t<Out> const &&>(*((Out &&) o)) = static_cast<T &&>(t) ) )( requires (Out &&o, T &&t) ( *o = static_cast<T &&>(t), *((Out &&) o) = static_cast<T &&>(t), const_cast<iter_reference_t<Out> const &&>(*o) = static_cast<T &&>(t), const_cast<iter_reference_t<Out> const &&>(*((Out &&) o)) = static_cast<T &&>(t) ) )

Variable Documentation

advance

constexpr advance_fn ranges::advance {}

constexpr

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

See also

advance_fn

back_inserter

constexpr back_inserter_fn ranges::back_inserter {}

constexpr

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

See also

back_inserter_fn

distance

constexpr distance_fn ranges::distance {}

constexpr

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

See also

distance_fn

distance_compare

constexpr distance_compare_fn ranges::distance_compare {}

constexpr

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

See also

distance_compare_fn

enumerate

constexpr enumerate_fn ranges::enumerate {}

related

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

See also

enumerate_fn

front_inserter

constexpr front_inserter_fn ranges::front_inserter {}

constexpr

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

See also

front_inserter_fn

get_cursor

constexpr get_cursor_fn ranges::get_cursor {}

constexpr

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

See also

get_cursor_fn

inserter

constexpr inserter_fn ranges::inserter {}

constexpr

#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

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

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

See also

iter_distance_fn

iter_distance_compare

constexpr iter_distance_compare_fn ranges::iter_distance_compare {}

constexpr

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

See also

iter_distance_compare_fn

iter_enumerate

constexpr iter_enumerate_fn ranges::iter_enumerate {}

constexpr

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

See also

iter_enumerate_fn

iter_size

constexpr iter_size_fn ranges::iter_size {}

constexpr

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

See also

iter_size_fn

iter_swap

constexpr _iter_swap_::fn iter_swap {}

constexpr

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

>iter_swap::fn

make_ostream_joiner

constexpr make_ostream_joiner_fn ranges::make_ostream_joiner {}

constexpr

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

See also

make_ostream_joiner_fn

move_into

constexpr move_into_fn ranges::move_into {}

constexpr

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

See also

move_into_fn

next

constexpr next_fn ranges::next {}

constexpr

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

See also

next_fn

prev

constexpr prev_fn ranges::prev {}

constexpr

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

See also

prev_fn