4 files changed, 117 insertions, 16 deletions
diff --git a/source/10-common/LookupTable.hpp b/source/10-common/LookupTable.hpp
index c50e28e..360cc2b 100644
--- a/source/10-common/LookupTable.hpp
+++ b/source/10-common/LookupTable.hpp
@@ -20,19 +20,30 @@
 #define BIDI_LUT_A2B_LOOKUP(name, from) (name##BType)(gLut_##name##_A2B[from])
 #define BIDI_LUT_B2A_LOOKUP(name, to) (name##AType)(gLut_##name##_B2A[to])
 
-#define STR_LUT_DECL(name, enumMinValue, enumMaxValue)              \
+// Forward string lookup
+#define FSTR_LUT_DECL(name, enumMinValue, enumMaxValue)             \
 	constexpr int kLutMinVal_##name = enumMinValue;                 \
 	const char* gLut_##name[(int)enumMaxValue - (int)enumMinValue]; \
 	void InitializeLut##name()
-#define STR_LUT_MAP_FOR(name)              \
+#define FSTR_LUT_MAP_FOR(name)             \
 	const char** lutMapping = gLut_##name; \
 	int lutMappingMinValue = kLutMinVal_##name
-#define STR_LUT_MAP(value, text) lutMapping[value - lutMappingMinValue] = text
-#define STR_LUT_MAP_ENUM(enumValue) STR_LUT_MAP(enumValue, #enumValue)
-#define STR_LUT_LOOKUP(name, enumValue) gLut_##name[enumValue - kLutMinVal_##name]
-#define STR_LUT_INIT(name) InitializeLut##name()
+#define FSTR_LUT_MAP(value, text) lutMapping[value - lutMappingMinValue] = text
+#define FSTR_LUT_MAP_ENUM(enumValue) FSTR_LUT_MAP(enumValue, #enumValue)
+#define FSTR_LUT_LOOKUP(name, enumValue) gLut_##name[enumValue - kLutMinVal_##name]
+#define FSTR_LUT_INIT(name) InitializeLut##name()
 
-// BSTR stands for bi-directional string
+// RSTR stands for reverse-string lookup
+#define RSTR_LUT_DECL(name, enumMinValue, enumMaxValue)                                   \
+	robin_hood::unordered_flat_map<std::string_view, decltype(enumMaxValue)> gLut_##name; \
+	void InitializeLut##name()
+#define RSTR_LUT_MAP_FOR(name) auto& lutMapping = gLut_##name;
+#define RSTR_LUT_MAP(value, text) lutMapping.insert_or_assign(std::string_view(text), value);
+#define RSTR_LUT(name) gLut_##name
+#define BSTR_LUT_LOOKUP(name, string) gLut_##name.find(std::string_view(text))->second
+#define RSTR_LUT_INIT(name) InitializeLut##name()
+
+// BSTR stands for bi-directional string lookup
 #define BSTR_LUT_DECL(name, enumMinValue, enumMaxValue)                                         \
 	constexpr int kLutMinVal_##name = enumMinValue;                                             \
 	const char* gLut_##name##_V2S[(int)enumMaxValue - (int)enumMinValue];                       \
@@ -49,5 +60,5 @@
 #define BSTR_LUT_V2S(name) gLut_##name##_V2S
 #define BSTR_LUT_S2V(name) gLut_##name##_S2V
 #define BSTR_LUT_V2S_LOOKUP(name, enumValue) gLut_##name##_V2S[enumValue - kLutMinVal_##name]
-#define BSTR_LUT_S2V_LOOKUP(name, string) gLut_##name##_S2V.find(std::string_view(text))
+#define BSTR_LUT_S2V_LOOKUP(name, string) gLut_##name##_S2V.find(std::string_view(text))->second
 #define BSTR_LUT_INIT(name) InitializeLut##name()
diff --git a/source/10-common/RTTI.hpp b/source/10-common/RTTI.hpp
new file mode 100644
index 0000000..bc0d289
--- /dev/null
+++ b/source/10-common/RTTI.hpp
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <cassert>
+
+template <class T, class TBase>
+bool is_a(TBase* t) {
+	assert(t != nullptr);
+	return T::IsInstance(t);
+}
+
+template <class T, class TBase>
+bool is_a_nullable(TBase* t) {
+	if (t) {
+		return is_a<T, TBase>(t);
+	} else {
+		return false;
+	}
+}
+
+template <class T, class TBase>
+T* dyn_cast(TBase* t) {
+	assert(t != nullptr);
+	if (T::IsInstance(t)) {
+		return static_cast<T*>(t);
+	} else {
+		return nullptr;
+	}
+}
+
+template <class T, class TBase>
+const T* dyn_cast(const TBase* t) {
+	assert(t != nullptr);
+	if (T::IsInstance(t)) {
+		return static_cast<const T*>(t);
+	} else {
+		return nullptr;
+	}
+}
+
+template <class T, class TBase>
+T* dyn_cast_nullable(TBase* t) {
+	if (!t) return nullptr;
+	return dyn_cast<T, TBase>(t);
+}
diff --git a/source/10-common/Type2ObjectMap.hpp b/source/10-common/Type2ObjectMap.hpp
new file mode 100644
index 0000000..24c45f3
--- /dev/null
+++ b/source/10-common/Type2ObjectMap.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "TypeTraits.hpp"
+
+#include <cstddef>
+
+template <typename TValue>
+class Type2ObjectMap {
+public:
+	template <typename TType>
+	TType& Insert(TType&& value) {
+		// TODO
+	}
+
+	template <typename TType>
+	TType& InsertOrAssign(TType& value) {
+		// TODO
+	}
+
+	template <typename TType>
+	TType Remove() {
+		// TODO
+	}
+
+	template <typename TType>
+	const TValue* Find() const {
+		// TODO
+	}
+
+	template <class TType>
+	TValue* Find() {
+		return const_cast<TValue*>(const_cast<const Type2ObjectMap*>(this)->Find<TType>());
+	}
+
+	size_t size() const {
+		// TODO
+	}
+};
diff --git a/source/10-common/TypeTraits.hpp b/source/10-common/TypeTraits.hpp
index cca9a1f..73a56f9 100644
--- a/source/10-common/TypeTraits.hpp
+++ b/source/10-common/TypeTraits.hpp
@@ -1,19 +1,27 @@
 #pragma once
 
-template <class T>
+#include <cstddef>
+
+/// This template will be instanciated for each unique type, and the char variable will be ODR-used which gives it an unique address.
+template <typename T>
+struct TypeIdentifier {
+	static const char obj = 0;
+};
+
+template <typename T>
 struct DefaultDeleter {
-    void operator()(T* ptr) const {
-        delete ptr;
-    }
+	void operator()(T* ptr) const {
+		delete ptr;
+	}
 };
 
-template <class>
+template <typename>
 struct RemoveMemberPtrImpl {};
 
-template <class T, class U>
+template <typename T, typename U>
 struct RemoveMemberPtrImpl<U T::*> {
-    using Type = U;
+	using Type = U;
 };
 
-template <class T>
+template <typename T>
 using RemoveMemberPtr = typename RemoveMemberPtrImpl<T>::Type;