Refactor Event class to support any delegate type.

CMakeLists.txt

@@ -14,16 +14,14 @@ if (WIN32)
     set(CMAKE_CXX_FLAGS "-municode")
 endif()
 
+
 file(GLOB_RECURSE SOURCES "src/*.cpp")
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
-include_directories("include")
+include_directories(${PROJECT_SOURCE_DIR}/include)
 
-add_library(Event SHARED ${SOURCES}
+add_library(Event SHARED ${SOURCES})
-        src/Event.cpp
-        include/EventConnection.h
-        src/EventConnection.cpp)
 
 set_target_properties(Event PROPERTIES LINKER_LANGUAGE CXX)
 

include/Event.h

@@ -1,5 +1,5 @@
-/// @file        Event.hpp
+/// @file        BasicEvent.hpp
-/// @description Templated Event Hook Class modeled after C# events
+/// @description Templated BasicEvent Hook Class modeled after C# events
 /// @author      Josh O'Leary - Redacted Software
 /// @revision    3
 /// @lastedit    2024-02-21
@@ -10,18 +10,21 @@
 #include <chrono>
 #include <functional>
 
-// TODO: Document & Explain this
+// TODO: ThreadSafeEvent / AsyncEvent version of the class.
+// TODO: ConsumableEvent - a version that can be "consumed" by a callback by returning true. It will be sunk and not passed to further callbacks.
 
-#include <EventConnection.h>
+///
+template <typename delegate, typename ... Args>
+class Connection;
 
-template <typename ... Args>
+/// BasicEvent is a templated class that can be used to raise events that can be listened in on
-class EventConnection;
+/// at other points in a codebase without having to tightly couple the two pieces of code.
-
+/// @param delegate A type that can be invoked via operator() 'Call operator'.
-template <typename ... Args>
+/// @param Args... The arguments that will be expected by this event and passed to it's delegate.
-class Event {
+template <typename delegate, typename ... Args>
+class BasicEvent {
 public:
-    using delegate = std::function<void(Args...)>;
+    using connection = Connection<delegate, Args ...>;
-    using connection = EventConnection<Args ...>;
     using event_ptr = std::shared_ptr<connection>;
 public:
     void Await(Args& ... arg);
@@ -35,28 +38,32 @@ private:
     uint64_t listenerCounter = 0;
 };
 
-template<typename... Args>
+template<typename delegate, typename... Args>
-EventConnection<Args...> Event<Args...>::operator+=(Event::delegate callback) { return Connect(callback); }
+Connection<delegate, Args...> BasicEvent<delegate, Args...>::operator+=(delegate callback) { return Connect(callback); }
 
-template<typename... Args>
+template<typename delegate, typename... Args>
-void Event<Args...>::operator()(Args... args) { Invoke(args...);}
+void BasicEvent<delegate, Args...>::operator()(Args... args) { Invoke(args...);}
 
-template <typename ... Args>
+template <typename delegate, typename ... Args>
-void Event<Args...>::Invoke(Args... args) {
+void BasicEvent<delegate, Args...>::Invoke(Args... args) {
     for (event_ptr &connection_ptr: this->listeners) {
         connection_ptr->Invoke(args...);
     }
 }
 
-template <typename ... Args>
+template <typename delegate, typename ... Args>
-EventConnection<Args...>  Event<Args...>::Connect(delegate callback)
+Connection<delegate, Args...>  BasicEvent<delegate, Args...>::Connect(delegate callback)
 {
     event_ptr retval(new connection(this, callback));
     this->listeners.push_back(retval);
     return *retval;
 }
 
-template <typename ... Args>
+template <typename delegate, typename ... Args>
-void Event<Args...>::Disconnect(connection &conn) {
+void BasicEvent<delegate, Args...>::Disconnect(connection &conn) {
     listeners.erase(std::remove(listeners.begin(), listeners.end(), 99), listeners.end());
 }
+
+template <typename ... Args>
+using Event = BasicEvent<std::function<void(Args...)>, Args...>;
+

include/EventConnection.h

@@ -1,4 +1,4 @@
-/// @file        EventConnection.hpp
+/// @file        Connection.hpp
 /// @description Callback handler for event connections
 /// @author      Josh O'Leary - Redacted Software
 /// @revision    3
@@ -10,32 +10,32 @@
 #include <functional>
 #include <Event.h>
 
-template <typename ... Args>
+template <typename delegate, typename ... Args>
-class Event;
+class BasicEvent;
 
-template <typename ... Args>
+/// A type that represents a handle to an active event connection.
-class EventConnection {
+template <typename delegate, typename ... Args>
+class Connection {
 private:
-    using delegate = std::function<void(Args...)>;
 public:
-    EventConnection(Event<Args...> *creator, delegate cb);
+    Connection(BasicEvent<delegate, Args...> *creator, delegate cb);
     bool Disconnect(); // Breaks the event connection, but does not destroy the instance
     void Invoke(Args... e);
 private:
-    Event<Args...> * owner;
+    BasicEvent<delegate, Args...> * owner;
     delegate callback;
     bool active = true;
 };
 
-template<typename... Args>
+template<typename delegate, typename... Args>
-EventConnection<Args...>::EventConnection(Event<Args...> *creator, EventConnection::delegate cb) : owner(creator), callback(std::move(cb)) {}
+Connection<delegate, Args...>::Connection(BasicEvent<delegate, Args...> *creator, delegate cb) : owner(creator), callback(std::move(cb)) {}
 
 
-template <typename... Args>
+template <typename delegate, typename... Args>
-void EventConnection<Args...>::Invoke(Args... e) { callback(e...); }
+void Connection<delegate, Args...>::Invoke(Args... e) { callback(e...); }
 
-template <typename ... Args>
+template <typename delegate, typename ... Args>
-bool EventConnection<Args...>::Disconnect() {
+bool Connection<delegate, Args...>::Disconnect() {
     if (active) {
         owner->Disconnect(this);
         active = false;

main.cpp

@@ -1,15 +1,25 @@
 #include <iostream>
-
+#include <functional>
 #include <Event.h>
+#include <EventConnection.h>
 
 void ProcessMessage(const std::string& message)
 {
     std::cout << "Received: " << message << std::endl;
 }
 
+// TODO: Event tests here.
+
 int main() {
 
-    Event<std::string> OnMessage;
+    Event<int> cum;
+
+    cum += [] (int i) { std::cout << i+5 << std::endl; };
+
+    cum.Invoke(69);
+
+    BasicEvent<std::function<void(std::string)>, std::string> OnMessage;
+    BasicEvent<std::function<void()>> VoidDelegate;
 
     bool run = true;
 
@@ -24,7 +34,11 @@ int main() {
         std::string input;
         std::cin >> input;
         OnMessage.Invoke(input);
+        VoidDelegate.Invoke();
+        OnMessage(input);
+        VoidDelegate();
     }
 
+
     return 0;
 }

src/Event.cpp

@@ -1 +1,3 @@
 #include <Event.h>
+
+