typeinfo.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
#include <rttr/type>
#include <rttr/registration>
#include <utility/dllexport.h>
#include <string.h>
#include <utility/module.h>
 
namespace nap
{
    namespace rtti
    {
        using TypeInfo = rttr::type;
        using Enum = rttr::enumeration;
        using Property = rttr::property;
        using Variant = rttr::variant;
        using Instance = rttr::instance;
        using VariantArray = rttr::variant_array_view;
        using VariantMap = rttr::variant_associative_view;
 
        namespace method
        {
            constexpr const char* description = "description";                  
            constexpr const char* moduleDescription = "moduleDescription";      
            constexpr const char* assign = "assign";                            
            constexpr const char* toObject = "toObject";                        
            constexpr const char* toString  = "toString";                       
            constexpr const char* translateTargetID = "translateTargetID";      
        }
 
        enum class EPropertyMetaData : uint8_t
        {
            Default     = 0,        
            Required    = 1,        
            FileLink    = 2,        
            Embedded    = 4,        
            ReadOnly    = 8         
        };
 
        enum class EPropertyFileType : uint8_t
        {
            Any             = 0,    
            Image           = 1,    
            FragShader      = 2,    
            VertShader      = 3,    
            ComputeShader   = 4,    
            Mesh            = 6,    
            Video           = 7,    
            ImageSequence   = 8,    
            Audio           = 9,    
            Font            = 10    
        };
 
        inline EPropertyMetaData operator&(EPropertyMetaData a, EPropertyMetaData b)
        {
            return static_cast<EPropertyMetaData>(static_cast<uint8_t>(a) & static_cast<uint8_t>(b));
        }
 
        inline EPropertyMetaData operator|(EPropertyMetaData a, EPropertyMetaData b)
        {
            return static_cast<EPropertyMetaData>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
        }
 
        inline bool isPrimitive(const rtti::TypeInfo& type)
        {
            return type.is_arithmetic() || type.is_enumeration() || type == rtti::TypeInfo::get<std::string>();
        }
 
        inline bool hasFlag(const rtti::Property& property, EPropertyMetaData flags)
        {
            const rtti::Variant& meta_data = property.get_metadata("flags");
            if (!meta_data.is_valid())
                return false;
 
            uint8_t current_flags = meta_data.convert<uint8_t>();
            return (current_flags & (uint8_t)flags) != 0;
        }
 
        inline bool isFileType(const rtti::Property &property, EPropertyFileType filetype)
        {
            const rtti::Variant& meta_data = property.get_metadata("filetype");
            return meta_data.is_valid() ?
                meta_data.convert<uint8_t>() == (uint8_t)filetype : false;
        }
 
        enum class ETypeCheck : uint8_t
        {
            EXACT_MATCH,                
            IS_DERIVED_FROM             
        };
 
        inline bool isTypeMatch(const rtti::TypeInfo& typeA, const rtti::TypeInfo& typeB, ETypeCheck typeCheck)
        {
            return typeCheck == ETypeCheck::EXACT_MATCH ? typeA == typeB : typeA.is_derived_from(typeB);
        }
 
        inline rttr::method findMethodRecursive(const rtti::TypeInfo& type, const std::string& methodName)
        {
            for (const rtti::TypeInfo& base : type.get_base_classes())
            {
                auto result = base.get_method(methodName);
                if (result.is_valid())
                    return result;
            }
            return type.get_method(methodName);
        }
    }
}
 
 
// RTTI Macros
 
#define RTTI_OF(Type) nap::rtti::TypeInfo::get<Type>()
 
 
 // RTTI_ENABLE
 
#define RTTI_ENABLE(...)                                                                                        \
    RTTR_ENABLE(__VA_ARGS__)                                                                                    \
    RTTR_REGISTRATION_FRIEND
 
 
// RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR
 
#define CONCAT_UNIQUE_NAMESPACE(x, y)               namespace x##y
#define UNIQUE_REGISTRATION_NAMESPACE(id)           CONCAT_UNIQUE_NAMESPACE(__rtti_registration_, id)
 
