Horizon
Loading...
Searching...
No Matches
Classes | Namespaces | Concepts | Typedefs | Functions | Variables
concepts.hpp File Reference
#include <iterator>
#include <type_traits>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/comparisons.hpp>
#include <range/v3/functional/concepts.hpp>
#include <range/v3/functional/identity.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/access.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/detail/prologue.hpp>
#include <range/v3/detail/epilogue.hpp>

Go to the source code of this file.

Classes

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

Namespaces

namespace  ranges::cpp20
 

Concepts

concept  ranges::readable_
 The readable_ concept.
 
concept  ranges::indirectly_readable
 The indirectly_readable concept.
 
concept  ranges::writable_
 The writable_ concept.
 
concept  ranges::indirectly_writable
 The indirectly_writable concept.
 
concept  ranges::weakly_incrementable_
 The weakly_incrementable_ concept.
 
concept  ranges::weakly_incrementable
 The weakly_incrementable concept.
 
concept  ranges::incrementable_
 The incrementable_ concept.
 
concept  ranges::incrementable
 The incrementable concept.
 
concept  ranges::input_or_output_iterator_
 The input_or_output_iterator_ concept.
 
concept  ranges::input_or_output_iterator
 The input_or_output_iterator concept.
 
concept  ranges::sentinel_for
 The sentinel_for concept.
 
concept  ranges::sized_sentinel_for_
 The sized_sentinel_for_ concept.
 
concept  ranges::sized_sentinel_for
 The sized_sentinel_for concept.
 
concept  ranges::output_iterator_
 The output_iterator_ concept.
 
concept  ranges::output_iterator
 The output_iterator concept.
 
concept  ranges::with_category_
 The with_category_ concept.
 
concept  ranges::input_iterator
 The input_iterator concept.
 
concept  ranges::forward_iterator
 The forward_iterator concept.
 
concept  ranges::bidirectional_iterator_
 The bidirectional_iterator_ concept.
 
concept  ranges::bidirectional_iterator
 The bidirectional_iterator concept.
 
concept  ranges::random_access_iterator_
 The random_access_iterator_ concept.
 
concept  ranges::random_access_iterator
 The random_access_iterator concept.
 
concept  ranges::contiguous_iterator_
 The contiguous_iterator_ concept.
 
concept  ranges::contiguous_iterator
 The contiguous_iterator concept.
 
concept  ranges::indirectly_unary_invocable
 The indirectly_unary_invocable concept.
 
concept  ranges::indirectly_regular_unary_invocable_
 The indirectly_regular_unary_invocable_ concept.
 
concept  ranges::indirectly_regular_unary_invocable
 The indirectly_regular_unary_invocable concept.
 
concept  ranges::indirect_unary_predicate_
 The indirect_unary_predicate_ concept.
 
concept  ranges::indirect_unary_predicate
 The indirect_unary_predicate concept.
 
concept  ranges::indirect_binary_predicate_impl_
 The indirect_binary_predicate_impl_ concept.
 
concept  ranges::indirect_binary_predicate_
 The indirect_binary_predicate_ concept.
 
concept  ranges::indirect_relation_
 The indirect_relation_ concept.
 
concept  ranges::indirect_relation
 The indirect_relation concept.
 
concept  ranges::indirect_strict_weak_order_
 The indirect_strict_weak_order_ concept.
 
concept  ranges::indirect_strict_weak_order
 The indirect_strict_weak_order concept.
 
concept  ranges::indirectly_movable_
 The indirectly_movable_ concept.
 
concept  ranges::indirectly_movable
 The indirectly_movable concept.
 
concept  ranges::indirectly_movable_storable_
 The indirectly_movable_storable_ concept.
 
concept  ranges::indirectly_movable_storable
 The indirectly_movable_storable concept.
 
concept  ranges::indirectly_copyable_
 The indirectly_copyable_ concept.
 
concept  ranges::indirectly_copyable
 The indirectly_copyable concept.
 
concept  ranges::indirectly_copyable_storable_
 The indirectly_copyable_storable_ concept.
 
concept  ranges::indirectly_copyable_storable
 The indirectly_copyable_storable concept.
 
concept  ranges::indirectly_swappable_
 The indirectly_swappable_ concept.
 
