RTTI.h

#pragma once
 
 
#include <Foundation/Basics.h>
#include <Foundation/Configuration/Plugin.h>
#include <Foundation/Memory/Allocator.h>
#include <Foundation/Reflection/Implementation/StaticRTTI.h>
 
// *****************************************
// ***** Runtime Type Information Data *****
 
struct plRTTIAllocator;
class plAbstractProperty;
class plAbstractFunctionProperty;
class plAbstractMessageHandler;
struct plMessageSenderInfo;
class plPropertyAttribute;
class plMessage;
using plMessageId = plUInt16;
 
class PL_FOUNDATION_DLL plRTTI
{
public:
  plRTTI(plStringView sName, const plRTTI* pParentType, plUInt32 uiTypeSize, plUInt32 uiTypeVersion, plUInt8 uiVariantType,
    plBitflags<plTypeFlags> flags, plRTTIAllocator* pAllocator, plArrayPtr<const plAbstractProperty*> properties, plArrayPtr<const plAbstractFunctionProperty*> functions,
    plArrayPtr<const plPropertyAttribute*> attributes, plArrayPtr<plAbstractMessageHandler*> messageHandlers,
    plArrayPtr<plMessageSenderInfo> messageSenders, const plRTTI* (*fnVerifyParent)());
 
 
  ~plRTTI();
 
  void VerifyCorrectness() const;
 
  static void VerifyCorrectnessForAllTypes();
 
  PL_ALWAYS_INLINE plStringView GetTypeName() const { return m_sTypeName; } // [tested]
 
  PL_ALWAYS_INLINE plUInt64 GetTypeNameHash() const { return m_uiTypeNameHash; } // [tested]
 
  PL_ALWAYS_INLINE const plRTTI* GetParentType() const { return m_pParentType; } // [tested]
 
  PL_ALWAYS_INLINE plVariantType::Enum GetVariantType() const { return static_cast<plVariantType::Enum>(m_uiVariantType); }
 
  PL_ALWAYS_INLINE bool IsDerivedFrom(const plRTTI* pBaseType) const // [tested]
  {
    const plUInt32 thisGeneration = m_ParentHierarchy.GetCount();
    const plUInt32 baseGeneration = pBaseType->m_ParentHierarchy.GetCount();
    PL_ASSERT_DEBUG(thisGeneration > 0 && baseGeneration > 0, "SetupParentHierarchy() has not been called");
    return thisGeneration >= baseGeneration && m_ParentHierarchy.GetData()[thisGeneration - baseGeneration] == pBaseType;
  }
 
  template <typename BASE>
  PL_ALWAYS_INLINE bool IsDerivedFrom() const // [tested]
  {
    return IsDerivedFrom(plGetStaticRTTI<BASE>());
  }
 
  PL_ALWAYS_INLINE plRTTIAllocator* GetAllocator() const { return m_pAllocator; } // [tested]
 
  PL_ALWAYS_INLINE plArrayPtr<const plAbstractProperty* const> GetProperties() const { return m_Properties; } // [tested]
 
  PL_ALWAYS_INLINE plArrayPtr<const plAbstractFunctionProperty* const> GetFunctions() const { return m_Functions; }
 
  PL_ALWAYS_INLINE plArrayPtr<const plPropertyAttribute* const> GetAttributes() const { return m_Attributes; }
 
  template <typename Type>
  const Type* GetAttributeByType() const;
 
  void GetAllProperties(plDynamicArray<const plAbstractProperty*>& out_properties) const; // [tested]
 
  PL_ALWAYS_INLINE plUInt32 GetTypeSize() const { return m_uiTypeSize; } // [tested]
 
  PL_ALWAYS_INLINE plUInt32 GetTypeVersion() const { return m_uiTypeVersion; }
 
  PL_ALWAYS_INLINE const plBitflags<plTypeFlags>& GetTypeFlags() const { return m_TypeFlags; } // [tested]
 
  static const plRTTI* FindTypeByName(plStringView sName); // [tested]
 
  static const plRTTI* FindTypeByNameHash(plUInt64 uiNameHash); // [tested]
  static const plRTTI* FindTypeByNameHash32(plUInt32 uiNameHash);
 
