Any container type, work on Event (de+)serialization

Author: NicusorN5

3DRadSpace/Engine3DRadSpace/Games/Game.cpp

@@ -29,6 +29,7 @@ void Game::_initialize()
 	RequireService(typeid(PostProcessCollection));
 	RequireService(typeid(Physics::IPhysicsEngine));
 	RequireService(typeid(Rendering::RenderingManager));
+	RequireService(typeid(ObjectList));
 
 	Internal::RegisterDefaultTypes(Content.get());
 
@@ -86,6 +87,14 @@ IService* Game::RequireService(const std::type_index& type)
 		AddService(RenderingManager.get());
 		return RenderingManager.get();
 	}
+	if (typeid(ObjectList) == type)
+	{
+		if (Objects) return Objects.get();
+		Objects = std::make_unique<Objects::ObjectList>(this);
+		AddService(Objects.get());
+		return Objects.get();
+	}
+
 	return nullptr;
 }
 

3DRadSpace/Engine3DRadSpace/Projects/EventInvocationRepresentation.cpp

@@ -0,0 +1,33 @@
+#include "EventInvocationRepresentation.hpp"
+#include "../Objects/Impl/Objects.hpp"
+
+using namespace Engine3DRadSpace;
+using namespace Engine3DRadSpace::Projects;
+using namespace Engine3DRadSpace::Reflection;
+
+EventInvocationRepresentation::EventInvocationRepresentation() :
+	OwnerObject(std::numeric_limits<size_t>::max()),
+	FunctionID(std::numeric_limits<size_t>::max())
+{
+}
+
+IReflectedFunction* EventInvocationRepresentation::FindFunction(const Reflection::UUID& uuid, size_t idxFn)
+{
+	auto reflObject = Internal::GetReflDataFromUUID(uuid);
+	if (reflObject == nullptr) return nullptr;
+
+	size_t id = 0;
+
+	for (auto& f : *reflObject)
+	{
+		auto fn = dynamic_cast<IReflectedFunction*>(f);
+		if (fn == nullptr) continue;
+
+		if (id++ == idxFn)
+		{
+			return fn;
+		}
+	}
+
+	return nullptr;
+}

3DRadSpace/Engine3DRadSpace/Projects/EventInvocationRepresentation.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#include "../Reflection/Event.hpp"
+
+namespace Engine3DRadSpace::Objects
+{
+	class ObjectList;
+}
+
+namespace Engine3DRadSpace::Projects
+{
+	/// <summary>
+	/// Serializable representation of a member function call.
+	/// </summary>
+	struct E3DRSP_PROJECTS_EXPORT EventInvocationRepresentation
+	{
+		/// <summary>
+		/// ID of the object in the ObjectList.
+		/// </summary>
+		size_t OwnerObject;
+		/// <summary>
+		/// ID of the function, per reflection metadata.
+		/// </summary>
+		size_t FunctionID;
+		/// <summary>
+		/// Arguments pack.
+		/// </summary>
+		std::vector<std::any> Args;
+
+		EventInvocationRepresentation();
+
+		static Reflection::IReflectedFunction* FindFunction(const Reflection::UUID& uuid, size_t idxFn);
+	};
+}

3DRadSpace/Engine3DRadSpace/Projects/EventRepresentation.cpp

@@ -1,69 +1,26 @@
 #include "EventRepresentation.hpp"
-#include "../Objects/ObjectList.hpp"
-#include "../Objects/Impl/Objects.hpp"
 
 using namespace Engine3DRadSpace;
 using namespace Engine3DRadSpace::Projects;
 using namespace Engine3DRadSpace::Reflection;
-using namespace Engine3DRadSpace::Objects;
 