concept  ranges::indirectly_swappable
 The indirectly_swappable concept.
 
concept  ranges::projected_indirect_relation_
 The projected_indirect_relation_ concept.
 
concept  ranges::indirectly_comparable
 The indirectly_comparable concept.
 
concept  ranges::permutable
 The permutable concept.
 
concept  ranges::projected_indirect_strict_weak_order_
 The projected_indirect_strict_weak_order_ concept.
 
concept  ranges::sortable
 The sortable concept.
 

Typedefs

template<typename Rng >
using ranges::iterator_tag_of = std::enable_if_t< input_iterator< Rng >, meta::conditional_t< contiguous_iterator< Rng >, ranges::contiguous_iterator_tag, meta::conditional_t< random_access_iterator< Rng >, std::random_access_iterator_tag, meta::conditional_t< bidirectional_iterator< Rng >, std::bidirectional_iterator_tag, meta::conditional_t< forward_iterator< Rng >, std::forward_iterator_tag, std::input_iterator_tag > > > > >
 
template<typename Fun , typename... Is>
using ranges::indirect_result_t = detail::enable_if_t<(bool) and_v<(bool) indirectly_readable< Is >... >, invoke_result_t< Fun, iter_reference_t< Is >... > >
 
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 >, meta::conditional_t< sized_sentinel_for< S, I >, sized_sentinel_tag, sentinel_tag > >
 

