Я пересоздал репозиторий из-за большого количества мусора в прошлом

FastRTTI/CMakeLists.txt

@@ -0,0 +1,29 @@
+file(GLOB SRC "*.cpp" "*.h")
+
+add_library(FastRTTI STATIC ${SRC})
+
+target_include_directories(FastRTTI
+    PUBLIC
+        ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+
+if(CMAKE_BUILD_TYPE STREQUAL "Release")
+    if(MSVC)
+        target_compile_options(FastRTTI PRIVATE /GR-)
+        target_link_options(FastRTTI PRIVATE /LTCG)
+    else()
+        # GCC / Clang
+        target_compile_options(FastRTTI PRIVATE -fno-rtti)
+        target_link_options(FastRTTI PRIVATE -flto)
+    endif()
+
+elseif(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    if(MSVC)
+        target_compile_options(FastRTTI PRIVATE /GR-)
+    else()
+        target_compile_options(FastRTTI PRIVATE
+            -g
+            -fno-rtti)
+    endif()
+endif()

FastRTTI/RTTI.cpp

@@ -0,0 +1,74 @@
+#include  "RTTI.h"
+
+void IRTTI::FastContainer::push_back(const Classes newType)
+{
+    if (0 == _size)
+    {
+        ++_size;
+        array = new Classes;
+        *array = newType;
+    }
+    else
+    {
+        ++_size;
+        Classes* NewArray = new Classes[_size];
+
+        long long indexObject = _size - 1;
+        for (long long i = 0, j = 0; i < _size - 1; ++i, ++j)
+        {
+            if (newType < array[i] && indexObject == _size - 1)
+            {
+                indexObject = j;
+                ++j;
+            }
+
+            NewArray[j] = array[i];
+        }
+        NewArray[indexObject] = newType;
+
+        delete[] array;
+        array = NewArray;
+    }
+}
+
+bool IRTTI::FastContainer::find(const Classes& Type) const
+{
+    long long low = 0;
+    long long high = _size - 1;
+
+    while (low <= high)
+    {
+        long long mid = (low + high) / 2;
+        if (static_cast<int>(array[mid]) == static_cast<int>(Type))
+            return true;
+        
+        if (static_cast<int>(array[mid]) > static_cast<int>(Type))
+            high = mid - 1;
+        else
+            low = mid + 1;
+    }
+
+    return false;
+}
+
+IRTTI::FastContainer::~FastContainer()
+{
+    _size = 0;
+    delete[] array;
+}
+
+void IRTTI::SetType(const Classes Type)
+{
+    this->type = Type;
+    Tree.push_back(Type);
+}
+
+IRTTI::IRTTI()
+{
+    SetType(Classes::IRTTI);
+}
+
+Classes RTTI::GetType(const IRTTI* object)
+{
+    return object->type;
+}

FastRTTI/RTTI.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "RTTI_Meta.h"
+
+// Interface RTTI
+GENERATE_META(IRTTI)
+class IRTTI
+{
+    // Fast array
+    class FastContainer final
+    {
+        long long _size = 0;
+        Classes* array = nullptr;
+    public:
+        long long constexpr size() const { return _size; }
+        void push_back(const Classes object);
+        bool find(const Classes& Type) const;
+
+        ~FastContainer();
+    };
+    FastContainer Tree;
+    Classes type;
+protected:
+    // That method set type value and add type to inheritance tree
+    void SetType(Classes Type);
+    
+    IRTTI();
+    ~IRTTI() = default;
+    
+    friend class RTTI;
+};
+
+// RTTI methods
+class RTTI final
+{
+    RTTI() = default;
+
+public:
+    template<class Kind>
+    static bool IsA(const IRTTI* object)
+    {
+        return Meta<Kind>::Type == object->type;
+    }
+
+    // That method realized dynamic_cast
+    template<class To, class From>
+    static To* dyn_cast(From* object)
+    {
+        IRTTI* InterfaceOfObject = static_cast<IRTTI*>(object);
+        if (IsA<To>(object))
+            return static_cast<To*>(object);
+
+        if (InterfaceOfObject->Tree.find(Meta<To>::Type))
+            return static_cast<To*>(object);
+        
+        return nullptr;
+    }
+
+    // That method return real type object in the form of enum value
+    static Classes GetType(const IRTTI* object);
+};

FastRTTI/RTTI_Meta.h

@@ -0,0 +1,17 @@
+#pragma once
+
+// This macro adds meta information to a type
+#define GENERATE_META(Class) \
+class Class; \
+template<> struct Meta <Class> { \
+static constexpr Classes Type = Classes::Class; \
+};
+
+// Predeclared struct for meta information
+template<class T> struct Meta;
+
+// Enum type classes
+enum class Classes
+{
+    IRTTI, IResource, Actor, TestActor
+};