From 06f1d48de47d1742eba5a759c2ae7465982a3309 Mon Sep 17 00:00:00 2001
From: Vraiment <jemc44@gmail.com>
Date: Sat, 5 Aug 2017 23:08:12 -0700
Subject: [PATCH] Added basic event dispatching (needs event types
 specialization)

---
 SDL2pp/Private/EventDispatching.hh | 27 +++++++-------
 tests/CMakeLists.txt               |  1 +
 tests/test_eventdispatching.cc     | 57 ++++++++++++++++++++++++++++++
 3 files changed, 72 insertions(+), 13 deletions(-)
 create mode 100644 tests/test_eventdispatching.cc

diff --git a/SDL2pp/Private/EventDispatching.hh b/SDL2pp/Private/EventDispatching.hh
index 6b671a6..7299bca 100644
--- a/SDL2pp/Private/EventDispatching.hh
+++ b/SDL2pp/Private/EventDispatching.hh
@@ -28,35 +28,36 @@
 
 #include <SDL_events.h>
 
+#include <iostream>
+using namespace std;
+
 namespace SDL2pp {
 namespace Private
 {
 	template <typename EventHandler>
-	auto DispatchEvent(const SDL_Event &event, EventHandler&& eventHandler) -> std::enable_if<IsEventHandlerFunctor<EventHandler, SDL_Event>::value>
-	{
-		eventHandler(event);
-	}
-	
-	template <typename EventHandler>
-	auto DispatchEvent(const SDL_Event &event, EventHandler&& eventHandler) -> std::enable_if<IsEventHandlerObject<EventHandler, SDL_Event>::value>
+	auto DispatchSpecificEvent(const SDL_Event &event, EventHandler&& eventHandler) -> typename std::enable_if<IsEventHandlerObject<EventHandler, SDL_Event>::value>::type
 	{
 		eventHandler.HandleEvent(event);
 	}
 	
 	template <typename EventHandler>
-	auto DispatchEvent(const SDL_Event&, EventHandler&&) -> std::enable_if<!IsEventHandler<EventHandler, SDL_Event>::value>
+	auto DispatchSpecificEvent(const SDL_Event &event, EventHandler&& eventHandler) -> typename std::enable_if<IsEventHandlerFunctor<EventHandler, SDL_Event>::value>::type
 	{
-		static_assert(!IsEventHandler<EventHandler, SDL_Event>::value, "One of the given values is not a valid event handler");
+		eventHandler(event);
+	}
+	
+	template <typename EventHandler>
+	auto DispatchSpecificEvent(const SDL_Event &, EventHandler&&) -> typename std::enable_if<!IsEventHandler<EventHandler, SDL_Event>::value>::type
+	{
+		static_assert(IsEventHandler<EventHandler, SDL_Event>::value, "Event handler is not a valid functor or object");
 	}
 
 	template <typename... EventHandlers>
-	void DispatchEvent(const SDL_Event & event, EventHandlers&&... eventHandlers) {
-		DispatchEvent(event, eventHandlers...);
-	}
+	void DispatchEvent(const SDL_Event &, EventHandlers&&...);
 	
 	template <typename EventHandler, typename... EventHandlers>
 	void DispatchEvent(const SDL_Event &event, EventHandler&& eventHandler, EventHandlers&&... eventHandlers) {
-		DispatchEvent(event, eventHandler);
+		DispatchSpecificEvent(event, eventHandler);
 		DispatchEvent(event, eventHandlers...);
 	}
 	
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index a66c299..e8a9cfc 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -3,6 +3,7 @@ SET(CLI_TESTS
 	test_color
 	test_color_constexpr
 	test_error
+	test_eventdispatching
 	test_eventhandler
 	test_optional
 	test_pointrect
diff --git a/tests/test_eventdispatching.cc b/tests/test_eventdispatching.cc
new file mode 100644
index 0000000..e7fca38
--- /dev/null
+++ b/tests/test_eventdispatching.cc
@@ -0,0 +1,57 @@
+#include <SDL_main.h>
+
+#include <SDL2pp/Private/EventDispatching.hh>
+
+#include "testing.h"
+
+using namespace SDL2pp::Private;
+
+static auto globalResult = Sint32{0};
+
+inline void handler(SDL_Event event)
+{
+	globalResult = event.user.code;
+}
+
+BEGIN_TEST(int, char*[])
+
+SDL_Event event;
+event.type = SDL_USEREVENT;
+event.user.code = 31;
+
+DispatchEvent(event);
+
+auto result = Sint32{0};
+DispatchEvent(event, [&result](SDL_Event event) {
+	result = event.user.code;
+});
+EXPECT_EQUAL(event.user.code, result);
+
+DispatchEvent(event, handler);
+EXPECT_EQUAL(event.user.code, globalResult);
+
+struct EventHandlerFunctor {
+	Sint32 result;
+
+	void operator()(SDL_Event event) {
+		result = event.user.code;
+	}
+};
+
+auto eventHandlerFunctor = EventHandlerFunctor{};
+DispatchEvent(event, eventHandlerFunctor);
+EXPECT_EQUAL(event.user.code, eventHandlerFunctor.result);
+
+struct EventHandlerObject {
+	Sint32 result;
+
+	void HandleEvent(SDL_Event event) {
+		result = event.user.code;
+	}
+};
+
+auto eventHandlerObject = EventHandlerObject{};
+DispatchEvent(event, eventHandlerObject);
+EXPECT_EQUAL(event.user.code, eventHandlerObject.result);
+
+END_TEST()