Functions

 ranges::template (typename I)(concept(readable_)(I)
 
template<typename O , typename T >
 ranges::CPP_requires (writable_, requires(O &&o, T &&t)(*o=(T &&) t, *(O &&) o=(T &&) t, const_cast< iter_reference_t< O > const && >(*o)=(T &&) t, const_cast< iter_reference_t< O > const && >(*(O &&) o)=(T &&) t))
 
template<typename I >
 ranges::CPP_requires (weakly_incrementable_, requires(I i)(++i, i++, concepts::requires_< same_as< I &, decltype(++i)> >))
 
template<typename I >
 ranges::CPP_requires (incrementable_, requires(I i)(concepts::requires_< same_as< I, decltype(i++)> >))
 
template<typename S , typename I >
 ranges::CPP_requires (sized_sentinel_for_, 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)> >))
 
 ranges::template (typename S, typename I)(concept(sized_sentinel_for_)(S
 
template<typename Out , typename T >
 ranges::CPP_requires (output_iterator_, requires(Out o, T &&t)(*o++=(T &&) t))
 
 ranges::template (typename I, typename Tag)(concept(with_category_)(I
 
template<typename I >
 ranges::CPP_requires (bidirectional_iterator_, requires(I i)(--i, i--, concepts::requires_< same_as< I &, decltype(--i)> >, concepts::requires_< same_as< I, decltype(i--)> >))
 
template<typename I >
 ranges::CPP_requires (random_access_iterator_, 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 > > >))
 
 ranges::template (typename F, typename I)(concept(indirectly_regular_unary_invocable_)(F
 
 ranges::template (typename F, typename I1, typename I2)(concept(indirect_binary_predicate_impl_)(F
 
 ranges::template (typename I, typename O)(concept(indirectly_movable_)(I
 
template<typename I1 , typename I2 >
 ranges::CPP_requires (indirectly_swappable_, 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)))
 
 ranges::template (typename C, typename I1, typename P1, typename I2, typename P2)(concept(projected_indirect_relation_)(C
 

Variables

same_as< iter_reference_t< I const >, iter_reference_t< I > > AND same_as< iter_rvalue_reference_t< I const >, iter_rvalue_reference_t< I > > AND common_reference_with< iter_reference_t< I > &&, iter_value_t< I > & > AND common_reference_with< iter_reference_t< I > &&, iter_rvalue_reference_t< I > && > AND ranges::common_reference_with< iter_rvalue_reference_t< I > &&, iter_value_t< I > const & >
 
template<typename I >
CPP_concept ranges::indirectly_readable
 
template<typename I >
RANGES_INLINE_VAR constexpr bool ranges::readable
 
template<typename O , typename T >
CPP_concept ranges::indirectly_writable
 
template<typename O , typename T >
RANGES_INLINE_VAR constexpr bool ranges::writable
 
template<typename I >
CPP_concept ranges::weakly_incrementable
 
template<typename I >
CPP_concept ranges::incrementable
 
template<typename I >
CPP_concept ranges::input_or_output_iterator
 
template<typename S , typename I >
CPP_concept ranges::sentinel_for
 
 ranges::I
 
!disable_sized_sentinel< std::remove_cv_t< S >, std::remove_cv_t< I > > AND ranges::sentinel_for< S, I >
 
template<typename S , typename I >
CPP_concept ranges::sized_sentinel_for
 
template<typename Out , typename T >
CPP_concept ranges::output_iterator
 
 ranges::Tag
 
template<typename I >
CPP_concept ranges::input_iterator
 
template<typename I >
CPP_concept ranges::forward_iterator
 
template<typename I >
CPP_concept ranges::bidirectional_iterator
 
template<typename I >
CPP_concept ranges::random_access_iterator
 
template<typename I >
CPP_concept ranges::contiguous_iterator
 
template<typename F , typename I >
CPP_concept ranges::indirectly_unary_invocable
 
regular_invocable< F &, iter_value_t< I > & > AND regular_invocable< F &, iter_reference_t< I > > AND regular_invocable< F &, iter_common_reference_t< I > > AND ranges::common_reference_with< invoke_result_t< F &, iter_value_t< I > & >, invoke_result_t< F &, iter_reference_t< I > > >
 
template<typename F , typename I >
CPP_concept ranges::indirectly_regular_unary_invocable
 
predicate< F &, iter_value_t< I > & > AND predicate< F &, iter_reference_t< I > > AND ranges::predicate< F &, iter_common_reference_t< I > >
 
template<typename F , typename I >
CPP_concept ranges::indirect_unary_predicate
 
 ranges::I2
 
predicate< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > AND predicate< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > AND predicate< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > AND predicate< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > AND ranges::predicate< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > >
 
template<typename F , typename I1 , typename I2 >
CPP_concept ranges::indirect_binary_predicate_
 
relation< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > AND relation< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > AND relation< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > AND relation< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > AND ranges::relation< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > >
 
template<typename F , typename I1 , typename I2 = I1>
CPP_concept ranges::indirect_relation
 
strict_weak_order< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > AND strict_weak_order< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > AND strict_weak_order< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > AND strict_weak_order< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > AND ranges::strict_weak_order< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > >
 
template<typename F , typename I1 , typename I2 = I1>
CPP_concept ranges::indirect_strict_weak_order
 
 ranges::indirectly_writable< O, iter_rvalue_reference_t< I > >
 
template<typename I , typename O >
CPP_concept ranges::indirectly_movable
 
indirectly_writable< O, iter_value_t< I > > AND movable< iter_value_t< I > > AND constructible_from< iter_value_t< I >, iter_rvalue_reference_t< I > > AND ranges::assignable_from< iter_value_t< I > &, iter_rvalue_reference_t< I > >
 
template<typename I , typename O >
CPP_concept ranges::indirectly_movable_storable
 
 ranges::indirectly_writable< O, iter_reference_t< I > >
 
template<typename I , typename O >
CPP_concept ranges::indirectly_copyable
 
indirectly_writable< O, iter_value_t< I > const & > AND copyable< iter_value_t< I > > AND constructible_from< iter_value_t< I >, iter_reference_t< I > > AND ranges::assignable_from< iter_value_t< I > &, iter_reference_t< I > >
 
template<typename I , typename O >
CPP_concept ranges::indirectly_copyable_storable
 
template<typename I1 , typename I2 = I1>
CPP_concept ranges::indirectly_swappable
 
 ranges::P2
 
 ranges::indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > >
 
template<typename I1 , typename I2 , typename C , typename P1 = identity, typename P2 = identity>
CPP_concept ranges::indirectly_comparable
 
template<typename I >
CPP_concept ranges::permutable
 
 ranges::indirect_strict_weak_order< C, projected< I1, P1 >, projected< I2, P2 > >
 
template<typename I1 , typename I2 , typename Out , typename C = less, typename P1 = identity, typename P2 = identity>
CPP_concept ranges::mergeable
 
template<typename I , typename C = less, typename P = identity>
CPP_concept ranges::sortable