RTTI.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Core/Reference.h>
#include <Jolt/Core/StaticArray.h>
#include <Jolt/ObjectStream/SerializableAttribute.h>
 
JPH_NAMESPACE_BEGIN
 
// RTTI
 
class JPH_EXPORT RTTI
{
public:
    using pCreateObjectFunction = void *(*)();
 
    using pDestructObjectFunction = void (*)(void *inObject);
 
    using pCreateRTTIFunction = void (*)(RTTI &inRTTI);
 
                                RTTI(const char *inName, int inSize, pCreateObjectFunction inCreateObject, pDestructObjectFunction inDestructObject);
                                RTTI(const char *inName, int inSize, pCreateObjectFunction inCreateObject, pDestructObjectFunction inDestructObject, pCreateRTTIFunction inCreateRTTI);
 
    // Properties
    inline const char *         GetName() const                                             { return mName; }
    void                        SetName(const char *inName)                                 { mName = inName; }
    inline int                  GetSize() const                                             { return mSize; }
    bool                        IsAbstract() const                                          { return mCreate == nullptr || mDestruct == nullptr; }
    int                         GetBaseClassCount() const;
    const RTTI *                GetBaseClass(int inIdx) const;
    uint32                      GetHash() const;
 
    void *                      CreateObject() const;
 
    void                        DestructObject(void *inObject) const;
 
    void                        AddBaseClass(const RTTI *inRTTI, int inOffset);
 
    bool                        operator == (const RTTI &inRHS) const;
    bool                        operator != (const RTTI &inRHS) const                       { return !(*this == inRHS); }
 
    bool                        IsKindOf(const RTTI *inRTTI) const;
 
    const void *                CastTo(const void *inObject, const RTTI *inRTTI) const;
 
    void                        AddAttribute(const SerializableAttribute &inAttribute);
    int                         GetAttributeCount() const;
    const SerializableAttribute & GetAttribute(int inIdx) const;
 
protected:
    struct BaseClass
    {
        const RTTI *            mRTTI;
        int                     mOffset;
    };
 
    const char *                mName;                                                      
    int                         mSize;                                                      
    StaticArray<BaseClass, 4>   mBaseClasses;                                               
    pCreateObjectFunction       mCreate;                                                    
    pDestructObjectFunction     mDestruct;                                                  
    StaticArray<SerializableAttribute, 32> mAttributes;                                     
};
 
// Add run time type info to types that don't have virtual functions
 
// JPH_DECLARE_RTTI_NON_VIRTUAL
#define JPH_DECLARE_RTTI_NON_VIRTUAL(linkage, class_name)                                                           \
public:                                                                                                             \
    JPH_OVERRIDE_NEW_DELETE                                                                                         \
    friend linkage RTTI *       GetRTTIOfType(class_name *);                                                        \
    friend inline const RTTI *  GetRTTI([[maybe_unused]] const class_name *inObject) { return GetRTTIOfType(static_cast<class_name *>(nullptr)); }\
    static void                 sCreateRTTI(RTTI &inRTTI);                                                          \
 
