Classes
struct	as_alias_t
	Empty class type used to request the as alias policy. More...

struct	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_view
	Converts a registry to a view. More...

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

struct	basic_actor
	Dedicated to those who aren't confident with the entity-component-system architecture. More...

struct	basic_collector
	Collector. More...

struct	basic_collector< matcher< type_list< Reject... >, type_list< Require... >, Rule... >, Other... >
	Collector. More...

struct	basic_collector<>
	Collector. More...

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

class	basic_group
	Group. More...

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

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

class	basic_hashed_string
	Zero overhead unique identifier. More...

class	basic_observer
	Observer. More...

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

class	basic_runtime_view
	Runtime view. 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_storage
	Basic storage implementation. More...

class	basic_storage< Entity, Type, std::enable_if_t< ENTT_ENABLE_ETO(Type)> >
	Basic storage implementation. More...

class	basic_view
	View. More...

class	basic_view< Entity, exclude_t< Exclude... >, Component... >
	Multi component view. More...

class	basic_view< Entity, exclude_t<>, Component >
	Single component view specialization. More...

struct	cache
	Simple cache for resources of a given type. More...

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

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

struct	connect_arg_t
	Used to wrap a function or a member of a specified type. More...

class	connection
	Connection class. More...

class	delegate
	Basic delegate implementation. More...

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

class	dispatcher
	Basic dispatcher implementation. More...

class	emitter
	General purpose event emitter. More...

struct	entt_traits
	Entity traits. More...

struct	entt_traits< std::uint16_t >
	Entity traits for a 16 bits entity identifier. More...

struct	entt_traits< std::uint32_t >
	Entity traits for a 32 bits entity identifier. More...

struct	entt_traits< std::uint64_t >
	Entity traits for a 64 bits entity identifier. More...

struct	exclude_t
	Alias for exclusion lists. More...

class	extended_meta_factory
	Extended meta factory to be used for reflection purposes. More...

class	family
	Dynamic identifier generator. More...

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

class	handle
	Shared resource handle. More...

class	identifier
	Types identifiers. More...

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

struct	insertion_sort
	Function object for performing insertion sort. 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< Type, std::void_t< decltype(std::declval< Type >()==std::declval< Type >())> >
	Provides the member constant `value` to true if a given type is equality comparable, false otherwise. More...

struct	is_named_type
	Provides the member constant `value` to true if a given type has a name. In all other cases, `value` is false. More...

struct	is_named_type< Type, std::void_t< named_type_traits_t< std::decay_t< Type > > > >
	Provides the member constant `value` to true if a given type has a name. In all other cases, `value` is false. More...

class	loader
	Base class for resource loaders. More...

struct	matcher
	Grouping matcher. More...

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

struct	meta_base
	Opaque container for meta base classes. More...

struct	meta_conv
	Opaque container for meta conversion functions. More...

struct	meta_ctor
	Opaque container for meta constructors. More...

struct	meta_ctx
	Opaque container for a meta context. More...

struct	meta_data
	Opaque container for meta data. More...

struct	meta_dtor
	Opaque container for meta destructors. More...

class	meta_factory
	A meta factory to be used for reflection purposes. More...

struct	meta_func
	Opaque container for meta functions. More...

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

struct	meta_prop
	Opaque container for meta properties of any type. More...

class	meta_type
	Opaque container for meta types. More...

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

struct	named_type_traits
	Traits class used mainly to push things across boundaries. More...

struct	named_type_traits< const Type >
	Specialization used to get rid of constness. More...

struct	overloaded
	Helper type for visitors. 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...

class	scheduler
	Cooperative scheduler for processes. More...

struct	scoped_connection
	Scoped connection class. More...

struct	service_locator
	Service locator, nothing more. More...

class	sigh
	Unmanaged signal handler. More...

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

class	sink
	Sink class. More...

class	sink< Ret(Args...)>
	Sink class. More...

class	sparse_set
	Basic sparse set implementation. More...

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

struct	storage
	Basic storage implementation. 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_size
	Primary template isn't defined on purpose. More...

struct	type_list_size< type_list< Type... > >
	Compile-time number of elements in a type list. More...

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

struct	type_list_unique< type_list< Type, Other... > >
	Removes duplicates types from a type list. More...

struct	type_list_unique< type_list<> >
	Removes duplicates types from a type list. More...

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

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

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

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

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

template<typename Type >
using	named_type_traits_t = typename named_type_traits< Type >::type
	Helper type. More...

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

