| ►Nentt | EnTT default namespace |
| Cadjacency_matrix | Basic implementation of a directed adjacency matrix |
| Cadl_meta_pointer_like | Fake ADL based lookup function for meta pointer-like types |
| Callocation_deleter | Deleter for allocator-aware unique pointers (waiting for C++20) |
| Cas_cref_t | Empty class type used to request the as cref policy |
| Cas_group | Converts a registry to a group |
| Cas_is_t | Empty class type used to request the as-is policy |
| Cas_ref_t | Empty class type used to request the as ref policy |
| Cas_view | Converts a registry to a view |
| Cas_void_t | Empty class type used to request the as void policy |
| Cbasic_any | A SBO friendly, type-safe container for single values of any type |
| Cbasic_collector | Collector |
| Cbasic_collector< matcher< type_list< Reject... >, type_list< Require... >, Rule... >, Other... > | Collector |
| Cbasic_collector<> | Collector |
| Cbasic_common_view | Basic storage view implementation |
| Cbasic_continuous_loader | Utility class for continuous loading |
| Cbasic_dispatcher | Basic dispatcher implementation |
| Cbasic_entt_traits | Common basic entity traits implementation |
| Cbasic_flow | Utility class for creating task graphs |
| Cbasic_group | Group |
| Cbasic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > > | Owning group |
| Cbasic_group< owned_t<>, get_t< Get... >, exclude_t< Exclude... > > | Non-owning group |
| Cbasic_handle | Non-owning handle to an entity |
| Cbasic_hashed_string | Zero overhead unique identifier |
| Cbasic_meta_associative_container_traits | General purpose implementation of meta associative container traits |
| Cbasic_meta_sequence_container_traits | General purpose implementation of meta sequence container traits |
| Cbasic_observer | Observer |
| ►Cbasic_organizer | Utility class for creating a static task graph |
| Cvertex | Vertex type of a task graph defined as an adjacency list |
| Cbasic_poly | Static polymorphism made simple and within everyone's reach |
| Cbasic_reactive_mixin | Mixin type used to add reactive support to storage types |
| Cbasic_registry | Fast and reliable entity-component system |
| Cbasic_runtime_view | Generic runtime view |
| Cbasic_scheduler | Cooperative scheduler for processes |
| Cbasic_sigh_mixin | Mixin type used to add signal support to storage types |
| Cbasic_snapshot | Utility class to create snapshots from a registry |
| Cbasic_snapshot_loader | Utility class to restore a snapshot as a whole |
| Cbasic_sparse_set | Sparse set implementation |
| Cbasic_storage | Storage implementation |
| Cbasic_storage< Entity, Entity, Allocator > | Swap-only entity storage specialization |
| Cbasic_storage< Type, Entity, Allocator, std::enable_if_t< component_traits< Type >::page_size==0u > > | Default constructor. |
| Cbasic_storage_view | Basic storage view implementation |
| Cbasic_table | Basic table implementation |
| Cbasic_view | View implementation |
| Cbasic_view< get_t< Get >, exclude_t<> > | Storage view specialization |
| Cbasic_view< get_t< Get... >, exclude_t< Exclude... >, std::enable_if_t<(sizeof...(Get) !=0u)> > | General purpose view |
| Cchoice_t | Utility class to disambiguate overloaded functions |
| Cchoice_t< 0 > | Utility class to disambiguate overloaded functions. |
| Ccomponent_traits | Common way to access various properties of components |
| Ccompressed_pair | A compressed pair |
| Cconnect_arg_t | Disambiguation tag for constructors and the like |
| Cconnection | Connection class |
| Cconstness_as | Transcribes the constness of a type to another type |
| Cconstness_as< To, const From > | Transcribes the constness of a type to another type. |
| Cdelegate | Basic delegate implementation |
| Cdelegate< Ret(Args...)> | Utility class to use to send around functions and members |
| Cdense_map | Associative container for key-value pairs with unique keys |
| Cdense_set | Associative container for unique objects of a given type |
| Cdirected_tag | Undirected graph category tag |
| Cemitter | General purpose event emitter |
| Centt_traits | Entity traits |
| Cenum_as_bitmask | Enable bitmask support for enum classes |
| Cenum_as_bitmask< Type, std::void_t< decltype(Type::_entt_enum_as_bitmask)> > | Enable bitmask support for enum classes. |
| Cexclude_t | Alias for exclusion lists |
| Cfamily | Dynamic identifier generator |
| Cforward_apply | Utility class to forward-and-apply tuple objects |
| Cget_t | Alias for lists of observed elements |
| Cident | Type integral identifiers |
| Cidentity | Identity function object (waiting for C++20) |
| Cinput_iterator_pointer | Helper type to use as pointer with input iterators |
| Cinsertion_sort | Function object for performing insertion sort |
| Ciota_iterator | Plain iota iterator (waiting for C++20) |
| Cis_applicable | Same as std::is_invocable, but with tuples |
| Cis_applicable< Func, const Tuple< Args... > > | Same as std::is_invocable, but with tuples. |
| Cis_applicable< Func, Tuple< Args... > > | Same as std::is_invocable, but with tuples. |
| Cis_applicable_r | Same as std::is_invocable_r, but with tuples for arguments |
| Cis_applicable_r< Ret, Func, std::tuple< Args... > > | Same as std::is_invocable_r, but with tuples for arguments. |
| Cis_complete | Provides the member constant value to true if a given type is complete, false otherwise |
| Cis_complete< Type, std::void_t< decltype(sizeof(Type))> > | Provides the member constant value to true if a given type is complete, false otherwise. |
| Cis_ebco_eligible | Provides the member constant value to true if a given type is both an empty and non-final class, false otherwise |
| Cis_equality_comparable | Provides the member constant value to true if a given type is equality comparable, false otherwise |
| Cis_equality_comparable< const Type > | Provides the member constant value to true if a given type is equality comparable, false otherwise. |
| Cis_iterator | Provides the member constant value to true if a given type is an iterator, false otherwise |
| Cis_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. |
| Cis_meta_pointer_like | 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 |
| Cis_meta_pointer_like< const Type > | Partial specialization to ensure that const pointer-like types are also accepted |
| Cis_meta_pointer_like< std::shared_ptr< Type > > | Makes std::shared_ptrs of any type pointer-like types for the meta system |
| Cis_meta_pointer_like< std::unique_ptr< Type, Args... > > | Makes std::unique_ptrs of any type pointer-like types for the meta system |
| Cis_meta_pointer_like< Type * > | Makes plain pointers pointer-like types for the meta system |
| Cis_meta_pointer_like< Type(*)[N]> | Partial specialization used to reject pointers to arrays |
| Cis_meta_policy | Provides the member constant value to true if a type also is a meta policy, false otherwise |
| Cis_transparent | Provides the member constant value to true if Type::is_transparent is valid and denotes a type, false otherwise |
| Cis_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. |
| Cis_tuple | Provides the member constant value to true if a given type is a tuple, false otherwise |
| Citerable_adaptor | Utility class to create an iterable object from a pair of iterators |
| Clocator | Service locator, nothing more |
| Cmatcher | Grouping matcher |
| Cmember_class | Extracts the class of a non-static member object or function |
| Cmeta_any | Opaque wrapper for values of any type |
| Cmeta_associative_container | Proxy object for associative containers |
| Cmeta_associative_container_traits | Traits class template to be specialized to enable support for meta associative containers |
| Cmeta_associative_container_traits< dense_map< Args... > > | Meta associative container traits for dense_maps of any type |
| Cmeta_associative_container_traits< dense_set< Args... > > | Meta associative container traits for dense_sets of any type |
| Cmeta_associative_container_traits< std::map< Args... > > | Meta associative container traits for std::maps of any type |
| Cmeta_associative_container_traits< std::set< Args... > > | Meta associative container traits for std::sets of any type |
| Cmeta_associative_container_traits< std::unordered_map< Args... > > | Meta associative container traits for std::unordered_maps of any type |
| Cmeta_associative_container_traits< std::unordered_set< Args... > > | Meta associative container traits for std::unordered_sets of any type |
| Cmeta_class_template_tag | Utility class to disambiguate class templates |
| Cmeta_ctx | Opaque meta context type |
| Cmeta_ctx_arg_t | Disambiguation tag for constructors and the like |
| Cmeta_custom | Opaque wrapper for user defined data of any type |
| Cmeta_data | Opaque wrapper for data members |
| Cmeta_factory | Meta factory to be used for reflection purposes |
| Cmeta_func | Opaque wrapper for member functions |
| Cmeta_function_descriptor | Primary template isn't defined on purpose |
| Cmeta_function_descriptor< Type, Ret Class::* > | Meta function descriptor |
| Cmeta_function_descriptor< Type, Ret(*)()> | Meta function descriptor |
| Cmeta_function_descriptor< Type, Ret(*)(MaybeType, Args...)> | Meta function descriptor |
| Cmeta_function_descriptor< Type, Ret(Class::*)(Args...) const > | Meta function descriptor |
| Cmeta_function_descriptor< Type, Ret(Class::*)(Args...)> | Meta function descriptor |
| Cmeta_function_descriptor_traits | Meta function descriptor traits |
| Cmeta_function_helper | Meta function helper |
| Cmeta_handle | Opaque pointers to instances of any type |
| Cmeta_prop | Opaque wrapper for properties of any type |
| Cmeta_sequence_container | Proxy object for sequence containers |
| Cmeta_sequence_container_traits | Traits class template to be specialized to enable support for meta sequence containers |
| Cmeta_sequence_container_traits< std::array< Type, N > > | Meta sequence container traits for std::arrays of any type |
| Cmeta_sequence_container_traits< std::deque< Args... > > | Meta sequence container traits for std::deques of any type |
| Cmeta_sequence_container_traits< std::list< Args... > > | Meta sequence container traits for std::lists of any type |
| Cmeta_sequence_container_traits< std::vector< Args... > > | Meta sequence container traits for std::vectors of any type |
| Cmeta_template_traits | Traits class template to be specialized to enable support for meta template information |
| Cmeta_template_traits< Clazz< Args... > > | General purpose traits class for generating meta template information |
| Cmeta_type | Opaque wrapper for types |
| Cmonostate | Minimal implementation of the monostate pattern |
| Cnth_argument | Extracts the n-th argument of a callable type |
| Cnull_t | Null object for all identifiers.
|
| Coverloaded | Helper type for visitors |
| Cowned_t | Alias for lists of owned elements |
| Cpoly_base | Poly base class used to inject functionalities into concepts |
| Cpoly_inspector | Inspector class used to infer the type of the virtual table |
| Cpoly_vtable | Static virtual table factory |
| Cprocess | Base class for processes |
| Cprocess_adaptor | Adaptor for lambdas and functors to turn them into processes |
| Cradix_sort | Function object for performing LSD radix sort |
| Creactive | Empty value type for reactive storage types |
| Cresource | Basic resource handle |
| Cresource_cache | Basic cache for resources of any type |
| Cresource_loader | Transparent loader for shared resources |
| Cscoped_connection | Scoped connection class |
| Csigh | Unmanaged signal handler |
| Csigh< Ret(Args...), Allocator > | Unmanaged signal handler |
| Csigh_helper | Primary template isn't defined on purpose |
| Csigh_helper< Registry > | Signal connection helper for registries |
| Csigh_helper< Registry, Type > | Signal connection helper for registries |
| Csink | Sink class |
| Csink< sigh< Ret(Args...), Allocator > > | Sink class |
| Csize_of | A type-only sizeof wrapper that returns 0 where sizeof complains |
| Csize_of< Type, std::void_t< decltype(sizeof(Type))> > | A type-only sizeof wrapper that returns 0 where sizeof complains. |
| Cstd_sort | Function object to wrap std::sort in a class type |
| Cstorage_for | |
| Cstorage_type | Provides a common way to define storage types |
| Cstorage_type< reactive, Entity, Allocator > | |
| Ctombstone_t | Tombstone object for all identifiers.
|
| Ctype_hash | Type hash |
| Ctype_identity | Identity type trait |
| Ctype_index | Type sequential identifier |
| Ctype_info | Implementation specific information about a type |
| Ctype_list | A class to use to push around lists of types, nothing more |
| Ctype_list_cat | Primary template isn't defined on purpose |
| Ctype_list_cat< type_list< Type... > > | Concatenates multiple type lists |
| Ctype_list_cat< type_list< Type... >, type_list< Other... >, List... > | Concatenates multiple type lists |
| Ctype_list_cat<> | Concatenates multiple type lists |
| Ctype_list_contains | Provides the member constant value to true if a type list contains a given type, false otherwise |
| Ctype_list_contains< type_list< Type... >, Other > | Provides the member constant value to true if a type list contains a given type, false otherwise. |
| Ctype_list_diff | Primary template isn't defined on purpose |
| Ctype_list_diff< type_list< Type... >, type_list< Other... > > | Computes the difference between two type lists |
| Ctype_list_element | Primary template isn't defined on purpose |
| Ctype_list_element< 0u, type_list< First, Other... > > | Provides compile-time indexed access to the types of a type list |
| Ctype_list_element< Index, type_list< First, Other... > > | Provides compile-time indexed access to the types of a type list |
| Ctype_list_index | Primary template isn't defined on purpose |
| Ctype_list_index< Type, type_list< First, Other... > > | Provides compile-time type access to the types of a type list |
| Ctype_list_index< Type, type_list< Type, Other... > > | Provides compile-time type access to the types of a type list |
| Ctype_list_index< Type, type_list<> > | Provides compile-time type access to the types of a type list |
| Ctype_list_transform | Primary template isn't defined on purpose |
| Ctype_list_transform< exclude_t< Type... >, Op > | Applies a given function to an exclude list and generate a new list |
| Ctype_list_transform< get_t< Type... >, Op > | Applies a given function to a get list and generate a new list |
| Ctype_list_transform< owned_t< Type... >, Op > | Applies a given function to an owned list and generate a new list |
| Ctype_list_transform< type_list< Type... >, Op > | Applies a given function to a type list and generate a new list |
| Ctype_list_unique | Removes duplicates types from a type list |
| Ctype_name | Type name |
| Cundirected_tag | Directed graph category tag |
| Cvalue_list | A class to use to push around lists of constant values, nothing more |
| Cvalue_list_cat | Primary template isn't defined on purpose |
| Cvalue_list_cat< value_list< Value... > > | Concatenates multiple value lists |
| Cvalue_list_cat< value_list< Value... >, value_list< Other... >, List... > | Concatenates multiple value lists |
| Cvalue_list_cat<> | Concatenates multiple value lists |
| Cvalue_list_contains | Provides the member constant value to true if a value list contains a given value, false otherwise |
| Cvalue_list_contains< value_list< Value... >, Other > | Provides the member constant value to true if a value list contains a given value, false otherwise. |
| Cvalue_list_diff | Primary template isn't defined on purpose |
| Cvalue_list_diff< value_list< Value... >, value_list< Other... > > | Computes the difference between two value lists |
| Cvalue_list_element | Primary template isn't defined on purpose |
| Cvalue_list_element< 0u, value_list< Value, Other... > > | Provides compile-time indexed access to the types of a type list |
| Cvalue_list_element< Index, value_list< Value, Other... > > | Provides compile-time indexed access to the values of a value list |
| Cvalue_list_index | Primary template isn't defined on purpose |
| Cvalue_list_index< Value, value_list< First, Other... > > | Provides compile-time type access to the values of a value list |
| Cvalue_list_index< Value, value_list< Value, Other... > > | Provides compile-time type access to the values of a value list |
| Cvalue_list_index< Value, value_list<> > | Provides compile-time type access to the values of a value list |
| Cvalue_list_unique | Primary template isn't defined on purpose |
| Cvalue_list_unique< value_list< Value, Other... > > | Removes duplicates values from a value list |
| Cvalue_list_unique< value_list<> > | Removes duplicates values from a value list |
| Cy_combinator | Basic implementation of a y-combinator |
| ►Nstd | |
| Ctuple_element< Index, entt::compressed_pair< First, Second > > | std::tuple_element specialization for compressed_pairs |
| Ctuple_element< Index, entt::type_list< Type... > > | |
| Ctuple_element< Index, entt::value_list< Value... > > | |
| Ctuple_size< entt::compressed_pair< First, Second > > | std::tuple_size specialization for compressed_pairs |
| Ctuple_size< entt::type_list< Type... > > | |
| Ctuple_size< entt::value_list< Value... > > | |