-EventInvocationRepresentation::EventInvocationRepresentation() : 
-	OwnerObject(std::numeric_limits<size_t>::max()), 
-	FunctionID(std::numeric_limits<size_t>::max())
-{
-}
-
-std::any EventInvocationRepresentation::Invoke(ObjectList* list)
-{
-	auto obj = list->operator[](OwnerObject);
-	return Invoke(obj);
-}
-
-IReflectedFunction* EventInvocationRepresentation::FindFunction(IObject* object, size_t idxFn)
-{
-	auto reflObject = Internal::GetReflDataFromUUID(object->GetUUID());
-	if (reflObject == nullptr) return nullptr;
-
-	size_t id = 0;
-
-	for (auto& f : *reflObject)
-	{
-		auto fn = dynamic_cast<IReflectedFunction*>(f);
-		if (fn == nullptr) continue;
-
-		if (id++ == idxFn)
-		{
-			return fn;
-		}
-	}
-
-	return nullptr;
-}
-
-std::any EventInvocationRepresentation::Invoke(IObject* obj)
-{
-	auto fn = FindFunction(obj, FunctionID);
-	if (fn != nullptr) return fn->Invoke(obj, Args);
-
-	return std::any();
-}
-
-std::optional<Event> EventRepresentation::Reconstruct(ObjectList* list) const
+std::optional<Event> EventRepresentation::Reconstruct(const Reflection::UUID& uuid) const
 {
 	Event e;
 
+	if (BoundFunctions.empty()) return std::nullopt;
+
 	for (auto& fn : BoundFunctions)
 	{
-		auto fnRelPtr = fn.FindFunction(list->operator[](fn.OwnerObject), fn.FunctionID);
-		if(!fnRelPtr) continue;
+		auto fnRelPtr = fn.FindFunction(uuid, fn.FunctionID);
+		if (!fnRelPtr) continue;
 
 		auto clonedFn = static_cast<IReflectedFunction*>(fnRelPtr->Clone().release());
-
 		std::unique_ptr<IReflectedFunction> boundFn;
 		boundFn.reset(clonedFn);
-
+		
 		e.Bind(std::move(boundFn));
 	}
 
-	return std::nullopt;
-}
+	return e;
+}

3DRadSpace/Engine3DRadSpace/Projects/EventRepresentation.hpp

@@ -1,46 +1,15 @@
 #pragma once
-#include "../Reflection/Event.hpp"
-
-namespace Engine3DRadSpace::Objects
-{
-	class ObjectList;
-}
+#include "EventInvocationRepresentation.hpp"
 
 namespace Engine3DRadSpace::Projects
 {
-	/// <summary>
-	/// Serializable representation of a member function call.
-	/// </summary>
-	struct E3DRSP_PROJECTS_EXPORT EventInvocationRepresentation
-	{
-		/// <summary>
-		/// ID of the object in the ObjectList.
-		/// </summary>
-		size_t OwnerObject;
-		/// <summary>
-		/// ID of the function, per reflection metadata.
-		/// </summary>
-		size_t FunctionID;
-		/// <summary>
-		/// Arguments pack.
-		/// </summary>
-		std::vector<std::any> Args;
-
-		EventInvocationRepresentation();
-
-		std::any Invoke(Objects::ObjectList* list);
-		std::any Invoke(Objects::IObject* obj);
-
-		static Reflection::IReflectedFunction* FindFunction(Objects::IObject* obj, size_t idxFn);
-	};
-
 	/// <summary>
 	/// Serializable representation of an <see cref="Event"/>.
 	/// </summary>
 	struct E3DRSP_PROJECTS_EXPORT EventRepresentation
 	{
 		std::vector<EventInvocationRepresentation> BoundFunctions;
 
-		std::optional<Reflection::Event> Reconstruct(Objects::ObjectList* list) const;
+		std::optional<Reflection::Event> Reconstruct(const Reflection::UUID &uuid) const;
 	};
 }

3DRadSpace/Engine3DRadSpace/Projects/Serialization.cpp

@@ -1,4 +1,6 @@
 #include "Serialization.hpp"
+#include "Serialization.hpp"
+#include "Serialization.hpp"
 #include "../Content/AssetID.hpp"
 #include "../Objects/Impl/Objects.hpp"
 #include "../Objects/ObjectList.hpp"
