 |
Arene Base
Fundamental Utilities For Safety Critical C++
|
|
Arene Base
Fundamental Utilities For Safety Critical C++
|
| ►Narene | Copyright 2026, Toyota Motor Corporation |
| ►Nbase | |
| ►Nfilesystem | |
| Cdirectory_handle | Class to wrap a directory handle |
| Cerror_code | A class representing a filesystem error value. Intended to be a wrapper around errno |
| Cfile_handle | An RAII wrapper around a POSIX file handle with unique-ownership semantics |
| Cscoped_change_directory | A RAII helper to temporarily change the working directory of the process |
| Ctemporary_directory | An RAII helper class to manage a temporary directory |
| ►Nintrusive | |
| Cbinary_tree_node | The tree node of the intrusive container. User type can be derived from this class to support intrusive containers. The parent_ points to itself for the root of a tree an indicator |
| Cpriority_queue | The intrusive priority_queue. By default, the priority_queue is building a max heap where the element at the top is always the largest. To build a min heap, pass a std::greater<> as the comparator |
| Cqueue | Intrusive queue implementation |
| Csingly_linked_node | Singly linked hook. User type can be derived from this class to support intrusive containers |
| ►Nlayout_left | |
| Cmapping | A mapping from a logical pack of indices into a single flat physical output index |
| ►Nlayout_right | |
| Cmapping | A mapping from a logical pack of indices into a single flat physical output index |
| ►Nlayout_stride | |
| Cmapping | A mapping from a logical pack of indices into a single flat physical output index, using a strided algorithm |
| ►Nlinalg | |
| Cmath_traits | A traits struct allowing SFINAE-friendly access to the properties of types which may be linalg objects |
| ►Ntesting | |
| ►Ninternal | |
| Cconditionally_constexpr_test | GoogleTest test type used to conditionally invoke tests at compile-time |
| Cconditionally_constexpr_test< TestTag, false > | Specialization for the false case: the test body runs at runtime only |
| Cconstexpr_test | GoogleTest test type used invoke tests at compile-time |
| Cbitwise_uniform_distribution | A uniform distribution to apply on top of a bit generator. Primary template (deliberately undefined) |
| Cbitwise_uniform_distribution< T, arene::base::constraints< std::enable_if_t< std::is_integral< T >::value > > > | A uniform distribution to apply on top of a bit generator. SFINAE overload for integral types |
| Cequal_to_value | |
| CExternalVectorDeathTest | The Death Tests use the same fixture as the "normal" tests. Inherits so that it will be a distinct type |
| ►CExternalVectorTest | Test fixture for all type-parameterized external_vector tests |
| Cinput_iterator_with_configurable_noexcept | An input iterator pointing to any type whose operators have adjustable noexcept specifications |
| Cthrowing_bidirectional_iterator_of_t | A bidirectional iterator of T which declares that it could throw, used in some noexcept tests |
| Cthrows_when_converted_to_t | A type with a noexcept(false) conversion operator to T (doesn't actually throw, just declares it) |
| CInlineVectorDeathTest | The Death Tests use the same fixture as the "normal" tests. Inherits so that it will be a distinct type |
| ►CInlineVectorTest | Test fixture for all type-parameterized inline_vector tests |
| Cinput_iterator_with_configurable_noexcept | An input iterator pointing to any type whose operators have adjustable noexcept specifications |
| Cthrowing_bidirectional_move_iterator_of_t | A bidirectional iterator of T which declares that it could throw, used in some noexcept tests |
| Cthrows_when_converted_to_t | A type with a noexcept(false) conversion operator to T (doesn't actually throw, just declares it) |
| Cmove_only_wrapper | |
| Cprng_xoshiro | Pseudorandom number generator implementing the xoshiro256++ algorithm |
| Cproperty_config | Configuration for property run |
| Cproperty_error | Error result of evaluating a property assertion |
| Cproperty_summary | Result of a property run |
| Crvalue_iterator | An iterator whose i'th position yields an rvalue reference to test_value(i) of the given type |
| Cthrows_without_nullptr | |
| ►Ntype_lists | |
| Capply_each | Apply the given template individually to every element of the given type list |
| Capply_each< TypeList< Types... >, ToApply > | Apply the given template individually to every element of the given type list |
| Ccontains_t | Query if a type-list contains a given type |
| Cempty_t | Get whether the type list is empty |
| Creverse | Reverses the types in a type list |
| Creverse< List< Ts... > > | Specialization for type-list-like types |
| Csort | Sort a type list. ComparisonPredicate<T1,T2>::value should be a constexpr bool that is true if T1 is ordered before T2, and false otherwise, for any pair of types T1 and T2 from the type list. The type member is an alias to the resulting type list, with the elements sorted according to the comparator, such that if ComparisonPredicate<T1,T2>::value is true, then T1 is before T2 in the resulting list. If neither ComparisonPredicate<T1,T2>::value nor ComparisonPredicate<T2,T1>::value is true then the whichever is first in TypeList appears first in the result |
| Csort< TypeList< Types... >, ComparisonPredicate > | Sort a type list. The type member type is an alias for an instantiation of TypeList holding the types in Types sorted according to ComparisonPredicate |
| ►Nunits | |
| ►Nscales | |
| Cpi | A class to represent a scale factor of Pi |
| Cabsolute_zero | A tag type for absolute zero, the origin of the Kelvin scale |
| Camount_of_substance | Base quantity kind for the quotient of the number of entites of a given kind in a system and the Avogadro constant |
| Campere | The SI base quantity unit for electric current |
| Cangular_degree | A quantity unit for angular_measure |
| Cangular_measure | A quantity kind for a measure of a geometric figure formed by two rays emanating from a common point, given by the arc length of the included arc of a circle centred at the common point divided by the radius of that circle |
| Ccandela | The SI base quantity unit for luminous intensity |
| Celectric_current | Base quantity kind for the quotient of the net electric charge transferred through a surface in a quasi-infinitessimal time interval, and the duration of that time interval |
| Cgram | A quantity unit for mass |
| Ckelvin | Base quantity kind for the partial derivative of internal energy with respect to entropy at constant volume and constant number of particles in the system |
| Clength | Base quantity kind for the linear extent in space between any two points |
| Cluminous_intensity | Base quantity kind for the density of luminous flux with respect to solid angle in a specified direction |
| Cmass | Base quantity kind for thr property of a body which expresses itself in terms of inertia with regard to changes in its state of motion as well as its gravitational attraction to other bodies |
| Cmeter | The SI base quantity unit for length |
| Cmole | The SI base quantity unit for amount of substance |
| Cnumber | Base quantity kind for all numeric quantity kinds |
| Cnumber_of_entities | Quantity kind for the number of entities of a given kind in a system |
| Cradian | A quantity unit for angular_measure |
| Csecond | The SI base quantity unit for time |
| Cthermodynamic_temperature | Base quantity kind for thermodynamic temperature |
| Ctime | Base quantity kind for time |
| Carray | A fixed-size array of T objects |
| Carray< T, 0 > | Specialize for zero-sized arrays as 'T array[0]' is not standards compliant |
| Catomic_monotonic_counter | A thread-safe atomic counter |
| ►Cbarrier | A backport of std::barrier from C++20 |
| Carrival_token | A class holding the result of a call to arrive, which can then be passed to wait to wait for the end of the completion step associated with the call to arrive |
| Ccircular_buffer | A container with fixed capacity featuring constant time insertion and removal at opposite ends; i.e., with an interface similar to std::queue. The storage for the elements is held directly within the class. Storing more than Capacity elements results in overwriting the oldest element |
| Cconjunction | Combines the values of multiple boolean type traits with a logical AND operation |
| Cconjunction< BoolTrait > | Specialization of arene::base::conjunction for a single trait. The result is that trait |
| Cconjunction< BoolTrait, Rest... > | Specialization of arene::base::conjunction for multiple traits |
| Cconst_inline_map_reference | A const reference class to an inline_map object, with size-erased type |
| Cconst_inline_string_reference | A const reference class to an inline_string object, with size-erased type |
| Cconst_vector_reference | A const reference class to an inline_vector object, with size-erased type |
| Cdefault_accessor | Accesses a single element from a pointer and an index |
| Cdisjunction | Combines the values of multiple boolean type traits with a logical OR operation |
| Cdisjunction< BoolTrait > | Specialization of arene::base::disjunction for a single trait. The result is that trait |
| Cdisjunction< BoolTrait, Rest... > | Specialization of arene::base::disjunction for multiple traits |
| Cebo_holder | A class to hold an instance of a type that is likely to be empty, such as a comparator or allocator, making use of the empty base class optimization if possible |
| Cebo_holder< Tag, Value, true > | A class to hold a value, making use of the empty base class optimization if possible. This specialization is for types that can be used as a base class |
| Cerror_result_t | Intermediary type for constructing a result with a given error_type |
| Cextent_slice | Set of extent regularly spaced integer indices |
| Cextents | Multidimensional index space |
| Cexternal_vector | Container similar to std::vector<T> that uses an external buffer for storage |
| Cfull_equality_operators_from_basic_equality | Helper class that can be inherited from by a class to define the != operator in terms of the == operator defined by that class |
| Cfull_extent_t | Tag class specifying the full extent of an mdspan |
| Cfull_ordering_operators_from_less_than | Helper class that can be inherited from by a class to define the >, <=, >=, == and != operators in terms of a < operator that the derived class provides |
| Cfull_ordering_operators_from_less_than_and_equals | Helper class that can be inherited from by a class to define the >, <=, >=, != operators in terms of a < operator and == operator that the derived class provides |
| Cfunction_ref | An implementation of the proposed std::function_ref from P0792. Provides a type-erased callable like std::function, but just stores a reference to the wrapped callable rather than a copy of it |
| Cfunction_ref< R(Args...), IsNoexcept > | This specialization handles non-const-qualified function signatures |
| Cgeneric_ordering_from_three_way_compare | Helper class that can be inherited from by a class to define the relational comparison operators in terms of a three_way_compare function provided by the Derived class, and an optional fast-inequality check heuristic |
| Cgeneric_ordering_from_three_way_compare_and_equals | Helper class that can be inherited from by a class to define the relational comparison operators in terms of a three_way_compare function provided by the Derived class, but preferentially implementing == and != to use operator==(Derived, Other) rather than three_way_compare |
| Cgive_cv_to | Add the cv qualification from one type to another |
| Cgive_cvref_to | Add the cv-ref qualification from one type to another |
| Chas_overloaded_address_operator | Type trait to check if a type has an overloaded address operator; the class derives from true_type if the type has an overloaded address operator, false_type otherwise |
| Cidentity | A backport of the C++20 std::identity function object. It returns its input unchanged |
| Cimplicit_constructor_base | A class that has the same implicit constructors as another type |
| Cin_place_index_t | Backport of std::in_place_index_t<size_t> from C++17 |
| Cin_place_t | Backport of std::in_place_t from C++17 |
| Cin_place_type_t | Backport of std::in_place_type_t<T> from C++17 |
| Cindex_of | Template meta-function for querying the 0-based index of a type in a list of types |
| Cinline_deque | A container with fixed capacity featuring constant time insertion and removal at opposite ends; i.e., with an interface similar to std::deque. The storage for the elements is held directly within the class. Any attempt to store more than Capacity elements is an ARENE_PRECONDITION violation |
| Cinline_function | A function wrapper akin to std::function that always stores the wrapped invocable internally |
| Cinline_function< ReturnType(Args...) const, BufferSize, IsNoexcept > | A function wrapper akin to std::function that always stores the wrapped invocable internally. This specialization is for where the function type is const qualified |
| Cinline_function< ReturnType(Args...), BufferSize, IsNoexcept > | A function wrapper akin to std::function that always stores the wrapped invocable internally. This specialization is for where the function type is not const qualified |
| Cinline_map | A container similar to std::map that has a fixed capacity |
| Cinline_map_reference | A reference class to an inline_map object, with size-erased type |
| Cinline_map_reference_iterator | Iterator type used by inline_map_reference and const_inline_map_reference |
| Cinline_set | A non-allocating fixed-capacity associative container storing elements of type Value |
| Cinline_string | A string type with a fixed maximum capacity, where the data is stored internally without allocations |
| Cinline_string_reference | A reference class to an inline_string object, with size-erased type |
| Cinline_vector | A container similar to std::vector<T> that has a fixed capacity. The storage for the elements is held directly within the class. Any attempt to store more than Capacity elements will throw std::length_error |
| CInlineDequeDeathTest | The death tests use the same fixture as the non-death tests, but as a distinct type to improve log output |
| CInlineDequeTest | Test fixture for all type-parameterized inline_deque tests |
| Cinteger_sequence_count_of | Get the number of occurrences of a value in the provided sequence. The result is stored in the value member |
| Cinteger_sequence_element | Trait providing the Index th element of a std::integer_sequence. The value member holds the value. If Index is out of range, there is no value member |
| Cinteger_sequence_index_of | Trait for the index of the first occurrence of a value in a std::integer_sequence |
| Cinvoke_result | Determines the return type of a functor invoked with the specified arguments |
| Cis_array_convertible | Type trait to check if a pointer to an array of From is convertible to a pointer to an array of To |
| Cis_inline_string | Trait to query if a type is an inline_string |
| Cis_invocable | Determine if a functor type is invocable with the specified argument types |
| Cis_invocable_r | Determine if a functor type is invocable with the specified return and argument types |
| Cis_nothrow_invocable | Determine if a functor type is no-throw invocable with the specified argument types |
| Cis_nothrow_invocable_r | Determine if a functor type is no-throw invocable with the specified return and argument types |
| Cis_nothrow_only_explicitly_constructible | Type trait to detect if a type is nothrow explicitly constructible from arguments of the specified types |
| Cis_one_of | Query if the type 'T' is one of the list of types 'Ts...' |
| Cis_only_explicitly_constructible | Type trait to detect if a type is explicitly constructible from arguments of the specified types |
| Cis_transparent_comparator | Trait to determine if a given type is a transparent comparator |
| Cis_transparent_comparator< C, void_t< typename C::is_transparent > > | Trait to determine if a given type is a transparent comparator |
| Clast_index_of | Template meta-function for querying the last 0-based index of a type in a list of types |
| Clatch | Backport of std::latch from C++20. Provides a count-down latch that stays permanently signalled when the count reaches zero. For a given instance, every call to count_down or arrive_and_wait synchronizes-with every call to wait or arrive_and_wait, and every call to try_wait that returns true |
| Cmanual_reset_event | An event class that allows blocking waits from an arbitrary number of threads that are then woken when the event is signalled. Additional calls to wait while the event is signalled will return immediately. If there are no waiting threads, the event can be reset to an unsignalled state |
| Cmdspan | A multidimensional view of elements over a contiguous sequence of elements |
| Cmember_function_cv | Obtains the cv-qualification of a member function pointer type |
| Cmember_function_pointer_traits | Contains the types within function_traits and member_pointer_traits for a member function pointer |
| Cmember_function_reference | Obtains the reference-qualification of a member function pointer type |
| Cmonostate | A monostate type that is a well-behaved empty value for variants |
| Cnegation | Negates the value of a boolean type trait |
| Cnon_constructible_dummy | A special dummy class that cannot be constructed. It can be used as a substitute argument for copy/move constructors or assignment operators that should be deleted, or any other place where a type is required, but not desired |
| Cnon_null | A pointer type which is never nullptr |
| Cnon_owning_ptr | A non-owning, nullable pointer with nullptr checks on dereference |
| ►Cnull_terminated_string_view | A read-only string-view that provides a view onto a null-terminated string |
| Csentinel | This type represents the sentinel of the range of characters |
| Cnullopt_t | Empty class type used to indicate that arene::base::optional does not contain a value |
| Coptional | Implementation of std::optional for pre-C++17 compilers, and which replaces defined undefined behavior with ARENE_PRECONDITION guards |
| Coptional_resetter | A simple class that resets an optional value in its destructor, unless dismissed |
| Cpriority_tag | A priority tag for overload resolution |
| Cpriority_tag< std::size_t{0}> | A priority tag for overload resolution |
| Cquantity | A class representing a quantity of a physical units type |
| Cquantity_origin | CRTP base class used when defining a new quantity origin, e.g. absolute zero for temperature |
| Cquantity_unit | Base class for declaring a quantity unit |
| Crange_slice | Slice of integer indices given the first and last |
| Crelative_origin | CRTP base class used when defining a new relative origin, e.g. zero celsius which is relative to zero Kelvin |
| Cremove_cvref | Backport of std::remove_cvref |
| Crepeat_type | Repeat a template argument a specified number of times |
| Crepeat_type< 0UL, T, Arg > | Repeat a template argument a specified number of times |
| Crepeat_type_ex | Repeat a template argument a specified number of times with an extra leading template argument |
| Crepeat_type_ex< 0UL, T, U, Arg > | Repeat a template argument a specified number of times with an extra leading template argument |
| Cresult | A sum type which can hold either a value or an error. Similar to std::expected |
| Cresult< void, E > | Specialization of result<T, E> for void value types |
| Creverse_iterator | A backport of the constexpr std::reverse_iterator from C++17 |
| Creverse_iterator< Itr, true > | A backport of the constexpr std::reverse_iterator from C++17 |
| Cscope_guard | RAII utility for executing logic on scope exit |
| Csemantic_version | A class representing semantic versions (https://semver.org/). Does not include build metadata or prerelease comparisons |
| Cspan | A backport of std::span for C++14. Provides a view over a contiguous range of elements of type T |
| Csrc_line_info | Container for the location information associated with a line of source code |
| Cstatic_if | A metaprogramming facility for selecting a branch statically without evaluating both branches apriori |
| Cstatic_if< false > | The definition when static_if gets a "false" condition |
| Cstatic_if< true > | The definition when static_if gets a "true" condition |
| Cstring_view | Backport of the C++17 std::string_view class |
| Csubmdspan_mapping_result | Specializations of submdspan_mapping_result are returned by overloads of submdspan_mapping |
| Csubmdspan_subextents_type | Determines the subextents type from an extents type and slice specifiers |
| Ctype_identity | Polyfill of std::type_identity added in C++20 |
| Ctype_list | Empty struct that is a list of types - cheaper to instantiate than tuple |
| Cunits_combination_traits | Traits class with information about if and how a physical unit of type QuantityType1 can be combined with a physical unit of type QuantityType2 |
| Cunits_combination_traits< QuantityType, QuantityType > | Specialization to allow addition and subtraction of a quantity type from itself |
| Cunits_conversion_traits | Traits class with information about if and how a physical unit of type From can be converted to a physical unit of type To |
| Cunwrap_ref_decay | Backport of std::unwrap_ref_decay from C++20 |
| Cunwrap_reference | Backport of std::unwrap_reference from C++20 |
| Cvalue_result_t | Intermediary type for constructing a result with a given value_type |
| Cvalue_result_t< void > | Intermediary type for constructing a result with a void value |
| Cvariant | Forward declaration of variant |
| Cvariant_alternative | Traits to get the I-th type of a variant |
| Cvariant_alternative< I, T const > | Implementation of variant_alternative for const variant with actual types |
| Cvariant_alternative< I, variant< Ts... > > | Implementation of variant_alternative for variant with actual types |
| Cvariant_size | Helper struct to get the size of a variant |
| Cvector_reference | A reference class to an inline_vector object, with size-erased type |
| ►Nstd | STL namespace |
| ►Nadd_lvalue_reference_detail | |
| Cadd_lvalue_reference | Base case when Type is not referenceable |
| Cadd_lvalue_reference< Type, arene::base::constraints< Type & > > | Add an lvalue reference onto Type |
| ►Nadd_pointer_detail | |
| Cadd_pointer | Base case for when Type is not referenceable or void |
| Cadd_pointer< Type, std::enable_if_t< internal::is_referenceable_v< Type >||std::is_void_v< Type > > > | Add a pointer to the given type |
| ►Nadd_rvalue_reference_detail | |
| Cadd_rvalue_reference | Base case when Type is not referenceable |
| Cadd_rvalue_reference< Type, arene::base::constraints< Type && > > | Add an rvalue reference onto Type |
| ►Nback_insert_iterator_detail | |
| Cadaptor_mixin | Mixin used to define back_insert_iterator |
| ►Nbasic_insert_iterator_detail | |
| Cbasic_insert_iterator | Iterator adaptor for insertion into a container |
| ►Nchrono | |
| ►Nchrono_detail | |
| Ccheck_conversion_overflow | Helper to detect if duration conversion would cause overflow |
| Cduration | Forward declaration of duration class template |
| Cduration_values | A customizable trait to indicate the zero, lowest, and highest values of a given representation type |
| Ctime_point | A class representing a single point in time for the given clock |
| Ctreat_as_floating_point | Trait to indicate if a representation type should be treated as floating-point |
| ►Ncommon_type_detail | |
| Ccommon_type_3_or_more | Primary template for computing common type of 3 or more types |
| Ccommon_type_3_or_more< arene::base::constraints< common_type_t< T1, T2 > >, T1, T2, Ts... > | Specialization for computing common type of 3 or more types |
| Cdecayed_conditional_result | Primary template for decaying conditional result types |
| Cdecayed_conditional_result< T1, T2, arene::base::constraints< conditional_result_t< T1, T2 > > > | Specialization that provides the decayed type of a conditional expression |
| ►Nhash_detail | |
| Cdefault_hash | Default implementation of std::hash implemented only for fundamental types, enumerations and pointers |
| Cdefault_hash< T, arene::base::constraints< enable_if_t< is_fundamental_v< T >||is_enum_v< T >||is_pointer_v< T > > > > | Default implementation of std::hash |
| Cfnv1a_hash | FNV-1a hash algorithm |
| ►Nignore_detail | |
| Cignore_t | A class that anything can be assigned to, and which discards the assigned object |
| ►Ninner_product_detail | |
| Creduce_value_policy | Reduce value policy for a C++14 compliant implementation |
| ►Ninsert_iterator_detail | |
| Cadaptor_mixin | Mixin used to define insert_iterator |
| ►Ninteger_sequence_detail | |
| Cfast_expand_sequence | Helper for quickly expanding the elements in a sequence |
| Cfast_expand_sequence< T, true > | Specialization if the sequence can be doubled |
| Cmake_integer_sequence | Helper type to check that the requested sequence size is non-negative |
| Cmake_integer_sequence< Type, Size, true > | Helper type to check that the requested sequence size is non-negative |
| Cmake_sequence_impl | Helper for constructing an integer sequence from 0 to N - 1 |
| Cmake_sequence_impl< T, 0 > | Recursive base case specialization |
| Cmake_sequence_impl< T, 0, Is... > | Recursive base case specialization |
| Cmake_sequence_impl< T, N > | Initial make sequence specialization |
| ►Nis_nothrow_constructible_detail | |
| Cis_nothrow_constructible | Internal implementation of is_nothrow_constructible |
| Cis_nothrow_constructible_impl | Internal implementation of is_nothrow_constructible |
| Cis_nothrow_constructible_impl< true, Type, Args... > | Internal implementation of is_nothrow_constructible |
| Cis_nothrow_constructible_impl< true, Type[N], Args... > | Internal implementation of is_nothrow_constructible |
| ►Niterator_traits_detail | |
| Citerator_traits_base | Base type for non-iterator types |
| Citerator_traits_base< Iter, arene::base::constraints< typename Iter::difference_type, typename Iter::value_type, typename Iter::reference, typename Iter::pointer, typename Iter::iterator_category > > | Base type for iterator types |
| ►Nmake_signed_detail | |
| Cmake_signed | Internal class providing std::make_signed |
| Cmake_signed< char > | Internal class providing std::make_signed for char |
| Cmake_signed< char16_t > | Internal class providing a signed type for char16_t |
| Cmake_signed< char32_t > | Internal class providing a signed type for char32_t |
| Cmake_signed< Type, arene::base::constraints< enable_if_t< is_enum_v< Type > >, enable_if_t<!is_const_v< Type > >, enable_if_t<!is_volatile_v< Type > > > > | Internal class providing std::make_signed for integral types that are already signed |
| Cmake_signed< Type, arene::base::constraints< enable_if_t< is_integral_v< Type > >, enable_if_t< is_signed_v< Type > >, enable_if_t<!is_same_v< Type, bool > >, enable_if_t<!is_const_v< Type > >, enable_if_t<!is_volatile_v< Type > > > > | Internal class providing std::make_signed for integral types that are already signed |
| Cmake_signed< Type, arene::base::constraints< enable_if_t< is_integral_v< Type >||is_enum_v< Type > >, enable_if_t< is_const_v< Type > >, enable_if_t< is_volatile_v< Type > > > > | Internal class providing std::make_signed for integral types or enumeration types that are const and volatile qualified |
| Cmake_signed< Type, arene::base::constraints< enable_if_t< is_integral_v< Type >||is_enum_v< Type > >, enable_if_t< is_const_v< Type > >, enable_if_t<!is_volatile_v< Type > > > > | Internal class providing std::make_signed for integral types or enumeration types that are const qualified |
| Cmake_signed< Type, arene::base::constraints< enable_if_t< is_integral_v< Type >||is_enum_v< Type > >, enable_if_t< is_volatile_v< Type > >, enable_if_t<!is_const_v< Type > > > > | Internal class providing std::make_signed for integral types or enumeration types that are volatile qualified |
| Cmake_signed< unsigned char > | Internal class providing std::make_signed for unsigned char |
| Cmake_signed< unsigned int > | Internal class providing std::make_signed for unsigned int |
| Cmake_signed< unsigned long > | Internal class providing std::make_signed for long |
| Cmake_signed< unsigned long long > | Internal class providing std::make_signed for unsigned long long |
| Cmake_signed< unsigned short > | Internal class providing std::make_signed for unsigned short |
| Cmake_signed< wchar_t > | Internal class providing a signed type for wchar_t |
| Csized_signed | Internal class providing a signed type with a specified size |
| Csized_signed< Size, arene::base::constraints< enable_if_t< Size==sizeof(char)> > > | Internal class providing a signed type with the size of char |
| Csized_signed< Size, arene::base::constraints< enable_if_t< Size==sizeof(short)> > > | Internal class providing a signed type with the size of short |
| Csized_signed< Size, arene::base::constraints< enable_if_t<(Size > sizeof(int))>, enable_if_t< Size==sizeof(long)> > > | Internal class providing a signed type with the size of long |
| Csized_signed< Size, arene::base::constraints< enable_if_t<(Size > sizeof(long))>, enable_if_t< Size==sizeof(long long)> > > | Internal class providing a signed type with the size of long long |
| Csized_signed< Size, arene::base::constraints< enable_if_t<(Size > sizeof(short))>, enable_if_t< Size==sizeof(int)> > > | Internal class providing a signed type with the size of int |
| ►Nmake_unsigned_detail | |
| Cmake_unsigned | Internal class providing std::make_unsigned |
| Cmake_unsigned< char > | Internal class providing std::make_unsigned for char |
| Cmake_unsigned< char16_t > | Internal class providing an unsigned type for char16_t |
| Cmake_unsigned< char32_t > | Internal class providing an unsigned type for char32_t |
| Cmake_unsigned< int > | Internal class providing std::make_unsigned for int |
| Cmake_unsigned< long > | Internal class providing std::make_unsigned for long |
| Cmake_unsigned< long long > | Internal class providing std::make_unsigned for long long |
| Cmake_unsigned< short > | Internal class providing std::make_unsigned for short |
| Cmake_unsigned< signed char > | Internal class providing std::make_unsigned for signed char |
| Cmake_unsigned< Type, arene::base::constraints< enable_if_t< is_enum_v< Type > >, enable_if_t<!is_const_v< Type > >, enable_if_t<!is_volatile_v< Type > > > > | Internal class providing std::make_unsigned for integral types that are already unsigned |
| Cmake_unsigned< Type, arene::base::constraints< enable_if_t< is_integral_v< Type > >, enable_if_t<!is_signed_v< Type > >, enable_if_t<!is_same_v< Type, bool > >, enable_if_t<!is_const_v< Type > >, enable_if_t<!is_volatile_v< Type > > > > | Internal class providing std::make_unsigned for integral types that are already unsigned |
| Cmake_unsigned< Type, arene::base::constraints< enable_if_t< is_integral_v< Type >||is_enum_v< Type > >, enable_if_t< is_const_v< Type > >, enable_if_t< is_volatile_v< Type > > > > | Internal class providing std::make_unsigned for integral types or enumeration types that are const and volatile qualified |
| Cmake_unsigned< Type, arene::base::constraints< enable_if_t< is_integral_v< Type >||is_enum_v< Type > >, enable_if_t< is_const_v< Type > >, enable_if_t<!is_volatile_v< Type > > > > | Internal class providing std::make_unsigned for integral types or enumeration types that are const qualified |
| Cmake_unsigned< Type, arene::base::constraints< enable_if_t< is_integral_v< Type >||is_enum_v< Type > >, enable_if_t< is_volatile_v< Type > >, enable_if_t<!is_const_v< Type > > > > | Internal class providing std::make_unsigned for integral types or enumeration types that are volatile qualified |
| Cmake_unsigned< wchar_t > | Internal class providing an unsigned type for wchar_t |
| Csized_unsigned | Internal class providing an unsigned type with a specified size |
| Csized_unsigned< Size, arene::base::constraints< enable_if_t< Size==sizeof(char)> > > | Internal class providing an unsigned type with the size of char |
| Csized_unsigned< Size, arene::base::constraints< enable_if_t< Size==sizeof(short)> > > | Internal class providing an unsigned type with the size of short |
| Csized_unsigned< Size, arene::base::constraints< enable_if_t<(Size > sizeof(int))>, enable_if_t< Size==sizeof(long)> > > | Internal class providing an unsigned type with the size of long |
| Csized_unsigned< Size, arene::base::constraints< enable_if_t<(Size > sizeof(long))>, enable_if_t< Size==sizeof(long long)> > > | Internal class providing an unsigned type with the size of long long |
| Csized_unsigned< Size, arene::base::constraints< enable_if_t<(Size > sizeof(short))>, enable_if_t< Size==sizeof(int)> > > | Internal class providing an unsigned type with the size of int |
| ►Nnumeric_limits_detail | |
| Cint_info | Internal helper to define properties for integer types |
| Cint_info< 1 > | Internal helper to define properties for 1-byte integer types |
| Cint_info< 2 > | Internal helper to define properties for 2-byte integer types |
| Cint_info< 4 > | Internal helper to define properties for 4-byte integer types |
| Cint_info< 8 > | Internal helper to define properties for 8-byte integer types |
| Cnumeric_limits_impl | Implementation template for numeric_limits |
| Cnumeric_limits_impl< bool, arene::base::constraints<> > | Specialization of the implementation template for numeric_limits for bool |
| Cnumeric_limits_impl< double, arene::base::constraints<> > | Specialization of the implementation template for numeric_limits for double |
| Cnumeric_limits_impl< float, arene::base::constraints<> > | Specialization of the implementation template for numeric_limits for float |
| Cnumeric_limits_impl< T, arene::base::constraints< enable_if_t< is_integral_v< T > > > > | Specialization of the implementation template for numeric_limits for integral types |
| ►Npointer_traits_detail | |
| Cpointer_traits_difference_type | Determine the difference_type to expose in the pointer_traits |
| Cpointer_traits_difference_type< PointerLike, arene::base::constraints< enable_if_t< arene::base::substitution_succeeds< require_difference_type, PointerLike > > > > | Determine the difference_type to expose in the pointer_traits |
| Cpointer_traits_element_type | Determine the element_type to expose in pointer_traits |
| Cpointer_traits_element_type< PointerLike, arene::base::constraints< enable_if_t< has_element_type_v< PointerLike > > > > | Determine the element_type to expose in the pointer_traits |
| Cpointer_traits_element_type< PointerLike< T, Args... >, arene::base::constraints< enable_if_t<!has_element_type_v< PointerLike< T, Args... > > > > > | Determine the element_type to expose in the pointer_traits |
| Cpointer_traits_impl | Define pointer_traits as empty when is_element_type_defined_v<PointerLike> is false |
| Cpointer_traits_impl< PointerLike, arene::base::constraints< enable_if_t< is_element_type_defined_v< PointerLike > > > > | Define pointer_traits for the base case when is_element_type_defined_v is true |
| Cpointer_traits_rebind | Determine the rebind to expose in the pointer_traits |
| Cpointer_traits_rebind< PointerLike< T, Args... >, U, arene::base::constraints< enable_if_t<!has_rebind_v< PointerLike< T, Args... >, U > > > > | Determine the rebind to expose in the pointer_traits |
| Cpointer_traits_rebind< T, U, arene::base::constraints< enable_if_t< has_rebind_v< T, U > > > > | Determine the rebind to expose in the pointer_traits |
| Cunspecified | An unspecified type to use as the input type for pointer_to |
| ►Nratio_detail | |
| Cfraction | A type used to represent a fraction for non-template computations |
| Cis_ratio | A type trait to check if a type is a specialization of std::ratio as required in [ratio.general] |
| Cis_ratio< ratio< N, D > > | A type trait to check if a type is a specialization of std::ratio as required in [ratio.general] |
| Cratio_add_impl | A helper for addition to enforce the type requirement in [ratio.general] and improve readability |
| Cratio_equal_impl | A helper for equality comparison to enforce the type requirement in [ratio.general] |
| Cratio_less_impl | A helper for less-than comparison to enforce the type requirement in [ratio.general] |
| Cratio_multiply_impl | A helper for multiplication to enforce the type requirement in [ratio.general] and improve readability |
| ►Nreference_wrapper_detail | |
| Cmixin_argument_types | Add argument member types to reference wrapped functions and member function pointers. The types added depend on the number of arguments expected by the wrapped type. For member function pointers the class pointer is considered as the first argument |
| Cmixin_argument_types< arene::base::type_list< Arg > > | One argument case, will add argument_type |
| Cmixin_argument_types< arene::base::type_list< Arg1, Arg2 > > | Two argument case, will add first_argument_type and second_argument_type |
| Cmixin_class_binary_argument_type | Forward member types first_argument_type and second_argument_type from a reference wrapped class containing those member types, if present |
| Cmixin_class_binary_argument_type< T, arene::base::constraints< typename T::first_argument_type, typename T::second_argument_type > > | Case where first_argument_type and second_argument_type are present and forwarded |
| Cmixin_class_result_type | Forward member type result_type from a reference wrapped class containing that member type, if present |
| Cmixin_class_result_type< T, arene::base::constraints< typename T::result_type > > | Case where reference_type is present and forwarded |
| Cmixin_class_unary_argument_type | Forward member type argument_type from a reference wrapped class containing that member type, if present |
| Cmixin_class_unary_argument_type< T, arene::base::constraints< typename T::argument_type > > | Case where argument_type is present and forwarded |
| Cmixin_function_types | Add member types to reference_wrapper based on the underlying wrapped type |
| Cmixin_function_types< T, arene::base::constraints< std::enable_if_t< std::is_class_v< T > > > > | Wrapped class case, potentially forwards member types if present within the class |
| Cmixin_function_types< T, arene::base::constraints< std::enable_if_t< std::is_function_v< std::remove_pointer_t< T > > > > > | Wrapped function case, sets result_type based on the return type of the function and potentially types based on argument types |
| Cmixin_function_types< T, arene::base::constraints< std::enable_if_t< std::is_member_function_pointer_v< T > > > > | Wrapped member function pointer case, sets result_type based on the return type of the function and potentially types based on member class and argument types |
| ►Nstdexcept_detail | |
| Csimple_string | A simple string class that manages a static storage size C-style string |
| ►Ntuple_detail | |
| Care_all_arguments | Determine if a trait predicate is true for all pairs of T... and U.. |
| Care_all_arguments< Trait, arene::base::type_list< T... >, arene::base::type_list< U... >, enable_if_t< sizeof...(T)==sizeof...(U)> > | Determine if a trait predicate is true for all pairs of T... and U.. |
| Cconvert_reference_wrapper_like | Handles reference binding when initializing a reference from a forwarded argument |
| Cconvert_reference_wrapper_like< T, enable_if_t< is_reference_v< T > > > | Handles reference binding when initializing a reference from a forwarded argument |
| Ctuple_impl | Helper used in the implementation of a tuple |
| Ctuple_impl< index_sequence< I... >, arene::base::type_list< T... > > | Helper used in the implementation of a tuple |
| Ctuple_leaf | Single element of a tuple |
| ►Nunderlying_type_detail | |
| Cunderlying_type | Helper trait used to implement std::underlying_type |
| Cunderlying_type< T, arene::base::constraints< enable_if_t< is_enum_v< T > > > > | Helper trait specialization used to implement std::underlying_type if T is an enumeration type |
| Cadd_const | Add const to the provided type. The type member is an alias for the modified type |
| Cadd_cv | Add const and volatile to the provided type. The type member is an alias for the modified type |
| Cadd_pointer | Adds a pointer to the given type |
| Cadd_volatile | Add volatile to the provided type. The type member is an alias for the modified type |
| Cbidirectional_iterator_tag | An empty tag type corresponding to a bidirectional iterator |
| Cchar_traits | Forward declaration for the traits class to abstract character and string operations. No definition is provided |
| Ccommon_type | Primary template for determining the common type of a set of types |
| Ccommon_type< chrono::duration< Rep1, Period1 >, chrono::duration< Rep2, Period2 > > | Specialization of common_type for two duration types |
| Ccommon_type< T > | Specialization for a single type |
| Ccommon_type< T1, T2 > | Specialization for two types |
| Ccommon_type< T1, T2, Ts... > | Specialization for three or more types |
| Cconditional | Helper template for selecting types based on a condition. If the supplied Condition is true then the nested type member is an alias for TrueType otherwise it is an alias for FalseType |
| Cconditional< true, TrueType, FalseType > | Helper template for selecting types based on a condition. If the supplied Condition is true then the nested type member is an alias for TrueType otherwise it is an alias for FalseType |
| Cdecay | Contains type, a conversion equivalent to those performed when passing function arguments by value |
| Cdivides | Function object for performing division |
| Cdivides< void > | Function object that can be invoked for division, specialized for type deduction |
| Cenable_if | Class to support constraining templates. Has a type member of the specified type if the Condition is true and no type member if the Condition is false |
| Cenable_if< true, Type > | Specialization of a class to support constraining templates for the case that the condition is true which has a type member of the specified type |
| Cequal_to | Function object that can be invoked for equality comparisons |
| Cequal_to< void > | Function object that can be invoked for equality comparisons, specialized for type deduction |
| Cextent | Obtains the size of an array type along a specified dimension |
| Cforward_iterator_tag | An empty tag type corresponding to a forward iterator |
| Cgreater | Function object that can be invoked for greater than comparisons |
| Cgreater< void > | Function object that can be invoked for greater than comparisons, specialized for type deduction |
| Cgreater_equal | Function object that can be invoked for greater than or equal to comparisons |
| Cgreater_equal< void > | Function object that can be invoked for greater than or equal to comparisons, specialized for type deduction |
| Chash | Hash function primary template |
| Chash< arene::base::monostate > | Implementation of std::hash for arene::base::monostate |
| Chash<::arene::base::non_null< P > > | std::hash specialization for non_null |
| Chash<::arene::base::non_owning_ptr< T > > | std::hash specialization for non_owning_ptr. The hash is equivalent to the hash of the underlying pointer |
| Chash<::arene::base::result< V, E > > | Specialization of std::hash for arene::base::result |
| Chash<::arene::base::result< void, E > > | Specialization of std::hash for arene::base::result<void, E> |
| Cinitializer_list | Implementation of std::initializer_list for brace initialization |
| Cinput_iterator_tag | An empty tag type corresponding to an input iterator |
| Cinteger_sequence | Implements a compile-time sequence of integers |
| Cintegral_constant | A helper class to represent a compile-time constant with the specified type and value. Instances of the type are implicitly convertible to the specified type and are nullary-invocable, yielding the specified type. The result of such a conversion or invocation is the specified value. The value member is a constant of the specified type, holding the specified value |
| Cis_abstract | Type trait to detect if a type is an abstract class |
| Cis_arithmetic | A type trait to check if a type is arithmetic. The class is derived from true_type if Type is an arithmetic type, false_type otherwise |
| Cis_array | A type trait to check if a type is an array. The class is derived from true_type if Type is an array, false_type otherwise |
| Cis_assignable | Type trait to detect if an instance of To is assignable to from arguments of From |
| Cis_base_of | Type trait to detect if Base is a base class of Derived |
| Cis_class | A type trait to check if a type is a class. The class is derived from true_type if Type is a class, false_type otherwise |
| Cis_const | A type trait to check if a type is const. The class is derived from true_type if Type is const, false_type otherwise |
| Cis_constructible | Type trait to detect if a type is constructible from arguments of the specified types |
| Cis_convertible | Type trait to detect if one type is convertible to another |
| Cis_copy_assignable | Type trait to detect if an instance of T is copy assignable |
| Cis_copy_constructible | Type trait to detect if an instance of T is copy constructible |
| Cis_default_constructible | Type trait to detect if an instance of T is default constructible |
| Cis_destructible | Type trait to detect if a type is destructible |
| Cis_empty | Type trait to check if a type is an empty type. Derives from std::true_type if it is, std::false_type otherwise |
| Cis_enum | Type trait to check if a type is an enumeration. Derives from std::true_type if it is, std::false_type otherwise |
| Cis_final | Type trait to check if a type is a final class. Derives from std::true_type if it is, std::false_type otherwise |
| Cis_floating_point | A type trait to check if a type is floating point. The class is derived from true_type if Type is a floating point type, false_type otherwise |
| Cis_function | A type trait to check if a type is a function. The class is derived from true_type if Type is a function, false_type otherwise |
| Cis_fundamental | Check if the supplied template argument is a fundamental type or not. The value member is true if so, false otherwise |
| Cis_integral | A type trait to check if a type is integral. The class is derived from true_type if Type is an integral type, false_type otherwise |
| Cis_lvalue_reference | Check if the supplied template argument is an lvalue reference or not. The value member is true if so, false otherwise |
| Cis_member_function_pointer | Check if the supplied template argument is a member function pointer or not. The value is true if so, false otherwise |
| Cis_member_object_pointer | Check if the supplied template argument is a member object pointer or not. The value is true if so, false otherwise |
| Cis_member_pointer | Check if the supplied template argument is a member pointer or not. The value is true if so, false otherwise |
| Cis_move_assignable | Type trait to detect if an instance of T is move assignable |
| Cis_move_constructible | Type trait to detect if an instance of T is move constructible |
| Cis_nothrow_assignable | Type trait to detect if an instance of To is assignable to from arguments of From without throwing |
| Cis_nothrow_constructible | Type trait to detect if a type is constructible from arguments of the specified types and is noexcept |
| Cis_nothrow_copy_assignable | Type trait to detect if an instance of T is copy assignable without throwing |
| Cis_nothrow_copy_constructible | Type trait to detect if an instance of T is copy constructible without throwing |
| Cis_nothrow_default_constructible | Type trait to detect if an instance of T is default constructible without throwing |
| Cis_nothrow_destructible | Type trait to detect if a type is destructible without throwing an exception |
| Cis_nothrow_move_assignable | Type trait to detect if an instance of T is move assignable without throwing |
| Cis_nothrow_move_constructible | Type trait to detect if an instance of T is move constructible without throwing |
| Cis_object | Check if the supplied template argument is an object or not. The value member is true if so, false otherwise |
| Cis_pointer | Check if the supplied template argument is a pointer or not. The value is true if so, false otherwise |
| Cis_reference | Check if the supplied template argument is a reference or not. The value member is true if so, false otherwise |
| Cis_rvalue_reference | Check if the supplied template argument is an rvalue reference or not. The value member is true if so, false otherwise |
| Cis_same | Trait to detect if the two template parameters are the same or not. The value member is true if the types are the same, false otherwise |
| Cis_signed | A type trait to check if a type is signed. The class is derived from true_type if Type is a signed type, false_type otherwise |
| Cis_trivially_copy_assignable | Type trait to detect if an instance of T is trivially copy assignable |
| Cis_trivially_copy_constructible | Type trait to detect if an instance of T is trivially copy constructible |
| Cis_trivially_copyable | Type trait to detect if an instance of T is trivially copyable |
| Cis_trivially_default_constructible | Type trait to detect if an instance of T is trivially default constructible |
| Cis_trivially_destructible | Type trait to detect if a type is trivially destructible |
| Cis_trivially_move_assignable | Type trait to detect if an instance of T is move assignable without throwing |
| Cis_trivially_move_constructible | Type trait to detect if an instance of T is trivially move constructible |
| Cis_unsigned | A type trait to check if a type is unsigned. The class is derived from true_type if Type is an unsigned type, false_type otherwise |
| Cis_void | A type trait to check if a type is void. The class is derived from true_type if Type is void, false_type otherwise |
| Cis_volatile | A type trait to check if a type is volatile. The class is derived from true_type if Type is volatile, false_type otherwise |
| Citerator | Base class to ease the definition of required types for simple iterators |
| Citerator_traits | Uniform interface to the properties of an iterator |
| Citerator_traits< T * > | Specialization for pointer to non-const type |
| Citerator_traits< T const * > | Specialization for pointer to const type |
| Cless | Function object that can be invoked for less than comparisons |
| Cless< void > | Function object that can be invoked for less than comparisons, specialized for type deduction |
| Cless_equal | Function object that can be invoked for less than or equal to comparisons |
| Cless_equal< void > | Function object that can be invoked for less than or equal to comparisons, specialized for type deduction |
| Clogical_and | Function object for performing logical AND (logical conjunction). Effectively calls operator&& on type T |
| Clogical_and< void > | Function object for performing logical AND (logical conjunction), specialized for deduction of parameter and return type |
| Clogical_or | Function object for performing logical OR (logical disjunction). Effectively calls operator|| on type T |
| Clogical_or< void > | Function object for performing logical OR (logical conjunction), specialized for deduction of parameter and return type |
| Cminus | Function object for performing subtraction |
| Cminus< void > | Function object that can be invoked for subtraction, specialized for type deduction |
| Cmodulus | Function object for performing modulus |
| Cmodulus< void > | Function object that can be invoked for modulus, specialized for type deduction |
| Cmove_iterator | An iterator adaptor that wraps another iterator such that dereferencing the wrapped iterator yields an rvalue reference to the source value |
| Cmultiplies | Function object for performing multiplication |
| Cmultiplies< void > | Function object that can be invoked for multiplication, specialized for type deduction |
| Cnegate | Function object for performing negation |
| Cnegate< void > | Function object that can be invoked for negate, specialized for type deduction |
| Cnot_equal_to | Function object that can be invoked for non-equality comparisons |
| Cnot_equal_to< void > | Function object that can be invoked for non-equality comparisons, specialized for type deduction |
| Cnothrow_t | Tag type used to disambiguate the overloads of throwing and non-throwing allocation functions |
| Cnumeric_limits | Traits class to provide information about the representation of arithmetic types |
| Cnumeric_limits< T const > | Traits class to provide information about the representation of arithmetic types |
| Cnumeric_limits< T const volatile > | Traits class to provide information about the representation of arithmetic types |
| Cnumeric_limits< T volatile > | Traits class to provide information about the representation of arithmetic types |
| Coutput_iterator_tag | An empty tag type corresponding to an output iterator |
| Cpiecewise_construct_t | Tag type for piecewise construction |
| Cplus | Function object for performing addition |
| Cplus< void > | Function object that can be invoked for addition, specialized for type deduction |
| Cpointer_traits | Uniform interface to pointer-like types |
| Cpointer_traits< T * > | pointer_traits specialization to handle raw pointer types |
| Crandom_access_iterator_tag | An empty tag type corresponding to a random access iterator |
| Crank | Obtains the number of dimensions of an array type |
| Cratio | A compile-time ratio of two integers, automatically reduced to lowest terms |
| Cratio_equal | Inherits from true_type if the first ratio is equal to the second, false_type if not |
| Cratio_greater | Inherits from true_type if the first ratio is greater than the second, false_type if not |
| Cratio_greater_equal | Inherits from true_type if the first ratio is greater than or equal to the second, false_type if not |
| Cratio_less | Inherits from true_type if the first ratio is less than the second, false_type if not |
| Cratio_less_equal | Inherits from true_type if the first ratio is less than or equal to the second, false_type if not |
| Cratio_not_equal | Inherits from true_type if the first ratio is not equal to the second, false_type if they are equal |
| Creference_wrapper | Wraps a reference in a copyable and assignable object |
| Cremove_all_extents | Removes all extents from the given array type |
| Cremove_all_extents< T[]> | Removes all extents from the given array type |
| Cremove_all_extents< T[N]> | Removes all extents from the given array type |
| Cremove_const | Remove const from the provided type. The type member is an alias for the modified type |
| Cremove_const< Type const > | Remove const from the provided type. The type member is an alias for the modified type |
| Cremove_cv | The type member is an alias for T, but with top-level const and/or volatile qualifiers removed |
| Cremove_cv< T const > | The type member is an alias for T, but with top-level const and/or volatile qualifiers removed |
| Cremove_cv< T const volatile > | The type member is an alias for T, but with top-level const and/or volatile qualifiers removed |
| Cremove_cv< T volatile > | The type member is an alias for T, but with top-level const and/or volatile qualifiers removed |
| Cremove_extent | Removes the first extent from the given array type |
| Cremove_extent< T[]> | Removes the first extent from the given array type |
| Cremove_extent< T[N]> | Removes the first extent from the given array type |
| Cremove_pointer | The type member is an alias for the type pointed to by T, or the same as T if it is not a pointer |
| Cremove_pointer< T * > | The type member is an alias for the type pointed to by T, or the same as T if it is not a pointer |
| Cremove_pointer< T *const > | The type member is an alias for the type pointed to by T, or the same as T if it is not a pointer |
| Cremove_pointer< T *const volatile > | The type member is an alias for the type pointed to by T, or the same as T if it is not a pointer |
| Cremove_pointer< T *volatile > | The type member is an alias for the type pointed to by T, or the same as T if it is not a pointer |
| Cremove_reference | The type member is an alias for T, but with top-level reference qualifiers removed |
| Cremove_reference< T & > | The type member is an alias for T, but with top-level reference qualifiers removed |
| Cremove_reference< T && > | The type member is an alias for T, but with top-level reference qualifiers removed |
| Cremove_volatile | Remove volatile from the provided type. The type member is an alias for the modified type |
| Cremove_volatile< Type volatile > | Remove volatile from the provided type. The type member is an alias for the modified type |
| Ctuple | Heterogeneous, fixed-size collection of values |
| Ctuple_element | Obtains the type of the specified element |
| Ctuple_element< 0, pair< T1, T2 > > | Obtain the first type of a pair |
| Ctuple_element< 1, pair< T1, T2 > > | Obtain the second type of a pair |
| Ctuple_element< I, arene::base::type_list< Tn... > > | A meta function to retrieve the specified element from a type list |
| Ctuple_element< I, T const > | Obtains the type of the specified element |
| Ctuple_element< I, T const volatile > | Obtains the type of the specified element |
| Ctuple_element< I, T volatile > | Obtains the type of the specified element |
| Ctuple_element< I, tuple< Types... > > | Obtain the element type at a given index |
| Ctuple_element< N, arene::base::array< T, ArrN > > | Specialization of std::tuple_element for arene::base::array |
| Ctuple_size | Obtain the number of elements in a tuple-like type |
| Ctuple_size< arene::base::array< T, N > > | Specialization of std::tuple_size for arene::base::array |
| Ctuple_size< arene::base::type_list< Tn... > > | Specialize tuple_size for type_list |
| Ctuple_size< pair< T1, T2 > > | Obtain the size of a pair |
| Ctuple_size< T const > | Obtain the number of elements in a tuple-like type |
| Ctuple_size< T const volatile > | Obtain the number of elements in a tuple-like type |
| Ctuple_size< T volatile > | Obtain the number of elements in a tuple-like type |
| Ctuple_size< tuple< Types... > > | Obtain the number of elements in a tuple-like type |
1.13.2