// JPH_IMPLEMENT_RTTI_NON_VIRTUAL
#define JPH_IMPLEMENT_RTTI_NON_VIRTUAL(class_name)                                                                  \
    RTTI *                      GetRTTIOfType(class_name *)                                                         \
    {                                                                                                               \
        static RTTI rtti(#class_name, sizeof(class_name), []() -> void * { return new class_name; }, [](void *inObject) { delete (class_name *)inObject; }, &class_name::sCreateRTTI); \
        return &rtti;                                                                                               \
    }                                                                                                               \
    void                        class_name::sCreateRTTI(RTTI &inRTTI)                                               \
 
// Same as above, but when you cannot insert the declaration in the class
// itself, for example for templates and third party classes
 
// JPH_DECLARE_RTTI_OUTSIDE_CLASS
#define JPH_DECLARE_RTTI_OUTSIDE_CLASS(linkage, class_name)                                                         \
    linkage RTTI *              GetRTTIOfType(class_name *);                                                        \
    inline const RTTI *         GetRTTI(const class_name *inObject) { return GetRTTIOfType((class_name *)nullptr); }\
    void                        CreateRTTI##class_name(RTTI &inRTTI);                                               \
 
// JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS
#define JPH_IMPLEMENT_RTTI_OUTSIDE_CLASS(class_name)                                                                \
    RTTI *                      GetRTTIOfType(class_name *)                                                         \
    {                                                                                                               \
        static RTTI rtti((const char *)#class_name, sizeof(class_name), []() -> void * { return new class_name; }, [](void *inObject) { delete (class_name *)inObject; }, &CreateRTTI##class_name); \
        return &rtti;                                                                                               \
    }                                                                                                               \
    void                        CreateRTTI##class_name(RTTI &inRTTI)
 
// Same as above, but for classes that have virtual functions
 
#define JPH_DECLARE_RTTI_HELPER(linkage, class_name, modifier)                                                      \
public:                                                                                                             \
    JPH_OVERRIDE_NEW_DELETE                                                                                         \
    friend linkage RTTI *       GetRTTIOfType(class_name *);                                                        \
    friend inline const RTTI *  GetRTTI(const class_name *inObject) { return inObject->GetRTTI(); }                 \
    virtual const RTTI *        GetRTTI() const modifier;                                                           \
    virtual const void *        CastTo(const RTTI *inRTTI) const modifier;                                          \
    static void                 sCreateRTTI(RTTI &inRTTI);                                                          \
 
// JPH_DECLARE_RTTI_VIRTUAL - for derived classes with RTTI
#define JPH_DECLARE_RTTI_VIRTUAL(linkage, class_name)                                                               \
    JPH_DECLARE_RTTI_HELPER(linkage, class_name, override)
 
// JPH_IMPLEMENT_RTTI_VIRTUAL
#define JPH_IMPLEMENT_RTTI_VIRTUAL(class_name)                                                                      \
    RTTI *          GetRTTIOfType(class_name *)                                                                     \
    {                                                                                                               \
        static RTTI rtti(#class_name, sizeof(class_name), []() -> void * { return new class_name; }, [](void *inObject) { delete (class_name *)inObject; }, &class_name::sCreateRTTI); \
        return &rtti;                                                                                               \
    }                                                                                                               \
    const RTTI *                class_name::GetRTTI() const                                                         \
    {                                                                                                               \
        return JPH_RTTI(class_name);                                                                                \
    }                                                                                                               \
    const void *                class_name::CastTo(const RTTI *inRTTI) const                                        \
    {                                                                                                               \
        return JPH_RTTI(class_name)->CastTo((const void *)this, inRTTI);                                            \
    }                                                                                                               \
    void                        class_name::sCreateRTTI(RTTI &inRTTI)                                               \
 
// JPH_DECLARE_RTTI_VIRTUAL_BASE - for concrete base class that has RTTI
#define JPH_DECLARE_RTTI_VIRTUAL_BASE(linkage, class_name)                                                          \
    JPH_DECLARE_RTTI_HELPER(linkage, class_name, )
 
// JPH_IMPLEMENT_RTTI_VIRTUAL_BASE
#define JPH_IMPLEMENT_RTTI_VIRTUAL_BASE(class_name)                                                                 \
    JPH_IMPLEMENT_RTTI_VIRTUAL(class_name)
 
// JPH_DECLARE_RTTI_ABSTRACT - for derived abstract class that have RTTI
#define JPH_DECLARE_RTTI_ABSTRACT(linkage, class_name)                                                              \
    JPH_DECLARE_RTTI_HELPER(linkage, class_name, override)
 
// JPH_IMPLEMENT_RTTI_ABSTRACT
#define JPH_IMPLEMENT_RTTI_ABSTRACT(class_name)                                                                     \
    RTTI *                      GetRTTIOfType(class_name *)                                                         \
    {                                                                                                               \
        static RTTI rtti(#class_name, sizeof(class_name), nullptr, [](void *inObject) { delete (class_name *)inObject; }, &class_name::sCreateRTTI); \
        return &rtti;                                                                                               \
    }                                                                                                               \
    const RTTI *                class_name::GetRTTI() const                                                         \
    {                                                                                                               \
        return JPH_RTTI(class_name);                                                                                \
    }                                                                                                               \
    const void *                class_name::CastTo(const RTTI *inRTTI) const                                        \
    {                                                                                                               \
        return JPH_RTTI(class_name)->CastTo((const void *)this, inRTTI);                                            \
    }                                                                                                               \
    void                        class_name::sCreateRTTI(RTTI &inRTTI)                                               \
 
// JPH_DECLARE_RTTI_ABSTRACT_BASE - for abstract base class that has RTTI
#define JPH_DECLARE_RTTI_ABSTRACT_BASE(linkage, class_name)                                                         \
    JPH_DECLARE_RTTI_HELPER(linkage, class_name, )
 
// JPH_IMPLEMENT_RTTI_ABSTRACT_BASE
#define JPH_IMPLEMENT_RTTI_ABSTRACT_BASE(class_name)                                                                \
    JPH_IMPLEMENT_RTTI_ABSTRACT(class_name)
 
// Declare an RTTI class for registering with the factory
 
#define JPH_DECLARE_RTTI_FOR_FACTORY(linkage, class_name)                                                           \
    linkage RTTI *              GetRTTIOfType(class class_name *);
 
#define JPH_DECLARE_RTTI_WITH_NAMESPACE_FOR_FACTORY(linkage, name_space, class_name)                                \
    namespace name_space {                                                                                          \
        class class_name;                                                                                           \
        linkage RTTI *          GetRTTIOfType(class class_name *);                                                  \
    }
 
// Find the RTTI of a class
 
#define JPH_RTTI(class_name)    GetRTTIOfType(static_cast<class_name *>(nullptr))
 
// Macro to rename a class, useful for embedded classes:
//
// class A { class B { }; }
//
// Now use JPH_RENAME_CLASS(B, A::B) to avoid conflicts with other classes named B
 
// JPH_RENAME_CLASS
#define JPH_RENAME_CLASS(class_name, new_name)                                                                      \
                                inRTTI.SetName(#new_name);
 
// Macro to add base classes
 
#define JPH_BASE_CLASS_OFFSET(inClass, inBaseClass) ((int(uint64((inBaseClass *)((inClass *)0x10000))))-0x10000)
 
// JPH_ADD_BASE_CLASS
#define JPH_ADD_BASE_CLASS(class_name, base_class_name)                                                             \
                                inRTTI.AddBaseClass(JPH_RTTI(base_class_name), JPH_BASE_CLASS_OFFSET(class_name, base_class_name));
 
// Macros and templates to identify a class
 
template <class Type>
inline bool IsType(const Type *inObject, const RTTI *inRTTI)
{
    return inObject == nullptr || *inObject->GetRTTI() == *inRTTI;
}
 
template <class Type>
inline bool IsType(const RefConst<Type> &inObject, const RTTI *inRTTI)
{
    return inObject == nullptr || *inObject->GetRTTI() == *inRTTI;
}
 
template <class Type>
inline bool IsType(const Ref<Type> &inObject, const RTTI *inRTTI)
{
    return inObject == nullptr || *inObject->GetRTTI() == *inRTTI;
}
 
template <class Type>
inline bool IsKindOf(const Type *inObject, const RTTI *inRTTI)
{
    return inObject == nullptr || inObject->GetRTTI()->IsKindOf(inRTTI);
}
 
template <class Type>
inline bool IsKindOf(const RefConst<Type> &inObject, const RTTI *inRTTI)
{
    return inObject == nullptr || inObject->GetRTTI()->IsKindOf(inRTTI);
}
 
template <class Type>
inline bool IsKindOf(const Ref<Type> &inObject, const RTTI *inRTTI)
{
    return inObject == nullptr || inObject->GetRTTI()->IsKindOf(inRTTI);
}
 
template <class DstType, class SrcType>
inline const DstType *StaticCast(const SrcType *inObject)
{
    JPH_ASSERT(IsKindOf(inObject, JPH_RTTI(DstType)), "Invalid cast");
    return static_cast<const DstType *>(inObject);
}
 
template <class DstType, class SrcType>
inline DstType *StaticCast(SrcType *inObject)
{
    JPH_ASSERT(IsKindOf(inObject, JPH_RTTI(DstType)), "Invalid cast");
    return static_cast<DstType *>(inObject);
}
 
template <class DstType, class SrcType>
inline RefConst<DstType> StaticCast(RefConst<SrcType> &inObject)
{
    JPH_ASSERT(IsKindOf(inObject, JPH_RTTI(DstType)), "Invalid cast");
    return static_cast<const DstType *>(inObject.GetPtr());
}
 
template <class DstType, class SrcType>
inline Ref<DstType> StaticCast(Ref<SrcType> &inObject)
{
    JPH_ASSERT(IsKindOf(inObject, JPH_RTTI(DstType)), "Invalid cast");
    return static_cast<DstType *>(inObject.GetPtr());
}
 
template <class DstType, class SrcType>
inline const DstType *DynamicCast(const SrcType *inObject)
{
    return inObject != nullptr? reinterpret_cast<const DstType *>(inObject->CastTo(JPH_RTTI(DstType))) : nullptr;
}
 
template <class DstType, class SrcType>
inline DstType *DynamicCast(SrcType *inObject)
{
    return inObject != nullptr? const_cast<DstType *>(reinterpret_cast<const DstType *>(inObject->CastTo(JPH_RTTI(DstType)))) : nullptr;
}
 
template <class DstType, class SrcType>
inline RefConst<DstType> DynamicCast(RefConst<SrcType> &inObject)
{
    return inObject != nullptr? reinterpret_cast<const DstType *>(inObject->CastTo(JPH_RTTI(DstType))) : nullptr;
}
 
template <class DstType, class SrcType>
inline Ref<DstType> DynamicCast(Ref<SrcType> &inObject)
{
    return inObject != nullptr? const_cast<DstType *>(reinterpret_cast<const DstType *>(inObject->CastTo(JPH_RTTI(DstType)))) : nullptr;
}
 
JPH_NAMESPACE_END