Added basic TypeId runtime reflection

muit · muit · commit b62737a77ef1 · 2024-05-07T00:35:52.000+02:00
diff --git a/Benchmarks/Lookups.bench.h b/Benchmarks/Lookups.bench.h
@@ -44,7 +44,7 @@ void RunLookupsBenchmarks()
 			}
 			u64 i = 0;
 			lookups.run("Array - Binary Search", [&data, &i] {
-				ankerl::nanobench::doNotOptimizeAway(data.FindSortedEqual(i));
+				ankerl::nanobench::doNotOptimizeAway(data.FindSorted(i));
 				++i;
 			});
 		}
@@ -76,7 +76,7 @@ void RunLookupsBenchmarks()
 	        }
 	        u64 i = 0;
 	        complexityBSearch.complexityN(size).run("Array - Binary Search", [&data, &i] {
-	            data.FindSortedEqual(i);
+	            data.FindSorted(i);
 	            ++i;
 	        });
 	    }
diff --git a/Include/Pipe/Core/Platform.h b/Include/Pipe/Core/Platform.h
@@ -178,4 +178,4 @@ namespace p
 #else
 	#define P_RESTRICT
 	#define P_ATTR_MALLOC
-#endif
+#endif
diff --git a/Include/Pipe/Core/TypeTraits.h b/Include/Pipe/Core/TypeTraits.h
@@ -155,6 +155,20 @@ namespace p
 	template<typename T>
 	concept IsChar = Internal::TIsChar<T>::value;
 
+
+	template<typename T>
+	struct HasSuper
+	{
+	private:
+		template<typename V>
+		static void Impl(decltype(typename V::Super(), int()));
+		template<typename V>
+		static bool Impl(char);
+
+	public:
+		static const bool value = std::is_void<decltype(Impl<T>(0))>::value;
+	};
+
 	template<typename T>
 	struct HasTypeMember
 	{
diff --git a/Include/Pipe/Core/Utility.h b/Include/Pipe/Core/Utility.h
@@ -60,6 +60,11 @@ namespace p
 #endif
 	}
 
+	struct Undefined
+	{
+		explicit Undefined() = default;
+	};
+
 	template<typename Predicate>
 	class ReversePredicate
 	{
diff --git a/Include/Pipe/Reflect/TypeId.h b/Include/Pipe/Reflect/TypeId.h
@@ -3,6 +3,7 @@
 
 #include "Pipe/Core/Hash.h"
 #include "Pipe/Core/Platform.h"
+#include "Pipe/Core/Utility.h"
 
 #include <format>
 #include <iostream>
@@ -13,11 +14,12 @@ namespace p
 	struct PIPE_API TypeId
 	{
 	protected:
-		u64 id = 0;
+		u64 id;
 
 
 	public:
-		constexpr TypeId() = default;
+		constexpr TypeId() : id{0} {}
+		constexpr TypeId(p::Undefined) {}
 		explicit constexpr TypeId(u64 id) : id(id) {}
 
 		constexpr u64 GetId() const
@@ -69,11 +71,17 @@ namespace p
 	}
 
 	template<typename T>
-	inline consteval TypeId GetTypeId()
+	inline consteval TypeId GetTypeId() requires(!IsConst<T>)
 	{
 		return TypeId{p::GetStringHash(TX(UNIQUE_FUNCTION_ID))};
 	}
 
+	template<typename T>
+	inline consteval TypeId GetTypeId() requires(IsConst<T>)
+	{
+		return GetTypeId<Mut<T>>();
+	}
+
 }    // namespace p
 
 
diff --git a/Include/Pipe/Reflect/TypeRegistry.h b/Include/Pipe/Reflect/TypeRegistry.h
@@ -25,6 +25,11 @@ namespace p
 		bool initialized = false;
 
 
+		TArray<TypeId> ids;
+		TArray<TypeId> parentIds;
+		TArray<StringView> names;
+
+
 	public:
 		TypeRegistry();
 		~TypeRegistry()
diff --git a/Include/PipeArrays.h b/Include/PipeArrays.h
@@ -559,7 +559,7 @@ namespace p
 		}
 
 		template<typename Value, typename SortPredicate = TLess<>>
