Iterator concepts. More...
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) indirectly_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 >, 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 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 > > |
Variables | |
concept indirectly_writable< O, iter_value_t< I > const & > &©able< iter_value_t< I > > &&constructible_from< iter_value_t< I >, iter_reference_t< I > > && | ranges::assignable_from< iter_value_t< I > &, iter_reference_t< I > > |
concept indirectly_writable< O, iter_value_t< I > > &&movable< iter_value_t< I > > &&constructible_from< iter_value_t< I >, iter_rvalue_reference_t< I > > && | ranges::assignable_from< iter_value_t< I > &, iter_rvalue_reference_t< I > > |
template<typename I > | |
concept | ranges::bbidirectional_iterator |
\concept bidirectional_iterator More... | |
template<typename I > | |
concept | ranges::bidirectional_iterator_ = requires( I i ) { --i, i--, concepts::requires_<same_as<I&, decltype(--i)>>, concepts::requires_<same_as<I, decltype(i--)>> ; } |
\concept bidirectional_iterator_ More... | |
template<typename I > | |
concept | ranges::ccontiguous_iterator |
\concept contiguous_iterator More... | |
concept regular_invocable< F &, iter_value_t< I > & > &®ular_invocable< F &, iter_reference_t< I > > &®ular_invocable< F &, iter_common_reference_t< I > > && | ranges::common_reference_with< invoke_result_t< F &, iter_value_t< I > & >, invoke_result_t< F &, iter_reference_t< I > > > |
concept same_as< iter_reference_t< I const >, iter_reference_t< I > > &&same_as< iter_rvalue_reference_t< I const >, iter_rvalue_reference_t< I > > &&common_reference_with< iter_reference_t< I > &&, iter_value_t< I > & > &&common_reference_with< iter_reference_t< I > &&, iter_rvalue_reference_t< I > && > && | ranges::common_reference_with< iter_rvalue_reference_t< I > &&, iter_value_t< I > const & > |
concept | ranges::contiguous_iterator_ = |
template<typename I > | |
concept | ranges::fforward_iterator |
\concept forward_iterator More... | |
template<typename I > | |
concept | ranges::iincrementable |
\concept incrementable More... | |
template<typename F , typename I1 , typename I2 > | |
concept | ranges::iindirect_binary_predicate_ |
\concept indirect_binary_predicate_ More... | |
template<typename F , typename I1 , typename I2 = I1> | |
concept | ranges::iindirect_relation |
\concept indirect_relation More... | |
template<typename F , typename I1 , typename I2 = I1> | |
concept | ranges::iindirect_strict_weak_order |
\concept indirect_strict_weak_order More... | |
template<typename F , typename I > | |
concept | ranges::iindirect_unary_predicate |
\concept indirect_unary_predicate More... | |
template<typename I1 , typename I2 , typename C , typename P1 = identity, typename P2 = identity> | |
concept | ranges::iindirectly_comparable |
\concept indirectly_comparable More... | |
template<typename I , typename O > | |
concept | ranges::iindirectly_copyable |
\concept indirectly_copyable More... | |
template<typename I , typename O > | |
concept | ranges::iindirectly_copyable_storable |
\concept indirectly_copyable_storable More... | |
template<typename I , typename O > | |
concept | ranges::iindirectly_movable |
\concept indirectly_movable More... | |
template<typename I , typename O > | |
concept | ranges::iindirectly_movable_storable |
\concept indirectly_movable_storable More... | |
template<typename I > | |
concept | ranges::iindirectly_readable |
\concept indirectly_readable More... | |
template<typename F , typename I > | |
concept | ranges::iindirectly_regular_unary_invocable |
\concept indirectly_regular_unary_invocable More... | |
template<typename I1 , typename I2 = I1> | |
concept | ranges::iindirectly_swappable |
\concept indirectly_swappable More... | |
template<typename F , typename I > | |
concept | ranges::iindirectly_unary_invocable |
\concept indirectly_unary_invocable More... | |
template<typename O , typename T > | |
concept | ranges::iindirectly_writable |
\concept indirectly_writable More... | |
template<typename I > | |
concept | ranges::iinput_iterator |
\concept input_iterator More... | |
template<typename I > | |
concept | ranges::iinput_or_output_iterator |
\concept input_or_output_iterator More... | |
template<typename I > | |
concept | ranges::incrementable_ = requires( I i ) { concepts::requires_<same_as<I, decltype(i++)>> ; } |
\concept incrementable_ More... | |
concept | ranges::indirect_binary_predicate_impl_ = |
concept | ranges::indirect_relation< C, projected< I1, P1 >, projected< I2, P2 > > |
concept | ranges::indirect_relation_ = |
concept | ranges::indirect_strict_weak_order< C, projected< I1, P1 >, projected< I2, P2 > > |
concept | ranges::indirect_strict_weak_order_ = |
concept | ranges::indirect_unary_predicate_ = |
concept | ranges::indirectly_copyable_ = |
concept | ranges::indirectly_copyable_storable_ = |
concept | ranges::indirectly_movable_ = |
concept | ranges::indirectly_movable_storable_ = |
concept | ranges::indirectly_regular_unary_invocable_ = |
template<typename I1 , typename I2 > | |
concept | ranges::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) ; } |
\concept indirectly_swappable_ More... | |
concept | ranges::indirectly_writable< O, iter_reference_t< I > > |
concept | ranges::indirectly_writable< O, iter_rvalue_reference_t< 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::mmergeable |
template<typename Out , typename T > | |
concept | ranges::ooutput_iterator |
\concept output_iterator More... | |
template<typename Out , typename T > | |
concept | ranges::output_iterator_ = requires( Out o, T && t ) { *o++ = (T &&) t ; } |
\concept output_iterator_ More... | |
template<typename I > | |
concept | ranges::ppermutable |
\concept permutable More... | |
concept predicate< F &, iter_value_t< I > & > &&predicate< F &, iter_reference_t< I > > && | ranges::predicate< F &, iter_common_reference_t< I > > |
concept 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 > > && | ranges::predicate< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > > |
concept | ranges::projected_indirect_relation_ = |
concept | ranges::projected_indirect_strict_weak_order_ = |
template<typename I > | |
concept | ranges::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>>> ; } |
\concept random_access_iterator_ More... | |
template<typename I > | |
constexpr bool | ranges::readable |
concept | ranges::readable_ = |
concept 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 > > && | ranges::relation< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > > |
template<typename I > | |
concept | ranges::rrandom_access_iterator |
\concept random_access_iterator More... | |
concept !disable_sized_sentinel< std::remove_cv_t< S >, std::remove_cv_t< I > > && | ranges::sentinel_for< S, I > |
template<typename S , typename I > | |
concept | ranges::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)>> ; } |
\concept sized_sentinel_for_ More... | |
template<typename S , typename I > | |
concept | ranges::ssentinel_for |
\concept sentinel_for More... | |
template<typename S , typename I > | |
concept | ranges::ssized_sentinel_for |
\concept sized_sentinel_for More... | |
template<typename I , typename C = less, typename P = identity> | |
concept | ranges::ssortable |
\concept sortable More... | |
concept 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 > > && | ranges::strict_weak_order< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > > |
template<typename I > | |
concept | ranges::weakly_incrementable_ = requires( I i ) { ++i, i++, concepts::requires_<same_as<I&, decltype(++i)>> ; } |
\concept weakly_incrementable_ More... | |
concept | ranges::with_category_ = |
template<typename O , typename T > | |
constexpr bool | ranges::writable |
template<typename O , typename T > | |
concept | ranges::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 ; } |
\concept writable_ More... | |
template<typename I > | |
concept | ranges::wweakly_incrementable |
\concept weakly_incrementable More... | |
Iterator concepts.
concept ranges::bbidirectional_iterator |
#include <range/v3/iterator/concepts.hpp>
\concept bidirectional_iterator
The bidirectional_iterator
concept
concept ranges::bidirectional_iterator_ = requires( I i ) { --i, i--, concepts::requires_<same_as<I&, decltype(--i)>>, concepts::requires_<same_as<I, decltype(i--)>> ; } |
#include <range/v3/iterator/concepts.hpp>
\concept bidirectional_iterator_
The bidirectional_iterator_
concept
concept ranges::ccontiguous_iterator |
#include <range/v3/iterator/concepts.hpp>
\concept contiguous_iterator
The contiguous_iterator
concept
concept ranges::fforward_iterator |
#include <range/v3/iterator/concepts.hpp>
\concept forward_iterator
The forward_iterator
concept
concept ranges::iincrementable |
#include <range/v3/iterator/concepts.hpp>
\concept incrementable
The incrementable
concept
concept ranges::iindirect_binary_predicate_ |
#include <range/v3/iterator/concepts.hpp>
\concept indirect_binary_predicate_
The indirect_binary_predicate_
concept
concept ranges::iindirect_relation |
#include <range/v3/iterator/concepts.hpp>
\concept indirect_relation
The indirect_relation
concept
concept ranges::iindirect_strict_weak_order |
#include <range/v3/iterator/concepts.hpp>
\concept indirect_strict_weak_order
The indirect_strict_weak_order
concept
concept ranges::iindirect_unary_predicate |
#include <range/v3/iterator/concepts.hpp>
\concept indirect_unary_predicate
The indirect_unary_predicate
concept
concept ranges::iindirectly_comparable |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_comparable
The indirectly_comparable
concept
concept ranges::iindirectly_copyable |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_copyable
The indirectly_copyable
concept
concept ranges::iindirectly_copyable_storable |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_copyable_storable
The indirectly_copyable_storable
concept
concept ranges::iindirectly_movable |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_movable
The indirectly_movable
concept
concept ranges::iindirectly_movable_storable |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_movable_storable
The indirectly_movable_storable
concept
concept ranges::iindirectly_readable |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_readable
The indirectly_readable
concept
concept ranges::iindirectly_regular_unary_invocable |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_regular_unary_invocable
The indirectly_regular_unary_invocable
concept
concept ranges::iindirectly_swappable |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_swappable
The indirectly_swappable
concept
concept ranges::iindirectly_unary_invocable |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_unary_invocable
The indirectly_unary_invocable
concept
concept ranges::iindirectly_writable |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_writable
The indirectly_writable
concept
concept ranges::iinput_iterator |
#include <range/v3/iterator/concepts.hpp>
\concept input_iterator
The input_iterator
concept
concept ranges::iinput_or_output_iterator |
#include <range/v3/iterator/concepts.hpp>
\concept input_or_output_iterator
The input_or_output_iterator
concept
concept ranges::incrementable_ = requires( I i ) { concepts::requires_<same_as<I, decltype(i++)>> ; } |
concept ranges::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) ; } |
#include <range/v3/iterator/concepts.hpp>
\concept indirectly_swappable_
The indirectly_swappable_
concept
concept ranges::mmergeable |
#include <range/v3/iterator/concepts.hpp>
concept ranges::ooutput_iterator |
#include <range/v3/iterator/concepts.hpp>
\concept output_iterator
The output_iterator
concept
concept ranges::output_iterator_ = requires( Out o, T && t ) { *o++ = (T &&) t ; } |
concept ranges::ppermutable |
#include <range/v3/iterator/concepts.hpp>
\concept permutable
The permutable
concept
concept ranges::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>>> ; } |
#include <range/v3/iterator/concepts.hpp>
\concept random_access_iterator_
The random_access_iterator_
concept
|
constexpr |
#include <range/v3/iterator/concepts.hpp>
concept ranges::rrandom_access_iterator |
#include <range/v3/iterator/concepts.hpp>
\concept random_access_iterator
The random_access_iterator
concept
concept ranges::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)>> ; } |
#include <range/v3/iterator/concepts.hpp>
\concept sized_sentinel_for_
The sized_sentinel_for_
concept
concept ranges::ssentinel_for |
#include <range/v3/iterator/concepts.hpp>
\concept sentinel_for
The sentinel_for
concept
concept ranges::ssized_sentinel_for |
#include <range/v3/iterator/concepts.hpp>
\concept sized_sentinel_for
The sized_sentinel_for
concept
concept ranges::ssortable |
#include <range/v3/iterator/concepts.hpp>
\concept sortable
The sortable
concept
concept ranges::weakly_incrementable_ = requires( I i ) { ++i, i++, concepts::requires_<same_as<I&, decltype(++i)>> ; } |
#include <range/v3/iterator/concepts.hpp>
\concept weakly_incrementable_
The weakly_incrementable_
concept
|
constexpr |
#include <range/v3/iterator/concepts.hpp>
concept ranges::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 ; } |
concept ranges::wweakly_incrementable |
#include <range/v3/iterator/concepts.hpp>
\concept weakly_incrementable
The weakly_incrementable
concept