EnTT: Class Hierarchy

EnTT 3.16.0

Loading...
Searching...
No Matches
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123]

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