Range-v3
Range algorithms, views, and actions for the Standard Library
concepts.hpp File Reference

Classes

struct  ranges::incrementable_traits< detail::projected_< I, Proj > >
 
struct  ranges::sentinel_tag
 
struct  ranges::sized_sentinel_tag
 

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

Variables

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>
 
template<typename I >
concept ranges::forward_iterator
 
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
 
template<typename I1 , typename I2 , typename Out , typename C = less, typename P1 = identity, typename P2 = identity>
concept ranges::mergeable
 
template<typename I >
concept i ranges::n
 
template<typename Out , typename T >
concept ranges::output_iterator
 
template<typename I >
concept ranges::permutable
 
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 &>
 
template<typename S , typename I >
concept ranges::sentinel_for
 
template<typename S , typename I >
concept ranges::defer::sentinel_for
 
template<typename S , typename I >
concept ranges::sized_sentinel_for
 
template<typename I , typename C = less, typename P = identity>
concept ranges::sortable
 
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

◆ sentinel_for

template<typename S , typename I >
concept ranges::defer::sentinel_for
Initial value:
=
ranges::sentinel_for < S, I >