Updated tests, rewrote code to fix lifetime issues

Author: Kelwan

ecsact/runtime/serialize.hh

@@ -46,6 +46,10 @@ std::vector<std::byte> serialize(const T& component_or_action) {
 	return bytes;
 }
 
+/**
+ * Serializes an ecsact_component when the type is unknown.
+ * @returns serialized action bytes
+ */
 inline std::vector<std::byte> serialize(const ecsact_component& component) {
 	std::vector<std::byte> out_component;
 	out_component.resize(ecsact_serialize_component_size(component.component_id));
@@ -58,6 +62,10 @@ inline std::vector<std::byte> serialize(const ecsact_component& component) {
 	return out_component;
 }
 
+/**
+ * Serializes an ecsact_action when the type is unknown.
+ * @returns serialized component bytes
+ */
 inline std::vector<std::byte> serialize(const ecsact_action& action) {
 	std::vector<std::byte> out_action;
 	out_action.resize(ecsact_serialize_action_size(action.action_id));
@@ -140,40 +148,42 @@ int deserialize(
 	return read_amount;
 }
 
-// NOTE: Document functions
-inline ecsact_action deserialize(
+/**
+ * Deserializes an ecsact_component when the type is unknown.
+ * @returns an ecsact_action
+ */
+inline std::vector<std::byte> deserialize(
 	const ecsact_action_id& id,
 	std::vector<std::byte>& serialized_action
 ) {
-	auto action = ecsact_action{};
+	std::vector<std::byte> action_data;
+	action_data.resize(serialized_action.size());
 
 	ecsact_deserialize_action(
 		id,
 		reinterpret_cast<uint8_t*>(serialized_action.data()),
-		&action
+		action_data.data()
 	);
-	return action;
+	return action_data;
 }
 
-inline ecsact_component deserialize(
+/**
+ * Deserializes an ecsact_component when the type is unknown.
+ * @returns an ecsact_component_id
+ */
+inline std::vector<std::byte> deserialize(
 	const ecsact_component_id& id,
 	std::vector<std::byte>&    serialized_component
 ) {
-	auto component = ecsact_component{};
-
-	std::vector<uint8_t> component_data;
+	std::vector<std::byte> component_data;
 	component_data.resize(serialized_component.size());
 
 	ecsact_deserialize_component(
 		id,
 		reinterpret_cast<uint8_t*>(serialized_component.data()),
 		component_data.data()
 	);
-
-	component.component_id = id;
-	component.component_data = component_data.data();
-
-	return component;
+	return component_data;
 }
 
 } // namespace ecsact

reference/async_reference/BUILD.bazel

@@ -20,6 +20,7 @@ cc_library(
         "//:core",
         "//reference/async_reference/callbacks:async_callbacks",
         "//reference/async_reference/callbacks:execution_callbacks",
+        "//reference/async_reference/detail/c_execution_options",
         "//reference/async_reference/entity_manager",
         "//reference/async_reference/tick_manager",
         "//reference/async_reference/util",

reference/async_reference/async_reference.cc

@@ -160,19 +160,21 @@ void async_reference::execute_systems() {
 
 			auto collector = exec_callbacks.get_collector();
 
-			std::unique_ptr<ecsact_execution_options> options = nullptr;
+			detail::c_execution_options c_exec_options;
 
 			if(cpp_options) {
-				options = std::make_unique<ecsact_execution_options>(
-					util::cpp_to_c_execution_options(*cpp_options, *registry_id)
+				util::cpp_to_c_execution_options(
+					c_exec_options,
+					*cpp_options,
+					*registry_id
 				);
 			}
-
+			auto options = c_exec_options.c();
 			entity_manager.process_entities(async_callbacks, *registry_id);
 
 			auto exec_lk = exec_callbacks.lock();
 			auto systems_error =
-				ecsact_execute_systems(*registry_id, 1, options.get(), collector);
+				ecsact_execute_systems(*registry_id, 1, &options, collector);
 			exec_lk.unlock();
 
 			auto end = clock::now();
@@ -227,7 +229,3 @@ ecsact_async_request_id async_reference::next_request_id() {
 		_last_request_id.fetch_add(1, std::memory_order_relaxed)
 	);
 }
-
-ecsact_async_request_id async_reference::convert_request_id(int32_t id) {
-	return static_cast<ecsact_async_request_id>(id);
-}

reference/async_reference/async_reference.hh

@@ -11,6 +11,7 @@
 #include "ecsact/runtime/core.hh"
 #include "ecsact/runtime/async.h"
 
+#include "reference/async_reference/detail/c_execution_options/c_execution_options.hh"
 #include "reference/async_reference/util/types.hh"
 #include "reference/async_reference/util/util.hh"
 #include "reference/async_reference/tick_manager/tick_manager.hh"
@@ -55,5 +56,4 @@ private:
 	std::chrono::milliseconds tick_rate = {};
 
 	ecsact_async_request_id next_request_id();
-	ecsact_async_request_id convert_request_id(int32_t id);
 };

reference/async_reference/callbacks/execution_callbacks.cc

@@ -103,7 +103,6 @@ void execution_callbacks::init_callback(
 	info.event = event;
 	info.entity_id = entity_id;
 	info.component_id = component_id;
-	std::unique_lock lk(self->execution_m);
 	self->init_callbacks_info.push_back(info);
 }
 
@@ -120,7 +119,6 @@ void execution_callbacks::update_callback(
 	info.event = event;
 	info.entity_id = entity_id;
 	info.component_id = component_id;
-	std::unique_lock lk(self->execution_m);
 	self->update_callbacks_info.push_back(info);
 }
 
@@ -133,16 +131,13 @@ void execution_callbacks::remove_callback(
 ) {
 	auto self = static_cast<execution_callbacks*>(callback_user_data);
 
-	std::unique_lock lk(self->execution_m);
 	std::erase_if(self->init_callbacks_info, [&](auto& init_cb_info) {
 		return init_cb_info.component_id == component_id;
 	});
-	lk.unlock();
 
 	auto info = types::callback_info{};
 	info.event = event;
 	info.entity_id = entity_id;
 	info.component_id = component_id;
-	lk.lock();
 	self->remove_callbacks_info.push_back(info);
 }

reference/async_reference/detail/c_execution_options/BUILD.bazel

@@ -0,0 +1,17 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("//bazel:copts.bzl", "copts")
+
+cc_library(
+    name = "c_execution_options",
+    srcs = ["c_execution_options.cc"],
+    hdrs = ["c_execution_options.hh"],
+    copts = copts,
+    local_defines = [
+        "ECSACT_CORE_API=",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//:async",
+        "//:core",
+    ],
+)

reference/async_reference/detail/c_execution_options/c_execution_options.cc

@@ -0,0 +1,46 @@
+#include "c_execution_options.hh"
+
+ecsact_execution_options detail::c_execution_options::c() {
+	for(auto& action_info : actions_info) {
+		ecsact_action action;
+		action.action_data = action_info.data.data();
+		action.action_id = action_info.id;
+
+		actions.push_back(action);
+	}
+
+	for(auto& add_info : adds_info) {
+		auto component = ecsact_component{};
+
+		component.component_id = add_info.id;
+		component.component_data = add_info.data.data();
+
+		adds.push_back(component);
+	}
+
+	for(auto& update_info : updates_info) {
+		auto component = ecsact_component{};
+
+		component.component_id = update_info.id;
+		component.component_data = update_info.data.data();
+
+		updates.push_back(component);
+	}
+
+	options.actions = actions.data();
+	options.actions_length = actions.size();
+
+	options.add_components = adds.data();
+	options.add_components_entities = adds_entities.data();
+	options.add_components_length = adds.size();
+
+	options.update_components = updates.data();
+	options.update_components_entities = updates_entities.data();
+	options.update_components_length = updates.size();
+
+	options.remove_components = remove_ids.data();
+	options.remove_components_entities = removes_entities.data();
+	options.remove_components_length = remove_ids.size();
+
+	return options;
+}

reference/async_reference/detail/c_execution_options/c_execution_options.hh

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <vector>
+#include <optional>
+
+#include "ecsact/runtime/core.h"
+#include "ecsact/runtime/async.h"
+
+namespace detail {
+
+template<typename T>
+struct data_info {
+	T id;
+
+	std::vector<std::byte> data;
+};
+
+struct c_execution_options {
+	/**
+	 * Holds the data lifetime used to reconstruct components and actions
+	 * Do NOT use this, it's an implementation detail
+	 */
+	std::vector<data_info<ecsact_action_id>>    actions_info;
+	std::vector<data_info<ecsact_component_id>> adds_info;
+	std::vector<ecsact_entity_id>               adds_entities;
+	std::vector<data_info<ecsact_component_id>> updates_info;
+	std::vector<ecsact_entity_id>               updates_entities;
+	std::vector<ecsact_component_id>            remove_ids;
+	std::vector<ecsact_entity_id>               removes_entities;
+
+	ecsact_execution_options c();
+
+private:
+	ecsact_execution_options options;
+
+	std::vector<ecsact_action>    actions;
+	std::vector<ecsact_component> adds;
+	std::vector<ecsact_component> updates;
+};
+} // namespace detail