Execution/EventDispatcher: subscribe: Multiple events

Author: MorganCaron

modules/Execution/EventDispatcher.mpp

@@ -31,15 +31,23 @@ export namespace CppUtils::Execution
 			}
 		}
 
-		template<String::Hasher eventName = Type::Hash{}>
+		template<String::Hasher... eventNames>
 		inline auto subscribe(auto&& function) -> void
+		{
+			if constexpr (sizeof...(eventNames) == 0)
+				subscribe(Type::Hash{}, std::forward<decltype(function)>(function));
+			else
+				(subscribe(static_cast<Type::Hash>(eventNames), function), ...);
+		}
+
+		inline auto subscribe(Type::Hash eventHash, auto&& function) -> void
 		{
 			using FunctionType = std::decay_t<decltype(function)>;
 			using ArgumentsTypes = typename Type::CallableTrait<FunctionType>::ArgumentsTypes;
 			[&]<class... Args>(std::tuple<Args...>*) {
 				using Tuple = std::tuple<std::remove_cvref_t<Args>...>;
 				auto lockGuard = std::unique_lock{m_mutex};
-				auto key = std::make_pair(static_cast<Type::Hash>(eventName), std::type_index{typeid(Tuple)});
+				auto key = std::make_pair(eventHash, std::type_index{typeid(Tuple)});
 				m_subscribers[key].emplace_back(
 					[function = std::forward<decltype(function)>(function)](const void* payload) mutable -> void {
 					const auto& args = *static_cast<const Tuple*>(payload);

modules/Execution/EventQueue.mpp

@@ -46,10 +46,10 @@ export namespace CppUtils::Execution
 			enqueue(std::move(task));
 		}
 
-		template<String::Hasher eventName = Type::Hash{}>
+		template<String::Hasher... eventNames>
 		inline auto subscribe(auto&& function) -> void
 		{
-			m_dispatcher.subscribe<eventName>(std::forward<decltype(function)>(function));
+			m_dispatcher.subscribe<eventNames...>(std::forward<decltype(function)>(function));
 		}
 
 		template<Chrono::Duration Duration = std::chrono::milliseconds>

modules/Log/Logger.mpp

@@ -54,10 +54,10 @@ export namespace CppUtils
 			emit<logType>(std::format(fmt, std::forward<Args>(args)...));
 		}
 
-		template<String::Hasher logType = Type::Hash{}>
+		template<String::Hasher... logTypes>
 		static inline auto subscribe(auto&& function) -> void
 		{
-			eventQueue().template subscribe<logType>(std::forward<decltype(function)>(function));
+			eventQueue().template subscribe<logTypes...>(std::forward<decltype(function)>(function));
 		}
 
 		template<Chrono::Duration Duration = std::chrono::milliseconds>

modules/Thread/AsyncEventDispatcher.mpp

@@ -33,10 +33,10 @@ export namespace CppUtils::Thread
 			});
 		}
 
-		template<String::Hasher eventName = Type::Hash{}>
+		template<String::Hasher... eventNames>
 		inline auto subscribe(auto&& function) -> void
 		{
-			m_eventDispatcher.subscribe<eventName>(std::forward<decltype(function)>(function));
+			m_eventDispatcher.subscribe<eventNames...>(std::forward<decltype(function)>(function));
 		}
 
 		inline auto waitUntilFinished() -> void

modules/Thread/ScheduledEventDispatcher.mpp

@@ -46,10 +46,10 @@ export namespace CppUtils::Thread
 			m_scheduler{step, numberThreads, std::move(onError), std::move(finally)}
 		{}
 
-		template<String::Hasher eventName = Type::Hash{}>
+		template<String::Hasher... eventNames>
 		inline auto subscribe(auto&& function) -> void
 		{
-			m_eventDispatcher.subscribe<eventName>(std::forward<decltype(function)>(function));
+			m_eventDispatcher.subscribe<eventNames...>(std::forward<decltype(function)>(function));
 		}
 
 		template<String::Hasher eventName = Type::Hash{}, class... Args, Chrono::Duration Delay = std::chrono::milliseconds>

tests/Execution/EventDispatcher.mpp

@@ -117,13 +117,29 @@ namespace CppUtils::UnitTest::Execution::EventDispatcher
 			auto eventDispatcher = CppUtils::Execution::EventDispatcher{};
 
 			eventDispatcher.subscribe<"Count">([count = 0, &suite](int expected) mutable {
-				count++;
+				++count;
 				suite.expectEqual(count, expected);
 			});
 
 			eventDispatcher.emit<"Count">(1);
 			eventDispatcher.emit<"Count">(2);
 			eventDispatcher.emit<"Count">(3);
 		});
+
+		suite.addTest("Multiple subscribe", [&] {
+			auto eventDispatcher = CppUtils::Execution::EventDispatcher{};
+			auto count = std::atomic_size_t{0};
+
+			eventDispatcher.subscribe<"A", "B", "C">([&count] {
+				++count;
+			});
+
+			eventDispatcher.emit<"A">();
+			eventDispatcher.emit<"B">();
+			eventDispatcher.emit<"C">();
+			eventDispatcher.emit<"D">();
+
+			suite.expectEqual(count, 3uz);
+		});
 	}};
 }

tests/Execution/EventQueue.mpp

@@ -23,5 +23,21 @@ namespace CppUtils::UnitTest::Execution
 			suite.expect(received);
 			suite.expectEqual(valueReceived, 42);
 		});
+
+		suite.addTest("Multiple subscribe", [&] {
+			auto queue = CppUtils::Execution::EventQueue{};
+			auto count = 0uz;
+
+			queue.subscribe<"A", "B">([&count] {
+				++count;
+			});
+
+			queue.emit<"A">();
+			queue.emit<"B">();
+			queue.emit<"C">();
+
+			queue.waitUntilFinished();
+			suite.expectEqual(count, 2uz);
+		});
 	}};
 }

tests/Thread/AsyncEventDispatcher.mpp

@@ -69,5 +69,21 @@ namespace CppUtils::UnitTest::Thread::AsyncEventDispatcher
 			dispatcher.waitUntilFinished();
 			suite.expectEqual(result.load(), 42);
 		});
+
+		suite.addTest("Multiple subscribe", [&] {
+			auto dispatcher = CppUtils::Thread::AsyncEventDispatcher{};
+			auto count = std::atomic_size_t{0};
+
+			dispatcher.subscribe<"A", "B">([&count] {
+				++count;
+			});
+
+			dispatcher.emit<"A">();
+			dispatcher.emit<"B">();
+			dispatcher.emit<"C">();
+
+			dispatcher.waitUntilFinished();
+			suite.expectEqual(count, 2uz);
+		});
 	}};
 }