using	observer = basic_observer< entity >
	Alias declaration for the most common use case. More...

using	actor = basic_actor< entity >
	Alias declaration for the most common use case. More...

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

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

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

template<typename... Types>
using	view = basic_view< entity, Types... >
	Alias declaration for the most common use case. More...

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

template<typename... Types>
using	group = basic_group< entity, Types... >
	Alias declaration for the most common use case. More...

template<ENTT_ID_TYPE Value>
using	tag = std::integral_constant< ENTT_ID_TYPE, Value >
	Alias template to ease the assignment of tags to entities. More...

Functions
template<typename Type , typename Class >
constexpr auto	overload (Type Class::*member) ENTT_NOEXCEPT
	Constant utility to disambiguate overloaded member functions. More...

template<typename Type >
constexpr auto	overload (Type *func) ENTT_NOEXCEPT
	Constant utility to disambiguate overloaded functions. More...

template<class... Type>
	overloaded (Type...) -> overloaded< Type... >
	Deduction guide. More...

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

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

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

template<auto Function>
	delegate (connect_arg_t< Function >) ENTT_NOEXCEPT -> delegate< std::remove_pointer_t< internal::to_function_pointer_t< decltype(Function)>>>
	Deduction guide. More...

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

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

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

	ENTT_OPAQUE_TYPE (entity, ENTT_ID_TYPE)
	Alias declaration for the most common use case. More...

	ENTT_OPAQUE_TYPE (component, ENTT_ID_TYPE)
	Alias declaration for the most common use case. More...

template<typename Entity >
	as_view (basic_registry< Entity > &) ENTT_NOEXCEPT -> as_view< false, Entity >
	Deduction guide. More...

template<typename Entity >
	as_view (const basic_registry< Entity > &) ENTT_NOEXCEPT -> as_view< true, Entity >
	Deduction guide. More...

template<typename Entity >
	as_group (basic_registry< Entity > &) ENTT_NOEXCEPT -> as_group< false, Entity >
	Deduction guide. More...

template<typename Entity >
	as_group (const basic_registry< Entity > &) ENTT_NOEXCEPT -> as_group< true, Entity >
	Deduction guide. More...

bool	operator!= (const meta_any &lhs, const meta_any &rhs) ENTT_NOEXCEPT
	Checks if two containers differ in their content. More...

bool	operator!= (const meta_prop &lhs, const meta_prop &rhs) ENTT_NOEXCEPT
	Checks if two meta objects refer to the same node. More...

bool	operator!= (const meta_base &lhs, const meta_base &rhs) ENTT_NOEXCEPT
	Checks if two meta objects refer to the same node. More...

bool	operator!= (const meta_conv &lhs, const meta_conv &rhs) ENTT_NOEXCEPT
	Checks if two meta objects refer to the same node. More...

bool	operator!= (const meta_ctor &lhs, const meta_ctor &rhs) ENTT_NOEXCEPT
	Checks if two meta objects refer to the same node. More...

bool	operator!= (const meta_dtor &lhs, const meta_dtor &rhs) ENTT_NOEXCEPT
	Checks if two meta objects refer to the same node. More...

bool	operator!= (const meta_data &lhs, const meta_data &rhs) ENTT_NOEXCEPT
	Checks if two meta objects refer to the same node. More...

bool	operator!= (const meta_func &lhs, const meta_func &rhs) ENTT_NOEXCEPT
	Checks if two meta objects refer to the same node. More...

bool	operator!= (const meta_type &lhs, const meta_type &rhs) ENTT_NOEXCEPT
	Checks if two meta objects refer to the same node. More...

template<typename Type >
meta_factory< Type >	meta () ENTT_NOEXCEPT
	Utility function to use for reflection. More...

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

meta_type	resolve (const ENTT_ID_TYPE identifier) ENTT_NOEXCEPT
	Returns the meta type associated with a given identifier. More...

template<typename Op >
std::enable_if_t< std::is_invocable_v< Op, meta_type >, void >	resolve (Op op) ENTT_NOEXCEPT
	Iterates all the reflected types. More...

Variables
template<ENTT_ID_TYPE Value>
monostate< Value >	monostate_v = {}
	Helper variable template. More...

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

template<class List >
constexpr auto	type_list_size_v = type_list_size<List>::value
	Helper variable template. More...

template<class Type >
constexpr auto	is_equality_comparable_v = is_equality_comparable<Type>::value
	Helper variable template. More...

