 |
Arene Base
Fundamental Utilities For Safety Critical C++
|
|
Arene Base
Fundamental Utilities For Safety Critical C++
|
| using arene::base::combine_kinds_t |
Template alias to combine a list of quantity kinds.
| Kinds | the quantity kinds to combine |
| using arene::base::compare_three_way = three_way_compare_detail::compare_three_way |
Function object that does a three-way comparison between operands, equivalent to std::compare_three_way .
| using arene::base::conditional_apply_t = typename static_if<B>::template then_apply_else_apply<OnTrue, OnFalse, Args...> |
lazily apply one of two template aliases based on a boolean condition
| B | the boolean condition |
| OnTrue | template alias applied to Args when B is true |
| OnFalse | template alias applied to Args when B is false |
| Args | parameter pack forwarded to the selected template alias |
Only the selected branch's template is instantiated with Args. The other branch's template is never applied, avoiding unnecessary instantiations and potential ill-formed types.
Example:
| using arene::base::conditional_identity_t = T |
an identity alias intended for use as a no-op branch in conditional_apply_t
| T | the type to return as-is |
When used as the OnTrue or OnFalse template parameter of conditional_apply_t, it passes the argument through unchanged.
std::type_identity_t is not suitable here because it is defined in terms of a class template (std::type_identity<T>::type), making it non-transparent. It cannot be redefined as a simple alias without breaking its common use as a type deduction barrier. | using arene::base::conditional_t = typename static_if<B>::template then_else<T, F> |
lazily select between two types based on a boolean condition
| B | the boolean condition |
| T | the type selected when B is true |
| F | the type selected when B is false |
Unlike std::conditional_t, this does not eagerly instantiate both branches. Only the selected type is used; the other remains untouched.
std::conditional_t, backed by static_if for lazy evaluation. conditional class template is intentionally not provided, to avoid unecessary class template instantiations. If the type is necessary, use std::conditional. | using arene::base::constraints = typename constraints_impl::constraints<EnableIfs...>::type |
Helper used to express template constraints in a consistent way using std::enable_if_t.
Use with std::enable_if_t to group N short-circuited constraints without N top-level template parameters and without std::conjunction . This preserves error information while also minimizing extraneous template parameters. If we eventually move all users to C++20, we can remove this and use language-level concepts.
Usage Example:
constraints is an alias to std::nullptr_t for two reasons. 1) It is unlikely that someone invoking the function-template will accidentally pass an explicit "nullptr" as a template argument the place that the constraints appear in the template parameter list. 2) There is only one possible value for a std::nullptr_t argument, so the choice for default argument value being nullptr is not subjective.Users should prefer using constraints to form the template parameter kind as in the example, as opposed to using its result as a default argument for a class template parameter. This is so that constraints in overload sets do not conflict with each other as if redeclarations that differ only by default arguments.
| using arene::base::dextents = typename extents_detail::dextents_helper<IndexType, std::integral_constant<std::size_t, Rank>>::type |
Backport of std::dextents from C++23, a type representing the extents of a multidimensional array with all dynamic extents.
| IndexType | the index type |
| Rank | The number of dimensions of the array |
IndexType must be an integral type other than bool | using arene::base::f32_t = float |
An alias to float.
| using arene::base::f64_t = double |
An alias to double.
| using arene::base::function_arguments_t = typename function_traits<Fn>::argument_types |
Determines the argument types of a function.
| Fn | function type |
| using arene::base::function_return_t = typename function_traits<Fn>::return_type |
Determines the return and argument types of a function.
| Fn | function type |
| using arene::base::function_traits = typename function_traits_detail::function_traits_impl<Fn> |
Contains the return_type, argument_type, and cv_qualifier of the given function type.
| Fn | Function type to build traits from |
| using arene::base::give_cv_to_t |
Add the cv qualification from one type to another.
| From | type to copy cv-ref qualification from |
| To | type to copy cv-ref qualification to |
To before adding cv qualification. If replacement semantics are desired, apply std::remove_cvref_t to To. | using arene::base::give_cvref_to_t |
Add the cv-ref qualification from one type to another.
| From | type to copy cv-ref qualification from |
| To | type to copy cv-ref qualification to |
To before adding cv or ref qualification. If replacement semantics are desired, apply std::remove_cvref_t to To. | using arene::base::give_qualifiers_to |
For a type Source and type Target: if Source is const volatile results in Target const volatile otherwise if Source is volatile results in Target volatile otherwise if Source is const result in Target const otherwise results in Target.
| Source | The type providing the qualifiers |
| Target | The type to modify the qualifiers of |
| using arene::base::int16_t = ::std::int16_t |
A 16-bit signed integer type.
| using arene::base::int32_t = ::std::int32_t |
A 32-bit signed integer type.
| using arene::base::int64_t = ::std::int64_t |
A 64-bit signed integer type.
| using arene::base::int8_t = ::std::int8_t |
An 8-bit signed integer type.
| using arene::base::integer_sequence_cat = typename integer_sequence_ops_detail::integer_sequence_cat_impl<Sequences...>::type |
Produces a single std::integer_sequence which is the concatenation of multiple std::integer_sequence.
| Sequences | the sequence of std::integer_sequence to concatenate |
Sequences must be an instantiation of std::integer_sequence. Sequences, maintaining order of appearance. | using arene::base::integer_sequence_unique_elements |
Create a new integer sequence with the unique values from the provided integer sequence. The values in the resultant sequence are in the order of their first occurrence in the provided sequence.
| Sequence | the provided integer sequence |
Sequence must be an instantiation of std::integer_sequence | using arene::base::inverse_unit_scale_t = typename scaled_unit_detail::inverse_unit_scale_helper<Type>::type |
A type that represents the inverse of a scale factor.
| Type | the type to invert |
| using arene::base::invoke_result_t = typename invoke_result<Fn, Args...>::type |
The return type of a functor invoked with the specified arguments.
| Fn | The functor type. |
| Args | The functor parameter types. |
| using arene::base::is_implicitly_constructible |
Type trait to detect if a type is implicitly constructible from arguments of the specified types.
| T | The type to check if it can be implicitly constructed. |
| Args | The arguments to try to implicitly construct with. |
| using arene::base::is_inline_buffer_string = is_inline_string<Type> |
Trait to query if a type is an inline_string.
| Type | The type to check. |
Inherits from std::true_type if Type is an instantiation of inline_string, else std::false_type.
| using arene::base::is_integral_constant_like = std::integral_constant<bool, is_integral_constant_like_v<T>> |
Backport for the C++26 exposition-only integral-constant-like concept.
| T | The type to test |
The concept integral-constant-like<T> specifies that all of the following are true:
| using arene::base::is_nothrow_implicitly_constructible |
Type trait to detect if a type is nothrow implicitly constructible from arguments of the specified types.
| T | The type to check if it can be nothrow implicitly constructed. |
| Args | The arguments to try to nothrow implicitly construct with. |
| using arene::base::is_transparent_comparator_for = std::integral_constant<bool, is_transparent_comparator_for_v<C, T, U>> |
| using arene::base::is_transparent_three_way_comparator_for |
Trait to determine if a given type is a transparent comparator for a given set of operands.
| C | The type to test |
| T | The type of the left hand operand |
| U | The type of the right hand operand Value will be equivalent to is_transparent_three_way_comparator_v<C> && is_invocable_r_v<strong_ordering, C, T, U>. |
| using arene::base::kind_with_exponent_t |
Alias template for raising the specified quantity kind to the specified exponent.
| Kind | The quantity kind to raise to an exponent |
| Exponent | The exponent to raise it to |
| using arene::base::lock_guard = mutex_detail::selected_lock_guard<Mutex> |
A lock guard suitable for use with clang's Thread Safety Analysis. Equivalent to std::lock_guard.
If Thread Safety Analysis is not supported by the current compiler, or the current stdlib already has a TSA annotated std::lock_guard, then this is a simple alias to std::lock_guard. Otherwise it is a thin wrapper around std::lock_guard which annotates it as a scoped capability, but is otherwise identical to std::lock_guard.
ARENE_HAS_THREAD_SAFETY_ANALYSIS platform query. ARENE_STDLIB_LIBCXX platform query.| Mutex | the type of the mutex to guard. |
| using arene::base::make_index_sequence_between = make_integer_sequence_between<std::size_t, Begin, End> |
A helper alias template for make_integer_sequence_between<size_t, Begin, End>
| Begin | the starting value of the sequence |
| End | the ending value of the sequence (not included) |
End >= Begin | using arene::base::make_index_sequence_from = make_integer_sequence_from<std::size_t, Begin, Size> |
A helper alias template for make_integer_sequence_from<size_t, Begin, Size>
| Begin | the starting value of the sequence |
| Size | the size of the sequence |
size_t | using arene::base::make_index_sequence_repeat_n |
An std::index_sequence whose elements are Count copies of Value.
| Value | the value to repeat |
| Count | the number of copies to emit |
| using arene::base::make_integer_sequence_between = typename make_integer_sequence_detail::make_between_impl<Type, Begin, End>::type |
Create an integer_sequence between two values [Begin, End)
| Type | the integer type |
| Begin | the starting value of the sequence |
| End | the ending value of the sequence (not included) |
End >= Begin | using arene::base::make_integer_sequence_from = typename make_integer_sequence_detail::make_from_impl<Type, Begin, Size>::type |
Create an integer_sequence starting from a particular value.
| Type | the integer type |
| Begin | the starting value of the sequence |
| Size | the size of the sequence |
Type Size >= 0 A POD type with the maximum alignment constraint.
| using arene::base::member_function_arguments_t = function_arguments_t<typename member_pointer_traits<F>::pointee_type> |
Obtains the argument types of a member function pointer type.
| F | member function pointer type |
| using arene::base::member_function_return_t = function_return_t<typename member_pointer_traits<F>::pointee_type> |
Obtains the return type of a member function pointer type.
| F | member function pointer type |
| using arene::base::member_pointer_class_type |
A type alias to the class type for which the supplied parameter is a pointer-to-member of.
| PointerToMember | The type of the pointer-to-member for which to obtain the class of which it is a pointer to member of |
| using arene::base::member_pointer_traits = typename function_traits_detail::member_pointer_traits_impl<std::remove_cv_t<F>> |
Contains the class_type and pointee_type of the given member pointer.
| F | member pointer type |
| using arene::base::monostate_identity |
A metafunction that is an identity for all types except for void types.
In the case of a void type, this results in arene::base::monostate with the same cv-qualifiers.
| T | The parameter type. |
| using arene::base::mutex = mutex_detail::selected_mutex |
A mutex suitable for use with clang's Thread Safety Analysis. Equivalent to std::mutex.
If Thread Safety Analysis is not supported by the current compiler, or the current stdlib already has a TSA annotated std::mutex, then this is a simple alias to std::mutex. Otherwise it is a thin wrapper around std::mutex which annotates it as a capability, but is otherwise identical to std::mutex.
ARENE_HAS_THREAD_SAFETY_ANALYSIS platform query. ARENE_STDLIB_LIBCXX platform query. | using arene::base::noexcept_function_ref = function_ref<Signature, true> |
A convience alias for function_ref with IsNoexcept set true.
| Signature | The function signature being wrapped of the form Return-type (Args...) optional-const |
| using arene::base::noexcept_inline_function = inline_function<Signature, BufferSize, true> |
A function wrapper to a noexcept-qualified invocable akin to std::function that always stores the wrapped invocable internally.
| Signature | The signature of the function call operator. |
| BufferSize | The size of the internal buffer. It defaults to 4 times the size of a pointer. |
int (int,double) const ) then the function call operator for this class will also be const-qualified. If the signature is not const-qualified, then only non-const objects will be invocable. | using arene::base::non_null_ptr = non_null<T*> |
Alias for a non_null which holds a raw pointer.
| T | The type of the pointed to element |
| using arene::base::null_opt_t = nullopt_t |
alias to maintain backwards compatibility with older versions of Arene Base.
| using arene::base::nullptr_t = ::std::nullptr_t |
The type of nullptr.
The type of the difference between two pointers.
| using arene::base::quantity_kind |
ParentKind class for declaring a quantity kind with a parent quantity kind.
| Derived | the derived class which represents the quantity kind |
| ParentKindOrOriginOrUnit | optional; the type of the parent quantity kind for Derived, or the type of the quantity origin, or the type of the default unit |
| OriginOrUnit | optional; the type of the quantity origin, or the default unit. Must not be specified if ParentKindOrOriginOrUnit is a unit, and must not be an origin if ParentKindOrOriginOrUnit is an origin |
| Unit | the type of the default unit. Must not be specified if either of ParentKindOrOriginOrUnit or OriginOrUnit is a unit |
Derived must derive from quantity_kind<Derived, ParentKindOrUnit, Unit> | using arene::base::quantity_origin_t = typename Kind::origin |
Type trait to get the origin of a quantity; if none exists, then this will cause a compilation error.
| Kind | Quantity kind to check |
| using arene::base::remove_cv_t = typename std::remove_cv<T>::type |
Backport of std::remove_cv_t.
| T | The source type |
| using arene::base::remove_cvref_t = remove_cv_t<remove_reference_t<T>> |
Backport of std::remove_cvref_t.
| T | The source type |
| using arene::base::remove_reference_t = typename std::remove_reference<T>::type |
Backport of std::remove_reference_t.
| T | The source type |
| using arene::base::repeat_type_t = typename repeat_type<N, T, Arg>::type |
Repeat a template argument a specified number of times.
| N | The number of times to repeat. |
| T | The templated type. |
| Arg | The repeated argument. |
| using arene::base::scaled_unit = typename scaled_unit_detail::scaled_unit_helper<BaseUnit, Scale>::type |
Type alias for a quantity unit that is another unit scaled by some scale factor.
| BaseUnit | the underlying unit |
| Scale | the scale factor |
| using arene::base::selected_unit_for_t = typename selected_unit_for_detail::selected_unit_for_impl<std::remove_cv_t<Kind>>::type |
Type trait for determining the unit for a quantity kind. If there is a unit for a given kind, then it is a type alias for the unit type. Otherwise, it is undefined.
| Kind | the type to check |
| using arene::base::size_t = ::std::size_t |
The type of the size of an object.
| using arene::base::smallest_signed_integer_for |
Calculates the smallest unsigned integer type that can be used to hold values from MinValue up to and including MaxValue.
| MinValue | The minimum value to store |
| MaxValue | The maximum value to store, must be greater than or equal to MinValue |
| using arene::base::smallest_unsigned_integer_for |
Calculates the smallest unsigned integer type that can be used to hold values up to and including MaxValue.
| MaxValue | The maximum value to store |
| using arene::base::strong_ordering = strong_ordering_detail::strong_ordering |
The enumeration specifying the result of an ordering comparison.
| using arene::base::submdspan_subextents_type_t = typename submdspan_subextents_type<Extents, SliceSpecifiers...>::type |
determines the subextents type from an extents type and slice specifiers
| Extents | specialization of extents type |
| SliceSpecifiers | parameter pack specifying the subset of each rank in Extents |
| using arene::base::timed_mutex = mutex_detail::selected_timed_mutex |
A timed mutex suitable for use with clang's Thread Safety Analysis. Equivalent to std::timed_mutex.
If Thread Safety Analysis is not supported by the current compiler, or the current stdlib already has a TSA annotated std::timed_mutex, then this is a simple alias to std::timed_mutex. Otherwise it is a thin wrapper around std::timed_mutex which annotates it as a capability, but is otherwise identical to std::timed_mutex.
ARENE_HAS_THREAD_SAFETY_ANALYSIS platform query. ARENE_STDLIB_LIBCXX platform query. | using arene::base::type_identity_t = typename type_identity<T>::type |
Polyfill of std::type_identity_t added in C++20.
| T | The type to preserve |
| using arene::base::uint16_t = ::std::uint16_t |
A 16-bit unsigned integer type.
| using arene::base::uint32_t = ::std::uint32_t |
A 32-bit unsigned integer type.
| using arene::base::uint64_t = ::std::uint64_t |
A 64-bit unsigned integer type.
| using arene::base::uint8_t = ::std::uint8_t |
An 8-bit unsigned integer type.
An integer type big enough to hold a pointer.
| using arene::base::unit_kind_t = typename unit_kind_detail::unit_kind_helper<Unit>::type |
Alias template for the underlying quantity kind for a unit.
| Unit | The unit to get the quantity kind for |
| using arene::base::unwrap_ref_decay_t = unwrap_reference_t<std::decay_t<T>> |
Backport of std::unwrap_ref_decay_t from C++20.
| T | A type to decay and then unwrap a reference wrapper |
| using arene::base::unwrap_reference_t |
Backport of std::unwrap_reference_t from C++20.
| T | A type from which to remove a std::reference_wrapper |
| using arene::base::variant_alternative_t = typename variant_alternative<I, T>::type |
Helper type of variant_size variant_alternative.
| I | the index of the type |
| T | the variant type |
| using arene::base::void_t = void |
An alias for void that accepts any number of type parameters, used for substitution checks.
a backport of C++17's std::void_t
|
strong |
|
strong |
An enumeration used for the return value of fast_inequality_check functions to indicate if two values are definitely not equal, or may be equal or not. This is used in generic implementations of operator== and operator!= to avoid comparing for ordering when only equality is required.
|
strong |
|
strong |
The set of differences between two semantic_version s, encoded as a bitfield of [patch.minor.major].
sem_ver_diff from two semantic_version instances.
|
constexprnoexcept |
Calculate the absolute value of a number.
| Number | The type of the number. |
| value | The value to take the absolute value of. |
Number is an Integral type, value is not the smallest negative number the type can represent. value, which is equivalent to return value < 0 ? -value : value;.| Number | The type of the number. |
| value | The value to take the absolute value of. |
value is not the smallest negative number the type can represent. value, which is equivalent to return value < 0 ? -value : value;.abs with unsigned values. This overload for unsigned values does not prevent potential logic errors in expressions like: arene::base::abs(a - b), where unsigned wraparound can lead to unexpected behavior if a < b. Ensure that you understand the implications of using abs() with unsigned types and consider using arene::base::abs_diff(a, b) instead.| Number | The type of the number. |
| value | The value to take the absolute value of. |
value, which is equivalent to return value < 0 ? -value : value;.
|
constexprnoexcept |
Calculate the absolute difference between two numbers.
| Number | The type of the number. |
| first | The first value to take the absolute difference of |
| second | The second value to take the absolute difference of |
first and second
|
constexpr |
Align a value to the nearest multiple of alignment, rounding up.
| Alignment | The alignment to align to. Must be a positive power-of-two. |
| Integer | The type of integer to align. |
| value | The value to align. |
value if it was already a multiple of alignment , otherwise the closest multiple of alignment greather than value .
|
constexpr |
Align a value to the nearest multiple of alignment, rounding down.
| Alignment | The alignment to align to. Must be a positive power-of-two. |
| Integer | The type of the integer to align. |
| value | The value to align. |
value if it was already a multiple of alignment , otherwise the closest multiple of alignment less than value.
|
noexcept |
Calculate the amount by which ptr needs to be adjusted to have the specified Alignment.
| Alignment | The alignment to calculate the offset to. |
| ptr | The address to calculate the offset for. |
ptr address to obtain an address that is a multiple of Alignment. | arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | advance_detail::advance | , |
| advance | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | algorithm_detail::inner_product_detail::inner_product_fn | , |
| inner_product | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | algorithm_detail::inplace_merge_detail::inplace_merge_impl_fn | , |
| inplace_merge | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | algorithm_detail::iter_swap_detail::iter_swap_impl_fn | , |
| iter_swap | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | algorithm_detail::rotate_detail::rotate_impl_fn | , |
| rotate | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | algorithm_detail::sort_detail::sort_impl_fn | , |
| sort | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | algorithm_detail::stable_sort_detail::stable_sort_impl_fn | , |
| stable_sort | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | algorithm_detail::transform_reduce_detail::transform_reduce_fn | , |
| transform_reduce | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | all_of_detail::all_of_fn | , |
| all_of | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | any_of_detail::any_of_fn | , |
| any_of | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | apply_detail::do_apply | , |
| apply | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | bind_back_detail::bind_back_fn | , |
| bind_back | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | bind_front_detail::bind_front_fn | , |
| bind_front | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | construct_at_detail::do_construct_at | , |
| construct_at | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | destroy_at_detail::do_destroy_at | , |
| destroy_at | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | equal_detail::equal_fn | , |
| equal | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | extents_detail::make_extents_fn | , |
| make_extents | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | full_extent_t | , |
| full_extent | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | inline_string_detail::make_inline_string_impl_fn | , |
| make_inline_string | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | iota_detail::iota_fn | , |
| iota | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | lexicographical_compare_detail::lexicographical_compare_fn | , |
| lexicographical_compare | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | lexicographical_compare_detail::lexicographical_compare_three_way_fn | , |
| lexicographical_compare_three_way | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | make_mdspan_detail::make_mdspan_impl | , |
| make_mdspan | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | not_fn_detail::not_fn_impl | , |
| not_fn | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | safe_comparisons_detail::cmp_equal_fn | , |
| cmp_equal | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | safe_comparisons_detail::cmp_greater_equal_fn | , |
| cmp_greater_equal | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | safe_comparisons_detail::cmp_greater_fn | , |
| cmp_greater | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | safe_comparisons_detail::cmp_less_equal_fn | , |
| cmp_less_equal | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | safe_comparisons_detail::cmp_less_fn | , |
| cmp_less | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | safe_comparisons_detail::cmp_not_equal_fn | , |
| cmp_not_equal | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | submdspan_canonicalize_slices_detail::submdspan_canonicalize_slices_fn | , |
| submdspan_canonicalize_slices | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | submdspan_detail::submdspan_fn | , |
| submdspan | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | submdspan_extents_detail::submdspan_extents_fn | , |
| submdspan_extents | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | transform_detail::transform_fn | , |
| transform | ) |
| arene::base::ARENE_CPP14_INLINE_VARIABLE | ( | tuple_cat_detail::tuple_cat_fn | , |
| tuple_cat | ) |
| arene::base::ARENE_IGNORE_ALL | ( | "-Wdeprecated-declarations" | , |
| "We still want to use the deprecated class in this other deprecated class" | ) |
| arene::base::ARENE_IGNORE_ALL | ( | "-Wfloat-equal" | , |
| "Checking for existence of | comparison, | ||
| not using it" | ) |
| arene::base::ARENE_IGNORE_ALL | ( | "-Wfloat-equal" | , |
| "Equality is used to check the properties of a single | value, | ||
| not compare two values" | ) |
| arene::base::ARENE_IGNORE_END | ( | ) |
Helper class that can be inherited from by a class to define the <, >, <=, >=, ==, and != comparison operators in terms of a three_way_compare function provided by the Derived class.
Requires that the derived class provides a static member function three_way_compare that accepts two const Derived& and returns a strong_ordering value indicating whether the first is less than, equal to or greater than the second. This three_way_compare functions must not throw exceptions.
| Derived | The type of the derived class. The comparison operators provided take parameters of this type. |
For example:
| arene::base::ARENE_IGNORE_END | ( | ) |
| arene::base::ARENE_IGNORE_START | ( | ) |
Helper class that can be inherited from by a class to define the <, >, <= and >= comparison operators in terms of a three_way_compare function provided by the Derived class, and define the != operator in terms of the == operator.
Requires that the derived class provides a static member function three_way_compare that accepts a const Derived& and a const Other&, and returns a strong_ordering value indicating whether the first is less than, equal to or greater than the second. This three_way_compare functions must not throw exceptions.
Requires that operator==(const Derived&, const Other&) is defined and does not throw exceptions
| Derived | The type of the derived class. The comparison operators provided take parameters of this type. |
| Other | The type of the other object to compare. The comparison operators provided take parameters of this type. |
For example:
| arene::base::ARENE_IGNORE_START | ( | ) |
|
noexcept |
Obtain a const view to the object representation of the elements of the span spn.
| spn | The span of elements to inspect. |
span<const Byte, Size> of the object representations of the elements of spn.
|
constexprnoexcept |
Obtain an lvalue-reference to a const object of type T.
Use this as an easier way to obtain a const-reference, deducing the appropriate type compared to writing explicit const_cast expressions.
std::as_const() function.| T | The type of the object to add const to |
| obj | The object to obtain a const-reference to. |
|
constexprdelete |
Prevent passing rvalue arguments to as_const().
| T | The type of the object to add const to |
| rvalue | The rvalue object |
|
noexcept |
Obtain a non-const view to the object representation of the elements of the span spn.
| spn | The span of elements to inspect. |
span<byte, Size> of the object representations of the elements of spn.
|
constexprnoexcept |
Given a sequence of invocables, creates a type which is the sum-type of all the input invocables.
Typically, bind_overloads is used to produce a variant-visitor inline from a sequence of lambdas, like so:
| OverloadsT | The types of the invocables to combine. |
| overloads | The invocables to combine. They will be perfect-forwarded into the resulting object. |
|
constexpr |
Construct a bit-mask with the lowest one_bits bits set to 1 and the rest of the bits set to 0.
For example:
| Integer | The mask type to return. |
| one_bits | The number of bits to set to 1 in the mask. Must be in range [0, Integer-bit-width]. |
Integer with the lowest one_bits bits set to 1 and the rest of the bits set to 0.
|
constexprnoexcept |
Swap the order of bytes in a given value.
| value | The value to byte-swap. |
value but with the byte-order reversed.
|
constexprnoexcept |
Swap the order of bytes in a given value.
| value | The value to byte-swap. |
value but with the byte-order reversed.
|
constexprnoexcept |
Swap the order of bytes in a given value.
| value | The value to byte-swap. |
value but with the byte-order reversed.
|
constexprnoexcept |
Swap the order of bytes in a given value.
| value | The value to byte-swap. |
value but with the byte-order reversed.
|
constexprnoexcept |
Swap the order of bytes in a given value.
| value | The value to byte-swap. |
value but with the byte-order reversed.
|
constexprnoexcept |
Swap the order of bytes in a given value.
| value | The value to byte-swap. |
value but with the byte-order reversed.
|
constexprnoexcept |
Swap the order of bytes in a given value.
| value | The value to byte-swap. |
value but with the byte-order reversed.
|
constexprnoexcept |
Swap the order of bytes in a given value.
| value | The value to byte-swap. |
value but with the byte-order reversed.
|
noexcept |
Check that the first value is ordered strictly before the second.
|
constexprnoexcept |
Clamp the supplied value between two bounds using std::less for ordering.
| T | The type of the value and both bounds |
| val | The value to clamp between the two bounds |
| low | The lower bound |
| high | The upper bound |
low must be less than or equal to high val if it's between the bounds, or to the nearest bound if val is outside the bounds
|
constexprnoexcept |
Clamp the supplied value between two bounds using the supplied comparator for ordering.
| T | The type of the value and both bounds |
| Compare | The type of a comparator which models a strict weak ordering, similar to std::less |
| val | The value to clamp between the two bounds |
| low | The lower bound |
| high | The upper bound |
| comp | The comparator instance to use |
low must be less than or equal to high ; that is, comp(high,low) must be false val if it's between the bounds, or to the nearest bound if val is outside the bounds
|
inlineconstexprnoexcept |
Computes the set of the potential changes between two different semantic versions.
| left | The first version value. |
| right | The second version value. |
contains_major_change(left, right) == truecontains_minor_change(left, right) == truecontains_patch_change(left, right) == true | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| ConstructFromOversizedInitializerList | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
inline_deque crashes when copy constructed from an initializer list that's too large to fit in the capacity | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| CopyConstructFromBackwardRange | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
inline_deque crashes when copy constructed from a random-access range in the wrong order | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| CopyConstructFromOversizedRange | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
inline_deque crashes when copy constructed from a range that's too large to fit within the capacity | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| NonWrappingInsertOneWhenFull | , | ||
| !TypeParam::wrapping_allowed &&std::is_move_constructible< typename TypeParam::value_type >::value &&std::is_move_assignable< typename TypeParam::value_type >::value | ) |
insert when a non-wrapping deque is full terminates the application | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| PopBackWhenEmpty | , | ||
| is_double_ended< TypeParam > | ) |
inline_deque is empty, pop_back terminates the application with a precondition violation | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| PushFrontMoreThanCapacity | , | ||
| is_double_ended< TypeParam > | ) |
inline_deque's capacity terminates the application with a precondition violation or wraps, depending on its parameters | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| BasicFunctionFromBack | , | ||
| TypeParam::capacity >= | 2 ) |
inline_deque functionality, inserting elements via push_back observing them with front, verifying that it doesn't remove elements, removing with pop_front, and checking the correct dequeing order (namely, FIFO) is preserved with the operations | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| BasicFunctionFromFront | , | ||
| is_double_ended< TypeParam > &&TypeParam::capacity >= | 2 ) |
inline_deque functionality, inserting elements via push_front observing them with back, verifying that it doesn't remove elements, removing with pop_back, and checking the correct dequeing order (namely, FIFO) is preserved with the operations | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CanConstructAtCompileTime | , | ||
| InlineDequeTest< TypeParam >::constexpr_compatible | ) |
inline_deque can be used at compile-time, asserting properties statically | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CanCopyAssign | , | ||
| std::is_copy_assignable< TypeParam >::value | ) |
inline_deque copy-assignment works as expected | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CanCopyConstruct | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
inline_deque copy-construction works as expected | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CanCopyTryConstruct | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
inline_deque copy-construction works as expected when invoked via try_construct | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CanObserveAndModifyFromBack | , | ||
| TypeParam::capacity >= | 2 ) |
inline_deque's front can also be used to modify the least-recently inserted element inplace | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CanObserveAndModifyFromFront | , | ||
| is_double_ended< TypeParam > &&TypeParam::capacity >= | 2 ) |
inline_deque's back can also be used to modify the least-recently inserted element inplace | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| ConstructFromEmptyList | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
inline_deque can be constructed from an empty initializer list | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| ConstructFromInitializerList | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
inline_deque can be constructed from an initializer list of T | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CopyAssignFromPartiallyFull | , | ||
| std::is_copy_assignable< TypeParam >::value | ) |
| arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CopyAssignIntoPartiallyFull | , | ||
| std::is_copy_assignable< TypeParam >::value | ) |
| arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CopyConstructFromRange | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
inline_deque can be constructed from a range of T using iterators | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CopyInsertOne | , | ||
| !TypeParam::wrapping_allowed &&std::is_copy_constructible< typename TypeParam::value_type >::value &&std::is_copy_assignable< typename TypeParam::value_type >::value | ) |
insert inserts a copy of the value at the requested position | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| CopyInsertOneAtEnd | , | ||
| !TypeParam::wrapping_allowed &&std::is_copy_constructible< typename TypeParam::value_type >::value &&std::is_copy_assignable< typename TypeParam::value_type >::value | ) |
insert can insert a value at the end | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| EmplaceFrontReturnsReference | , | ||
| is_double_ended< TypeParam > | ) |
inline_deque returns a reference to the emplaced element | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| FrontPushedElementIsCorrect | , | ||
| is_double_ended< TypeParam > | ) |
inline_deque with plenty of capacity, an element can be inserted via push_front and then inspected | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| GoCircularFromFront | , | ||
| is_double_ended< TypeParam > | ) |
inline_deque has circular or ring-buffer behavior, such that when previously inserted elements via push_front are removed via pop_back, then space in the fixed-capacity storage of the deque is made available for new elements to be inserted | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| InsertConstraints | , | ||
| !TypeParam::wrapping_allowed | ) |
insert functions are correct | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| IteratorsNotInvalidatedByPopBack | , | ||
| is_double_ended< TypeParam > &&TypeParam::capacity() >= | 3U ) |
pop_back() only invalidates iterators and references to the last element and end() | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| IteratorsNotInvalidatedByPopFront | , | ||
| TypeParam::capacity() >= | 2U ) |
pop_front() only invalidates iterators and references to the first element | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| MoveInsertOne | , | ||
| !TypeParam::wrapping_allowed &&std::is_move_constructible< typename TypeParam::value_type >::value &&std::is_move_assignable< typename TypeParam::value_type >::value | ) |
insert inserts the value at the requested position | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| MoveInsertOneAtEnd | , | ||
| !TypeParam::wrapping_allowed &&std::is_move_constructible< typename TypeParam::value_type >::value &&std::is_move_assignable< typename TypeParam::value_type >::value | ) |
insert can insert a value at the end | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| PushBackCopiesLvalues | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
inline_deque copies it | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| PushFrontCopiesLvalues | , | ||
| is_double_ended< TypeParam > &&std::is_copy_constructible< TypeParam >::value | ) |
inline_deque copies it | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| PushFrontDetailCoverage | , | ||
| !is_double_ended< TypeParam > | ) |
| arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| PushFrontOneElement | , | ||
| is_double_ended< TypeParam > | ) |
inline_deque with plenty of capacity, an element can be inserted via push_front, which causes a size increase | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| PushFrontWithinCapacity | , | ||
| is_double_ended< TypeParam > | ) |
inline_deque, elements can be inserted via push_front within its capacity, making the size be equal to capacity | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| SelfCopyAssign | , | ||
| std::is_copy_assignable< TypeParam >::value | ) |
inline_deque self copy-assignment does nothing | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| TryConstructFromOversizedInitializerList | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
try_construct returns empty when constructing from an initializer list that's too large for the capacity | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| TryCopyConstructFromBackwardRange | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
try_construct returns empty when copy constructing from a random-access range in the wrong order | arene::base::CONDITIONAL_TYPED_TEST_P | ( | InlineDequeTest | , |
| TryCopyConstructFromOversizedRange | , | ||
| std::is_copy_constructible< TypeParam >::value | ) |
try_construct returns empty when copy constructing from a range that's too large to fit within the capacity
|
inlineconstexprnoexcept |
Consume a list of values and discard them. Must be called with an extra pair of braces around the expressions to be consumed: consume_values({e1,e2,...}). The use of std::initializer_list ensures the expressions to be consumed are evaluated in left-to-right sequential order.
void type. void_ can be used as the return type if it would otherwise be void
|
inlineconstexprnoexcept |
Predicate to test if a sem_ver_diff contains a major change.
| diff | The computed difference between two versions |
|
inlineconstexprnoexcept |
Compares ONLY the major part of two semantic versions, to see if there's a major change between the two.
| left | The first version value. |
| right | The second version value. |
true if there is a major change, otherwise false
|
inlineconstexprnoexcept |
Predicate to test if a sem_ver_diff contains a minor change.
| diff | The computed difference between two versions |
|
inlineconstexprnoexcept |
Compares ONLY the minor part of two semantic versions, to see if there's a minor change between the two.
| left | The first version value. |
| right | The second version value. |
true if there is a minor change, otherwise false
|
inlineconstexprnoexcept |
Predicate to test if a sem_ver_diff contains a patch change.
| diff | The computed difference between two versions |
|
inlineconstexprnoexcept |
Compares ONLY the patch part of two semantic versions, to see if there's a patch change between the two.
| left | The first version value. |
| right | The second version value. |
true if there is a patch change, otherwise false
|
constexprnoexcept |
Copies the elements in the range, defined by [first, last), to another range beginning at output.
| InputIterator | The type of the Source iterator |
| OutputIterator | The type of the Destination iterator |
| first | Start of the range of elements to copy from |
| last | End (non-inclusive) of the range of elements to copy from |
| output | Start of the range of elements to copy into |
|
constexprnoexcept |
Copies the elements in the range, defined by [first, last), to another range beginning at output. Only copies the elements for which the predicate pred returns true. The relative order of the elements that are copied is preserved.
| InputIterator | The type of the Source iterator |
| OutputIterator | The type of the Destination iterator |
| Predicate | Function to test whether a value might be copied |
| first | Start of the range of elements to copy from |
| last | End (non-inclusive) of the range of elements to copy from |
| output | Start of the range of elements to copy into |
| pred | Unary predicate which returns true for the required elements |
|
constexprnoexcept |
Return a number with the magnitude of the first operand and the sign of the second.
| magnitude | The operand to take the magnitude from |
| sign | The operand to take the sign from |
magnitude and the same sign as sign
|
constexprnoexcept |
Return a number with the magnitude of the first operand and the sign of the second.
| magnitude | The operand to take the magnitude from |
| sign | The operand to take the sign from |
magnitude and the same sign as sign
|
constexprnoexcept |
Find the number of elements between first and last.
| Iterator | The type of iterator to compute the distance between |
| first | The iterator to start the distance computation from |
| last | The iterator end the distance computation at |
first to last. For iterators satisfying random_access_iterator, this value can be negative if first is reachable from last. last must be reachable from first, or else the behavior is undefined.
|
constexprnoexcept |
Convenience function to construct a result<Value,ErrorType> containing the ErrorType from any reference.
Example Usage:
| ErrorType | the error_type of the produced result. |
| error | error to instantiate the result with. |
result<Value,ErrorType> .
|
constexprnoexcept |
Visit the contained value or error with two independent functors.
| ResultType | The type of the result object to visit. |
| OnValue | The type of the invocable to invoke if the result holds a value . Must satisfy is_invocable with the result of self.value() , and must have the same return type as OnValue . |
| OnError | The type of the invocable to invoke if the result holds an error. Must satisfy is_invocable with the result of self.error() , and must have the same return type as OnValue . |
| self | The result object |
| on_expected | The invocable to invoke if self holds a value |
| on_unexpected | The invocable to invoke if self holds an error |
Example Usage:
|
constexprnoexcept |
Assigns all elements in a sequence to a given value.
| Itr | The type of the iterator for the sequence. Its reference must be std::assignable from T |
| Sent | The type of the sentinel to mark the end of the sequence. It must be inequality comparable with Itr |
| T | The type of the value to fill the sequence with. |
| first | Iterator to the first position in the sequence to fill. |
| last | Sentinel to mark the end of the sequence to fill. |
| value | The value to fill the sequence with. |
value first must eventually produce an iterator which compares equal to last , else behavior is undefined.Performs exactly std::distance(first,last) assignments of value . Backport of the constexpr std::fill from C++20 .
|
constexprnoexcept |
Constexpr-compatible implementation of std::find.
| Iterator | The type of the iterators |
| Value | The type of the value being searched for |
| first | The iterator for the start of the range |
| last | The iterator for the end of the range |
| value_to_find | The value to search for |
*it==value, or last if there is no such iterator
|
constexprnoexcept |
Returns an iterator to the first element in the range [first, last) that satisfies equality criteria: an element for which predicate pred returns true.
| Iterator | The type of the Iterator to conduct the search |
| Value | Value to find |
| Predicate | Condition predicate to find a value |
| first | Start of the range to find the value |
| last | End (exclusive) of the range to find the value |
| pred | Unary predicate which returns true for the elements to find |
|
constexpr |
Perform an operation on each element of a "tuple-ish" type, which includes std::tuple, std::pair, std::array, or arene::base::array.
| Tuple | type implementing the tuple protocol. |
| Op | The type of operation to perform on each tuple element. |
| tuple | The tuple-ish to iterate over. |
| operation | The operation to perform on each element. |
std::tuple_size std::tuple_element I, which is specified as: ** std::forward<Tuple>(tuple).get<I>() if valid ** otherwise, get<I>(std::forward<Tuple>(tuple)) if valid, where get is looked up by ADL only Note that the tuple-like concept defines types that satisfy the tuple protocol but are restricted to a list of types defined in the std namespace (std::array, std::pair, std::tuple in C++14). The term tuple-ish is used to define types that satisfy the tuple protocol without the restriction that the type is define in the std namespace – which includes user-defined types.
|
constexpr |
Perform an operation on each element of a "tuple-ish" type, which includes std::tuple, std::pair, std::array, or arene::base::array.
| Tuple | type implementing the tuple protocol. |
| Op | The type of operation to perform on each tuple element, which accepts the index as the first parameter of type std::size_t or std::integral_constant<std::size_t, N>. |
| tuple | The tuple-ish to iterate over. |
| operation | The operation to perform on each element, which should accept a std::size_t or std::integral_constant<std::size_t, N> as the first argument for the element's index. |
std::tuple_size std::tuple_element I, which is specified as: ** std::forward<Tuple>(tuple).get<I>() if valid ** otherwise, get<I>(std::forward<Tuple>(tuple)) if valid, where get is looked up by ADL only Note that the tuple-like concept defines types that satisfy the tuple protocol but are restricted to a list of types defined in the std namespace (std::array, std::pair, std::tuple in C++14). The term tuple-ish is used to define types that satisfy the tuple protocol without the restriction that the type is defined in the std namespace – which includes user-defined types.
|
inlineconstexprnoexcept |
Convert a strong_ordering into an integer three-way-comparison result.
| ordering | The ordering to convert. |
-1 if ordering is strong_ordering::less, 0 if ordering is strong_ordering::equal, and 1 if ordering is strong_ordering::greater.
|
constexprnoexcept |
Calculates the Greatest Common Divisor (GCD) of two Integral values.
| Integral | The type of the values |
| lhs | First value |
| rhs | Second value |
lhs and rhs . If either lhs or rhs is 0 , then the absolute value of the non-zero operand is returned. If both are 0 , then returns 0 .
|
constexprnoexcept |
Get a reference to the element at the specified index in the array.
| I | The index of the element to retrieve. Must satisfy I<N . |
| T | The type of the array elements |
| N | The number of array elements |
| arr | The array to retrieve the element from |
std::move(arr[I]) .
|
constexprnoexcept |
Get a reference to the element at the specified index in the array.
| I | The index of the element to retrieve. Must satisfy I<N . |
| T | The type of the array elements |
| N | The number of array elements |
| arr | The array to retrieve the element from |
arr[I] .
|
constexprnoexcept |
Get a reference to the element at the specified index in the array.
| I | The index of the element to retrieve. Must satisfy I<N . |
| T | The type of the array elements |
| N | The number of array elements |
| arr | The array to retrieve the element from |
std::move(arr[I]) .
|
constexprnoexcept |
Get a reference to the element at the specified index in the array.
| I | The index of the element to retrieve. Must satisfy I<N . |
| T | The type of the array elements |
| N | The number of array elements |
| arr | The array to retrieve the element from |
arr[I] .
|
inlineconstexprnoexcept |
Get value held by a variant by type.
Get value held by a variant by index.
| T | the alternative type to get |
| var | variant to get from |
| bad_variant_access | if ARENE_IS_ON(ARENE_EXCEPTIONS_ENABLED) and if the type of the object currently held by the variant does not match the type requested. |
ARENE_IS_OFF(ARENE_EXCEPTIONS_ENABLED) the type of the object currently held by the variant must match the type requested else ARENE_PRECONDITION violation. | Index | the index into Ts of the alternative to get |
| var | variant to get from |
| bad_variant_access | if ARENE_IS_ON(ARENE_EXCEPTIONS_ENABLED) and if the type index of the object currently held by the variant does not match the index requested. |
ARENE_IS_OFF(ARENE_EXCEPTIONS_ENABLED) the index type of the object currently held by the variant must match the type requested else ARENE_PRECONDITION violation.
|
inlineconstexprnoexcept |
Get value held by a variant by type.
Get value held by a variant by index.
| T | the alternative type to get |
| var | variant to get from |
| bad_variant_access | if ARENE_IS_ON(ARENE_EXCEPTIONS_ENABLED) and if the type of the object currently held by the variant does not match the type requested. |
ARENE_IS_OFF(ARENE_EXCEPTIONS_ENABLED) the type of the object currently held by the variant must match the type requested else ARENE_PRECONDITION violation. | Index | the index into Ts of the alternative to get |
| var | variant to get from |
| bad_variant_access | if ARENE_IS_ON(ARENE_EXCEPTIONS_ENABLED) and if the type index of the object currently held by the variant does not match the index requested. |
ARENE_IS_OFF(ARENE_EXCEPTIONS_ENABLED) the type index of the object currently held by the variant must match the type requested else ARENE_PRECONDITION violation.
|
inlineconstexprnoexcept |
Get value held by a variant by type.
Get value held by a variant by index.
| T | the alternative type to get |
| var | variant to get from |
| bad_variant_access | if ARENE_IS_ON(ARENE_EXCEPTIONS_ENABLED) and if the type of the object currently held by the variant does not match the type requested. |
ARENE_IS_OFF(ARENE_EXCEPTIONS_ENABLED) the type of the object currently held by the variant must match the type requested else ARENE_PRECONDITION violation. | Index | the index into Ts of the alternative to get |
| var | variant to get from |
| bad_variant_access | if ARENE_IS_ON(ARENE_EXCEPTIONS_ENABLED) and if the type index of the object currently held by the variant does not match the index requested. |
ARENE_IS_OFF(ARENE_EXCEPTIONS_ENABLED) the type index of the object currently held by the variant must match the type requested else ARENE_PRECONDITION violation.
|
inlineconstexprnoexcept |
Get value held by a variant by type.
Get value held by a variant by index.
| T | the alternative type to get |
| var | variant to get from |
| bad_variant_access | if ARENE_IS_ON(ARENE_EXCEPTIONS_ENABLED) and if the type of the object currently held by the variant does not match the type requested. |
ARENE_IS_OFF(ARENE_EXCEPTIONS_ENABLED) the type of the object currently held by the variant must match the type requested else ARENE_PRECONDITION violation. | Index | the index into Ts of the alternative to get |
| var | variant to get from |
| bad_variant_access | if ARENE_IS_ON(ARENE_EXCEPTIONS_ENABLED) and if the type index of the object currently held by the variant does not match the index requested. |
ARENE_IS_OFF(ARENE_EXCEPTIONS_ENABLED) the type index of the object currently held by the variant must match the type requested else ARENE_PRECONDITION violation.
|
inlineconstexprnoexcept |
Attempt to get a pointer to the object held by the variant by index.
Attempt to get a pointer to the object held by the variant by type.
| I | Index of the type in Ts to get |
| Ts | the types that the variant can hold |
| ptr | A pointer to the variant to access |
nullptr .| T | Type in Ts to get |
| Ts | the types that the variant can hold |
| ptr | A pointer to the variant to access |
nullptr .
|
inlineconstexprnoexcept |
Attempt to get a pointer to the object held by the variant by index.
Attempt to get a pointer to the object held by the variant by type.
| I | Index of the type in Ts to get |
| Ts | the types that the variant can hold |
| ptr | A pointer to the variant to access |
nullptr .| T | Type in Ts to get |
| Ts | the types that the variant can hold |
| ptr | A pointer to the variant to access |
nullptr .
|
constexprnoexcept |
Check if the variant holds a value of a given alternative type.
| T | the alternative type to check |
| Ts | the types that the variant can hold |
| var | the variant to check |
T does not appear exactly once in Ts .
|
constexprnoexcept |
Implementation of std::invoke from C++23: invokes the specified callable with the specified arguments.
| F | The type of the callable to invoke |
| Args | The types of the arguments |
| func | The callable to invoke |
| args | The arguments with which to invoke the callable |
F cannot be invoked with the specified Args
|
constexpr |
Check if an address is a multiple of the specified alignment.
| Alignment | The power-of-2 alignment to check for. |
| pointer | The pointer to check the address of. |
true if the pointer is aligned to a multiple of Alignment , otherwise false.
|
constexpr |
Check if an integer is a multiple of the specified power-of-two alignment.
| Alignment | The alignment to check against. Must be a positive power-of-two. |
| Integer | An integral type. |
| value | The value to check. |
true if value is a multiple of alignment.
|
inlineconstexprnoexcept |
Predicate to test if a sem_ver_diff represents a change of at least one major version.
| diff | The computed difference between two versions. |
|
inlineconstexprnoexcept |
Binary predicate to test if two semantic_versions differ by major versions.
| left | The left hand operand. |
| right | The right hand operand. |
major() is different between left and right .
|
inlineconstexprnoexcept |
Predicate to test if a sem_ver_diff represents a change of minor versions, ignoring patch versions.
| diff | The computed difference between two versions. |
|
inlineconstexprnoexcept |
Binary predicate to test if two semantic_versions differ by minor versions, ignoring patch versions.
| left | The left hand operand. |
| right | The right hand operand. |
|
inlineconstexprnoexcept |
Predicate to test if a sem_ver_diff represents a change of exclusively patch versions.
| diff | The computed difference between two versions. |
|
inlineconstexprnoexcept |
Binary predicate to test if two semantic_versions differ by exclusively patch versions.
| left | The left hand operand. |
| right | The right hand operand. |
|
constexprnoexcept |
Query to determine if the caller may be in a constant-evaluated-context.
This trait can be used to provide both constexpr and non-constexpr specializations of an implementation when there is a performance optimization that can only be performed in non-contexpr contexts.
std::is_constant_evaluated . Therefor on compilers lacking these intrinsics, it is not possible to determine if the current context is constant-evaluated. As such, the name has been changed to reflex the loosened semantics; while is_constant_evaluated returns true IFF the current context is a constant evaluated context, is_possible_constant_evaluated returns fase IFF the current context is not a constant evaluated context. Relaxing this constraint allows code to be written in pre-C++20 contexts to perform this query, and if the compiler version supports it, benefit, while always safely falling back to the constexpr compatible implementation when compiled with compilers which do not support the intrinsic.
|
constexprnoexcept |
Check if an integer is a positive power-of-two.
| Integer | An integral type. |
| value | The value to test for a power-of-two. |
true if the value is a positive power of two, false otherwise. The unsigned type corresponding to the specific integer type
|
inlineconstexprnoexcept |
Check if a string is valid UTF-8.
This rejects any incomplete encoding sequences, any overlong encodings (e.g. 7 bit encoded in 4 bytes), any encodings of UTF-16 surrogate pair code points, and any encoding that would decode to a codepoint beyond the max Unicode codepoint of 0X10FFFF.
| str | The string to check. |
|
constexprnoexcept |
Check whether or not the argument is finite, i.e. not infinity or NaN.
| num | The number to check |
true if num has a finite value, otherwise false
|
constexprnoexcept |
Check whether or not the argument is finite, i.e. not infinity or NaN.
| num | The number to check |
true if num has a finite value, otherwise false
|
constexprnoexcept |
Check whether or not the argument has a (positive or negative) infinite value.
| num | The number to check |
true if num has an infinite value, otherwise false
|
constexprnoexcept |
Check whether or not the argument has a (positive or negative) infinite value.
| num | The number to check |
true if num has an infinite value, otherwise false
|
constexprnoexcept |
Check whether or not the argument has a NaN value.
| num | The number to check |
true if num has a NaN value, otherwise false
|
constexprnoexcept |
Check whether or not the argument has a NaN value.
| num | The number to check |
true if num has a NaN value, otherwise false
|
constexprnoexcept |
Check whether or not the argument is normal, i.e. not infinity, NaN, subnormal, or zero.
| num | The number to check |
true if num has a normal value, otherwise false
|
constexprnoexcept |
Check whether or not the argument is normal, i.e. not infinity, NaN, subnormal, or zero.
| num | The number to check |
true if num has a normal value, otherwise false
|
constexprnoexcept |
Calculates the Least Common Multiple (LCM) of two integral values.
| Integral | The type of the values |
| lhs | First value |
| rhs | Second value |
lhs and rhs. If either lhs or rhs is 0, then returns 0. The result is always non-negative.The LCM is the smallest positive integer that is divisible by both input values. It is calculated using the mathematical identity: lcm(a,b) = abs(a*b) / gcd(a,b).
|
inlineconstexprnoexcept |
Computes the integer base-2 log of a value.
| value | The value to compute the base-2 log of. |
x , for which 2^x<=value . value must be greater than zero.
|
constexpr |
Create a copy of the string view with leading whitespace removed.
| MaxLength | The size of the inline string |
| str | The string to be trimmed |
arene::base::whitespace_chars . An empty or all whitespace string will result in an empty return string.
|
constexpr |
Create a copy of the string view with leading whitespace removed.
| str | The string to be trimmed |
arene::base::whitespace_chars . An empty or all whitespace string will result in an empty return string.
|
constexprnoexcept |
|
constexprdelete |
Deleted overload for not constructing a non-null pointer from a null pointer.
| ptr | The null pointer |
|
constexprnoexcept |
non_owning_ptr factory to allow template deduction.
| T | The raw pointer type to construct the non_owning_ptr from |
| ptr | The pointer to construct the non_owning_ptr from. |
non_owning_ptr<std::remove_pointer_t<T>>{ptr}.
|
constexprnoexcept |
Return the sequence of 2^N for each N in the half-open range [Begin,End)
std::index_sequence holding the values
|
constexprnoexcept |
Factory function for creating a reverse_iterator with deduced template arguments pre C++17.
| Itr | The type of the wrapped_iterator to wrap. Must satisfy is_bidirectional_iterator_v . |
| iter | The iterator to construct from. |
reverse_iterator<Itr>{std::forward<Itr>(iter)} .
|
inlineconstexprnoexcept |
Convert an integer three-way-comparison result into a strong_ordering.
| three_way_result | The result to convert. |
strong_ordering::less if three_way_result is less than zero, strong_ordering::equal if three_way_result is equal to zero, and strong_ordering::greater if three_way_result is greater than zero.
|
constexprnoexcept |
Combine an iterator and sentinel into a range type that can be used with range-based for loops.
| Iterator | The type of the position iterator for the range |
| Sentinel | The type of the sentinel for the range |
| iterator | The iterator |
| sentinel | The sentinel |
|
constexprnoexcept |
Moves the elements in the range [first, last), to another range beginning at output, starting from first and proceeding to last - 1. After this operation the elements in the moved-from range will still contain valid values of the appropriate type, but not necessarily the same values as before the move.
| InIterator | The type of the Iterator for the range to take items from |
| OutIterator | The type of the Iterator for the range to put items into |
| first | Start of the range to take items from |
| last | End (exclusive) of the range to take items from |
| output | Start of the range to put items into |
|
constexprnoexcept |
Moves the elements from the range [first, last), to another range ending at result. The elements are moved in reverse order (the last element is moved first), but their relative order is preserved.
| InIterator | The type of the Iterator for the range to take items from |
| OutIterator | The type of the Iterator for the range to put items into |
| first | Start of the range to take items from |
| last | End (exclusive) of the range to take items from |
| result | Start of the range to put items into |
|
constexprnoexcept |
Produces the Nth successor (or predecessor if steps is negative) of an iterator.
| Iterator | The iterator to advance. Does not participate in overload resolution unless Iterator is at least an input iterator. |
| itr | The iterator to advance |
| steps | The number of steps to advance the iterator by |
itr steps times results in attempting to produce an invalid iterator such as past-the-end or before-the-begin, behavior is undefined. Iterator is an input iterator, steps is not negative, else ARENE_PRECONDITION violation. itr steps times.
|
noexcept |
Declarative helper for constructing scope_guard instances.
A simple factory function for scope_guard with a declarative name that makes its purpose clear. Example usage:
| CallableType | a callable with signature void(void) noexcept . Must be move-copyable and decay constructible. |
| func | The callable to invoke upon destruction of the returned scope_guard object. |
func through forwarding. Bit-wise and of the byte representations.
| lhs | The first value |
| rhs | The second value |
lhs and rhs Modify lhs by bit-wise and'ing it with the bits of rhs.
| lhs | The value to modify |
| rhs | The second value |
lhs
|
constexprnoexcept |
Left-shift the bits of val by shift.
| IntegerType | The type of integer to shift by |
| val | The byte to shift |
| shift | The number of bits to shift by |
val left by shift bits shift < CHAR_BIT, otherwise ARENE_PRECONDITION violation
|
constexprnoexcept |
Modify val by shifting its bits left by shift.
| val | The value to shift |
| shift | The number of bits to shift by |
val
|
constexprnoexcept |
Right-shift the bits of val by shift.
| IntegerType | The type of integer to shift by. |
| val | The byte to shift |
| shift | The number of bits to shift by |
val right by shift bits shift < CHAR_BIT, otherwise ARENE_PRECONDITION violation
|
constexprnoexcept |
Modify val by shifting its bits right by shift.
| val | The value to shift |
| shift | The number of bits to shift by |
val Bit-wise xor of the byte representations.
| lhs | The first value |
| rhs | The second value |
lhs and rhs Modify lhs by bit-wise xor'ing it with the bits of rhs.
| lhs | The value to modify |
| rhs | The second value |
val Bit-wise or of the byte representations.
| lhs | The first value |
| rhs | The second value |
lhs and rhs Modify lhs by bit-wise or'ing it with the bits of rhs.
| lhs | The value to modify |
| rhs | The second value |
lhs Bit-wise negation of the byte representation.
| val | The value to negate |
val
|
inlineconstexprnoexcept |
Return the opposite ordering for a strong_ordering three-way-comparison result.
| ordering | The ordering to convert. |
strong_ordering::greater if ordering is strong_ordering::less, strong_ordering::equal if ordering is strong_ordering::equal, and strong_ordering::less if ordering is strong_ordering::greater.
|
inlineconstexprnoexcept |
Raises 2 to the power of a value.
| value | The value to raise two to the power of. |
2^value std::uint64_t , or else precondition violation.
|
constexprnoexcept |
Produces the Nth predecessor (or successor if steps is negative) of an iterator.
| Iterator | The iterator to advance. Does not participate in overload resolution unless Iterator is at least a bidirectional iterator. |
| itr | The iterator to advance |
| steps | The number of steps to advance the iterator by |
itr steps times results in attempting to produce an invalid iterator such as past-the-end or before-the-begin, behavior is undefined. steps is not std::numeric_limits<difference_type>::min() , else behavior is undefined. itr steps times. Read a value from a serialized binary representation stored in big-endian byte order.
| T | The type of the value to read. |
| bytes | A view of the bytes to read the data from. |
|
deletenoexcept |
Read a value from a serialized binary representation stored in big-endian byte order.
| T | The type of the value to read. |
| bytes | A view of the bytes to read the data from. |
Read an integral value from a serialized binary representation stored in little-endian byte order.
Read an enum value from a serialized binary representation stored in little-endian byte order.
| T | The type of the value to read. |
| bytes | A view of the bytes to read the data from. |
|
deletenoexcept |
Read a value from a serialized binary representation stored in little-endian byte order.
Read a floating point value from a serialized binary representation stored in little-endian byte order.
| T | The type of the value to read. |
| bytes | A view of the bytes to read the data from. |
| arene::base::REGISTER_TYPED_TEST_SUITE_P | ( | InlineDequeDeathTest | , |
| PushFrontMoreThanCapacity | , | ||
| PushBackMoreThanCapacity | , | ||
| NonWrappingInsertOneWhenFull | , | ||
| BackWhenEmpty | , | ||
| ConstBackWhenEmpty | , | ||
| PopFrontWhenEmpty | , | ||
| PopBackWhenEmpty | , | ||
| FrontWhenEmpty | , | ||
| ConstFrontWhenEmpty | , | ||
| CopyConstructFromBackwardRange | , | ||
| CopyConstructFromOversizedRange | , | ||
| MoveConstructFromBackwardRange | , | ||
| MoveConstructFromOversizedRange | , | ||
| ConstructFromOversizedInitializerList | , | ||
| DereferencingEndIteratorIsPreconditionViolation | , | ||
| DereferencingBeginOfEmptyDequeIsPreconditionViolation | , | ||
| DefaultConstructedIteratorCantBeUsed | , | ||
| DefaultConstructedConstIteratorCantBeUsed | , | ||
| IteratorOrderingFromDifferentDequesIsPreconditionViolation | , | ||
| SubtractingIteratorByMinimumValueIsPreconditionViolation | ) |
| arene::base::REGISTER_TYPED_TEST_SUITE_P | ( | InlineDequeTest | , |
| CanConstruct | , | ||
| CapacityIsAsSpecified | , | ||
| CapacityIsNoexcept | , | ||
| SizeIsNoexcept | , | ||
| PushFrontOneElement | , | ||
| PushBackOneElement | , | ||
| EmplaceFrontReturnsReference | , | ||
| EmplaceBackReturnsReference | , | ||
| FrontPushedElementIsCorrect | , | ||
| BackPushedElementIsCorrect | , | ||
| PushFrontWithinCapacity | , | ||
| PushBackWithinCapacity | , | ||
| PushFrontDetailCoverage | , | ||
| InsertConstraints | , | ||
| CopyInsertOne | , | ||
| MoveInsertOne | , | ||
| CopyInsertOneAtEnd | , | ||
| MoveInsertOneAtEnd | , | ||
| GoCircularFromFront | , | ||
| GoCircularFromBack | , | ||
| BasicFunctionFromFront | , | ||
| BasicFunctionFromBack | , | ||
| CanObserveAndModifyFromFront | , | ||
| CanObserveAndModifyFromBack | , | ||
| PushFrontCopiesLvalues | , | ||
| PushBackCopiesLvalues | , | ||
| NotCopyConstructibleIfDataTypeNotCopyConstructible | , | ||
| NotMoveConstructibleIfDataTypeNotMoveConstructible | , | ||
| NotCopyAssignableIfDataTypeNotCopyConstructibleAndCopyAssignable | , | ||
| NotMoveAssignableIfDataTypeNotMoveConstructibleAndMoveAssignable | , | ||
| CanConstructAtCompileTime | , | ||
| RangeConstructionSfinae | , | ||
| RangeConstructionNoexcept | , | ||
| CopyConstructFromRange | , | ||
| MoveConstructFromRange | , | ||
| InitializerListConstructionSfinae | , | ||
| InitializerListConstructionNoexcept | , | ||
| ConstructFromInitializerList | , | ||
| ConstructFromEmptyList | , | ||
| TryCopyConstructFromBackwardRange | , | ||
| TryCopyConstructFromOversizedRange | , | ||
| TryMoveConstructFromBackwardRange | , | ||
| TryMoveConstructFromOversizedRange | , | ||
| TryConstructFromOversizedInitializerList | , | ||
| CanCopyConstruct | , | ||
| CanCopyTryConstruct | , | ||
| CanMoveConstruct | , | ||
| CanMoveTryConstruct | , | ||
| CanCopyAssign | , | ||
| SelfCopyAssign | , | ||
| CanMoveAssign | , | ||
| SelfMoveAssign | , | ||
| CopyAssignIntoPartiallyFull | , | ||
| CopyAssignFromPartiallyFull | , | ||
| MoveAssignIntoPartiallyFull | , | ||
| MoveAssignFromPartiallyFull | , | ||
| IteratorsAreRandomAccessAndNoexcept | , | ||
| NonConstIteratorsImplicitlyConvertibleToConst | , | ||
| InspectWithIterators | , | ||
| IteratorsWrapAround | , | ||
| MutableIteratorsWork | , | ||
| InspectWithReverseIterators | , | ||
| MutableReverseIteratorsWork | , | ||
| IteratorsNotInvalidatedByPopFront | , | ||
| IteratorsNotInvalidatedByPopBack | , | ||
| BinaryPlusEquivalentToPlusEquals | , | ||
| BinaryMinusEquivalentToMinusEquals | , | ||
| IteratorBracketOperatorEquivalentToBinaryPlus | , | ||
| ContainerBracketOperatorEquivalentToIteratorBracketOperator | , | ||
| AnyIteratorDifferenceReturnsDistance | , | ||
| IteratorForwardMovementIsTheSameAsRepeatedIncrementing | , | ||
| IteratorBackwardMovementIsTheSameAsRepeatedDecrementing | , | ||
| IteratorsIncrementedOutOfBoundsBecomeEnd | , | ||
| EmptyDequeBeginEqualsEnd | , | ||
| IteratorsAreOrdered | ) |
|
constexpr |
Create a copy of the string view with trailing whitespace removed.
| MaxLength | The size of the inline string |
| str | The string_view reference to be trimmed |
arene::base::whitespace_chars . An empty or all whitespace string will result in an empty return string.
|
constexpr |
Create a copy of the string view with trailing whitespace removed.
| str | The string_view reference to be trimmed |
arene::base::whitespace_chars . An empty or all whitespace string will result in an empty return string.
|
constexprnoexcept |
Check the sign bit of a floating point number.
| num | The number to check |
true if num is negative (i.e. its sign bit is 1), false if num is positive
|
constexprnoexcept |
Check the sign bit of a floating point number.
| num | The number to check |
true if num is negative (i.e. its sign bit is 1), false if num is positive
|
constexprnoexcept |
Exchanges elements between range [first1, last1) and another range starting at first2. Precondition: the two ranges [first1, last1) and [first2, last2) do not overlap, where last2 = std::next(first2, std::distance(first1, last1)).
| SourceIterator | The type of the Iterator for the first range |
| DestIterator | The type of the Iterator for the second range |
| first1 | Beginning of the first range of elements to swap |
| last1 | End of the first range of elements to swap |
| first2 | Beginning of the second range of elements to swap |
|
inline |
Throw std::system_error based on the value of errno.
| std::system_error |
|
constexprnoexcept |
Internal function to construct an array from an rvalue C-style array, using the specified indices.
| T | The type of the array elements |
| Size | The number of array elements |
| arr | The source array |
|
constexprnoexcept |
Function to construct an array from a C-style array, using the specified indices.
| T | The type of the array elements |
| Size | The number of array elements |
| arr | The source array |
|
constexprnoexcept |
Convert an integer to an arene::base::byte.
| ValueType | The type of the integer. |
| val | The value to convert |
byte
|
inlineconstexprnoexcept |
Produces a string representation of an input boolean value.
| S | The size of the inline string to write the result to. Must be at least 5 characters. |
| value | The value to convert. |
|
inlineconstexprnoexcept |
Produces a string representation of an input integral value in base-10.
| T | The type of the value to convert. |
| S | The size of the inline string to write the result to. Must be large enough to hold T. |
| value | The value to convert. |
|
constexprnoexcept |
convert the byte value to an integral representation.
| IntegerType | The type of integer to convert to. |
| val | The byte to convert. |
val. | auto arene::base::to_string | ( | string_view const | str | ) | -> std::string |
Construct a std::string from the string_view.
| str | The string_view to convert |
std::string holding a copy of the string from the view
|
constexprnoexcept |
This replicates a function that went into C++23 called std::to_underlying (https://wg21.link/P1682). It automatically processes and figures out the type of an enumeration value.
| T | The type of the numeration for which to return the underlying value |
| value | The value of type T for which to retrieve the underlying value |
|
constexpr |
Create a copy of the string view with leading and trailing whitespace removed.
| MaxLength | The size of the inline string |
| str | The string_view reference to be trimmed |
arene::base::whitespace_chars . An empty or all whitespace string will result in an empty return string.
|
constexpr |
Create a copy of the string view with leading and trailing whitespace removed.
| str | The string_view reference to be trimmed |
arene::base::whitespace_chars . An empty or all whitespace string will result in an empty return string. | arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| BackWhenEmpty | ) |
inline_deque is empty, back terminates the application with a precondition violation | arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| ConstBackWhenEmpty | ) |
inline_deque is empty, the const overload of back terminates the application with a precondition violation | arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| ConstFrontWhenEmpty | ) |
inline_deque is empty, the const overload of front terminates the application with a precondition violation | arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| DefaultConstructedConstIteratorCantBeUsed | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| DefaultConstructedIteratorCantBeUsed | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| DereferencingBeginOfEmptyDequeIsPreconditionViolation | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| DereferencingEndIteratorIsPreconditionViolation | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| FrontWhenEmpty | ) |
inline_deque is empty, front terminates the application with a precondition violation | arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| IteratorOrderingFromDifferentDequesIsPreconditionViolation | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| MoveConstructFromBackwardRange | ) |
inline_deque crashes when move constructed from a range with the iterators in the wrong order | arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| MoveConstructFromOversizedRange | ) |
inline_deque crashes when move constructed from a range that's too large to fit within the capacity | arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| PopFrontWhenEmpty | ) |
inline_deque is empty, pop_front terminates the application with a precondition violation | arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| PushBackMoreThanCapacity | ) |
inline_deque's capacity terminates the application with a precondition violation or wraps, depending on its parameters | arene::base::TYPED_TEST_P | ( | InlineDequeDeathTest | , |
| SubtractingIteratorByMinimumValueIsPreconditionViolation | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| AnyIteratorDifferenceReturnsDistance | ) |
operator- between any two iterators returns the distance between them | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| BackPushedElementIsCorrect | ) |
inline_deque with plenty of capacity, an element can be inserted via push_back and then inspected | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| BinaryMinusEquivalentToMinusEquals | ) |
operator- on an iterator and a difference gives the same result as using operator-= on them | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| BinaryPlusEquivalentToPlusEquals | ) |
operator+ on an iterator gives the same result as using operator+= on a copy of it | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| CanConstruct | ) |
inline_deque has size equal to zero | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| CanMoveAssign | ) |
inline_deque move-assignment works as expected | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| CanMoveConstruct | ) |
inline_deque move-construction works as expected | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| CanMoveTryConstruct | ) |
inline_deque move-construction works as expected when invoked via try_construct | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| CapacityIsAsSpecified | ) |
inline_deque is equal to the supplied template parameter | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| CapacityIsNoexcept | ) |
capacity member function of inline_deque is declared noexcept | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| ContainerBracketOperatorEquivalentToIteratorBracketOperator | ) |
operator[] on the deque gives the same result as using operator[] on begin() | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| EmplaceBackReturnsReference | ) |
inline_deque returns a reference to the emplaced element | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| EmptyDequeBeginEqualsEnd | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| GoCircularFromBack | ) |
inline_deque has circular or ring-buffer behavior, such that when previously inserted elements via push_back are removed via pop_front, then space in the fixed-capacity storage of the deque is made available for new elements to be inserted | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| InitializerListConstructionNoexcept | ) |
inline_deque initializer list construction has the correct noexcept specification | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| InitializerListConstructionSfinae | ) |
inline_deque initializer list construction is enabled or disabled appropriately based on the value type | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| InspectWithIterators | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| InspectWithReverseIterators | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| IteratorBackwardMovementIsTheSameAsRepeatedDecrementing | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| IteratorBracketOperatorEquivalentToBinaryPlus | ) |
operator[] on an iterator gives the same result as using binary operator+ and unary operator* | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| IteratorForwardMovementIsTheSameAsRepeatedIncrementing | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| IteratorsAreOrdered | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| IteratorsAreRandomAccessAndNoexcept | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| IteratorsIncrementedOutOfBoundsBecomeEnd | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| IteratorsWrapAround | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| MoveAssignFromPartiallyFull | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| MoveAssignIntoPartiallyFull | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| MoveConstructFromRange | ) |
inline_deque can be constructed from a range of T using iterators | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| MutableIteratorsWork | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| MutableReverseIteratorsWork | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| NonConstIteratorsImplicitlyConvertibleToConst | ) |
| arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| NotCopyAssignableIfDataTypeNotCopyConstructibleAndCopyAssignable | ) |
inline_deque is not copy-assignable if the data type is not copy-constructible | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| NotCopyConstructibleIfDataTypeNotCopyConstructible | ) |
inline_deque is not copy-constructible if the data type is not copy-constructible | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| NotMoveAssignableIfDataTypeNotMoveConstructibleAndMoveAssignable | ) |
inline_deque is not move-assignable if the data type is not move-constructible | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| NotMoveConstructibleIfDataTypeNotMoveConstructible | ) |
inline_deque is not move-constructible if the data type is not move-constructible | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| PushBackOneElement | ) |
inline_deque with plenty of capacity, an element can be inserted via push_back, which causes a size increase | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| PushBackWithinCapacity | ) |
inline_deque, elements can be inserted via push_back within its capacity, making the size be equal to capacity | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| RangeConstructionNoexcept | ) |
inline_deque range construction has the correct noexcept specification | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| RangeConstructionSfinae | ) |
inline_deque range construction is enabled or disabled appropriately based on the arguments | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| SelfMoveAssign | ) |
inline_deque self move-assignment does nothing | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| SizeIsNoexcept | ) |
size member function of inline_deque is declared noexcept | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| TryMoveConstructFromBackwardRange | ) |
try_construct returns empty when move constructing from a range with the iterators in the wrong order | arene::base::TYPED_TEST_P | ( | InlineDequeTest | , |
| TryMoveConstructFromOversizedRange | ) |
try_construct returns empty when move constructing from a range that's too large to fit within the capacity | arene::base::TYPED_TEST_SUITE_P | ( | InlineDequeDeathTest | ) |
| arene::base::TYPED_TEST_SUITE_P | ( | InlineDequeTest | ) |
|
inlineconstexprnoexcept |
Convenience function to construct a result<void,Error> .
Example Usage:
result<void,Error> .
|
constexprnoexcept |
Convenience function to construct a result<ValueType,Error> containing the ValueType from any reference.
Example Usage:
| ValueType | the value_type of the produced result. |
| value | value to instantiate the result with. |
result<ValueType,Error> .
|
noexcept |
Invokes a given visitor with the active alternative in a given variant.
| RetT | The type to coerce all return types to. |
| VisitorT | The type of the visitor to invoke. |
| VariantT | The type of the variant to unwrap. Given variant<Ts...> , is_invocable_r<RetT,VisitorT,Ts> must hold where Visitor and Ts maintain the cref qualification visitor and variant respectively. |
| visitor | The visitor to invoke. |
| vrnt | The variant to take the active alternative of. |
visitor with the active alternative in vrnt , converted to RetT . vrnt.valueless_by_exception()==false , else ARENE_PRECONDITION violation.
|
noexcept |
Invokes a given visitor with the active alternative in a given variant.
| VisitorT | The type of the visitor to invoke. |
| VariantT | The type of the variant to unwrap. Given variant<Ts...> , is_invocable<VisitorT,Ts> must hold where Visitor and Ts maintain the cref qualification of Ts. |
| visitor | The visitor to invoke. |
| vrnt | The variant to take the active alternative of. |
visitor with the active alternative in vrnt . vrnt.valueless_by_exception()==false , else ARENE_PRECONDITION violation.
|
inlineconstexpr |
Characters defined as whitespace to be trimmed.
|
constexprnoexcept |
Write a value to a buffer in big-endian binary representation.
| T | The type of the value to write. This template parameter must be explicitly specified. |
| value | The value to write. |
| bytes | The buffer to write the big-endian binary representation to. |
|
deletenoexcept |
Write a value to a buffer in big-endian binary representation.
| T | The type of the value to write. This template parameter must be explicitly specified. |
| value | The value to write. |
| bytes | The buffer to write the big-endian binary representation to. |
|
constexprnoexcept |
Write an integral value to a buffer in little-endian binary representation.
Write an enum value to a buffer in little-endian binary representation.
| T | The type of the value to write. This template parameter must be explicitly specified. |
| value | The value to write. |
| bytes | The buffer to write the little-endian binary representation to. |
|
deletenoexcept |
Write a value to a buffer in little-endian binary representation.
Write a floating point value to a buffer in little-endian binary representation.
| T | The type of the value to write. This template parameter must be explicitly specified. |
| value | The value to write. |
| bytes | The buffer to write the little-endian binary representation to. |
|
externconstexpr |
Type trait to check if a type implements the tuple protocol.
get<Idx>() functions and specializations of std::tuple_size and std::tuple_element. The get<Idx>() implementations can either be member functions or free functions found by ADL; if both are present, the member functions are preferred.Types implementing the tuple protocol can be used with structured bindings. Standard classes like std::tuple, std::pair, and std::array implement the tuple protocol, as does arene::base::array.
This trait checks that get<0>() and get<size-1>() both return types that are reference-compatible with tuple_element at the same index (convertible to tuple_element_t const&, for each of the four value categories of T). Intermediate indices are not checked for performance reasons. If tuple_size<T> == 0, the type is considered to be tuple-like regardless of the presence or behaviour of get and tuple_element.
| T | The type to check |
|
externconstexpr |
A bool variable template that is true if all parameters are the same type, otherwise false.
|
externconstexpr |
All the types are the same if more than one type and they are all the same as the first.
|
externconstexpr |
Trait which tests if every value in a parameter pack is true .
| Args | The set of boolean values to test |
true , or the parameter pack is empty. false .
|
externconstexpr |
Trait which tests if every value in a parameter pack is true .
| Args | The set of boolean values to test |
true , or the parameter pack is empty. false .
|
constexpr |
A trait which always is false, as a type-dependent expression.
| T | has no impact on the result, but must result in always_false_v<T> being a type-dependent expression. |
This is generally used in order to allow having a "fallback" case in a template specialization set which triggers a more meaningful error than "no definition found." Before C++23, the expression static_assert(false,"message") will unconditionally trigger a compiler error, even if the expression is in an uninstantiated template. always_false_v<T> works around this by making the expression type-dependant, like so:
|
externconstexpr |
Trait which tests if at least one value in a parameter pack is true .
| Args | The set of boolean values to test |
true false , or the parameter pack is empty.
|
externconstexpr |
Trait which tests if at least one value in a parameter pack is true .
| Args | The set of boolean values to test |
true false , or the parameter pack is empty.
|
constexpr |
|
constexpr |
|
constexpr |
|
constexpr |
|
constexpr |
|
constexpr |
|
externconstexpr |
Reinterpret the object representation of one type as that of another.
| To | type to reinterpret as |
| From | type to reinterpret from |
| from | the source of bits for the return value |
Obtain a value of type To by reinterpreting the object representation of From. Every bit in the value representation of the returned To object is equal to the corresponding bit in the object representation of from. The values of padding bits in the returned To object are unspecified.
If there is no value of type To corresponding to the value representation produced, the behavior is undefined. If there are multiple such values, which value is produced is unspecified.
A bit in the value representation of the result is indeterminate if it does not correspond to a bit in the value representation of From (i.e. it corresponds to a padding bit), or corresponds to a bit of an object that is not within its lifetime, or has an indeterminate value. For each bit in the value representation of the result that is indeterminate, the smallest object containing that bit has an indeterminate value; the behavior is undefined unless that object is of unsigned char type. The result does not otherwise contain any indeterminate values.
To whose value representation is as described above. sizeof(To) == sizeof(From) is true std::is_trivially_copyable<To>::value is true std::is_trivially_copyable<From>::value is true bit_cast is usable in a constant expression only when the compiler provides __builtin_bit_cast . Query this via ARENE_IS_ON(ARENE_HAS_CONSTEXPR_BIT_CAST) . On toolchains without the builtin (e.g. GCC 8), bit_cast compiles but cannot appear in a constexpr context.
|
strong |
A type that represents a byte of data.
Use this for cases where you are dealing with serialised data in bytes or inspecting byte-representations of values.
This type is equivalent to std::byte added in C++17.
This type supports only bit-wise operations and does not support arithmetic operations like +, -, *, / or %.
|
externconstexpr |
Boolean constant indicating if instances of Lhs and Rhs can be compared using compare_three_way.
| Lhs | The type of the left-hand operand |
| Rhs | The type of the right-hand operand |
|
externconstexpr |
Boolean constant indicating if instances of Lhs and Rhs can be compared using compare_three_way.
| Lhs | The type of the left-hand operand |
| Rhs | The type of the right-hand operand |
|
externconstexpr |
The combined value of multiple boolean type traits.
| BoolTraits | the traits to combine |
BoolTraits::value && ... . bool(BoolTrait[N]::value) is false , then the remaining BoolTraits::value... are not evaluated.
|
externconstexpr |
Determine if one type decays to be the same as another type.
decays_to_v is useful to emulate deduced-this added in C++23 and for other disambiguation needs in overload sets
| T | The type to decay and compare to U |
| U | The unqualified type to which the decayed T is compared. U is not modified before the comparison. |
|
staticconstexpr |
The default size of the buffer used for inline_function .
|
externconstexpr |
Check if an iterator/sentinel pair form an iterable range that can be iterated without throwing.
| Iterator | The type to check as an iterator |
| Sentinel | The type to check as a sentinel |
denotes_iterable_range and which cant be iterated without throwing: all of operator++ , operator++(int) , operator* , and operator!= are noexcept .
|
externconstexpr |
Check if an iterator/sentinel pair form an iterable range. The value is true if the pair do form an iterable range, false otherwise.
| Iterator | The type to check as an iterator |
| Sentinel | The type to check as a sentinel |
|
externconstexpr |
The combined value of multiple boolean type traits through a logical OR operation.
| BoolTraits | the traits to combine |
BoolTraits::value || ... . BoolTrait[N]::value is true , then the remaining BoolTraits::value... are not evaluated.
|
externconstexpr |
A backport of C++23's std::forward_like @a , it allows forwarding a type with the same reference and const qualifications as another type.
| From | The type to take the reference and qualification properties from. |
| To | The type to apply the reference and qualification properties to. |
| val | The value to apply the reference and qualification properties to. |
To with the following properties:std::remove_reference_t<From> is a const-qualified type, then the referenced type of the return type is std::remove_reference_t<To> const . Otherwise, the referenced type is std::remove_reference_t<To> const-qualified.From is an lvalue reference, then the return type is also an lvalue reference, otherwise it is an rvalue reference.From is a referenceable type
|
constexpr |
The minimum memory spacing required between two items to avoid false-sharing.
Backport of C++17's std::hardware_destructive_interference_size. See P0154R0 for more details
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with a static fast_inequality_check member function that returns inequality_heuristic.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
T::fast_inequality_check(T,U) is defined and returns inequality_heuristic.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Type trait to check if a type has an overloaded address operator; the value is true if the type has an overloaded address operator, false otherwise.
| T | The type to check |
|
externconstexpr |
Type trait for determining if the given quantity kind has a unit selected. It is true if a unit is selected, false otherwise.
| Kind | the quantity kind to check |
|
externconstexpr |
Type trait for determining if the given quantity kind has a unit selected. It is true if a unit is selected, false otherwise.
| Kind | the quantity kind to check |
|
constexpr |
backport of std::in_place from C++17, a tag variable for in-place construction
|
externconstexpr |
backport of std::in_place_index<T> from C++17
|
externconstexpr |
backport of std::in_place_type<T> from C++17
|
externconstexpr |
Template meta-function for querying the 0-based index of 'T' within a list of types, 'Ts...'.
The instantiation will be ill-formed if T is not a member of Ts...
| T | The type to search for. |
| Ts | The list of types to search in. |
|
constexpr |
|
constexpr |
|
constexpr |
Externalized initialization of capacity is needed pre C++17.
|
constexpr |
Externalized initialization of max_size is needed pre C++17.
|
constexpr |
|
externconstexpr |
Checks if the specified integer sequence contains the specified value.
| Sequence | the sequence to search |
| value | the value to search for |
Sequence must be an instantiation of std::integer_sequence.
|
externconstexpr |
Get the number of occurrences of a value in the provided sequence.
| Sequence | the sequence to search |
| value | the value to search for |
Sequence must be an instantiation of std::integer_sequence.
|
externconstexpr |
The value of the Index th element of a std::integer_sequence.
Sequence must be an instantiation of std::integer_sequence.
|
externconstexpr |
The index of the first occurrence of a value in a std::integer_sequence.
Sequence must be an instantiation of std::integer_sequence. value must occur in Sequence else compilation will fail.
|
externconstexpr |
Check if a type is a valid accessor policy.
| AccessorPolicy | The policy to check |
A type A meets the accessor policy requirements if
element_type data_handle_type reference offset_policy access that takes a data_handle_type and a std::size_t offest that takes a data_handle_type and a std::size_t arene::base::is_copyable_v is trueis_nothrow_move_constructible_v is trueis_nothrow_move_assignable_v is trueis_nothrow_swappable_v is true
|
externconstexpr |
Check if instances of Lhs can be added to instances of Rhs. The value is true if they can be added, false otherwise.
| Lhs | The type of the left-hand operand |
| Rhs | The type of the right-hand operand, defaults to Lhs |
|
externconstexpr |
Trait query if a type has an ADL-discoverable swap function.
| T | The type to test. |
swap(T&,T&) is well-formed.
|
externconstexpr |
Trait query if a two types have an ADL-discoverable swap function.
| T | The first type to test. |
| U | The second type to test. |
swap(std::declval<T>(),std::declval<U>()) and swap(std::declval<U>(),std::declval<T>()) are both well-formed in unevaluated context after using std::swap, the value equals true. Otherwise, the value is false.
|
constexpr |
Type trait to check if a pointer to an array of From is convertible to a pointer to an array of To.
|
externconstexpr |
Type trait for checking if one type is a base quantity kind for another, or the same type. Evaluates to true if the first type is the same as the second, or a base quantity kind of the second (the second is a derived quantity kind of the first), false otherwise.
| BaseKind | the base kind |
| Type | the type to check. |
|
externconstexpr |
Type trait for checking if one type is a base quantity kind for another. Evaluates to true if the first type is a base quantity kind of the second (the second is a derived quantity kind of the first), false otherwise.
Note: a quantity kind is not considered to be a base quantity for itself, so is_base_quantity_kind_of_v<T,T> will always be false, for all types T
| BaseKind | the base kind |
| Type | the type to check. |
|
constexpr |
Type trait to check if a type is a bidirectional iterator The value is true if the type meets the requirements, false otherwise.
| T | The type being checked |
|
constexpr |
Specialization for types that meet the syntactic requirements for a bidirectional iterator
| T | The type being checked |
|
externconstexpr |
determines if a type satisfies the BinaryPredicate named requirement
| F | the possible binary predicate function object |
| T1 | type of the first argument |
| T2 | type of the second argument |
BinaryPredicate is a set of requirements expected by some of the standard library facilities from the user-provided function object types.
Given a BinaryPredicate pred and a pair of iterators iter1 and iter2 or an iterator iter and a (possibly const) value value, the type and value category of the expression pred(*iter1, *iter2) or, respectively, pred(*iter, value) , must meet the BooleanTestable requirements.
In addition, evaluation of that expression is not allowed to call non-const member functions of the dereferenced iterators; syntactically, the predicate must accept const object arguments, with the same behavior regardless of whether its arguments are const or non-const.
A type satisfies BinaryPredicate if
|
externconstexpr |
determines if a type satisfies the Compare named requirement
| F | the possible compare function object |
| T1 | type of the first argument |
| T2 | type of the second argument |
Compare is a set of requirements expected by some of the standard library facilities from the user-provided function object types.
The return value of the function call operation applied to an object of a type satisfying Compare, when converted to bool, yields true if the first argument of the call appears before the second in the strict weak ordering relation induced by this type, and false otherwise.
As with any BinaryPredicate, evaluation of that expression is not allowed to call non-const functions through the dereferenced iterators and, syntactically, the function call operation must accept const object arguments, with the same behavior regardless of whether the arguments are const or non-const.
A type satisfies Compare if
comp, an object of type F and equiv(a, b) , an expression-equivalent to !comp(a, b) && !comp(b, a) , the following expressions must be valid and have their specified effects:comp(a, b) establishes a strict weak orderingequiv(a, b) establishes an equivalence relationship
|
externconstexpr |
Backport for the C++20 copyable concept.
| T | The type to test |
The concept copyable<T> specifies that T is a movable object type that can also be copied (that is, it supports copy construction and copy assignment).
|
externconstexpr |
Backport for the C++20 copyable concept.
| T | The type to test |
The concept copyable<T> specifies that T is a movable object type that can also be copied (that is, it supports copy construction and copy assignment).
|
externconstexpr |
Trait query if a type can be swapped via the default implementation.
| T | The type to test. |
std::is_move_assignable<T> and std::is_move_constructible<T> are true.
|
constexpr |
Type trait to see if a particular TypeParam is double-ended or not; used to exclude some tests.
| TypeParam | The queue/deque type to check |
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the equality operator.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Helper variable to check if a provided type is an instantiation of extents.
The value is true if the type is an instantiation of extents, false otherwise
| T | The type to check |
|
externconstexpr |
Helper variable to check if a provided type is an instantiation of extents.
The value is true if the type is an instantiation of extents, false otherwise
| IndexType | the index type |
| Extents | sequence of static extents |
|
constexpr |
Type trait to check if a type is a forward iterator The value is true if the type meets the requirements, false otherwise.
| T | The type being checked |
|
constexpr |
Specialization for types that meet the input iterator requirements
| T | The type being checked |
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the greater-than operator.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the greater-than-or-equal operator.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Type trait to detect if a type is implicitly constructible from arguments of the specified types.
| T | The type to check if it can be implicitly constructed. |
| Args | The arguments to try to implicitly construct with. |
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the inequality operator.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Trait to query if a type is an inline_string.
| Type | The type to check. |
true if Type is a cv-qualified instantiation of inline_string. Otherwise, false.
|
externconstexpr |
Trait to query if a type is an inline_string.
| Type | The type to check. |
true if Type is a cv-qualified instantiation of inline_string. Otherwise, false.
|
constexpr |
Type trait to check if a type is an input iterator The value is true if the type meets the requirements, false otherwise.
| T | The type being checked |
|
constexpr |
Specialization for types that meet the syntactic input iterator requirements
| T | The type being checked |
|
constexpr |
true iff Type is an instantiation of Template
false. See specialization below.
|
constexpr |
true iff Type is an instantiation of Template
true.
|
externconstexpr |
Backport for the C++26 exposition-only integral-constant-like concept.
| T | The type to test |
The concept integral-constant-like<T> specifies that all of the following are true:
|
externconstexpr |
Determine if a functor type is invocable with the specified return and argument types.
Trait to determine if a given type is a transparent comparator for a given set of operands.
| Ret | The functor return type. |
| Fn | The functor type. |
| Args | The functor parameter types. |
| C | The type to test |
| T | The type of the left hand operand |
| U | The type of the right hand operand |
|
externconstexpr |
Determine if a functor type is invocable with the specified argument types.
| Fn | The functor type. |
| Args | The functor parameter types. |
|
constexpr |
Type trait for checking if a type is an iterator. The value is true if the type meets the requirements, false otherwise.
| T | The type being checked |
|
externconstexpr |
Helper trait to check if T is a valid layout mapping policy.
A valid layout mapping policy must have a template member mapping such that T::mapping<some_extent> is a valid layout mapping, such that T::mapping<some_extent>::extents_type is some_extent and T::mapping<some_extent>::layout_type is T
The value is true if T has all these properties, false otherwise
| T | The type being checked |
|
externconstexpr |
Helper trait to indicate if the given type has all the basic properties required of a layout mapping:
T::extents_type must be an instance of extents T::index_type must be an alias for T::extents_type::index_type T::rank_type must be an alias for T::extents_type::rank_type T::layout_type must be a valid layout mapping policy for T such that T::layout_type::mapping<T::extents_type> is T const member functions:extents() must return an instance of T::extents_type required_span_size() must return an instance of T::index_type is_unique() must return bool is_exhaustive() must return bool is_strided() must return bool static member functions:is_always_unique() must return bool is_always_exhaustive() must return bool is_always_strided() must return bool T::extents_type::rank() indices of type T::index_type returning an instance of T::index_type The value is true if T has all these properties, false otherwise
| T | The type being checked |
|
externconstexpr |
Specialization of is_layout_mapping_v to break a recursive cycle in the layout_stride equality operator.
| Extents | Any specialization of arene::base::extents |
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the less-than operator.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the less-than-or-equal operator.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Type trait to determine if the given type is an mdspan of some kind.
| T | The type to check |
|
externconstexpr |
Backport for the C++20 movable concept.
| T | The type to test |
The concept movable<T> specifies that T is an object type that can be moved (that is, it can be move constructed, move assigned, and lvalues of type T can be swapped).
|
externconstexpr |
Backport for the C++20 movable concept.
| T | The type to test |
The concept movable<T> specifies that T is an object type that can be moved (that is, it can be move constructed, move assigned, and lvalues of type T can be swapped).
|
externconstexpr |
Used to check if the noexcept specifier is considered part of a function's type. In C++14 and earlier noexcept was not considered as part of a function type. However, in C++17 and later noexcept is part of a function type. An example:
auto without_noexcept() -> void;
auto with_noexcept() noexcept -> void;
bool types_match = std::is_same<decltype(&without_noexcept), decltype(&with_noexcept)>::value;
In C++14 and earlier types_match will be true because both types will be void (*)(). In C++17 and later types_match will be false because the second type will be void (*)() noexcept.
This value is templated on a Dummy type in order for it to operate with SFINAE. Use as: std::enable_if_t<is_noexcept_part_of_function_type_v<T>>
| Dummy | An unused type for SFINAE compatibility |
|
constexpr |
|
constexpr |
Trait that deduces if a type is an non_owning_ptr to any type.
The test is after removing const and reference qualification
| T | The type to test if it is a non_owning_ptr |
|
externconstexpr |
Check if instances of Lhs can be added to instances of Rhs without throwing an exception. The value is true if they can be added without throwing, false otherwise.
| Lhs | The type of the left-hand operand |
| Rhs | The type of the right-hand operand, defaults to Lhs |
|
externconstexpr |
Trait query if a type has a noexcept ADL-discoverable swap function.
| T | The type to test. |
swap(T&,T&) is well-formed and it is marked noexcept .
|
externconstexpr |
Trait query if two types have a noexcept ADL-discoverable swap function.
| T | The first type to test. |
| U | The second type to test. |
swap(std::declval<T>(),std::declval<U>()) and swap(std::declval<U>(),std::declval<T>()) are both well-formed in unevaluated context after using std::swap and are marked noexcept, the value equals true. Otherwise, the value is false.
|
externconstexpr |
Trait query if two types have a noexcept ADL-discoverable swap function.
| T | The first type to test. |
| U | The second type to test. |
swap(std::declval<T>(),std::declval<U>()) and swap(std::declval<U>(),std::declval<T>()) are both well-formed in unevaluated context after using std::swap and are marked noexcept, the value equals true. Otherwise, the value is false.
|
externconstexpr |
Trait query if a type can be noexcept swapped the default implementation.
| T | The type to test. |
std::is_nothrow_move_assignable<T> and std::is_nothrow_move_constructible<T> are true.
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the equality operator without throwing an exception.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U without throwing, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the greater-than operator without throwing an exception.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U without throwing, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the greater-than-or-equal operator without throwing an exception.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U without throwing, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Type trait to detect if a type is nothrow implicitly constructible from arguments of the specified types.
| T | The type to check if it can be nothrow implicitly constructed. |
| Args | The arguments to try to nothrow implicitly construct with. |
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the inequality operator without throwing an exception.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U without throwing, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Determine if a functor type is no-throw invocable with the specified return and argument types.
| Ret | The functor return type. |
| Fn | The functor type. |
| Args | The functor parameter types. |
|
externconstexpr |
Determine if a functor type is no-throw invocable with the specified argument types.
| Fn | The functor type. |
| Args | The functor parameter types. |
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the less-than operator without throwing an exception.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U without throwing, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with the less-than-or-equal operator without throwing an exception.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
true if an instance of T can be compared with an instance of U without throwing, false otherwise.
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Type trait to detect if a type is nothrow explicitly constructible from arguments of the specified types.
| T | The type to check if it can be nothrow explicitly constructed. |
| Args | The arguments to try to nothrow explicitly construct with. |
|
externconstexpr |
Check if instances of Rhs can be subtracted from an instance of Lhs without throwing an exception. The value is true if they can be added without throwing, false otherwise.
| Lhs | The type of the left-hand operand |
| Rhs | The type of the right-hand operand, defaults to Lhs |
|
externconstexpr |
Trait query indicating if a type can be noexcept-swapped.
| T | the type to test |
is_nothrow_swappable_with_v<T&, T&>
|
externconstexpr |
Trait query indicating if two types can be noexcept-swapped.
| T | the first type to test |
| U | the second type to test |
swap(std::declval<T>(),std::declval<U>()) and swap(std::declval<U>(),std::declval<T>()) are both well-formed in unevaluated context after using std::swap and are marked noexcept, the value equals true. Otherwise, the value is false.
|
constexpr |
Query if the type 'T' is one of the list of types 'Ts...'.
Evaluates to 'true' if 'T' is a member of the set 'Ts...', otherwise to 'false'.
| T | The type to search for in TL. |
| TL | The TypeList to search in for T. |
|
externconstexpr |
Type trait to detect if a type is explicitly constructible from arguments of the specified types.
| T | The type to check if it can be explicitly constructed. |
| Args | The arguments to try to explicitly construct with. |
|
constexpr |
Type trait to check if a type is an output iterator The value is true if the type meets the requirements, false otherwise.
| T | The type being checked |
|
constexpr |
Specialization for types that meet the basic iterator requirements
| T | The type being checked |
|
externconstexpr |
Type trait to check if a type implements the tuple protocol and has a std::tuple_size of 2.
| T | The type to check |
|
externconstexpr |
Type trait to check if a type implements the tuple protocol and has a std::tuple_size of 2.
| T | The type to check |
|
externconstexpr |
Type trait for detecting if a type is a unit for a specific quantity kind. Evaluates to true if Unit is a unit for Kind, false otherwise.
| Unit | the type to check |
| Kind | the type to check if the type is a unit for |
|
externconstexpr |
backport for the C++20 predicate concept
| F | the possible predicate |
| Args | the argument types that the predicate is invoked with |
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 to produce a boolean-testable result.
|
externconstexpr |
Type trait for detecting a quantity kind. Evaluates to true if the type is a quantity kind, false otherwise.
| Type | the type to check |
|
externconstexpr |
Type trait to check if a quantity kind is itself an origin. The value is true if it is, false otherwise.
| Kind | Quantity kind to check |
|
constexpr |
Type trait to check if a type is a random-access iterator The value is true if the type meets the requirements, false otherwise.
| T | The type being checked |
|
constexpr |
Specialization for types that meets the syntactic requirements of a random access iterator
| T | The type being checked |
|
constexpr |
|
constexpr |
|
externconstexpr |
helper trait to check if a type is a submdspan slice type
| IndexType | mdspan index type |
| Slice | potential submdspan slice type |
Given a signed or unsigned integer type IndexType, a type Slice is a submdspan slice type for IndexType if at least one of the following holds:
std::is_convertible<Slice, full_extent_t>::value is true; std::is_convertible<Slice, IndexType>::value is true;Slice is a specialization of extent_slice and std::is_convertible<X, IndexType>::value is true for X denoting Slice::offset_type, Slice::extent_type, and Slice::stride_type;Slice is a specialization of range_slice and std::is_convertible<X, IndexType>::value is true for X denoting Slice::first_type, Slice::last_type, and Slice::stride_type; orSlice is pair-like, the "first type" of Slice is convertible to IndexType, and the "second type" of Slice is convertible to IndexType.
|
externconstexpr |
Check if instances of Rhs can be subtracted from an instance of Lhs. The value is true if they can be added, false otherwise.
| Lhs | The type of the left-hand operand |
| Rhs | The type of the right-hand operand, defaults to Lhs |
|
externconstexpr |
Trait query indicating if a type can be swapped.
| T | the type to test |
is_swappable_with_v<T&, T&>
|
externconstexpr |
Trait query indicating two types can be swapped.
| T | the first type to test |
| U | the second type to test |
swap(std::declval<T>(),std::declval<U>()) and swap(std::declval<U>(),std::declval<T>()) are both well-formed in unevaluated context after using std::swap, the value equals true. Otherwise, the value is false.
|
externconstexpr |
Type trait to check if an instance of type T can be compared to an instance of type U with a static three-way-compare member function that returns strong_ordering.
| T | The type of the lhs |
| U | The type of the rhs. Defaults to T |
T::three_way_compare(T,U) is defined and returns strong_ordering .
|
externconstexpr |
Specialization for the case that T and U can be compared.
|
externconstexpr |
Trait to determine if a given type is a transparent comparator for a given set of operands.
| C | The type to test |
| T | The type of the left hand operand |
| U | The type of the right hand operand |
is_transparent_comparator_v<C> && is_invocable_r_v<bool, C, T, U>.
|
externconstexpr |
Trait to determine if a given type is a transparent comparator.
| C | The type to test |
C::is_transparent exists and is a type definition C::is_transparent does not exist, or is not a type definition.
|
externconstexpr |
Trait to determine if a given type is a transparent comparator that performs a three-way comparison for a given set of operands.
| C | The type to test |
| T | The type of the left hand operand |
| U | The type of the right hand operand |
is_transparent_comparator_v<C> && is_invocable_r_v<strong_ordering, C, T, U>.
|
externconstexpr |
Type trait to check if a type implements the tuple protocol.
get<Idx>() functions and specializations of std::tuple_size and std::tuple_element. The get<Idx>() implementations can either be member functions or free functions found by ADL; if both are present, the member functions are preferred.Types implementing the tuple protocol can be used with structured bindings. Standard classes like std::tuple, std::pair, and std::array implement the tuple protocol, as does arene::base::array.
This trait checks that get<0>() and get<size-1>() both return types that are reference-compatible with tuple_element at the same index (convertible to tuple_element_t const&, for each of the four value categories of T). Intermediate indices are not checked for performance reasons. If tuple_size<T> == 0, the type is considered to be tuple-like regardless of the presence or behaviour of get and tuple_element.
| T | The type to check |
|
externconstexpr |
Type trait to check if a type implements the tuple protocol.
get<Idx>() functions and specializations of std::tuple_size and std::tuple_element. The get<Idx>() implementations can either be member functions or free functions found by ADL; if both are present, the member functions are preferred.Types implementing the tuple protocol can be used with structured bindings. Standard classes like std::tuple, std::pair, and std::array implement the tuple protocol, as does arene::base::array.
This trait checks that get<0>() and get<size-1>() both return types that are reference-compatible with tuple_element at the same index (convertible to tuple_element_t const&, for each of the four value categories of T). Intermediate indices are not checked for performance reasons. If tuple_size<T> == 0, the type is considered to be tuple-like regardless of the presence or behaviour of get and tuple_element.
| T | The type to check |
|
externconstexpr |
Type trait for detecting if a type is a unit. Evaluates to true if the type is a unit, false otherwise.
| Kind | the type to check |
|
externconstexpr |
Template meta-function for querying the last 0-based index of 'T' within a list of types, 'Ts...'.
The instantiation will be ill-formed if T is not a member of Ts...
| T | The type to search for. |
| Ts | The list of types to search in. |
|
constexpr |
Get the number of dimensions in the extents.
| ElementType | the element type |
| Extents | an instantiation of extents representing the shape of the multidimensional index space |
| LayoutPolicy | a layout policy (defaults to layout_right) |
| AccessorPolicy | an accessor policy (defaults to default_accessor<ElementType>) |
|
constexpr |
Get the number of dimensions with dynamic extent.
| ElementType | the element type |
| Extents | an instantiation of extents representing the shape of the multidimensional index space |
| LayoutPolicy | a layout policy (defaults to layout_right) |
| AccessorPolicy | an accessor policy (defaults to default_accessor<ElementType>) |
|
staticconstexpr |
An enum representing the cv-qualification of a member function pointer type.
| F | member function pointer type |
|
staticconstexpr |
An enum representing the reference-qualification of a member function pointer type.
| F | member function pointer type |
|
externconstexpr |
The negated value of a boolean type trait.
| BoolTrait | the trait to negate |
!BoolTrait::value .
|
constexpr |
Trait which tests if no values in a parameter pack are true .
| Args | The set of boolean values to test |
true , or the parameter pack is empty. false .
|
constexpr |
alias to maintain backwards compatibility with older versions of Arene Base.
|
constexpr |
Tag variable for empty-optional construction.
|
externconstexpr |
Type trait to check if a quantity kind has an origin. The value is true if it does, false otherwise.
| Kind | Quantity kind to check |
|
externconstexpr |
An array holding a sequence of integer values starting at 0, incrementing by 1 each time.
| ElementType | The type of each element |
| Count | The number of elements in the sequence. |
|
externconstexpr |
An array holding a sequence of integer values starting at Begin, ending at End and incrementing by 1 each time.
| ElementType | The type of each element |
| Begin | The first element in the sequence. |
| End | The last element in the sequence. |
|
externconstexpr |
An array holding a sequence of integer values starting at Begin, incrementing by 1 each time.
| ElementType | The type of each element |
| Begin | The first element in the sequence. |
| Count | The number of elements in the sequence. |
|
constexpr |
|
externconstexpr |
Determines if a template can be instantiated successfully, similar to C++20's requires clause.
Template<P...> successfully undergoes substitution when in a SFINAE context, otherwise false.This is generally used to help emulate "concepts" in a pattern such as the following example which detects if a type has a member function named foo() :
|
externconstexpr |
The name of a type as an inline_string.
| T | The type to get the name of |
|
constexpr |
Special value used as the return value of variant::index() when variant::valueless_by_exception() is true.
|
constexpr |
Declaration of variant_size_v. Default to variant_npos.
|
constexpr |
Specialization of variant_size_v for variant.
| Ts | the types in the variant |
|
constexpr |
Specialization of variant_size_v for const variant.
| Ts | the types in the variant |
|
constexpr |
The version of Arene.Base.
5'021'001 is a major version of 5 , a minor version of 21 , and a patch version of 1.
|
constexpr |
The major version for Arene.Base.
|
constexpr |
The minor version for Arene.Base.
|
constexpr |
The patch version for Arene.Base.
|
constexpr |
The version of Arene.Base as a string.
1.13.2