  using PredicateFunc = plDelegate<bool(const plRTTI*), 48>;
  static const plRTTI* FindTypeIf(PredicateFunc func);
 
  const plAbstractProperty* FindPropertyByName(plStringView sName, bool bSearchBaseTypes = true) const; // [tested]
 
  PL_ALWAYS_INLINE plStringView GetPluginName() const { return m_sPluginName; } // [tested]
 
  PL_ALWAYS_INLINE const plArrayPtr<plAbstractMessageHandler*>& GetMessageHandlers() const { return m_MessageHandlers; }
 
  bool DispatchMessage(void* pInstance, plMessage& ref_msg) const;
 
  bool DispatchMessage(const void* pInstance, plMessage& ref_msg) const;
 
  template <typename MessageType>
  PL_ALWAYS_INLINE bool CanHandleMessage() const
  {
    return CanHandleMessage(MessageType::GetTypeMsgId());
  }
 
  inline bool CanHandleMessage(plMessageId id) const
  {
    PL_ASSERT_DEBUG(m_uiMsgIdOffset != plSmallInvalidIndex, "Message handler table should have been gathered at this point.\n"
                                                            "If this assert is triggered for a type loaded from a dynamic plugin,\n"
                                                            "you may have forgotten to instantiate an plPlugin object inside your plugin DLL.");
 
    const plUInt32 uiIndex = id - m_uiMsgIdOffset;
    return uiIndex < m_DynamicMessageHandlers.GetCount() && m_DynamicMessageHandlers.GetData()[uiIndex] != nullptr;
  }
 
  PL_ALWAYS_INLINE const plArrayPtr<plMessageSenderInfo>& GetMessageSender() const { return m_MessageSenders; }
 
  struct ForEachOptions
  {
    using StorageType = plUInt8;
 
    enum Enum
    {
      None = 0,
      ExcludeNonAllocatable = PL_BIT(0), 
      ExcludeAbstract = PL_BIT(1),       
      ExcludeNotConcrete = ExcludeNonAllocatable | ExcludeAbstract,
 
      Default = None
    };
 
    struct Bits
    {
      plUInt8 ExcludeNonAllocatable : 1;
      plUInt8 ExcludeAbstract : 1;
    };
  };
 
  using VisitorFunc = plDelegate<void(const plRTTI*), 48>;
  static void ForEachType(VisitorFunc func, plBitflags<ForEachOptions> options = ForEachOptions::Default); // [tested]
 
  static void ForEachDerivedType(const plRTTI* pBaseType, VisitorFunc func, plBitflags<ForEachOptions> options = ForEachOptions::Default);
 
  template <typename T>
  static PL_ALWAYS_INLINE void ForEachDerivedType(VisitorFunc func, plBitflags<ForEachOptions> options = ForEachOptions::Default)
  {
    ForEachDerivedType(plGetStaticRTTI<T>(), func, options);
  }
 
protected:
  plStringView m_sPluginName;
  plStringView m_sTypeName;
  plArrayPtr<const plAbstractProperty* const> m_Properties;
  plArrayPtr<const plAbstractFunctionProperty* const> m_Functions;
  plArrayPtr<const plPropertyAttribute* const> m_Attributes;
  void UpdateType(const plRTTI* pParentType, plUInt32 uiTypeSize, plUInt32 uiTypeVersion, plUInt8 uiVariantType, plBitflags<plTypeFlags> flags);
  void RegisterType();
  void UnregisterType();
 
  void GatherDynamicMessageHandlers();
  void SetupParentHierarchy();
 
  const plRTTI* m_pParentType = nullptr;
  plRTTIAllocator* m_pAllocator = nullptr;
 
  plUInt32 m_uiTypeSize = 0;
  plUInt32 m_uiTypeVersion = 0;
  plUInt64 m_uiTypeNameHash = 0;
  plUInt32 m_uiTypeIndex = 0;
  plBitflags<plTypeFlags> m_TypeFlags;
  plUInt8 m_uiVariantType = 0;
  plUInt16 m_uiMsgIdOffset = plSmallInvalidIndex;
 
  const plRTTI* (*m_VerifyParent)();
 
  plArrayPtr<plAbstractMessageHandler*> m_MessageHandlers;
  plSmallArray<plAbstractMessageHandler*, 1, plStaticsAllocatorWrapper> m_DynamicMessageHandlers; // do not track this data, it won't be deallocated before shutdown
 