-		i32 FindSortedEqual(const Value& value, SortPredicate sortPredicate = {}) const
+		i32 FindSorted(const Value& value, SortPredicate sortPredicate = {}) const
 		{
 			return p::BinarySearch(Data(), 0, Size(), value, sortPredicate);
 		}
@@ -589,7 +589,7 @@ namespace p
 		template<typename Value, typename SortPredicate = TLess<>>
 		bool ContainsSorted(const Value& value, SortPredicate sortPredicate = {}) const
 		{
-			return FindSortedEqual(value, sortPredicate) != NO_INDEX;
+			return FindSorted(value, sortPredicate) != NO_INDEX;
 		}
 #pragma endregion Search
 
@@ -871,55 +871,55 @@ namespace p
 		 */
 		template<typename SortPredicate = TLess<Type>>
 		i32 AddUniqueSorted(const Type& value, SortPredicate sortPredicate = {},
-		    bool* outFound = nullptr, bool insertSorted = true)
+		    bool* outAdded = nullptr, bool insertSorted = true)
 		{
 			const i32 index = Super::LowerBound(value, sortPredicate);
 			if (index != NO_INDEX)
 			{
 				if (!sortPredicate(value, Super::data[index]))    // Equal check, found element
 				{
-					if (outFound)
-						*outFound = false;
+					if (outAdded)
+						*outAdded = false;
 					return index;
 				}
 				else if (insertSorted)
 				{
 					Insert(index, value);
-					if (outFound)
-						*outFound = true;
+					if (outAdded)
+						*outAdded = true;
 					return index;
 				}
 			}
 
-			if (outFound)
-				*outFound = true;
+			if (outAdded)
+				*outAdded = true;
 			return Add(value);
 		}
 
 		template<typename SortPredicate = TLess<Type>>
 		i32 AddUniqueSorted(Type&& value, SortPredicate sortPredicate = {},
-		    bool* outFound = nullptr, bool insertSorted = true)
+		    bool* outAdded = nullptr, bool insertSorted = true)
 		{
 			const i32 index = Super::LowerBound(value, sortPredicate);
 			if (index != NO_INDEX)
 			{
 				if (!sortPredicate(value, Super::data[index]))    // Equal check, found element
 				{
-					if (outFound)
-						*outFound = false;
+					if (outAdded)
+						*outAdded = false;
 					return index;
 				}
 				else if (insertSorted)
 				{
 					Insert(index, p::Forward<Type>(value));
-					if (outFound)
-						*outFound = true;
+					if (outAdded)
+						*outAdded = true;
 					return index;
 				}
 			}
 
-			if (outFound)
-				*outFound = true;
+			if (outAdded)
+				*outAdded = true;
 			return Add(p::Forward<Type>(value));
 		}
 
@@ -1043,6 +1043,9 @@ namespace p
 			return Super::data[atIndex];
 		}
 
+		void AddUninitialized(i32 count);
+		void InsertUninitialized(i32 atIndex, i32 count);
+
 #pragma endregion Insertions
 
 
