EnTT default namespace. More...

Classes
class	adjacency_matrix
	Basic implementation of a directed adjacency matrix. More...

struct	adl_meta_pointer_like
	Fake ADL based lookup function for meta pointer-like types. More...

struct	allocation_deleter
	Deleter for allocator-aware unique pointers (waiting for C++20). More...

struct	as_cref_t
	Empty class type used to request the as cref policy. More...

class	as_group
	Converts a registry to a group. More...

struct	as_is_t
	Empty class type used to request the as-is policy. More...

struct	as_ref_t
	Empty class type used to request the as ref policy. More...

class	as_view
	Converts a registry to a view. More...

struct	as_void_t
	Empty class type used to request the as void policy. More...

class	basic_any
	A SBO friendly, type-safe container for single values of any type. More...

class	basic_common_view
	Basic storage view implementation. More...

class	basic_continuous_loader
	Utility class for continuous loading. More...

class	basic_dispatcher
	Basic dispatcher implementation. More...

class	basic_entt_traits
	Common basic entity traits implementation. More...

class	basic_flow
	Utility class for creating task graphs. More...

class	basic_group
	Group. More...

class	basic_group< owned_t< Owned... >, get_t< Get... >, exclude_t< Exclude... > >
	Owning group. More...

class	basic_group< owned_t<>, get_t< Get... >, exclude_t< Exclude... > >
	Non-owning group. More...

class	basic_handle
	Non-owning handle to an entity. More...

class	basic_hashed_string
	Zero overhead unique identifier. More...

struct	basic_meta_associative_container_traits
	General purpose implementation of meta associative container traits. More...

struct	basic_meta_sequence_container_traits
	General purpose implementation of meta sequence container traits. More...

class	basic_organizer
	Utility class for creating a static task graph. More...

class	basic_poly
	Static polymorphism made simple and within everyone's reach. More...

class	basic_reactive_mixin
	Mixin type used to add reactive support to storage types. More...

class	basic_registry
	Fast and reliable entity-component system. More...

class	basic_runtime_view
	Generic runtime view. More...

class	basic_scheduler
	Cooperative scheduler for processes. More...

class	basic_sigh_mixin
	Mixin type used to add signal support to storage types. More...

class	basic_snapshot
	Utility class to create snapshots from a registry. More...

class	basic_snapshot_loader
	Utility class to restore a snapshot as a whole. More...

class	basic_sparse_set
	Sparse set implementation. More...

class	basic_storage
	Storage implementation. More...

class	basic_storage< Entity, Entity, Allocator >
	Swap-only entity storage specialization. More...

class	basic_storage< Type, Entity, Allocator, std::enable_if_t< component_traits< Type, Entity >::page_size==0u > >
	Default constructor. More...

class	basic_storage_view
	Basic storage view implementation. More...

class	basic_table
	Basic table implementation. More...

class	basic_view
	View implementation. More...

class	basic_view< get_t< Get >, exclude_t<> >
	Storage view specialization. More...

class	basic_view< get_t< Get... >, exclude_t< Exclude... >, std::enable_if_t<(sizeof...(Get) !=0u)> >
	General purpose view. More...

struct	choice_t
	Utility class to disambiguate overloaded functions. More...

struct	choice_t< 0 >
	Utility class to disambiguate overloaded functions. More...

struct	component_traits
	Common way to access various properties of components. More...

class	compressed_pair
	A compressed pair. More...

struct	connect_arg_t
	Disambiguation tag for constructors and the like. More...

class	connection
	Connection class. More...

struct	constness_as
	Transcribes the constness of a type to another type. More...

struct	constness_as< To, const From >
	Transcribes the constness of a type to another type. More...

class	delegate
	Basic delegate implementation. More...

class	delegate< Ret(Args...)>
	Utility class to use to send around functions and members.

class	dense_map
	Associative container for key-value pairs with unique keys. More...

class	dense_set
	Associative container for unique objects of a given type. More...

struct	directed_tag
	Undirected graph category tag. More...

class	emitter
	General purpose event emitter. More...

struct	entt_traits
	Entity traits. More...

struct	enum_as_bitmask
	Enable bitmask support for enum classes. More...

struct	enum_as_bitmask< Type, std::void_t< decltype(Type::_entt_enum_as_bitmask)> >
	Enable bitmask support for enum classes. More...

struct	exclude_t
	Alias for exclusion lists. More...

class	family
	Dynamic identifier generator. More...

struct	forward_apply
	Utility class to forward-and-apply tuple objects. More...

struct	get_t
	Alias for lists of observed elements. More...

class	ident
	Type integral identifiers. More...

struct	identity
	Identity function object (waiting for C++20). More...

struct	input_iterator_pointer
	Helper type to use as pointer with input iterators. More...

struct	insertion_sort
	Function object for performing insertion sort. More...

class	iota_iterator
	Plain iota iterator (waiting for C++20). More...

struct	is_applicable
	Same as std::is_invocable, but with tuples. More...

struct	is_applicable< Func, const Tuple< Args... > >
	Same as std::is_invocable, but with tuples. More...

struct	is_applicable< Func, Tuple< Args... > >
	Same as std::is_invocable, but with tuples. More...

struct	is_applicable_r
	Same as std::is_invocable_r, but with tuples for arguments. More...

struct	is_applicable_r< Ret, Func, std::tuple< Args... > >
	Same as std::is_invocable_r, but with tuples for arguments. More...

struct	is_complete
	Provides the member constant `value` to true if a given type is complete, false otherwise. More...

struct	is_complete< Type, std::void_t< decltype(sizeof(Type))> >
	Provides the member constant `value` to true if a given type is complete, false otherwise. More...

struct	is_ebco_eligible
	Provides the member constant `value` to true if a given type is both an empty and non-final class, false otherwise. More...

struct	is_equality_comparable
	Provides the member constant `value` to true if a given type is equality comparable, false otherwise. More...

struct	is_equality_comparable< const Type >
	Provides the member constant `value` to true if a given type is equality comparable, false otherwise. More...

struct	is_iterator
	Provides the member constant `value` to true if a given type is an iterator, false otherwise. More...

struct	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. More...

struct	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. More...

struct	is_meta_pointer_like< const Type >
	Partial specialization to ensure that const pointer-like types are also accepted. More...

struct	is_meta_pointer_like< std::shared_ptr< Type > >
	Makes `std::shared_ptr`s of any type pointer-like types for the meta system. More...

struct	is_meta_pointer_like< std::unique_ptr< Type, Args... > >
	Makes `std::unique_ptr`s of any type pointer-like types for the meta system. More...

struct	is_meta_pointer_like< Type * >
	Makes plain pointers pointer-like types for the meta system. More...

struct	is_meta_pointer_like< Type(*)[N]>
	Partial specialization used to reject pointers to arrays. More...

struct	is_meta_pointer_like< Type, std::void_t< typename Type::is_meta_pointer_like > >
	Specialization for self-proclaimed meta pointer like types. More...

struct	is_meta_policy
	Provides the member constant `value` to true if a type also is a meta policy, false otherwise. More...

struct	is_transparent
	Provides the member constant `value` to true if `Type::is_transparent` is valid and denotes a type, false otherwise. More...

struct	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. More...

struct	is_tuple
	Provides the member constant `value` to true if a given type is a tuple, false otherwise. More...

struct	is_tuple< std::tuple< Args... > >
	Provides the member constant `value` to true if a given type is a tuple, false otherwise. More...

struct	iterable_adaptor
	Utility class to create an iterable object from a pair of iterators. More...

class	locator
	Service locator, nothing more. More...

class	member_class
	Extracts the class of a non-static member object or function. More...

class	meta_any
	Opaque wrapper for values of any type. More...

class	meta_associative_container
	Proxy object for associative containers. More...

struct	meta_associative_container_traits
	Traits class template to be specialized to enable support for meta associative containers. More...

struct	meta_associative_container_traits< dense_map< Args... > >
	Meta associative container traits for `dense_map`s of any type. More...

struct	meta_associative_container_traits< dense_set< Args... > >
	Meta associative container traits for `dense_set`s of any type. More...

struct	meta_associative_container_traits< std::map< Args... > >
	Meta associative container traits for `std::map`s of any type. More...

struct	meta_associative_container_traits< std::set< Args... > >
	Meta associative container traits for `std::set`s of any type. More...

struct	meta_associative_container_traits< std::unordered_map< Args... > >
	Meta associative container traits for `std::unordered_map`s of any type. More...

struct	meta_associative_container_traits< std::unordered_set< Args... > >
	Meta associative container traits for `std::unordered_set`s of any type. More...

struct	meta_class_template_tag
	Utility class to disambiguate class templates. More...

class	meta_ctx
	Opaque meta context type. More...

class	meta_ctx_arg_t
	Disambiguation tag for constructors and the like. More...

struct	meta_custom
	Opaque wrapper for user defined data of any type. More...

struct	meta_data
	Opaque wrapper for data members. More...

class	meta_factory
	Meta factory to be used for reflection purposes. More...

struct	meta_func
	Opaque wrapper for member functions. More...

struct	meta_function_descriptor
	Primary template isn't defined on purpose. More...

struct	meta_function_descriptor< Type, Ret Class::* >
	Meta function descriptor. More...

struct	meta_function_descriptor< Type, Ret(*)()>
	Meta function descriptor. More...

struct	meta_function_descriptor< Type, Ret(*)(MaybeType, Args...)>
	Meta function descriptor. More...

struct	meta_function_descriptor< Type, Ret(Class::*)(Args...) const >
	Meta function descriptor. More...

struct	meta_function_descriptor< Type, Ret(Class::*)(Args...)>
	Meta function descriptor. More...

struct	meta_function_descriptor_traits
	Meta function descriptor traits. More...

class	meta_function_helper
	Meta function helper. More...

struct	meta_handle
	Opaque pointers to instances of any type. More...

class	meta_sequence_container
	Proxy object for sequence containers. More...

struct	meta_sequence_container_traits
	Traits class template to be specialized to enable support for meta sequence containers. More...

struct	meta_sequence_container_traits< std::array< Type, N > >
	Meta sequence container traits for `std::array`s of any type. More...

struct	meta_sequence_container_traits< std::deque< Args... > >
	Meta sequence container traits for `std::deque`s of any type. More...

struct	meta_sequence_container_traits< std::list< Args... > >
	Meta sequence container traits for `std::list`s of any type. More...

struct	meta_sequence_container_traits< std::vector< Args... > >
	Meta sequence container traits for `std::vector`s of any type. More...

struct	meta_template_traits
	Traits class template to be specialized to enable support for meta template information. More...

struct	meta_template_traits< Clazz< Args... > >
	General purpose traits class for generating meta template information. More...

class	meta_type
	Opaque wrapper for types. More...

struct	monostate
	Minimal implementation of the monostate pattern. More...

class	nth_argument
	Extracts the n-th argument of a callable type. More...

struct	null_t
	Null object for all identifiers. More...

struct	overloaded
	Helper type for visitors. More...

struct	owned_t
	Alias for lists of owned elements. More...

struct	poly_base
	Poly base class used to inject functionalities into concepts. More...

struct	poly_inspector
	Inspector class used to infer the type of the virtual table. More...

class	poly_vtable
	Static virtual table factory. More...

class	process
	Base class for processes. More...

struct	process_adaptor
	Adaptor for lambdas and functors to turn them into processes. More...

struct	radix_sort
	Function object for performing LSD radix sort. More...

struct	reactive
	Empty value type for reactive storage types. More...

class	resource
	Basic resource handle. More...

class	resource_cache
	Basic cache for resources of any type. More...

struct	resource_loader
	Transparent loader for shared resources. More...

struct	scoped_connection
	Scoped connection class. More...

class	sigh
	Unmanaged signal handler. More...

class	sigh< Ret(Args...), Allocator >
	Unmanaged signal handler.

struct	sigh_helper
	Primary template isn't defined on purpose. More...

struct	sigh_helper< Registry >
	Signal connection helper for registries. More...

struct	sigh_helper< Registry, Type >
	Signal connection helper for registries. More...

class	sink
	Sink class. More...

class	sink< sigh< Ret(Args...), Allocator > >
	Sink class.

struct	size_of
	A type-only `sizeof` wrapper that returns 0 where `sizeof` complains. More...

struct	size_of< Type, std::void_t< decltype(sizeof(Type))> >
	A type-only `sizeof` wrapper that returns 0 where `sizeof` complains. More...

struct	std_sort
	Function object to wrap `std::sort` in a class type. More...

struct	storage_for

struct	storage_type
	Provides a common way to define storage types. More...

struct	storage_type< reactive, Entity, Allocator >

struct	tombstone_t
	Tombstone object for all identifiers. More...

struct	type_hash
	Type hash. More...

struct	type_identity
	Identity type trait. More...

struct	type_index
	Type sequential identifier. More...

struct	type_info
	Implementation specific information about a type. More...

struct	type_list
	A class to use to push around lists of types, nothing more. More...

struct	type_list_cat
	Primary template isn't defined on purpose. More...

struct	type_list_cat< type_list< Type... > >
	Concatenates multiple type lists. More...

struct	type_list_cat< type_list< Type... >, type_list< Other... >, List... >
	Concatenates multiple type lists. More...

struct	type_list_cat<>
	Concatenates multiple type lists. More...

struct	type_list_contains
	Provides the member constant `value` to true if a type list contains a given type, false otherwise. More...

struct	type_list_contains< type_list< Type... >, Other >
	Provides the member constant `value` to true if a type list contains a given type, false otherwise. More...

struct	type_list_diff
	Primary template isn't defined on purpose. More...

struct	type_list_diff< type_list< Type... >, type_list< Other... > >
	Computes the difference between two type lists. More...

struct	type_list_element
	Primary template isn't defined on purpose. More...

struct	type_list_element< 0u, type_list< First, Other... > >
	Provides compile-time indexed access to the types of a type list. More...

struct	type_list_element< Index, type_list< First, Other... > >
	Provides compile-time indexed access to the types of a type list. More...

struct	type_list_index
	Primary template isn't defined on purpose. More...

struct	type_list_index< Type, type_list< First, Other... > >
	Provides compile-time type access to the types of a type list. More...

struct	type_list_index< Type, type_list< Type, Other... > >
	Provides compile-time type access to the types of a type list. More...

struct	type_list_index< Type, type_list<> >
	Provides compile-time type access to the types of a type list. More...