  plArrayPtr<plMessageSenderInfo> m_MessageSenders;
  plSmallArray<const plRTTI*, 7, plStaticsAllocatorWrapper> m_ParentHierarchy;
 
private:
  PL_MAKE_SUBSYSTEM_STARTUP_FRIEND(Foundation, Reflection);
 
  static void AssignPlugin(plStringView sPluginName);
 
  static void SanityCheckType(plRTTI* pType);
 
  static void PluginEventHandler(const plPluginEvent& EventData);
};
 
PL_DECLARE_FLAGS_OPERATORS(plRTTI::ForEachOptions);
 
 
// ***********************************
// ***** Object Allocator Struct *****
 
 
struct PL_FOUNDATION_DLL plRTTIAllocator
{
  virtual ~plRTTIAllocator();
 
  virtual bool CanAllocate() const { return true; } // [tested]
 
  template <typename T>
  plInternal::NewInstance<T> Allocate(plAllocator* pAllocator = nullptr)
  {
    return AllocateInternal(pAllocator).Cast<T>();
  }
 
  template <typename T>
  plInternal::NewInstance<T> Clone(const void* pObject, plAllocator* pAllocator = nullptr)
  {
    return CloneInternal(pObject, pAllocator).Cast<T>();
  }
 
  virtual void Deallocate(void* pObject, plAllocator* pAllocator = nullptr) = 0; // [tested]
 
private:
  virtual plInternal::NewInstance<void> AllocateInternal(plAllocator* pAllocator) = 0;
  virtual plInternal::NewInstance<void> CloneInternal(const void* pObject, plAllocator* pAllocator)
  {
    PL_REPORT_FAILURE("Cloning is not supported by this allocator.");
    return plInternal::NewInstance<void>(nullptr, pAllocator);
  }
};
 
struct PL_FOUNDATION_DLL plRTTINoAllocator : public plRTTIAllocator
{
  virtual bool CanAllocate() const override { return false; } // [tested]
 
  virtual plInternal::NewInstance<void> AllocateInternal(plAllocator* pAllocator) override // [tested]
  {
    PL_REPORT_FAILURE("This function should never be called.");
    return plInternal::NewInstance<void>(nullptr, pAllocator);
  }
 
  virtual void Deallocate(void* pObject, plAllocator* pAllocator) override // [tested]
  {
    PL_REPORT_FAILURE("This function should never be called.");
  }
};
 
template <typename CLASS, typename AllocatorWrapper = plDefaultAllocatorWrapper>
struct plRTTIDefaultAllocator : public plRTTIAllocator
{
  virtual plInternal::NewInstance<void> AllocateInternal(plAllocator* pAllocator) override // [tested]
  {
    if (pAllocator == nullptr)
    {
      pAllocator = AllocatorWrapper::GetAllocator();
    }
 
    return PL_NEW(pAllocator, CLASS);
  }
 
  virtual plInternal::NewInstance<void> CloneInternal(const void* pObject, plAllocator* pAllocator) override // [tested]
  {
    if (pAllocator == nullptr)
    {
      pAllocator = AllocatorWrapper::GetAllocator();
    }
 
    return CloneImpl(pObject, pAllocator, plTraitInt<std::is_copy_constructible<CLASS>::value>());
  }
 
  virtual void Deallocate(void* pObject, plAllocator* pAllocator) override // [tested]
  {
    if (pAllocator == nullptr)
    {
      pAllocator = AllocatorWrapper::GetAllocator();
    }
 
    CLASS* pPointer = static_cast<CLASS*>(pObject);
    PL_DELETE(pAllocator, pPointer);
  }
 
private:
  plInternal::NewInstance<void> CloneImpl(const void* pObject, plAllocator* pAllocator, plTraitInt<0>)
  {
    PL_REPORT_FAILURE("Clone failed since the type is not copy constructible");
    return plInternal::NewInstance<void>(nullptr, pAllocator);
  }
 
  plInternal::NewInstance<void> CloneImpl(const void* pObject, plAllocator* pAllocator, plTraitInt<1>)
  {
    return PL_NEW(pAllocator, CLASS, *static_cast<const CLASS*>(pObject));
  }
};