template<class Type >
constexpr auto	named_type_traits_v = named_type_traits<Type>::value
	Helper variable template. More...

template<class Type >
constexpr auto	is_named_type_v = is_named_type<Type>::value
	Helper variable template. More...

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

constexpr auto	null = internal::null{}
	Compile-time constant for null entities. More...

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

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

constexpr basic_collector	collector {}
	Variable template used to ease the definition of collectors. More...

constexpr as_alias_t	as_alias
	Disambiguation tag. More...

Typedef Documentation

◆ actor

using entt::actor = typedef basic_actor<entity>

Alias declaration for the most common use case.

◆ continuous_loader

using entt::continuous_loader = typedef basic_continuous_loader<entity>

Alias declaration for the most common use case.

◆ group

template<typename... Types>

using entt::group = typedef basic_group<entity, Types...>

Alias declaration for the most common use case.

Template Parameters

Types Types of components iterated by the group.

◆ hashed_string

using entt::hashed_string = typedef basic_hashed_string<char>

Aliases for common character types.

◆ hashed_wstring

using entt::hashed_wstring = typedef basic_hashed_string<wchar_t>

Aliases for common character types.

◆ named_type_traits_t

template<typename Type >

using entt::named_type_traits_t = typedef typename named_type_traits<Type>::type

Helper type.

Template Parameters

Type	Potentially named type.

◆ observer

using entt::observer = typedef basic_observer<entity>

Alias declaration for the most common use case.

◆ registry

using entt::registry = typedef basic_registry<entity>

Alias declaration for the most common use case.

◆ runtime_view

using entt::runtime_view = typedef basic_runtime_view<entity>

Alias declaration for the most common use case.

◆ snapshot

using entt::snapshot = typedef basic_snapshot<entity>

Alias declaration for the most common use case.

◆ snapshot_loader

using entt::snapshot_loader = typedef basic_snapshot_loader<entity>

Alias declaration for the most common use case.

◆ tag

template<ENTT_ID_TYPE Value>

using entt::tag = typedef std::integral_constant<ENTT_ID_TYPE, Value>

Alias template to ease the assignment of tags to entities.

If used in combination with hashed strings, it simplifies the assignment of tags to entities and the use of tags in general where a type would be required otherwise.
As an example and where the user defined literal for hashed strings hasn't been changed:

entt::registry registry;

registry.assign<entt::tag<"enemy"_hs>>(entity);

Note: Tags are empty components and therefore candidates for the empty component optimization.

Template Parameters

Value The numeric representation of an instance of hashed string.

◆ type_list_cat_t

template<typename... List>

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

Helper type.

Template Parameters

List	Type lists to concatenate.

◆ type_list_unique_t

template<typename Type >

using entt::type_list_unique_t = typedef typename type_list_unique<Type>::type

Helper type.

Template Parameters

Type	A type list.

◆ view

template<typename... Types>

using entt::view = typedef basic_view<entity, Types...>

Alias declaration for the most common use case.

Template Parameters

Types Types of components iterated by the view.

Function Documentation

◆ as_group() [1/2]

template<typename Entity >

entt::as_group ( basic_registry< Entity > & ) -> as_group< false, Entity >

Deduction guide.

It allows to deduce the constness of a registry directly from the instance provided to the constructor.

Template Parameters

Entity A valid entity type (see entt_traits for more details).

◆ as_group() [2/2]

template<typename Entity >

entt::as_group ( const basic_registry< Entity > & ) -> as_group< true, Entity >

Deduction guide.

It allows to deduce the constness of a registry directly from the instance provided to the constructor.

Template Parameters

Entity A valid entity type (see entt_traits for more details).

◆ as_view() [1/2]

template<typename Entity >

entt::as_view ( basic_registry< Entity > & ) -> as_view< false, Entity >

Deduction guide.

It allows to deduce the constness of a registry directly from the instance provided to the constructor.

Template Parameters

Entity A valid entity type (see entt_traits for more details).

◆ as_view() [2/2]

template<typename Entity >

entt::as_view ( const basic_registry< Entity > & ) -> as_view< true, Entity >

Deduction guide.

It allows to deduce the constness of a registry directly from the instance provided to the constructor.

Template Parameters

Entity A valid entity type (see entt_traits for more details).

◆ basic_hashed_string()

template<typename Char , std::size_t N>

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

Deduction guide.

It allows to deduce the character type of the hashed string directly from a human-readable identifer provided to the constructor.

