Int to enum. More...

Classes
struct	always_false

struct	arg_list

struct	builder

struct	component_binding_ctx

struct	cpp_type

struct	cpp_type< T, if_not_t< is_pair< T >::value > >

struct	cpp_type< T, if_t< is_pair< T >::value > >

struct	cpp_type_impl

struct	each_column

struct	each_column< T, if_t< !is_pointer< T >::value &&!is_empty< actual_type_t< T > >::value &&!is_actual< T >::value > >

struct	each_column< T, if_t< !is_pointer< T >::value &&!is_empty< actual_type_t< T > >::value &&is_actual< T >::value > >

struct	each_column< T, if_t< is_empty< actual_type_t< T > >::value &&!is_pointer< T >::value > >

struct	each_column< T, if_t< is_pointer< T >::value &&!is_empty< actual_type_t< T > >::value > >

struct	each_column_base

struct	each_invoker

struct	each_ref_column

struct	entity_with_invoker

struct	entity_with_invoker< Func, if_t< is_callable< Func >::value > >

struct	entity_with_invoker_impl

struct	entity_with_invoker_impl< arg_list< Args ... > >

struct	enum_constant_data
	Enumeration constant data. More...

struct	enum_data_impl
	Enumeration type data. More...

struct	enum_is_valid

struct	enum_type
	Class that scans an enum for constants, extracts names & creates entities. More...

struct	filter_invoker

struct	filter_invoker< Func, if_not_t< is_same< first_arg_t< Func >, flecs::entity >::value > >

struct	filter_invoker< Func, if_t< is_same< first_arg_t< Func >, flecs::entity >::value > >

struct	filter_invoker_no_ent

struct	filter_invoker_no_ent< Func, arg_list< Args ... > >

struct	filter_invoker_w_ent

struct	filter_invoker_w_ent< Func, arg_list< E, Args ... > >

struct	function_traits

struct	function_traits_defs

struct	function_traits_impl

struct	function_traits_impl< ReturnType(*)(Args...)>

struct	function_traits_impl< ReturnType(Args...)>

struct	function_traits_impl< ReturnType(ClassType::*)(Args...) const & >

struct	function_traits_impl< ReturnType(ClassType::*)(Args...) const && >

struct	function_traits_impl< ReturnType(ClassType::*)(Args...) const >

struct	function_traits_impl< ReturnType(ClassType::*)(Args...) const volatile & >

struct	function_traits_impl< ReturnType(ClassType::*)(Args...) const volatile && >

struct	function_traits_impl< ReturnType(ClassType::*)(Args...) const volatile >

struct	function_traits_impl< ReturnType(ClassType::*)(Args...) volatile & >

struct	function_traits_impl< ReturnType(ClassType::*)(Args...) volatile && >

struct	function_traits_impl< ReturnType(ClassType::*)(Args...) volatile >

struct	function_traits_impl< ReturnType(ClassType::*)(Args...)>

struct	function_traits_no_cv

struct	function_traits_no_cv< T, decltype((void)&T::operator())>

struct	invoker

struct	iter_invoker

struct	node_builder

struct	pair_base

struct	placement_new_tag_t

struct	range_iterator
	Iterate over an integer range (used to iterate over entity range). More...

struct	sig

struct	term_ptr

struct	term_ptrs

struct	to_constant

Typedefs
template<typename ... Components>
using	filter_builder_base = builder< filter, ecs_filter_desc_t, filter_builder< Components... >, filter_builder_i, Components ... >

template<typename ... Components>
using	observer_builder_base = node_builder< observer, ecs_observer_desc_t, observer_builder< Components... >, observer_builder_i, Components ... >

template<typename ... Components>
using	pipeline_builder_base = builder< pipeline, ecs_pipeline_desc_t, pipeline_builder< Components... >, pipeline_builder_i, Components ... >

template<typename ... Components>
using	query_builder_base = builder< query, ecs_query_desc_t, query_builder< Components... >, query_builder_i, Components ... >

template<typename ... Components>
using	rule_builder_base = builder< rule, ecs_filter_desc_t, rule_builder< Components... >, filter_builder_i, Components ... >

