feat: implement new async session api

.bazelversion

@@ -1 +1 @@
-7.3.0
+7.5.0

MODULE.bazel

@@ -4,18 +4,29 @@ module(
     compatibility_level = 1,
 )
 
-bazel_dep(name = "rules_cc", version = "0.0.9")
-bazel_dep(name = "ecsact_runtime", version = "0.7.0")
-bazel_dep(name = "ecsact_codegen", version = "0.4.3")
-bazel_dep(name = "ecsact_lang_cpp", version = "0.4.10")
-bazel_dep(name = "rules_ecsact", version = "0.5.8")
-bazel_dep(name = "ecsact_cli", version = "0.3.19")
+bazel_dep(name = "rules_cc", version = "0.0.17")
+bazel_dep(name = "ecsact_runtime", version = "0.8.1")
+
+# NOTE: I don't know why this is necessary. The compatibility error is very unclear.
+# Possibly due to this? https://github.com/bazelbuild/bazel/issues/22972
+single_version_override(
+    module_name = "ecsact_runtime",
+    version = "0.8.1",
+)
+
+bazel_dep(name = "ecsact_codegen", version = "0.4.4")
+bazel_dep(name = "ecsact_lang_cpp", version = "0.4.11")
+bazel_dep(name = "rules_ecsact", version = "0.5.9")
+bazel_dep(name = "ecsact_cli", version = "0.3.23")
 bazel_dep(name = "bazel_skylib", version = "1.4.2")
 bazel_dep(name = "boost.process", version = "1.83.0.bzl.2")
 bazel_dep(name = "boost.dll", version = "1.83.0.bzl.2")
 
 bazel_dep(name = "toolchains_llvm", version = "1.0.0", dev_dependency = True)
 bazel_dep(name = "hedron_compile_commands", dev_dependency = True)
+
+bazel_dep(name = "docopt.cpp", version = "0.6.2")
+
 git_override(
     module_name = "hedron_compile_commands",
     commit = "204aa593e002cbd177d30f11f54cff3559110bb9",

async_reference/BUILD.bazel

@@ -12,19 +12,18 @@ ecsact_build_recipe(
         "ecsact_deserialize_action",
         "ecsact_deserialize_component",
         "ecsact_execute_systems",
-        "ecsact_get_component",
         "ecsact_serialize_action",
         "ecsact_serialize_action_size",
         "ecsact_serialize_component",
         "ecsact_serialize_component_size",
         "ecsact_stream",
     ],
     exports = [
-        "ecsact_async_connect",
-        "ecsact_async_disconnect",
         "ecsact_async_enqueue_execution_options",
         "ecsact_async_flush_events",
         "ecsact_async_get_current_tick",
+        "ecsact_async_start",
+        "ecsact_async_stop",
         "ecsact_async_stream",
     ],
 )

async_reference/async.cc

@@ -1,6 +1,7 @@
 #include <optional>
 #include <stdarg.h>
 #include <span>
+#include <map>
 #include "ecsact/runtime/async.h"
 #include "async_reference/async_reference.hh"
 #include "async_reference/callbacks/async_callbacks.hh"
@@ -11,87 +12,121 @@ using namespace ecsact::async_reference;
 // NOTE: These are the singletons for managing the reference library state.
 //       This file should be small. Declare a few variables and call a few
 //       functions in the C function bodies. Keep the logic minimal.
-static auto async_callbacks = detail::async_callbacks{};
+static auto async_callbacks =
+	std::map<ecsact_async_session_id, detail::async_callbacks>{};
 static auto request_id_factory = detail::request_id_factory{};
+static auto last_session_id = ecsact_async_session_id{};
 static auto reference = std::optional<detail::async_reference>{};
 
