reflection.h

 
#ifndef _Reflection_h_
#define _Reflection_h_
 
#include <memory>
#include <typeinfo>
#include <mutex>
#include <type_traits>
 
#include <system/details/demangle.h>
#include "system/reflection_seprt.h"
 
namespace System
{
 
 
template <typename T>
T& static_holder()
{
    static T value;
    return value;
}
 
class TypeInfo;
 
template <typename ...BaseTypes> class BaseTypesInfo;
 
 
template <typename ...AllTypes> struct AnyTypesMatch;
 
template <typename FirstType, typename SecondType, typename ...OtherTypes>
struct AnyTypesMatch<FirstType, SecondType, OtherTypes...>
{
    static constexpr bool value =
        std::is_same<FirstType, SecondType>::value ||
        AnyTypesMatch<FirstType, OtherTypes...>::value ||
        AnyTypesMatch<SecondType, OtherTypes...>::value;
};
 
template <typename LastType>
struct AnyTypesMatch<LastType>
{
    static constexpr bool value = false;
};
 
 
template <typename FirstType, typename ...BaseTypes>
class BaseTypesInfo<FirstType, BaseTypes...>
{
    static_assert(!AnyTypesMatch<FirstType, BaseTypes...>::value, "Two or more of the direct basic types match");
public:
    typedef FirstType Type;
    template <typename T>
    inline static bool CallIsForAll(T *object, const TypeInfo &typeInfo)
    {
        return object->FirstType::Is(typeInfo) || BaseTypesInfo<BaseTypes...>::CallIsForAll(object, typeInfo);
    }
};
 
template <>
class BaseTypesInfo<>
{
public:
    template <typename T>
    inline static bool CallIsForAll(T*, const TypeInfo&)
    {
        return false;
    }
};
 
 
}
 
 
//-------------------------------------------------------
// definition of RTTI methonds inside a class declaration
 
