Classes
struct	_templ

struct	_type

struct	_type< const T & >

struct	_type< dyndata::AbstractIter< T > >

struct	_type< T * >

class	AbstractClass

class	AbstractTuple

class	ActualParamType

class	BoolType

class	Class

class	CollectionIterator

class	Constructor0

class	Constructor1

class	Constructor2

class	CStringType

class	Declare

class	Enum

class	Enumerable

class	FloatType

struct	inst

class	InstanceClass

class	InstanceType

class	IntType

class	Iterator

class	IterIterator

class	make

class	Method0

class	Method0Const

class	Method1

class	Method1Const

class	Method2

class	Method2Const

struct	no_inst

class	Object

class	ObjectClass

class	Operation

class	Parameter

class	ParamType

class	PointerType

class	Serializable

class	Static0

class	Static1

class	Static2

class	StringType

class	TemplateClass

class	TemplateType

class	Tuple

class	Tuple1

class	Type

class	VoidType

Functions
Variant	__call_static0 (void(*f)(void))

template<class T >
Variant	__call_static0 (T(*f)(void))

template<class T1 >
Variant	__call_static1 (void(*f)(T1), T1 a1)

template<class T , class T1 >
Variant	__call_static1 (T(*f)(T1), T1 a1)

template<class T1 , class T2 >
Variant	__call_static2 (void(*f)(T1, T2), T1 a1, T2 a2)

template<class T , class T1 , class T2 >
Variant	__call_static2 (T(*f)(T1, T2), T1 a1, T2 a2)

template<class C >
Variant	__call_method0 (void(C::f)(void), C o)

template<class T , class C >
Variant	__call_method0 (T(C::f)(void), C o)

template<class C >
Variant	__call_method0_const (void(C::f)(void) const, const C o)

template<class T , class C >
Variant	__call_method0_const (T(C::f)(void) const, const C o)

template<class C , class T1 >
Variant	__call_method1 (void(C::f)(T1), C o, T1 a1)

template<class T , class C , class T1 >
Variant	__call_method1 (T(C::f)(T1), C o, T1 a1)

template<class C , class T1 >
Variant	__call_method1_const (void(C::f)(T1) const, const C o, T1 a1)

template<class T , class C , class T1 >
Variant	__call_method1_const (T(C::f)(T1) const, const C o, T1 a1)

template<class C , class T1 , class T2 >
Variant	__call_method2 (void(C::f)(T1, T2), C o, T1 a1, T2 a2)

template<class T , class C , class T1 , class T2 >
Variant	__call_method2 (T(C::f)(T1, T2), C o, T1 a1, T2 a2)

template<class C , class T1 , class T2 >
Variant	__call_method2_const (void(C::f)(T1, T2) const, const C o, T1 a1, T2 a2)

template<class T , class C , class T1 , class T2 >
Variant	__call_method2_const (T(C::f)(T1, T2) const, const C o, T1 a1, T2 a2)

rtti::Enum::Value	value (cstring name, int value)

template<class T , class A >
AbstractClass *	tuple1 (cstring name, A(T::*a)() const)

io::Output &	operator<< (io::Output &out, const Type &type)

Variables
const Type &	int8_type = single<IntType<t::int8> >()

const Type &	uint8_type = single<IntType<t::uint8> >()

const Type &	int16_type = single<IntType<t::int16> >()

const Type &	uint16_type = single<IntType<t::uint16> >()

const Type &	int32_type = single<IntType<t::int32> >()

const Type &	uint32_type = single<IntType<t::uint32> >()

const Type &	int64_type = single<IntType<t::int64> >()

const Type &	uint64_type = single<IntType<t::uint64> >()

const Type &	float_type = single<FloatType<float> >()

const Type &	double_type = single<FloatType<double> >()

const Type &	long_double_type = single<FloatType<long double> >()

const Type &	bool_type = single<BoolType>()

const Type &	string_type = single<StringType>()

const Type &	cstring_type = single<CStringType>()

const Type &	void_type = single<VoidType>()

static HashMap< string, const Type * >	type_map

static const ActualParamType	__param0 (0)

static const ActualParamType	__param1 (1)

static const ActualParamType	__param2 (2)

static const ActualParamType	__param3 (3)

Function Documentation

◆ __call_method0() [1/2]

Variant elm::rtti::__call_method0	(	T(C::*)(void)	f,
		C *	o
	)

inline

◆ __call_method0() [2/2]

Variant elm::rtti::__call_method0	(	void(C::*)(void)	f,
		C *	o
	)

inline

Referenced by Method0< T, C >::call().

◆ __call_method0_const() [1/2]

Variant elm::rtti::__call_method0_const	(	T(C::*)(void) const	f,
		const C *	o
	)

inline

◆ __call_method0_const() [2/2]

