EnTT: Class List

EnTT 3.15.0

Loading...
Searching...
No Matches
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]

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