DynamicRTTI.h

#pragma once
 
 
#include <Foundation/Reflection/Implementation/StaticRTTI.h>
 
#define PL_ADD_DYNAMIC_REFLECTION_NO_GETTER(SELF, BASE_TYPE) \
  PL_ALLOW_PRIVATE_PROPERTIES(SELF);                         \
                                                             \
public:                                                      \
  using OWNTYPE = SELF;                                      \
  using SUPER = BASE_TYPE;                                   \
  PL_ALWAYS_INLINE static const plRTTI* GetStaticRTTI()      \
  {                                                          \
    return &SELF::s_RTTI;                                    \
  }                                                          \
                                                             \
private:                                                     \
  static plRTTI s_RTTI;                                      \
  PL_REFLECTION_DEBUG_CODE
 
 
#define PL_ADD_DYNAMIC_REFLECTION(SELF, BASE_TYPE)      \
  PL_ADD_DYNAMIC_REFLECTION_NO_GETTER(SELF, BASE_TYPE)  \
public:                                                 \
  virtual const plRTTI* GetDynamicRTTI() const override \
  {                                                     \
    return &SELF::s_RTTI;                               \
  }
 
 
#if PL_ENABLED(PL_COMPILE_FOR_DEVELOPMENT) && PL_ENABLED(PL_COMPILER_MSVC)
 
#  define PL_REFLECTION_DEBUG_CODE                       \
    static const plRTTI* ReflectionDebug_GetParentType() \
    {                                                    \
      return __super::GetStaticRTTI();                   \
    }
 
#  define PL_REFLECTION_DEBUG_GETPARENTFUNC &OwnType::ReflectionDebug_GetParentType
 
#else
#  define PL_REFLECTION_DEBUG_CODE /*empty*/
#  define PL_REFLECTION_DEBUG_GETPARENTFUNC nullptr
#endif
 
 
#define PL_BEGIN_DYNAMIC_REFLECTED_TYPE(Type, Version, AllocatorType) \
  PL_RTTIINFO_DECL(Type, Type::SUPER, Version)                        \
  plRTTI Type::s_RTTI = GetRTTI((Type*)0);                            \
  PL_RTTIINFO_GETRTTI_IMPL_BEGIN(Type, Type::SUPER, AllocatorType)
 
#define PL_END_DYNAMIC_REFLECTED_TYPE                                                                                                \
  return plRTTI(GetTypeName((OwnType*)0), plGetStaticRTTI<OwnBaseType>(), sizeof(OwnType), GetTypeVersion((OwnType*)0),              \
    plVariant::TypeDeduction<OwnType>::value, flags, &Allocator, Properties, Functions, Attributes, MessageHandlers, MessageSenders, \
    PL_REFLECTION_DEBUG_GETPARENTFUNC);                                                                                              \
  }
 
#define PL_BEGIN_ABSTRACT_DYNAMIC_REFLECTED_TYPE(Type, Version)     \
  PL_BEGIN_DYNAMIC_REFLECTED_TYPE(Type, Version, plRTTINoAllocator) \
    flags.Add(plTypeFlags::Abstract);
 
#define PL_END_ABSTRACT_DYNAMIC_REFLECTED_TYPE PL_END_DYNAMIC_REFLECTED_TYPE
 
class PL_FOUNDATION_DLL plReflectedClass : public plNoBase
{
  PL_ADD_DYNAMIC_REFLECTION_NO_GETTER(plReflectedClass, plNoBase);
 
public:
  virtual const plRTTI* GetDynamicRTTI() const { return &plReflectedClass::s_RTTI; }
 
public:
  PL_ALWAYS_INLINE plReflectedClass() = default;
  PL_ALWAYS_INLINE virtual ~plReflectedClass() = default;
 
  bool IsInstanceOf(const plRTTI* pType) const;
 
  template <typename T>
  PL_ALWAYS_INLINE bool IsInstanceOf() const
  {
    const plRTTI* pType = plGetStaticRTTI<T>();
    return IsInstanceOf(pType);
  }
};