The Linux Manuals (man pages) document is an important part of Linux documents. Linux Manuals are organized as several sections. Each section has a group of commands for a specific area in Linux usage, administration or development.
std::experimental::ranges::StrictWeakOrder – std::experimental::ranges::StrictWeakOrder Synopsis Defined in header <experimental/ranges/concepts> template < class R, class T, class U > (1) (ranges TS) concept bool StrictWeakOrder = Relation<R, T, U>; The concept StrictWeakOrder<R, T, U> specifies that the Relation R imposes a strict weak ordering on its arguments. A relation r is a strict weak ordering if *…
std::experimental::ranges::StrictTotallyOrdered,std::experimental::ranges::StrictTotallyOrderedWith – std::experimental::ranges::StrictTotallyOrdered,std::experimental::ranges::StrictTotallyOrderedWith Synopsis Defined in header<experimental / ranges / concepts> template <class T> concept bool StrictTotallyOrdered = EqualityComparable<T> && requires(const std::remove_reference_t<T> &a, const std::remove_reference_t<T> &b) { (1)(ranges TS) { a < b } -> Boolean &&; { a > b } -> Boolean &&; { a <= b } -> Boolean &&; { a…
std::experimental::ranges::Sortable – std::experimental::ranges::Sortable Synopsis template <class I, class R = ranges::less<>, class P = ranges::identity> concept bool Sortable = (ranges TS) Permutable<I> && IndirectStrictWeakOrder<R, ranges::projected<I, P>>; The Sortable concept specifies the common requirements of algorithms that permute sequences into ordered sequences (for example, ranges::sort).
std::experimental::ranges::SizedSentinel – std::experimental::ranges::SizedSentinel Synopsis Defined in header<experimental / ranges / iterator> template <class S, class I> concept bool SizedSentinel = Sentinel<S, I> && !ranges::disable_sized_sentinel<std::remove_cv_t<S>, std::remove_cv_t<I>> && (1)(ranges TS) requires(const I &i, const S &s) { { s – i } -> Same<ranges::difference_type_t<I>> &&; { i – s } -> Same<ranges::difference_type_t<I>> &&; }; template <class S,…
std::experimental::ranges::SizedRange – std::experimental::ranges::SizedRange Synopsis Defined in header <experimental/ranges/range> template <class T> concept bool SizedRange = Range<T> && !ranges::disable_sized_range<std::remove_cv_t<std::remove_reference_t<T>>> && (ranges TS) requires(T& t) { { ranges::size(t) } -> ConvertibleTo<ranges::difference_type_t<ranges::iterator_t<T>>>; }; This section is incomplete Reason: add description and extra caveats
std::experimental::ranges::SignedIntegral – std::experimental::ranges::SignedIntegral Synopsis Defined in header <experimental/ranges/concepts> template < class T > (ranges TS) concept bool SignedIntegral = Integral<T> && std::is_signed<T>::value; The concept SignedIntegral<T> is satisfied if and only if T is an integral type and std::is_signed<T>::value is true. There need not be any subsumption relationship between SignedIntegral<T> and std::is_signed<T>::value. Notes SignedIntegral<T> may be…
std::experimental::ranges::Sentinel – std::experimental::ranges::Sentinel Synopsis Defined in header <experimental/ranges/iterator> template < class S, class I > concept bool Sentinel = (ranges TS) Semiregular<S> && Iterator<I> && WeaklyEqualityComparableWith<S, I>; The Sentinel concept specifies the relationship between an Iterator type and a Semiregular type whose values denote a range. Let s and i be values of type S…
std::experimental::ranges::Semiregular – std::experimental::ranges::Semiregular Synopsis Defined in header <experimental/ranges/concepts> template <class T> (ranges TS) concept bool Semiregular = Copyable<T> && DefaultConstructible<T>; The Semiregular concept specifies that a type is both copyable and default constructible. It is satisfied by types that behave similarly to built-in types like int, except that they need not support comparison with ==.
std::experimental::ranges::Same – std::experimental::ranges::Same Synopsis Defined in header <experimental/ranges/concepts> template < class T, class U > (ranges TS) concept bool Same = std::is_same<T, U>::value; // see below The concept Same<T, U> is satisfied if and only if T and U denote the same type. Despite being specified using it, there need not be any subsumption relationship…
std::experimental::ranges::Relation – std::experimental::ranges::Relation Synopsis Defined in header<experimental / ranges / concepts> template <class R, class T, class U> concept bool Relation = Predicate<R, T, T> && Predicate<R, U, U> && CommonReference< const std::remove_reference_t<T> &, const std::remove_reference_t<U> &> && Predicate<R, (1)(ranges TS) ranges::common_reference_t< const std::remove_reference_t<T> &, const std::remove_reference_t<U> &>, ranges::common_reference_t< const std::remove_reference_t<T> &, const std::remove_reference_t<U> &>>…
std::experimental::ranges::Regular – std::experimental::ranges::Regular Synopsis Defined in header <experimental/ranges/concepts> template <class T> (ranges TS) concept bool Regular = Semiregular<T> && EqualityComparable<T>; The Regular concept specifies that a type is regular, that is, it is copyable, default constructible, and equality comparable. It is satisfied by types that behave similarly to built-in types like int, and that are…
std::experimental::ranges::Readable – std::experimental::ranges::Readable Synopsis Defined in header<experimental / ranges / iterator> template <class In> concept bool Readable = requires { typename ranges::value_type_t<In>; typename ranges::reference_t<In>; (ranges TS) typename ranges::rvalue_reference_t<In>; } && CommonReference<ranges::reference_t<In> &&, ranges::value_type_t<In> &> && CommonReference<ranges::reference_t<In> &&, ranges::rvalue_reference_t<In> &&> && CommonReference<ranges::rvalue_reference_t<In> &&, const ranges::value_type_t<In> &>; The concept Readable is satisfied by types that are readable…
std::experimental::ranges::Range – std::experimental::ranges::Range Synopsis Defined in header <experimental/ranges/range> template < class T > concept bool Range = requires(T&& t) { (ranges TS) ranges::begin(t); /* not necessarily equality-preserving (see below) */ ranges::end(t); }; Given an lvalue t of type std::remove_reference_t<T>, Range<T> is satisfied only if * [ranges::begin(t), ranges::end(t)) denotes a range; and * both ranges::begin(t) and…
std::experimental::ranges::RandomAccessRange – std::experimental::ranges::RandomAccessRange Synopsis Defined in header <experimental/ranges/range> template <class T> concept bool RandomAccessRange = (ranges TS) BidirectionalRange<T> && RandomAccessIterator<ranges::iterator_t<T>>; This section is incomplete Reason: add description and extra caveats
std::experimental::ranges::RandomAccessIterator – std::experimental::ranges::RandomAccessIterator Synopsis Defined in header<experimental / ranges / iterator> template <class I> concept bool RandomAccessIterator = BidirectionalIterator<I> && DerivedFrom<ranges::iterator_category_t<I>, ranges::random_access_iterator_tag> && StrictTotallyOrdered<I> && SizedSentinel<I, I> && requires(I i, const I j, const ranges::difference_type_t<I> n) { { i += n } -> Same<I> &; (ranges TS) { j + n } -> Same<I> &&;…
std::experimental::ranges::Predicate – std::experimental::ranges::Predicate Synopsis Defined in header <experimental/ranges/concepts> template < class F, class… Args > concept bool Predicate = (ranges TS) RegularInvocable<F, Args…> && Boolean<std::result_of_t<F&&(Args&&…)>>; The concept Predicate<F, Args…> specifies that F is a predicate that accepts arguments whose types and value categories are encoded by Args…, i.e., it can be invoked with these arguments…
std::experimental::ranges::Permutable – std::experimental::ranges::Permutable Synopsis template <class I> concept bool Permutable = ForwardIterator<I> && (ranges TS) IndirectlyMovableStorable<I, I> && IndirectlySwappable<I, I>; The Permutable concept specifies the common requirements of algorithms that reorder elements in place by moving or swapping them (for example, ranges::rotate).
std::experimental::ranges::OutputRange – std::experimental::ranges::OutputRange Synopsis Defined in header <experimental/ranges/range> template <class R, class T> concept bool OutputRange = (ranges TS) Range<R> && OutputIterator<ranges::iterator_t<R>, T>; This section is incomplete Reason: add description and extra caveats
std::experimental::ranges::OutputIterator – std::experimental::ranges::OutputIterator Synopsis Defined in header <experimental/ranges/iterator> template <class I, class T> concept bool OutputIterator = Iterator<I> && Writable<I, T> && (ranges TS) requires(I i, T&& t) { *i++ = std::forward<T>(t); // not required to be equality preserving }; The OutputIterator concept is a refinement of Iterator, adding the requirement that it can be…
std::experimental::ranges::MoveConstructible – std::experimental::ranges::MoveConstructible Synopsis Defined in header <experimental/ranges/concepts> template < class T > concept bool MoveConstructible = (ranges TS) Constructible<T, T> && ConvertibleTo<T, T>; The concept MoveConstructible is satisfied if T is a reference type, or if it is an object type where an object of that type can constructed from an rvalue of that…