diff --git a/adjacency__matrix_8hpp_source.html b/adjacency__matrix_8hpp_source.html index f0fd38464..170f620e6 100644 --- a/adjacency__matrix_8hpp_source.html +++ b/adjacency__matrix_8hpp_source.html @@ -1,9 +1,9 @@ - +
- +| ►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_continuous_loader | Utility class for continuous loading |
| Cbasic_dispatcher | Basic dispatcher 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_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_registry | Fast and reliable entity-component system |
| Cbasic_runtime_view | Generic runtime view |
| 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 | Basic sparse set implementation |
| Cbasic_storage | Basic storage implementation |
| Cbasic_storage< Type, Entity, Allocator, std::enable_if_t< ignore_as_empty_v< Type > > > | Default constructor. |
| Cbasic_view | View implementation |
| Cbasic_view< get_t< Get >, exclude_t<>, std::void_t< std::enable_if_t<!component_traits< typename Get::value_type >::in_place_delete > > > | Single component view specialization |
| Cbasic_view< get_t< Get... >, exclude_t< Exclude... > > | Multi component 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. |
| Cfamily | Dynamic identifier generator |
| Cforward_apply | Utility class to forward-and-apply tuple objects |
| 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< Type, std::void_t< decltype(std::declval< Type >()==std::declval< 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_same_v< std::remove_cv_t< std::remove_pointer_t< Type > >, void > > > | 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_data | Opaque wrapper for data members |
| Cmeta_factory | Basic 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 given function or member function |
| Cnull_t | Null object for all identifiers. + |
| 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_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_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_registry | Fast and reliable entity-component system |
| Cbasic_runtime_view | Generic runtime view |
| Cbasic_scheduler | Cooperative scheduler for processes |
| 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 | Basic sparse set implementation |
| Cbasic_storage | Basic 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_view | View implementation |
| Cbasic_view< get_t< Get >, exclude_t<>, std::void_t< std::enable_if_t<!Get::traits_type::in_place_delete > > > | Single component view specialization |
| Cbasic_view< get_t< Get... >, exclude_t< Exclude... > > | Multi component 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 components |
| 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< Type, std::void_t< decltype(std::declval< Type >()==std::declval< Type >())> > | Provides the member constant value to true if a given type is equality comparable, false otherwise. |
| Cis_equality_comparable< Type[N]> | 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_same_v< std::remove_cv_t< std::remove_pointer_t< Type > >, void > > > | 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_data | Opaque wrapper for data members |
| Cmeta_factory | Basic 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 given function or member function |
| Cnull_t | Null object for all identifiers. |
| Coverloaded | Helper type for visitors |
| 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 |
| Cresource | Basic resource handle |
| Cresource_cache | Basic cache for resources of any type |
| Cresource_loader | Transparent loader for shared resources |
| Cscheduler | Cooperative scheduler for processes |
| Cscoped_connection | Scoped connection class |
| Csigh | Unmanaged signal handler |
| Csigh< Ret(Args...), Allocator > | Unmanaged signal handler |
| Csigh_storage_mixin | Mixin type used to add signal support to storage types |
| 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 |
| Ctombstone_t | Tombstone object for all identifiers. + |
| Coverloaded | Helper type for visitors |
| Cowned_t | Alias for lists of owned components |
| 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 |
| 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 |
| Csigh_mixin | Mixin type used to add signal support to storage types |
| 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 |
| 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< type_list< Type... >, Op > | Applies a given function to a type list and generate a new list |
| Ctype_list_unique | Primary template isn't defined on purpose |
| Ctype_list_unique< type_list< Type, Other... > > | Removes duplicates types from a type list |
| Ctype_list_unique< type_list<> > | 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_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 |
| Cy_combinator | Basic implementation of a y-combinator |
| ►Nstd | |
| 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 | Primary template isn't defined on purpose |
| Ctype_list_unique< type_list< Type, Other... > > | Removes duplicates types from a type list |
| Ctype_list_unique< type_list<> > | 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_size< entt::compressed_pair< First, Second > > | std::tuple_size 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... > > |
Public Member Functions | |
| adjacency_matrix () noexcept(noexcept(allocator_type{})) | |
| Default constructor. More... | |
| Default constructor. | |
| adjacency_matrix (const allocator_type &allocator) noexcept | |
| Constructs an empty container with a given allocator. More... | |
| Constructs an empty container with a given allocator. | |
| adjacency_matrix (const size_type vertices, const allocator_type &allocator=allocator_type{}) | |
| Constructs an empty container with a given allocator and user supplied number of vertices. More... | |
| Constructs an empty container with a given allocator and user supplied number of vertices. | |
| adjacency_matrix (const adjacency_matrix &other) | |
| Copy constructor. More... | |
| Copy constructor. | |
| adjacency_matrix (const adjacency_matrix &other, const allocator_type &allocator) | |
| Allocator-extended copy constructor. More... | |
| Allocator-extended copy constructor. | |
| adjacency_matrix (adjacency_matrix &&other) noexcept | |
| Move constructor. More... | |
| Move constructor. | |
| adjacency_matrix (adjacency_matrix &&other, const allocator_type &allocator) | |
| Allocator-extended move constructor. More... | |
| Allocator-extended move constructor. | |
| adjacency_matrix & | operator= (const adjacency_matrix &other) |
| Default copy assignment operator. More... | |
| Default copy assignment operator. | |
| adjacency_matrix & | operator= (adjacency_matrix &&other) noexcept |
| Default move assignment operator. More... | |
| Default move assignment operator. | |
| constexpr allocator_type | get_allocator () const noexcept |
| Returns the associated allocator. More... | |
| Returns the associated allocator. | |
| void | clear () noexcept |
| Clears the adjacency matrix. More... | |
| Clears the adjacency matrix. | |
| void | swap (adjacency_matrix &other) |
| Exchanges the contents with those of a given adjacency matrix. More... | |
| Exchanges the contents with those of a given adjacency matrix. | |
| size_type | size () const noexcept |
| Returns the number of vertices. More... | |
| Returns the number of vertices. | |
| iterable_adaptor< vertex_iterator > | vertices () const noexcept |
| Returns an iterable object to visit all vertices of a matrix. More... | |
| Returns an iterable object to visit all vertices of a matrix. | |
| iterable_adaptor< edge_iterator > | edges () const noexcept |
| Returns an iterable object to visit all edges of a matrix. More... | |
| Returns an iterable object to visit all edges of a matrix. | |
| iterable_adaptor< out_edge_iterator > | out_edges (const vertex_type vertex) const noexcept |
| Returns an iterable object to visit all out edges of a vertex. More... | |
| Returns an iterable object to visit all out edges of a vertex. | |
| iterable_adaptor< in_edge_iterator > | in_edges (const vertex_type vertex) const noexcept |
| Returns an iterable object to visit all in edges of a vertex. More... | |
| Returns an iterable object to visit all in edges of a vertex. | |
| void | resize (const size_type vertices) |
| Resizes an adjacency matrix. More... | |
| Resizes an adjacency matrix. | |
| std::pair< edge_iterator, bool > | insert (const vertex_type lhs, const vertex_type rhs) |
| Inserts an edge into the adjacency matrix, if it does not exist. More... | |
| Inserts an edge into the adjacency matrix, if it does not exist. | |
| size_type | erase (const vertex_type lhs, const vertex_type rhs) |
| Removes the edge associated with a pair of given vertices. More... | |
| Removes the edge associated with a pair of given vertices. | |
| bool | contains (const vertex_type lhs, const vertex_type rhs) const |
| Checks if an adjacency matrix contains a given edge. More... | |
| Checks if an adjacency matrix contains a given edge. | |
Basic implementation of a directed adjacency matrix.
+class entt::adjacency_matrix< Category, Allocator >Basic implementation of a directed adjacency matrix.
| Category | Either a directed or undirected category tag. |
|
- EnTT 3.11.0
+ EnTT 3.12.0
|
This is the complete list of members for entt::as_group< Registry >, including all inherited members.
| as_group(registry_type &source) noexcept | entt::as_group< Registry > | inline |
| entity_type typedef | entt::as_group< Registry > | |
| entity_type typedef | entt::as_group< Registry > | |
| operator basic_group< Owned, Get, Exclude >() const | entt::as_group< Registry > | inline |
| registry_type typedef | entt::as_group< Registry > |
Public Member Functions | |
| as_group (registry_type &source) noexcept | |
| Constructs a converter for a given registry. More... | |
| Constructs a converter for a given registry. | |
| template<typename Owned , typename Get , typename Exclude > | |
| operator basic_group< Owned, Get, Exclude > () const | |
| Conversion function from a registry to a group. More... | |
| Conversion function from a registry to a group. | |
Converts a registry to a group.
+class entt::as_group< Registry >Converts a registry to a group.
| Registry | Basic registry type. |
| using entt::as_group< Registry >::entity_type = std::remove_const_t<typename registry_type::entity_type> | +using entt::as_group< Registry >::entity_type = typename registry_type::entity_type |
This is the complete list of members for entt::as_view< Registry >, including all inherited members.
| as_view(registry_type &source) noexcept | entt::as_view< Registry > | inline |
| entity_type typedef | entt::as_view< Registry > | |
| entity_type typedef | entt::as_view< Registry > | |
| operator basic_view< Get, Exclude >() const | entt::as_view< Registry > | inline |
| registry_type typedef | entt::as_view< Registry > |
Public Member Functions | |
| as_view (registry_type &source) noexcept | |
| Constructs a converter for a given registry. More... | |
| Constructs a converter for a given registry. | |
| template<typename Get , typename Exclude > | |
| operator basic_view< Get, Exclude > () const | |
| Conversion function from a registry to a view. More... | |
| Conversion function from a registry to a view. | |
Converts a registry to a view.
+class entt::as_view< Registry >Converts a registry to a view.
| Registry | Basic registry type. |
| using entt::as_view< Registry >::entity_type = std::remove_const_t<typename registry_type::entity_type> | +using entt::as_view< Registry >::entity_type = typename registry_type::entity_type |

Public Member Functions | |
| constexpr | basic_any () noexcept |
| Default constructor. More... | |
| Default constructor. | |
| template<typename Type , typename... Args> | |
| basic_any (std::in_place_type_t< Type >, Args &&...args) | |
| Constructs a wrapper by directly initializing the new object. More... | |
| Constructs a wrapper by directly initializing the new object. | |
| template<typename Type , typename = std::enable_if_t<!std::is_same_v<std::decay_t<Type>, basic_any>>> | |
| basic_any (Type &&value) | |
| Constructs a wrapper from a given value. More... | |
| Constructs a wrapper from a given value. | |
| basic_any (const basic_any &other) | |
| Copy constructor. More... | |
| Copy constructor. | |
| basic_any (basic_any &&other) noexcept | |
| Move constructor. More... | |
| Move constructor. | |
| ~basic_any () | |
| Frees the internal storage, whatever it means. More... | |
| Frees the internal storage, whatever it means. | |
| basic_any & | operator= (const basic_any &other) |
| Copy assignment operator. More... | |
| Copy assignment operator. | |
| basic_any & | operator= (basic_any &&other) noexcept |
| Move assignment operator. More... | |
| Move assignment operator. | |
| template<typename Type > | |
| std::enable_if_t<!std::is_same_v< std::decay_t< Type >, basic_any >, basic_any & > | operator= (Type &&value) |
| Value assignment operator. More... | |
| Value assignment operator. | |
| const type_info & | type () const noexcept |
Returns the object type if any, type_id<void>() otherwise. More... | |
Returns the object type if any, type_id<void>() otherwise. | |
| const void * | data () const noexcept |
| Returns an opaque pointer to the contained instance. More... | |
| Returns an opaque pointer to the contained instance. | |
| const void * | data (const type_info &req) const noexcept |
| Returns an opaque pointer to the contained instance. More... | |
| Returns an opaque pointer to the contained instance. | |
| void * | data () noexcept |
| Returns an opaque pointer to the contained instance. More... | |
| Returns an opaque pointer to the contained instance. | |
| void * | data (const type_info &req) noexcept |
| Returns an opaque pointer to the contained instance. More... | |
| Returns an opaque pointer to the contained instance. | |
| template<typename Type , typename... Args> | |
| void | emplace (Args &&...args) |
| Replaces the contained object by creating a new instance directly. More... | |
| Replaces the contained object by creating a new instance directly. | |
| bool | assign (const basic_any &other) |
| Assigns a value to the contained object without replacing it. More... | |
| Assigns a value to the contained object without replacing it. | |
| bool | assign (basic_any &&other) |
| Assigns a value to the contained object without replacing it. More... | |
| Assigns a value to the contained object without replacing it. | |
| void | reset () |
| Destroys contained object. More... | |
| Destroys contained object. | |
| operator bool () const noexcept | |
| Returns false if a wrapper is empty, true otherwise. More... | |
| Returns false if a wrapper is empty, true otherwise. | |
| bool | operator== (const basic_any &other) const noexcept |
| Checks if two wrappers differ in their content. More... | |
| Checks if two wrappers differ in their content. | |
| bool | operator!= (const basic_any &other) const noexcept |
| Checks if two wrappers differ in their content. More... | |
| Checks if two wrappers differ in their content. | |
| basic_any | as_ref () noexcept |
| Aliasing constructor. More... | |
| Aliasing constructor. | |
| basic_any | as_ref () const noexcept |
| Aliasing constructor. More... | |
| Aliasing constructor. | |
| bool | owner () const noexcept |
| Returns true if a wrapper owns its object, false otherwise. More... | |
| Returns true if a wrapper owns its object, false otherwise. | |
Static Public Attributes | |
| static constexpr auto | length = Len |
| Size of the internal storage. More... | |
| Size of the internal storage. | |
| static constexpr auto | alignment = Align |
| Alignment requirement. More... | |
| Alignment requirement. | |
A SBO friendly, type-safe container for single values of any type.
+class entt::basic_any< Len, Align >A SBO friendly, type-safe container for single values of any type.
| Len | Size of the storage reserved for the small buffer optimization. |
Aliasing constructor.
-Aliasing constructor.
+Assigns a value to the contained object without replacing it.
+Assigns a value to the contained object without replacing it.
| other | The value to assign to the contained object. |
Public Member Functions | |
| basic_continuous_loader (registry_type &source) noexcept | |
| Constructs an instance that is bound to a given registry. More... | |
| Constructs an instance that is bound to a given registry. | |
| basic_continuous_loader (basic_continuous_loader &&)=default | |
| Default move constructor. | |
| basic_continuous_loader & | operator= (basic_continuous_loader &&)=default |
| Default move assignment operator. More... | |
| Default move assignment operator. | |
| template<typename Type , typename Archive > | |
| basic_continuous_loader & | get (Archive &archive, const id_type id=type_hash< Type >::value()) |
| Restores all elements of a type with associated identifiers. | |
| template<typename Archive > | |
| basic_continuous_loader & | entities (Archive &archive) |
| Restores entities that were in use during serialization. More... | |
| Restores all identifiers, including those to be recycled. | |
| template<typename... Component, typename Archive , typename... Other, typename... Member> | |
| basic_continuous_loader & | component (Archive &archive, Member Other::*...member) |
| Restores components and assigns them to the right entities. More... | |
| template<typename... Component, typename Archive , typename... Member, typename... Clazz> | |
| basic_continuous_loader & | component (Archive &archive, Member Clazz::*...member) |
| Serializes all elements of a type with associated identifiers. | |
| basic_continuous_loader & | shrink () |
| Helps to purge entities that no longer have a conterpart. More... | |
| Helps to purge entities that no longer have a counterpart. | |
| basic_continuous_loader & | orphans () |
| Destroys those entities that have no components. More... | |
| Destroys those entities that have no components. | |
| bool | contains (entity_type entt) const noexcept |
| Tests if a loader knows about a given entity. More... | |
| Tests if a loader knows about a given entity. | |
| entity_type | map (entity_type entt) const noexcept |
| Returns the identifier to which an entity refers. More... | |
| Returns the identifier to which an entity refers. | |
Utility class for continuous loading.
-A continuous loader is designed to load data from a source registry to a (possibly) non-empty destination. The loader can accommodate in a registry more than one snapshot in a sort of continuous loading that updates the destination one step at a time.
+class entt::basic_continuous_loader< Registry >
Utility class for continuous loading.
+A continuous loader is designed to load data from a source registry to a (possibly) non-empty destination. The loader can accommodate in a registry more than one snapshot in a sort of continuous loading that updates the destination one step at a time.
Identifiers that entities originally had are not transferred to the target. Instead, the loader maps remote identifiers to local ones while restoring a snapshot.
- An example of use is the implementation of a client-server applications with the requirement of transferring somehow parts of the representation side to side.
| Registry | Basic registry type. |
Basic registry type.
+Basic registry type.
-Definition at line 410 of file snapshot.hpp.
+Definition at line 395 of file snapshot.hpp.
Definition at line 418 of file snapshot.hpp.
+Definition at line 403 of file snapshot.hpp.
| @@ -236,7 +247,7 @@ template<typename... Component, typename Archive , typename... Other, typenam | ||||
| - | Member Other::*... | +Member Clazz::*... | member | |
Restores components and assigns them to the right entities.
-The template parameter list must be exactly the same used during serialization. In the event that the entity to which the component is assigned doesn't exist yet, the loader will take care to create a local counterpart for it.
- Members can be either data members of type entity_type or containers of entities. In both cases, the loader will visit them and update the entities by replacing each one with its local counterpart.
Serializes all elements of a type with associated identifiers.
+It creates local counterparts for remote elements as needed.
+ Members are either data members of type entity_type or containers of entities. In both cases, a loader visits them and replaces entities with their local counterpart.
| Component | Type of component to restore. |
| Archive | Type of input archive. |
| Other | Types of components to update with local counterparts. |
| Member | Types of members to update with their local counterparts. |
Definition at line 479 of file snapshot.hpp.
+Definition at line 508 of file snapshot.hpp.
entity is managed by the loader, false otherwise. Definition at line 540 of file snapshot.hpp.
+Definition at line 570 of file snapshot.hpp.
Restores entities that were in use during serialization.
-This function restores the entities that were in use during serialization and creates local counterparts for them if required.
+Restores all identifiers, including those to be recycled.
+It creates local counterparts for remote elements as needed.
| Archive | Type of input archive. |
+
|
+ +inline | +
Restores all elements of a type with associated identifiers.
+It creates local counterparts for remote elements as needed.
+ Members are either data members of type entity_type or containers of entities. In both cases, a loader visits them and replaces entities with their local counterpart.
| Type | Type of elements to restore. |
| Archive | Type of input archive. |
| archive | A valid reference to an input archive. |
| id | Optional name used to map the storage within the registry. |
Definition at line 428 of file snapshot.hpp.
Definition at line 549 of file snapshot.hpp.
+Definition at line 580 of file snapshot.hpp.
Destroys those entities that have no components.
-In case all the entities were serialized but only part of the components was saved, it could happen that some of the entities have no components once restored.
- This functions helps to identify and destroy those entities.
In case all the entities were serialized but only part of the components was saved, it could happen that some of the entities have no components once restored.
+ This function helps to identify and destroy those entities.
Definition at line 525 of file snapshot.hpp.
+Definition at line 560 of file snapshot.hpp.
Helps to purge entities that no longer have a conterpart.
-Users should invoke this member function after restoring each snapshot, unless they know exactly what they are doing.
+Helps to purge entities that no longer have a counterpart.
+Users should invoke this member function after restoring each snapshot, unless they know exactly what they are doing.
Definition at line 493 of file snapshot.hpp.
+Definition at line 546 of file snapshot.hpp.
Public Member Functions | |
| basic_dispatcher () | |
| Default constructor. More... | |
| Default constructor. | |
| basic_dispatcher (const allocator_type &allocator) | |
| Constructs a dispatcher with a given allocator. More... | |
| Constructs a dispatcher with a given allocator. | |
| basic_dispatcher (basic_dispatcher &&other) noexcept | |
| Move constructor. More... | |
| Move constructor. | |
| basic_dispatcher (basic_dispatcher &&other, const allocator_type &allocator) noexcept | |
| Allocator-extended move constructor. More... | |
| Allocator-extended move constructor. | |
| basic_dispatcher & | operator= (basic_dispatcher &&other) noexcept |
| Move assignment operator. More... | |
| Move assignment operator. | |
| void | swap (basic_dispatcher &other) |
| Exchanges the contents with those of a given dispatcher. More... | |
| Exchanges the contents with those of a given dispatcher. | |
| constexpr allocator_type | get_allocator () const noexcept |
| Returns the associated allocator. More... | |
| Returns the associated allocator. | |
| template<typename Type > | |
| size_type | size (const id_type id=type_hash< Type >::value()) const noexcept |
| Returns the number of pending events for a given type. More... | |
| Returns the number of pending events for a given type. | |
| size_type | size () const noexcept |
| Returns the total number of pending events. More... | |
| Returns the total number of pending events. | |
| template<typename Type > | |
| auto | sink (const id_type id=type_hash< Type >::value()) |
| Returns a sink object for the given event and queue. More... | |
| Returns a sink object for the given event and queue. | |
| template<typename Type > | |
| void | trigger (Type &&value={}) |
| Triggers an immediate event of a given type. More... | |
| Triggers an immediate event of a given type. | |
| template<typename Type > | |
| void | trigger (const id_type id, Type &&value={}) |
| Triggers an immediate event on a queue of a given type. More... | |
| Triggers an immediate event on a queue of a given type. | |
| template<typename Type , typename... Args> | |
| void | enqueue (Args &&...args) |
| Enqueues an event of the given type. More... | |
| Enqueues an event of the given type. | |
| template<typename Type > | |
| void | enqueue (Type &&value) |
| Enqueues an event of the given type. More... | |
| Enqueues an event of the given type. | |
| template<typename Type , typename... Args> | |
| void | enqueue_hint (const id_type id, Args &&...args) |
| Enqueues an event of the given type. More... | |
| Enqueues an event of the given type. | |
| template<typename Type > | |
| void | enqueue_hint (const id_type id, Type &&value) |
| Enqueues an event of the given type. More... | |
| Enqueues an event of the given type. | |
| template<typename Type > | |
| void | disconnect (Type &value_or_instance) |
| Utility function to disconnect everything related to a given value or instance from a dispatcher. More... | |
| Utility function to disconnect everything related to a given value or instance from a dispatcher. | |
| template<typename Type > | |
| void | disconnect (Type *value_or_instance) |
| Utility function to disconnect everything related to a given value or instance from a dispatcher. More... | |
| Utility function to disconnect everything related to a given value or instance from a dispatcher. | |
| template<typename Type > | |
| void | clear (const id_type id=type_hash< Type >::value()) |
| Discards all the events stored so far in a given queue. More... | |
| Discards all the events stored so far in a given queue. | |
| void | clear () noexcept |
| Discards all the events queued so far. More... | |
| Discards all the events queued so far. | |
| template<typename Type > | |
| void | update (const id_type id=type_hash< Type >::value()) |
| Delivers all the pending events of a given queue. More... | |
| Delivers all the pending events of a given queue. | |
| void | update () const |
| Delivers all the pending events. More... | |
| Delivers all the pending events. | |
Basic dispatcher implementation.
-A dispatcher can be used either to trigger an immediate event or to enqueue events to be published all together once per tick.
+class entt::basic_dispatcher< Allocator >
Basic dispatcher implementation.
+A dispatcher can be used either to trigger an immediate event or to enqueue events to be published all together once per tick.
Listeners are provided in the form of member functions. For each event of type Type, listeners are such that they can be invoked with an argument of type Type &, no matter what the return type is.
The dispatcher creates instances of the sigh class internally. Refer to the documentation of the latter for more details.
The dispatcher creates instances of the sigh class internally. Refer to the documentation of the latter for more details.
| Allocator | Type of allocator used to manage memory and elements. | ||||||||||||
|
+ EnTT 3.12.0
+
+ |
+
This is the complete list of members for entt::basic_entt_traits< Traits >, including all inherited members.
+| combine(const entity_type lhs, const entity_type rhs) noexcept | entt::basic_entt_traits< Traits > | inlinestatic |
| construct(const entity_type entity, const version_type version) noexcept | entt::basic_entt_traits< Traits > | inlinestatic |
| entity_mask | entt::basic_entt_traits< Traits > | static |
| entity_type typedef | entt::basic_entt_traits< Traits > | |
| next(const value_type value) noexcept | entt::basic_entt_traits< Traits > | inlinestatic |
| to_entity(const value_type value) noexcept | entt::basic_entt_traits< Traits > | inlinestatic |
| to_integral(const value_type value) noexcept | entt::basic_entt_traits< Traits > | inlinestatic |
| to_version(const value_type value) noexcept | entt::basic_entt_traits< Traits > | inlinestatic |
| value_type typedef | entt::basic_entt_traits< Traits > | |
| version_mask | entt::basic_entt_traits< Traits > | static |
| version_type typedef | entt::basic_entt_traits< Traits > |
|
+ EnTT 3.12.0
+
+ |
+
Common basic entity traits implementation. + More...
+ +#include <entity.hpp>
+Public Types | |
| using | value_type = typename Traits::value_type |
| Value type. | |
| using | entity_type = typename Traits::entity_type |
| Underlying entity type. | |
| using | version_type = typename Traits::version_type |
| Underlying version type. | |
+Static Public Member Functions | |
| static constexpr entity_type | to_integral (const value_type value) noexcept |
| Converts an entity to its underlying type. | |
| static constexpr entity_type | to_entity (const value_type value) noexcept |
| Returns the entity part once converted to the underlying type. | |
| static constexpr version_type | to_version (const value_type value) noexcept |
| Returns the version part once converted to the underlying type. | |
| static constexpr value_type | next (const value_type value) noexcept |
| Returns the successor of a given identifier. | |
| static constexpr value_type | construct (const entity_type entity, const version_type version) noexcept |
| Constructs an identifier from its parts. | |
| static constexpr value_type | combine (const entity_type lhs, const entity_type rhs) noexcept |
| Combines two identifiers in a single one. | |
+Static Public Attributes | |
| static constexpr entity_type | entity_mask = Traits::entity_mask |
| Entity mask size. | |
| static constexpr entity_type | version_mask = Traits::version_mask |
| Version mask size. | |
Common basic entity traits implementation.
+| Traits | Actual entity traits to use. |
Definition at line 74 of file entity.hpp.
+| using entt::basic_entt_traits< Traits >::entity_type = typename Traits::entity_type | +
Underlying entity type.
+ +Definition at line 84 of file entity.hpp.
+ +| using entt::basic_entt_traits< Traits >::value_type = typename Traits::value_type | +
Value type.
+ +Definition at line 82 of file entity.hpp.
+ +| using entt::basic_entt_traits< Traits >::version_type = typename Traits::version_type | +
Underlying version type.
+ +Definition at line 86 of file entity.hpp.
+ +
+
|
+ +inlinestaticconstexprnoexcept | +
Combines two identifiers in a single one.
+The returned identifier is a copy of the first element except for its version, which is taken from the second element.
+| lhs | The identifier from which to take the entity part. |
| rhs | The identifier from which to take the version part. |
Definition at line 154 of file entity.hpp.
+ +
+
|
+ +inlinestaticconstexprnoexcept | +
Constructs an identifier from its parts.
+If the version part is not provided, a tombstone is returned.
+ If the entity part is not provided, a null identifier is returned.
| entity | The entity part of the identifier. |
| version | The version part of the identifier. |
Definition at line 140 of file entity.hpp.
+ +
+
|
+ +inlinestaticconstexprnoexcept | +
Returns the successor of a given identifier.
+| value | The identifier of which to return the successor. |
Definition at line 125 of file entity.hpp.
+ +
+
|
+ +inlinestaticconstexprnoexcept | +
Returns the entity part once converted to the underlying type.
+| value | The value to convert. |
Definition at line 107 of file entity.hpp.
+ +
+
|
+ +inlinestaticconstexprnoexcept | +
Converts an entity to its underlying type.
+| value | The value to convert. |
Definition at line 98 of file entity.hpp.
+ +
+
|
+ +inlinestaticconstexprnoexcept | +
Returns the version part once converted to the underlying type.
+| value | The value to convert. |
Definition at line 116 of file entity.hpp.
+ +
+
|
+ +staticconstexpr | +
Entity mask size.
+ +Definition at line 89 of file entity.hpp.
+ +
+
|
+ +staticconstexpr | +
Version mask size.
+ +Definition at line 91 of file entity.hpp.
+ +Public Member Functions | |
| basic_flow () | |
| Default constructor. More... | |
| Default constructor. | |
| basic_flow (const allocator_type &allocator) | |
| Constructs a flow builder with a given allocator. More... | |
| Constructs a flow builder with a given allocator. | |
| basic_flow (const basic_flow &)=default | |
| Default copy constructor. | |
| basic_flow (const basic_flow &other, const allocator_type &allocator) | |
| Allocator-extended copy constructor. More... | |
| Allocator-extended copy constructor. | |
| basic_flow (basic_flow &&) noexcept=default | |
| Default move constructor. | |
| basic_flow (basic_flow &&other, const allocator_type &allocator) | |
| Allocator-extended move constructor. More... | |
| Allocator-extended move constructor. | |
| basic_flow & | operator= (const basic_flow &)=default |
| Default copy assignment operator. More... | |
| Default copy assignment operator. | |
| basic_flow & | operator= (basic_flow &&) noexcept=default |
| Default move assignment operator. More... | |
| Default move assignment operator. | |
| constexpr allocator_type | get_allocator () const noexcept |
| Returns the associated allocator. More... | |
| Returns the associated allocator. | |
| id_type | operator[] (const size_type pos) const |
| Returns the identifier at specified location. More... | |
| Returns the identifier at specified location. | |
| void | clear () noexcept |
| Clears the flow builder. More... | |
| Clears the flow builder. | |
| void | swap (basic_flow &other) |
| Exchanges the contents with those of a given flow builder. More... | |
| Exchanges the contents with those of a given flow builder. | |
| size_type | size () const noexcept |
| Returns the number of tasks. More... | |
| Returns the number of tasks. | |
| basic_flow & | bind (const id_type value) |
| Binds a task to a flow builder. More... | |
| Binds a task to a flow builder. | |
| basic_flow & | sync () |
| Turns the current task into a sync point. More... | |
| Turns the current task into a sync point. | |
| basic_flow & | set (const id_type res, bool is_rw=false) |
| Assigns a resource to the current task with a given access mode. More... | |
| Assigns a resource to the current task with a given access mode. | |
| basic_flow & | ro (const id_type res) |
| Assigns a read-only resource to the current task. More... | |
| Assigns a read-only resource to the current task. | |
| template<typename It > | |
| std::enable_if_t< std::is_same_v< std::remove_const_t< typename std::iterator_traits< It >::value_type >, id_type >, basic_flow & > | ro (It first, It last) |
| Assigns a range of read-only resources to the current task. More... | |
| Assigns a range of read-only resources to the current task. | |
| basic_flow & | rw (const id_type res) |
| Assigns a writable resource to the current task. More... | |
| Assigns a writable resource to the current task. | |
| template<typename It > | |
| std::enable_if_t< std::is_same_v< std::remove_const_t< typename std::iterator_traits< It >::value_type >, id_type >, basic_flow & > | rw (It first, It last) |
| Assigns a range of writable resources to the current task. More... | |
| Assigns a range of writable resources to the current task. | |
| adjacency_matrix< directed_tag > | graph () const |
| Generates a task graph for the current content. More... | |
| graph_type | graph () const |
| Generates a task graph for the current content. | |
Utility class for creating task graphs.
+class entt::basic_flow< Allocator >Utility class for creating task graphs.
| Allocator | Type of allocator used to manage memory and elements. |
| using entt::basic_flow< Allocator >::graph_type = adjacency_matrix_type | +
Iterable task list.
- +Unsigned integer type.
- +Default constructor.
- +Clears the flow builder.
- +Returns the associated allocator.
| adjacency_matrix< directed_tag > entt::basic_flow< Allocator >::graph | +graph_type entt::basic_flow< Allocator >::graph | ( | ) | const | @@ -532,12 +562,12 @@ template<typename Allocator >||
|
- EnTT 3.11.0
+ EnTT 3.12.0
|
Group.
-Primary template isn't defined on purpose. All the specializations give a compile-time error, but for a few reasonable cases.
+class entt::basic_group< typename, typename, typename >Group.
+Primary template isn't defined on purpose. All the specializations give a compile-time error, but for a few reasonable cases.
- +Public Member Functions | |
| basic_group () noexcept | |
| Default constructor to use to create empty, invalid groups. More... | |
| Default constructor to use to create empty, invalid groups. | |
| basic_group (const std::size_t &extent, Owned &...opool, Get &...gpool) noexcept | |
| Constructs a group from a set of storage classes. More... | |
| template<typename Type > | |
| decltype(auto) | storage () const noexcept |
| Returns the storage for a given component type. More... | |
| template<std::size_t Index> | |
| decltype(auto) | storage () const noexcept |
| Returns the storage for a given index. More... | |
| basic_group (handler &ref) noexcept | |
| Constructs a group from a set of storage classes. | |
| const common_type & | handle () const noexcept |
| Returns the leading storage of a group. | |
| template<typename Type > | |
| auto * | storage () const noexcept |
| Returns the storage for a given component type, if any. | |
| template<std::size_t Index> | |
| auto * | storage () const noexcept |
| Returns the storage for a given index, if any. | |
| size_type | size () const noexcept |
| Returns the number of entities that that are part of the group. More... | |
| Returns the number of entities that that are part of the group. | |
| bool | empty () const noexcept |
| Checks whether a group is empty. More... | |
| Checks whether a group is empty. | |
| iterator | begin () const noexcept |
| Returns an iterator to the first entity of the group. More... | |
| iterator | begin () const noexcept |
| Returns an iterator to the first entity of the group. | |
| iterator | end () const noexcept |
| Returns an iterator that is past the last entity of the group. More... | |
| iterator | end () const noexcept |
| Returns an iterator that is past the last entity of the group. | |
| reverse_iterator | rbegin () const noexcept |
| Returns an iterator to the first entity of the reversed group. More... | |
| reverse_iterator | rbegin () const noexcept |
| Returns an iterator to the first entity of the reversed group. | |
| reverse_iterator | rend () const noexcept |
| Returns an iterator that is past the last entity of the reversed group. More... | |
| reverse_iterator | rend () const noexcept |
| Returns an iterator that is past the last entity of the reversed group. | |
| entity_type | front () const noexcept |
| Returns the first entity of the group, if any. More... | |
| Returns the first entity of the group, if any. | |
| entity_type | back () const noexcept |
| Returns the last entity of the group, if any. More... | |
| Returns the last entity of the group, if any. | |
| iterator | find (const entity_type entt) const noexcept |
| Finds an entity. More... | |
| iterator | find (const entity_type entt) const noexcept |
| Finds an entity. | |
| entity_type | operator[] (const size_type pos) const |
| Returns the identifier that occupies the given position. More... | |
| Returns the identifier that occupies the given position. | |
| operator bool () const noexcept | |
| Checks if a group is properly initialized. More... | |
| Checks if a group is properly initialized. | |
| bool | contains (const entity_type entt) const noexcept |
| Checks if a group contains an entity. More... | |
| Checks if a group contains an entity. | |
| template<typename... Type> | |
| template<typename Type , typename... Other> | |
| decltype(auto) | get (const entity_type entt) const |
| Returns the components assigned to the given entity. | |
| template<std::size_t... Index> | |
| decltype(auto) | get (const entity_type entt) const |
| Returns the components assigned to the given entity. More... | |
| Returns the components assigned to the given entity. | |
| template<typename Func > | |
| void | each (Func func) const |
| Iterates entities and components and applies the given function object to them. More... | |
| Iterates entities and components and applies the given function object to them. | |
| iterable | each () const noexcept |
| Returns an iterable object to use to visit a group. More... | |
| Returns an iterable object to use to visit a group. | |
| template<typename... Type, typename Compare , typename Sort = std_sort, typename... Args> | |
| template<typename Type , typename... Other, typename Compare , typename Sort = std_sort, typename... Args> | |
| void | sort (Compare compare, Sort algo=Sort{}, Args &&...args) const |
| Sort a group according to the given comparison function. | |
| template<std::size_t... Index, typename Compare , typename Sort = std_sort, typename... Args> | |
| void | sort (Compare compare, Sort algo=Sort{}, Args &&...args) const |
| Sort a group according to the given comparison function. More... | |
| Sort a group according to the given comparison function. | |
Owning group.
-Owning groups returns all entities and only the entities that are at least in the given storage. Moreover:
+class entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >Owning group.
+Owning groups returns all entities and only the entities that are at least in the given storage. Moreover:
The more types of storage are owned, the faster it is to iterate a group.
-Important
-Iterators aren't invalidated if:
+The more types of storage are owned, the faster it is to iterate a group.
+Important
+Iterators aren't invalidated if:
In all other cases, modifying the pools iterated by the group in any way invalidates all the iterators and using them results in undefined behavior.
+In all other cases, modifying the pools iterated by the group in any way invalidates all the iterators.
| Owned | Types of storage owned by the group. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::base_type = basic_common_type | +using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::common_type = base_type |
| using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::entity_type = underlying_type | +using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::entity_type = underlying_type |
| using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::iterable = iterable_adaptor<internal::extended_group_iterator<iterator, owned_t<Owned...>, get_t<Get...> >> | +using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::handler = internal::group_handler<owned_t<std::remove_const_t<Owned>...>, get_t<std::remove_const_t<Get>...>, exclude_t<std::remove_const_t<Exclude>...> > | +
| using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::iterable = iterable_adaptor<internal::extended_group_iterator<iterator, owned_t<Owned...>, get_t<Get...> >> |
| using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::iterator = typename base_type::iterator | +using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::iterator = typename common_type::iterator |
| using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::reverse_iterator = typename base_type::reverse_iterator | +using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::reverse_iterator = typename common_type::reverse_iterator |
| using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::size_type = std::size_t | +using entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::size_type = std::size_t |
| entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::basic_group | +entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::basic_group | ( | ) | @@ -345,12 +386,12 @@ template<typename... Owned, typename... Get, typename... Exclude> |
|
@@ -394,20 +419,18 @@ template<typename... Owned, typename... Get, typename... Exclude> ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| extent | The actual number of entities to iterate. |
| opool | Storage types to iterate owned by the group. |
| gpool | Storage types to iterate observed by the group. |
| ref | A reference to a group handler. |
Definition at line 555 of file group.hpp.
+Definition at line 753 of file group.hpp.
| entity_type entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::back | +entity_type entt::basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >::back | ( | ) | const | @@ -434,12 +457,12 @@ template<typename... Owned, typename... Get, typename... Exclude>
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||