struct	type_list_transform
	Primary template isn't defined on purpose. More...

struct	type_list_transform< exclude_t< Type... >, Op >
	Applies a given function to an exclude list and generate a new list. More...

struct	type_list_transform< get_t< Type... >, Op >
	Applies a given function to a get list and generate a new list. More...

struct	type_list_transform< owned_t< Type... >, Op >
	Applies a given function to an owned list and generate a new list. More...

struct	type_list_transform< type_list< Type... >, Op >
	Applies a given function to a type list and generate a new list. More...

struct	type_list_unique
	Removes duplicates types from a type list. More...

struct	type_name
	Type name. More...

struct	undirected_tag
	Directed graph category tag. More...

struct	value_list
	A class to use to push around lists of constant values, nothing more. More...

struct	value_list_cat
	Primary template isn't defined on purpose. More...

struct	value_list_cat< value_list< Value... > >
	Concatenates multiple value lists. More...

struct	value_list_cat< value_list< Value... >, value_list< Other... >, List... >
	Concatenates multiple value lists. More...

struct	value_list_cat<>
	Concatenates multiple value lists. More...

struct	value_list_contains
	Provides the member constant `value` to true if a value list contains a given value, false otherwise. More...

struct	value_list_contains< value_list< Value... >, Other >
	Provides the member constant `value` to true if a value list contains a given value, false otherwise. More...

struct	value_list_diff
	Primary template isn't defined on purpose. More...

struct	value_list_diff< value_list< Value... >, value_list< Other... > >
	Computes the difference between two value lists. More...

struct	value_list_element
	Primary template isn't defined on purpose. More...

struct	value_list_element< 0u, value_list< Value, Other... > >
	Provides compile-time indexed access to the types of a type list. More...

struct	value_list_element< Index, value_list< Value, Other... > >
	Provides compile-time indexed access to the values of a value list. More...

struct	value_list_index
	Primary template isn't defined on purpose. More...

struct	value_list_index< Value, value_list< First, Other... > >
	Provides compile-time type access to the values of a value list. More...

struct	value_list_index< Value, value_list< Value, Other... > >
	Provides compile-time type access to the values of a value list. More...

struct	value_list_index< Value, value_list<> >
	Provides compile-time type access to the values of a value list. More...

struct	value_list_unique
	Primary template isn't defined on purpose. More...

struct	value_list_unique< value_list< Value, Other... > >
	Removes duplicates values from a value list. More...

struct	value_list_unique< value_list<> >
	Removes duplicates values from a value list. More...

struct	y_combinator
	Basic implementation of a y-combinator. More...

Typedefs
template<typename... Type>
using	table = basic_table<std::vector<Type>...>
	Alias declaration for the most common use case.

using	id_type = std::uint32_t
	Alias declaration for type identifiers.

using	any = basic_any<>
	Alias declaration for the most common use case.

using	hashed_string = basic_hashed_string<char>
	Aliases for common character types.

using	hashed_wstring = basic_hashed_string<wchar_t>
	Aliases for common character types.

template<typename Type>
using	type_identity_t = typename type_identity<Type>::type
	Helper type.

template<typename Type, typename>
using	unpack_as_type = Type
	Using declaration to be used to repeat the same type a number of times equal to the size of a given parameter pack.

template<auto Value>
using	integral_constant = std::integral_constant<decltype(Value), Value>
	Wraps a static constant.

template<id_type Value>
using	tag = integral_constant<Value>
	Alias template to facilitate the creation of named values.

template<std::size_t Index, typename List>
using	type_list_element_t = typename type_list_element<Index, List>::type
	Helper type.

template<typename... List>
using	type_list_cat_t = typename type_list_cat<List...>::type
	Helper type.

template<typename List>
using	type_list_unique_t = typename type_list_unique<List>::type
	Helper type.

template<typename... List>
using	type_list_diff_t = typename type_list_diff<List...>::type
	Helper type.

template<typename List, template< typename... > class Op>
using	type_list_transform_t = typename type_list_transform<List, Op>::type
	Helper type.

template<std::size_t Index, typename List>
using	value_list_element_t = typename value_list_element<Index, List>::type
	Helper type.

template<typename... List>
using	value_list_cat_t = typename value_list_cat<List...>::type
	Helper type.

template<typename Type>
using	value_list_unique_t = typename value_list_unique<Type>::type
	Helper type.

template<typename... List>
using	value_list_diff_t = typename value_list_diff<List...>::type
	Helper type.

template<typename To, typename From>
using	constness_as_t = typename constness_as<To, From>::type
	Alias template to facilitate the transcription of the constness.

template<typename Member>
using	member_class_t = typename member_class<Member>::type
	Helper type.

template<std::size_t Index, typename Candidate>
using	nth_argument_t = typename nth_argument<Index, Candidate>::type
	Helper type.

using	sparse_set = basic_sparse_set<>
	Alias declaration for the most common use case.

template<typename Type>
using	storage = basic_storage<Type>
	Alias declaration for the most common use case.

template<typename Type>
using	sigh_mixin = basic_sigh_mixin<Type, basic_registry<typename Type::entity_type, typename Type::base_type::allocator_type>>
	Alias declaration for the most common use case.

template<typename Type>
using	reactive_mixin = basic_reactive_mixin<Type, basic_registry<typename Type::entity_type, typename Type::base_type::allocator_type>>
	Alias declaration for the most common use case.

using	registry = basic_registry<>
	Alias declaration for the most common use case.

using	organizer = basic_organizer<registry>
	Alias declaration for the most common use case.

using	handle = basic_handle<registry>
	Alias declaration for the most common use case.

using	const_handle = basic_handle<const registry>
	Alias declaration for the most common use case.

template<typename... Args>
using	handle_view = basic_handle<registry, Args...>
	Alias declaration for the most common use case.

template<typename... Args>
using	const_handle_view = basic_handle<const registry, Args...>
	Alias declaration for the most common use case.

using	snapshot = basic_snapshot<registry>
	Alias declaration for the most common use case.

using	snapshot_loader = basic_snapshot_loader<registry>
	Alias declaration for the most common use case.

using	continuous_loader = basic_continuous_loader<registry>
	Alias declaration for the most common use case.

using	runtime_view = basic_runtime_view<sparse_set>
	Alias declaration for the most common use case.

using	const_runtime_view = basic_runtime_view<const sparse_set>
	Alias declaration for the most common use case.

template<typename... Args>
using	storage_type_t = typename storage_type<Args...>::type
	Helper type.

template<typename... Args>
using	storage_for_t = typename storage_for<Args...>::type
	Helper type.

template<typename Get, typename Exclude = exclude_t<>>
using	view = basic_view<type_list_transform_t<Get, storage_for>, type_list_transform_t<Exclude, storage_for>>
	Alias declaration for the most common use case.

template<typename Owned, typename Get = get_t<>, typename Exclude = exclude_t<>>
using	group = basic_group<type_list_transform_t<Owned, storage_for>, type_list_transform_t<Get, storage_for>, type_list_transform_t<Exclude, storage_for>>
	Alias declaration for the most common use case.

using	flow = basic_flow<>
	Alias declaration for the most common use case.

template<typename Type, typename It>
using	meta_range = iterable_adaptor<internal::meta_range_iterator<Type, It>>
	Iterable range to use to iterate all types of meta objects.

template<typename Type, typename Candidate>
using	meta_function_helper_t = typename meta_function_helper<Type, Candidate>::type
	Helper type.

template<typename Concept>
using	poly = basic_poly<Concept>
	Alias declaration for the most common use case.

using	scheduler = basic_scheduler<>
	Alias declaration for the most common use case.

using	dispatcher = basic_dispatcher<>
	Alias declaration for the most common use case.

Enumerations
enum class	any_policy : std::uint8_t { empty , dynamic , embedded , ref , cref }
	Possible modes of an any object. More...

enum class	entity : id_type
	Default entity identifier. More...

enum class	deletion_policy : std::uint8_t { swap_and_pop = 0u , in_place = 1u , swap_only = 2u , unspecified = swap_and_pop }
	Storage deletion policy. More...

enum class	any_policy
	Possible modes of an any object. More...

Functions
template<typename Type, std::size_t Len, std::size_t Align>
std::remove_const_t< Type >	any_cast (const basic_any< Len, Align > &data) noexcept
	Performs type-safe access to the contained object.

template<typename Type, std::size_t Len, std::size_t Align>
std::remove_const_t< Type >	any_cast (basic_any< Len, Align > &data) noexcept
	Performs type-safe access to the contained object.

template<typename Type, std::size_t Len, std::size_t Align>
std::remove_const_t< Type >	any_cast (basic_any< Len, Align > &&data) noexcept
	Performs type-safe access to the contained object.

template<typename Type, std::size_t Len, std::size_t Align>
const Type *	any_cast (const basic_any< Len, Align > *data) noexcept
	Performs type-safe access to the contained object.

template<typename Type, std::size_t Len, std::size_t Align>
Type *	any_cast (basic_any< Len, Align > *data) noexcept
	Performs type-safe access to the contained object.

template<typename Type, std::size_t Len = basic_any<>::length, std::size_t Align = basic_any<Len>::alignment, typename... Args>
basic_any< Len, Align >	make_any (Args &&...args)
	Constructs a wrapper from a given type, passing it all arguments.

template<std::size_t Len = basic_any<>::length, std::size_t Align = basic_any<Len>::alignment, typename Type>
basic_any< Len, Align >	forward_as_any (Type &&value)
	Forwards its argument and avoids copies for lvalue references.

template<typename Type>
constexpr std::enable_if_t< std::is_unsigned_v< Type >, int >	popcount (const Type value) noexcept
	Returns the number of set bits in a value (waiting for C++20 and `std::popcount`).

template<typename Type>
constexpr std::enable_if_t< std::is_unsigned_v< Type >, bool >	has_single_bit (const Type value) noexcept
	Checks whether a value is a power of two or not (waiting for C++20 and `std::has_single_bit`).

template<typename Type>
constexpr std::enable_if_t< std::is_unsigned_v< Type >, Type >	next_power_of_two (const Type value) noexcept
	Computes the smallest power of two greater than or equal to a value (waiting for C++20 and `std::bit_ceil`).

template<typename Type>
constexpr std::enable_if_t< std::is_unsigned_v< Type >, Type >	fast_mod (const Type value, const std::size_t mod) noexcept
	Fast module utility function (powers of two only).

template<typename Type, typename Other>
	compressed_pair (Type &&, Other &&) -> compressed_pair< std::decay_t< Type >, std::decay_t< Other > >
	Deduction guide.

template<typename First, typename Second>
constexpr void	swap (compressed_pair< First, Second > &lhs, compressed_pair< First, Second > &rhs) noexcept
	Swaps two compressed pair objects.

template<typename Char>
	basic_hashed_string (const Char *str, std::size_t len) -> basic_hashed_string< Char >
	Deduction guide.

template<typename Char, std::size_t N>
	basic_hashed_string (const Char(&str)[N]) -> basic_hashed_string< Char >
	Deduction guide.