Template Parameters

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

Parameters

str	Human-readable identifer.

◆ delegate() [1/3]

template<auto Candidate, typename Type >

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

Deduction guide.

It allows to deduce the function type of the delegate directly from a member or a free function with payload provided to the constructor.

Template Parameters

Candidate	Member or free function to connect to the delegate.
Type	Type of class or type of payload.

◆ delegate() [2/3]

template<auto Candidate, typename Type >

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

Deduction guide.

It allows to deduce the function type of the delegate directly from a member or a free function with payload provided to the constructor.

Template Parameters

Candidate	Member or free function to connect to the delegate.
Type	Type of class or type of payload.

◆ delegate() [3/3]

template<auto Function>

entt::delegate ( connect_arg_t< Function > ) -> delegate< std::remove_pointer_t< internal::to_function_pointer_t< decltype(Function)>>>

Deduction guide.

It allows to deduce the function type of the delegate directly from a function provided to the constructor.

Template Parameters

Function A valid free function pointer.

◆ ENTT_OPAQUE_TYPE() [1/2]

entt::ENTT_OPAQUE_TYPE	(	component	,
		ENTT_ID_TYPE
	)

Alias declaration for the most common use case.

◆ ENTT_OPAQUE_TYPE() [2/2]

entt::ENTT_OPAQUE_TYPE	(	entity	,
		ENTT_ID_TYPE
	)

Alias declaration for the most common use case.

◆ meta()

template<typename Type >

meta_factory<Type> entt::meta ( )

inline

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.

◆ operator!=() [1/11]

template<typename Char >

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

constexpr

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.

◆ operator!=() [2/11]

template<typename Ret , typename... Args>

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

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.

◆ operator!=() [3/11]

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

inline

Checks if two containers differ in their content.

Parameters

lhs	A meta any object, either empty or not.
rhs	A meta any object, either empty or not.

Returns: True if the two containers differ in their content, false otherwise.

◆ operator!=() [4/11]

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

inline

Checks if two meta objects refer to the same node.

Parameters

lhs	A meta object, either valid or not.
rhs	A meta object, either valid or not.

Returns: True if the two meta objects refer to the same node, false otherwise.

◆ operator!=() [5/11]

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

inline

Checks if two meta objects refer to the same node.

Parameters

lhs	A meta object, either valid or not.
rhs	A meta object, either valid or not.

Returns: True if the two meta objects refer to the same node, false otherwise.

◆ operator!=() [6/11]

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

inline

Checks if two meta objects refer to the same node.

Parameters

lhs	A meta object, either valid or not.
rhs	A meta object, either valid or not.

Returns: True if the two meta objects refer to the same node, false otherwise.

◆ operator!=() [7/11]

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

inline

Checks if two meta objects refer to the same node.

Parameters

lhs	A meta object, either valid or not.
rhs	A meta object, either valid or not.

Returns: True if the two meta objects refer to the same node, false otherwise.

◆ operator!=() [8/11]

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

inline

Checks if two meta objects refer to the same node.

Parameters

lhs	A meta object, either valid or not.
rhs	A meta object, either valid or not.

Returns: True if the two meta objects refer to the same node, false otherwise.

◆ operator!=() [9/11]

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

inline

Checks if two meta objects refer to the same node.

Parameters

lhs	A meta object, either valid or not.
rhs	A meta object, either valid or not.

Returns: True if the two meta objects refer to the same node, false otherwise.

◆ operator!=() [10/11]

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

inline

Checks if two meta objects refer to the same node.

Parameters

lhs	A meta object, either valid or not.
rhs	A meta object, either valid or not.

Returns: True if the two meta objects refer to the same node, false otherwise.

◆ operator!=() [11/11]

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

inline

Checks if two meta objects refer to the same node.

Parameters

lhs	A meta object, either valid or not.
rhs	A meta object, either valid or not.

Returns: True if the two meta objects refer to the same node, false otherwise.

◆ overload() [1/2]

template<typename Type >

constexpr auto entt::overload ( Type * func )

constexpr

Constant utility to disambiguate overloaded functions.

Template Parameters

Type	Function type of the desired overload.

Parameters

func	A valid pointer to a function.

Returns: Pointer to the function.

◆ overload() [2/2]

template<typename Type , typename Class >

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

constexpr

Constant utility to disambiguate overloaded member functions.

Template Parameters

Type	Function type of the desired overload.
Class	Type of class to which the member functions belong.

Parameters