#define RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR_1(Type)                                                     \
UNIQUE_REGISTRATION_NAMESPACE(__COUNTER__)                                                                  \
{                                                                                                           \
    static nap::ModuleDescriptor* getModuleDescriptor() { return NAP_MODULE_DESCIPTOR_HANDLE; }             \
    RTTR_REGISTRATION                                                                                       \
    {                                                                                                       \
        using namespace rttr;                                                                               \
        std::string rtti_class_type_name = #Type;                                                           \
        registration::class_<Type> rtti_class_type(#Type);                                                  \
        rtti_class_type.method(nap::rtti::method::moduleDescription, &getModuleDescriptor);
 
 
#define RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR_2(Type, Description)                                            \
    UNIQUE_REGISTRATION_NAMESPACE(__COUNTER__)                                                                  \
    {                                                                                                           \
        static const char* getTypeDescription()             { return Description; }                             \
        static nap::ModuleDescriptor* getModuleDescriptor() { return NAP_MODULE_DESCIPTOR_HANDLE; }             \
        RTTR_REGISTRATION                                                                                       \
        {                                                                                                       \
            using namespace rttr;                                                                               \
            std::string rtti_class_type_name = #Type;                                                           \
            registration::class_<Type> rtti_class_type(#Type);                                                  \
            rtti_class_type.method(nap::rtti::method::description, &getTypeDescription);                        \
            rtti_class_type.method(nap::rtti::method::moduleDescription, &getModuleDescriptor);                 
 
// Selector
#define GET_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR_MACRO(_1,_2,NAME,...) NAME
 
#define RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR(...) GET_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR_MACRO(__VA_ARGS__, RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR_2, RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR_1)(__VA_ARGS__)
 
 
// RTTI_PROPERTY
 
#define RTTI_PROPERTY_3(Name, Member, Flags)                                                                \
        rtti_class_type.property(Name, Member)( metadata("flags", (uint8_t)(Flags)));
 
#define RTTI_PROPERTY_4(Name, Member, Flags, Description)                                                   \
            rtti_class_type.property(Name, Member)(                                                         \
                                metadata("flags", (uint8_t)(Flags)),                                        \
                                metadata("description", (const char*)(Description)));
 
#define GET_PROPERTY_MACRO(_1,_2,_3,_4,NAME,...) NAME
 
#define RTTI_PROPERTY(...) GET_PROPERTY_MACRO(__VA_ARGS__, RTTI_PROPERTY_4, RTTI_PROPERTY_3)(__VA_ARGS__)
 
 
// RTTI_PROPERTY_FILELINK
 
#define RTTI_PROPERTY_FILELINK_4(Name, Member, Flags, FileType)                                                 \
            rtti_class_type.property(Name, Member)(                                                             \
                                metadata("flags", (uint8_t)(nap::rtti::EPropertyMetaData::FileLink | Flags)),   \
                                metadata("filetype", (uint8_t)(FileType)));
 
#define RTTI_PROPERTY_FILELINK_5(Name, Member, Flags, FileType, Description)                                    \
            rtti_class_type.property(Name, Member)(                                                             \
                                metadata("flags", (uint8_t)(nap::rtti::EPropertyMetaData::FileLink | Flags)),   \
                                metadata("filetype", (uint8_t)(FileType)),                                      \
                                metadata("description", (const char*)(Description)));                           
 
#define GET_PROPERTY_FILELINK_MACRO(_1,_2,_3,_4,_5,NAME,...) NAME
 
#define RTTI_PROPERTY_FILELINK(...) GET_PROPERTY_FILELINK_MACRO(__VA_ARGS__, RTTI_PROPERTY_FILELINK_5, RTTI_PROPERTY_FILELINK_4)(__VA_ARGS__)
 
 
// RTTI_FUNCTION
 
#define RTTI_FUNCTION(Name, Member)                                                                             \
            rtti_class_type.method(Name, Member);
 
#define RTTI_CUSTOM_REGISTRATION_FUNCTION(Func)
 
 
// RTTI_CONSTRUCTOR
 
#define RTTI_CONSTRUCTOR(...)                                                                               \
        rtti_class_type.constructor<__VA_ARGS__>()(policy::ctor::as_raw_ptr);
 
 
 // RTTI_VALUE_CONSTRUCTOR
 
#define RTTI_VALUE_CONSTRUCTOR(...)                                                                             \
            rtti_class_type.constructor<__VA_ARGS__>()(policy::ctor::as_object);
 
 
// RTTI_END_CLASS
 
#define RTTI_END_CLASS                                                                                          \
        }                                                                                                       \
    }
 
 
// RTTI_BEGIN_STRUCT_NO_DEFAULT_CONSTRUCTOR
 
#define RTTI_BEGIN_STRUCT_NO_DEFAULT_CONSTRUCTOR_1(Type)                                                        \
    RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR(Type)
 
#define RTTI_BEGIN_STRUCT_NO_DEFAULT_CONSTRUCTOR_2(Type, Description)                                           \
    RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR(Type, Description)
 
#define GET_RTTI_BEGIN_STRUCT_NO_DEFAULT_CONSTRUCTOR_MACRO(_1,_2,NAME,...) NAME
 
#define RTTI_BEGIN_STRUCT_NO_DEFAULT_CONSTRUCTOR(...) GET_RTTI_BEGIN_STRUCT_NO_DEFAULT_CONSTRUCTOR_MACRO(__VA_ARGS__, RTTI_BEGIN_STRUCT_NO_DEFAULT_CONSTRUCTOR_2, RTTI_BEGIN_STRUCT_NO_DEFAULT_CONSTRUCTOR_1)(__VA_ARGS__)
 
 
 // RTTI_END_STRUCT
 
#define RTTI_END_STRUCT                                                                                         \
    RTTI_END_CLASS
 
 
 // RTTI_BEGIN_CLASS
 
#define RTTI_BEGIN_CLASS_1(Type)                                                                                    \
    RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR(Type)                                                                   \
    RTTI_CONSTRUCTOR()
 
#define RTTI_BEGIN_CLASS_2(Type, Description)                                                                       \
    RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR(Type, Description)                                                      \
    RTTI_CONSTRUCTOR()
 
#define GET_RTTI_BEGIN_CLASS_MACRO(_1,_2,NAME,...) NAME
 
#define RTTI_BEGIN_CLASS(...) GET_RTTI_BEGIN_CLASS_MACRO(__VA_ARGS__, RTTI_BEGIN_CLASS_2, RTTI_BEGIN_CLASS_1)(__VA_ARGS__)
 
 
// RTTI_BEGIN_STRUCT
 
#define RTTI_BEGIN_STRUCT_1(Type)                                                                                   \
    RTTI_BEGIN_STRUCT_NO_DEFAULT_CONSTRUCTOR(Type)                                                                  \
    RTTI_VALUE_CONSTRUCTOR()
 
#define RTTI_BEGIN_STRUCT_2(Type, Description)                                                                      \
    RTTI_BEGIN_STRUCT_NO_DEFAULT_CONSTRUCTOR(Type, Description)                                                     \
    RTTI_VALUE_CONSTRUCTOR()
 
#define GET_RTTI_BEGIN_STRUCT_MACRO(_1,_2,NAME,...) NAME
 
#define RTTI_BEGIN_STRUCT(...) GET_RTTI_BEGIN_STRUCT_MACRO(__VA_ARGS__, RTTI_BEGIN_STRUCT_2, RTTI_BEGIN_STRUCT_1)(__VA_ARGS__)
 
 
 // RTTI_BEGIN_ENUM
 
#define RTTI_BEGIN_ENUM(Type)                                                                                   \
    UNIQUE_REGISTRATION_NAMESPACE(__COUNTER__)                                                                  \
    {                                                                                                           \
        RTTR_REGISTRATION                                                                                       \
        {                                                                                                       \
            using namespace rttr;                                                                               \
            registration::enumeration<Type>(#Type)                                                              \
            (
 
#define RTTI_ENUM_VALUE(Value, String)                                                                          \
                value(String, Value)
 
#define RTTI_END_ENUM                                                                                           \
            );                                                                                                  \
        }                                                                                                       \
    }
 
 
// RTTI_DEFINE_BASE
 
#define RTTI_DEFINE_BASE_1(Type)                                                                                \
    RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR(Type)                                                               \
    RTTI_END_CLASS
 
#define RTTI_DEFINE_BASE_2(Type, Description)                                                                   \
    RTTI_BEGIN_CLASS_NO_DEFAULT_CONSTRUCTOR(Type, Description)                                                  \
    RTTI_END_CLASS
 
#define GET_RTTI_DEFINE_BASE_MACRO(_1,_2,NAME,...) NAME
 
#define RTTI_DEFINE_BASE(...) GET_RTTI_DEFINE_BASE_MACRO(__VA_ARGS__, RTTI_DEFINE_BASE_2, RTTI_DEFINE_BASE_1)(__VA_ARGS__)
 
 
// RTTI_DEFINE_CLASS
 
#define RTTI_DEFINE_CLASS_1(Type)                                                                               \
    RTTI_BEGIN_CLASS(Type)                                                                                      \
    RTTI_END_CLASS
 
#define RTTI_DEFINE_CLASS_2(Type, Description)                                                                  \
    RTTI_BEGIN_CLASS(Type, Description)                                                                         \
    RTTI_END_CLASS
 
#define GET_RTTI_DEFINE_CLASS_MACRO(_1,_2,NAME,...) NAME
 
#define RTTI_DEFINE_CLASS(...) GET_RTTI_DEFINE_CLASS_MACRO(__VA_ARGS__, RTTI_DEFINE_CLASS_2, RTTI_DEFINE_CLASS_1)(__VA_ARGS__)
 
 
// RTTI_DEFINE_STRUCT
 
#define RTTI_DEFINE_STRUCT_1(Type)                                                                              \
    RTTI_BEGIN_STRUCT(Type)                                                                                     \
    RTTI_END_STRUCT
 
#define RTTI_DEFINE_STRUCT_2(Type, Description)                                                                 \
    RTTI_BEGIN_STRUCT(Type, Description)                                                                        \
    RTTI_END_STRUCT
 
#define GET_RTTI_DEFINE_STRUCT_MACRO(_1,_2,NAME,...) NAME
 
#define RTTI_DEFINE_STRUCT(...) GET_RTTI_DEFINE_STRUCT_MACRO(__VA_ARGS__, RTTI_DEFINE_STRUCT_2, RTTI_DEFINE_STRUCT_1)(__VA_ARGS__)