template<typename Char>
constexpr bool	operator== (const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
	Compares two hashed strings.

template<typename Char>
constexpr bool	operator!= (const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
	Compares two hashed strings.

template<typename Char>
constexpr bool	operator< (const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
	Compares two hashed strings.

template<typename Char>
constexpr bool	operator<= (const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
	Compares two hashed strings.

template<typename Char>
constexpr bool	operator> (const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
	Compares two hashed strings.

template<typename Char>
constexpr bool	operator>= (const basic_hashed_string< Char > &lhs, const basic_hashed_string< Char > &rhs) noexcept
	Compares two hashed strings.

constexpr hashed_string	operator""_hs (const char *str, std::size_t) noexcept
	User defined literal for hashed strings.

constexpr hashed_wstring	operator""_hws (const wchar_t *str, std::size_t) noexcept
	User defined literal for hashed wstrings.

template<typename Type>
constexpr bool	operator== (const iota_iterator< Type > &lhs, const iota_iterator< Type > &rhs) noexcept
	Comparison operator.

template<typename Type>
constexpr bool	operator!= (const iota_iterator< Type > &lhs, const iota_iterator< Type > &rhs) noexcept
	Comparison operator.

template<typename Type>
constexpr auto	to_address (Type &&ptr) noexcept
	Unwraps fancy pointers, does nothing otherwise (waiting for C++20).

template<typename Allocator>
constexpr void	propagate_on_container_copy_assignment (Allocator &lhs, Allocator &rhs) noexcept
	Utility function to design allocation-aware containers.

template<typename Allocator>
constexpr void	propagate_on_container_move_assignment (Allocator &lhs, Allocator &rhs) noexcept
	Utility function to design allocation-aware containers.

template<typename Allocator>
constexpr void	propagate_on_container_swap (Allocator &lhs, Allocator &rhs) noexcept
	Utility function to design allocation-aware containers.

template<typename Type, typename Allocator, typename... Args>
constexpr auto	allocate_unique (Allocator &allocator, Args &&...args)
	Allows `std::unique_ptr` to use allocators (waiting for C++20).

template<typename Type, typename Allocator, typename... Args>
constexpr auto	uses_allocator_construction_args (const Allocator &allocator, Args &&...args) noexcept
	Uses-allocator construction utility (waiting for C++20).

template<typename Type, typename Allocator, typename... Args>
constexpr Type	make_obj_using_allocator (const Allocator &allocator, Args &&...args)
	Uses-allocator construction utility (waiting for C++20).

template<typename Type, typename Allocator, typename... Args>
constexpr Type *	uninitialized_construct_using_allocator (Type *value, const Allocator &allocator, Args &&...args)
	Uses-allocator construction utility (waiting for C++20).

template<typename Type>
constexpr decltype(auto)	unwrap_tuple (Type &&value) noexcept
	Utility function to unwrap tuples of a single element.

template<typename Func>
	forward_apply (Func) -> forward_apply< std::remove_reference_t< std::remove_cv_t< Func > > >
	Deduction guide.

constexpr bool	operator== (const type_info &lhs, const type_info &rhs) noexcept
	Compares the contents of two type info objects.

constexpr bool	operator!= (const type_info &lhs, const type_info &rhs) noexcept
	Compares the contents of two type info objects.

constexpr bool	operator< (const type_info &lhs, const type_info &rhs) noexcept
	Compares two type info objects.

constexpr bool	operator<= (const type_info &lhs, const type_info &rhs) noexcept
	Compares two type info objects.

constexpr bool	operator> (const type_info &lhs, const type_info &rhs) noexcept
	Compares two type info objects.

constexpr bool	operator>= (const type_info &lhs, const type_info &rhs) noexcept
	Compares two type info objects.

template<typename Type>
const type_info &	type_id () noexcept
	Returns the type info object associated to a given type.

template<typename Type>
const type_info &	type_id (Type &&) noexcept
	Returns the type info object associated to a given type.

template<typename... Type, typename... Other>
constexpr type_list< Type..., Other... >	operator+ (type_list< Type... >, type_list< Other... >)
	Concatenates multiple type lists.

template<auto... Value, auto... Other>
constexpr value_list< Value..., Other... >	operator+ (value_list< Value... >, value_list< Other... >)
	Concatenates multiple value lists.

template<typename Type, typename Class>
constexpr auto	overload (Type Class::*member) noexcept
	Constant utility to disambiguate overloaded members of a class.

template<typename Func>
constexpr auto	overload (Func *func) noexcept
	Constant utility to disambiguate overloaded functions.

template<typename... Func>
	overloaded (Func...) -> overloaded< Func... >
	Deduction guide.

template<typename Entity>
constexpr entt_traits< Entity >::entity_type	to_integral (const Entity value) noexcept
	Converts an entity to its underlying type.

template<typename Entity>
constexpr entt_traits< Entity >::entity_type	to_entity (const Entity value) noexcept
	Returns the entity part once converted to the underlying type.

template<typename Entity>
constexpr entt_traits< Entity >::version_type	to_version (const Entity value) noexcept
	Returns the version part once converted to the underlying type.

template<typename Entity>
constexpr bool	operator== (const Entity lhs, const null_t rhs) noexcept
	Compares a null object and an identifier of any type.

template<typename Entity>
constexpr bool	operator!= (const Entity lhs, const null_t rhs) noexcept
	Compares a null object and an identifier of any type.

template<typename Entity>
constexpr bool	operator== (const Entity lhs, const tombstone_t rhs) noexcept
	Compares a tombstone object and an identifier of any type.

template<typename Entity>
constexpr bool	operator!= (const Entity lhs, const tombstone_t rhs) noexcept
	Compares a tombstone object and an identifier of any type.

template<typename... Args, typename... Other>
bool	operator== (const basic_handle< Args... > &lhs, const basic_handle< Other... > &rhs) noexcept
	Compares two handles.

template<typename... Args, typename... Other>
bool	operator!= (const basic_handle< Args... > &lhs, const basic_handle< Other... > &rhs) noexcept
	Compares two handles.

template<typename... Args>
constexpr bool	operator== (const basic_handle< Args... > &lhs, const null_t rhs) noexcept
	Compares a handle with the null object.

template<typename... Args>
constexpr bool	operator== (const null_t lhs, const basic_handle< Args... > &rhs) noexcept
	Compares a handle with the null object.

template<typename... Args>
constexpr bool	operator!= (const basic_handle< Args... > &lhs, const null_t rhs) noexcept
	Compares a handle with the null object.

template<typename... Args>
constexpr bool	operator!= (const null_t lhs, const basic_handle< Args... > &rhs) noexcept
	Compares a handle with the null object.

template<auto Member, typename Registry = std::decay_t<nth_argument_t<0u, decltype(Member)>>>
void	invoke (Registry &reg, const typename Registry::entity_type entt)
	Helper to create a listener that directly invokes a member function.

template<typename... Args>
basic_storage< Args... >::entity_type	to_entity (const basic_storage< Args... > &storage, const typename basic_storage< Args... >::value_type &instance)
	Returns the entity associated with a given element.

template<typename Registry>
	sigh_helper (Registry &) -> sigh_helper< Registry >
	Deduction guide.

template<typename... Type>
	basic_view (Type &...storage) -> basic_view< get_t< Type... >, exclude_t<> >
	Deduction guide.

template<typename... Get, typename... Exclude>
	basic_view (std::tuple< Get &... >, std::tuple< Exclude &... >={}) -> basic_view< get_t< Get... >, exclude_t< Exclude... > >
	Deduction guide.

template<typename Graph, typename Writer>
void	dot (std::ostream &out, const Graph &graph, Writer writer)
	Outputs a graph in dot format.

template<typename Graph>
void	dot (std::ostream &out, const Graph &graph)
	Outputs a graph in dot format.

template<typename Type>
decltype(auto)	dereference_meta_pointer_like (const Type &value)
	ADL based lookup function for dereferencing meta pointer-like types.

template<typename Type>
auto	meta (meta_ctx &ctx) noexcept
	Utility function to use for reflection.

template<typename Type>
auto	meta () noexcept
	Utility function to use for reflection.

void	meta_reset (meta_ctx &ctx, const id_type id) noexcept
	Resets a type and all its parts.

void	meta_reset (const id_type id) noexcept
	Resets a type and all its parts.

template<typename Type>
void	meta_reset (meta_ctx &ctx) noexcept
	Resets a type and all its parts.

template<typename Type>
void	meta_reset () noexcept
	Resets a type and all its parts.

void	meta_reset (meta_ctx &ctx) noexcept
	Resets all meta types.

void	meta_reset () noexcept
	Resets all meta types.

template<typename Type>
meta_any	forward_as_meta (const meta_ctx &ctx, Type &&value)
	Forwards its argument and avoids copies for lvalue references.

template<typename Type>
meta_any	forward_as_meta (Type &&value)
	Forwards its argument and avoids copies for lvalue references.

bool	operator!= (const meta_data &lhs, const meta_data &rhs) noexcept
	Checks if two objects refer to the same type.

bool	operator!= (const meta_func &lhs, const meta_func &rhs) noexcept
	Checks if two objects refer to the same type.

bool	operator!= (const meta_type &lhs, const meta_type &rhs) noexcept
	Checks if two objects refer to the same type.

template<typename Type>
meta_type	resolve (const meta_ctx &ctx) noexcept
	Returns the meta type associated with a given type.

template<typename Type>
meta_type	resolve () noexcept
	Returns the meta type associated with a given type.

meta_range< meta_type, typename decltype(internal::meta_context::value)::const_iterator >	resolve (const meta_ctx &ctx) noexcept
	Returns a range to use to visit all meta types.

meta_range< meta_type, typename decltype(internal::meta_context::value)::const_iterator >	resolve () noexcept
	Returns a range to use to visit all meta types.

meta_type	resolve (const meta_ctx &ctx, const id_type id) noexcept
	Returns the meta type associated with a given identifier, if any.

meta_type	resolve (const id_type id) noexcept
	Returns the meta type associated with a given identifier, if any.

meta_type	resolve (const meta_ctx &ctx, const type_info &info) noexcept
	Returns the meta type associated with a given type info object.

meta_type	resolve (const type_info &info) noexcept
	Returns the meta type associated with a given type info object.

template<typename Policy = as_is_t, typename Type>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_dispatch (const meta_ctx &ctx, Type &&value)
	Wraps a value depending on the given policy.

template<typename Policy = as_is_t, typename Type>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_dispatch (Type &&value)
	Wraps a value depending on the given policy.

template<typename Type, auto Data>
bool	meta_setter (meta_handle instance, meta_any value)
	Sets the value of a given variable.

template<typename Type, auto Data, typename Policy = as_is_t>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_getter (meta_handle instance)
	Gets the value of a given variable.

template<typename Type, auto Data, typename Policy = as_is_t>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_getter (const meta_ctx &ctx, meta_handle instance)
	Gets the value of a given variable.

template<typename Type, typename Policy = as_is_t, typename Candidate>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_invoke (meta_handle instance, Candidate &&candidate, meta_any *const args)
	Tries to invoke an object given a list of erased parameters.

template<typename Type, typename Policy = as_is_t, typename Candidate>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_invoke (const meta_ctx &ctx, meta_handle instance, Candidate &&candidate, meta_any *const args)
	Tries to invoke an object given a list of erased parameters.

template<typename Type, auto Candidate, typename Policy = as_is_t>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_invoke (meta_handle instance, meta_any *const args)
	Tries to invoke a function given a list of erased parameters.

template<typename Type, auto Candidate, typename Policy = as_is_t>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_invoke (const meta_ctx &ctx, meta_handle instance, meta_any *const args)
	Tries to invoke a function given a list of erased parameters.

template<typename Type, typename... Args>
meta_any	meta_construct (const meta_ctx &ctx, meta_any *const args)
	Tries to construct an instance given a list of erased parameters.

template<typename Type, typename... Args>
meta_any	meta_construct (meta_any *const args)
	Tries to construct an instance given a list of erased parameters.

template<typename Type, typename Policy = as_is_t, typename Candidate>
meta_any	meta_construct (const meta_ctx &ctx, Candidate &&candidate, meta_any *const args)
	Tries to construct an instance given a list of erased parameters.

template<typename Type, typename Policy = as_is_t, typename Candidate>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_construct (Candidate &&candidate, meta_any *const args)
	Tries to construct an instance given a list of erased parameters.

template<typename Type, auto Candidate, typename Policy = as_is_t>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_construct (const meta_ctx &ctx, meta_any *const args)
	Tries to construct an instance given a list of erased parameters.

template<typename Type, auto Candidate, typename Policy = as_is_t>
std::enable_if_t< is_meta_policy_v< Policy >, meta_any >	meta_construct (meta_any *const args)
	Tries to construct an instance given a list of erased parameters.

template<std::size_t Member, typename Poly, typename... Args>
decltype(auto)	poly_call (Poly &&self, Args &&...args)
	Shortcut for calling `poly_base<Type>::invoke`.

template<typename Lhs, typename Rhs>
bool	operator== (const resource< Lhs > &lhs, const resource< Rhs > &rhs) noexcept
	Compares two handles.

template<typename Lhs, typename Rhs>
bool	operator!= (const resource< Lhs > &lhs, const resource< Rhs > &rhs) noexcept
	Compares two handles.

template<typename Lhs, typename Rhs>
bool	operator< (const resource< Lhs > &lhs, const resource< Rhs > &rhs) noexcept
	Compares two handles.

template<typename Lhs, typename Rhs>
bool	operator> (const resource< Lhs > &lhs, const resource< Rhs > &rhs) noexcept
	Compares two handles.

template<typename Lhs, typename Rhs>
bool	operator<= (const resource< Lhs > &lhs, const resource< Rhs > &rhs) noexcept
	Compares two handles.

template<typename Lhs, typename Rhs>
bool	operator>= (const resource< Lhs > &lhs, const resource< Rhs > &rhs) noexcept
	Compares two handles.

template<typename Ret, typename... Args>
bool	operator!= (const delegate< Ret(Args...)> &lhs, const delegate< Ret(Args...)> &rhs) noexcept
	Compares the contents of two delegates.

template<auto Candidate>
	delegate (connect_arg_t< Candidate >) -> delegate< std::remove_pointer_t< internal::function_pointer_t< decltype(Candidate)> > >
	Deduction guide.

template<auto Candidate, typename Type>
	delegate (connect_arg_t< Candidate >, Type &&) -> delegate< std::remove_pointer_t< internal::function_pointer_t< decltype(Candidate), Type > > >
	Deduction guide.

template<typename Ret, typename... Args>
	delegate (Ret()(const void , Args...), const void *=nullptr) -> delegate< Ret(Args...)>
	Deduction guide.

template<typename Ret, typename... Args, typename Allocator>
	sink (sigh< Ret(Args...), Allocator > &) -> sink< sigh< Ret(Args...), Allocator > >
	Deduction guide.

Variables
template<typename Type>
constexpr bool	enum_as_bitmask_v = enum_as_bitmask<Type>::value
	Helper variable template.

template<id_type Value>
monostate< Value >	monostate_v {}
	Helper variable template.

template<typename Type>
constexpr bool	is_tuple_v = is_tuple<Type>::value
	Helper variable template.

template<std::size_t N>
constexpr choice_t< N >	choice {}
	Variable template for the choice trick.

template<typename Type>
constexpr std::size_t	size_of_v = size_of<Type>::value
	Helper variable template.

template<auto Value, typename>
constexpr auto	unpack_as_value = Value
	Helper variable template to be used to repeat the same value a number of times equal to the size of a given parameter pack.

template<typename Type, typename List>
constexpr std::size_t	type_list_index_v = type_list_index<Type, List>::value
	Helper variable template.

template<typename List, typename Type>
constexpr bool	type_list_contains_v = type_list_contains<List, Type>::value
	Helper variable template.

template<std::size_t Index, typename List>
constexpr auto	value_list_element_v = value_list_element<Index, List>::value
	Helper type.

template<auto Value, typename List>
constexpr std::size_t	value_list_index_v = value_list_index<Value, List>::value
	Helper variable template.

template<typename List, auto Value>
constexpr bool	value_list_contains_v = value_list_contains<List, Value>::value
	Helper variable template.

template<typename Func, typename Args>
constexpr bool	is_applicable_v = is_applicable<Func, Args>::value
	Helper variable template.

template<typename Ret, typename Func, typename Args>
constexpr bool	is_applicable_r_v = is_applicable_r<Ret, Func, Args>::value
	Helper variable template.

template<typename Type>
constexpr bool	is_complete_v = is_complete<Type>::value
	Helper variable template.

template<typename Type>
constexpr bool	is_iterator_v = is_iterator<Type>::value
	Helper variable template.

template<typename Type>
constexpr bool	is_ebco_eligible_v = is_ebco_eligible<Type>::value
	Helper variable template.

template<typename Type>
constexpr bool	is_transparent_v = is_transparent<Type>::value
	Helper variable template.

template<typename Type>
constexpr bool	is_equality_comparable_v = is_equality_comparable<Type>::value
	Helper variable template.

constexpr null_t	null {}
	Compile-time constant for null entities.

constexpr tombstone_t	tombstone {}
	Compile-time constant for tombstone entities.

template<typename... Type>
constexpr exclude_t< Type... >	exclude {}
	Variable template for exclusion lists.

template<typename... Type>
constexpr get_t< Type... >	get {}
	Variable template for lists of observed elements.

template<typename... Type>
constexpr owned_t< Type... >	owned {}
	Variable template for lists of owned elements.

constexpr meta_ctx_arg_t	meta_ctx_arg {}
	Constant of type meta_context_arg_t used to disambiguate calls.

template<typename Type>
constexpr bool	is_meta_policy_v = is_meta_policy<Type>::value
	Helper variable template.

template<typename Type>
constexpr auto	is_meta_pointer_like_v = is_meta_pointer_like<Type>::value
	Helper variable template.

template<auto Candidate>
constexpr connect_arg_t< Candidate >	connect_arg {}
	Constant of type connect_arg_t used to disambiguate calls.

Detailed Description

EnTT default namespace.

Typedef Documentation

◆ any

using entt::any = basic_any<>

Alias declaration for the most common use case.

Definition at line 32 of file fwd.hpp.

◆ const_handle

using entt::const_handle = basic_handle<const registry>

Alias declaration for the most common use case.

Definition at line 104 of file fwd.hpp.

◆ const_handle_view

template<typename... Args>

using entt::const_handle_view = basic_handle<const registry, Args...>

Alias declaration for the most common use case.

Template Parameters

Args	Other template parameters.

Definition at line 118 of file fwd.hpp.

◆ const_runtime_view

using entt::const_runtime_view = basic_runtime_view<const sparse_set>

Alias declaration for the most common use case.

Definition at line 133 of file fwd.hpp.

◆ constness_as_t

template<typename To, typename From>

using entt::constness_as_t = typename constness_as<To, From>::type

Alias template to facilitate the transcription of the constness.

Template Parameters

To	The type to which to transcribe the constness.
From	The type from which to transcribe the constness.

Definition at line 841 of file type_traits.hpp.

◆ continuous_loader

using entt::continuous_loader = basic_continuous_loader<registry>

Alias declaration for the most common use case.

Definition at line 127 of file fwd.hpp.

◆ dispatcher

using entt::dispatcher = basic_dispatcher<>

Alias declaration for the most common use case.

Definition at line 28 of file fwd.hpp.

◆ flow

using entt::flow = basic_flow<>

Alias declaration for the most common use case.

Definition at line 23 of file fwd.hpp.

◆ group

template<typename Owned, typename Get = get_t<>, typename Exclude = exclude_t<>>

using entt::group = basic_group<type_list_transform_t<Owned, storage_for>, type_list_transform_t<Get, storage_for>, type_list_transform_t<Exclude, storage_for>>

Alias declaration for the most common use case.

Template Parameters

Owned	Types of storage owned by the group.
Get	Types of storage observed by the group.
Exclude	Types of storage used to filter the group.

Definition at line 286 of file fwd.hpp.

◆ handle

using entt::handle = basic_handle<registry>

Alias declaration for the most common use case.

Definition at line 101 of file fwd.hpp.

◆ handle_view

template<typename... Args>

using entt::handle_view = basic_handle<registry, Args...>

Alias declaration for the most common use case.

Template Parameters

Args	Other template parameters.

Definition at line 111 of file fwd.hpp.

◆ hashed_string

using entt::hashed_string = basic_hashed_string<char>

Aliases for common character types.

Definition at line 41 of file fwd.hpp.

◆ hashed_wstring

using entt::hashed_wstring = basic_hashed_string<wchar_t>

Aliases for common character types.

Definition at line 44 of file fwd.hpp.

◆ id_type

using entt::id_type = std::uint32_t

Alias declaration for type identifiers.

Definition at line 29 of file fwd.hpp.

◆ integral_constant

template<auto Value>

using entt::integral_constant = std::integral_constant<decltype(Value), Value>

Wraps a static constant.

Template Parameters

Value A static constant.

Definition at line 97 of file type_traits.hpp.

◆ member_class_t

template<typename Member>

using entt::member_class_t = typename member_class<Member>::type

Helper type.

Template Parameters

Member A pointer to a non-static member object or function.

Definition at line 870 of file type_traits.hpp.

◆ meta_function_helper_t

template<typename Type, typename Candidate>

using entt::meta_function_helper_t = typename meta_function_helper<Type, Candidate>::type

Helper type.

Template Parameters

Type	Reflected type to which the meta function is associated.
Candidate	The actual function to associate with the reflected type.

Definition at line 152 of file utility.hpp.

◆ meta_range

template<typename Type, typename It>

using entt::meta_range = iterable_adaptor<internal::meta_range_iterator<Type, It>>

Iterable range to use to iterate all types of meta objects.

Template Parameters

Type	Type of meta objects returned.
It	Type of forward iterator.

Definition at line 147 of file range.hpp.

◆ nth_argument_t

template<std::size_t Index, typename Candidate>

using entt::nth_argument_t = typename nth_argument<Index, Candidate>::type

Helper type.

Template Parameters

Index	The index of the argument to extract.
Candidate	A valid function, member function or data member type.

Definition at line 905 of file type_traits.hpp.

◆ organizer

using entt::organizer = basic_organizer<registry>

Alias declaration for the most common use case.

Definition at line 98 of file fwd.hpp.

◆ poly

template<typename Concept>

using entt::poly = basic_poly<Concept>

Alias declaration for the most common use case.

Template Parameters

Concept Concept descriptor.

Definition at line 17 of file fwd.hpp.

◆ reactive_mixin

template<typename Type>

using entt::reactive_mixin = basic_reactive_mixin<Type, basic_registry<typename Type::entity_type, typename Type::base_type::allocator_type>>

Alias declaration for the most common use case.

Template Parameters

Type	Underlying storage type.

Definition at line 92 of file fwd.hpp.

◆ registry

using entt::registry = basic_registry<>

Alias declaration for the most common use case.

Definition at line 95 of file fwd.hpp.

◆ runtime_view

using entt::runtime_view = basic_runtime_view<sparse_set>

Alias declaration for the most common use case.

Definition at line 130 of file fwd.hpp.

◆ scheduler

using entt::scheduler = basic_scheduler<>

Alias declaration for the most common use case.

Definition at line 16 of file fwd.hpp.

◆ sigh_mixin

template<typename Type>

using entt::sigh_mixin = basic_sigh_mixin<Type, basic_registry<typename Type::entity_type, typename Type::base_type::allocator_type>>

Alias declaration for the most common use case.

Template Parameters

Type	Underlying storage type.

Definition at line 85 of file fwd.hpp.

◆ snapshot

using entt::snapshot = basic_snapshot<registry>

Alias declaration for the most common use case.

Definition at line 121 of file fwd.hpp.

◆ snapshot_loader

using entt::snapshot_loader = basic_snapshot_loader<registry>

Alias declaration for the most common use case.

Definition at line 124 of file fwd.hpp.

◆ sparse_set

using entt::sparse_set = basic_sparse_set<>

Alias declaration for the most common use case.

Definition at line 71 of file fwd.hpp.

◆ storage

template<typename Type>

using entt::storage = basic_storage<Type>

Alias declaration for the most common use case.

Template Parameters

Type	Element type.

Definition at line 78 of file fwd.hpp.

◆ storage_for_t

template<typename... Args>

using entt::storage_for_t = typename storage_for<Args...>::type

Helper type.

Template Parameters

Args	Arguments to forward.

Definition at line 269 of file fwd.hpp.

◆ storage_type_t

template<typename... Args>

using entt::storage_type_t = typename storage_type<Args...>::type

Helper type.

Template Parameters

Args	Arguments to forward.

Definition at line 250 of file fwd.hpp.

◆ table

template<typename... Type>

using entt::table = basic_table<std::vector<Type>...>

Alias declaration for the most common use case.

Template Parameters

Type	Element types.

Definition at line 34 of file fwd.hpp.

◆ tag

template<id_type Value>

using entt::tag = integral_constant<Value>

Alias template to facilitate the creation of named values.

Template Parameters

Value A constant value at least convertible to id_type.

Definition at line 104 of file type_traits.hpp.

◆ type_identity_t

template<typename Type>

using entt::type_identity_t = typename type_identity<Type>::type

Helper type.

Template Parameters

Type A type.

Definition at line 54 of file type_traits.hpp.

◆ type_list_cat_t

template<typename... List>

using entt::type_list_cat_t = typename type_list_cat<List...>::type

Helper type.

Template Parameters

List	Type lists to concatenate.

Definition at line 252 of file type_traits.hpp.

◆ type_list_diff_t

template<typename... List>

using entt::type_list_diff_t = typename type_list_diff<List...>::type

Helper type.

Template Parameters

List	Type lists between which to compute the difference.

Definition at line 335 of file type_traits.hpp.

◆ type_list_element_t

template<std::size_t Index, typename List>

using entt::type_list_element_t = typename type_list_element<Index, List>::type

Helper type.

Template Parameters

Index	Index of the type to return.
List	Type list to search into.

Definition at line 149 of file type_traits.hpp.

◆ type_list_transform_t

template<typename List, template< typename... > class Op>

using entt::type_list_transform_t = typename type_list_transform<List, Op>::type

Helper type.

Template Parameters

List	Type list.
Op	Unary operation as template class with a type member named `type`.

Definition at line 359 of file type_traits.hpp.

◆ type_list_unique_t

template<typename List>

using entt::type_list_unique_t = typename type_list_unique<List>::type

Helper type.

Template Parameters

List	Type list.

Definition at line 287 of file type_traits.hpp.

◆ unpack_as_type

template<typename Type, typename>

using entt::unpack_as_type = Type

Using declaration to be used to repeat the same type a number of times equal to the size of a given parameter pack.

Template Parameters

Type	A type to repeat.

Definition at line 82 of file type_traits.hpp.

◆ value_list_cat_t

template<typename... List>

using entt::value_list_cat_t = typename value_list_cat<List...>::type

Helper type.

Template Parameters

List	Value lists to concatenate.

Definition at line 517 of file type_traits.hpp.

◆ value_list_diff_t

template<typename... List>

using entt::value_list_diff_t = typename value_list_diff<List...>::type

Helper type.

Template Parameters

List	Value lists between which to compute the difference.

Definition at line 597 of file type_traits.hpp.

◆ value_list_element_t

template<std::size_t Index, typename List>

using entt::value_list_element_t = typename value_list_element<Index, List>::type

Helper type.

Template Parameters

Index	Index of the type to return.
List	Value list to search into.

Definition at line 406 of file type_traits.hpp.

◆ value_list_unique_t

template<typename Type>

using entt::value_list_unique_t = typename value_list_unique<Type>::type

Helper type.

Template Parameters

Type	A value list.

Definition at line 549 of file type_traits.hpp.

◆ view

template<typename Get, typename Exclude = exclude_t<>>

using entt::view = basic_view<type_list_transform_t<Get, storage_for>, type_list_transform_t<Exclude, storage_for>>

Alias declaration for the most common use case.

Template Parameters

Get	Types of storage iterated by the view.
Exclude	Types of storage used to filter the view.

Definition at line 277 of file fwd.hpp.

Enumeration Type Documentation

◆ any_policy [1/2]

enum class entt::any_policy : std::uint8_t

strong

Possible modes of an any object.

Enumerator
empty	Default mode, the object does not own any elements.
dynamic	Owning mode, the object owns a dynamically allocated element.
embedded	Owning mode, the object owns an embedded element.
ref	Aliasing mode, the object points to a non-const element.
cref	Const aliasing mode, the object points to a const element.

Definition at line 11 of file fwd.hpp.

◆ any_policy [2/2]

enum class entt::any_policy : std::uint8_t

strong

Possible modes of an any object.

Definition at line 11 of file fwd.hpp.

◆ deletion_policy

enum class entt::deletion_policy : std::uint8_t

strong

Storage deletion policy.

Enumerator
swap_and_pop	Swap-and-pop deletion policy.
in_place	In-place deletion policy.
swap_only	Swap-only deletion policy.
unspecified	Unspecified deletion policy.

Definition at line 17 of file fwd.hpp.

◆ entity

enum class entt::entity : id_type

strong

Default entity identifier.

Definition at line 14 of file fwd.hpp.

Function Documentation

◆ allocate_unique()

template<typename Type, typename Allocator, typename... Args>

auto entt::allocate_unique	(	Allocator &	allocator,
		Args &&...	args )

constexpr

Allows std::unique_ptr to use allocators (waiting for C++20).

Template Parameters

Type	Type of object to allocate for and to construct.
Allocator	Type of allocator used to manage memory and elements.
Args	Types of arguments to use to construct the object.

Parameters

allocator	The allocator to use.
args	Parameters to use to construct the object.

Returns: A properly initialized unique pointer with a custom deleter.

Definition at line 109 of file memory.hpp.

◆ any_cast() [1/5]

template<typename Type, std::size_t Len, std::size_t Align>

std::remove_const_t< Type > entt::any_cast ( basic_any< Len, Align > && data )

nodiscardnoexcept

Performs type-safe access to the contained object.

Template Parameters

Type	Type to which conversion is required.
Len	Size of the storage reserved for the small buffer optimization.
Align	Alignment requirement.

Parameters

data	Target any object.

Returns: The element converted to the requested type.

Definition at line 482 of file any.hpp.

◆ any_cast() [2/5]

template<typename Type, std::size_t Len, std::size_t Align>

std::remove_const_t< Type > entt::any_cast ( basic_any< Len, Align > & data )

nodiscardnoexcept

Performs type-safe access to the contained object.

Template Parameters

Type	Type to which conversion is required.
Len	Size of the storage reserved for the small buffer optimization.
Align	Alignment requirement.

Parameters

data	Target any object.

Returns: The element converted to the requested type.

Definition at line 472 of file any.hpp.

◆ any_cast() [3/5]

template<typename Type, std::size_t Len, std::size_t Align>

Type * entt::any_cast ( basic_any< Len, Align > * data )

nodiscardnoexcept

Performs type-safe access to the contained object.

Template Parameters

Type	Type to which conversion is required.
Len	Size of the storage reserved for the small buffer optimization.
Align	Alignment requirement.

Parameters

data	Target any object.

Returns: The element converted to the requested type.

Definition at line 505 of file any.hpp.

◆ any_cast() [4/5]

template<typename Type, std::size_t Len, std::size_t Align>

std::remove_const_t< Type > entt::any_cast ( const basic_any< Len, Align > & data )

nodiscardnoexcept

Performs type-safe access to the contained object.

Template Parameters

Type	Type to which conversion is required.
Len	Size of the storage reserved for the small buffer optimization.
Align	Alignment requirement.

Parameters

data	Target any object.

Returns: The element converted to the requested type.

Definition at line 464 of file any.hpp.

◆ any_cast() [5/5]

template<typename Type, std::size_t Len, std::size_t Align>

const Type * entt::any_cast ( const basic_any< Len, Align > * data )

nodiscardnoexcept

Performs type-safe access to the contained object.

Template Parameters

Type	Type to which conversion is required.
Len	Size of the storage reserved for the small buffer optimization.
Align	Alignment requirement.

Parameters

data	Target any object.

Returns: The element converted to the requested type.

Definition at line 498 of file any.hpp.

◆ basic_hashed_string() [1/2]

template<typename Char>

entt::basic_hashed_string	(	const Char *	str,
		std::size_t	len ) -> basic_hashed_string< Char >

Deduction guide.

Template Parameters

Char	Character type.

Parameters

str	Human-readable identifier.
len	Length of the string to hash.

◆ basic_hashed_string() [2/2]

template<typename Char, std::size_t N>

entt::basic_hashed_string ( const Char(&) str[N] ) -> basic_hashed_string< Char >

Deduction guide.

Template Parameters

Char	Character type.
N	Number of characters of the identifier.

Parameters

str	Human-readable identifier.

◆ basic_view() [1/2]

template<typename... Get, typename... Exclude>

entt::basic_view	(	std::tuple< Get &... >	,
		std::tuple< Exclude &... >	= {} ) -> basic_view< get_t< Get... >, exclude_t< Exclude... > >

Deduction guide.

Template Parameters

Get	Types of elements iterated by the view.
Exclude	Types of elements used to filter the view.

◆ basic_view() [2/2]

template<typename... Type>

entt::basic_view ( Type &... storage ) -> basic_view< get_t< Type... >, exclude_t<> >

Deduction guide.

Template Parameters

Type	Type of storage classes used to create the view.

Parameters

storage The storage for the types to iterate.

◆ compressed_pair()

template<typename Type, typename Other>

entt::compressed_pair	(	Type &&	,
		Other &&	) -> compressed_pair< std::decay_t< Type >, std::decay_t< Other > >

Deduction guide.

Template Parameters

Type	Type of value to use to initialize the first element.
Other	Type of value to use to initialize the second element.

◆ delegate() [1/3]

template<auto Candidate>

entt::delegate ( connect_arg_t< Candidate > ) -> delegate< std::remove_pointer_t< internal::function_pointer_t< decltype(Candidate)> > >

Deduction guide.

Template Parameters

Candidate Function or member to connect to the delegate.

◆ delegate() [2/3]

template<auto Candidate, typename Type>

entt::delegate	(	connect_arg_t< Candidate >	,
		Type &&	) -> delegate< std::remove_pointer_t< internal::function_pointer_t< decltype(Candidate), Type > > >

Deduction guide.

Template Parameters

Candidate	Function or member to connect to the delegate.
Type	Type of class or type of payload.

◆ delegate() [3/3]

template<typename Ret, typename... Args>

entt::delegate	(	Ret(*	)(const void *, Args...),
		const void *	= nullptr ) -> delegate< Ret(Args...)>

Deduction guide.

Template Parameters

Ret	Return type of a function type.
Args	Types of arguments of a function type.

◆ dereference_meta_pointer_like()

template<typename Type>

decltype(auto) entt::dereference_meta_pointer_like ( const Type & value )

ADL based lookup function for dereferencing meta pointer-like types.

Template Parameters

Type	Element type.

Parameters

value A pointer-like object.

Returns: The value returned from the dereferenced pointer.

Definition at line 13 of file adl_pointer.hpp.

◆ dot() [1/2]

template<typename Graph>

void entt::dot	(	std::ostream &	out,
		const Graph &	graph )

Outputs a graph in dot format.

Template Parameters

Graph Graph type, valid as long as it exposes edges and vertices.

Parameters

out	A standard output stream.
graph	The graph to output.

Definition at line 52 of file dot.hpp.

◆ dot() [2/2]

template<typename Graph, typename Writer>

void entt::dot	(	std::ostream &	out,
		const Graph &	graph,
		Writer	writer )

Outputs a graph in dot format.

Template Parameters

Graph	Graph type, valid as long as it exposes edges and vertices.
Writer	Vertex decorator type.

Parameters

out	A standard output stream.
graph	The graph to output.
writer	Vertex decorator object.

Definition at line 19 of file dot.hpp.

◆ fast_mod()

template<typename Type>

std::enable_if_t< std::is_unsigned_v< Type >, Type > entt::fast_mod	(	const Type	value,
		const std::size_t	mod )

nodiscardconstexprnoexcept

Fast module utility function (powers of two only).

Template Parameters

Type	Unsigned integer type.

Parameters

value	A value of unsigned integer type.
mod	Modulus, it must be a power of two.

Returns: The common remainder.

Definition at line 63 of file bit.hpp.

◆ forward_apply()

template<typename Func>

entt::forward_apply ( Func ) -> forward_apply< std::remove_reference_t< std::remove_cv_t< Func > > >

Deduction guide.

Template Parameters

Func	Type of underlying invocable object.

◆ forward_as_any()

template<std::size_t Len = basic_any<>::length, std::size_t Align = basic_any<Len>::alignment, typename Type>

basic_any< Len, Align > entt::forward_as_any ( Type && value )

nodiscard

Forwards its argument and avoids copies for lvalue references.

Template Parameters

Len	Size of the storage reserved for the small buffer optimization.
Align	Optional alignment requirement.
Type	Type of argument to use to construct the new instance.

Parameters

value Parameter to use to construct the instance.

Returns: A properly initialized and not necessarily owning wrapper.

Definition at line 538 of file any.hpp.

◆ forward_as_meta() [1/2]

template<typename Type>

meta_any entt::forward_as_meta	(	const meta_ctx &	ctx,
		Type &&	value )

nodiscard

Forwards its argument and avoids copies for lvalue references.

Template Parameters

Type	Type of argument to use to construct the new instance.

Parameters

value	Parameter to use to construct the instance.
ctx	The context from which to search for meta types.

Returns: A properly initialized and not necessarily owning wrapper.

Definition at line 672 of file meta.hpp.

◆ forward_as_meta() [2/2]

template<typename Type>

meta_any entt::forward_as_meta ( Type && value )

nodiscard

Forwards its argument and avoids copies for lvalue references.

Template Parameters

Type	Type of argument to use to construct the new instance.

Parameters

value Parameter to use to construct the instance.

Returns: A properly initialized and not necessarily owning wrapper.

Definition at line 683 of file meta.hpp.

◆ has_single_bit()

template<typename Type>

std::enable_if_t< std::is_unsigned_v< Type >, bool > entt::has_single_bit ( const Type value )

nodiscardconstexprnoexcept

Checks whether a value is a power of two or not (waiting for C++20 and std::has_single_bit).

Template Parameters

Type	Unsigned integer type.

Parameters

value A value of unsigned integer type.

Returns: True if the value is a power of two, false otherwise.

Definition at line 31 of file bit.hpp.

◆ invoke()

template<auto Member, typename Registry = std::decay_t<nth_argument_t<0u, decltype(Member)>>>

void entt::invoke	(	Registry &	reg,
		const typename Registry::entity_type	entt )

Helper to create a listener that directly invokes a member function.

Template Parameters

Member	Member function to invoke on an element of the given type.
Registry	Basic registry type.

Parameters

reg	A registry that contains the given entity and its elements.
entt	Entity from which to get the element.

Definition at line 108 of file helper.hpp.

◆ make_any()

template<typename Type, std::size_t Len = basic_any<>::length, std::size_t Align = basic_any<Len>::alignment, typename... Args>

basic_any< Len, Align > entt::make_any ( Args &&... args )

nodiscard

Constructs a wrapper from a given type, passing it all arguments.

Template Parameters

Type	Type of object to use to initialize the wrapper.
Len	Size of the storage reserved for the small buffer optimization.
Align	Optional alignment requirement.
Args	Types of arguments to use to construct the new instance.

Parameters

args	Parameters to use to construct the instance.

Returns: A properly initialized wrapper for an object of the given type.

Definition at line 525 of file any.hpp.

◆ make_obj_using_allocator()

template<typename Type, typename Allocator, typename... Args>

Type entt::make_obj_using_allocator	(	const Allocator &	allocator,
		Args &&...	args )

constexpr

Uses-allocator construction utility (waiting for C++20).

Primarily intended for internal use. Creates an object of a given type by means of uses-allocator construction.

Template Parameters

Type	Type of object to create.
Allocator	Type of allocator used to manage memory and elements.
Args	Types of arguments to use to construct the object.

Parameters

allocator	The allocator to use.
args	Parameters to use to construct the object.

Returns: A newly created object of the given type.

Definition at line 219 of file memory.hpp.

◆ meta() [1/2]

template<typename Type>

auto entt::meta ( )

nodiscardnoexcept

Utility function to use for reflection.

This is the point from which everything starts.
By invoking this function with a type that is not yet reflected, a meta type is created to which it will be possible to attach meta objects through a dedicated factory.

Template Parameters

Type	Type to reflect.

Returns: A meta factory for the given type.

Definition at line 535 of file factory.hpp.

◆ meta() [2/2]

template<typename Type>

auto entt::meta ( meta_ctx & ctx )

nodiscardnoexcept

Utility function to use for reflection.

This is the point from which everything starts.
By invoking this function with a type that is not yet reflected, a meta type is created to which it will be possible to attach meta objects through a dedicated factory.

Template Parameters

Type	Type to reflect.

Parameters

ctx	The context into which to construct meta types.

Returns: A meta factory for the given type.

Definition at line 519 of file factory.hpp.

◆ meta_construct() [1/6]

template<typename Type, typename Policy = as_is_t, typename Candidate>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_construct	(	Candidate &&	candidate,
		meta_any *const	args )

nodiscard

Tries to construct an instance given a list of erased parameters.

Template Parameters

Type	Reflected type to which the object to invoke is associated.
Policy	Optional policy (no policy set by default).
Candidate	The type of the actual object to invoke.

Parameters

candidate	The actual object to invoke.
args	Parameters to use to invoke the object.

Returns: A meta any containing the returned value, if any.

Definition at line 485 of file utility.hpp.

◆ meta_construct() [2/6]

template<typename Type, typename Policy = as_is_t, typename Candidate>

meta_any entt::meta_construct	(	const meta_ctx &	ctx,
		Candidate &&	candidate,
		meta_any *const	args )

nodiscard

Tries to construct an instance given a list of erased parameters.

Warning: The context provided is used only for the return type.
It's up to the caller to bind the arguments to the right context(s).

Template Parameters

Type	Reflected type to which the object to invoke is associated.
Policy	Optional policy (no policy set by default).
Candidate	The type of the actual object to invoke.

Parameters

ctx	The context from which to search for meta types.
candidate	The actual object to invoke.
args	Parameters to use to invoke the object.

Returns: A meta any containing the returned value, if any.

Definition at line 465 of file utility.hpp.

◆ meta_construct() [3/6]

template<typename Type, typename... Args>

meta_any entt::meta_construct	(	const meta_ctx &	ctx,
		meta_any *const	args )

nodiscard

Tries to construct an instance given a list of erased parameters.

Warning: The context provided is used only for the return type.
It's up to the caller to bind the arguments to the right context(s).

Template Parameters

Type	Actual type of the instance to construct.
Args	Types of arguments expected.

Parameters

ctx	The context from which to search for meta types.
args	Parameters to use to construct the instance.

Returns: A meta any containing the new instance, if any.

Definition at line 433 of file utility.hpp.

◆ meta_construct() [4/6]

template<typename Type, auto Candidate, typename Policy = as_is_t>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_construct	(	const meta_ctx &	ctx,
		meta_any *const	args )

nodiscard

Tries to construct an instance given a list of erased parameters.

Warning: The context provided is used only for the return type.
It's up to the caller to bind the arguments to the right context(s).

Template Parameters

Type	Reflected type to which the function is associated.
Candidate	The actual function to invoke.
Policy	Optional policy (no policy set by default).

Parameters

ctx	The context from which to search for meta types.
args	Parameters to use to invoke the function.

Returns: A meta any containing the returned value, if any.

Definition at line 504 of file utility.hpp.

◆ meta_construct() [5/6]

template<typename Type, typename... Args>

meta_any entt::meta_construct ( meta_any *const args )

nodiscard

Tries to construct an instance given a list of erased parameters.

Template Parameters

Type	Actual type of the instance to construct.
Args	Types of arguments expected.

Parameters

args	Parameters to use to construct the instance.

Returns: A meta any containing the new instance, if any.

Definition at line 445 of file utility.hpp.

◆ meta_construct() [6/6]

template<typename Type, auto Candidate, typename Policy = as_is_t>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_construct ( meta_any *const args )

nodiscard

Tries to construct an instance given a list of erased parameters.

Template Parameters

Type	Reflected type to which the function is associated.
Candidate	The actual function to invoke.
Policy	Optional policy (no policy set by default).

Parameters

args	Parameters to use to invoke the function.

Returns: A meta any containing the returned value, if any.

Definition at line 517 of file utility.hpp.

◆ meta_dispatch() [1/2]

template<typename Policy = as_is_t, typename Type>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_dispatch	(	const meta_ctx &	ctx,
		Type &&	value )

nodiscard

Wraps a value depending on the given policy.

This function always returns a wrapped value in the requested context.
Therefore, if the passed value is itself a wrapped object with a different context, it undergoes a rebinding to the requested context.

Template Parameters

Policy	Optional policy (no policy set by default).
Type	Type of value to wrap.

Parameters

ctx	The context from which to search for meta types.
value	Value to wrap.

Returns: A meta any containing the returned value, if any.

Definition at line 168 of file utility.hpp.

◆ meta_dispatch() [2/2]

template<typename Policy = as_is_t, typename Type>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_dispatch ( Type && value )

nodiscard

Wraps a value depending on the given policy.

Template Parameters

Policy	Optional policy (no policy set by default).
Type	Type of value to wrap.

Parameters

value Value to wrap.

Returns: A meta any containing the returned value, if any.

Definition at line 189 of file utility.hpp.

◆ meta_getter() [1/2]

template<typename Type, auto Data, typename Policy = as_is_t>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_getter	(	const meta_ctx &	ctx,
		meta_handle	instance )

nodiscard

Gets the value of a given variable.

Template Parameters

Type	Reflected type to which the variable is associated.
Data	The actual variable to get.
Policy	Optional policy (no policy set by default).

Parameters

ctx	The context from which to search for meta types.
instance	An opaque instance of the underlying type, if required.

Returns: A meta any containing the value of the underlying variable.

Definition at line 355 of file utility.hpp.

◆ meta_getter() [2/2]

template<typename Type, auto Data, typename Policy = as_is_t>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_getter ( meta_handle instance )

nodiscard

Gets the value of a given variable.

Template Parameters

Type	Reflected type to which the variable is associated.
Data	The actual variable to get.
Policy	Optional policy (no policy set by default).

Parameters

instance An opaque instance of the underlying type, if required.

Returns: A meta any containing the value of the underlying variable.

Definition at line 317 of file utility.hpp.

◆ meta_invoke() [1/4]

template<typename Type, typename Policy = as_is_t, typename Candidate>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_invoke	(	const meta_ctx &	ctx,
		meta_handle	instance,
		Candidate &&	candidate,
		meta_any *const	args )

nodiscard

Tries to invoke an object given a list of erased parameters.

Template Parameters

Type	Reflected type to which the object to invoke is associated.
Policy	Optional policy (no policy set by default).

Parameters

ctx	The context from which to search for meta types.

Template Parameters

Candidate The type of the actual object to invoke.

Parameters

instance	An opaque instance of the underlying type, if required.
candidate	The actual object to invoke.
args	Parameters to use to invoke the object.

Returns: A meta any containing the returned value, if any.

Definition at line 386 of file utility.hpp.

◆ meta_invoke() [2/4]

template<typename Type, auto Candidate, typename Policy = as_is_t>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_invoke	(	const meta_ctx &	ctx,
		meta_handle	instance,
		meta_any *const	args )

nodiscard

Tries to invoke a function given a list of erased parameters.

Template Parameters

Type	Reflected type to which the function is associated.
Candidate	The actual function to invoke.
Policy	Optional policy (no policy set by default).

Parameters

ctx	The context from which to search for meta types.
instance	An opaque instance of the underlying type, if required.
args	Parameters to use to invoke the function.

Returns: A meta any containing the returned value, if any.

Definition at line 415 of file utility.hpp.

◆ meta_invoke() [3/4]

template<typename Type, typename Policy = as_is_t, typename Candidate>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_invoke	(	meta_handle	instance,
		Candidate &&	candidate,
		meta_any *const	args )

nodiscard

Tries to invoke an object given a list of erased parameters.

Template Parameters

Type	Reflected type to which the object to invoke is associated.
Policy	Optional policy (no policy set by default).
Candidate	The type of the actual object to invoke.

Parameters

instance	An opaque instance of the underlying type, if required.
candidate	The actual object to invoke.
args	Parameters to use to invoke the object.

Returns: A meta any containing the returned value, if any.

Definition at line 370 of file utility.hpp.

◆ meta_invoke() [4/4]

template<typename Type, auto Candidate, typename Policy = as_is_t>

std::enable_if_t< is_meta_policy_v< Policy >, meta_any > entt::meta_invoke	(	meta_handle	instance,
		meta_any *const	args )

nodiscard

Tries to invoke a function given a list of erased parameters.

Template Parameters

Type	Reflected type to which the function is associated.
Candidate	The actual function to invoke.
Policy	Optional policy (no policy set by default).

Parameters

instance	An opaque instance of the underlying type, if required.
args	Parameters to use to invoke the function.

Returns: A meta any containing the returned value, if any.

Definition at line 400 of file utility.hpp.

◆ meta_reset() [1/6]

template<typename Type>

void entt::meta_reset ( )

noexcept

Resets a type and all its parts.

See also: meta_reset

Template Parameters

Type	Type to reset.

Definition at line 599 of file factory.hpp.

◆ meta_reset() [2/6]

void entt::meta_reset ( )

inlinenoexcept

Resets all meta types.

See also: meta_reset

Definition at line 619 of file factory.hpp.

◆ meta_reset() [3/6]

void entt::meta_reset ( const id_type id )

inlinenoexcept

Resets a type and all its parts.

Resets a type and all its data members, member functions and properties, as well as its constructors, destructors and conversion functions if any.
Base classes aren't reset but the link between the two types is removed.

The type is also removed from the set of searchable types.

Parameters

id	Unique identifier.

Definition at line 574 of file factory.hpp.

◆ meta_reset() [4/6]

template<typename Type>

void entt::meta_reset ( meta_ctx & ctx )

noexcept

Resets a type and all its parts.

See also: meta_reset

Template Parameters

Type	Type to reset.

Parameters

ctx	The context from which to reset meta types.

Definition at line 587 of file factory.hpp.

◆ meta_reset() [5/6]

void entt::meta_reset ( meta_ctx & ctx )

inlinenoexcept

Resets all meta types.

See also: meta_reset

Parameters

ctx	The context from which to reset meta types.

Definition at line 610 of file factory.hpp.

◆ meta_reset() [6/6]

void entt::meta_reset	(	meta_ctx &	ctx,
		const id_type	id )

inlinenoexcept

Resets a type and all its parts.

Resets a type and all its data members, member functions and properties, as well as its constructors, destructors and conversion functions if any.
Base classes aren't reset but the link between the two types is removed.

The type is also removed from the set of searchable types.

Parameters

id	Unique identifier.
ctx	The context from which to reset meta types.

Definition at line 551 of file factory.hpp.

◆ meta_setter()

template<typename Type, auto Data>

bool entt::meta_setter	(	meta_handle	instance,
		meta_any	value )

nodiscard

Sets the value of a given variable.

Template Parameters

Type	Reflected type to which the variable is associated.
Data	The actual variable to set.

Parameters

instance	An opaque instance of the underlying type, if required.
value	Parameter to use to set the variable.

Returns: True in case of success, false otherwise.

Definition at line 276 of file utility.hpp.

◆ next_power_of_two()

template<typename Type>

std::enable_if_t< std::is_unsigned_v< Type >, Type > entt::next_power_of_two ( const Type value )

nodiscardconstexprnoexcept

Computes the smallest power of two greater than or equal to a value (waiting for C++20 and std::bit_ceil).

Template Parameters

Type	Unsigned integer type.

Parameters

value A value of unsigned integer type.

Returns: The smallest power of two greater than or equal to the given value.

Definition at line 43 of file bit.hpp.

◆ operator!=() [1/13]

template<typename... Args, typename... Other>

bool entt::operator!=	(	const basic_handle< Args... > &	lhs,
		const basic_handle< Other... > &	rhs )

nodiscardnoexcept

Compares two handles.

Template Parameters

Args	Scope of the first handle.
Other	Scope of the second handle.

Parameters

lhs	A valid handle.
rhs	A valid handle.

Returns: False if both handles refer to the same registry and the same entity, true otherwise.

Definition at line 377 of file handle.hpp.

◆ operator!=() [2/13]

template<typename... Args>

bool entt::operator!=	(	const basic_handle< Args... > &	lhs,
		const null_t	rhs )

nodiscardconstexprnoexcept

Compares a handle with the null object.

Template Parameters

Args	Scope of the handle.

Parameters

lhs	A valid handle.
rhs	A null object yet to be converted.

Returns: True if the two elements differ, false otherwise.

Definition at line 413 of file handle.hpp.

◆ operator!=() [3/13]

template<typename Char>

bool entt::operator!=	(	const basic_hashed_string< Char > &	lhs,
		const basic_hashed_string< Char > &	rhs )

nodiscardconstexprnoexcept

Compares two hashed strings.

Template Parameters

Char	Character type.

Parameters

lhs	A valid hashed string.
rhs	A valid hashed string.

Returns: True if the two hashed strings differ, false otherwise.

Definition at line 232 of file hashed_string.hpp.

◆ operator!=() [4/13]

template<typename Ret, typename... Args>

bool entt::operator!=	(	const delegate< Ret(Args...)> &	lhs,
		const delegate< Ret(Args...)> &	rhs )

nodiscardnoexcept

Compares the contents of two delegates.

Template Parameters

Ret	Return type of a function type.
Args	Types of arguments of a function type.

Parameters

lhs	A valid delegate object.
rhs	A valid delegate object.

Returns: True if the two contents differ, false otherwise.

Definition at line 297 of file delegate.hpp.

◆ operator!=() [5/13]

template<typename Entity>

bool entt::operator!=	(	const Entity	lhs,
		const null_t	rhs )

nodiscardconstexprnoexcept

Compares a null object and an identifier of any type.

Template Parameters

Entity Type of identifier.

Parameters

lhs	Identifier with which to compare.
rhs	A null object yet to be converted.

Returns: True if the two elements differ, false otherwise.

Definition at line 279 of file entity.hpp.

◆ operator!=() [6/13]

template<typename Entity>

bool entt::operator!=	(	const Entity	lhs,
		const tombstone_t	rhs )

nodiscardconstexprnoexcept

Compares a tombstone object and an identifier of any type.

Template Parameters

Entity Type of identifier.

Parameters

lhs	Identifier with which to compare.
rhs	A tombstone object yet to be converted.

Returns: True if the two elements differ, false otherwise.

Definition at line 364 of file entity.hpp.

◆ operator!=() [7/13]

template<typename Type>

bool entt::operator!=	(	const iota_iterator< Type > &	lhs,
		const iota_iterator< Type > &	rhs )

nodiscardconstexprnoexcept

Comparison operator.

Template Parameters

Type	Value type of the iota iterator.

Parameters

lhs	A properly initialized iota iterator.
rhs	A properly initialized iota iterator.

Returns: True if the two iterators differ, false otherwise.

Definition at line 131 of file iterator.hpp.

◆ operator!=() [8/13]

bool entt::operator!=	(	const meta_data &	lhs,
		const meta_data &	rhs )

inlinenodiscardnoexcept

Checks if two objects refer to the same type.

Parameters

lhs	An object, either valid or not.
rhs	An object, either valid or not.

Returns: False if the objects refer to the same node, true otherwise.

Definition at line 958 of file meta.hpp.

◆ operator!=() [9/13]

bool entt::operator!=	(	const meta_func &	lhs,
		const meta_func &	rhs )

inlinenodiscardnoexcept

Checks if two objects refer to the same type.

Parameters

lhs	An object, either valid or not.
rhs	An object, either valid or not.

Returns: False if the objects refer to the same node, true otherwise.

Definition at line 1083 of file meta.hpp.

◆ operator!=() [10/13]

bool entt::operator!=	(	const meta_type &	lhs,
		const meta_type &	rhs )

inlinenodiscardnoexcept

Checks if two objects refer to the same type.

Parameters

lhs	An object, either valid or not.
rhs	An object, either valid or not.

Returns: False if the objects refer to the same node, true otherwise.

Definition at line 1535 of file meta.hpp.

◆ operator!=() [11/13]

template<typename... Args>

bool entt::operator!=	(	const null_t	lhs,
		const basic_handle< Args... > &	rhs )

nodiscardconstexprnoexcept

Compares a handle with the null object.

Template Parameters

Args	Scope of the handle.

Parameters

lhs	A null object yet to be converted.
rhs	A valid handle.

Returns: True if the two elements differ, false otherwise.

Definition at line 425 of file handle.hpp.

◆ operator!=() [12/13]

template<typename Lhs, typename Rhs>

bool entt::operator!=	(	const resource< Lhs > &	lhs,
		const resource< Rhs > &	rhs )

nodiscardnoexcept

Compares two handles.

Template Parameters

Lhs	Type of resource managed by the first handle.
Rhs	Type of resource managed by the second handle.

Parameters

lhs	A valid handle.
rhs	A valid handle.

Returns: False if both handles refer to the same resource, true otherwise.

Definition at line 208 of file resource.hpp.

◆ operator!=() [13/13]

bool entt::operator!=	(	const type_info &	lhs,
		const type_info &	rhs )

nodiscardconstexprnoexcept

Compares the contents of two type info objects.

Parameters

lhs	A type info object.
rhs	A type info object.

Returns: True if the two type info objects differ, false otherwise.

Definition at line 192 of file type_info.hpp.

◆ operator""_hs()

hashed_string entt::literals::operator""_hs	(	const char *	str,
		std::size_t	)

nodiscardconstexprnoexcept

User defined literal for hashed strings.

Parameters

str	The literal without its suffix.

Returns: A properly initialized hashed string.

Definition at line 294 of file hashed_string.hpp.

◆ operator""_hws()

hashed_wstring entt::literals::operator""_hws	(	const wchar_t *	str,
		std::size_t	)

nodiscardconstexprnoexcept

User defined literal for hashed wstrings.

Parameters

str	The literal without its suffix.

Returns: A properly initialized hashed wstring.

Definition at line 303 of file hashed_string.hpp.

◆ operator+() [1/2]

template<typename... Type, typename... Other>

type_list< Type..., Other... > entt::operator+	(	type_list< Type... >	,
		type_list< Other... >	)

constexpr

Concatenates multiple type lists.

Template Parameters

Type	Types provided by the first type list.
Other	Types provided by the second type list.

Returns: A type list composed by the types of both the type lists.

Definition at line 210 of file type_traits.hpp.

◆ operator+() [2/2]

template<auto... Value, auto... Other>

value_list< Value..., Other... > entt::operator+	(	value_list< Value... >	,
		value_list< Other... >	)

constexpr

Concatenates multiple value lists.

Template Parameters

Value	Values provided by the first value list.
Other	Values provided by the second value list.

Returns: A value list composed by the values of both the value lists.

Definition at line 475 of file type_traits.hpp.

◆ operator<() [1/3]

template<typename Char>

bool entt::operator<	(	const basic_hashed_string< Char > &	lhs,
		const basic_hashed_string< Char > &	rhs )

nodiscardconstexprnoexcept

Compares two hashed strings.

Template Parameters

Char	Character type.

Parameters

lhs	A valid hashed string.
rhs	A valid hashed string.

Returns: True if the first element is less than the second, false otherwise.

Definition at line 244 of file hashed_string.hpp.

◆ operator<() [2/3]

template<typename Lhs, typename Rhs>

bool entt::operator<	(	const resource< Lhs > &	lhs,
		const resource< Rhs > &	rhs )

nodiscardnoexcept

Compares two handles.

Template Parameters

Lhs	Type of resource managed by the first handle.
Rhs	Type of resource managed by the second handle.

Parameters

lhs	A valid handle.
rhs	A valid handle.

Returns: True if the first handle is less than the second, false otherwise.

Definition at line 221 of file resource.hpp.

◆ operator<() [3/3]

bool entt::operator<	(	const type_info &	lhs,
		const type_info &	rhs )

nodiscardconstexprnoexcept

Compares two type info objects.

Parameters

lhs	A valid type info object.
rhs	A valid type info object.

Returns: True if the first element is less than the second, false otherwise.

Definition at line 202 of file type_info.hpp.

◆ operator<=() [1/3]

template<typename Char>

bool entt::operator<=	(	const basic_hashed_string< Char > &	lhs,
		const basic_hashed_string< Char > &	rhs )

nodiscardconstexprnoexcept

Compares two hashed strings.

Template Parameters

Char	Character type.

Parameters

lhs	A valid hashed string.
rhs	A valid hashed string.

Returns: True if the first element is less than or equal to the second, false otherwise.

Definition at line 257 of file hashed_string.hpp.

◆ operator<=() [2/3]

template<typename Lhs, typename Rhs>

bool entt::operator<=	(	const resource< Lhs > &	lhs,
		const resource< Rhs > &	rhs )

nodiscardnoexcept

Compares two handles.

Template Parameters

Lhs	Type of resource managed by the first handle.
Rhs	Type of resource managed by the second handle.

Parameters

lhs	A valid handle.
rhs	A valid handle.

Returns: True if the first handle is less than or equal to the second, false otherwise.

Definition at line 248 of file resource.hpp.

◆ operator<=() [3/3]

bool entt::operator<=	(	const type_info &	lhs,
		const type_info &	rhs )

nodiscardconstexprnoexcept

Compares two type info objects.

Parameters

lhs	A valid type info object.
rhs	A valid type info object.

Returns: True if the first element is less than or equal to the second, false otherwise.

Definition at line 213 of file type_info.hpp.

◆ operator==() [1/9]

template<typename... Args, typename... Other>

bool entt::operator==	(	const basic_handle< Args... > &	lhs,
		const basic_handle< Other... > &	rhs )

nodiscardnoexcept

Compares two handles.

Template Parameters

Args	Scope of the first handle.
Other	Scope of the second handle.

Parameters

lhs	A valid handle.
rhs	A valid handle.

Returns: True if both handles refer to the same registry and the same entity, false otherwise.

Definition at line 363 of file handle.hpp.

◆ operator==() [2/9]

template<typename... Args>

bool entt::operator==	(	const basic_handle< Args... > &	lhs,
		const null_t	rhs )

nodiscardconstexprnoexcept

Compares a handle with the null object.

Template Parameters

Args	Scope of the handle.

Parameters

lhs	A valid handle.
rhs	A null object yet to be converted.

Returns: False if the two elements differ, true otherwise.

Definition at line 389 of file handle.hpp.

◆ operator==() [3/9]

template<typename Char>

bool entt::operator==	(	const basic_hashed_string< Char > &	lhs,
		const basic_hashed_string< Char > &	rhs )

nodiscardconstexprnoexcept

Compares two hashed strings.

Template Parameters

Char	Character type.

Parameters

lhs	A valid hashed string.
rhs	A valid hashed string.

Returns: True if the two hashed strings are identical, false otherwise.

Definition at line 220 of file hashed_string.hpp.

◆ operator==() [4/9]

template<typename Entity>

bool entt::operator==	(	const Entity	lhs,
		const null_t	rhs )

nodiscardconstexprnoexcept

Compares a null object and an identifier of any type.

Template Parameters

Entity Type of identifier.

Parameters

lhs	Identifier with which to compare.
rhs	A null object yet to be converted.

Returns: False if the two elements differ, true otherwise.

Definition at line 267 of file entity.hpp.

◆ operator==() [5/9]

template<typename Entity>

bool entt::operator==	(	const Entity	lhs,
		const tombstone_t	rhs )

nodiscardconstexprnoexcept

Compares a tombstone object and an identifier of any type.

Template Parameters

Entity Type of identifier.

Parameters

lhs	Identifier with which to compare.
rhs	A tombstone object yet to be converted.

Returns: False if the two elements differ, true otherwise.

Definition at line 352 of file entity.hpp.

◆ operator==() [6/9]

template<typename Type>

bool entt::operator==	(	const iota_iterator< Type > &	lhs,
		const iota_iterator< Type > &	rhs )

nodiscardconstexprnoexcept

Comparison operator.

Template Parameters

Type	Value type of the iota iterator.

Parameters

lhs	A properly initialized iota iterator.
rhs	A properly initialized iota iterator.

Returns: True if the two iterators are identical, false otherwise.

Definition at line 119 of file iterator.hpp.

◆ operator==() [7/9]

template<typename... Args>

bool entt::operator==	(	const null_t	lhs,
		const basic_handle< Args... > &	rhs )

nodiscardconstexprnoexcept

Compares a handle with the null object.

Template Parameters

Args	Scope of the handle.

Parameters

lhs	A null object yet to be converted.
rhs	A valid handle.

Returns: False if the two elements differ, true otherwise.

Definition at line 401 of file handle.hpp.

◆ operator==() [8/9]

template<typename Lhs, typename Rhs>

bool entt::operator==	(	const resource< Lhs > &	lhs,
		const resource< Rhs > &	rhs )

nodiscardnoexcept

Compares two handles.

Template Parameters

Lhs	Type of resource managed by the first handle.
Rhs	Type of resource managed by the second handle.

Parameters

lhs	A valid handle.
rhs	A valid handle.

Returns: True if both handles refer to the same resource, false otherwise.

Definition at line 195 of file resource.hpp.

◆ operator==() [9/9]

bool entt::operator==	(	const type_info &	lhs,
		const type_info &	rhs )

nodiscardconstexprnoexcept

Compares the contents of two type info objects.

Parameters

lhs	A type info object.
rhs	A type info object.

Returns: True if the two type info objects are identical, false otherwise.

Definition at line 182 of file type_info.hpp.

◆ operator>() [1/3]

template<typename Char>

bool entt::operator>	(	const basic_hashed_string< Char > &	lhs,
		const basic_hashed_string< Char > &	rhs )

nodiscardconstexprnoexcept

Compares two hashed strings.

Template Parameters

Char	Character type.

Parameters

lhs	A valid hashed string.
rhs	A valid hashed string.

Returns: True if the first element is greater than the second, false otherwise.

Definition at line 270 of file hashed_string.hpp.

◆ operator>() [2/3]

template<typename Lhs, typename Rhs>

bool entt::operator>	(	const resource< Lhs > &	lhs,
		const resource< Rhs > &	rhs )

nodiscardnoexcept

Compares two handles.

Template Parameters

Lhs	Type of resource managed by the first handle.
Rhs	Type of resource managed by the second handle.

Parameters

lhs	A valid handle.
rhs	A valid handle.

Returns: True if the first handle is greater than the second, false otherwise.

Definition at line 234 of file resource.hpp.

◆ operator>() [3/3]

bool entt::operator>	(	const type_info &	lhs,
		const type_info &	rhs )

nodiscardconstexprnoexcept

Compares two type info objects.

Parameters

lhs	A valid type info object.
rhs	A valid type info object.

Returns: True if the first element is greater than the second, false otherwise.

Definition at line 224 of file type_info.hpp.

◆ operator>=() [1/3]

template<typename Char>

bool entt::operator>=	(	const basic_hashed_string< Char > &	lhs,
		const basic_hashed_string< Char > &	rhs )

nodiscardconstexprnoexcept

Compares two hashed strings.

Template Parameters

Char	Character type.

Parameters

lhs	A valid hashed string.
rhs	A valid hashed string.

Returns: True if the first element is greater than or equal to the second, false otherwise.

Definition at line 283 of file hashed_string.hpp.

◆ operator>=() [2/3]

template<typename Lhs, typename Rhs>

bool entt::operator>=	(	const resource< Lhs > &	lhs,
		const resource< Rhs > &	rhs )

nodiscardnoexcept

Compares two handles.

Template Parameters

Lhs	Type of resource managed by the first handle.
Rhs	Type of resource managed by the second handle.

Parameters

lhs	A valid handle.
rhs	A valid handle.

Returns: True if the first handle is greater than or equal to the second, false otherwise.

Definition at line 262 of file resource.hpp.

◆ operator>=() [3/3]

bool entt::operator>=	(	const type_info &	lhs,
		const type_info &	rhs )

nodiscardconstexprnoexcept

Compares two type info objects.

Parameters

lhs	A valid type info object.
rhs	A valid type info object.

Returns: True if the first element is greater than or equal to the second, false otherwise.

Definition at line 235 of file type_info.hpp.

◆ overload() [1/2]

template<typename Func>

auto entt::overload ( Func * func )

nodiscardconstexprnoexcept

Constant utility to disambiguate overloaded functions.

Template Parameters

Func	Function type of the desired overload.

Parameters

func	A valid pointer to a function.

Returns: Pointer to the function.

Definition at line 45 of file utility.hpp.

◆ overload() [2/2]

template<typename Type, typename Class>

auto entt::overload ( Type Class::* member )

nodiscardconstexprnoexcept

Constant utility to disambiguate overloaded members of a class.

Template Parameters

Type	Type of the desired overload.
Class	Type of class to which the member belongs.

Parameters

member A valid pointer to a member.

Returns: Pointer to the member.

Definition at line 34 of file utility.hpp.

◆ overloaded()

template<typename... Func>

entt::overloaded ( Func... ) -> overloaded< Func... >

Deduction guide.

Template Parameters

Func	Types of function objects.

◆ poly_call()

template<std::size_t Member, typename Poly, typename... Args>

decltype(auto) entt::poly_call	(	Poly &&	self,
		Args &&...	args )

Shortcut for calling poly_base<Type>::invoke.

Template Parameters

Member	Index of the function to invoke.
Poly	A fully defined poly object.
Args	Types of arguments to pass to the function.

Parameters

self	A reference to the poly object that made the call.
args	The arguments to pass to the function.

Returns: The return value of the invoked function, if any.

Definition at line 173 of file poly.hpp.

◆ popcount()

template<typename Type>

std::enable_if_t< std::is_unsigned_v< Type >, int > entt::popcount ( const Type value )

nodiscardconstexprnoexcept

Returns the number of set bits in a value (waiting for C++20 and std::popcount).

Template Parameters

Type	Unsigned integer type.

Parameters

value A value of unsigned integer type.

Returns: The number of set bits in the value.

Definition at line 19 of file bit.hpp.

◆ propagate_on_container_copy_assignment()

template<typename Allocator>

void entt::propagate_on_container_copy_assignment	(	Allocator &	lhs,
		Allocator &	rhs )

constexprnoexcept

Utility function to design allocation-aware containers.

Template Parameters

Allocator Type of allocator.

Parameters

lhs	A valid allocator.
rhs	Another valid allocator.

Definition at line 35 of file memory.hpp.

◆ propagate_on_container_move_assignment()

template<typename Allocator>

void entt::propagate_on_container_move_assignment	(	Allocator &	lhs,
		Allocator &	rhs )

constexprnoexcept

Utility function to design allocation-aware containers.

Template Parameters

Allocator Type of allocator.

Parameters

lhs	A valid allocator.
rhs	Another valid allocator.

Definition at line 48 of file memory.hpp.

◆ propagate_on_container_swap()

template<typename Allocator>

void entt::propagate_on_container_swap	(	Allocator &	lhs,
		Allocator &	rhs )

constexprnoexcept

Utility function to design allocation-aware containers.

Template Parameters

Allocator Type of allocator.

Parameters

lhs	A valid allocator.
rhs	Another valid allocator.

Definition at line 61 of file memory.hpp.

◆ resolve() [1/8]

template<typename Type>

meta_type entt::resolve ( )

nodiscardnoexcept

Returns the meta type associated with a given type.

Template Parameters

Type	Type to use to search for a meta type.

Returns: The meta type associated with the given type, if any.

Definition at line 32 of file resolve.hpp.

◆ resolve() [2/8]

meta_range< meta_type, typename decltype(internal::meta_context::value)::const_iterator > entt::resolve ( )

inlinenodiscardnoexcept

Returns a range to use to visit all meta types.

Returns: An iterable range to use to visit all meta types.

Definition at line 50 of file resolve.hpp.

◆ resolve() [3/8]

meta_type entt::resolve ( const id_type id )

inlinenodiscardnoexcept

Returns the meta type associated with a given identifier, if any.

Parameters

id	Unique identifier.

Returns: The meta type associated with the given identifier, if any.

Definition at line 75 of file resolve.hpp.

◆ resolve() [4/8]

template<typename Type>

meta_type entt::resolve ( const meta_ctx & ctx )

nodiscardnoexcept

Returns the meta type associated with a given type.

Template Parameters

Type	Type to use to search for a meta type.

Parameters

ctx	The context from which to search for meta types.

Returns: The meta type associated with the given type, if any.

Definition at line 21 of file resolve.hpp.

◆ resolve() [5/8]

meta_range< meta_type, typename decltype(internal::meta_context::value)::const_iterator > entt::resolve ( const meta_ctx & ctx )

inlinenodiscardnoexcept

Returns a range to use to visit all meta types.

Parameters

ctx	The context from which to search for meta types.

Returns: An iterable range to use to visit all meta types.

Definition at line 41 of file resolve.hpp.

◆ resolve() [6/8]

meta_type entt::resolve	(	const meta_ctx &	ctx,
		const id_type	id )

inlinenodiscardnoexcept

Returns the meta type associated with a given identifier, if any.

Parameters

ctx	The context from which to search for meta types.
id	Unique identifier.

Returns: The meta type associated with the given identifier, if any.

Definition at line 60 of file resolve.hpp.

◆ resolve() [7/8]

meta_type entt::resolve	(	const meta_ctx &	ctx,
		const type_info &	info )

inlinenodiscardnoexcept

Returns the meta type associated with a given type info object.

Parameters

ctx	The context from which to search for meta types.
info	The type info object of the requested type.

Returns: The meta type associated with the given type info object, if any.

Definition at line 85 of file resolve.hpp.

◆ resolve() [8/8]

meta_type entt::resolve ( const type_info & info )

inlinenodiscardnoexcept

Returns the meta type associated with a given type info object.

Parameters

info	The type info object of the requested type.

Returns: The meta type associated with the given type info object, if any.

Definition at line 96 of file resolve.hpp.

◆ sigh_helper()

template<typename Registry>

entt::sigh_helper ( Registry & ) -> sigh_helper< Registry >

Deduction guide.

Template Parameters

Registry Basic registry type.

◆ sink()

template<typename Ret, typename... Args, typename Allocator>

entt::sink ( sigh< Ret(Args...), Allocator > & ) -> sink< sigh< Ret(Args...), Allocator > >

Deduction guide.

It allows to deduce the signal handler type of a sink directly from the signal it refers to.

Template Parameters

Ret	Return type of a function type.
Args	Types of arguments of a function type.
Allocator	Type of allocator used to manage memory and elements.

◆ swap()

template<typename First, typename Second>

void entt::swap	(	compressed_pair< First, Second > &	lhs,
		compressed_pair< First, Second > &	rhs )

constexprnoexcept

Swaps two compressed pair objects.

Template Parameters

First	The type of the first element that the pairs store.
Second	The type of the second element that the pairs store.

Parameters

lhs	A valid compressed pair object.
rhs	A valid compressed pair object.

Definition at line 243 of file compressed_pair.hpp.

◆ to_address()

template<typename Type>

auto entt::to_address ( Type && ptr )

nodiscardconstexprnoexcept

Unwraps fancy pointers, does nothing otherwise (waiting for C++20).

Template Parameters

Type	Pointer type.

Parameters

ptr	Fancy or raw pointer.

Returns: A raw pointer that represents the address of the original pointer.

Definition at line 20 of file memory.hpp.

◆ to_entity() [1/2]

template<typename... Args>

basic_storage< Args... >::entity_type entt::to_entity	(	const basic_storage< Args... > &	storage,
		const typename basic_storage< Args... >::value_type &	instance )

Returns the entity associated with a given element.

Warning: Currently, this function only works correctly with the default storage as it makes assumptions about how the elements are laid out.

Template Parameters

Args	Storage type template parameters.

Parameters

storage	A storage that contains the given element.
instance	A valid element instance.

Returns: The entity associated with the given element.

Definition at line 126 of file helper.hpp.

◆ to_entity() [2/2]

template<typename Entity>

entt_traits< Entity >::entity_type entt::to_entity ( const Entity value )

nodiscardconstexprnoexcept

Returns the entity part once converted to the underlying type.

Template Parameters

Entity The value type.

Parameters

value The value to convert.

Returns: The integral representation of the entity part.

Definition at line 188 of file entity.hpp.

◆ to_integral()

template<typename Entity>

entt_traits< Entity >::entity_type entt::to_integral ( const Entity value )

nodiscardconstexprnoexcept

Converts an entity to its underlying type.

Template Parameters

Entity The value type.

Parameters

value The value to convert.

Returns: The integral representation of the given value.

Definition at line 177 of file entity.hpp.

◆ to_version()

template<typename Entity>

entt_traits< Entity >::version_type entt::to_version ( const Entity value )

nodiscardconstexprnoexcept

Returns the version part once converted to the underlying type.

Template Parameters

Entity The value type.

Parameters

value The value to convert.

Returns: The integral representation of the version part.

Definition at line 199 of file entity.hpp.

◆ type_id() [1/2]

template<typename Type>

const type_info & entt::type_id ( )

nodiscardnoexcept

Returns the type info object associated to a given type.

The returned element refers to an object with static storage duration.
The type doesn't need to be a complete type. If the type is a reference, the result refers to the referenced type. In all cases, top-level cv-qualifiers are ignored.

Template Parameters

Type	Type for which to generate a type info object.

Returns: A reference to a properly initialized type info object.

Definition at line 251 of file type_info.hpp.

◆ type_id() [2/2]

template<typename Type>

const type_info & entt::type_id ( Type && )

nodiscardnoexcept

Returns the type info object associated to a given type.

The returned element refers to an object with static storage duration.
The type doesn't need to be a complete type. If the type is a reference, the result refers to the referenced type. In all cases, top-level cv-qualifiers are ignored.

Template Parameters

Type	Type for which to generate a type info object.

Returns: A reference to a properly initialized type info object.

Definition at line 263 of file type_info.hpp.

◆ uninitialized_construct_using_allocator()

template<typename Type, typename Allocator, typename... Args>

Type * entt::uninitialized_construct_using_allocator	(	Type *	value,
		const Allocator &	allocator,
		Args &&...	args )

constexpr

Uses-allocator construction utility (waiting for C++20).

Primarily intended for internal use. Creates an object of a given type by means of uses-allocator construction at an uninitialized memory location.

Template Parameters

Type	Type of object to create.
Allocator	Type of allocator used to manage memory and elements.
Args	Types of arguments to use to construct the object.

Parameters

value	Memory location in which to place the object.
allocator	The allocator to use.
args	Parameters to use to construct the object.

Returns: A pointer to the newly created object of the given type.

Definition at line 238 of file memory.hpp.

◆ unwrap_tuple()

template<typename Type>

decltype(auto) entt::unwrap_tuple ( Type && value )

constexprnoexcept

Utility function to unwrap tuples of a single element.

Template Parameters

Type	Tuple type of any sizes.

Parameters

value A tuple object of the given type.

Returns: The tuple itself if it contains more than one element, the first element otherwise.

Definition at line 40 of file tuple.hpp.

◆ uses_allocator_construction_args()

template<typename Type, typename Allocator, typename... Args>

auto entt::uses_allocator_construction_args	(	const Allocator &	allocator,
		Args &&...	args )

constexprnoexcept

Uses-allocator construction utility (waiting for C++20).

Primarily intended for internal use. Prepares the argument list needed to create an object of a given type by means of uses-allocator construction.

Template Parameters

Type	Type to return arguments for.
Allocator	Type of allocator used to manage memory and elements.
Args	Types of arguments to use to construct the object.

Parameters

allocator	The allocator to use.
args	Parameters to use to construct the object.

Returns: The arguments needed to create an object of the given type.

Definition at line 201 of file memory.hpp.

Variable Documentation

◆ choice

template<std::size_t N>

choice_t<N> entt::choice {}

inlineconstexpr

Variable template for the choice trick.

Template Parameters

N	Number of choices available.

Definition at line 33 of file type_traits.hpp.

◆ connect_arg

template<auto Candidate>

connect_arg_t<Candidate> entt::connect_arg {}

inlineconstexpr

Constant of type connect_arg_t used to disambiguate calls.

Template Parameters

Candidate Element to connect (likely a free or member function).

Definition at line 42 of file fwd.hpp.

◆ enum_as_bitmask_v

template<typename Type>

bool entt::enum_as_bitmask_v = enum_as_bitmask<Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

Type	The enum class type for which to enable bitmask support.

Definition at line 24 of file enum.hpp.

◆ exclude

template<typename... Type>

exclude_t<Type...> entt::exclude {}

inlineconstexpr

Variable template for exclusion lists.

Template Parameters

Type	List of types.

Definition at line 150 of file fwd.hpp.

◆ get

template<typename... Type>

get_t<Type...> entt::get {}

inlineconstexpr

Variable template for lists of observed elements.

Template Parameters

Type	List of types.

Definition at line 167 of file fwd.hpp.

◆ is_applicable_r_v

template<typename Ret, typename Func, typename Args>

bool entt::is_applicable_r_v = is_applicable_r<Ret, Func, Args>::value

inlineconstexpr

Helper variable template.

Template Parameters

Ret	The type to which the return type of the function should be convertible.
Func	A valid function type.
Args	The list of arguments to use to probe the function type.

Definition at line 651 of file type_traits.hpp.

◆ is_applicable_v

template<typename Func, typename Args>

bool entt::is_applicable_v = is_applicable<Func, Args>::value

inlineconstexpr

Helper variable template.

Template Parameters

Func	A valid function type.
Args	The list of arguments to use to probe the function type.

Definition at line 627 of file type_traits.hpp.

◆ is_complete_v

template<typename Type>

bool entt::is_complete_v = is_complete<Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

Type	The type to test.

Definition at line 670 of file type_traits.hpp.

◆ is_ebco_eligible_v

template<typename Type>

bool entt::is_ebco_eligible_v = is_ebco_eligible<Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

Type	The type to test.

Definition at line 718 of file type_traits.hpp.

◆ is_equality_comparable_v

template<typename Type>

bool entt::is_equality_comparable_v = is_equality_comparable<Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

Type	The type to test.

Definition at line 815 of file type_traits.hpp.

◆ is_iterator_v

template<typename Type>

bool entt::is_iterator_v = is_iterator<Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

Type	The type to test.

Definition at line 702 of file type_traits.hpp.

◆ is_meta_pointer_like_v

template<typename Type>

auto entt::is_meta_pointer_like_v = is_meta_pointer_like<Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

Type	Potentially pointer-like type.

Definition at line 50 of file type_traits.hpp.

◆ is_meta_policy_v

template<typename Type>

bool entt::is_meta_policy_v = is_meta_policy<Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

Type	Type to check.

Definition at line 54 of file policy.hpp.

◆ is_transparent_v

template<typename Type>

bool entt::is_transparent_v = is_transparent<Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

Type	The type to test.

Definition at line 737 of file type_traits.hpp.

◆ is_tuple_v

template<typename Type>

bool entt::is_tuple_v = is_tuple<Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

Type	The type to test.

Definition at line 30 of file tuple.hpp.

◆ meta_ctx_arg

meta_ctx_arg_t entt::meta_ctx_arg {}

inlineconstexpr

Constant of type meta_context_arg_t used to disambiguate calls.

Definition at line 31 of file context.hpp.

◆ monostate_v

template<id_type Value>

monostate<Value> entt::monostate_v {}

inline

Helper variable template.

Template Parameters

Value Value used to differentiate between different variables.

Definition at line 56 of file monostate.hpp.

◆ null

null_t entt::null {}

inlineconstexpr

Compile-time constant for null entities.

There exist implicit conversions from this variable to identifiers of any allowed type. Similarly, there exist comparison operators between the null entity and any other identifier.

Definition at line 375 of file entity.hpp.

◆ owned

template<typename... Type>

owned_t<Type...> entt::owned {}

inlineconstexpr

Variable template for lists of owned elements.

Template Parameters

Type	List of types.

Definition at line 184 of file fwd.hpp.

◆ size_of_v

template<typename Type>

std::size_t entt::size_of_v = size_of<Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

Type	The type of which to return the size.

Definition at line 74 of file type_traits.hpp.

◆ tombstone

tombstone_t entt::tombstone {}

inlineconstexpr

Compile-time constant for tombstone entities.

There exist implicit conversions from this variable to identifiers of any allowed type. Similarly, there exist comparison operators between the tombstone entity and any other identifier.

Definition at line 384 of file entity.hpp.

◆ type_list_contains_v

template<typename List, typename Type>

bool entt::type_list_contains_v = type_list_contains<List, Type>::value

inlineconstexpr

Helper variable template.

Template Parameters

List	Type list.
Type	Type to look for.

Definition at line 313 of file type_traits.hpp.

◆ type_list_index_v

template<typename Type, typename List>

std::size_t entt::type_list_index_v = type_list_index<Type, List>::value

inlineconstexpr

Helper variable template.

Template Parameters

List	Type list.
Type	Type to look for and for which to return the index.

Definition at line 201 of file type_traits.hpp.

◆ unpack_as_value

template<auto Value, typename>

auto entt::unpack_as_value = Value

inlineconstexpr

Helper variable template to be used to repeat the same value a number of times equal to the size of a given parameter pack.

Template Parameters

Value A value to repeat.

Definition at line 90 of file type_traits.hpp.

◆ value_list_contains_v

template<typename List, auto Value>

bool entt::value_list_contains_v = value_list_contains<List, Value>::value

inlineconstexpr

Helper variable template.

Template Parameters

List	Value list.
Value	Value to look for.

Definition at line 575 of file type_traits.hpp.

◆ value_list_element_v

template<std::size_t Index, typename List>

auto entt::value_list_element_v = value_list_element<Index, List>::value

inlineconstexpr

Helper type.

Template Parameters

Index	Index of the value to return.
List	Value list to search into.

Definition at line 414 of file type_traits.hpp.

◆ value_list_index_v

template<auto Value, typename List>

std::size_t entt::value_list_index_v = value_list_index<Value, List>::value

inlineconstexpr

Helper variable template.

Template Parameters

List	Value list.
Value	Value to look for and for which to return the index.

Definition at line 466 of file type_traits.hpp.

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ any

◆ const_handle

◆ const_handle_view

◆ const_runtime_view

◆ constness_as_t

◆ continuous_loader

◆ dispatcher

◆ flow

◆ group

◆ handle

◆ handle_view

◆ hashed_string

◆ hashed_wstring

◆ id_type

◆ integral_constant

◆ member_class_t

◆ meta_function_helper_t

◆ meta_range

◆ nth_argument_t

◆ organizer

◆ poly

◆ reactive_mixin

◆ registry

◆ runtime_view

◆ scheduler

◆ sigh_mixin

◆ snapshot

◆ snapshot_loader

◆ sparse_set

◆ storage

◆ storage_for_t

◆ storage_type_t

◆ table

◆ tag

◆ type_identity_t

◆ type_list_cat_t

◆ type_list_diff_t

◆ type_list_element_t

◆ type_list_transform_t

◆ type_list_unique_t

◆ unpack_as_type

◆ value_list_cat_t

◆ value_list_diff_t

◆ value_list_element_t

◆ value_list_unique_t

◆ view

Enumeration Type Documentation

◆ any_policy [1/2]

◆ any_policy [2/2]

◆ deletion_policy

◆ entity

Function Documentation

◆ allocate_unique()

◆ any_cast() [1/5]

◆ any_cast() [2/5]

◆ any_cast() [3/5]

◆ any_cast() [4/5]

◆ any_cast() [5/5]

◆ basic_hashed_string() [1/2]

◆ basic_hashed_string() [2/2]

◆ basic_view() [1/2]

◆ basic_view() [2/2]

◆ compressed_pair()

◆ delegate() [1/3]

◆ delegate() [2/3]

◆ delegate() [3/3]

◆ dereference_meta_pointer_like()

◆ dot() [1/2]

◆ dot() [2/2]

◆ fast_mod()

◆ forward_apply()

◆ forward_as_any()

◆ forward_as_meta() [1/2]