| Centt::adjacency_matrix< Category, Allocator > | Basic implementation of a directed adjacency matrix |
| Centt::adl_meta_pointer_like< Type > | Fake ADL based lookup function for meta pointer-like types |
| ►CAllocator | |
| Centt::allocation_deleter< Allocator > | Deleter for allocator-aware unique pointers (waiting for C++20) |
| Centt::as_cref_t | Empty class type used to request the as cref policy |
| Centt::as_group< Registry > | Converts a registry to a group |
| Centt::as_is_t | Empty class type used to request the as-is policy |
| Centt::as_ref_t | Empty class type used to request the as ref policy |
| Centt::as_view< Registry > | Converts a registry to a view |
| Centt::as_void_t | Empty class type used to request the as void policy |
| Centt::basic_any< Len, Align > | A SBO friendly, type-safe container for single values of any type |
| Centt::basic_any<> | |
| Centt::basic_collector<... > | Collector |
| Centt::basic_collector< matcher< type_list< Reject... >, type_list< Require... >, Rule... >, Other... > | Collector |
| Centt::basic_collector<> | Collector |
| Centt::basic_common_view< Type, Get, Exclude > | Basic storage view implementation |
| ►Centt::basic_common_view< std::common_type_t< Get::base_type..., Exclude::base_type... >, sizeof...(Get), sizeof...(Exclude)> | |
| Centt::basic_view< get_t< Get... >, exclude_t< Exclude... >, std::enable_if_t<(sizeof...(Get) !=0u)> > | General purpose view |
| Centt::basic_continuous_loader< Registry > | Utility class for continuous loading |
| Centt::basic_dispatcher< Allocator > | Basic dispatcher implementation |
| Centt::basic_entt_traits< Traits > | Common basic entity traits implementation |
| ►Centt::basic_entt_traits< internal::entt_traits< Type > > | |
| Centt::entt_traits< Type > | Entity traits |
| Centt::basic_flow< Allocator > | Utility class for creating task graphs |
| Centt::basic_flow<> | |
| Centt::basic_group< typename, typename, typename > | Group |
| Centt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > > | Owning group |
| Centt::basic_group< owned_t<>, get_t< Get... >, exclude_t< Exclude... > > | Non-owning group |
| Centt::basic_handle< Registry, Scope > | Non-owning handle to an entity |
| ►Cinternal::basic_hashed_string | |
| Centt::basic_hashed_string< Char > | Zero overhead unique identifier |
| Centt::basic_meta_associative_container_traits< Type > | General purpose implementation of meta associative container traits |
| ►Centt::basic_meta_associative_container_traits< dense_map< Args... > > | |
| Centt::meta_associative_container_traits< dense_map< Args... > > | Meta associative container traits for dense_maps of any type |
| ►Centt::basic_meta_associative_container_traits< dense_set< Args... > > | |
| Centt::meta_associative_container_traits< dense_set< Args... > > | Meta associative container traits for dense_sets of any type |
| ►Centt::basic_meta_associative_container_traits< std::map< Args... > > | |
| Centt::meta_associative_container_traits< std::map< Args... > > | Meta associative container traits for std::maps of any type |
| ►Centt::basic_meta_associative_container_traits< std::set< Args... > > | |
| Centt::meta_associative_container_traits< std::set< Args... > > | Meta associative container traits for std::sets of any type |
| ►Centt::basic_meta_associative_container_traits< std::unordered_map< Args... > > | |
| Centt::meta_associative_container_traits< std::unordered_map< Args... > > | Meta associative container traits for std::unordered_maps of any type |
| ►Centt::basic_meta_associative_container_traits< std::unordered_set< Args... > > | |
| Centt::meta_associative_container_traits< std::unordered_set< Args... > > | Meta associative container traits for std::unordered_sets of any type |
| ►Cinternal::basic_meta_factory | |
| Centt::meta_factory< Type > | Meta factory to be used for reflection purposes |
| Centt::basic_meta_sequence_container_traits< Type > | General purpose implementation of meta sequence container traits |
| ►Centt::basic_meta_sequence_container_traits< std::array< Type, N > > | |
| Centt::meta_sequence_container_traits< std::array< Type, N > > | Meta sequence container traits for std::arrays of any type |
| ►Centt::basic_meta_sequence_container_traits< std::deque< Args... > > | |
| Centt::meta_sequence_container_traits< std::deque< Args... > > | Meta sequence container traits for std::deques of any type |
| ►Centt::basic_meta_sequence_container_traits< std::list< Args... > > | |
| Centt::meta_sequence_container_traits< std::list< Args... > > | Meta sequence container traits for std::lists of any type |
| ►Centt::basic_meta_sequence_container_traits< std::vector< Args... > > | |
| Centt::meta_sequence_container_traits< std::vector< Args... > > | Meta sequence container traits for std::vectors of any type |
| Centt::basic_observer< Registry, Allocator > | Observer |
| Centt::basic_organizer< Registry > | Utility class for creating a static task graph |
| Centt::basic_registry< Entity, Allocator > | Fast and reliable entity-component system |
| Centt::basic_runtime_view< Type, Allocator > | Generic runtime view |
| Centt::basic_scheduler< Delta, Allocator > | Cooperative scheduler for processes |
| Centt::basic_snapshot< Registry > | Utility class to create snapshots from a registry |
| Centt::basic_snapshot_loader< Registry > | Utility class to restore a snapshot as a whole |
| ►Centt::basic_sparse_set< Entity, Allocator > | Sparse set implementation |
| Centt::basic_storage< mask_type, typename Registry::entity_type, typename std::allocator_traits< Allocator >::template rebind_alloc< mask_type > > | |
| Centt::basic_storage< Entity, Entity, Allocator > | Swap-only entity storage specialization |
| ►Centt::basic_sparse_set< Entity, std::allocator_traits< Allocator >::template rebind_alloc< Entity > > | |
| Centt::basic_storage< Type, Entity, Allocator, typename > | Storage implementation |
| Centt::basic_storage< Type, Entity, Allocator, std::enable_if_t< component_traits< Type >::page_size==0u > > | Default constructor. |
| Centt::basic_sparse_set< typename Registry::entity_type, std::allocator_traits< Allocator >::template rebind_alloc< typename Registry::entity_type > > | |
| Centt::basic_storage_view< Type, Policy > | Basic storage view implementation |
| ►Centt::basic_storage_view< Get::base_type, Get::storage_policy > | |
| Centt::basic_view< get_t< Get >, exclude_t<> > | Storage view specialization |
| Centt::basic_table< Container > | Basic table implementation |
| Centt::basic_view< typename, typename, typename > | View implementation |
| ►Cstd::bool_constant | |
| Centt::is_ebco_eligible< Type > | Provides the member constant value to true if a given type is both an empty and non-final class, false otherwise |
| ►Centt::is_equality_comparable< Type > | Provides the member constant value to true if a given type is equality comparable, false otherwise |
| Centt::is_equality_comparable< const Type > | Provides the member constant value to true if a given type is equality comparable, false otherwise. |
| Centt::is_meta_policy< Type > | Provides the member constant value to true if a type also is a meta policy, false otherwise |
| Centt::type_list_contains< type_list< Type... >, Other > | Provides the member constant value to true if a type list contains a given type, false otherwise. |
| Centt::value_list_contains< value_list< Value... >, Other > | Provides the member constant value to true if a value list contains a given value, false otherwise. |
| Centt::choice_t< N > | Utility class to disambiguate overloaded functions |
| Centt::choice_t< 0 > | Utility class to disambiguate overloaded functions. |
| Centt::component_traits< Type, typename > | Common way to access various properties of components |
| ►Cinternal::compressed_pair_element | |
| Centt::compressed_pair< sparse_container_type, hasher > | |
| Centt::compressed_pair< sparse_container_type, hasher > | |
| Centt::compressed_pair< packed_container_type, key_equal > | |
| Centt::compressed_pair< packed_container_type, key_equal > | |
| Centt::compressed_pair< entt::dense_map, allocator_type > | |
| Centt::compressed_pair< entt::dense_map, allocator_type > | |
| Centt::compressed_pair< size_type, allocator_type > | |
| Centt::compressed_pair< size_type, allocator_type > | |
| Centt::compressed_pair< container_type, allocator_type > | |
| Centt::compressed_pair< container_type, allocator_type > | |
| Centt::compressed_pair< entt::dense_map, loader_type > | |
| Centt::compressed_pair< entt::dense_map, loader_type > | |
| Centt::compressed_pair< First, Second > | A compressed pair |
| Centt::compressed_pair< First, Second > | A compressed pair |
| ►Cconditional | |
| Cstd::tuple_element< Index, entt::compressed_pair< First, Second > > | std::tuple_element specialization for compressed_pairs |
| Centt::connect_arg_t< auto > | Disambiguation tag for constructors and the like |
| Centt::connection | Connection class |
| Centt::constness_as< To, From > | Transcribes the constness of a type to another type |
| Centt::constness_as< To, const From > | Transcribes the constness of a type to another type. |
| Centt::delegate< typename > | Basic delegate implementation |
| Centt::delegate< Ret(Args...)> | Utility class to use to send around functions and members |
| Centt::dense_map< Key, Type, Hash, KeyEqual, Allocator > | Associative container for key-value pairs with unique keys |
| Centt::dense_map< id_type, ro_rw_container_type, identity, std::equal_to<>, typename alloc_traits::template rebind_alloc< std::pair< const id_type, ro_rw_container_type > > > | |
| Centt::dense_map< id_type, std::shared_ptr< base_type >, identity, std::equal_to<>, typename alloc_traits::template rebind_alloc< std::pair< const id_type, std::shared_ptr< base_type > > > > | |
| Centt::dense_map< id_type, std::shared_ptr< internal::group_descriptor >, identity, std::equal_to<>, typename alloc_traits::template rebind_alloc< std::pair< const id_type, std::shared_ptr< internal::group_descriptor > > > > | |
| Centt::dense_map< typename traits_type::entity_type, std::pair< entity_type, entity_type > > | |
| Centt::dense_set< Type, Hash, KeyEqual, Allocator > | Associative container for unique objects of a given type |
| Centt::dense_set< id_type, identity, std::equal_to<>, typename alloc_traits::template rebind_alloc< id_type > > | |
| ►Centt::directed_tag | Undirected graph category tag |
| Centt::undirected_tag | Directed graph category tag |
| Centt::emitter< Derived, Allocator > | General purpose event emitter |
| ►Cstd::false_type | |
| ►Centt::is_meta_pointer_like< Type > | |
| Centt::is_meta_pointer_like< const Type > | Partial specialization to ensure that const pointer-like types are also accepted |
| Centt::enum_as_bitmask< Type, typename > | Enable bitmask support for enum classes |
| Centt::is_applicable< typename, typename > | Same as std::is_invocable, but with tuples |
| Centt::is_applicable_r< typename, typename, typename > | Same as std::is_invocable_r, but with tuples for arguments |
| Centt::is_complete< Type, typename > | Provides the member constant value to true if a given type is complete, false otherwise |
| Centt::is_iterator< Type, typename > | Provides the member constant value to true if a given type is an iterator, false otherwise |
| Centt::is_meta_pointer_like< typename > | Provides the member constant value to true if a given type is a pointer-like type from the point of view of the meta system, false otherwise |
| Centt::is_meta_pointer_like< Type(*)[N]> | Partial specialization used to reject pointers to arrays |
| Centt::is_transparent< Type, typename > | Provides the member constant value to true if Type::is_transparent is valid and denotes a type, false otherwise |
| Centt::family<... > | Dynamic identifier generator |
| ►CFunc | |
| Centt::forward_apply< Func > | Utility class to forward-and-apply tuple objects |
| Centt::overloaded< Func > | Helper type for visitors |
| Centt::process_adaptor< Func, Delta > | Adaptor for lambdas and functors to turn them into processes |
| ►Cinternal::has_iterator_category | |
| Centt::is_iterator< Type, std::enable_if_t<!std::is_void_v< std::remove_cv_t< std::remove_pointer_t< Type > > > > > | Provides the member constant value to true if a given type is an iterator, false otherwise. |
| Centt::ident< Type > | Type integral identifiers |
| Centt::identity | Identity function object (waiting for C++20) |
| Centt::input_iterator_pointer< Type > | Helper type to use as pointer with input iterators |
| Centt::insertion_sort | Function object for performing insertion sort |
| ►Cstd::integral_constant | |
| Centt::size_of< Type, typename > | A type-only sizeof wrapper that returns 0 where sizeof complains |
| Centt::size_of< Type, std::void_t< decltype(sizeof(Type))> > | A type-only sizeof wrapper that returns 0 where sizeof complains. |
| Cstd::tuple_size< entt::compressed_pair< First, Second > > | std::tuple_size specialization for compressed_pairs |
| Cstd::tuple_size< entt::type_list< Type... > > | |
| Cstd::tuple_size< entt::value_list< Value... > > | |
| Centt::iota_iterator< Type > | Plain iota iterator (waiting for C++20) |
| ►Cstd::is_enum | |
| Centt::enum_as_bitmask< Type, std::void_t< decltype(Type::_entt_enum_as_bitmask)> > | Enable bitmask support for enum classes. |
| ►Cstd::is_invocable | |
| Centt::is_applicable< Func, Tuple< Args... > > | Same as std::is_invocable, but with tuples. |
| Centt::is_applicable< Func, const Tuple< Args... > > | Same as std::is_invocable, but with tuples. |
| ►Cstd::is_invocable_r | |
| Centt::is_applicable_r< Ret, Func, std::tuple< Args... > > | Same as std::is_invocable_r, but with tuples for arguments. |
| ►Cinternal::is_tuple_impl | |
| Centt::is_tuple< Type > | Provides the member constant value to true if a given type is a tuple, false otherwise |
| Centt::iterable_adaptor< It, Sentinel > | Utility class to create an iterable object from a pair of iterators |
| Centt::locator< Service > | Service locator, nothing more |
| Centt::matcher<... > | Grouping matcher |
| Centt::member_class< Member > | Extracts the class of a non-static member object or function |
| Centt::meta_any | Opaque wrapper for values of any type |
| Centt::meta_associative_container | Proxy object for associative containers |
| Centt::meta_associative_container_traits< typename > | Traits class template to be specialized to enable support for meta associative containers |
| Centt::meta_class_template_tag< class > | Utility class to disambiguate class templates |
| ►Cinternal::meta_context | |
| Centt::meta_ctx | Opaque meta context type |
| Centt::meta_ctx_arg_t | Disambiguation tag for constructors and the like |
| Centt::meta_custom | Opaque wrapper for user defined data of any type |
| Centt::meta_data | Opaque wrapper for data members |
| Centt::meta_func | Opaque wrapper for member functions |
| Centt::meta_function_descriptor< typename, typename > | Primary template isn't defined on purpose |
| Centt::meta_function_descriptor_traits< Ret, Args, Static, Const > | Meta function descriptor traits |
| ►Centt::meta_function_descriptor_traits< Ret &, std::conditional_t< std::is_base_of_v< Class, Type >, type_list<>, type_list< Class & > >, !std::is_base_of_v< Class, Type >, false > | |
| Centt::meta_function_descriptor< Type, Ret Class::* > | Meta function descriptor |
| ►Centt::meta_function_descriptor_traits< Ret, std::conditional_t< std::is_base_of_v< Class, Type >, type_list< Args... >, type_list< Class &, Args... > >, !std::is_base_of_v< Class, Type >, false > | |
| Centt::meta_function_descriptor< Type, Ret(Class::*)(Args...)> | Meta function descriptor |
| ►Centt::meta_function_descriptor_traits< Ret, std::conditional_t< std::is_base_of_v< Class, Type >, type_list< Args... >, type_list< const Class &, Args... > >, !std::is_base_of_v< Class, Type >, true > | |
| Centt::meta_function_descriptor< Type, Ret(Class::*)(Args...) const > | Meta function descriptor |
| ►Centt::meta_function_descriptor_traits< Ret, std::conditional_t< std::is_same_v< std::remove_cv_t< std::remove_reference_t< MaybeType > >, Type >||std::is_base_of_v< std::remove_cv_t< std::remove_reference_t< MaybeType > >, Type >, type_list< Args... >, type_list< MaybeType, Args... > >, !(std::is_same_v< std::remove_cv_t< std::remove_reference_t< MaybeType > >, Type >||std::is_base_of_v< std::remove_cv_t< std::remove_reference_t< MaybeType > >, Type >), std::is_const_v< std::remove_reference_t< MaybeType > > &&(std::is_same_v< std::remove_cv_t< std::remove_reference_t< MaybeType > >, Type >||std::is_base_of_v< std::remove_cv_t< std::remove_reference_t< MaybeType > >, Type >)> | |
| Centt::meta_function_descriptor< Type, Ret(*)(MaybeType, Args...)> | Meta function descriptor |
| ►Centt::meta_function_descriptor_traits< Ret, type_list<>, true, false > | |
| Centt::meta_function_descriptor< Type, Ret(*)()> | Meta function descriptor |
| Centt::meta_function_helper< Type, Candidate > | Meta function helper |
| Centt::meta_handle | Opaque pointers to instances of any type |
| Centt::meta_prop | Opaque wrapper for properties of any type |
| Centt::meta_sequence_container | Proxy object for sequence containers |
| Centt::meta_sequence_container_traits< typename > | Traits class template to be specialized to enable support for meta sequence containers |
| Centt::meta_template_traits< typename > | Traits class template to be specialized to enable support for meta template information |
| Centt::meta_template_traits< Clazz< Args... > > | General purpose traits class for generating meta template information |
| Centt::meta_type | Opaque wrapper for types |
| Centt::monostate< id_type > | Minimal implementation of the monostate pattern |
| Centt::nth_argument< Index, Candidate > | Extracts the n-th argument of a callable type |
| Centt::null_t | Null object for all identifiers.
|
| Centt::poly_base< Poly > | Poly base class used to inject functionalities into concepts |
| Centt::poly_inspector | Inspector class used to infer the type of the virtual table |
| Centt::poly_vtable< Concept, Len, Align > | Static virtual table factory |
| Centt::process< Derived, Delta > | Base class for processes |
| ►Centt::process< process_adaptor< Func, Delta >, Delta > | |
| Centt::process_adaptor< Func, Delta > | Adaptor for lambdas and functors to turn them into processes |
| Centt::radix_sort< Bit, N > | Function object for performing LSD radix sort |
| Centt::reactive | Empty value type for reactive storage types |
| Centt::resource< Type > | Basic resource handle |
| Centt::resource_cache< Type, Loader, Allocator > | Basic cache for resources of any type |
| Centt::resource_loader< Type > | Transparent loader for shared resources |
| Centt::scoped_connection | Scoped connection class |
| Centt::sigh< Type, typename > | Unmanaged signal handler |
| Centt::sigh< Ret(Args...), Allocator > | Unmanaged signal handler |
| Centt::sigh< void(owner_type &, const typename underlying_type::entity_type), typename underlying_type::allocator_type > | |
| Centt::sigh_helper<... > | Primary template isn't defined on purpose |
| ►Centt::sigh_helper< Registry > | Signal connection helper for registries |
| Centt::sigh_helper< Registry, Type > | Signal connection helper for registries |
| Centt::sink< typename > | Sink class |
| Centt::sink< sigh< Ret(Args...), Allocator > > | Sink class |
| Centt::std_sort | Function object to wrap std::sort in a class type |
| Centt::storage_for< Type, Entity, Allocator > | |
| Centt::storage_type< Type, Entity, Allocator, typename > | Provides a common way to define storage types |
| Centt::storage_type< reactive, Entity, Allocator > | |
| ►CConcept::template type | |
| Centt::basic_poly< Concept, Len, Align > | Static polymorphism made simple and within everyone's reach |
| Centt::tombstone_t | Tombstone object for all identifiers.
|
| ►Cstd::true_type | |
| Centt::is_complete< Type, std::void_t< decltype(sizeof(Type))> > | Provides the member constant value to true if a given type is complete, false otherwise. |
| Centt::is_meta_pointer_like< Type * > | Makes plain pointers pointer-like types for the meta system |
| Centt::is_meta_pointer_like< std::shared_ptr< Type > > | Makes std::shared_ptrs of any type pointer-like types for the meta system |
| Centt::is_meta_pointer_like< std::unique_ptr< Type, Args... > > | Makes std::unique_ptrs of any type pointer-like types for the meta system |
| Centt::is_transparent< Type, std::void_t< typename Type::is_transparent > > | Provides the member constant value to true if Type::is_transparent is valid and denotes a type, false otherwise. |
| ►CType | |
| Centt::basic_reactive_mixin< Type, Registry > | Mixin type used to add reactive support to storage types |
| Centt::basic_sigh_mixin< Type, Registry > | Mixin type used to add signal support to storage types |
| Centt::type_hash< Type, typename > | Type hash |
| Centt::type_identity< Type > | Identity type trait |
| Centt::type_index< Type, typename > | Type sequential identifier |
| Centt::type_info | Implementation specific information about a type |
| Centt::type_list< Type > | A class to use to push around lists of types, nothing more |
| ►Centt::type_list< Type... > | |
| Centt::exclude_t< Type > | Alias for exclusion lists |
| Centt::get_t< Type > | Alias for lists of observed elements |
| Centt::owned_t< Type > | Alias for lists of owned elements |
| Centt::type_list_cat<... > | Primary template isn't defined on purpose |
| Centt::type_list_cat< type_list< Type... > > | Concatenates multiple type lists |
| Centt::type_list_cat< type_list< Type... >, type_list< Other... >, List... > | Concatenates multiple type lists |
| Centt::type_list_cat<> | Concatenates multiple type lists |
| Centt::type_list_contains< List, Type > | Provides the member constant value to true if a type list contains a given type, false otherwise |
| Centt::type_list_diff<... > | Primary template isn't defined on purpose |
| Centt::type_list_diff< type_list< Type... >, type_list< Other... > > | Computes the difference between two type lists |
| Centt::type_list_element< size_t, typename > | Primary template isn't defined on purpose |
| Centt::type_list_element< 0u, type_list< First, Other... > > | Provides compile-time indexed access to the types of a type list |
| ►Centt::type_list_element< Index - 1u, type_list< Other... > > | |
| Centt::type_list_element< Index, type_list< First, Other... > > | Provides compile-time indexed access to the types of a type list |
| ►Centt::type_list_element< Index, entt::type_list< Type... > > | |
| Cstd::tuple_element< Index, entt::type_list< Type... > > | |
| Centt::type_list_index< typename, typename > | Primary template isn't defined on purpose |
| Centt::type_list_index< Type, type_list< First, Other... > > | Provides compile-time type access to the types of a type list |
| Centt::type_list_index< Type, type_list< Type, Other... > > | Provides compile-time type access to the types of a type list |
| Centt::type_list_index< Type, type_list<> > | Provides compile-time type access to the types of a type list |
| Centt::type_list_transform< typename, class > | Primary template isn't defined on purpose |
| Centt::type_list_transform< exclude_t< Type... >, Op > | Applies a given function to an exclude list and generate a new list |
| Centt::type_list_transform< get_t< Type... >, Op > | Applies a given function to a get list and generate a new list |
| Centt::type_list_transform< owned_t< Type... >, Op > | Applies a given function to an owned list and generate a new list |
| Centt::type_list_transform< type_list< Type... >, Op > | Applies a given function to a type list and generate a new list |
| Centt::type_list_unique< List > | Removes duplicates types from a type list |
| Centt::type_name< Type, typename > | Type name |
| Centt::value_list< Value > | A class to use to push around lists of constant values, nothing more |
| Centt::value_list_cat<... > | Primary template isn't defined on purpose |
| Centt::value_list_cat< value_list< Value... > > | Concatenates multiple value lists |
| Centt::value_list_cat< value_list< Value... >, value_list< Other... >, List... > | Concatenates multiple value lists |
| Centt::value_list_cat<> | Concatenates multiple value lists |
| Centt::value_list_contains< List, Value > | Provides the member constant value to true if a value list contains a given value, false otherwise |
| Centt::value_list_diff<... > | Primary template isn't defined on purpose |
| Centt::value_list_diff< value_list< Value... >, value_list< Other... > > | Computes the difference between two value lists |
| Centt::value_list_element< size_t, typename > | Primary template isn't defined on purpose |
| Centt::value_list_element< 0u, value_list< Value, Other... > > | Provides compile-time indexed access to the types of a type list |
| ►Centt::value_list_element< Index - 1u, value_list< Other... > > | |
| Centt::value_list_element< Index, value_list< Value, Other... > > | Provides compile-time indexed access to the values of a value list |
| ►Centt::value_list_element< Index, entt::value_list< Value... > > | |
| Cstd::tuple_element< Index, entt::value_list< Value... > > | |
| Centt::value_list_index< auto, typename > | Primary template isn't defined on purpose |
| Centt::value_list_index< Value, value_list< First, Other... > > | Provides compile-time type access to the values of a value list |
| Centt::value_list_index< Value, value_list< Value, Other... > > | Provides compile-time type access to the values of a value list |
| Centt::value_list_index< Value, value_list<> > | Provides compile-time type access to the values of a value list |
| Centt::value_list_unique< typename > | Primary template isn't defined on purpose |
| Centt::value_list_unique< value_list< Value, Other... > > | Removes duplicates values from a value list |
| Centt::value_list_unique< value_list<> > | Removes duplicates values from a value list |
| Centt::basic_organizer< Registry >::vertex | Vertex type of a task graph defined as an adjacency list |
| Centt::y_combinator< Func > | Basic implementation of a y-combinator |
