typeInfo.hpp File Reference

Include dependency graph for typeInfo.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	checkStatic< T >
struct	checkStatic< T >::has_static_member_TYPENAME< typename, typename >
struct	checkStatic< T >::has_static_member_TYPENAME< testType, Ret(Args...)>
struct	checkStatic< T >::has_static_member_TYPENAME< testType, Ret(Args...)>::Check< U, U >

Namespaces
	pFlow

Macros
#define	has_static_member(name)
#define	QuadrupleTypeInfoNV(T)
#define	TripleTypeInfoNV(T)
#define	ClassInfo(tName)
#define	TypeInfo(tName)
#define	TypeInfoNV(tName)
#define	TypeInfoTemplate11(tName, Type)
#define	TypeInfoTemplate12(tName, Type1, Type2)
#define	TypeInfoTemplate13(tName, Type1, Type2, Type3)
#define	TypeInfoTemplateNV11(tName, Type)
#define	TypeInfoTemplateNV111(tName, Type, tName2)
#define	TypeInfoTemplate111(tName, Type, tName2)
#define	TypeInfoTemplate211(tBase, tName1, Type, tName3)
#define	TypeInfoTemplate22(tBase, tName1, Type1, Type2)

Functions
template<typename T >
word	basicTypeName ()
template<>
word	basicTypeName< word > ()
template<>
word	basicTypeName< int64 > ()
template<>
word	basicTypeName< int32 > ()
template<>
word	basicTypeName< int8 > ()
template<>
word	basicTypeName< uint64 > ()
template<>
word	basicTypeName< uint32 > ()
template<>
word	basicTypeName< uint8 > ()
template<>
word	basicTypeName< real > ()
template<typename T >
word	getTypeName ()
template<typename T >
word	getTypeName (const T &)
template<typename Type1 , typename Type2 >
bool	checkType (Type2 *object)
template<typename Type1 , typename Type2 >
bool	checkType (Type2 &object)

Macro Definition Documentation

has_static_member

#define has_static_member

(

name

)

Value:

    template <typename, typename>                                          \
    struct has_static_member_##name;                                       \
                                                                           \
    template <typename testType, typename Ret, typename... Args>           \
    struct has_static_member_##name<testType, Ret(Args...)>                \
    {                                                                      \
        template <typename U, U>                                           \
        struct Check;                                                      \
                                                                           \
        template <typename U>                                              \
        static std::true_type Test(Check<Ret (*)(Args...), &U::name> *);   \
        template <typename U>                                              \
        static std::false_type Test(...);                                  \
        static const bool      value = decltype(Test<testType>(0))::value; \
    };

Definition at line 29 of file typeInfo.hpp.

QuadrupleTypeInfoNV

#define QuadrupleTypeInfoNV

(

T

)

Value:

    inline static word TYPENAME()       \
    {                                   \
        return getTypeName<T>()+"x4";   \
    }                                   \
    word typeName() const               \
    {                                   \
        return TYPENAME();              \
    }

Definition at line 163 of file typeInfo.hpp.

TripleTypeInfoNV

#define TripleTypeInfoNV

(

T

)

Value:

    inline static word TYPENAME()       \
    {                                   \
        return getTypeName<T>()+"x3";   \
    }                                   \
    word typeName() const               \
    {                                   \
        return TYPENAME();              \
    }

Definition at line 173 of file typeInfo.hpp.

ClassInfo

#define ClassInfo

(

tName

)

Value:

    inline static word TYPENAME() \
    {                             \
        return tName;             \
    }

Definition at line 183 of file typeInfo.hpp.

TypeInfo

#define TypeInfo

(

tName

)

Value:

    inline static word TYPENAME() \
    {                             \
        return tName;             \
    }                             \
    virtual word typeName() const \
    {                             \
        return TYPENAME();        \
    }

Definition at line 189 of file typeInfo.hpp.

TypeInfoNV

#define TypeInfoNV

(

tName

)

Value:

    inline static word TYPENAME() \
    {                             \
        return tName;             \
    }                             \
    word typeName() const         \
    {                             \
        return TYPENAME();        \
    }