@@ -1098,7 +1101,7 @@ namespace p
 		bool RemoveSorted(const OtherType& value, SortPredicate sortPredicate = {},
 		    const bool shouldShrink = true)
 		{
-			return RemoveAt(Super::FindSortedEqual(value, sortPredicate));
+			return RemoveAt(Super::FindSorted(value, sortPredicate));
 		}
 
 		/**
@@ -1458,8 +1461,6 @@ namespace p
 
 
 	protected:
-		void AddUninitialized(i32 count);
-		void InsertUninitialized(i32 atIndex, i32 count);
 		void CopyFrom(const IArray<const Type>& other);
 
 		template<u32 OtherInlineCapacity>
diff --git a/Include/PipeECS.h b/Include/PipeECS.h
@@ -9,6 +9,7 @@
 #include "Pipe/Memory/UniquePtr.h"
 #include "Pipe/Reflect/Builders/NativeTypeBuilder.h"
 #include "PipeArrays.h"
+#include "PipeReflect.h"
 
 
 ////////////////////////////////
@@ -2106,7 +2107,7 @@ namespace p
 	template<typename T>
 	inline TPool<Mut<T>>& EntityContext::AssurePool() const
 	{
-		constexpr TypeId componentId = GetTypeId<Mut<T>>();
+		const TypeId componentId = AssureTypeId<Mut<T>>();
 
 		i32 index = pools.LowerBound(PoolInstance{componentId, {}});
 		if (index != NO_INDEX)
diff --git a/Include/PipeReflect.h b/Include/PipeReflect.h
@@ -0,0 +1,61 @@
+// Copyright 2015-2024 Piperift - All rights reserved
+
+#pragma once
+
+#include "Pipe/Core/StringView.h"
+#include "Pipe/Reflect/TypeId.h"
+#include "Pipe/Reflect/TypeName.h"
+
+
+namespace p
+{
+	///////////////////////////////////////////////////////
+	// Runtime reflection
+
+	namespace details
+	{
+		PIPE_API i32 AssureSingleTypeId(TypeId id);
+		PIPE_API void SetTypeParentUnsafe(i32 index, TypeId parentId);
+		PIPE_API void SetTypeNameUnsafe(i32 index, StringView name);
+	}    // namespace details
+
+
+	template<typename T>
+	TypeId AssureTypeId();
+
+	PIPE_API TypeId GetParentId(TypeId id);
+	PIPE_API TypeId GetParentId(TypeId id);
+	PIPE_API bool IsParentOf(TypeId parentId, TypeId childId);
+	PIPE_API StringView GetTypeName(TypeId id);
+
+
+	///////////////////////////////////////////////////////
+	// Implementations
+
+	template<typename T>
+	TypeId AssureTypeId()
+	{
+		// Static to only register once
+		static TypeId typeId = []() {
+			TypeId parentId{p::Undefined{}};
+			if constexpr (HasSuper<T>::value)
+			{
+				parentId = AssureTypeId<typename T::Super>();
+			}
+			else
+			{
+				parentId = TypeId{};
+			}
+
+			const TypeId typeId = GetTypeId<T>();
+			const i32 index     = details::AssureSingleTypeId(typeId);
+			if (index != NO_INDEX)    // Invalid or already registered
+			{
+				details::SetTypeParentUnsafe(index, parentId);
+				details::SetTypeNameUnsafe(index, GetTypeName<T>());
+			}
+			return typeId;
+		}();
+		return typeId;
+	}
+};    // namespace p
diff --git a/Src/Memory/MemoryStats.cpp b/Src/Memory/MemoryStats.cpp
@@ -131,7 +131,7 @@ namespace p
 		}
 
 		std::unique_lock lock{mutex};
-		const i32 index = allocations.FindSortedEqual(ptr, SortLessAllocationStats{});
+		const i32 index = allocations.FindSorted(ptr, SortLessAllocationStats{});
 		if (index != NO_INDEX)
 		{
 			AllocationStats& allocation = allocations[index];
diff --git a/Src/PipeECS.cpp b/Src/PipeECS.cpp
@@ -548,7 +548,7 @@ namespace p
 
 	BasePool* EntityContext::GetPool(TypeId componentId) const
 	{
-		const i32 index = pools.FindSortedEqual(PoolInstance{componentId, {}});
+		const i32 index = pools.FindSorted(PoolInstance{componentId, {}});
 		return index != NO_INDEX ? pools[index].GetPool() : nullptr;
 	}
 
@@ -607,21 +607,21 @@ namespace p
 
 	void* EntityContext::TryGetStatic(TypeId typeId)
 	{
-		const i32 index = statics.FindSortedEqual<TypeId, SortLessStatics>(typeId);
+		const i32 index = statics.FindSorted<TypeId, SortLessStatics>(typeId);
 		return index != NO_INDEX ? statics[index].Get() : nullptr;
 	}
 	const void* EntityContext::TryGetStatic(TypeId typeId) const
 	{
-		const i32 index = statics.FindSortedEqual<TypeId, SortLessStatics>(typeId);
+		const i32 index = statics.FindSorted<TypeId, SortLessStatics>(typeId);
 		return index != NO_INDEX ? statics[index].Get() : nullptr;
 	}
 	bool EntityContext::HasStatic(TypeId typeId) const
 	{
-		return statics.FindSortedEqual<TypeId, SortLessStatics>(typeId) != NO_INDEX;
+		return statics.FindSorted<TypeId, SortLessStatics>(typeId) != NO_INDEX;
 	}
 	bool EntityContext::RemoveStatic(TypeId typeId)
 	{
-		const i32 index = statics.FindSortedEqual<TypeId, SortLessStatics>(typeId);
+		const i32 index = statics.FindSorted<TypeId, SortLessStatics>(typeId);
 		if (index != NO_INDEX)
 		{
 			statics.RemoveAt(index);
diff --git a/Src/PipeReflect.cpp b/Src/PipeReflect.cpp
diff --git a/Tests/Math/Math.spec.cpp b/Tests/Math/Math.spec.cpp
diff --git a/Tests/Reflection/TypeId.spec.cpp b/Tests/Reflection/TypeId.spec.cpp

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ void RunLookupsBenchmarks()`
`44`	`44`	`}`
`45`	`45`	`u64 i = 0;`
`46`	`46`	`lookups.run("Array - Binary Search", [&data, &i] {`
`47`		`- ankerl::nanobench::doNotOptimizeAway(data.FindSortedEqual(i));`
	`47`	`+ ankerl::nanobench::doNotOptimizeAway(data.FindSorted(i));`
`48`	`48`	`++i;`
`49`	`49`	`});`
`50`	`50`	`}`
`@@ -76,7 +76,7 @@ void RunLookupsBenchmarks()`
`76`	`76`	`}`
`77`	`77`	`u64 i = 0;`
`78`	`78`	`complexityBSearch.complexityN(size).run("Array - Binary Search", [&data, &i] {`
`79`		`- data.FindSortedEqual(i);`
	`79`	`+ data.FindSorted(i);`
`80`	`80`	`++i;`
`81`	`81`	`});`
`82`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,11 @@ namespace p`
`60`	`60`	`#endif`
`61`	`61`	`}`
`62`	`62`
	`63`	`+ struct Undefined`
	`64`	`+ {`
	`65`	`+ explicit Undefined() = default;`
	`66`	`+ };`
	`67`	`+`
`63`	`68`	`template<typename Predicate>`
`64`	`69`	`class ReversePredicate`
`65`	`70`	`{`
Original file line number	Diff line number	Diff line change
`@@ -559,7 +559,7 @@ namespace p`
`559`	`559`	`}`
`560`	`560`
`561`	`561`	`template<typename Value, typename SortPredicate = TLess<>>`
`562`		`- i32 FindSortedEqual(const Value& value, SortPredicate sortPredicate = {}) const`
	`562`	`+ i32 FindSorted(const Value& value, SortPredicate sortPredicate = {}) const`
`563`	`563`	`{`
`564`	`564`	`return p::BinarySearch(Data(), 0, Size(), value, sortPredicate);`
`565`	`565`	`}`
`@@ -589,7 +589,7 @@ namespace p`
`589`	`589`	`template<typename Value, typename SortPredicate = TLess<>>`
`590`	`590`	`bool ContainsSorted(const Value& value, SortPredicate sortPredicate = {}) const`
`591`	`591`	`{`
`592`		`- return FindSortedEqual(value, sortPredicate) != NO_INDEX;`
	`592`	`+ return FindSorted(value, sortPredicate) != NO_INDEX;`
`593`	`593`	`}`
`594`	`594`	`#pragma endregion Search`
`595`	`595`
`@@ -871,55 +871,55 @@ namespace p`
`871`	`871`	`*/`
`872`	`872`	`template<typename SortPredicate = TLess<Type>>`
`873`	`873`	`i32 AddUniqueSorted(const Type& value, SortPredicate sortPredicate = {},`
`874`		`- bool* outFound = nullptr, bool insertSorted = true)`
	`874`	`+ bool* outAdded = nullptr, bool insertSorted = true)`
`875`	`875`	`{`
`876`	`876`	`const i32 index = Super::LowerBound(value, sortPredicate);`
`877`	`877`	`if (index != NO_INDEX)`
`878`	`878`	`{`
`879`	`879`	`if (!sortPredicate(value, Super::data[index])) // Equal check, found element`
`880`	`880`	`{`
`881`		`- if (outFound)`
`882`		`- *outFound = false;`
	`881`	`+ if (outAdded)`
	`882`	`+ *outAdded = false;`
`883`	`883`	`return index;`
`884`	`884`	`}`
`885`	`885`	`else if (insertSorted)`
`886`	`886`	`{`
`887`	`887`	`Insert(index, value);`
`888`		`- if (outFound)`
`889`		`- *outFound = true;`
	`888`	`+ if (outAdded)`
	`889`	`+ *outAdded = true;`
`890`	`890`	`return index;`
`891`	`891`	`}`
`892`	`892`	`}`
`893`	`893`
`894`		`- if (outFound)`
`895`		`- *outFound = true;`
	`894`	`+ if (outAdded)`
	`895`	`+ *outAdded = true;`
`896`	`896`	`return Add(value);`
`897`	`897`	`}`
`898`	`898`
`899`	`899`	`template<typename SortPredicate = TLess<Type>>`
`900`	`900`	`i32 AddUniqueSorted(Type&& value, SortPredicate sortPredicate = {},`
`901`		`- bool* outFound = nullptr, bool insertSorted = true)`
	`901`	`+ bool* outAdded = nullptr, bool insertSorted = true)`
`902`	`902`	`{`
`903`	`903`	`const i32 index = Super::LowerBound(value, sortPredicate);`
`904`	`904`	`if (index != NO_INDEX)`
`905`	`905`	`{`
`906`	`906`	`if (!sortPredicate(value, Super::data[index])) // Equal check, found element`
`907`	`907`	`{`
`908`		`- if (outFound)`
`909`		`- *outFound = false;`
	`908`	`+ if (outAdded)`
	`909`	`+ *outAdded = false;`
`910`	`910`	`return index;`
`911`	`911`	`}`
`912`	`912`	`else if (insertSorted)`
`913`	`913`	`{`
`914`	`914`	`Insert(index, p::Forward<Type>(value));`
`915`		`- if (outFound)`
`916`		`- *outFound = true;`
	`915`	`+ if (outAdded)`
	`916`	`+ *outAdded = true;`
`917`	`917`	`return index;`
`918`	`918`	`}`
`919`	`919`	`}`
`920`	`920`
`921`		`- if (outFound)`
`922`		`- *outFound = true;`
	`921`	`+ if (outAdded)`
	`922`	`+ *outAdded = true;`
`923`	`923`	`return Add(p::Forward<Type>(value));`
`924`	`924`	`}`
`925`	`925`
`@@ -1043,6 +1043,9 @@ namespace p`
`1043`	`1043`	`return Super::data[atIndex];`
`1044`	`1044`	`}`
`1045`	`1045`
	`1046`	`+ void AddUninitialized(i32 count);`
	`1047`	`+ void InsertUninitialized(i32 atIndex, i32 count);`
	`1048`	`+`
`1046`	`1049`	`#pragma endregion Insertions`
`1047`	`1050`
`1048`	`1051`
`@@ -1098,7 +1101,7 @@ namespace p`
`1098`	`1101`	`bool RemoveSorted(const OtherType& value, SortPredicate sortPredicate = {},`
`1099`	`1102`	`const bool shouldShrink = true)`
`1100`	`1103`	`{`
`1101`		`- return RemoveAt(Super::FindSortedEqual(value, sortPredicate));`
	`1104`	`+ return RemoveAt(Super::FindSorted(value, sortPredicate));`
`1102`	`1105`	`}`
`1103`	`1106`
`1104`	`1107`	`/**`
`@@ -1458,8 +1461,6 @@ namespace p`
`1458`	`1461`
`1459`	`1462`
`1460`	`1463`	`protected:`
`1461`		`- void AddUninitialized(i32 count);`
`1462`		`- void InsertUninitialized(i32 atIndex, i32 count);`
`1463`	`1464`	`void CopyFrom(const IArray<const Type>& other);`
`1464`	`1465`
`1465`	`1466`	`template<u32 OtherInlineCapacity>`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ namespace p`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`std::unique_lock lock{mutex};`
`134`		`- const i32 index = allocations.FindSortedEqual(ptr, SortLessAllocationStats{});`
	`134`	`+ const i32 index = allocations.FindSorted(ptr, SortLessAllocationStats{});`
`135`	`135`	`if (index != NO_INDEX)`
`136`	`136`	`{`
`137`	`137`	`AllocationStats& allocation = allocations[index];`