Variant elm::rtti::__call_method0_const	(	void(C::*)(void) const	f,
		const C *	o
	)

inline

Referenced by Method0Const< T, C >::call().

◆ __call_method1() [1/2]

Variant elm::rtti::__call_method1	(	T(C::*)(T1)	f,
		C *	o,
		T1	a1
	)

inline

◆ __call_method1() [2/2]

Variant elm::rtti::__call_method1	(	void(C::*)(T1)	f,
		C *	o,
		T1	a1
	)

inline

Referenced by Method1< T, C, T1 >::call().

◆ __call_method1_const() [1/2]

Variant elm::rtti::__call_method1_const	(	T(C::*)(T1) const	f,
		const C *	o,
		T1	a1
	)

inline

◆ __call_method1_const() [2/2]

Variant elm::rtti::__call_method1_const	(	void(C::*)(T1) const	f,
		const C *	o,
		T1	a1
	)

inline

Referenced by Method1Const< T, C, T1 >::call().

◆ __call_method2() [1/2]

Variant elm::rtti::__call_method2	(	T(C::*)(T1, T2)	f,
		C *	o,
		T1	a1,
		T2	a2
	)

inline

◆ __call_method2() [2/2]

Variant elm::rtti::__call_method2	(	void(C::*)(T1, T2)	f,
		C *	o,
		T1	a1,
		T2	a2
	)

inline

Referenced by Method2< T, C, T1, T2 >::call().

◆ __call_method2_const() [1/2]

Variant elm::rtti::__call_method2_const	(	T(C::*)(T1, T2) const	f,
		const C *	o,
		T1	a1,
		T2	a2
	)

inline

◆ __call_method2_const() [2/2]

Variant elm::rtti::__call_method2_const	(	void(C::*)(T1, T2) const	f,
		const C *	o,
		T1	a1,
		T2	a2
	)

inline

Referenced by Method2Const< T, C, T1, T2 >::call().

◆ __call_static0() [1/2]

Variant elm::rtti::__call_static0 ( T(*)(void) f )

inline

◆ __call_static0() [2/2]

Variant elm::rtti::__call_static0 ( void(*)(void) f )

inline

Referenced by Static0< T >::call().

◆ __call_static1() [1/2]

Variant elm::rtti::__call_static1	(	T(*)(T1)	f,
		T1	a1
	)

inline

◆ __call_static1() [2/2]

Variant elm::rtti::__call_static1	(	void(*)(T1)	f,
		T1	a1
	)

inline

Referenced by Static1< T, T1 >::call().

◆ __call_static2() [1/2]

Variant elm::rtti::__call_static2	(	T(*)(T1, T2)	f,
		T1	a1,
		T2	a2
	)

inline

◆ __call_static2() [2/2]

Variant elm::rtti::__call_static2	(	void(*)(T1, T2)	f,
		T1	a1,
		T2	a2
	)

inline

Referenced by Static2< T, T1, T2 >::call().

◆ operator<<()

io::Output & operator<<	(	io::Output &	out,
		const Type &	type
	)

Print the given type.

Parameters

out	Output stream.
type	Type to print.

References Type::asPtr(), Type::isPtr(), and Type::name().

◆ tuple1()

AbstractClass* elm::rtti::tuple1	(	cstring	name,
		A(T::*)() const	a
	)

◆ value()

rtti::Enum::Value elm::rtti::value	(	cstring	name,
		int	value
	)

inline

Referenced by Enum::nameFor().

Variable Documentation

◆ __param0

const ActualParamType __param0(0)

static

◆ __param1

const ActualParamType __param1(1)

◆ __param2

const ActualParamType __param2(2)

◆ __param3

const ActualParamType __param3(3)

◆ type_map

HashMap<string, const Type *> type_map

static

Map of available types.

Referenced by Type::get(), Type::initialize(), and Type::types().

Classes

Functions

Variables

Function Documentation

◆ __call_method0() [1/2]

◆ __call_method0() [2/2]

◆ __call_method0_const() [1/2]

◆ __call_method0_const() [2/2]

◆ __call_method1() [1/2]

◆ __call_method1() [2/2]

◆ __call_method1_const() [1/2]

◆ __call_method1_const() [2/2]

◆ __call_method2() [1/2]

◆ __call_method2() [2/2]

◆ __call_method2_const() [1/2]

◆ __call_method2_const() [2/2]

◆ __call_static0() [1/2]

◆ __call_static0() [2/2]

◆ __call_static1() [1/2]

◆ __call_static1() [2/2]

◆ __call_static2() [1/2]

◆ __call_static2() [2/2]

◆ operator<<()

◆ tuple1()

◆ value()

Variable Documentation

◆ __param0

◆ __param1

◆ __param2

◆ __param3

◆ type_map