-ecsact_async_request_id ecsact_async_connect(const char* connection_string) {
-	auto req_id = request_id_factory.next_id();
-	reference.emplace(async_callbacks);
-	reference->connect(req_id, connection_string);
-	return req_id;
+static auto generate_next_session_id() -> ecsact_async_session_id {
+	return static_cast<ecsact_async_session_id>(
+		++reinterpret_cast<int32_t&>(last_session_id)
+	);
 }
 
-void ecsact_async_disconnect() {
-	if(reference) {
-		reference->disconnect();
-		reference.reset();
+auto ecsact_async_start( //
+	const void* option_data,
+	int32_t     option_data_size
+) -> ecsact_async_session_id {
+	if(!reference) {
+		reference.emplace(async_callbacks);
 	}
+
+	auto session_id = generate_next_session_id();
+	auto connect_str = std::string_view{};
+	if(option_data && option_data_size > 0) {
+		connect_str = std::string_view{
+			static_cast<const char*>(option_data),
+			static_cast<size_t>(option_data_size)
+		};
+	}
+
+	reference->start(session_id, connect_str);
+
+	return session_id;
 }
 
-void ecsact_async_flush_events(
+auto ecsact_async_stop(ecsact_async_session_id session_id) -> void {
+	if(!reference) {
+		return;
+	}
+
+	reference->stop(session_id);
+
+	if(reference->session_count() == 0) {
+		reference = std::nullopt;
+	}
+}
+
+auto ecsact_async_flush_events(
+	ecsact_async_session_id                  session_id,
 	const ecsact_execution_events_collector* execution_evc,
 	const ecsact_async_events_collector*     async_evc
-) {
-	async_callbacks.invoke(async_evc);
-	if(reference) {
-		reference->invoke_execution_events(execution_evc);
+) -> void {
+	if(!reference) {
+		async_callbacks[session_id].invoke(session_id, async_evc);
+		return;
 	}
+
+	reference->flush_events(session_id, execution_evc, async_evc);
+	async_callbacks[session_id].invoke(session_id, async_evc);
 }
 
-ecsact_async_request_id ecsact_async_enqueue_execution_options(
+auto ecsact_async_enqueue_execution_options(
+	ecsact_async_session_id        session_id,
 	const ecsact_execution_options options
-) {
+) -> ecsact_async_request_id {
 	auto req_id = request_id_factory.next_id();
 	if(!reference) {
-		async_callbacks.add(detail::types::async_error{
+		async_callbacks[session_id].add(detail::types::async_error{
 			.error = ECSACT_ASYNC_ERR_NOT_CONNECTED,
 			.request_ids = {req_id},
 		});
 		return req_id;
 	}
 
-	reference->enqueue_execution_options(req_id, options);
+	reference->enqueue_execution_options(session_id, req_id, options);
+
 	return req_id;
 }
 
-int32_t ecsact_async_get_current_tick() {
-	if(reference) {
-		return reference->get_current_tick();
+auto ecsact_async_get_current_tick( //
+	ecsact_async_session_id session_id
+) -> int32_t {
+	if(!reference) {
+		return 0;
 	}
-	return 0;
+	return reference->get_current_tick(session_id);
 }
 
-ecsact_async_request_id ecsact_async_stream(
-	ecsact_entity_id    entity,
-	ecsact_component_id component_id,
-	const void*         component_data,
-	const void*         indexed_fields
-) {
-	auto req_id = request_id_factory.next_id();
-	// TODO: indexed fields
+auto ecsact_async_stream(
+	ecsact_async_session_id session_id,
+	ecsact_entity_id        entity,
+	ecsact_component_id     component_id,
+	const void*             component_data,
+	const void*             indexed_fields
+) -> void {
 	if(indexed_fields != nullptr) {
-		async_callbacks.add(detail::types::async_error{
+		async_callbacks[session_id].add(detail::types::async_error{
 			.error = ECSACT_ASYNC_ERR_INTERNAL,
-			.request_ids = {req_id},
+			.request_ids = {ECSACT_INVALID_ID(async_request)},
 		});
-		return req_id;
+		return;
 	}
 
 	if(!reference) {
-		async_callbacks.add(detail::types::async_error{
+		async_callbacks[session_id].add(detail::types::async_error{
 			.error = ECSACT_ASYNC_ERR_NOT_CONNECTED,
-			.request_ids = {req_id},
+			.request_ids = {ECSACT_INVALID_ID(async_request)},
 		});
-		return req_id;
+		return;
 	}
 
 	reference->stream( //
-		req_id,
+		session_id,
 		entity,
 		component_id,
 		component_data,
 		indexed_fields
 	);
-	return req_id;
 }