![]() |
Elm
2
ELM is a library providing generic data structures, OS-independent interface, plugins and XML.
|
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) |
Referenced by Method0< T, C >::call().
Referenced by Method0Const< T, C >::call().
|
inline |
Referenced by Method1< T, C, T1 >::call().
|
inline |
Referenced by Method1Const< T, C, T1 >::call().
|
inline |
Referenced by Method2< T, C, T1, T2 >::call().
|
inline |
|
inline |
Referenced by Method2Const< T, C, T1, T2 >::call().
Referenced by Static0< T >::call().
|
inline |
Referenced by Static1< T, T1 >::call().
|
inline |
Referenced by Static2< T, T1, T2 >::call().
io::Output & operator<< | ( | io::Output & | out, |
const Type & | type | ||
) |
Print the given type.
out | Output stream. |
type | Type to print. |
References Type::asPtr(), Type::isPtr(), and Type::name().
AbstractClass* elm::rtti::tuple1 | ( | cstring | name, |
A(T::*)() const | a | ||
) |
|
inline |
Referenced by Enum::nameFor().
|
static |
const ActualParamType __param1(1) |
const ActualParamType __param2(2) |
const ActualParamType __param3(3) |
Map of available types.
Referenced by Type::get(), Type::initialize(), and Type::types().