#define __ThisTypeInfo_Compiletime(thisType, hash) \
        struct ThisTypeInfo : System::TypeInfoPtr { \
            ThisTypeInfo() : System::TypeInfoPtr(ASPOSE_T(#thisType), hash) {
 
#define __ThisTypeInfo_Compiletime_Named(thisType, name, hash) \
        struct ThisTypeInfo : System::TypeInfoPtr { \
            ThisTypeInfo() : System::TypeInfoPtr(ASPOSE_T(name), hash) {
 
#define __ThisTypeInfo_Compiletime_Named_Declare_Exported(method_api, thisType, name, hash) \
        struct ThisTypeInfo : System::TypeInfoPtr { \
            method_api ThisTypeInfo();
 
#define __ThisTypeInfo_Runtime(thisType) \
        struct ThisTypeInfo : System::TypeInfoPtr { \
            ThisTypeInfo() : System::TypeInfoPtr(typeid(thisType)) {
 
#define __RTTI_INFO_METHODS(thisType, baseTypes) \
    public: \
 \
 \
        static const System::TypeInfo& Type() { \
            return *System::static_holder<ThisTypeInfo>(); \
        } \
 \
        const System::TypeInfo& GetType() const override { \
            return thisType::Type(); \
        } \
 \
 \
 \
        bool Is(const System::TypeInfo &target) const override { \
            const System::TypeInfo& thisis = thisType::Type(); \
            return (thisis == target) ? true : baseTypes::CallIsForAll(this, target); \
        } \
    private:
 
#define __RTTI_INFO_METHODS_EXPORTED(method_api, thisType, baseTypes) \
    public: \
 \
 \
        static method_api const System::TypeInfo& Type(); \
 \
        method_api const System::TypeInfo& GetType() const override; \
 \
 \
 \
        method_api bool Is(const System::TypeInfo &target) const override; \
    private:
 
#define __RTTI_INFO_METHODS_BOXED(thisType, baseTypes) \
    public: \
        static const System::TypeInfo& Type() { \
            return *System::static_holder<ThisTypeInfo>(); \
        } \
        bool Is(const System::TypeInfo &target) const override { \
            const System::TypeInfo& thisis = thisType::GetType(); \
            return (thisis == target) ? true : baseTypes::CallIsForAll(this, target); \
        } \
    private:
 
 
#define RTTI_INFO_END() } };
 
 
// for class without attributes
 
// baseTypes: (TypeA)(TypeB)(TypeC)
 
#define RTTI_INFO(thisType, baseTypes) \
    __RTTI_INFO_METHODS(thisType, baseTypes) \
    __ThisTypeInfo_Compiletime(thisType, 0) \
    RTTI_INFO_END()
 
#define RTTI_INFO_NAMED(thisType, name, baseTypes) \
    __RTTI_INFO_METHODS(thisType, baseTypes) \
    __ThisTypeInfo_Compiletime_Named(thisType, name, 0) \
    RTTI_INFO_END()
 
#define RTTI_INFO_NAMED_DECLARE_EXPORTED(method_api, thisType, name, baseTypes) \
    __RTTI_INFO_METHODS_EXPORTED(method_api, thisType, baseTypes) \
    __ThisTypeInfo_Compiletime_Named_Declare_Exported(method_api, thisType, name, 0) \
    };
 
// baseTypes: (TypeA)(TypeB)(TypeC)
#define RTTI_INFO_HASH(hash, thisType, baseTypes) \
    __RTTI_INFO_METHODS(thisType, baseTypes) \
    __ThisTypeInfo_Compiletime(thisType, hash) \
    RTTI_INFO_END()
 
#define __ThisTypeInfo_SetBaseType(baseTypes) \
    ptr->SetBaseType(&baseTypes::Type::Type);
 
#define __ThisTypeInfo_SetTemplParamType(templParamType) \
    ptr->SetTemplParamType(System::ObjectExt::GetType<templParamType>());
 
#define __ThisTypeInfo_SetDefaultConstructor(elementType) \
    ptr->AddDefaultConstructor<elementType>();
 
 
#define RTTI_INFO_TEMPLATE_CLASS_REFL(thisType, baseTypes, templParamType) \
    __RTTI_INFO_METHODS(thisType, baseTypes) \
    __ThisTypeInfo_Runtime(thisType) \
    __ThisTypeInfo_SetBaseType(baseTypes) \
    __ThisTypeInfo_SetDefaultConstructor(thisType) \
    __ThisTypeInfo_SetTemplParamType(templParamType) \
    RTTI_INFO_END()
 
 
// baseTypes: (TypeA)(TypeB)(TypeC)
#define RTTI_INFO_TEMPLATE_CLASS(thisType, baseTypes) \
    __RTTI_INFO_METHODS(thisType, baseTypes) \
    __ThisTypeInfo_Runtime(thisType) \
    __ThisTypeInfo_SetBaseType(baseTypes) \
    RTTI_INFO_END()
 
// baseTypes: (TypeA)(TypeB)(TypeC)
#define RTTI_INFO_CUSTOM(thisType, baseTypes) \
    __RTTI_INFO_METHODS(thisType, baseTypes)
 
 
// baseTypes: (TypeA)(TypeB)(TypeC)
#define RTTI_INFO_BOXED_CUSTOM(thisType, baseTypes) \
    __RTTI_INFO_METHODS_BOXED(thisType, baseTypes)
 
#define RTTI_INFO_BOXED(thisType, baseTypes) \
    __RTTI_INFO_METHODS_BOXED(thisType, baseTypes) \
    __ThisTypeInfo_Runtime(thisType) \
    __ThisTypeInfo_SetBaseType(baseTypes) \
    RTTI_INFO_END()
 
 
// for class with attributes
 
// baseTypes: (TypeA)(TypeB)(TypeC)
#define RTTI_INFO_BEGIN(thisType, baseTypes) \
    __RTTI_INFO_METHODS(thisType, baseTypes) \
    __ThisTypeInfo_Compiletime(thisType, 0)
 
// baseTypes: (TypeA)(TypeB)(TypeC)
#define RTTI_INFO_HASH_BEGIN(hash, thisType, baseTypes) \
    __RTTI_INFO_METHODS(hash, thisType, baseTypes)
 
#define RTTI_ATTRIBUTE(type, params) \
    ptr->AddAttribute( System::static_pointer_cast<System::Object>( System::MakeObject<type> (params) ) );
 
// for value types
#define RTTI_INFO_VALUE_TYPE(thisType) \
    public: \
        static const System::TypeInfo& Type() { \
            return *System::static_holder<ThisTypeInfo>(); \
        } \
        const System::TypeInfo& GetType() const { \
            return thisType::Type(); \
        } \
    private:\
    __ThisTypeInfo_Compiletime(thisType, 0) \
    ptr->SetBaseType(&System::Object::Type); \
    RTTI_INFO_END()
 
#endif // _Reflection_h_