Definition at line 199 of file typeInfo.hpp.

TypeInfoTemplate11

#define TypeInfoTemplate11	(		tName,
			Type
	)

Value:

    inline static word TYPENAME()                             \
    {                                                         \
        return word(tName) + "<" + getTypeName<Type>() + ">"; \
    }                                                         \
    virtual word typeName() const                             \
    {                                                         \
        return TYPENAME();                                    \
    }

Definition at line 209 of file typeInfo.hpp.

TypeInfoTemplate12

#define TypeInfoTemplate12	(		tName,
			Type1,
			Type2
	)

Value:

    inline static word TYPENAME()                               \
    {                                                           \
        return word(tName) + "<" + getTypeName<Type1>() + "," + \
               getTypeName<Type2>() + ">";                      \
    }                                                           \
    virtual word typeName() const                               \
    {                                                           \
        return TYPENAME();                                      \
    }

Definition at line 219 of file typeInfo.hpp.

TypeInfoTemplate13

#define TypeInfoTemplate13	(		tName,
			Type1,
			Type2,
			Type3
	)

Value:

    inline static word TYPENAME()                                       \
    {                                                                   \
        return word(tName) + "<" + getTypeName<Type1>() + "," +         \
               getTypeName<Type2>() + "," + getTypeName<Type3>() + ">"; \
    }                                                                   \
    virtual word typeName() const                                       \
    {                                                                   \
        return TYPENAME();                                              \
    }

Definition at line 230 of file typeInfo.hpp.

TypeInfoTemplateNV11

#define TypeInfoTemplateNV11	(		tName,
			Type
	)

Value:

    inline static word TYPENAME()                             \
    {                                                         \
        return word(tName) + "<" + getTypeName<Type>() + ">"; \
    }                                                         \
    inline word typeName() const                              \
    {                                                         \
        return TYPENAME();                                    \
    }

Definition at line 242 of file typeInfo.hpp.

TypeInfoTemplateNV111

#define TypeInfoTemplateNV111	(		tName,
			Type,
			tName2
	)

Value:

    inline static word TYPENAME()                                             \
    {                                                                         \
        return word(tName) + "<" + getTypeName<Type>() + "," + word(tName2) + \
               ">";                                                           \
    }                                                                         \
    inline word typeName() const                                              \
    {                                                                         \
        return TYPENAME();                                                    \
    }

Definition at line 252 of file typeInfo.hpp.

TypeInfoTemplate111

#define TypeInfoTemplate111	(		tName,
			Type,
			tName2
	)

Value:

    inline static word TYPENAME()                                             \
    {                                                                         \
        return word(tName) + "<" + getTypeName<Type>() + "," + word(tName2) + \
               ">";                                                           \
    }                                                                         \
    virtual word typeName() const                                             \
    {                                                                         \
        return TYPENAME();                                                    \
    }

Definition at line 263 of file typeInfo.hpp.

TypeInfoTemplate211

#define TypeInfoTemplate211	(		tBase,
			tName1,
			Type,
			tName3
	)

Value:

    inline static word TYPENAME()                                             \
    {                                                                         \
        return word(tBase) + "<" + word(tName1) + "," + getTypeName<Type>() + \
               "," + word(tName3) + ">";                                      \
    }                                                                         \
    virtual word typeName() const                                             \
    {                                                                         \
        return TYPENAME();                                                    \
    }

Definition at line 274 of file typeInfo.hpp.

TypeInfoTemplate22

#define TypeInfoTemplate22	(		tBase,
			tName1,
			Type1,
			Type2
	)

Value:

    inline static word TYPENAME()                                              \
    {                                                                          \
        return word(tBase) + "<" + word(tName1) + "," + getTypeName<Type1>() + \
               "," + getTypeName<Type2>() + ">";                               \
    }                                                                          \
    virtual word typeName() const                                              \
    {                                                                          \
        return TYPENAME();                                                     \
    }

Definition at line 285 of file typeInfo.hpp.