 |
Arene Base
Fundamental Utilities For Safety Critical C++
|
|
Arene Base
Fundamental Utilities For Safety Critical C++
|
STL namespace.
| using std::add_const_t = typename add_const<Type>::type |
Add const to the provided type. An alias for the modified type.
| Type | The type to add const to |
| using std::add_cv_t = typename add_cv<Type>::type |
Add const and volatile to the provided type. An alias for the modified type.
| Type | The type to add const and volatile to |
| using std::add_lvalue_reference = add_lvalue_reference_detail::add_lvalue_reference<Type> |
Add an lvalue reference onto Type.
| Type | The type to add an lvalue reference to |
add_lvalue_reference works with both referenceable and non-referenceable types. Referenceable types are types in one of three categories:
For category 3, this should follow reference collapsing rules.
Any type not in one of these three categories is a "non-referenceable" type. For example, void. For non-referenceable types, add_lvalue_reference will return back the input type.
| using std::add_lvalue_reference_t = typename add_lvalue_reference<Type>::type |
Add an lvalue reference onto Type.
| Type | The type to add an lvalue reference to |
| using std::add_pointer_t = typename add_pointer<Type>::type |
Adds a pointer to the given type.
If Type is a referenceable type or (possibly cv-qualified) void, the member typedef type provided is typename std::remove_reference<T>::type*. Otherwise, the member typedef type provided is T.
| T | The type to add the pointer to |
| using std::add_rvalue_reference = add_rvalue_reference_detail::add_rvalue_reference<Type> |
Add an rvalue reference onto Type.
| Type | The type to add an rvalue reference to |
add_rvalue_reference works with both referenceable and non-referenceable types. Referenceable types are types in one of three categories:
For category 3, this should follow reference collapsing rules.
Any type not in one of these three categories is a "non-referenceable" type. For example, void. For non-referenceable types, add_rvalue_reference will return back the input type.
| using std::add_rvalue_reference_t = typename add_rvalue_reference<Type>::type |
Add an rvalue reference onto Type.
| Type | The type to add an rvalue reference to |
| using std::add_volatile_t = typename add_volatile<Type>::type |
Add volatile to the provided type. An alias for the modified type.
| Type | The type to add volatile to |
The SI prefix for 10^(-18), expressed as a ratio.
| using std::back_insert_iterator |
iterator adaptor for insertion at the end of a container
| Container | associated container type |
std::back_insert_iterator is an OutputIterator that appends elements to a container for which it was constructed. The container's push_back() member function is called whenever the iterator (whether dereferenced or not) is assigned to. Incrementing the std::back_insert_iterator is a no-op.
| using std::bool_constant = integral_constant<bool, Value> |
An alias for integral_constant<bool,Value>
| Value | the value of the constant |
| using std::centi = ratio<1, 100> |
The SI prefix for 10^(-2), expressed as a ratio.
| using std::common_type_t = typename common_type<Ts...>::type |
Helper alias template for common_type.
| Ts | Types to find common type for |
| using std::conditional_t = typename conditional<Condition, TrueType, FalseType>::type |
Helper template alias for selecting types based on a condition. If the supplied Condition is true then it is an alias for TrueType otherwise it is an alias for FalseType.
| Condition | The condition |
| TrueType | The type to use if the condition is true |
| FalseType | The type to use if the condition is false |
| using std::decay_t = typename decay<Type>::type |
A conversion equivalent to those performed when passing function arguments by value.
| Type | The type to decay |
| using std::enable_if_t = typename enable_if<Condition, Type>::type |
Type alias to support constraining templates. Is an alias for the specified type if the Condition is true and is not defined if the Condition is false.
| Condition | the condition to check |
| Type | the type of the result |
| using std::false_type = bool_constant<false> |
An alias for bool_constant<false>
| using std::femto = ratio<1, 1'000'000'000'000'000> |
The SI prefix for 10^(-15), expressed as a ratio.
| using std::hecto = ratio<100, 1> |
The SI prefix for 10^2, expressed as a ratio.
| using std::index_sequence = integer_sequence<size_t, Ints...> |
A helper alias template for integer_sequence<size_t, Ints>
| Ints | a non-type parameter pack of elements defining the sequence |
| using std::index_sequence_for = make_index_sequence<sizeof...(Types)> |
A helper alias template convert any type parameter pack into an index sequence of the same length.
| Types | parameter pack of types |
| using std::insert_iterator |
iterator adaptor for insertion into a container
| Container | associated container type |
std::insert_iterator is an OutputIterator that inserts elements into a container for which it was constructed, at the position pointed to by the supplied iterator. The container's insert() member function is called whenever the iterator (whether dereferenced or not) is assigned to. Incrementing the std::insert_iterator is a no-op.
std::insert_iterator places the earliest elements first. | using std::int16_t = ::int16_t |
A 16-bit signed integer type.
| using std::int32_t = ::int32_t |
A 32-bit signed integer type.
| using std::int64_t = ::int64_t |
A 64-bit signed integer type.
| using std::int8_t = ::int8_t |
An 8-bit signed integer type.
| using std::intmax_t = ::intmax_t |
A maximum-width signed integer type.
| using std::intptr_t = ::intptr_t |
A signed integer type the same size as a pointer.
| using std::make_index_sequence = make_integer_sequence<size_t, Size> |
A helper alias template for make_integer_sequence<size_t, Size>
| Size | size of the sequence |
| using std::make_integer_sequence = typename integer_sequence_detail::make_integer_sequence<Type, Size>::type |
Helper alias template to simplify creation of std::integer_sequence types with 0, 1, ..., N - 1 as Ints.
| Type | an integer type to use for the sequence of elements |
| Size | size of the sequence |
If N is negative the program is ill-formed. The alias template make_integer_sequence denotes a specialization of integer_sequence with N template non-type arguments. The type make_integer_sequence<T, N> denotes the type integer_sequence<T, 0, 1, ..., N-1>.
| using std::make_signed = make_signed_detail::make_signed<Type> |
A type trait to provide the equivalent signed type for integral and enumeration types other than bool.
| Type | The type to get the equivalent of |
| using std::make_signed_t = typename make_signed<Type>::type |
A type alias for the equivalent signed type for integral and enumeration types other than bool.
| Type | The type to get the equivalent of |
| using std::make_unsigned = make_unsigned_detail::make_unsigned<Type> |
A type trait to provide the equivalent unsigned type for integral and enumeration types other than bool.
| Type | The type to get the equivalent of |
| using std::make_unsigned_t = typename make_unsigned<Type>::type |
A type alias for the equivalent unsigned type for integral and enumeration types other than bool.
| Type | The type to get the equivalent of |
| using std::max_align_t = ::max_align_t |
A POD type which has the maximum alignment required for any built-in type.
| using std::micro = ratio<1, 1'000'000> |
The SI prefix for 10^(-6), expressed as a ratio.
| using std::milli = ratio<1, 1'000> |
The SI prefix for 10^(-3), expressed as a ratio.
| using std::ptrdiff_t = ::ptrdiff_t |
A type suitable for holding the difference between two pointers.
| using std::ratio_add = typename ratio_detail::ratio_add_impl<R1, R2>::type |
Defines the ratio yielded by adding the two given ratios.
| R1 | The first addend |
| R2 | The second addend |
| using std::ratio_divide = ratio_multiply<R1, ratio<R2::den, R2::num>> |
Defines the ratio yielded by dividing the two given ratios.
| R1 | The dividend |
| R2 | The divisor |
| using std::ratio_multiply = typename ratio_detail::ratio_multiply_impl<R1, R2>::type |
Defines the ratio yielded by multiplying the two given ratios.
| R1 | The first multiplicand |
| R2 | The second multiplicand |
| using std::ratio_subtract = ratio_add<R1, ratio<-R2::num, R2::den>> |
Defines the ratio yielded by subtracting the two given ratios.
| R1 | The minuend |
| R2 | The subtrahend |
| using std::remove_all_extents_t = typename remove_all_extents<T>::type |
Removes all extents from the given array type.
| T | The array type to remove the extents from |
Alias to remove_all_extents<T>::type.
| using std::remove_const_t = typename remove_const<Type>::type |
remove const from the provided type. An alias for the modified type.
| Type | The type to remove const to |
| using std::remove_cv_t = typename remove_cv<T>::type |
An alias for T, but with top-level const and/or volatile qualifiers removed.
| T | The type to remove the qualifiers from |
| using std::remove_extent_t = typename remove_extent<T>::type |
Removes the first extent from the given array type.
| T | The array type to remove the first extent from |
Alias to remove_extent<T>::type.
| using std::remove_pointer_t = typename remove_pointer<T>::type |
The type member is an alias for the type pointed to by T, or the same as T if it is not a pointer.
| T | The type to remove the pointer from |
| using std::remove_reference_t = typename remove_reference<T>::type |
An alias for T, but with top-level reference qualifiers removed.
| T | The type to remove the reference qualifiers from |
| using std::remove_volatile_t = typename remove_volatile<Type>::type |
remove volatile from the provided type. An alias for the modified type.
| Type | The type to remove volatile to |
| using std::size_t = ::size_t |
A type suitable for holding the size of an object.
| using std::string = basic_string<arene::base::detail::character> |
Alias for the common case of a string with char characters, standard traits and standard allocator.
| using std::true_type = bool_constant<true> |
An alias for bool_constant<true>
| using std::tuple_element_t = typename tuple_element<I, T>::type |
obtains the type of the specified element
| I | index to obtain the element type of |
| T | tuple-like type |
| using std::uint16_t = ::uint16_t |
A 16-bit unsigned integer type.
| using std::uint32_t = ::uint32_t |
A 32-bit unsigned integer type.
| using std::uint64_t = ::uint64_t |
A 64-bit unsigned integer type.
| using std::uint8_t = ::uint8_t |
An 8-bit unsigned integer type.
| using std::uintmax_t = ::uintmax_t |
A maximum-width unsigned integer type.
| using std::uintptr_t = ::uintptr_t |
An unsigned integer type the same size as a pointer.
| using std::underlying_type = underlying_type_detail::underlying_type<T> |
Obtains the underlying integer type for a given enumeration type.
| T | Enumeration type |
Provides member type alias type that names the underlying type of T if T is an enumeration type. If T is not an enumeration type, there is no member type.
| using std::underlying_type_t = typename underlying_type<T>::type |
An alias for the underlying type of T, if T is an enumeration type.
| T | The type to get the underlying type of |
| using std::void_t = arene::base::void_t<Args...> |
An alias for void that accepts any number of type parameters, used for substitution checks template.
| Args | Any number of template parameters |
|
noexcept |
Perform a left-fold on the input range [first,last) starting with the value init . For each element e in the range, does init=init+e.
| InputIterator | The iterator type of the range |
| T | The type of the initial value and return value |
| first | The start of the range |
| last | The end of the range |
| init | The initial value |
init as modified by the operations InputIterator must be a valid input iterator init=init+*first must be defined. | Any | exception thrown from iterator operations, or init=init+e |
|
noexcept |
Perform a left-fold on the input range [first,last) starting with the value init using the specified binary_op . For each element e in the range, does init=binary_op(init,e)
| InputIterator | The iterator type of the range |
| T | The type of the initial value and return value |
| BinaryOperation | The type of the binary operation |
| first | The start of the range |
| last | The end of the range |
| init | The initial value |
| binary_op | The operator to use to accumulate the values |
init as modified by the operations InputIterator must be a valid input iterator init=binary_op(init,*first) must be defined. | Any | exception thrown from iterator operations, or init=binary_op(init,*first) |
|
constexprnoexcept |
Obtains the actual address of the object or function arg, even in presence of overloaded operator&.
| T | The type of the value |
| value | The value to take the address of |
|
constexprdeletenoexcept |
Obtains the actual address of the object or function arg, even in presence of overloaded operator&.
| T | The type of the value |
|
noexcept |
finds the first two adjacent items that are equal
| ForwardIterator | iterator type |
| first | the beginning of the range |
| last | the end of the range |
ForwardIteratorerator must satisfy the forward iterator requirements. [begin, end) must be a valid range. e1 == e2 must be convertible to bool for every argument e1, e2 of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e1 or e2.[first, last) such that *it == *(it + 1) or last if no such element is found.min((i - first) + 1, (last - first) - 1) equality comparisons, where i is adjacent_find's return value.
|
noexcept |
finds the first two adjacent items that satisfy a given predicate
| ForwardIterator | iterator type |
| BinaryPred | binary predicate type |
| first | the beginning of the range |
| last | the end of the range |
| pred | binary predicate which returns true if the elements should be treated as equal |
ForwardIteratorerator must satisfy the forward iterator requirements. [begin, end) must be a valid range. pred(e1, e2) must be convertible to bool for every argument e1, e2 of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e1 or e2.[first, last) such that pred(*it, *(it + 1)) != false or last if no such element is found.min((i - first) + 1, (last - first) - 1) applications of the corresponding predicate, where i is adjacent_find's return value.
|
constexprnoexcept |
creates a std::back_insert_iterator of type inferred from the argument
| Container | container type to insert into |
| container | container to insert into |
std::back_inserter is a convenience function template that constructs a std::back_insert_iterator for the container container with the type deduced from the type of the argument.
std::back_insert_iterator which can be used to add elements to the end of the container container.
|
constexprnoexcept |
Obtain the result of calling cont.begin() on a container.
| Container | The type of the container |
| cont | The container object |
cont.begin()
|
constexprnoexcept |
Obtain the result of calling cont.begin() on a const container.
| Container | The type of the container |
| cont | The container object |
cont.begin()
|
constexprnoexcept |
Obtain a pointer to the first element of the array.
| Element | The element type of the array |
| Size | The size of the array |
| array | The array |
array
|
constexprnoexcept |
Equivalent to invoking begin(cont) on a const container.
| Container | The type of the container |
| cont | The container object |
cont.begin()
|
constexprnoexcept |
Equivalent to invoking end(cont) on a const container.
| Container | The type of the container |
| cont | The container object |
cont.end()
|
noexcept |
Copy count elements from the input range starting with first to the output range starting with out.
| InputIterator | The type of the input iterator |
| Size | The type of the count of elements to copy |
| OutputIterator | The type of the output iterator |
| first | The start of the source range |
| count | The number of elements to copy |
| out | The start of the output range |
out InputIterator must be an input iterator first must be the start of a valid input range of at least count elements Size must be convertible to an integral type OutputIterator must be an output iterator out must be the start of a valid output range of at least count elements
|
constexpr |
Count the number of elements in a range satisfying a predicate.
| InputIterator | The type of the iterators denoting the input range. |
| UnaryPredicate | The type of the unary callable that returns a boolean testable value |
| begin | The start of the range |
| end | The end of the range |
| predicate | The unary predicate which returns true for the counted elements |
predicate returns true InputIterator must satisfy the input iterator requirements. predicate(v) must be convertible to bool for every argument v of type (possibly const) VT, where VT is the value type of InputIterator, regardless of value category, and must not modify v.
|
noexcept |
Create a const type-deduced copy of a reference_wrapper.
| T | Type wrapped by the input wrapper |
| other | reference_wrapper to copy |
reference_wrapper
|
delete |
Cannot create a reference_wrapper from an rvalue reference.
| T | type of the reference |
|
noexcept |
Create a const type-deduced reference_wrapper.
| T | type of the reference |
| to_wrap | Object or function to wrap |
reference_wrapper around the input of const-qualified type
|
noexcept |
A dummy function that is declared but not defined, with a user-specified return type, for use in unevaluated expressions.
| T | The return type |
|
constexprnoexcept |
Obtain the result of calling cont.end() on a container.
| Container | The type of the container |
| cont | The container object |
cont.end()
|
constexprnoexcept |
Obtain the result of calling cont.end() on a const container.
| Container | The type of the container |
| cont | The container object |
cont.end()
|
constexprnoexcept |
Obtain a pointer to the one-past-the-end element of the array.
| Element | The element type of the array |
| Size | The size of the array |
| array | The array |
array
|
constexprnoexcept |
Assign a new value to an object and return the old value. Implements std::exchange.
| T | The type of the object to update |
| U | The type of the source |
| target | The object to update |
| source | The source |
T must be move-constructible is_assignable_v<T&,U&&> must be true
|
noexcept |
Find the first position in a range where the predicate is false. Returns the end of the range if there is no such position.
| InputIterator | The type of the iterator used to mark the range |
| Predicate | The type of the predicate |
| first | The start of the range |
| last | The end of the range |
| pred | The predicate |
pred(*it) is false, or last if no such iterator exists InputIterator must be an input iterator pred(*first) must be well-formed and return a boolean-testable value
|
constexprnoexcept |
Cast a value to an rvalue if T is an rvalue or rvalue reference, otherwise forward an lvalue reference.
| T | The type of the value |
| value | The value to cast |
|
constexprnoexcept |
Cast a value to an rvalue if T is an rvalue or rvalue reference, otherwise forward an lvalue reference.
| T | The type of the value |
| value | The value to cast |
|
constexprnoexcept |
construct a tuple of references to the provided arguments suitable for forwarding as arguments to a function call.
| ArgTs | types of the tuple members, deduced from args |
| args | a pack of values used to initialize the tuple |
tuple constructed as if via std::tuple<Args&&...>(std::forward<Args>(args)...)
|
constexprnoexcept |
access an element of a pair
| T1 | first pair type |
| T2 | second pair type |
| values | reference to a pair |
values std::is_same<T1, T2>::value is true | T1 | second pair type |
| T2 | second pair type |
| values | reference to a pair |
values std::is_same<T1, T2>::value is true
|
constexprnoexcept |
access an element of a pair
| I | index of the element to access |
| T1 | first pair type |
| T2 | second pair type |
| values | reference to a pair |
values I >= 2
|
constexprnoexcept |
access an element of a pair
| T1 | first pair type |
| T2 | second pair type |
| values | reference to a pair |
values std::is_same<T1, T2>::value is true | T1 | second pair type |
| T2 | second pair type |
| values | reference to a pair |
values std::is_same<T1, T2>::value is true
|
constexprnoexcept |
access an element of a pair
| I | index of the element to access |
| T1 | first pair type |
| T2 | second pair type |
| values | reference to a pair |
values I >= 2
|
constexprnoexcept |
access an element of a pair
| T1 | first pair type |
| T2 | second pair type |
| values | reference to a pair |
values std::is_same<T1, T2>::value is true | T1 | second pair type |
| T2 | second pair type |
| values | reference to a pair |
values std::is_same<T1, T2>::value is true
|
constexprnoexcept |
access an element of a pair
| I | index of the element to access |
| T1 | first pair type |
| T2 | second pair type |
| values | reference to a pair |
values I >= 2
|
constexprnoexcept |
access an element of a pair
| T1 | first pair type |
| T2 | second pair type |
| values | reference to a pair |
values std::is_same<T1, T2>::value is true | T1 | second pair type |
| T2 | second pair type |
| values | reference to a pair |
values std::is_same<T1, T2>::value is true
|
constexprnoexcept |
access an element of a pair
| I | index of the element to access |
| T1 | first pair type |
| T2 | second pair type |
| values | reference to a pair |
values I >= 2
|
constexprnoexcept |
access an element of a mutable rvalue reference to a tuple
access an element of an rvalue reference to a tuple
| I | index of the element to access |
| Types | types of the tuple |
| tup | tuple to access an element from |
I'th element of tup | T | type of the element to access; must occur exactly once within tuple |
| Types | types of the tuple |
| tup | tuple to access an element from |
T within tup
|
constexprnoexcept |
access an element of a mutable lvalue reference to a tuple
access an element of an lvalue reference to a tuple
| I | index of the element to access |
| Types | types of the tuple |
| tup | tuple to access an element from |
I'th element of tup | T | type of the element to access; must occur exactly once within tuple |
| Types | types of the tuple |
| tup | tuple to access an element from |
T within tup
|
constexprnoexcept |
access an element of a const rvalue reference to a tuple
| I | index of the element to access |
| Types | types of the tuple |
| tup | tuple to access an element from |
I'th element of tup | T | type of the element to access; must occur exactly once within tuple |
| Types | types of the tuple |
| tup | tuple to access an element from |
T within tup
|
constexprnoexcept |
access an element of a const lvalue reference to a tuple
| I | index of the element to access |
| Types | types of the tuple |
| tup | tuple to access an element from |
I'th element of tup | T | type of the element to access; must occur exactly once within tuple |
| Types | types of the tuple |
| tup | tuple to access an element from |
T within tup
|
noexcept |
computes the inner product of two ranges of elements
| InputIt1 | type of the iterator for the first range |
| InputIt2 | type of the iterator for the second range |
| Value | type of the accumulated value |
| first1 | iterator to the beginning of the first range |
| last1 | iterator to one past the end of the first range |
| first2 | iterator to the beginning of the second range |
| init | initial value to start with |
acc (of type Value) with the initial value init and then modifies it with the expression acc = plus(acc, multiplies(*i1, *i2)) for every iterator i1 in the range [first1, last1) in order and its corresponding iterator i2 in the range beginning at first2. [first2, first2 + distance(first1, last1)) is a valid range operator+ does not invalidate subranges, nor modify elements in the ranges [first1, last1) and [first2, first2 + distance(first1, last1)) operator* does not invalidate subranges, nor modify elements in the ranges [first1, last1) and [first2, first2 + distance(first1, last1)) InputIt1 must satisfy the input iterator requirementsInputIt2 must satisfy the input iterator requirementsValue is copy constructibleValue is copy assignable *first1 * *first2 is a valid expression init + multiplies(*first1, *first2) is assignable to Value plus and multiplies, where N = distance(first1, last1) .inner_product always performs the operations in the order given.
|
noexcept |
computes the inner product of two ranges of elements
| InputIt1 | type of the iterator for the first range |
| InputIt2 | type of the iterator for the second range |
| Value | type of the accumulated value |
| Plus | type of the addition operation |
| Multiplies | type of the multiplication operation |
| first1 | iterator to the beginning of the first range |
| last1 | iterator to one past the end of the first range |
| first2 | iterator to the beginning of the second range |
| init | initial value to start with |
| plus | binary function object used to reduce transformed elements to a single value |
| multiplies | binary function object applied to each pair of elements of the input ranges |
acc (of type Value) with the initial value init and then modifies it with the expression acc = plus(acc, multiplies(*i1, *i2)) for every iterator i1 in the range [first1, last1) in order and its corresponding iterator i2 in the range beginning at first2. [first2, first2 + distance(first1, last1)) is a valid range plus does not invalidate subranges, nor modify elements in the ranges [first1, last1) and [first2, first2 + distance(first1, last1)) multiplies does not invalidate subranges, nor modify elements in the ranges [first1, last1) and [first2, first2 + distance(first1, last1)) InputIt1 must satisfy the input iterator requirementsInputIt2 must satisfy the input iterator requirementsValue is copy constructibleValue is copy assignable multiplies(*first1, *first2) is a valid expression plus(init, multiplies(*first1, *first2)) is assignable to Value plus and multiplies, where N = distance(first1, last1) .inner_product always performs the operations in the order given.
|
constexprnoexcept |
creates an std::insert_iterator of type inferred from the argument
| Container | container type to insert into |
| container | container to insert into |
| iter | iterator in container specifying the insertion position |
std::inserter is a convenience function template that constructs an std::insert_iterator for the container container and its iterator iter with the type deduced from the type of the container argument.
std::insert_iterator which can be used to insert elements into the container container at the position specified by iter.
|
noexcept |
fills a range with successive increments of the starting value
| ForwardIt | the type of the ForwardIt |
| Value | the type of the value |
| first | ForwardIt to the beginning of the range |
| last | ForwardIt to one past the end of the range |
| value | initial value to fill with |
Fills the range [first, last) with sequentially increasing values, starting with value and repetitively evaluating ++value .
ForwardIt must satisfy the forward iterator requirements T is convertible to the value type of ForwardIt ++value is well-formed distance(first, last) increments and assignments.
|
noexcept |
Check if a range is sorted. Returns false if there are any pair of sequential elements i and j such that j<i is true otherwise returns true.
| ForwardIterator | The iterator type used to identify the range |
| first | The start of the range |
| last | The end of the range |
true if the range is sorted, false otherwise *first<*first must be valid and return a boolean-testable result
|
noexcept |
Check if a range is sorted. Returns false if there are any pair of sequential elements i and j such that comp(j,i) is true otherwise returns true.
| ForwardIterator | The iterator type used to identify the range |
| Comparator | The type of the comparator |
| first | The start of the range |
| last | The end of the range |
| comp | The comparator |
true if the range is sorted, false otherwise comp(*first,*first) must be valid and return a boolean-testable result comp must provide a strict weak order over the elements of the range
|
constexprnoexcept |
swaps the objects pointed to by two iterators
| ForwardIterator1 | type of the first iterator |
| ForwardIterator2 | type of the second iterator |
| lhs | first iterator to object to swap |
| rhs | second iterator to object to swap |
|
constexprnoexcept |
returns an iterator to the first element not less than the given value
| ForwardIterator | iterator type |
| T | value type to compare against |
| Compare | binary predicate type |
| first | beginning of the partitioned range of elements |
| last | end of the partitioned range of elements |
| value | value to compare elements to |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. e < value must be convertible to bool for every argument e of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e or value. e of [begin, end) must be partitioned with respect to the expression e < value.[first, last) not ordered before value, or last if no such element is found.std::distance(first, last), at most log2(N) + O(1) comparisons with value using operator<.
|
constexprnoexcept |
returns an iterator to the first element not less than the given value
| ForwardIterator | iterator type |
| T | value type to compare against |
| Compare | binary predicate type |
| first | beginning of the partitioned range of elements |
| last | end of the partitioned range of elements |
| value | value to compare elements to |
| comp | binary predicate which returns true if the first argument is ordered before the second |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. comp(e, value) must be convertible to bool for every argument e of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e or value. e of [begin, end) must be partitioned with respect to the expression comp(e, value).[first, last) not ordered before value, or last if no such element is found.std::distance(first, last), at most log2(N) + O(1) applications of the comparator comp. | auto std::make_move_iterator | ( | Iterator | iter | ) | -> std::move_iterator<Iterator> |
Create a move_iterator with the specified underlying iterator.
| Iterator | The type of the underlying iterator |
| iter | The value to use for the underlying iterator |
move_iterator
|
constexprnoexcept |
Creates a std::pair object, deducing the target type from the types of arguments.
| T1 | The first argument type |
| T2 | The second argument type |
| first | The first argument |
| second | The second argument |
Given types std::decay<T1>::type as U1 and std::decay<T2>::type as U2, the types V1 and V2 are defined as follows:
If U1 is std::reference_wrapper<X>, V1 is X&; otherwise V1 is U1. If U2 is std::reference_wrapper<Y>, V2 is Y&; otherwise V2 is U2.
std::pair<V1, V2>(std::forward<T1>(x), std::forward<T2>(y))
|
constexprnoexcept |
construct a tuple with types deduced from the provided arguments
| Types | types of the tuple members, deduced from args |
| args | a pack of values used to initialize the tuple |
tuple with contents initialized using args reference_wrapper instances
|
constexprnoexcept |
Returns the largest value in the std::initializer_list.
| T | The type of the values in the std::initializer_list |
| list | The list of values to compare |
list list.size() > 0 std::is_copy_constructible<T>::value == true comp(a, b) must be convertible to bool for every argument a, b of type T const& .
|
constexprnoexcept |
Returns the largest value in the std::initializer_list.
| T | The type of the values in the std::initializer_list |
| Compare | The type of the comparison function |
| list | The list of values to compare |
| comp | The comparison function which returns true if the first parameter is less than the second |
list using the comparison function comp to compare the values list.size() > 0 std::is_copy_constructible<T>::value == true comp(a, b) must be convertible to bool for every argument a, b of type T const& .
|
constexprnoexcept |
Returns the larger of the given values.
| T | The type of the values |
| lhs | The first value to compare |
| rhs | The second value to compare |
lhs and rhs LessThanComparable, the behavior is undefined
|
constexprnoexcept |
Returns the larger of the given values.
| T | The type of the values |
| Compare | The type of the comparison function |
| lhs | The first value to compare |
| rhs | The second value to compare |
| comp | The comparison function which returns true if the first parameter is less than the second |
lhs and rhs using the comparison function comp to compare the values
|
constexprnoexcept |
returns the largest element in a range
| ForwardIterator | iterator type |
| Compare | binary predicate type |
| first | beginning of the range of elements |
| last | end of the range of elements |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. e1 < e2 must be convertible to bool for every argument e1, e2 of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e1 or e2.Finds the largest element, i.e. the element ordered after all other elements, in the range [first, last).
[first, last). If several elements in the range are equivalent to the largest element, returns the iterator to the first such element. Returns last if the range is empty.std::distance(first, last), exactly max(N - 1, 0) comparisons using operator<.
|
constexprnoexcept |
returns the largest element in a range
| ForwardIterator | iterator type |
| Compare | binary predicate type |
| first | beginning of the range of elements |
| last | end of the range of elements |
| comp | binary predicate which returns true if the first argument is ordered before the second |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. comp(e1, e2) must be convertible to bool for every argument e1, e2 of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e1 or e2.Finds the largest element, i.e. the element ordered after all other elements, in the range [first, last).
[first, last). If several elements in the range are equivalent to the largest element, returns the iterator to the first such element. Returns last if the range is empty.std::distance(first, last), exactly max(N - 1, 0) applications of the comparator comp.
|
inline |
copies one buffer to another
| dest | destination buffer |
| src | source buffer |
| count | number of bytes to copy |
|
constexprnoexcept |
Returns the smallest value in the std::initializer_list.
| T | The type of the values in the std::initializer_list |
| list | The list of values to compare |
list list.size() > 0 std::is_copy_constructible<T>::value == true comp(a, b) must be convertible to bool for every argument a, b of type T const& .
|
constexprnoexcept |
Returns the smallest value in the std::initializer_list.
| T | The type of the values in the std::initializer_list |
| Compare | The type of the comparison function |
| list | The list of values to compare |
| comp | The comparison function which returns true if the first parameter is less than the second |
list using the comparison function comp to compare the values list.size() > 0 std::is_copy_constructible<T>::value == true comp(a, b) must be convertible to bool for every argument a, b of type T const& .
|
constexprnoexcept |
Returns the smaller of the given values.
| T | The type of the values |
| lhs | The first value to compare |
| rhs | The second value to compare |
lhs and rhs LessThanComparable, the behavior is undefined
|
constexprnoexcept |
Returns the smaller of the given values.
| T | The type of the values |
| Compare | The type of the comparison function |
| lhs | The first value to compare |
| rhs | The second value to compare |
| comp | The comparison function which returns true if the first parameter is less than the second |
lhs and rhs using the comparison function comp to compare the values
|
constexprnoexcept |
returns the smallest element in a range
| ForwardIterator | iterator type |
| Compare | binary predicate type |
| first | beginning of the range of elements |
| last | end of the range of elements |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. e1 < e2 must be convertible to bool for every argument e1, e2 of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e1 or e2.Finds the smallest element, i.e. the element ordered before all other elements, in the range [first, last).
[first, last). If several elements in the range are equivalent to the smallest element, returns the iterator to the first such element. Returns last if the range is empty.std::distance(first, last), exactly max(N - 1, 0) comparisons using operator<.
|
constexprnoexcept |
returns the smallest element in a range
| ForwardIterator | iterator type |
| Compare | binary predicate type |
| first | beginning of the range of elements |
| last | end of the range of elements |
| comp | binary predicate which returns true if the first argument is ordered before the second |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. comp(e1, e2) must be convertible to bool for every argument e1, e2 of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e1 or e2.Finds the smallest element, i.e. the element ordered before all other elements, in the range [first, last).
[first, last). If several elements in the range are equivalent to the smallest element, returns the iterator to the first such element. Returns last if the range is empty.std::distance(first, last), exactly max(N - 1, 0) applications of the comparator comp.
|
constexprnoexcept |
returns the smallest and largest elements in a range
| ForwardIterator | iterator type |
| Compare | binary predicate type |
| first | beginning of the range of elements |
| last | end of the range of elements |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. e1 < e2 must be convertible to bool for every argument e1, e2 of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e1 or e2.Finds both the first smallest element, i.e. the element ordered before all other elements, and the last largest element, i.e. the element ordered after all other elements, in the range [first, last).
[first, last). If several elements in the range are equivalent to the smallest element, returns the iterator to the first such element. If several elements in the range are equivalent to the largest element, returns the iterator to the last such element. Returns make_pair(first, first) if the range is empty.std::distance(first, last), at most max(floor(3*(N-1)/2), 0) applications of the comparator operator<.
|
constexprnoexcept |
returns the smallest and largest elements in a range
| ForwardIterator | iterator type |
| Compare | binary predicate type |
| first | beginning of the range of elements |
| last | end of the range of elements |
| comp | binary predicate which returns true if the first argument is ordered before the second |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. comp(e1, e2) must be convertible to bool for every argument e1, e2 of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e1 or e2.Finds both the first smallest element, i.e. the element ordered before all other elements, and the last largest element, i.e. the element ordered after all other elements, in the range [first, last).
[first, last). If several elements in the range are equivalent to the smallest element, returns the iterator to the first such element. If several elements in the range are equivalent to the largest element, returns the iterator to the last such element. Returns make_pair(first, first) if the range is empty.std::distance(first, last), at most max(floor(3*(N-1)/2), 0) applications of the comparator comp. | auto std::move | ( | InputIterator | begin, |
| InputIterator | end, | ||
| OutputIterator | result ) -> OutputIterator |
Move elements from a source range to a destination range. Implements std::move.
For each element e in the half-open range [begin,end) writes std::move(e) to *result and increments result.
This overload is to generate an error for the case that the elements from the source cannot be assigned to the destination
| InputIterator | The type of the iterators denoting the input range. |
| OutputIterator | The type of the iterator for the output range |
| begin | The start of the source range |
| end | The end of the source range |
| result | The start of the destination range |
OutputIterator equivalent to the final value of result InputIterator must satisfy the input iterator requirements. OutputIterator must satisfy the output iterator requirements. result must be a valid iterator for an output range that can be written to at least as many times as there are elements in the input range. *result=std::move(*begin) is well-formed. | Any | exception thrown by the iteration or move-assignment operations |
|
constexprnoexcept |
Move elements from a source range to a destination range. Implements std::move.
For each element e in the half-open range [begin,end) in order, writes std::move(e) to *result and increments result
| InputIterator | The type of the iterators denoting the input range. |
| OutputIterator | The type of the iterator for the output range |
| begin | The start of the source range |
| end | The end of the source range |
| result | The start of the destination range |
OutputIterator equivalent to the final value of result InputIterator must satisfy the input iterator requirements. OutputIterator must satisfy the output iterator requirements. result must be a valid iterator for an output range that can be written to at least as many times as there are elements in the input range. *result=std::move(*begin) is well-formed. | Any | exception thrown by the iteration or move-assignment operations |
|
constexprnoexcept |
Cast a value to an rvalue.
| T | The type of the value |
| value | The value to cast |
|
noexcept |
Check if the predicate is false for every element in the range. Returns true if there is no element in the range for which the predicate returns true, false otherwise.
| InputIterator | The type of the iterator used to mark the range |
| Predicate | The type of the predicate |
| first | The start of the range |
| last | The end of the range |
| pred | The predicate |
true if there is no element in the range pred(*it) returns true InputIterator must be an input iterator pred(*first) must be well-formed and return a boolean-testable value | auto std::operator!= | ( | move_iterator< Iterator1 > const & | lhs, |
| move_iterator< Iterator2 > const & | rhs ) -> bool |
Check if two iterators are not equal.
| Iterator1 | The type of the first iterator |
| Iterator2 | The type of the second iterator |
| lhs | The first iterator |
| rhs | The second iterator |
true if the iterators are not equal, and false otherwise
|
constexprnoexcept |
Compare two pairs to see if the first is not equal to the second. Uses the equality comparison operators of the members.
| T1 | The type of the first data member of the pairs being compared |
| T2 | The type of the second data member of the pairs being compared |
| lhs | The first pair to compare |
| rhs | The second pair to compare |
true if lhs is not equal to rhs, false otherwise T1 and T2 must have equality operators that provide an equivalency comparison
|
constexprnoexcept |
Compare two tuples by doing an equality comparison on their elements starting from 0.
| LTypes | The element types of the left tuple |
| RTypes | The element types of the right tuple |
| left | The left tuple to compare |
| right | The right tuple to compare |
true if any of the elements of left compare unequal to those of right, otherwise false | auto std::operator+ | ( | typename move_iterator< Iterator >::difference_type | delta, |
| move_iterator< Iterator > const & | iter ) -> move_iterator<Iterator> |
Obtain a new iterator referencing the value from moving the specified iterator forwards by a specified amount.
| delta | The amount to move |
| iter | The iterator to start from |
Iterator must be a random access iterator | auto std::operator- | ( | move_iterator< Iterator1 > const & | lhs, |
| move_iterator< Iterator2 > const & | rhs ) -> |
Obtain the distance between two iterators.
| Iterator1 | The type of the first iterator |
| Iterator2 | The type of the second iterator |
| lhs | The first iterator |
| rhs | The second iterator |
| auto std::operator< | ( | move_iterator< Iterator1 > const & | lhs, |
| move_iterator< Iterator2 > const & | rhs ) -> bool |
Check if one iterator is less than another.
| Iterator1 | The type of the first iterator |
| Iterator2 | The type of the second iterator |
| lhs | The first iterator |
| rhs | The second iterator |
true if the first iterator is less than the second, and false otherwise
|
constexprnoexcept |
Compare two pairs to see if the first is less than the second. Uses lexicographical ordering based on the less-than comparisons of the members.
| T1 | The type of the first data member of the pairs being compared |
| T2 | The type of the second data member of the pairs being compared |
| lhs | The first pair to compare |
| rhs | The second pair to compare |
true if lhs is less than rhs, false otherwise T1 and T2 must have less than operators that provide a strict weak ordering
|
constexprnoexcept |
Compare two tuples by doing a lexicographic comparison on their elements starting from 0.
| LTypes | The element types of the left tuple |
| RTypes | The element types of the right tuple |
| left | The left tuple to compare |
| right | The right tuple to compare |
true if a lexicographic comparison of the elements gives "less", otherwise false | auto std::operator<= | ( | move_iterator< Iterator1 > const & | lhs, |
| move_iterator< Iterator2 > const & | rhs ) -> bool |
Check if one iterator is less than or equal to another.
| Iterator1 | The type of the first iterator |
| Iterator2 | The type of the second iterator |
| lhs | The first iterator |
| rhs | The second iterator |
true if the first iterator is less than or equal to the second, and false otherwise
|
constexprnoexcept |
Compare two pairs to see if the first is less than or equal to the second. Uses lexicographical ordering based on the less-than comparisons of the members.
| T1 | The type of the first data member of the pairs being compared |
| T2 | The type of the second data member of the pairs being compared |
| lhs | The first pair to compare |
| rhs | The second pair to compare |
true if lhs is less than or equal to rhs, false otherwise T1 and T2 must have less than operators that provide a strict weak ordering
|
constexprnoexcept |
Compare two tuples by doing a lexicographic comparison on their elements starting from 0.
| LTypes | The element types of the left tuple |
| RTypes | The element types of the right tuple |
| left | The left tuple to compare |
| right | The right tuple to compare |
true if a lexicographic comparison of the elements gives "less" or "equal", otherwise false | auto std::operator== | ( | move_iterator< Iterator1 > const & | lhs, |
| move_iterator< Iterator2 > const & | rhs ) -> bool |
Check if two iterators are equal.
| Iterator1 | The type of the first iterator |
| Iterator2 | The type of the second iterator |
| lhs | The first iterator |
| rhs | The second iterator |
true if the iterators are equal, and false otherwise
|
constexprnoexcept |
Compare two pairs to see if they are equal, by checking if both members of the first are equal to the corresponding members of the second using the equality comparison operators of the members.
| T1 | The type of the first data member of the pairs being compared |
| T2 | The type of the second data member of the pairs being compared |
| lhs | The first pair to compare |
| rhs | The second pair to compare |
true if lhs is equal to rhs, false otherwise T1 and T2 must have equality operators that provide an equivalency comparison
|
constexprnoexcept |
Compare two tuples by doing an equality comparison on their elements starting from 0.
| LTypes | The element types of the left tuple |
| RTypes | The element types of the right tuple |
| left | The left tuple to compare |
| right | The right tuple to compare |
true if the elements of left all compare equal to those of right, otherwise false | auto std::operator> | ( | move_iterator< Iterator1 > const & | lhs, |
| move_iterator< Iterator2 > const & | rhs ) -> bool |
Check if one iterator is greater than another.
| Iterator1 | The type of the first iterator |
| Iterator2 | The type of the second iterator |
| lhs | The first iterator |
| rhs | The second iterator |
true if the first iterator is greater than the second, and false otherwise
|
constexprnoexcept |
Compare two pairs to see if the first is greater than the second. Uses lexicographical ordering based on the less-than comparisons of the members.
| T1 | The type of the first data member of the pairs being compared |
| T2 | The type of the second data member of the pairs being compared |
| lhs | The first pair to compare |
| rhs | The second pair to compare |
true if lhs is greater than rhs, false otherwise T1 and T2 must have less than operators that provide a strict weak ordering
|
constexprnoexcept |
Compare two tuples by doing a lexicographic comparison on their elements starting from 0.
| LTypes | The element types of the left tuple |
| RTypes | The element types of the right tuple |
| left | The left tuple to compare |
| right | The right tuple to compare |
true if a lexicographic comparison of the elements gives "greater", otherwise false | auto std::operator>= | ( | move_iterator< Iterator1 > const & | lhs, |
| move_iterator< Iterator2 > const & | rhs ) -> bool |
Check if one iterator is greater than or equal to another.
| Iterator1 | The type of the first iterator |
| Iterator2 | The type of the second iterator |
| lhs | The first iterator |
| rhs | The second iterator |
true if the first iterator is greater than or equal to the second, and false otherwise
|
constexprnoexcept |
Compare two pairs to see if the first is greater than or equal to the second. Uses lexicographical ordering based on the less-than comparisons of the members.
| T1 | The type of the first data member of the pairs being compared |
| T2 | The type of the second data member of the pairs being compared |
| lhs | The first pair to compare |
| rhs | The second pair to compare |
true if lhs is greater than or equal to rhs, false otherwise T1 and T2 must have less than operators that provide a strict weak ordering
|
constexprnoexcept |
Compare two tuples by doing a lexicographic comparison on their elements starting from 0.
| LTypes | The element types of the left tuple |
| RTypes | The element types of the right tuple |
| left | The left tuple to compare |
| right | The right tuple to compare |
true if a lexicographic comparison of the elements gives "greater" or "equal", otherwise false | auto std::partial_sort_copy | ( | SourceIterator | source_begin, |
| SourceIterator | source_end, | ||
| TargetIterator | target_begin, | ||
| TargetIterator | target_end ) -> TargetIterator |
Copy the first K elements from the source range, as sorted with respect to operator< , into the target range, where K is the minimum of std::distance(source_begin,source_end) and std::distance(target_begin,target_end)
This performs at most N * (log2(K) + 1) comparisons, where N is std::distance(source_begin,source_end)
| SourceIterator | The type of the iterator for the input range |
| TargetIterator | The type of the iterator for the output range |
| source_begin | The start of the input range |
| source_end | The end of the input range |
| target_begin | The start of the output range |
| target_end | The end of the output range |
TargetIterator referring to one-past the last stored element in the output SourceIterator must be an input iterator, and TargetIterator must be a random access iterator, and | auto std::partial_sort_copy | ( | SourceIterator | source_begin, |
| SourceIterator | source_end, | ||
| TargetIterator | target_begin, | ||
| TargetIterator | target_end, | ||
| Comparator | comp ) -> TargetIterator |
Copy the first K elements from the source range, as sorted with respect to the supplied comparator, into the target range, where K is the minimum of std::distance(source_begin,source_end) and std::distance(target_begin,target_end).
This performs at most N * (log2(K) + 1) comparisons, where N is std::distance(source_begin,source_end)
| SourceIterator | The type of the iterator for the input range |
| TargetIterator | The type of the iterator for the output range |
| Comparator | The comparator type |
| source_begin | The start of the input range |
| source_end | The end of the input range |
| target_begin | The start of the output range |
| target_end | The end of the output range |
| comp | The comparator |
TargetIterator referring to one-past the last stored element in the output SourceIterator must be an input iterator, and TargetIterator must be a random access iterator, and comp(*source_begin,*target_begin) and comp(*target_begin,*target_begin) are both well-formed and convertible to bool
|
noexcept |
Create a type-deduced copy of a reference_wrapper.
| T | Type wrapped by the input wrapper |
| other | reference_wrapper to copy |
reference_wrapper
|
delete |
Cannot create a reference_wrapper from an rvalue reference.
| T | type of the reference |
|
noexcept |
Create a type-deduced reference_wrapper.
| T | type of the reference |
| to_wrap | Object or function to wrap |
reference_wrapper around the input
|
noexcept |
removes elements satisfying specific criteria
| I | forward iterator type |
| P | removal predicate type |
| first | beginning of the range of elements |
| last | end of the range of elements |
| pred | unary predicate which returns true if the element should be removed |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. pred(v) must be convertible to bool for every argument r of type RT, where RT is the reference type of I, regardless of value category, and must not modify r.Removes all elements satisfying specific criteria from the range [first, last) and returns a past-the-end iterator for the new end of the range.
Removal is performed by shifting the elements in the range in such a way that the elements that are not to be removed appear in the beginning of the range. The relative ordering of non removed elements is maintained by std::remove_if.
end(), then it points to an unspecified value, and so do iterators to any values between this iterator and end().std::distance(first, last), exactly N applications of the predicate pred.
|
constexprnoexcept |
reverses the order of elements in a range
| BidirIt | The iterator used to iterate over the input range |
| first | the beginning of the range |
| last | the end of the range |
|
noexcept |
sorts a range into ascending order
| I | iterator type |
| first | beginning of the range |
| last | end of the range |
I must satisfy the random access iterator requirements. I must be ValueSwappable. *first must be Movable. [first, last) must be a valid range. r1 < r2 must be convertible to bool for every argument r1 and r2 of type RT, where RT is the reference type of I, regardless of value category, and must not modify r1 or r2. operator< must define a strict weak ordering relation. For values a, b, and c, the following properties must be satisfied: a < a is false a < b and b < c are both true, then a < c is true e(a, b) be !(a < b) && !(b < a) , then e is transitiveSorts the elements in the range [first, last) in non-descending order, specified by operator<. The order of equal elements is not guaranteed to be preserved.
last - first , O(N * log(N)) applications of operator<.
|
noexcept |
sorts a range into ascending order
| I | iterator type |
| C | compare type |
| first | beginning of the range |
| last | end of the range |
| comp | comparison function object |
I must satisfy the random access iterator requirements. I must be ValueSwappable. *first must be Movable. [first, last) must be a valid range. comp(r1, r2) must be convertible to bool for every argument r1 and r2 of type RT, where RT is the reference type of I, regardless of value category, and must not modify r1 or r2. a, b, and c, the following properties must be satisfied: comp(a, a) is false comp(a, b) and comp(b, c) are both true, then pred(a, c) is true e(a, b) be !comp(a, b) && !comp(b, a) , then e is transitiveSorts the elements in the range [first, last) in non-descending order, specified by comp. The order of equal elements is not guaranteed to be preserved.
is_sorted(first, last, comp) is true last - first , O(N * log(N)) applications of comp.
|
noexcept |
sorts a range into ascending order
| I | iterator type |
| first | beginning of the range |
| last | end of the range |
I must satisfy the random access iterator requirements. I must be ValueSwappable. *first must be Movable. [first, last) must be a valid range. comp(r1, r2) must be convertible to bool for every argument r1 and r2 of type RT, where RT is the reference type of I, regardless of value category, and must not modify r1 or r2. a, b, and c, the following properties must be satisfied: comp(a, a) is false comp(a, b) and comp(b, c) are both true, then comp(a, c) is true e(a, b) be !comp(a, b) && !comp(b, a) , then e is transitiveSorts the elements in the range [first, last) in non-descending order, specified by operator<. The order of equal elements is guaranteed to be preserved.
is_sorted(first, last) is true last - first , worst case of O(N * log(N)) applications of operator<.
|
noexcept |
sorts a range into ascending order
| I | iterator type |
| C | compare type |
| first | beginning of the range |
| last | end of the range |
| comp | comparison function object |
I must satisfy the random access iterator requirements. I must be ValueSwappable. *first must be Movable. [first, last) must be a valid range. comp(r1, r2) must be convertible to bool for every argument r1 and r2 of type RT, where RT is the reference type of I, regardless of value category, and must not modify r1 or r2. a, b, and c, the following properties must be satisfied: comp(a, a) is false comp(a, b) and comp(b, c) are both true, then comp(a, c) is true e(a, b) be !comp(a, b) && !comp(b, a) , then e is transitiveSorts the elements in the range [first, last) in non-descending order, specified by comp. The order of equal elements is guaranteed to be preserved.
is_sorted(first, last, comp) is true last - first , worst case of O(N * log(N)) applications of comp.
|
noexcept |
Swap a pair with another instance of the same type. Swaps lhs.first with rhs.first and swaps lhs.second with rhs.second.
This is disabled if either T1 or T2 is not swappable
| lhs | The first pair to swap |
| rhs | The second pair to swap |
|
constexprnoexcept |
swaps the values of two objects
| T | type of the objects to swap |
| lhs | object to swap |
| rhs | object to swap |
|
constexprnoexcept |
swaps the contents of two arrays
| T | type of the objects in the arrays to swap |
| lhs | array to swap |
| rhs | array to swap |
|
noexcept |
swap two tuples
| Types | The types in the two tuples to be swapped |
| lhs | the first tuple to swap |
| rhs | the second tuple to swap |
swap(get<Idx>(lhs),get<Idx>(rhs)) for every element.
|
noexcept |
function called when exception handling fails
std::terminate that is only enough to allow use of //arene/base:contracts within //stdlib.
|
constexprnoexcept |
Constructs a tuple of references to the given arguments.
| Types | Types of the arguments. |
| args | References to the values to include in the tuple. |
|
constexprnoexcept |
concatenate tuples
| Tuples | types of the tuples to concatenate |
| tuples | std::tuple objects to concatenate |
std::tuple whose elements are the concatenation of tuples in orderstd::tuple or std::pair Passing non-std::tuple tuple-likes to std::tuple_cat is undefined behavior per the standard; use arene::base::tuple_cat for those.
|
noexcept |
removes consecutive elements in a range
| I | forward iterator type |
| first | beginning of the range of elements |
| last | end of the range of elements |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. pred(r1, r2) must be convertible to bool for every argument r1 and r2 of type RT, where RT is the reference type of I, regardless of value category, and must not modify r1 or r2. operator== must define an equivalence relation. For values a, b, and c, the following properties must be satisfied: pred(a, a) is true pred(a, b) == pred(b, a) is true pred(a, b) and pred(b, c) are both true, then pred(a, c) is true Removes all except the first element from a consecutive group of equal elements in the range [first, last) , and and returns a past-the-end iterator for the new end of the range.
Removal is performed by shifting the elements in the range in such a way that the elements that are not to be removed appear in the beginning of the range. The relative ordering of non removed elements is maintained by std::unique, (i.e. relative ordering is stable).
end(), then it points to an unspecified value, and so do iterators to any values between this iterator and end(). std::distance(first, last) , exactly max(0, N - 1) applications of operator==.
|
noexcept |
removes consecutive elements in a range
| I | forward iterator type |
| P | binary predicate type |
| first | beginning of the range of elements |
| last | end of the range of elements |
| pred | binary predicate which returns true if the elements are equivalent |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. pred(r1, r2) must be convertible to bool for every argument r1 and r2 of type RT, where RT is the reference type of I, regardless of value category, and must not modify r1 or r2. a, b, and c, the following properties must be satisfied: pred(a, a) is true pred(a, b) == pred(b, a) is true pred(a, b) and pred(b, c) are both true, then pred(a, c) is true Removes all except the first element from a consecutive group of equivalent elements in the range [first, last) , and and returns a past-the-end iterator for the new end of the range.
Removal is performed by shifting the elements in the range in such a way that the elements that are not to be removed appear in the beginning of the range. The relative ordering of non removed elements is maintained by std::unique, (i.e. relative ordering is stable).
end(), then it points to an unspecified value, and so do iterators to any values between this iterator and end(). std::distance(first, last) , exactly max(0, N - 1) applications of the predicate pred.
|
constexprnoexcept |
returns an iterator to the first element greater than the given value
| ForwardIterator | iterator type |
| T | value type to compare against |
| Compare | binary predicate type |
| first | beginning of the partitioned range of elements |
| last | end of the partitioned range of elements |
| value | value to compare elements to |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. value < e must be convertible to bool for every argument e of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e or value. e of [begin, end) must be partitioned with respect to the expression value < e.[first, last) ordered after value, or last if no such element is found.std::distance(first, last), at most log2(N) + O(1) comparisons with value using operator<.
|
constexprnoexcept |
returns an iterator to the first element greater than the given value
| ForwardIterator | iterator type |
| T | value type to compare against |
| Compare | binary predicate type |
| first | beginning of the partitioned range of elements |
| last | end of the partitioned range of elements |
| value | value to compare elements to |
| comp | binary predicate which returns true if the first argument is ordered before the second |
ForwardIterator must satisfy the forward iterator requirements. [begin, end) must be a valid range. comp(value, e) must be convertible to bool for every argument e of type RT, where RT is the reference type of ForwardIterator, regardless of value category, and must not modify e or value. e of [begin, end) must be partitioned with respect to the expression comp(value, e).[first, last) ordered after value, or last if no such element is found.std::distance(first, last), at most log2(N) + O(1) applications of the comparator comp.
|
externconstexpr |
obtains the size of an array type along a specified dimension
| T | type to query |
| N | specified array dimension |
If T is an array type of rank greater than N, obtains the bound of the N 'th dimension of T as the value. If T is an array type of unknown bound, then the value is 0. In all other cases, value is 0.
|
externconstexpr |
obtains the size of an array type along a specified dimension
| T | type to query |
If T is an array type of rank greater than N, obtains the bound of the N 'th dimension of T as the value. If T is an array type of unknown bound, then the value is 0. In all other cases, value is 0.
|
externconstexpr |
obtains the size of an array type along a specified dimension
| T | type to query |
| N | specified array dimension |
If T is an array type of rank greater than N, obtains the bound of the N 'th dimension of T as the value. If T is an array type of unknown bound, then the value is 0. In all other cases, value is 0.
|
externconstexpr |
obtains the size of an array type along a specified dimension
| T | type to query |
| I | array bound at dimension 0 |
If T is an array type of rank greater than N, obtains the bound of the N 'th dimension of T as the value. If T is an array type of unknown bound, then the value is 0. In all other cases, value is 0.
|
externconstexpr |
obtains the size of an array type along a specified dimension
| T | type to query |
| I | array bound at dimension 0 |
| N | specified array dimension |
If T is an array type of rank greater than N, obtains the bound of the N 'th dimension of T as the value. If T is an array type of unknown bound, then the value is 0. In all other cases, value is 0.
|
staticconstexpr |
An object to which anything can be assigned, which ignores the assigned value.
|
constexpr |
Out-of-line definition for the value constant.
| Type | The type of the value |
| Value | The value of the constant |
|
externconstexpr |
Type trait to detect if a type is an abstract class.
| T | type may be an abstract class |
|
externconstexpr |
A type trait to check if a type is an arithmetic type. The value is true if Type is an arithmetic type, false otherwise.
| Type | The type to check |
|
externconstexpr |
A type trait to check if a type is an array. The value is true if Type is an array, false otherwise.
| Type | The type to check |
|
externconstexpr |
A type trait to check if a type is an array. The value is true if Type is an array, false otherwise.
| Type | The type to check |
|
externconstexpr |
A type trait to check if a type is an array. The value is true if Type is an array, false otherwise.
| Type | The type to check |
|
externconstexpr |
Type trait to detect if an instance of To is assignable to from arguments of From.
| To | The type of the value to (try to) assign to |
| From | The type of the value to (try to) assign from |
|
externconstexpr |
Type trait to detect if Base is a base class of Derived.
| Base | The type which may be a base class |
| Derived | The type which may be a derived class |
|
externconstexpr |
A type trait to check if a type is a class. The value is true if Type is a class, false otherwise.
| Type | The type to check |
|
externconstexpr |
A type trait to check if a type is const. The value is true if Type is const, false otherwise.
| Type | The type to check |
|
externconstexpr |
A type trait to check if a type is const. The value is true if Type is const, false otherwise.
| Type | The type to check, without const |
|
externconstexpr |
Type trait to detect if a type is constructible from arguments of the specified types.
| Type | The type to (try to) construct |
| Args | The types of the arguments to (try to) construct from |
|
externconstexpr |
Type trait to detect if one type is convertible to another.
| From | The type to (try to) convert from |
| To | The type to (try to) convert to |
|
externconstexpr |
Type trait to detect if an instance of T is copy assignable.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if an instance of T is copy constructible.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if an instance of T is default constructible.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if a type is destructible.
| Type | The type to (try to) destruct |
|
externconstexpr |
Type trait to check if a type is an empty type. true if it is, false otherwise.
| Type | The type to check |
|
externconstexpr |
Type trait to check if a type is an enumeration. true if it is, false otherwise.
| Type | The type to check |
|
externconstexpr |
Type trait to check if a type is a final class. true if it is, false otherwise.
| Type | The type to check |
|
externconstexpr |
A type trait to check if a type is floating point. The value is true if Type is a floating point type, false otherwise.
| Type | The type to check |
|
externconstexpr |
A type trait to check if a type is a function. The value is true if Type is a function, false otherwise. Adding a cv-qualifier sequence on top of a function type causes the cv-qualifier to be ignored.
| Type | The type to check |
|
externconstexpr |
Check if the supplied template argument is a fundamental type or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
A type trait to check if a type is integral. The value is true if Type is an integral type, false otherwise.
| Type | The type to check |
|
externconstexpr |
Check if the supplied template argument is an lvalue reference or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
Check if the supplied template argument is an lvalue reference or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
Check if the supplied template argument is a member function pointer or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
Check if the supplied template argument is a member object pointer or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
Check if the supplied template argument is a member pointer or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
Type trait to detect if an instance of T is move assignable.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if an instance of T is move constructible.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if an instance of To is assignable to from arguments of From without throwing.
| To | The type of the value to (try to) assign to |
| From | The type of the value to (try to) assign from |
|
externconstexpr |
Type trait to detect if a type is constructible from arguments of the specified types and is noexcept.
| Type | The type to (try to) construct |
| Args | The types of the arguments to (try to) construct from |
|
externconstexpr |
Type trait to detect if an instance of T is copy assignable without throwing.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if an instance of T is copy constructible without throwing.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if an instance of T is default constructible without throwing.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if a type is destructible without throwing an exception.
| Type | The type to (try to) destruct |
|
externconstexpr |
Type trait to detect if an instance of T is move assignable without throwing.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if an instance of T is move constructible without throwing.
| T | The type of the value to check |
|
externconstexpr |
Check if the supplied template argument is an object or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
Check if the supplied template argument is a pointer or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
Check if the supplied template argument is a reference or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
Check if the supplied template argument is an rvalue reference or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
Check if the supplied template argument is an rvalue reference or not. The value is true if so, false otherwise.
| T | The type to check |
|
externconstexpr |
Trait to detect if the two supplied types are the same or not. The value is true if the types are the same, false otherwise.
| T1 | The first type |
| T2 | The second type |
|
externconstexpr |
Trait to detect if the two supplied types are the same or not. The value is true if the types are the same, false otherwise.
| T | The type |
|
externconstexpr |
A type trait to check if a type is signed. The value is true if Type is a signed type, false otherwise.
| Type | The type to check |
|
externconstexpr |
Type trait to detect if an instance of T is trivially copy assignable.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if an instance of T is trivially copy constructible.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if an instance of T is trivially copyable.
| T | The type of the value to check |
volatile qualified types are not trivially copyable. This was changed with CWG issue 2094, which was accepted as a DR in 2016: https://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#2094 This implementations matches the post-CWG2094 behaviour, which is consistent with C++17 and later too.
|
externconstexpr |
Type trait to detect if an instance of T is trivially default constructible.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if a type is trivially destructible.
| Type | The type to (try to) destruct |
|
externconstexpr |
Type trait to detect if an instance of T is move assignable without throwing.
| T | The type of the value to check |
|
externconstexpr |
Type trait to detect if an instance of T is trivially move constructible.
| T | The type of the value to check |
|
externconstexpr |
A type trait to check if a type is unsigned. The value is true if Type is an unsigned type, false otherwise.
| Type | The type to check |
|
externconstexpr |
A type trait to check if a type is void. The value is true if Type is void, false otherwise.
| Type | The type to check |
|
externconstexpr |
A type trait to check if a type is volatile. The value is true if Type is volatile, false otherwise.
| Type | The type to check |
|
externconstexpr |
A type trait to check if a type is volatile. The value is true if Type is volatile, false otherwise.
| Type | The type to check, without volatile |
|
extern |
A constant of std::nothrow_t.
| using std::nullptr_t |
The type of nullptr.
|
constexpr |
Tag constant for piecewise construction.
|
externconstexpr |
obtains the number of dimensions of an array type
| T | type to query |
If T is an array type, provides the member constant value equal to the number of dimensions of the array. For any other type, value is 0.
|
externconstexpr |
obtains the number of dimensions of an array type
| T | type to query |
If T is an array type, provides the member constant value equal to the number of dimensions of the array. For any other type, value is 0.
|
externconstexpr |
obtains the number of dimensions of an array type
| T | type to query |
| N | array bound |
If T is an array type, provides the member constant value equal to the number of dimensions of the array. For any other type, value is 0.
|
externconstexpr |
obtain the number of elements in a tuple-like type
| T | tuple like type |
1.13.2