template<typename ... Components>
using	system_builder_base = node_builder< system, ecs_system_desc_t, system_builder< Components... >, system_builder_i, Components ... >

Functions
template<>
const char *	symbol_name< uint8_t > ()

template<>
const char *	symbol_name< uint16_t > ()

template<>
const char *	symbol_name< uint32_t > ()

template<>
const char *	symbol_name< uint64_t > ()

template<>
const char *	symbol_name< int8_t > ()

template<>
const char *	symbol_name< int16_t > ()

template<>
const char *	symbol_name< int32_t > ()

template<>
const char *	symbol_name< int64_t > ()

template<>
const char *	symbol_name< float > ()

template<>
const char *	symbol_name< double > ()

template<typename T , enable_if_t< std::is_trivial< T >::value==true > * = nullptr>
void	register_lifecycle_actions (ecs_world_t *, ecs_entity_t)

void	ecs_ctor_illegal (void , int32_t, const ecs_type_info_t ti)

void	ecs_dtor_illegal (void , int32_t, const ecs_type_info_t ti)

void	ecs_copy_illegal (void , const void , int32_t, const ecs_type_info_t *ti)

void	ecs_move_illegal (void , void , int32_t, const ecs_type_info_t *ti)

void	ecs_copy_ctor_illegal (void , const void , int32_t, const ecs_type_info_t *ti)

void	ecs_move_ctor_illegal (void , void , int32_t, const ecs_type_info_t *ti)

template<typename T >
void	ctor_impl (void ptr, int32_t count, const ecs_type_info_t info)

template<typename T >
void	dtor_impl (void ptr, int32_t count, const ecs_type_info_t info)

template<typename T >
void	copy_impl (void dst_ptr, const void src_ptr, int32_t count, const ecs_type_info_t *info)

template<typename T >
void	move_impl (void dst_ptr, void src_ptr, int32_t count, const ecs_type_info_t *info)

template<typename T >
void	copy_ctor_impl (void dst_ptr, const void src_ptr, int32_t count, const ecs_type_info_t *info)

template<typename T >
void	move_ctor_impl (void dst_ptr, void src_ptr, int32_t count, const ecs_type_info_t *info)

template<typename T >
void	ctor_move_dtor_impl (void dst_ptr, void src_ptr, int32_t count, const ecs_type_info_t *info)

template<typename T , if_not_t< std::is_trivially_move_assignable< T >::value > = 0>
void	move_dtor_impl (void dst_ptr, void src_ptr, int32_t count, const ecs_type_info_t *info)

template<typename T , if_t< std::is_trivially_constructible< T >::value > = 0>
ecs_xtor_t	ctor ()

template<typename T , if_t< std::is_trivially_destructible< T >::value > = 0>
ecs_xtor_t	dtor ()

template<typename T , if_t< std::is_trivially_copyable< T >::value > = 0>
ecs_copy_t	copy ()

template<typename T , if_t< std::is_trivially_move_assignable< T >::value > = 0>
ecs_move_t	move ()

template<typename T , if_t< std::is_trivially_copy_constructible< T >::value > = 0>
ecs_copy_t	copy_ctor ()

template<typename T , if_t< std::is_trivially_move_constructible< T >::value > = 0>
ecs_move_t	move_ctor ()

template<typename T , if_t< std::is_trivially_move_constructible< T >::value &&std::is_trivially_destructible< T >::value > = 0>
ecs_move_t	ctor_move_dtor ()

template<typename T , if_t< std::is_trivially_move_assignable< T >::value &&std::is_trivially_destructible< T >::value > = 0>
ecs_move_t	move_dtor ()

template<typename T >
ecs_entity_t	do_import (world &world, const char *symbol)

template<typename T >
flecs::entity	import (world &world)

void	system_init (flecs::world &world)

void	timer_init (flecs::world &world)

template<typename E >
constexpr size_t	enum_type_len ()

template<typename E , E C>
constexpr bool	enum_constant_is_valid ()
	Test if value is valid for enumeration.

template<class Ty >
void	destruct_obj (Ty *_ptr)

template<class Ty >
void	free_obj (Ty *_ptr)

Variables
constexpr placement_new_tag_t	placement_new_tag {}