@@ -10,6 +12,7 @@ using namespace Engine3DRadSpace::Graphics;
 using namespace Engine3DRadSpace::Internal;
 using namespace Engine3DRadSpace::Math;
 using namespace Engine3DRadSpace::Objects;
+using namespace Engine3DRadSpace::Projects;
 using namespace Engine3DRadSpace::Reflection;
 
 static void deserializeObjectHierarchy(ObjectList* lst, IObject* obj, const json& j)
@@ -255,6 +258,14 @@ json Engine3DRadSpace::Projects::Serializer::SerializeObject(IObject* obj)
 					offset += sizeof(Color);
 					break;
 				}
+				case FieldRepresentationType::Event:
+				{
+					Projects::EventRepresentation e;
+					jsonField[subFieldName][str_i] = e;
+
+					offset += sizeof(Event);
+					break;
+				}
 				case FieldRepresentationType::ObjectID:
 				{
 					size_t id = field->GetAtOffset<size_t>(objPtr, offset);
@@ -474,6 +485,13 @@ json Engine3DRadSpace::Projects::Serializer::SerializeObject(IObject* obj)
 				}
 				case FieldRepresentationType::Event:
 				{
+					EventRepresentation eventData = jsonField.get<EventRepresentation>();
+					Event event = eventData.Reconstruct(uuid).value();
+
+					void* dest = newStruct.get() + offset;
+					new (dest) Event();
+					offset += sizeof(Event);
+
 					break;
 				}
 				case FieldRepresentationType::ObjectID:
@@ -583,4 +601,49 @@ bool Engine3DRadSpace::Projects::Serializer::SaveProject(ObjectList* lst, Conten
 
 	file << std::setw(4) << j;
 	return true;
-} 
+}
+
+void Engine3DRadSpace::Projects::to_json(json& j, const EventRepresentation& event)
+{
+	auto size = event.BoundFunctions.size();
+	j["numFn"] = size;
+
+	for (auto i = 0; i < size; i++)
+	{
+		auto& fn = event.BoundFunctions[i];
+		json jFn;
+
+		jFn["OwnerObject"] = fn.OwnerObject;
+		jFn["FunctionID"] = fn.FunctionID;
+		
+		json jArgs = json::array();
+		for (auto& arg : fn.Args)
+		{
+			jArgs.push_back(arg.type().name());
+		}
+
+		jFn["Args"] = jArgs;
+		j["BoundFunctions"].push_back(jFn);
+	}
+}
+
+void Engine3DRadSpace::Projects::from_json(const json& j, EventRepresentation& event)
+{
+	auto size = j["numFn"].get<size_t>();
+	
+	for (auto i = 0; i < size; i++)
+	{
+		auto& jFn = j["BoundFunctions"][i];
+		EventInvocationRepresentation fn;
+
+		fn.OwnerObject = jFn["OwnerObject"].get<size_t>();
+		fn.FunctionID = jFn["FunctionID"].get<size_t>();
+		for (auto& jArg : jFn["Args"])
+		{
+			std::string typeName = jArg.get<std::string>();
+			fn.Args.push_back(std::any(typeName));
+		}
+
+		event.BoundFunctions.push_back(fn);
+	}
+}

3DRadSpace/Engine3DRadSpace/Projects/Serialization.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include "../Reflection/Reflection.hpp"
 #include "../Games/Game.hpp"
+#include "EventRepresentation.hpp"
 #include <nlohmann/json.hpp>
 
 using json = nlohmann::json;
@@ -56,4 +57,7 @@ namespace Engine3DRadSpace::Projects
 		/// <returns>True if succeded.</returns>
 		static bool SaveProject(Objects::ObjectList* lst, Content::ContentManager* content, const std::filesystem::path& projectPath);
 	};
+
+	void to_json(json& j, const EventRepresentation& event);
+	void from_json(const json& j, EventRepresentation& event);
 }