- cppreference.com (original) (raw)

namespace std { namespace experimental { namespace ranges { inline namespace v1 { template concept bool /* dereferenceable */ // exposition only = requires(T& t) { {t} -> auto&&; }; namespace { constexpr / unspecified / iter_move = / unspecified /; constexpr / unspecified / iter_swap = / unspecified */; } template struct difference_type; template using difference_type_t = typename difference_type::type; template struct value_type; template using value_type_t = typename value_type::type; template struct iterator_category; template using iterator_category_t = typename iterator_category::type; template </* dereferenceable */ T> using reference_t = decltype(declval<T&>()); template </* dereferenceable */ T> requires / see definition / using rvalue_reference_t = decltype(ranges::iter_move(declval<T&>())); template concept bool Readable = / see definition /; template <class Out, class T> concept bool Writable = / see definition /; template concept bool WeaklyIncrementable = / see definition /; template concept bool Incrementable = / see definition /; template concept bool Iterator = / see definition /; template <class S, class I> concept bool Sentinel = / see definition /; template <class S, class I> constexpr bool disable_sized_sentinel = false; template <class S, class I> concept bool SizedSentinel = / see definition /; template concept bool InputIterator = / see definition /; template concept bool OutputIterator = / see definition /; template concept bool ForwardIterator = / see definition /; template concept bool BidirectionalIterator = / see definition /; template concept bool RandomAccessIterator = / see definition /; template <class F, class I> concept bool IndirectUnaryInvocable = / see definition /; template <class F, class I> concept bool IndirectRegularUnaryInvocable = / see definition /; template <class F, class I> concept bool IndirectUnaryPredicate = / see definition /; template <class F, class I1, class I2 = I1> concept bool IndirectRelation = / see definition /; template <class F, class I1, class I2 = I1> concept bool IndirectStrictWeakOrder = / see definition /; template struct indirect_result_of; template <class F, class... Is> requires Invocable<F, reference_t...> struct indirect_result_of<F(Is...)>; template using indirect_result_of_t = typename indirect_result_of::type; template <Readable I, IndirectRegularUnaryInvocable Proj> struct projected; template <WeaklyIncrementable I, class Proj> struct difference_type<projected<I, Proj>>; template <class In, class Out> concept bool IndirectlyMovable = / see definition /; template <class In, class Out> concept bool IndirectlyMovableStorable = / see definition /; template <class In, class Out> concept bool IndirectlyCopyable = / see definition /; template <class In, class Out> concept bool IndirectlyCopyableStorable = / see definition /; template <class I1, class I2 = I1> concept bool IndirectlySwappable = / see definition /; template <class I1, class I2, class R = equal_to<>, class P1 = identity, class P2 = identity> concept bool IndirectlyComparable = / see definition /; template concept bool Permutable = / see definition /; template <class I1, class I2, class Out, class R = less<>, class P1 = identity, class P2 = identity> concept bool Mergeable = / see definition /; template <class I, class R = less<>, class P = identity> concept bool Sortable = / see definition /; template using iterator_traits = / see definition /; template using iter_common_reference_t = common_reference_t<reference_t, value_type_t&>; struct output_iterator_tag { }; struct input_iterator_tag { }; struct forward_iterator_tag : input_iterator_tag { }; struct bidirectional_iterator_tag : forward_iterator_tag { }; struct random_access_iterator_tag : bidirectional_iterator_tag { }; namespace { constexpr / unspecified / advance = / unspecified /; constexpr / unspecified / distance = / unspecified /; constexpr / unspecified / next = / unspecified /; constexpr / unspecified / prev = / unspecified */; } template class reverse_iterator; template <class I1, class I2> requires EqualityComparableWith<I1, I2> constexpr bool operator==( const reverse_iterator& x, const reverse_iterator& y); template <class I1, class I2> requires EqualityComparableWith<I1, I2> constexpr bool operator!=( const reverse_iterator& x, const reverse_iterator& y); template <class I1, class I2> requires StrictTotallyOrderedWith<I1, I2> constexpr bool operator<( const reverse_iterator& x, const reverse_iterator& y); template <class I1, class I2> requires StrictTotallyOrderedWith<I1, I2> constexpr bool operator>( const reverse_iterator& x, const reverse_iterator& y); template <class I1, class I2> requires StrictTotallyOrderedWith<I1, I2> constexpr bool operator>=( const reverse_iterator& x, const reverse_iterator& y); template <class I1, class I2> requires StrictTotallyOrderedWith<I1, I2> constexpr bool operator<=( const reverse_iterator& x, const reverse_iterator& y); template <class I1, class I2> requires SizedSentinel<I1, I2> constexpr difference_type_t operator-( const reverse_iterator& x, const reverse_iterator& y); template constexpr reverse_iterator operator+( difference_type_t n, const reverse_iterator& x); template constexpr reverse_iterator make_reverse_iterator(I i); template class back_insert_iterator; template back_insert_iterator back_inserter(Container& x); template class front_insert_iterator; template front_insert_iterator front_inserter(Container& x); template class insert_iterator; template insert_iterator inserter(Container& x, iterator_t i); template class move_iterator; template <class I1, class I2> requires EqualityComparableWith<I1, I2> constexpr bool operator==( const move_iterator& x, const move_iterator& y); template <class I1, class I2> requires EqualityComparableWith<I1, I2> constexpr bool operator!=( const move_iterator& x, const move_iterator& y); template <class I1, class I2> requires StrictTotallyOrderedWith<I1, I2> constexpr bool operator<( const move_iterator& x, const move_iterator& y); template <class I1, class I2> requires StrictTotallyOrderedWith<I1, I2> constexpr bool operator<=( const move_iterator& x, const move_iterator& y); template <class I1, class I2> requires StrictTotallyOrderedWith<I1, I2> constexpr bool operator>( const move_iterator& x, const move_iterator& y); template <class I1, class I2> requires StrictTotallyOrderedWith<I1, I2> constexpr bool operator>=( const move_iterator& x, const move_iterator& y); template <class I1, class I2> requires SizedSentinel<I1, I2> constexpr difference_type_t operator-( const move_iterator& x, const move_iterator& y); template constexpr move_iterator operator+( difference_type_t n, const move_iterator& x); template constexpr move_iterator make_move_iterator(I i); template class move_sentinel; template <class I, Sentinel S> constexpr bool operator==( const move_iterator& i, const move_sentinel& s); template <class I, Sentinel S> constexpr bool operator==( const move_sentinel& s, const move_iterator& i); template <class I, Sentinel S> constexpr bool operator!=( const move_iterator& i, const move_sentinel& s); template <class I, Sentinel S> constexpr bool operator!=( const move_sentinel& s, const move_iterator& i); template <class I, SizedSentinel S> constexpr difference_type_t operator-( const move_sentinel& s, const move_iterator& i); template <class I, SizedSentinel S> constexpr difference_type_t operator-( const move_iterator& i, const move_sentinel& s); template constexpr move_sentinel make_move_sentinel(S s); template <Iterator I, Sentinel S> requires !Same<I, S> class common_iterator; template <Readable I, class S> struct value_type<common_iterator<I, S>>; template <InputIterator I, class S> struct iterator_category<common_iterator<I, S>>; template <ForwardIterator I, class S> struct iterator_category<common_iterator<I, S>>; template <class I1, class I2, Sentinel S1, Sentinel S2> bool operator==( const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y); template <class I1, class I2, Sentinel S1, Sentinel S2> requires EqualityComparableWith<I1, I2> bool operator==( const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y); template <class I1, class I2, Sentinel S1, Sentinel S2> bool operator!=( const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y); template <class I2, SizedSentinel I1, SizedSentinel S1, SizedSentinel S2> difference_type_t operator-( const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y); class default_sentinel; template class counted_iterator; template <class I1, class I2> requires Common<I1, I2> constexpr bool operator==( const counted_iterator& x, const counted_iterator& y); constexpr bool operator==( const counted_iterator& x, default_sentinel); constexpr bool operator==( default_sentinel, const counted_iterator& x); template <class I1, class I2> requires Common<I1, I2> constexpr bool operator!=( const counted_iterator& x, const counted_iterator& y); constexpr bool operator!=( const counted_iterator& x, default_sentinel y); constexpr bool operator!=( default_sentinel x, const counted_iterator& y); template <class I1, class I2> requires Common<I1, I2> constexpr bool operator<( const counted_iterator& x, const counted_iterator& y); template <class I1, class I2> requires Common<I1, I2> constexpr bool operator<=( const counted_iterator& x, const counted_iterator& y); template <class I1, class I2> requires Common<I1, I2> constexpr bool operator>( const counted_iterator& x, const counted_iterator& y); template <class I1, class I2> requires Common<I1, I2> constexpr bool operator>=( const counted_iterator& x, const counted_iterator& y); template <class I1, class I2> requires Common<I1, I2> constexpr difference_type_t operator-( const counted_iterator& x, const counted_iterator& y); template constexpr difference_type_t operator-( const counted_iterator& x, default_sentinel y); template constexpr difference_type_t operator-( default_sentinel x, const counted_iterator& y); template constexpr counted_iterator operator+(difference_type_t n, const counted_iterator& x); template constexpr counted_iterator make_counted_iterator(I i, difference_type_t n); class unreachable; template constexpr bool operator==(const I&, unreachable) noexcept; template constexpr bool operator==(unreachable, const I&) noexcept; template constexpr bool operator!=(const I&, unreachable) noexcept; template constexpr bool operator!=(unreachable, const I&) noexcept; template class dangling; template <class T, class CharT = char, class Traits = char_traits, class Distance = ptrdiff_t> class istream_iterator; template <class T, class CharT, class Traits, class Distance> bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x, const istream_iterator<T, CharT, Traits, Distance>& y); template <class T, class CharT, class Traits, class Distance> bool operator==(default_sentinel x, const istream_iterator<T, CharT, Traits, Distance>& y); template <class T, class CharT, class Traits, class Distance> bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x, default_sentinel y); template <class T, class CharT, class Traits, class Distance> bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x, const istream_iterator<T, CharT, Traits, Distance>& y); template <class T, class CharT, class Traits, class Distance> bool operator!=(default_sentinel x, const istream_iterator<T, CharT, Traits, Distance>& y); template <class T, class CharT, class Traits, class Distance> bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x, default_sentinel y); template <class T, class CharT = char, class Traits = char_traits> class ostream_iterator; template <class CharT, class Traits = char_traits > class istreambuf_iterator; template <class CharT, class Traits> bool operator==(const istreambuf_iterator<CharT, Traits>& a, const istreambuf_iterator<CharT, Traits>& b); template <class CharT, class Traits> bool operator==(default_sentinel a, const istreambuf_iterator<CharT, Traits>& b); template <class CharT, class Traits> bool operator==(const istreambuf_iterator<CharT, Traits>& a, default_sentinel b); template <class CharT, class Traits> bool operator!=(const istreambuf_iterator<CharT, Traits>& a, const istreambuf_iterator<CharT, Traits>& b); template <class CharT, class Traits> bool operator!=(default_sentinel a, const istreambuf_iterator<CharT, Traits>& b); template <class CharT, class Traits> bool operator!=(const istreambuf_iterator<CharT, Traits>& a, default_sentinel b); template <class CharT, class Traits = char_traits > class ostreambuf_iterator; }}}} namespace std { template <experimental::ranges::Iterator Out> struct iterator_traits; template <experimental::ranges::InputIterator In> struct iterator_traits; template <experimental::ranges::InputIterator In> requires experimental::ranges::Sentinel<In, In> struct iterator_traits; }