Author: Linux Manual

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

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

std::experimental::ranges::iterator_t,std::experimental::ranges::sentinel_t – std::experimental::ranges::iterator_t,std::experimental::ranges::sentinel_t Synopsis Defined in header <experimental/ranges/range> template< class T > (1) (ranges TS) using iterator_t = decltype(ranges::begin(std::declval<T&>())); template< class T > (2) (ranges TS) using sentinel_t = decltype(ranges::end(std::declval<T&>())); Obtain the iterator and sentinel types of a range T.

std::experimental::ranges::iterator_category – std::experimental::ranges::iterator_category Synopsis Defined in header<experimental / ranges / iterator> template <class I> (1) struct iterator_category { }; template <class T> (2) struct iterator_category<T *>; template <class T> (3) struct iterator_category<const T> : iterator_category<T> { }; template <class T> requires requires { typename T::iterator_category; } (4) struct iterator_category<T>; Computes the iterator category of the…

std::experimental::ranges::is_swappable_with,std::experimental::ranges::is_swappable, – std::experimental::ranges::is_swappable_with,std::experimental::ranges::is_swappable, Synopsis             std::experimental::ranges::is_nothrow_swappable Defined in header<experimental / ranges / type_traits> template <class T, class U> (1)(ranges TS) struct is_swappable_with; template <class T> (2)(ranges TS) struct is_swappable; template <class T, class U> (3)(ranges TS) struct is_nothrow_swappable_with; template <class T> (4)(ranges TS) struct is_nothrow_swappable; 1) If the expressions ranges::swap(std::declval<T>(), std::declval<U>()) and ranges::swap(std::declval<U>(), std::declval<T>()) are both well-formed when treated…

std::experimental::ranges::is_permutation – std::experimental::ranges::is_permutation 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> bool is_permutation(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{}, Proj1 proj1…

std::experimental::ranges::invoke – std::experimental::ranges::invoke Synopsis Defined in header<experimental / ranges / functional> template <class F, class… Args> (ranges TS) std::result_of_t<F && (Args && …)> invoke(F &&f, Args &&…args); Invoke the Callable object f with the parameters args, and return the result, as if by return INVOKE(std::forward<F>(f), std::forward<Args>(args)…); , where INVOKE(f, t1, t2, …, tN) is defined…

std::experimental::ranges::input_iterator_tag, – std::experimental::ranges::input_iterator_tag, Synopsis             std::experimental::ranges::forward_iterator_tag,          std::experimental::ranges::bidirectional_iterator_tag,          std::experimental::ranges::random_access_iterator_tag Defined in header<experimental / ranges / iterator> struct input_iterator_tag { }; struct output_iterator_tag { }; struct forward_iterator_tag : public input_iterator_tag { }; struct bidirectional_iterator_tag : public forward_iterator_tag { }; struct random_access_iterator_tag : public bidirectional_iterator_tag { }; Defines the category of an iterator. Each tag is an empty type…

std::experimental::ranges::indirect_result_of – std::experimental::ranges::indirect_result_of Synopsis Defined in header<experimental / ranges / iterator> template <class> struct indirect_result_of { }; template <class F, class… Is> (ranges TS) requires Invocable<F, ranges::reference_t<Is>…> struct indirect_result_of<F(Is…)> : std::result_of<F(ranges::reference_t<Is> &&…)> { };

std::experimental::ranges::identity – std::experimental::ranges::identity Synopsis Defined in header <experimental/ranges/functional> struct identity; (ranges TS) ranges::identity is a function object type whose operator() returns its argument unchanged. It is used as the default projection for all Ranges TS algorithms. Member types Member type Definition is_transparent /* unspecified */ Member functions            returns the argument unchanged operator() (public member function)…

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

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

std::experimental::ranges::for_each – std::experimental::ranges::for_each Synopsis Defined in header <experimental/ranges/algorithm> template< InputIterator I, Sentinel<I> S, class Proj = ranges::identity, IndirectUnaryInvocable<projected<I, Proj>> Fun > (1) (ranges TS) ranges::tagged_pair<tag::in(I), tag::fun(Fun)> for_each(I first, S last, Fun f, Proj proj = Proj{}); template< InputRange R, class Proj = ranges::identity, IndirectUnaryInvocable<projected<ranges::iterator_t<R>, Proj>> Fun > (2) (ranges TS) ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>), tag::fun(Fun)> for_each(R&& r, Fun…

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

std::experimental::ranges::find_end – std::experimental::ranges::find_end Synopsis Defined in header <experimental/ranges/algorithm> template< ForwardIterator I1, Sentinel<I1> S1, ForwardIterator I2, Sentinel<I2> S2, class Proj = ranges::identity, IndirectRelation<I2, projected<I1, Proj>> Pred = ranges::equal_to<> > (1) (ranges TS) I1 find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{}, Proj proj = Proj{}); template< ForwardRange R1, ForwardRange R2, class Proj…

std::experimental::ranges::find,std::experimental::ranges::find_if,std::experimental::ranges::find_if_not – std::experimental::ranges::find,std::experimental::ranges::find_if,std::experimental::ranges::find_if_not Synopsis Defined in header<experimental / ranges / algorithm> template <InputIterator I, Sentinel<I> S, class T, class Proj = ranges::identity> requires IndirectRelation < ranges::equal_to<>, projected<I, Proj>, const T * > (1)(ranges TS) I find(I first, S last, const T &value, Proj proj = Proj{}); template <InputRange R, class T, class Proj = ranges::identity>…

std::experimental::ranges::find,std::experimental::ranges::find_if, – std::experimental::ranges::find,std::experimental::ranges::find_if, Synopsis Defined in header <experimental/ranges/algorithm> template< InputIterator I, Sentinel<I> S, class T, class Proj = ranges::identity > requires IndirectRelation<ranges::equal_to<>, projected<I, Proj>,    (1) (ranges TS) const T*> I find(I first, S last, const T &value, Proj proj = Proj{}); template <InputRange R, class T, class Proj = ranges::identity> requires IndirectRelation<ranges::equal_to<>, projected<ranges::iterator_t<R>, Proj>, const T*>                    (2) (ranges TS)…

std::experimental::ranges::exchange – std::experimental::ranges::exchange Synopsis Defined in header <experimental/ranges/utility> template< MoveConstructible T, class U = T > requires Assignable<T&, U> (ranges TS) constexpr T exchange(T& obj, U&& new_val) noexcept(/* see below */); Replaces the value of obj with new_value and returns the old value of obj, as if by T old_value = std::move(obj); obj = std::forward<U>(new_value);…

std::experimental::ranges::equal_to – std::experimental::ranges::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 equal_to; template <> (ranges TS) struct equal_to<void>; Function object for performing comparisons. The primary template invokes operator…

std::experimental::ranges::equal – std::experimental::ranges::equal Synopsis Defined in header<experimental / ranges / algorithm> template <InputIterator I1, Sentinel<I1> S1, InputIterator 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> bool equal(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{}, Proj1 proj1…