Linux Manuals

std::experimental::ranges::value_type – std::experimental::ranges::value_type Synopsis Defined in header<experimental / ranges / iterator> template <class I> (1) struct value_type { }; template <class T> (2) struct value_type<T *>; template <class I> requires std::is_array<I>::value(3) struct value_type<I> : value_type<std::decay_t<I>> { }; template <class T> (4) struct value_type<const T> : value_type<std::decay_t<T>> { }; template <class T> requires requires { typename…

std::experimental::ranges::tagged_tuple – std::experimental::ranges::tagged_tuple Synopsis Defined in header <experimental/ranges/tuple> template< TaggedType… Types > (ranges TS) using tagged_tuple = /* see below */; Convenience alias template for naming a ranges::tagged wrapping a std::tuple. A TaggedType is a function type S(T), where S is a TagSpecifier and T is the type of the element. tagged_tuple<S1(T1), …, SN(TN)> is…

std::experimental::ranges::tagged_pair – std::experimental::ranges::tagged_pair Synopsis Defined in header <experimental/ranges/utility> template< TaggedType T1, TaggedType T2 > (ranges TS) using tagged_pair = /* see below */; Convenience alias template for naming a ranges::tagged wrapping a std::pair. A TaggedType is a function type S(T), where S is a TagSpecifier and T is the type of the element. tagged_pair<S1(T1), S2(T2)>…

std::experimental::ranges::tagged<Base,Tags…>::tagged – std::experimental::ranges::tagged<Base,Tags…>::tagged Synopsis using Base::Base; (1) tagged() = default; (2) tagged(tagged &&that) = default; (3) tagged(const tagged &that) = default; (4) tagged(Base &&that) noexcept(std::is_nothrow_move_constructible<Base>::value)(5) requires MoveConstructible<Base>; tagged(const Base &that) noexcept(std::is_nothrow_copy_constructible<Base>::value)(6) requires CopyConstructible<Base>; template <class Other> requires Constructible<Base, Other>(7) constexpr tagged(ranges::tagged<Other, Tags…> &&that) noexcept(std::is_nothrow_constructible<Base, Other>::value); template <class Other> requires Constructible<Base, const Other &>(8) constexpr tagged(const…

std::experimental::ranges::tag::in,in1,in2,out,out1,out2,fun,min,max,begin,end – std::experimental::ranges::tag::in,in1,in2,out,out1,out2,fun,min,max,begin,end Synopsis Defined in header<experimental / ranges / algorithm> struct in { /* implementation-defined */ }; struct in1 { /* implementation-defined */ }; struct in2 { /* implementation-defined */ }; struct out { /* implementation-defined */ }; struct out1 { /* implementation-defined */ }; struct out2 { /* implementation-defined */ }; (ranges TS)…

std::experimental::ranges::swap – std::experimental::ranges::swap Synopsis Defined in header<experimental / ranges / utility> namespace { (ranges TS) constexpr /* unspecified */ swap = /* unspecified */; (customization point object) } Call signature template <class T, class U> requires /* see below */ void swap(T &&t, U &&u) noexcept(/* see below */); Exchanges the values referenced by t…

std::experimental::ranges::swap(ranges::tagged) – std::experimental::ranges::swap(ranges::tagged) Synopsis friend constexpr void swap(tagged &lhs, tagged &rhs) noexcept(noexcept(lhs.swap(rhs))) requires Swappable<Base>; Swap the contents of *this and rhs, as if by lhs.swap(rhs);. This function is a hidden friend: it is not visible to ordinary unqualified or qualified_lookup, and can only be found by argument-dependent_lookup when tagged is an associated class of the…

std::experimental::ranges::sort – std::experimental::ranges::sort Synopsis Defined in header<experimental / ranges / algorithm> template <RandomAccessIterator I, Sentinel<I> S, class Comp = ranges::less<>, class Proj = ranges::identity> (1)(ranges TS) requires Sortable<I, Comp, Proj> I sort(I first, S last, Comp comp = Comp{}, Proj proj = Proj{}); template <RandomAccessRange R, class Comp = ranges::less<>, class Proj = ranges::identity> (2)(ranges…

std::experimental::ranges::search_n – std::experimental::ranges::search_n Synopsis Defined in header<experimental / ranges / algorithm> template <ForwardIterator I, Sentinel<I> S, class T, class Pred = ranges::equal_to<>, class Proj = ranges::identity> requires IndirectlyComparable<I, const T *, Pred, Proj>(1) (ranges TS) I search_n(I first, S last, ranges::difference_type_t<I> count, const T &value, Pred pred = Pred{}, Proj proj = Proj{}); template <ForwardRange…

std::experimental::ranges::search – std::experimental::ranges::search Synopsis Defined in header <experimental/ranges/algorithm> template< ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2, Sentinel<I2> S2, class Pred = ranges::equal_to<>, class Proj1 = ranges::identity, class Proj2 = ranges::identity > (1) (ranges TS) requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2> I1 search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{}, Proj1 proj1 =…

std::experimental::ranges::reference_t,std::experimental::ranges::rvalue_reference_t,std::experimental::ranges::iter_common_reference_t – std::experimental::ranges::reference_t,std::experimental::ranges::rvalue_reference_t,std::experimental::ranges::iter_common_reference_t Synopsis Defined in header <experimental/ranges/iterator> template <class T> concept bool /*dereferenceable*/ = requires(T& t) { {*t} -> auto&&; }; // exposition only template< /*dereferenceable*/ T > (1) (ranges TS) using reference_t = decltype(*declval<T&>()); template< /*dereferenceable*/ T > requires requires(T& t) { { ranges::iter_move(t) } -> auto&&; } (2) (ranges TS) using rvalue_reference_t…

std::experimental::ranges::reference_t,std::experimental::ranges::rvalue_reference_t, – std::experimental::ranges::reference_t,std::experimental::ranges::rvalue_reference_t, Synopsis Defined in header <experimental/ranges/iterator> template <class T> concept bool /*dereferenceable*/ = requires(T& t) { {*t} -> auto&&; }; // exposition only template< /*dereferenceable*/ T > (1) (ranges TS) using reference_t = decltype(*declval<T&>()); template< /*dereferenceable*/ T > requires requires(T& t) { { ranges::iter_move(t) } -> auto&&; }      (2) (ranges TS) using rvalue_reference_t = decltype(ranges::iter_move(declval<T&>())); template< Readable T > using iter_common_reference_t = (3)…

std::experimental::ranges::projected – std::experimental::ranges::projected Synopsis Defined in header<experimental / ranges / iterator> template <Readable I, IndirectRegularUnaryInvocable<I> Proj> struct projected { using value_type = std::remove_cv_t<std::remove_reference_t<ranges::indirect_result_of_t<Proj &(I)>>>; ranges::indirect_result_of_t<Proj &(I)> operator*() const; }; (ranges TS) template <WeaklyIncrementable I, class Proj> struct difference_type<projected<I, Proj>> { using type = ranges::difference_type_t<I>; }; The class template projected bundles a Readable type I and…

std::experimental::ranges::prev – std::experimental::ranges::prev Synopsis Defined in header<experimental / ranges / iterator> namespace { (ranges TS) constexpr /* unspecified */ prev = /* unspecified */; (customization point object) } Call signature template <Iterator I> (1) constexpr I prev(I i); template <Iterator I> (2) constexpr I prev(I i, ranges::difference_type_t<I> n); template <Iterator I> (3) constexpr I prev(I…

std::experimental::ranges::not_equal_to – std::experimental::ranges::not_equal_to Synopsis Defined in header<experimental / ranges / functional> template <class T = void> requires EqualityComparable<T> || Same<T, void> ||(ranges TS) /* == on two const T lvalues invokes a built-in operator comparing pointers */ struct not_equal_to; template <> (ranges TS) struct not_equal_to<void>; Function object for performing comparisons. The primary template invokes operator…

std::experimental::ranges::next – std::experimental::ranges::next Synopsis Defined in header<experimental / ranges / iterator> namespace { (ranges TS) constexpr /* unspecified */ next = /* unspecified */; (customization point object) } Call signature template <Iterator I> (1) constexpr I next(I i); template <Iterator I> (2) constexpr I next(I i, ranges::difference_type_t<I> n); template <Iterator I, Sentinel<I> S> (3) constexpr…

std::experimental::ranges::mismatch – std::experimental::ranges::mismatch Synopsis Defined in header<experimental / ranges / algorithm> template <InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2, class Proj1 = ranges::identity, class Proj2 = ranges::identity, class Pred = ranges::equal_to<>> requires IndirectRelation<Pred, projected<I1, Proj1>, projected<I2, Proj2>>(1) (ranges TS) auto mismatch(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{}, Proj1 proj1…

std::experimental::ranges::make_tagged_tuple – std::experimental::ranges::make_tagged_tuple Synopsis Defined in header<experimental / ranges / tuple> template <TagSpecifier… Tags, class… Types> requires sizeof…(Tags) == sizeof…(Types)(ranges TS) constexpr ranges::tagged</*see below*/, Tags…> make_tagged_tuple(Types &&…t); Convenience function for creating a tagged tuple, deducing the element types from the arguments (the tag specifiers must be explicitly specified). The see below portion of the return…

std::experimental::ranges::make_tagged_pair – std::experimental::ranges::make_tagged_pair Synopsis Defined in header<experimental / ranges / utility> template <TagSpecifier Tag1, TagSpecifier Tag2, class T1, class T2> (ranges TS) constexpr ranges::tagged</*see below*/, Tag1, Tag2> make_tagged_pair(T1 &&x, T2 &&y); Convenience function for creating a tagged pair, deducing the element types from the arguments (the tag specifiers must be explicitly specified). The see below…

std::experimental::ranges::lexicographical_compare – std::experimental::ranges::lexicographical_compare Synopsis Defined in header <experimental/ranges/algorithm> template< InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2, class Proj1 = ranges::identity, class Proj2 = ranges::identity, class Comp = ranges::less<> > requires IndirectStrictWeakOrder<Comp, projected<I1, Proj1>, projected<I2, Proj2>> (1) (ranges TS) bool lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = Comp{}, Proj1 proj1 =…