fix: force inline for c++ wrappers

* this should help with some linking errors where the wrong ecsact function would be used

Author: zaucy

MODULE.bazel.lock

@@ -26,8 +26,8 @@ public:
 	 * Set async error callback. If callback is already set it will be
 	 * overwritten.
 	 */
-	auto set_async_error_callback(async_error_callback_t callback)
-		-> async_events_collector& {
+	auto set_async_error_callback(async_error_callback_t callback
+	) -> async_events_collector& {
 		_async_error_cb = std::move(callback);
 		return *this;
 	}
@@ -36,8 +36,8 @@ public:
 	 * Set async error callback. If callback is already set it will be
 	 * overwritten.
 	 */
-	auto set_system_error_callback(system_error_callback_t callback)
-		-> async_events_collector& {
+	auto set_system_error_callback(system_error_callback_t callback
+	) -> async_events_collector& {
 		_system_error_cb = std::move(callback);
 		return *this;
 	}
@@ -46,8 +46,8 @@ public:
 	 * Set async error callback. If callback is already set it will be
 	 * overwritten.
 	 */
-	auto set_async_requests_done_callback(async_requests_done_callback_t callback)
-		-> async_events_collector& {
+	auto set_async_requests_done_callback(async_requests_done_callback_t callback
+	) -> async_events_collector& {
 		_async_requests_done_cb = std::move(callback);
 		return *this;
 	}
@@ -136,49 +136,51 @@ private:
 	}
 };
 
-[[nodiscard]] inline auto connect(const std::string& connection_string)
-	-> ecsact_async_request_id {
+[[nodiscard]] ECSACT_ALWAYS_INLINE auto connect(
+	const std::string& connection_string
+) -> ecsact_async_request_id {
 	return ecsact_async_connect(connection_string.c_str());
 }
 
-inline auto disconnect() -> void {
+ECSACT_ALWAYS_INLINE auto disconnect() -> void {
 	ecsact_async_disconnect();
 }
 
-[[nodiscard]] inline auto get_current_tick() -> int32_t {
+[[nodiscard]] ECSACT_ALWAYS_INLINE auto get_current_tick() -> int32_t {
 	return ecsact_async_get_current_tick();
 }
 
-[[nodiscard]] inline auto enqueue_execution_options(
+[[nodiscard]] ECSACT_ALWAYS_INLINE auto enqueue_execution_options(
 	ecsact::core::execution_options& options
 ) -> ecsact_async_request_id {
 	return ecsact_async_enqueue_execution_options(options.c());
 }
 
-inline auto flush_events() -> void {
+ECSACT_ALWAYS_INLINE auto flush_events() -> void {
 	ecsact_async_flush_events(nullptr, nullptr);
 }
 
 template<typename ExecutionEventsCollector>
 	requires(std::convertible_to<
-					 decltype(std::declval<ExecutionEventsCollector>().c()),
-					 const ecsact_execution_events_collector>)
-inline auto flush_events(ExecutionEventsCollector&& evc) -> void {
+						decltype(std::declval<ExecutionEventsCollector>().c()),
+						const ecsact_execution_events_collector>)
+ECSACT_ALWAYS_INLINE auto flush_events(ExecutionEventsCollector&& evc) -> void {
 	const ecsact_execution_events_collector evc_c = evc.c();
 	ecsact_async_flush_events(&evc_c, nullptr);
 }
 
 template<typename AsyncEventsCollector>
 	requires(std::convertible_to<
-					 decltype(std::declval<AsyncEventsCollector>().c()),
-					 const ecsact_async_events_collector>)
-inline auto flush_events(AsyncEventsCollector&& async_evc) -> void {
+						decltype(std::declval<AsyncEventsCollector>().c()),
+						const ecsact_async_events_collector>)
+ECSACT_ALWAYS_INLINE auto flush_events(AsyncEventsCollector&& async_evc
+) -> void {
 	const ecsact_async_events_collector async_evc_c = async_evc.c();
 	ecsact_async_flush_events(nullptr, &async_evc_c);
 }
 
 template<typename ExecutionEventsCollector, typename AsyncEventsCollector>
-inline auto flush_events(
+ECSACT_ALWAYS_INLINE auto flush_events(
 	ExecutionEventsCollector&& evc,
 	AsyncEventsCollector&&     async_evc
 ) -> void {

ecsact/runtime/async.hh

@@ -27,6 +27,12 @@
 #	define ECSACT_IMPORT(ImportModule, ImportName)
 #endif
 
+#ifdef _MSC_VER
+#	define ECSACT_ALWAYS_INLINE __forceinline
+#else
+#	define ECSACT_ALWAYS_INLINE __attribute__((always_inline))
+#endif
+
 ECSACT_TYPED_ID(ecsact_package_id);
 ECSACT_TYPED_ID(ecsact_system_id);
 ECSACT_TYPED_ID(ecsact_action_id);
@@ -50,13 +56,13 @@ ECSACT_TYPED_ID(ecsact_component_like_id);
 #ifdef __cplusplus
 template<typename To, typename From>
 To ecsact_id_cast(From);
-#	define ECSACT_CAST_ID_FN(From, To)             \
-		template<>                                    \
-		inline To ecsact_id_cast<To, From>(From id) { \
-			return (To)id;                              \
+#	define ECSACT_CAST_ID_FN(From, To)                           \
+		template<>                                                  \
+		ECSACT_ALWAYS_INLINE To ecsact_id_cast<To, From>(From id) { \
+			return (To)id;                                            \
 		}
 #else
-inline int32_t ecsact_id_cast(int32_t id) {
+ECSACT_ALWAYS_INLINE int32_t ecsact_id_cast(int32_t id) {
 	return id;
 }
 
@@ -361,9 +367,8 @@ typedef int (*ecsact_action_compare_fn_t)(const void* a, const void* b);
  * necessary function. Any 32 bit integer >=0 is a valid placeholder entity ID.
  * Integers <0 are reserved as special placeholder IDs.
  */
-inline ecsact_placeholder_entity_id ecsact_util_make_placeholder_entity_id(
-	int32_t id
-) {
+ECSACT_ALWAYS_INLINE ecsact_placeholder_entity_id
+ecsact_util_make_placeholder_entity_id(int32_t id) {
 	return (ecsact_placeholder_entity_id)id;
 }