Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 1234]

►CAdaptorMixin
Cstd::basic_insert_iterator_detail::basic_insert_iterator< Container, AdaptorMixin >	Iterator adaptor for insertion into a container
►Carene::base::array< T, N >	A fixed-size array of T objects
Carene::base::extents< std::uint16_t, 1, 2, 3, 4 >
►Carene::base::array< IndexType, mdspan_detail::extent_sequence< Extents... >::rank_dynamic >
Carene::base::extents< IndexType,(static_cast< void >(Is), dynamic_extent)... >
Carene::base::extents< IndexType, Extents >	Multidimensional index space
►Carene::base::array< inline_container::detail::unsafe_element_storage< T >, Capacity >
►Carene::base::inline_deque_detail::inline_deque_internal_storage< T, Capacity, AllowWrapping, bool >	Base class for inline_deque that holds the elements
►Carene::base::inline_deque_detail::inline_deque_impl< T, Capacity, true >
Carene::base::circular_buffer< T, Capacity >	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
►Carene::base::inline_deque_detail::inline_deque_impl< T, Capacity, false >
Carene::base::inline_deque< T, Capacity >	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
Carene::base::array< T, 0 >	Specialize for zero-sized arrays as 'T array[0]' is not standards compliant
Carene::base::array< T, Capacity >
Carene::base::atomic_monotonic_counter	A thread-safe atomic counter
Carene::base::barrier< CompletionFunction >	A backport of std::barrier from C++20
Carene::base::barrier< CompletionFunction >::arrival_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
Carene::base::const_vector_reference< T >	A const reference class to an inline_vector object, with size-erased type
►Carene::base::default_accessor< ElementType >	Accesses a single element from a pointer and an index
Carene::base::mdspan< ElementType, Extents, LayoutPolicy, AccessorPolicy >	A multidimensional view of elements over a contiguous sequence of elements
►Carene::base::ebo_holder< Tag, Value, bool >	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
Cstd::tuple_detail::tuple_leaf< I, tuple_element_t< I, Tuple > >
Carene::base::ebo_holder< bound_args_tag< perfect_forward_call_wrapper< not_fn_policy, BoundFunc, BoundArgs... > >, std::tuple< BoundArgs... > >
Carene::base::ebo_holder< bound_args_tag< perfect_forward_call_wrapper< Policy, Func, BoundArgs... > >, std::tuple< BoundArgs... > >
►Carene::base::ebo_holder< integral_constant< size_t, I >, remove_const_t< T > >
►Cstd::tuple_detail::tuple_leaf< I, T, class >	Single element of a tuple
Cstd::tuple_detail::tuple_impl< index_sequence< I... >, arene::base::type_list< T... > >	Helper used in the implementation of a tuple
Carene::base::ebo_holder< invoke_tag< perfect_forward_call_wrapper< not_fn_policy, BoundFunc, BoundArgs... > >, BoundFunc >
Carene::base::ebo_holder< invoke_tag< perfect_forward_call_wrapper< Policy, Func, BoundArgs... > >, Func >
Carene::base::error_result_t< ErrorType >	Intermediary type for constructing a result with a given error_type
Carene::base::extent_slice< OffsetType, ExtentType, StrideType >	Set of extent regularly spaced integer indices
►Carene::base::external_vector_detail::external_storage_base< ValueType >	Base class for vector_interface that redirects via the storage_base base class of the derived class to access the external storage
►Carene::base::inline_vector_detail::vector_interface< external_vector_detail::external_storage_base< T > >
Carene::base::external_vector< T >	Container similar to std::vector<T> that uses an external buffer for storage
►Carene::base::external_vector_detail::storage_base< T >	Storage base class for external_vector
Carene::base::external_vector< ValueType >
Carene::base::external_vector< T >	Container similar to std::vector<T> that uses an external buffer for storage
Carene::base::filesystem::directory_handle	Class to wrap a directory handle
Carene::base::filesystem::error_code	A class representing a filesystem error value. Intended to be a wrapper around errno
Carene::base::filesystem::file_handle	An RAII wrapper around a POSIX file handle with unique-ownership semantics
Carene::base::filesystem::scoped_change_directory	A RAII helper to temporarily change the working directory of the process
Carene::base::filesystem::temporary_directory	An RAII helper class to manage a temporary directory
Carene::base::full_extent_t	Tag class specifying the full extent of an mdspan
Carene::base::function_ref< Signature, IsNoexcept >	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
►Carene::base::function_ref_detail::function_ref_base< false, IsNoexcept, R, Args... >
Carene::base::function_ref< R(Args...), IsNoexcept >	This specialization handles non-const-qualified function signatures
►Carene::base::generic_ordering_from_three_way_compare< Derived >	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
Carene::base::reverse_iterator< iterator >
Carene::base::reverse_iterator< const_iterator >
►Carene::base::generic_ordering_from_three_way_compare< const_inline_string_reference >
Carene::base::const_inline_string_reference	A const reference class to an inline_string object, with size-erased type
►Carene::base::generic_ordering_from_three_way_compare< inline_set< Value, Capacity, compare_three_way > >
Carene::base::inline_set< Value, Capacity, Compare >	A non-allocating fixed-capacity associative container storing elements of type Value
►Carene::base::generic_ordering_from_three_way_compare< inline_string< MaxSize > >
Carene::base::inline_string< PATH_MAX >
Carene::base::inline_string< max_error_length >
Carene::base::inline_string< relative_path_length >
Carene::base::inline_string< MaxSize >	A string type with a fixed maximum capacity, where the data is stored internally without allocations
►Carene::base::generic_ordering_from_three_way_compare< inline_string_reference >
Carene::base::inline_string_reference	A reference class to an inline_string object, with size-erased type
►Carene::base::generic_ordering_from_three_way_compare< null_terminated_string_view >
Carene::base::null_terminated_string_view	A read-only string-view that provides a view onto a null-terminated string
►Carene::base::generic_ordering_from_three_way_compare< quantity< QuantityType, Rep > >
Carene::base::quantity< QuantityType, Rep >	A class representing a quantity of a physical units type
►Carene::base::generic_ordering_from_three_way_compare< reverse_iterator< Itr > >
Carene::base::reverse_iterator< Itr, true >	A backport of the constexpr std::reverse_iterator from C++17
Carene::base::reverse_iterator< Itr, bool >	A backport of the constexpr std::reverse_iterator from C++17
Carene::base::reverse_iterator< Itr, true >	A backport of the constexpr std::reverse_iterator from C++17
►Carene::base::generic_ordering_from_three_way_compare< semantic_version >
Carene::base::semantic_version	A class representing semantic versions (https://semver.org/). Does not include build metadata or prerelease comparisons
►Carene::base::generic_ordering_from_three_way_compare< string_view >
Carene::base::string_view	Backport of the C++17 std::string_view class
►Carene::base::generic_ordering_from_three_way_compare_and_equals< Derived >	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
Carene::base::non_null< T * >
Carene::base::optional< Value >
Carene::base::optional< value_type >
►Carene::base::generic_ordering_from_three_way_compare_and_equals< inline_map< Key, Value, Capacity, compare_three_way > >
Carene::base::inline_map< Key, Value, Capacity, Compare >	A container similar to std::map that has a fixed capacity
►Carene::base::generic_ordering_from_three_way_compare_and_equals< non_null< P > >
Carene::base::non_null< P >	A pointer type which is never nullptr
►Carene::base::generic_ordering_from_three_way_compare_and_equals< optional< arene::base::testing::property_error > >
Carene::base::optional< arene::base::testing::property_error >
►Carene::base::generic_ordering_from_three_way_compare_and_equals< optional< T > >
Carene::base::optional< T >	Implementation of std::optional for pre-C++17 compilers, and which replaces defined undefined behavior with ARENE_PRECONDITION guards
Carene::base::give_cv_to< From, To >	Add the cv qualification from one type to another
Carene::base::give_cvref_to< From, To >	Add the cv-ref qualification from one type to another
►Carene::base::identity	A backport of the C++20 std::identity function object. It returns its input unchanged
Cstd::tuple_detail::convert_reference_wrapper_like< T, enable_if_t< is_reference_v< T > > >	Handles reference binding when initializing a reference from a forwarded argument
Cstd::tuple_detail::convert_reference_wrapper_like< T, class >	Handles reference binding when initializing a reference from a forwarded argument
►Carene::base::implicit_constructor_base< T, bool, bool, bool, bool >	A class that has the same implicit constructors as another type
Carene::base::optional< Value >
Carene::base::optional< value_type >
Carene::base::optional< T >	Implementation of std::optional for pre-C++17 compilers, and which replaces defined undefined behavior with ARENE_PRECONDITION guards
►Carene::base::implicit_constructor_base< arene::base::testing::property_error >
Carene::base::optional< arene::base::testing::property_error >
Carene::base::in_place_index_t< I >	Backport of std::in_place_index_t<size_t> from C++17
Carene::base::in_place_t	Backport of std::in_place_t from C++17
Carene::base::in_place_type_t< T >	Backport of std::in_place_type_t<T> from C++17
►Carene::base::inline_deque_detail::ring_buffer_indices< Capacity, AllowWrapping >	Ring-buffer indices independent of the contained value type
Carene::base::inline_deque_detail::inline_deque_internal_storage< T, Capacity, AllowWrapping, bool >	Base class for inline_deque that holds the elements
►Carene::base::inline_deque_detail::storage_wrapping_interface< inline_deque_internal_storage< T, Capacity, AllowWrapping >, AllowWrapping >
Carene::base::inline_deque_detail::inline_deque_internal_storage< T, Capacity, AllowWrapping, bool >	Base class for inline_deque that holds the elements
Carene::base::inline_function< Signature, BufferSize, IsNoexcept >	A function wrapper akin to std::function that always stores the wrapped invocable internally
►Carene::base::inline_function_detail::inline_function_base< BufferSize, false, IsNoexcept, ReturnType, Args... >
Carene::base::inline_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
►Carene::base::inline_function_detail::inline_function_base< BufferSize, true, IsNoexcept, ReturnType, Args... >
Carene::base::inline_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
►Carene::base::inline_map_detail::inline_map_base< Key, Value, compare_three_way >
Carene::base::inline_map< Key, Value, Capacity, Compare >	A container similar to std::map that has a fixed capacity
►Carene::base::inline_map_detail::inline_map_passkey_base< MapBase >	Private access for the family of types related to an inline_map
Carene::base::inline_map_reference_iterator< MapBase, false >
Carene::base::inline_map_reference_iterator< MapBase, true >
Carene::base::inline_map_reference_iterator< MapBase, IsConst >	Iterator type used by inline_map_reference and const_inline_map_reference
►Carene::base::inline_map_detail::inline_map_passkey_base< inline_map_detail::inline_map_base< Key, Value, compare_three_way > >
Carene::base::inline_map< Key, Value, Capacity, Compare >	A container similar to std::map that has a fixed capacity
►Carene::base::inline_map_detail::inline_map_passkey_base< map_base_type >
Carene::base::inline_map_reference_iterator< map_base_type, false >
Carene::base::inline_map_reference_iterator< map_base_type, true >
►Carene::base::inline_map_reference_detail::const_inline_map_reference_interface< const_inline_map_reference< Key, Value, Compare > >
Carene::base::const_inline_map_reference< Key, Value, Compare >	A const reference class to an inline_map object, with size-erased type
►Carene::base::inline_map_reference_detail::const_inline_map_reference_interface< inline_map_reference< Key, Value, Compare > >
Carene::base::inline_map_reference< Key, Value, Compare >	A reference class to an inline_map object, with size-erased type
►Carene::base::inline_string_detail::inline_string_base	Base class for inline_string which detemplatizes functionality not dependent on the buffer size
Carene::base::inline_string< PATH_MAX >
Carene::base::inline_string< max_error_length >
Carene::base::inline_string< relative_path_length >
Carene::base::inline_string< MaxSize >	A string type with a fixed maximum capacity, where the data is stored internally without allocations
►Carene::base::inline_vector_detail::inline_vector_internal_non_constexpr_storage< T, Capacity, bool >	Base class for inline_vector that holds the elements when the elements aren't usable in constexpr contexts
►Carene::base::inline_vector_detail::inline_vector_internal_storage< T, Capacity, bool >	Base class for inline_vector that holds the elements
►Carene::base::inline_vector_detail::vector_interface< inline_vector_detail::inline_vector_internal_storage< T, Capacity > >
Carene::base::inline_vector< T, OtherCapacity >
Carene::base::inline_vector< T, Capacity >	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
►Carene::base::inline_vector_detail::vector_base< T >	Implementation details for inline_vector which depend on neither the capacity nor the storage mechanism
Carene::base::inline_vector_detail::vector_interface< inline_vector_detail::inline_vector_internal_storage< T, Capacity > >
Carene::base::inline_vector_detail::vector_interface< external_vector_detail::external_storage_base< T > >
►Carene::base::inline_vector_detail::vector_base< Storage::value_type >
►Carene::base::inline_vector_detail::vector_interface< Storage >	Interface to the storage for inline_vector
Carene::base::external_vector< ValueType >
Carene::base::inline_vector< ValueType, capacity >
Carene::base::integer_sequence_element< Index, Sequence, bool >	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
Carene::base::integer_sequence_index_of< Sequence, Value, bool >	Trait for the index of the first occurrence of a value in a std::integer_sequence
Carene::base::intrusive::binary_tree_node< Tag >	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
Carene::base::intrusive::priority_queue< T, Compare, Tag >	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
Carene::base::intrusive::queue< T, Tag >	Intrusive queue implementation
Carene::base::intrusive::singly_linked_node< Tag >	Singly linked hook. User type can be derived from this class to support intrusive containers
►Carene::base::is_invocable_detail::invoke_result< Fn, type_list< Args... > >
Carene::base::invoke_result< Fn, Args >	Determines the return type of a functor invoked with the specified arguments
Carene::base::latch	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
►Carene::base::linalg::math_traits_impl::default_math_traits< T, typename >	Default implementation of math_traits which uses member typedefs for mdspan and is empty for other T
Carene::base::linalg::math_traits< T >	A traits struct allowing SFINAE-friendly access to the properties of types which may be linalg objects
Carene::base::manual_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
Carene::base::monostate	A monostate type that is a well-behaved empty value for variants
Carene::base::non_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
Carene::base::null_terminated_string_view::sentinel	This type represents the sentinel of the range of characters
Carene::base::nullopt_t	Empty class type used to indicate that arene::base::optional does not contain a value
►Carene::base::operators_detail::inequality_operator_mixin< Derived, Derived >
►Carene::base::full_equality_operators_from_basic_equality< Derived, Derived >
►Carene::base::full_ordering_operators_from_less_than_and_equals< Derived, Derived >
Carene::base::full_ordering_operators_from_less_than< Derived, Other >	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
►Carene::base::full_ordering_operators_from_less_than_and_equals< Derived, Other >	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
Carene::base::inline_vector< ValueType, capacity >
Carene::base::full_equality_operators_from_basic_equality< Derived, Derived >
►Carene::base::full_equality_operators_from_basic_equality< Derived, Other >	Helper class that can be inherited from by a class to define the != operator in terms of the == operator defined by that class
►Carene::base::full_ordering_operators_from_less_than_and_equals< non_owning_ptr< T > >
Carene::base::non_owning_ptr< T >	A non-owning, nullable pointer with nullptr checks on dereference
Carene::base::full_equality_operators_from_basic_equality< Derived, Other >	Helper class that can be inherited from by a class to define the != operator in terms of the == operator defined by that class
►Carene::base::operators_detail::inequality_operator_mixin< inline_vector< T, Capacity >, inline_vector< T, Capacity > >
►Carene::base::full_equality_operators_from_basic_equality< inline_vector< T, Capacity >, inline_vector< T, Capacity > >
►Carene::base::full_ordering_operators_from_less_than_and_equals< inline_vector< T, Capacity > >
Carene::base::inline_vector< T, OtherCapacity >
Carene::base::inline_vector< T, Capacity >	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
Carene::base::full_equality_operators_from_basic_equality< inline_vector< T, Capacity >, inline_vector< T, Capacity > >
►Carene::base::operators_detail::inequality_operator_mixin< variant< Ts... >, variant< Ts... > >
►Carene::base::full_equality_operators_from_basic_equality< variant< Ts... >, variant< Ts... > >
►Carene::base::full_ordering_operators_from_less_than_and_equals< variant< Ts... > >
Carene::base::variant< Ts >	Forward declaration of variant
Carene::base::full_equality_operators_from_basic_equality< variant< Ts... >, variant< Ts... > >
►Carene::base::operators_detail::ordering_operators_from_less_than_mixin< LhsType, RhsType >	Helper class to define >, <= and >= operators in terms of the < operator with a left-hand operand of type LhsType and a right-hand operand of type RhsType
Carene::base::full_ordering_operators_from_less_than_and_equals< non_owning_ptr< T > >
Carene::base::full_ordering_operators_from_less_than_and_equals< non_owning_ptr< T > >
►Carene::base::operators_detail::ordering_operators_from_less_than_mixin< Derived, Derived >
Carene::base::full_ordering_operators_from_less_than_and_equals< Derived, Derived >
Carene::base::full_ordering_operators_from_less_than_and_equals< Derived, Derived >
Carene::base::full_ordering_operators_from_less_than_and_equals< Derived, Other >	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
Carene::base::full_ordering_operators_from_less_than_and_equals< Derived, Other >	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
►Carene::base::operators_detail::ordering_operators_from_less_than_mixin< inline_vector< T, Capacity >, inline_vector< T, Capacity > >
Carene::base::full_ordering_operators_from_less_than_and_equals< inline_vector< T, Capacity > >
Carene::base::full_ordering_operators_from_less_than_and_equals< inline_vector< T, Capacity > >
►Carene::base::operators_detail::ordering_operators_from_less_than_mixin< variant< Ts... >, variant< Ts... > >
Carene::base::full_ordering_operators_from_less_than_and_equals< variant< Ts... > >
Carene::base::full_ordering_operators_from_less_than_and_equals< variant< Ts... > >
Carene::base::optional_resetter< Value >	A simple class that resets an optional value in its destructor, unless dismissed
Carene::base::priority_tag< N >	A priority tag for overload resolution
Carene::base::priority_tag< std::size_t{0}>	A priority tag for overload resolution
►Carene::base::quantity_kind_detail::quantity_kind_origin_mixin< OptionalOrigin >
►Carene::base::quantity_kind_detail::quantity_kind_base< Derived, OptionalParentKind, OptionalOrigin, OptionalUnit >	Base class for declaring a quantity kind
Carene::base::quantity_unit< combined_quantity_kind< BaseKinds... >, combine_kinds_t< unit_kind_t< BaseKinds >... > >
►Carene::base::quantity_kind_detail::quantity_kind_origin_mixin< units_detail::missing >	Mixin base class for declaring the origin of a quantity kind
►Carene::base::quantity_kind_detail::quantity_kind_base< Tag, Kind, units_detail::missing, units_detail::missing >
Carene::base::quantity_unit< Tag, Kind >	Base class for declaring a quantity unit
►Carene::base::quantity_kind_detail::quantity_kind_base< ampere, electric_current, units_detail::missing, units_detail::missing >
►Carene::base::quantity_unit< ampere, electric_current >
Carene::base::units::ampere	The SI base quantity unit for electric current
►Carene::base::quantity_kind_detail::quantity_kind_base< angular_degree, scaled_unit< scaled_unit< radian, inverse_unit_scale_t< scales::pi > >, std::ratio< 180, 1 > >, units_detail::missing, units_detail::missing >
►Carene::base::quantity_unit< angular_degree, scaled_unit< scaled_unit< radian, inverse_unit_scale_t< scales::pi > >, std::ratio< 180, 1 > > >
Carene::base::units::angular_degree	A quantity unit for angular_measure
►Carene::base::quantity_kind_detail::quantity_kind_base< candela, luminous_intensity, units_detail::missing, units_detail::missing >
►Carene::base::quantity_unit< candela, luminous_intensity >
Carene::base::units::candela	The SI base quantity unit for luminous intensity
►Carene::base::quantity_kind_detail::quantity_kind_base< gram, mass, units_detail::missing, units_detail::missing >
►Carene::base::quantity_unit< gram, mass >
Carene::base::units::gram	A quantity unit for mass
►Carene::base::quantity_kind_detail::quantity_kind_base< kelvin, thermodynamic_temperature, units_detail::missing, units_detail::missing >
►Carene::base::quantity_unit< kelvin, thermodynamic_temperature >
Carene::base::units::kelvin	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
►Carene::base::quantity_kind_detail::quantity_kind_base< meter, length, units_detail::missing, units_detail::missing >
►Carene::base::quantity_unit< meter, length >
Carene::base::units::meter	The SI base quantity unit for length
►Carene::base::quantity_kind_detail::quantity_kind_base< mole, amount_of_substance, units_detail::missing, units_detail::missing >
►Carene::base::quantity_unit< mole, amount_of_substance >
Carene::base::units::mole	The SI base quantity unit for amount of substance
►Carene::base::quantity_kind_detail::quantity_kind_base< radian, angular_measure, units_detail::missing, units_detail::missing >
►Carene::base::quantity_unit< radian, angular_measure >
Carene::base::units::radian	A quantity unit for angular_measure
►Carene::base::quantity_kind_detail::quantity_kind_base< second, time, units_detail::missing, units_detail::missing >
►Carene::base::quantity_unit< second, time >
Carene::base::units::second	The SI base quantity unit for time
►Carene::base::quantity_kind_detail::quantity_kind_base< quantity_kind_with_exponent< Kind, PositiveExponent, NegativeExponent >, Kind, units_detail::missing, units_detail::missing >
Carene::base::quantity_unit< quantity_kind_with_exponent< Kind, PositiveExponent, NegativeExponent >, kind_with_exponent_helper< Kind::parent_quantity_kind_type, PositiveExponent, NegativeExponent >::type >
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< amount_of_substance >
Carene::base::quantity_kind_detail::quantity_kind_base< mole, amount_of_substance, units_detail::missing, units_detail::missing >
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< angular_measure >
Carene::base::quantity_kind_detail::quantity_kind_base< radian, angular_measure, units_detail::missing, units_detail::missing >
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< electric_current >
Carene::base::quantity_kind_detail::quantity_kind_base< ampere, electric_current, units_detail::missing, units_detail::missing >
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< Kind >
Carene::base::quantity_kind_detail::quantity_kind_base< Tag, Kind, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< quantity_kind_with_exponent< Kind, PositiveExponent, NegativeExponent >, Kind, units_detail::missing, units_detail::missing >
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< length >
Carene::base::quantity_kind_detail::quantity_kind_base< meter, length, units_detail::missing, units_detail::missing >
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< luminous_intensity >
Carene::base::quantity_kind_detail::quantity_kind_base< candela, luminous_intensity, units_detail::missing, units_detail::missing >
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< mass >
Carene::base::quantity_kind_detail::quantity_kind_base< gram, mass, units_detail::missing, units_detail::missing >
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< OptionalParentKind >
Carene::base::quantity_kind_detail::quantity_kind_base< Derived, OptionalParentKind, OptionalOrigin, OptionalUnit >	Base class for declaring a quantity kind
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< scaled_unit< scaled_unit< radian, inverse_unit_scale_t< scales::pi > >, std::ratio< 180, 1 > > >
Carene::base::quantity_kind_detail::quantity_kind_base< angular_degree, scaled_unit< scaled_unit< radian, inverse_unit_scale_t< scales::pi > >, std::ratio< 180, 1 > >, units_detail::missing, units_detail::missing >
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< thermodynamic_temperature >
Carene::base::quantity_kind_detail::quantity_kind_base< kelvin, thermodynamic_temperature, units_detail::missing, units_detail::missing >
►Carene::base::quantity_kind_detail::quantity_kind_parent_mixin< time >
Carene::base::quantity_kind_detail::quantity_kind_base< second, time, units_detail::missing, units_detail::missing >
►Carene::base::quantity_kind_detail::quantity_kind_unit_mixin< OptionalUnit >
Carene::base::quantity_kind_detail::quantity_kind_base< Derived, OptionalParentKind, OptionalOrigin, OptionalUnit >	Base class for declaring a quantity kind
►Carene::base::quantity_kind_detail::quantity_kind_unit_mixin< units_detail::missing >	Mixin base class for declaring the unit of a quantity kind
Carene::base::quantity_kind_detail::quantity_kind_base< Tag, Kind, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< ampere, electric_current, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< angular_degree, scaled_unit< scaled_unit< radian, inverse_unit_scale_t< scales::pi > >, std::ratio< 180, 1 > >, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< candela, luminous_intensity, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< gram, mass, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< kelvin, thermodynamic_temperature, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< meter, length, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< mole, amount_of_substance, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< radian, angular_measure, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< second, time, units_detail::missing, units_detail::missing >
Carene::base::quantity_kind_detail::quantity_kind_base< quantity_kind_with_exponent< Kind, PositiveExponent, NegativeExponent >, Kind, units_detail::missing, units_detail::missing >
Carene::base::quantity_origin< Derived >	CRTP base class used when defining a new quantity origin, e.g. absolute zero for temperature
►Carene::base::quantity_origin< absolute_zero >
Carene::base::units::absolute_zero	A tag type for absolute zero, the origin of the Kelvin scale
Carene::base::range_slice< FirstType, LastType, StrideType >	Slice of integer indices given the first and last
Carene::base::relative_origin< Derived, BaseOrigin >	CRTP base class used when defining a new relative origin, e.g. zero celsius which is relative to zero Kelvin
Carene::base::remove_cvref< T >	Backport of std::remove_cvref
Carene::base::repeat_type< N, T, Arg >	Repeat a template argument a specified number of times
Carene::base::repeat_type< 0UL, T, Arg >	Repeat a template argument a specified number of times
Carene::base::repeat_type_ex< N, T, U, Arg >	Repeat a template argument a specified number of times with an extra leading template argument
Carene::base::repeat_type_ex< 0UL, T, U, Arg >	Repeat a template argument a specified number of times with an extra leading template argument
►Carene::base::reverse_iterator_detail::reverse_iterator_base< Itr >	Base class for reverse_iterator providing operations that do not depend on pointer-ness of underlying iterator
Carene::base::reverse_iterator< iterator >
Carene::base::reverse_iterator< const_iterator >
Carene::base::reverse_iterator< Itr, true >	A backport of the constexpr std::reverse_iterator from C++17
Carene::base::reverse_iterator< Itr, bool >	A backport of the constexpr std::reverse_iterator from C++17
Carene::base::reverse_iterator< Itr, true >	A backport of the constexpr std::reverse_iterator from C++17
Carene::base::scope_guard< Func >	RAII utility for executing logic on scope exit
Carene::base::src_line_info	Container for the location information associated with a line of source code
Carene::base::static_if< V >	A metaprogramming facility for selecting a branch statically without evaluating both branches apriori
Carene::base::static_if< false >	The definition when static_if gets a "false" condition
Carene::base::static_if< true >	The definition when static_if gets a "true" condition
Carene::base::submdspan_mapping_result< LayoutMapping >	Specializations of submdspan_mapping_result are returned by overloads of submdspan_mapping
►Carene::base::submdspan_subextents_type_detail::submdspan_subextents_type_impl< Extents, mdspan_detail::canonical_slice_t< Extents::index_type, SliceSpecifiers >... >
Carene::base::submdspan_subextents_type< Extents, SliceSpecifiers >	Determines the subextents type from an extents type and slice specifiers
Carene::base::testing::bitwise_uniform_distribution< T, typename >	A uniform distribution to apply on top of a bit generator. Primary template (deliberately undefined)
Carene::base::testing::bitwise_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
Carene::base::testing::equal_to_value< T >
Carene::base::testing::ExternalVectorTest< T >::input_iterator_with_configurable_noexcept< U, OperatorsNoexcept >	An input iterator pointing to any type whose operators have adjustable noexcept specifications
Carene::base::testing::ExternalVectorTest< T >::throwing_bidirectional_iterator_of_t	A bidirectional iterator of T which declares that it could throw, used in some noexcept tests
Carene::base::testing::ExternalVectorTest< T >::throws_when_converted_to_t	A type with a noexcept(false) conversion operator to T (doesn't actually throw, just declares it)
Carene::base::testing::InlineVectorTest< Vector >::input_iterator_with_configurable_noexcept< U, OperatorsNoexcept >	An input iterator pointing to any type whose operators have adjustable noexcept specifications
Carene::base::testing::InlineVectorTest< Vector >::throwing_bidirectional_move_iterator_of_t	A bidirectional iterator of T which declares that it could throw, used in some noexcept tests
Carene::base::testing::InlineVectorTest< Vector >::throws_when_converted_to_t	A type with a noexcept(false) conversion operator to T (doesn't actually throw, just declares it)
Carene::base::testing::move_only_wrapper< ValueType >
Carene::base::testing::prng_xoshiro	Pseudorandom number generator implementing the xoshiro256++ algorithm
Carene::base::testing::property_config	Configuration for property run
Carene::base::testing::property_error	Error result of evaluating a property assertion
Carene::base::testing::property_summary	Result of a property run
Carene::base::testing::throws_without_nullptr< T >
Carene::base::type_identity< T >	Polyfill of std::type_identity added in C++20
Carene::base::type_list< Tn >	Empty struct that is a list of types - cheaper to instantiate than tuple
Carene::base::type_lists::apply_each< TypeList, ToApply >	Apply the given template individually to every element of the given type list
Carene::base::type_lists::apply_each< TypeList< Types... >, ToApply >	Apply the given template individually to every element of the given type list
►Carene::base::type_lists::at_detail::at_impl
Cstd::tuple_element< I, arene::base::type_list< Tn... > >	A meta function to retrieve the specified element from a type list
Carene::base::type_lists::contains_t< L0, T >	Query if a type-list contains a given type
Carene::base::type_lists::empty_t< L0 >	Get whether the type list is empty
Carene::base::type_lists::reverse< List >	Reverses the types in a type list
Carene::base::type_lists::reverse< List< Ts... > >	Specialization for type-list-like types
Carene::base::type_lists::sort< TypeList, ComparisonPredicate >	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
Carene::base::type_lists::sort< 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
Carene::base::units::scales::pi	A class to represent a scale factor of Pi
Carene::base::units_combination_traits< QuantityType1, QuantityType2 >	Traits class with information about if and how a physical unit of type QuantityType1 can be combined with a physical unit of type QuantityType2
Carene::base::units_combination_traits< QuantityType, QuantityType >	Specialization to allow addition and subtraction of a quantity type from itself
►Carene::base::units_conversion_traits_detail::units_conversion_traits_impl< From, To, typename >	Determine if the quantity type can be implicitly converted
Carene::base::units_conversion_traits< From, To >	Traits class with information about if and how a physical unit of type From can be converted to a physical unit of type To
Carene::base::unwrap_ref_decay< T >	Backport of std::unwrap_ref_decay from C++20
Carene::base::unwrap_reference< T >	Backport of std::unwrap_reference from C++20
Carene::base::value_result_t< ValueType >	Intermediary type for constructing a result with a given value_type
Carene::base::value_result_t< void >	Intermediary type for constructing a result with a void value
Carene::base::variant_alternative< I, T >	Traits to get the I-th type of a variant
Carene::base::variant_alternative< I, T const >	Implementation of variant_alternative for const variant with actual types
Carene::base::variant_alternative< I, variant< Ts... > >	Implementation of variant_alternative for variant with actual types
Carene::base::vector_reference< T >	A reference class to an inline_vector object, with size-erased type
►CBoolTrait
Carene::base::conjunction< BoolTrait >	Specialization of arene::base::conjunction for a single trait. The result is that trait
Carene::base::disjunction< BoolTrait >	Specialization of arene::base::disjunction for a single trait. The result is that trait
►Cconditional_t
Carene::base::conjunction< BoolTrait, Rest... >	Specialization of arene::base::conjunction for multiple traits
Carene::base::disjunction< BoolTrait, Rest... >	Specialization of arene::base::disjunction for multiple traits
Carene::base::index_of< T, Ts >	Template meta-function for querying the 0-based index of a type in a list of types
Carene::base::last_index_of< T, Ts >	Template meta-function for querying the last 0-based index of a type in a list of types
Cstd::common_type< T1, T2 >	Specialization for two types
►Cdetail::mixin_at
Carene::base::inline_string< PATH_MAX >
Carene::base::inline_string< max_error_length >
Carene::base::inline_string< relative_path_length >
Carene::base::inline_vector_detail::vector_interface< inline_vector_detail::inline_vector_internal_storage< T, Capacity > >
Carene::base::inline_vector_detail::vector_interface< external_vector_detail::external_storage_base< T > >
Carene::base::inline_string< MaxSize >	A string type with a fixed maximum capacity, where the data is stored internally without allocations
Carene::base::inline_vector_detail::vector_interface< Storage >	Interface to the storage for inline_vector
►Cfast_expand_sequence::template type
Cstd::integer_sequence_detail::make_sequence_impl< T, N - sizeof...(Is), Is..., sizeof...(Is)+Is... >
►Cstd::integer_sequence_detail::make_sequence_impl< Type, Size >
Cstd::integer_sequence_detail::make_integer_sequence< Type, Size, true >	Helper type to check that the requested sequence size is non-negative
Cstd::integer_sequence_detail::make_integer_sequence< Type, Size, bool >	Helper type to check that the requested sequence size is non-negative
►Cstd::integer_sequence_detail::make_sequence_impl< T, N - 1, T{}>
Cstd::integer_sequence_detail::make_sequence_impl< T, N >	Initial make sequence specialization
Cstd::integer_sequence_detail::make_sequence_impl< T, 0 >	Recursive base case specialization
Cstd::integer_sequence_detail::make_sequence_impl< T, 0, Is... >	Recursive base case specialization
Cstd::integer_sequence_detail::make_sequence_impl< T, N >	Initial make sequence specialization
Cstd::integer_sequence_detail::make_sequence_impl< T, N, Is >	Helper for constructing an integer sequence from 0 to N - 1
►Cfunction_traits
Carene::base::member_function_pointer_traits< F >	Contains the types within function_traits and member_pointer_traits for a member function pointer
►Cinline_container::detail::compare_wrapper
Carene::base::inline_map< Key, Value, Capacity, Compare >	A container similar to std::map that has a fixed capacity
Carene::base::inline_set< Value, Capacity, Compare >	A non-allocating fixed-capacity associative container storing elements of type Value
►Cinline_container::detail::comparison_interface
Carene::base::external_vector< ValueType >
Carene::base::external_vector< T >	Container similar to std::vector<T> that uses an external buffer for storage
►Cinline_container::detail::range_interface
Carene::base::inline_deque_detail::inline_deque_impl< T, Capacity, true >
Carene::base::inline_deque_detail::inline_deque_impl< T, Capacity, false >
Carene::base::const_inline_map_reference< Key, Value, Compare >	A const reference class to an inline_map object, with size-erased type
Carene::base::inline_map_reference< Key, Value, Compare >	A reference class to an inline_map object, with size-erased type
►Cinline_container_detail::iterator_interface
Carene::base::inline_map_reference_iterator< MapBase, false >
Carene::base::inline_map_reference_iterator< MapBase, true >
Carene::base::inline_map_reference_iterator< map_base_type, false >
Carene::base::inline_map_reference_iterator< map_base_type, true >
Carene::base::inline_map_reference_iterator< MapBase, IsConst >	Iterator type used by inline_map_reference and const_inline_map_reference
Carene::base::testing::rvalue_iterator< T >	An iterator whose i'th position yields an rvalue reference to test_value(i) of the given type
►Cinline_container_detail::try_construct_interface
Carene::base::external_vector< ValueType >
Carene::base::circular_buffer< T, Capacity >	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
Carene::base::external_vector< T >	Container similar to std::vector<T> that uses an external buffer for storage
Carene::base::inline_deque< T, Capacity >	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_string_std_string_mixin
Carene::base::inline_string< PATH_MAX >
Carene::base::inline_string< max_error_length >
Carene::base::inline_string< relative_path_length >
Carene::base::inline_string< MaxSize >	A string type with a fixed maximum capacity, where the data is stored internally without allocations
►Clayout_detail::strided_mapping_base
Carene::base::layout_left::mapping< Extents >	A mapping from a logical pack of indices into a single flat physical output index
Carene::base::layout_right::mapping< Extents >	A mapping from a logical pack of indices into a single flat physical output index
Carene::base::layout_stride::mapping< Extents >	A mapping from a logical pack of indices into a single flat physical output index, using a strided algorithm
►Clayout_right::template mapping
Carene::base::mdspan< ElementType, Extents, LayoutPolicy, AccessorPolicy >	A multidimensional view of elements over a contiguous sequence of elements
►Cmdspan_detail::extent_sequence
Carene::base::extents< IndexType,(static_cast< void >(Is), dynamic_extent)... >
Carene::base::extents< std::uint16_t, 1, 2, 3, 4 >
Carene::base::extents< IndexType, Extents >	Multidimensional index space
►Cmember_pointer_traits
Carene::base::member_function_pointer_traits< F >	Contains the types within function_traits and member_pointer_traits for a member function pointer
►Coptional_detail::optional_base
Carene::base::optional< Value >
Carene::base::optional< value_type >
Carene::base::optional< arene::base::testing::property_error >
Carene::base::optional< T >	Implementation of std::optional for pre-C++17 compilers, and which replaces defined undefined behavior with ARENE_PRECONDITION guards
►Coptional_detail::optional_value_interface
Carene::base::optional< Value >
Carene::base::optional< value_type >
Carene::base::optional< arene::base::testing::property_error >
Carene::base::optional< T >	Implementation of std::optional for pre-C++17 compilers, and which replaces defined undefined behavior with ARENE_PRECONDITION guards
►Cquantity_kind
Carene::base::units::amount_of_substance	Base quantity kind for the quotient of the number of entites of a given kind in a system and the Avogadro constant
Carene::base::units::angular_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
Carene::base::units::electric_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
Carene::base::units::length	Base quantity kind for the linear extent in space between any two points
Carene::base::units::luminous_intensity	Base quantity kind for the density of luminous flux with respect to solid angle in a specified direction
Carene::base::units::mass	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
Carene::base::units::number	Base quantity kind for all numeric quantity kinds
Carene::base::units::number_of_entities	Quantity kind for the number of entities of a given kind in a system
Carene::base::units::thermodynamic_temperature	Base quantity kind for thermodynamic temperature
Carene::base::units::time	Base quantity kind for time
►Cresult_detail::result_base
Carene::base::result< void, E >	Specialization of result<T, E> for void value types
Carene::base::result< T, E >	A sum type which can hold either a value or an error. Similar to std::expected
Carene::base::result< void, E >	Specialization of result<T, E> for void value types
►Cspan_detail::span_base
Carene::base::span< character const >
Carene::base::span< T, Extent >	A backport of std::span for C++14. Provides a view over a contiguous range of elements of type T
Cstd::add_const< Type >	Add const to the provided type. The type member is an alias for the modified type
►Cstd::add_const< tuple_element< I, T >::type >
Cstd::tuple_element< I, T const >	Obtains the type of the specified element
Cstd::add_cv< Type >	Add const and volatile to the provided type. The type member is an alias for the modified type
►Cstd::add_cv< tuple_element< I, T >::type >
Cstd::tuple_element< I, T const volatile >	Obtains the type of the specified element
Cstd::add_lvalue_reference_detail::add_lvalue_reference< Type, class >	Base case when Type is not referenceable
Cstd::add_lvalue_reference_detail::add_lvalue_reference< Type, arene::base::constraints< Type & > >	Add an lvalue reference onto Type
►Cstd::add_pointer_detail::add_pointer< Type, class >	Base case for when Type is not referenceable or void
Cstd::add_pointer< Type >	Adds a pointer to the given type
Cstd::add_pointer_detail::add_pointer< Type, std::enable_if_t< internal::is_referenceable_v< Type >||std::is_void_v< Type > > >	Add a pointer to the given type
Cstd::add_rvalue_reference_detail::add_rvalue_reference< Type, class >	Base case when Type is not referenceable
Cstd::add_rvalue_reference_detail::add_rvalue_reference< Type, arene::base::constraints< Type && > >	Add an rvalue reference onto Type
Cstd::add_volatile< Type >	Add volatile to the provided type. The type member is an alias for the modified type
►Cstd::add_volatile< tuple_element< I, T >::type >
Cstd::tuple_element< I, T volatile >	Obtains the type of the specified element
Cstd::back_insert_iterator_detail::adaptor_mixin< Container >	Mixin used to define back_insert_iterator
Cstd::char_traits< CharT >	Forward declaration for the traits class to abstract character and string operations. No definition is provided
Cstd::chrono::chrono_detail::check_conversion_overflow< FromPeriod, ToPeriod >	Helper to detect if duration conversion would cause overflow
Cstd::chrono::duration< Rep, Period >	Forward declaration of duration class template
Cstd::chrono::duration_values< Rep >	A customizable trait to indicate the zero, lowest, and highest values of a given representation type
Cstd::chrono::time_point< Clock, Duration >	A class representing a single point in time for the given clock
Cstd::common_type<... >	Primary template for determining the common type of a set of types
Cstd::common_type< chrono::duration< Rep1, Period1 >, chrono::duration< Rep2, Period2 > >	Specialization of common_type for two duration types
►Cstd::common_type< common_type_t< T1, T2 >, Ts... >
Cstd::common_type_detail::common_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
►Cstd::common_type< T, T >
Cstd::common_type< T >	Specialization for a single type
Cstd::common_type_detail::common_type_3_or_more< Constraints, T1, T2, Ts >	Primary template for computing common type of 3 or more types
►Cstd::common_type_detail::common_type_3_or_more< arene::base::constraints<>, T1, T2, Ts... >
Cstd::common_type< T1, T2, Ts... >	Specialization for three or more types
Cstd::common_type_detail::decayed_conditional_result< T1, T2, class >	Primary template for decaying conditional result types
Cstd::common_type_detail::decayed_conditional_result< T1, T2, arene::base::constraints< conditional_result_t< T1, T2 > > >	Specialization that provides the decayed type of a conditional expression
Cstd::conditional< Condition, 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
Cstd::conditional< 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
Cstd::decay< Type >	Contains type, a conversion equivalent to those performed when passing function arguments by value
Cstd::divides< T >	Function object for performing division
Cstd::divides< void >	Function object that can be invoked for division, specialized for type deduction
Cstd::enable_if< Condition, Type >	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
Cstd::enable_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
Cstd::equal_to< T >	Function object that can be invoked for equality comparisons
Cstd::equal_to< void >	Function object that can be invoked for equality comparisons, specialized for type deduction
Cstd::greater< T >	Function object that can be invoked for greater than comparisons
Cstd::greater< void >	Function object that can be invoked for greater than comparisons, specialized for type deduction
Cstd::greater_equal< T >	Function object that can be invoked for greater than or equal to comparisons
Cstd::greater_equal< void >	Function object that can be invoked for greater than or equal to comparisons, specialized for type deduction
►Cstd::hash_detail::default_hash< T, typename >	Default implementation of std::hash implemented only for fundamental types, enumerations and pointers
Cstd::hash< arene::base::monostate >	Implementation of std::hash for arene::base::monostate
Cstd::hash<::arene::base::non_null< P > >	std::hash specialization for non_null
Cstd::hash<::arene::base::non_owning_ptr< T > >	std::hash specialization for non_owning_ptr. The hash is equivalent to the hash of the underlying pointer
Cstd::hash<::arene::base::result< V, E > >	Specialization of std::hash for arene::base::result
Cstd::hash<::arene::base::result< void, E > >	Specialization of std::hash for arene::base::result<void, E>
Cstd::hash< T >	Hash function primary template
►Cstd::hash_detail::fnv1a_hash< T >	FNV-1a hash algorithm
Cstd::hash_detail::default_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
Cstd::ignore_detail::ignore_t	A class that anything can be assigned to, and which discards the assigned object
Cstd::initializer_list< T >	Implementation of std::initializer_list for brace initialization
Cstd::inner_product_detail::reduce_value_policy< Value >	Reduce value policy for a C++14 compliant implementation
►Cstd::input_iterator_tag	An empty tag type corresponding to an input iterator
►Cstd::forward_iterator_tag	An empty tag type corresponding to a forward iterator
►Cstd::bidirectional_iterator_tag	An empty tag type corresponding to a bidirectional iterator
Cstd::random_access_iterator_tag	An empty tag type corresponding to a random access iterator
►Cstd::insert_iterator_detail::adaptor_mixin< Container >	Mixin used to define insert_iterator
Cstd::basic_insert_iterator_detail::basic_insert_iterator< Container, insert_iterator_detail::adaptor_mixin< Container > >
Cstd::integer_sequence< Type, Ints >	Implements a compile-time sequence of integers
Cstd::integer_sequence_detail::fast_expand_sequence< T, DoDouble >	Helper for quickly expanding the elements in a sequence
Cstd::integer_sequence_detail::fast_expand_sequence< T, true >	Specialization if the sequence can be doubled
Cstd::integral_constant< Type, Value >	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
►Cstd::integral_constant< bool, !bool(BoolTrait::value)>
Carene::base::negation< BoolTrait >	Negates the value of a boolean type trait
►Cstd::integral_constant< bool, !ratio_equal< R1, R2 >::value >
Cstd::ratio_not_equal< R1, R2 >	Inherits from true_type if the first ratio is not equal to the second, false_type if they are equal
►Cstd::integral_constant< bool, !ratio_less< R1, R2 >::value >
Cstd::ratio_greater_equal< R1, R2 >	Inherits from true_type if the first ratio is greater than or equal to the second, false_type if not
►Cstd::integral_constant< bool, !ratio_less< R2, R1 >::value >
Cstd::ratio_less_equal< R1, R2 >	Inherits from true_type if the first ratio is less than or equal to the second, false_type if not
►Cstd::integral_constant< bool, fraction_less(fraction{R1::num, R1::den}, fraction{R2::num, R2::den})>
Cstd::ratio_less< R1, R2 >	Inherits from true_type if the first ratio is less than the second, false_type if not
►Cstd::integral_constant< bool, has_overloaded_address_operator_v< T > >
Carene::base::has_overloaded_address_operator< T >	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
►Cstd::integral_constant< bool, is_array_convertible_v< From, To > >
Carene::base::is_array_convertible< From, To >	Type trait to check if a pointer to an array of From is convertible to a pointer to an array of To
►Cstd::integral_constant< bool, is_inline_string_v< Type > >
Carene::base::is_inline_string< Type >	Trait to query if a type is an inline_string
►Cstd::integral_constant< bool, is_invocable_detail::is_invocable_r< false, Ret, Fn, Args... >::value >
Carene::base::is_invocable_r< Ret, Fn, Args >	Determine if a functor type is invocable with the specified return and argument types
►Cstd::integral_constant< bool, is_invocable_detail::is_invocable_r< false, void, Fn, Args... >::value >
Carene::base::is_invocable< Fn, Args >	Determine if a functor type is invocable with the specified argument types
►Cstd::integral_constant< bool, is_invocable_detail::is_invocable_r< true, Ret, Fn, Args... >::value >
Carene::base::is_nothrow_invocable_r< Ret, Fn, Args >	Determine if a functor type is no-throw invocable with the specified return and argument types
►Cstd::integral_constant< bool, is_invocable_detail::is_invocable_r< true, void, Fn, Args... >::value >
Carene::base::is_nothrow_invocable< Fn, Args >	Determine if a functor type is no-throw invocable with the specified argument types
►Cstd::integral_constant< bool, is_nothrow_only_explicitly_constructible_v< T, Args... > >
Carene::base::is_nothrow_only_explicitly_constructible< T, Args >	Type trait to detect if a type is nothrow explicitly constructible from arguments of the specified types
►Cstd::integral_constant< bool, is_one_of_v< T, Ts... > >
Carene::base::is_one_of< T, Ts >	Query if the type 'T' is one of the list of types 'Ts...'
►Cstd::integral_constant< bool, is_only_explicitly_constructible_v< T, Args... > >
Carene::base::is_only_explicitly_constructible< T, Args >	Type trait to detect if a type is explicitly constructible from arguments of the specified types
►Cstd::integral_constant< bool, R1::num==R2::num &&R1::den==R2::den >
Cstd::ratio_equal< R1, R2 >	Inherits from true_type if the first ratio is equal to the second, false_type if not
►Cstd::integral_constant< bool, ratio_less< R2, R1 >::value >
Cstd::ratio_greater< R1, R2 >	Inherits from true_type if the first ratio is greater than the second, false_type if not
Cstd::integral_constant< bool, std::is_convertible< FromMapping::extents_type, ToMapping::extents_type >::value &&(std::is_same< layout_left::mapping< FromMapping::extents_type >, FromMapping >::value||std::is_same< layout_right::mapping< FromMapping::extents_type >, FromMapping >::value||std::is_same< layout_stride::mapping< FromMapping::extents_type >, FromMapping >::value)>
►Cstd::integral_constant< bool, Value >
►Cstd::is_floating_point< Rep >
Cstd::chrono::treat_as_floating_point< Rep >	Trait to indicate if a representation type should be treated as floating-point
Cstd::is_abstract< T >	Type trait to detect if a type is an abstract class
Cstd::is_arithmetic< Type >	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
Cstd::is_array< Type >	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
Cstd::is_assignable< To, From >	Type trait to detect if an instance of To is assignable to from arguments of From
Cstd::is_base_of< Base, Derived >	Type trait to detect if Base is a base class of Derived
Cstd::is_class< Type >	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
Cstd::is_const< Type >	A type trait to check if a type is const. The class is derived from true_type if Type is const, false_type otherwise
Cstd::is_constructible< Type, Args >	Type trait to detect if a type is constructible from arguments of the specified types
Cstd::is_convertible< From, To >	Type trait to detect if one type is convertible to another
Cstd::is_copy_assignable< T >	Type trait to detect if an instance of T is copy assignable
Cstd::is_copy_constructible< T >	Type trait to detect if an instance of T is copy constructible
Cstd::is_default_constructible< T >	Type trait to detect if an instance of T is default constructible
Cstd::is_destructible< Type >	Type trait to detect if a type is destructible
Cstd::is_empty< Type >	Type trait to check if a type is an empty type. Derives from std::true_type if it is, std::false_type otherwise
Cstd::is_enum< Type >	Type trait to check if a type is an enumeration. Derives from std::true_type if it is, std::false_type otherwise
Cstd::is_final< Type >	Type trait to check if a type is a final class. Derives from std::true_type if it is, std::false_type otherwise
Cstd::is_floating_point< Type >	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
Cstd::is_function< Type >	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
Cstd::is_fundamental< T >	Check if the supplied template argument is a fundamental type or not. The value member is true if so, false otherwise
Cstd::is_integral< Type >	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
Cstd::is_lvalue_reference< T >	Check if the supplied template argument is an lvalue reference or not. The value member is true if so, false otherwise
Cstd::is_member_function_pointer< T >	Check if the supplied template argument is a member function pointer or not. The value is true if so, false otherwise
Cstd::is_member_object_pointer< T >	Check if the supplied template argument is a member object pointer or not. The value is true if so, false otherwise
Cstd::is_member_pointer< T >	Check if the supplied template argument is a member pointer or not. The value is true if so, false otherwise
Cstd::is_move_assignable< T >	Type trait to detect if an instance of T is move assignable
Cstd::is_move_constructible< T >	Type trait to detect if an instance of T is move constructible
Cstd::is_nothrow_assignable< To, From >	Type trait to detect if an instance of To is assignable to from arguments of From without throwing
Cstd::is_nothrow_constructible_detail::is_nothrow_constructible_impl< true, Type, Args... >	Internal implementation of is_nothrow_constructible
Cstd::is_nothrow_copy_assignable< T >	Type trait to detect if an instance of T is copy assignable without throwing
Cstd::is_nothrow_copy_constructible< T >	Type trait to detect if an instance of T is copy constructible without throwing
Cstd::is_nothrow_default_constructible< T >	Type trait to detect if an instance of T is default constructible without throwing
Cstd::is_nothrow_destructible< Type >	Type trait to detect if a type is destructible without throwing an exception
Cstd::is_nothrow_move_assignable< T >	Type trait to detect if an instance of T is move assignable without throwing
Cstd::is_nothrow_move_constructible< T >	Type trait to detect if an instance of T is move constructible without throwing
Cstd::is_object< T >	Check if the supplied template argument is an object or not. The value member is true if so, false otherwise
Cstd::is_pointer< T >	Check if the supplied template argument is a pointer or not. The value is true if so, false otherwise
Cstd::is_reference< T >	Check if the supplied template argument is a reference or not. The value member is true if so, false otherwise
Cstd::is_rvalue_reference< T >	Check if the supplied template argument is an rvalue reference or not. The value member is true if so, false otherwise
Cstd::is_same< T1, T2 >	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
Cstd::is_signed< Type >	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
Cstd::is_trivially_copy_assignable< T >	Type trait to detect if an instance of T is trivially copy assignable
Cstd::is_trivially_copy_constructible< T >	Type trait to detect if an instance of T is trivially copy constructible
Cstd::is_trivially_copyable< T >	Type trait to detect if an instance of T is trivially copyable
Cstd::is_trivially_default_constructible< T >	Type trait to detect if an instance of T is trivially default constructible
Cstd::is_trivially_destructible< Type >	Type trait to detect if a type is trivially destructible
Cstd::is_trivially_move_assignable< T >	Type trait to detect if an instance of T is move assignable without throwing
Cstd::is_trivially_move_constructible< T >	Type trait to detect if an instance of T is trivially move constructible
Cstd::is_unsigned< Type >	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
Cstd::is_void< Type >	A type trait to check if a type is void. The class is derived from true_type if Type is void, false_type otherwise
Cstd::is_volatile< Type >	A type trait to check if a type is volatile. The class is derived from true_type if Type is volatile, false_type otherwise
Cstd::tuple_detail::are_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..
►Cstd::integral_constant< bool, Value >< false >
Carene::base::disjunction< BoolTrait >	Specialization of arene::base::disjunction for a single trait. The result is that trait
Carene::base::disjunction< BoolTrait, Rest... >	Specialization of arene::base::disjunction for multiple traits
Carene::base::is_transparent_comparator< C, void_t< typename C::is_transparent > >	Trait to determine if a given type is a transparent comparator
►Cstd::is_nothrow_constructible_detail::is_nothrow_constructible_impl< is_constructible_v< Type, Args... >, Type, Args... >
►Cstd::is_nothrow_constructible_detail::is_nothrow_constructible< Type, Args... >
Cstd::is_nothrow_constructible< Type, Args >	Type trait to detect if a type is constructible from arguments of the specified types and is noexcept
Cstd::is_nothrow_constructible_detail::is_nothrow_constructible< Type, Args >	Internal implementation of is_nothrow_constructible
►Cstd::is_nothrow_constructible_detail::is_nothrow_constructible_impl< true, Type >
Cstd::is_nothrow_constructible_detail::is_nothrow_constructible_impl< true, Type[N], Args... >	Internal implementation of is_nothrow_constructible
Cstd::is_nothrow_constructible_detail::is_nothrow_constructible_impl< true, Type, Args... >	Internal implementation of is_nothrow_constructible
Cstd::is_nothrow_constructible_detail::is_nothrow_constructible_impl< true, Type[N], Args... >	Internal implementation of is_nothrow_constructible
Cstd::ratio_detail::is_ratio< ratio< N, D > >	A type trait to check if a type is a specialization of std::ratio as required in [ratio.general]
Cstd::tuple_detail::are_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..
Carene::base::disjunction<... >	Combines the values of multiple boolean type traits with a logical OR operation
Carene::base::is_transparent_comparator< C, typename >	Trait to determine if a given type is a transparent comparator
Cstd::is_nothrow_constructible_detail::is_nothrow_constructible_impl< IsConstructible, Type, Args >	Internal implementation of is_nothrow_constructible
Cstd::ratio_detail::is_ratio< T >	A type trait to check if a type is a specialization of std::ratio as required in [ratio.general]
Cstd::tuple_detail::are_all_arguments< Trait, TupleTypeList, List, class >	Determine if a trait predicate is true for all pairs of T... and U..
►Cstd::integral_constant< bool, Value >< true >
Carene::base::conjunction< BoolTrait >	Specialization of arene::base::conjunction for a single trait. The result is that trait
Carene::base::conjunction< BoolTrait, Rest... >	Specialization of arene::base::conjunction for multiple traits
Carene::base::conjunction<... >	Combines the values of multiple boolean type traits with a logical AND operation
Carene::base::is_transparent_comparator< C, void_t< typename C::is_transparent > >	Trait to determine if a given type is a transparent comparator
Cstd::ratio_detail::is_ratio< ratio< N, D > >	A type trait to check if a type is a specialization of std::ratio as required in [ratio.general]
►Cstd::integral_constant< cv_qualifier, function_traits< member_pointer_traits< F >::pointee_type >::member_function_cv_qualifier >
Carene::base::member_function_cv< F >	Obtains the cv-qualification of a member function pointer type
►Cstd::integral_constant< reference_qualifier, function_traits< member_pointer_traits< F >::pointee_type >::member_function_reference_qualifier >
Carene::base::member_function_reference< F >	Obtains the reference-qualification of a member function pointer type
►Cstd::integral_constant< size_t, 2 >
Cstd::tuple_size< pair< T1, T2 > >	Obtain the size of a pair
►Cstd::integral_constant< size_t, extent_v< T, 0 > >
Cstd::extent< T, N >	Obtains the size of an array type along a specified dimension
►Cstd::integral_constant< size_t, rank_v< T > >
Cstd::rank< T >	Obtains the number of dimensions of an array type
►Cstd::integral_constant< size_t, sizeof...(Types)>
Cstd::tuple_size< tuple< Types... > >	Obtain the number of elements in a tuple-like type
Cstd::integral_constant< std::size_t, 5 >
Cstd::integral_constant< std::size_t, digits_for_integral_value< T >()>
►Cstd::integral_constant< std::size_t, integer_sequence_ops_detail::get_integer_sequence_count_of(Value, Sequence{})>
Carene::base::integer_sequence_count_of< Sequence, Value >	Get the number of occurrences of a value in the provided sequence. The result is stored in the value member
►Cstd::integral_constant< std::size_t, N >
Cstd::tuple_size< arene::base::array< T, N > >	Specialization of std::tuple_size for arene::base::array
►Cstd::integral_constant< std::size_t, sizeof...(Tn)>
Cstd::tuple_size< arene::base::type_list< Tn... > >	Specialize tuple_size for type_list
►Cstd::integral_constant< std::size_t, variant_size_v< Variant > >
Carene::base::variant_size< Variant >	Helper struct to get the size of a variant
Cstd::iterator< Category, T, Distance, Pointer, Reference >	Base class to ease the definition of required types for simple iterators
►Cstd::iterator< output_iterator_tag, void, void, void, void >
Cstd::basic_insert_iterator_detail::basic_insert_iterator< Container, insert_iterator_detail::adaptor_mixin< Container > >
Cstd::basic_insert_iterator_detail::basic_insert_iterator< Container, AdaptorMixin >	Iterator adaptor for insertion into a container
►Cstd::iterator_traits_detail::iterator_traits_base< Iter, typename >	Base type for non-iterator types
Cstd::iterator_traits< T * >	Specialization for pointer to non-const type
Cstd::iterator_traits< T const * >	Specialization for pointer to const type
Cstd::iterator_traits< Iter >	Uniform interface to the properties of an iterator
Cstd::iterator_traits_detail::iterator_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
Cstd::less< T >	Function object that can be invoked for less than comparisons
Cstd::less< void >	Function object that can be invoked for less than comparisons, specialized for type deduction
Cstd::less_equal< T >	Function object that can be invoked for less than or equal to comparisons
Cstd::less_equal< void >	Function object that can be invoked for less than or equal to comparisons, specialized for type deduction
Cstd::logical_and< T >	Function object for performing logical AND (logical conjunction). Effectively calls operator&& on type T
Cstd::logical_and< void >	Function object for performing logical AND (logical conjunction), specialized for deduction of parameter and return type
Cstd::logical_or< T >	Function object for performing logical OR (logical disjunction). Effectively calls operator|| on type T
Cstd::logical_or< void >	Function object for performing logical OR (logical conjunction), specialized for deduction of parameter and return type
Cstd::make_signed_detail::make_signed< Type, typename >	Internal class providing std::make_signed
Cstd::make_signed_detail::make_signed< char >	Internal class providing std::make_signed for char
Cstd::make_signed_detail::make_signed< char16_t >	Internal class providing a signed type for char16_t
Cstd::make_signed_detail::make_signed< char32_t >	Internal class providing a signed type for char32_t
Cstd::make_signed_detail::make_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
Cstd::make_signed_detail::make_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
Cstd::make_signed_detail::make_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
Cstd::make_signed_detail::make_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
Cstd::make_signed_detail::make_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
Cstd::make_signed_detail::make_signed< unsigned char >	Internal class providing std::make_signed for unsigned char
Cstd::make_signed_detail::make_signed< unsigned int >	Internal class providing std::make_signed for unsigned int
Cstd::make_signed_detail::make_signed< unsigned long >	Internal class providing std::make_signed for long
Cstd::make_signed_detail::make_signed< unsigned long long >	Internal class providing std::make_signed for unsigned long long
Cstd::make_signed_detail::make_signed< unsigned short >	Internal class providing std::make_signed for unsigned short
Cstd::make_signed_detail::make_signed< wchar_t >	Internal class providing a signed type for wchar_t
Cstd::make_signed_detail::sized_signed< Size, typename >	Internal class providing a signed type with a specified size
Cstd::make_signed_detail::sized_signed< Size, arene::base::constraints< enable_if_t< Size==sizeof(char)> > >	Internal class providing a signed type with the size of char
Cstd::make_signed_detail::sized_signed< Size, arene::base::constraints< enable_if_t< Size==sizeof(short)> > >	Internal class providing a signed type with the size of short
Cstd::make_signed_detail::sized_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
Cstd::make_signed_detail::sized_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
Cstd::make_signed_detail::sized_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
Cstd::make_unsigned_detail::make_unsigned< Type, typename >	Internal class providing std::make_unsigned
Cstd::make_unsigned_detail::make_unsigned< char >	Internal class providing std::make_unsigned for char
Cstd::make_unsigned_detail::make_unsigned< char16_t >	Internal class providing an unsigned type for char16_t
Cstd::make_unsigned_detail::make_unsigned< char32_t >	Internal class providing an unsigned type for char32_t
Cstd::make_unsigned_detail::make_unsigned< int >	Internal class providing std::make_unsigned for int
Cstd::make_unsigned_detail::make_unsigned< long >	Internal class providing std::make_unsigned for long
Cstd::make_unsigned_detail::make_unsigned< long long >	Internal class providing std::make_unsigned for long long
Cstd::make_unsigned_detail::make_unsigned< short >	Internal class providing std::make_unsigned for short
Cstd::make_unsigned_detail::make_unsigned< signed char >	Internal class providing std::make_unsigned for signed char
Cstd::make_unsigned_detail::make_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
Cstd::make_unsigned_detail::make_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
Cstd::make_unsigned_detail::make_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
Cstd::make_unsigned_detail::make_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
Cstd::make_unsigned_detail::make_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
Cstd::make_unsigned_detail::make_unsigned< wchar_t >	Internal class providing an unsigned type for wchar_t
Cstd::make_unsigned_detail::sized_unsigned< Size, typename >	Internal class providing an unsigned type with a specified size
Cstd::make_unsigned_detail::sized_unsigned< Size, arene::base::constraints< enable_if_t< Size==sizeof(char)> > >	Internal class providing an unsigned type with the size of char
Cstd::make_unsigned_detail::sized_unsigned< Size, arene::base::constraints< enable_if_t< Size==sizeof(short)> > >	Internal class providing an unsigned type with the size of short
Cstd::make_unsigned_detail::sized_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
Cstd::make_unsigned_detail::sized_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
Cstd::make_unsigned_detail::sized_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
Cstd::minus< T >	Function object for performing subtraction
Cstd::minus< void >	Function object that can be invoked for subtraction, specialized for type deduction
Cstd::modulus< T >	Function object for performing modulus
Cstd::modulus< void >	Function object that can be invoked for modulus, specialized for type deduction
Cstd::move_iterator< Iterator >	An iterator adaptor that wraps another iterator such that dereferencing the wrapped iterator yields an rvalue reference to the source value
Cstd::multiplies< T >	Function object for performing multiplication
Cstd::multiplies< void >	Function object that can be invoked for multiplication, specialized for type deduction
Cstd::negate< T >	Function object for performing negation
Cstd::negate< void >	Function object that can be invoked for negate, specialized for type deduction
Cstd::not_equal_to< T >	Function object that can be invoked for non-equality comparisons
Cstd::not_equal_to< void >	Function object that can be invoked for non-equality comparisons, specialized for type deduction
Cstd::nothrow_t	Tag type used to disambiguate the overloads of throwing and non-throwing allocation functions
Cstd::numeric_limits_detail::int_info< size_t >	Internal helper to define properties for integer types
Cstd::numeric_limits_detail::int_info< 1 >	Internal helper to define properties for 1-byte integer types
Cstd::numeric_limits_detail::int_info< 2 >	Internal helper to define properties for 2-byte integer types
Cstd::numeric_limits_detail::int_info< 4 >	Internal helper to define properties for 4-byte integer types
Cstd::numeric_limits_detail::int_info< 8 >	Internal helper to define properties for 8-byte integer types
►Cstd::numeric_limits_detail::numeric_limits_impl< T, typename >	Implementation template for numeric_limits
Cstd::numeric_limits< T const >	Traits class to provide information about the representation of arithmetic types
Cstd::numeric_limits< T const volatile >	Traits class to provide information about the representation of arithmetic types
Cstd::numeric_limits< T volatile >	Traits class to provide information about the representation of arithmetic types
Cstd::numeric_limits< T >	Traits class to provide information about the representation of arithmetic types
Cstd::numeric_limits< T const >	Traits class to provide information about the representation of arithmetic types
Cstd::numeric_limits< T const volatile >	Traits class to provide information about the representation of arithmetic types
Cstd::numeric_limits< T volatile >	Traits class to provide information about the representation of arithmetic types
Cstd::numeric_limits_detail::numeric_limits_impl< bool, arene::base::constraints<> >	Specialization of the implementation template for numeric_limits for bool
Cstd::numeric_limits_detail::numeric_limits_impl< double, arene::base::constraints<> >	Specialization of the implementation template for numeric_limits for double
Cstd::numeric_limits_detail::numeric_limits_impl< float, arene::base::constraints<> >	Specialization of the implementation template for numeric_limits for float
Cstd::numeric_limits_detail::numeric_limits_impl< T, arene::base::constraints< enable_if_t< is_integral_v< T > > > >	Specialization of the implementation template for numeric_limits for integral types
Cstd::output_iterator_tag	An empty tag type corresponding to an output iterator
Cstd::piecewise_construct_t	Tag type for piecewise construction
Cstd::plus< T >	Function object for performing addition
Cstd::plus< void >	Function object that can be invoked for addition, specialized for type deduction
Cstd::pointer_traits_detail::pointer_traits_difference_type< PointerLike, class >	Determine the difference_type to expose in the pointer_traits
Cstd::pointer_traits_detail::pointer_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
Cstd::pointer_traits_detail::pointer_traits_element_type< PointerLike, class >	Determine the element_type to expose in pointer_traits
Cstd::pointer_traits_detail::pointer_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
Cstd::pointer_traits_detail::pointer_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
Cstd::pointer_traits_detail::pointer_traits_impl< PointerLike, class >	Define pointer_traits as empty when is_element_type_defined_v<PointerLike> is false
Cstd::pointer_traits_detail::pointer_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
►Cstd::pointer_traits_detail::pointer_traits_impl< T >
Cstd::pointer_traits< T * >	pointer_traits specialization to handle raw pointer types
Cstd::pointer_traits< T >	Uniform interface to pointer-like types
Cstd::pointer_traits_detail::pointer_traits_rebind< T, U, class >	Determine the rebind to expose in the pointer_traits
Cstd::pointer_traits_detail::pointer_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
Cstd::pointer_traits_detail::pointer_traits_rebind< T, U, arene::base::constraints< enable_if_t< has_rebind_v< T, U > > > >	Determine the rebind to expose in the pointer_traits
Cstd::pointer_traits_detail::unspecified	An unspecified type to use as the input type for pointer_to
Cstd::ratio< N, D >	A compile-time ratio of two integers, automatically reduced to lowest terms
Cstd::ratio_detail::fraction	A type used to represent a fraction for non-template computations
Cstd::ratio_detail::ratio_add_impl< R1, R2 >	A helper for addition to enforce the type requirement in [ratio.general] and improve readability
Cstd::ratio_detail::ratio_equal_impl< R1, R2 >	A helper for equality comparison to enforce the type requirement in [ratio.general]
Cstd::ratio_detail::ratio_less_impl< R1, R2 >	A helper for less-than comparison to enforce the type requirement in [ratio.general]
Cstd::ratio_detail::ratio_multiply_impl< R1, R2 >	A helper for multiplication to enforce the type requirement in [ratio.general] and improve readability
Cstd::reference_wrapper_detail::mixin_argument_types< TypeList >	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
►Cstd::reference_wrapper_detail::mixin_argument_types< arene::base::function_arguments_t< std::remove_pointer_t< T > > >
Cstd::reference_wrapper_detail::mixin_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
Cstd::reference_wrapper_detail::mixin_argument_types< arene::base::type_list< Arg > >	One argument case, will add argument_type
Cstd::reference_wrapper_detail::mixin_argument_types< arene::base::type_list< Arg1, Arg2 > >	Two argument case, will add first_argument_type and second_argument_type
►Cstd::reference_wrapper_detail::mixin_argument_types< arene::base::type_lists::concat_t< arene::base::type_list< std::remove_reference_t< arene::base::member_function_pointer_traits< T >::implicit_argument_type > * >, arene::base::member_function_arguments_t< T > > >
Cstd::reference_wrapper_detail::mixin_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
►Cstd::reference_wrapper_detail::mixin_class_binary_argument_type< T, typename >	Forward member types first_argument_type and second_argument_type from a reference wrapped class containing those member types, if present
Cstd::reference_wrapper_detail::mixin_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
Cstd::reference_wrapper_detail::mixin_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
►Cstd::reference_wrapper_detail::mixin_class_result_type< T, typename >	Forward member type result_type from a reference wrapped class containing that member type, if present
Cstd::reference_wrapper_detail::mixin_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
Cstd::reference_wrapper_detail::mixin_class_result_type< T, arene::base::constraints< typename T::result_type > >	Case where reference_type is present and forwarded
►Cstd::reference_wrapper_detail::mixin_class_unary_argument_type< T, typename >	Forward member type argument_type from a reference wrapped class containing that member type, if present
Cstd::reference_wrapper_detail::mixin_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
Cstd::reference_wrapper_detail::mixin_class_unary_argument_type< T, arene::base::constraints< typename T::argument_type > >	Case where argument_type is present and forwarded
►Cstd::reference_wrapper_detail::mixin_function_types< T, typename >	Add member types to reference_wrapper based on the underlying wrapped type
Cstd::reference_wrapper< T >	Wraps a reference in a copyable and assignable object
Cstd::remove_all_extents< T >	Removes all extents from the given array type
Cstd::remove_all_extents< T[]>	Removes all extents from the given array type
Cstd::remove_all_extents< T[N]>	Removes all extents from the given array type
Cstd::remove_const< Type >	Remove const from the provided type. The type member is an alias for the modified type
Cstd::remove_const< Type const >	Remove const from the provided type. The type member is an alias for the modified type
Cstd::remove_cv< T >	The type member is an alias for T, but with top-level const and/or volatile qualifiers removed
Cstd::remove_cv< T const >	The type member is an alias for T, but with top-level const and/or volatile qualifiers removed
Cstd::remove_cv< T const volatile >	The type member is an alias for T, but with top-level const and/or volatile qualifiers removed
Cstd::remove_cv< T volatile >	The type member is an alias for T, but with top-level const and/or volatile qualifiers removed
Cstd::remove_extent< T >	Removes the first extent from the given array type
Cstd::remove_extent< T[]>	Removes the first extent from the given array type
Cstd::remove_extent< T[N]>	Removes the first extent from the given array type
Cstd::remove_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
Cstd::remove_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
Cstd::remove_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
Cstd::remove_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
Cstd::remove_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
Cstd::remove_reference< T >	The type member is an alias for T, but with top-level reference qualifiers removed
Cstd::remove_reference< T & >	The type member is an alias for T, but with top-level reference qualifiers removed
Cstd::remove_reference< T && >	The type member is an alias for T, but with top-level reference qualifiers removed
Cstd::remove_volatile< Type >	Remove volatile from the provided type. The type member is an alias for the modified type
Cstd::remove_volatile< Type volatile >	Remove volatile from the provided type. The type member is an alias for the modified type
Cstd::stdexcept_detail::simple_string	A simple string class that manages a static storage size C-style string
Cstd::tuple_detail::tuple_impl< Indices, Types >	Helper used in the implementation of a tuple
►Cstd::tuple_detail::tuple_impl< index_sequence_for< Types... >, arene::base::type_list< Types... > >
Cstd::tuple< BoundArgs... >
Cstd::tuple< Types >	Heterogeneous, fixed-size collection of values
Cstd::tuple_element< I, T >	Obtains the type of the specified element
Cstd::tuple_element< 0, pair< T1, T2 > >	Obtain the first type of a pair
Cstd::tuple_element< 1, pair< T1, T2 > >	Obtain the second type of a pair
Cstd::tuple_element< I, tuple< Types... > >	Obtain the element type at a given index
Cstd::tuple_element< N, arene::base::array< T, ArrN > >	Specialization of std::tuple_element for arene::base::array
►Cstd::tuple_size< T >	Obtain the number of elements in a tuple-like type
Cstd::tuple_size< T const >	Obtain the number of elements in a tuple-like type
Cstd::tuple_size< T const volatile >	Obtain the number of elements in a tuple-like type
Cstd::tuple_size< T volatile >	Obtain the number of elements in a tuple-like type
Cstd::underlying_type_detail::underlying_type< T, typename >	Helper trait used to implement std::underlying_type
Cstd::underlying_type_detail::underlying_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
►CStorage
Carene::base::inline_vector_detail::vector_interface< Storage >	Interface to the storage for inline_vector
►Cstring_view_ostream_mixin
Carene::base::null_terminated_string_view	A read-only string-view that provides a view onto a null-terminated string
Carene::base::string_view	Backport of the C++17 std::string_view class
►Ctesting::Test
►Carene::base::testing::InlineVectorTest< T >
Carene::base::testing::InlineVectorDeathTest< T >	The Death Tests use the same fixture as the "normal" tests. Inherits so that it will be a distinct type
Carene::base::testing::internal::conditionally_constexpr_test< TestTag, false >	Specialization for the false case: the test body runs at runtime only
►Carene::base::InlineDequeTest< Deque >	Test fixture for all type-parameterized inline_deque tests
Carene::base::InlineDequeDeathTest< Deque >	The death tests use the same fixture as the non-death tests, but as a distinct type to improve log output
►Carene::base::testing::ExternalVectorTest< T >	Test fixture for all type-parameterized external_vector tests
Carene::base::testing::ExternalVectorDeathTest< T >	The Death Tests use the same fixture as the "normal" tests. Inherits so that it will be a distinct type
Carene::base::testing::InlineVectorTest< Vector >	Test fixture for all type-parameterized inline_vector tests
Carene::base::testing::internal::conditionally_constexpr_test< TestTag, RunInConstexpr >	GoogleTest test type used to conditionally invoke tests at compile-time
Carene::base::testing::internal::conditionally_constexpr_test< TestTag, false >	Specialization for the false case: the test body runs at runtime only
Carene::base::testing::internal::constexpr_test< TestTag >	GoogleTest test type used invoke tests at compile-time
►CValue
Carene::base::ebo_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