member A valid pointer to a member function.

Returns: Pointer to the member function.

◆ overloaded()

template<class... Type>

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

Deduction guide.

Template Parameters

Func	Types of function objects.

◆ resolve() [1/3]

template<typename Type >

meta_type entt::resolve ( )

inline

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.

◆ resolve() [2/3]

meta_type entt::resolve ( const ENTT_ID_TYPE identifier )

inline

Returns the meta type associated with a given identifier.

Parameters

identifier Unique identifier.

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

◆ resolve() [3/3]

template<typename Op >

std::enable_if_t<std::is_invocable_v<Op, meta_type>, void> entt::resolve ( Op op )

inline

Iterates all the reflected types.

Template Parameters

Op	Type of the function object to invoke.

Parameters

op	A valid function object.

◆ sink()

template<typename Ret , typename... Args>

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

Deduction guide.

It allows to deduce the function 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.

Variable Documentation

◆ as_alias

constexpr as_alias_t entt::as_alias

constexpr

Disambiguation tag.

◆ choice

template<std::size_t N>

constexpr choice_t<N> entt::choice {}

constexpr

Variable template for the choice trick.

Template Parameters

N	Number of choices available.

◆ collector

constexpr basic_collector entt::collector {}

constexpr

Variable template used to ease the definition of collectors.

◆ connect_arg

template<auto Func>

constexpr connect_arg_t<Func> entt::connect_arg {}

constexpr

Constant of type connect_arg_t used to disambiguate calls.

◆ exclude

template<typename... Type>

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

constexpr

Variable template for exclusion lists.

Template Parameters

Type	List of types.

◆ get

template<typename... Type>

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

constexpr

Variable template for lists of observed components.

Template Parameters

Type	List of types.

◆ is_equality_comparable_v

template<class Type >

constexpr auto entt::is_equality_comparable_v = is_equality_comparable<Type>::value

constexpr

Helper variable template.

Template Parameters

Type	Potentially equality comparable type.

◆ is_named_type_v

template<class Type >

constexpr auto entt::is_named_type_v = is_named_type<Type>::value

constexpr

Helper variable template.

Template Parameters

Type	Potentially named type.

◆ monostate_v

template<ENTT_ID_TYPE Value>

monostate<Value> entt::monostate_v = {}

inline

Helper variable template.

Template Parameters

Value Value used to differentiate between different variables.

◆ named_type_traits_v

template<class Type >

constexpr auto entt::named_type_traits_v = named_type_traits<Type>::value

constexpr

Helper variable template.

Template Parameters

Type	Potentially named type.

◆ null

constexpr auto entt::null = internal::null{}

constexpr

Compile-time constant for null entities.

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

◆ type_list_size_v

template<class List >

constexpr auto entt::type_list_size_v = type_list_size<List>::value

constexpr

Helper variable template.

Template Parameters

List	Type list.

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ actor

◆ continuous_loader

◆ group

◆ hashed_string

◆ hashed_wstring

◆ named_type_traits_t

◆ observer

◆ registry

◆ runtime_view

◆ snapshot

◆ snapshot_loader

◆ tag

◆ type_list_cat_t

◆ type_list_unique_t

◆ view

Function Documentation

◆ as_group() [1/2]

◆ as_group() [2/2]

◆ as_view() [1/2]

◆ as_view() [2/2]

◆ basic_hashed_string()

◆ delegate() [1/3]

◆ delegate() [2/3]

◆ delegate() [3/3]

◆ ENTT_OPAQUE_TYPE() [1/2]

◆ ENTT_OPAQUE_TYPE() [2/2]

◆ meta()

◆ operator!=() [1/11]

◆ operator!=() [2/11]

◆ operator!=() [3/11]

◆ operator!=() [4/11]

◆ operator!=() [5/11]

◆ operator!=() [6/11]

◆ operator!=() [7/11]

◆ operator!=() [8/11]

◆ operator!=() [9/11]

◆ operator!=() [10/11]

◆ operator!=() [11/11]

◆ overload() [1/2]

◆ overload() [2/2]

◆ overloaded()

◆ resolve() [1/3]

◆ resolve() [2/3]

◆ resolve() [3/3]

◆ sink()

Variable Documentation

◆ as_alias

◆ choice

◆ collector

◆ connect_arg

◆ exclude

◆ get

◆ is_equality_comparable_v

◆ is_named_type_v

◆ monostate_v

◆ named_type_traits_v

◆ null

◆ type_list_size_v