Refactor Event class to support any delegate type.

include/Event.h

@@ -1,5 +1,5 @@
-/// @file        Event.hpp
-/// @description Templated Event Hook Class modeled after C# events
+/// @file        BasicEvent.hpp
+/// @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>
-class EventConnection;
-
-template <typename ... Args>
-class Event {
+/// BasicEvent is a templated class that can be used to raise events that can be listened in on
+/// 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'.
+/// @param Args... The arguments that will be expected by this event and passed to it's delegate.
+template <typename delegate, typename ... Args>
+class BasicEvent {
 public:
-    using delegate = std::function<void(Args...)>;
-    using connection = EventConnection<Args ...>;
+    using connection = Connection<delegate, 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>
-EventConnection<Args...> Event<Args...>::operator+=(Event::delegate callback) { return Connect(callback); }
+template<typename delegate, typename... Args>
+Connection<delegate, Args...> BasicEvent<delegate, Args...>::operator+=(delegate callback) { return Connect(callback); }
 
-template<typename... Args>
-void Event<Args...>::operator()(Args... args) { Invoke(args...);}
+template<typename delegate, typename... Args>
+void BasicEvent<delegate, Args...>::operator()(Args... args) { Invoke(args...);}
 
-template <typename ... Args>
-void Event<Args...>::Invoke(Args... args) {
+template <typename delegate, typename ... Args>
+void BasicEvent<delegate, Args...>::Invoke(Args... args) {
     for (event_ptr &connection_ptr: this->listeners) {
         connection_ptr->Invoke(args...);
     }
 }
 
-template <typename ... Args>
-EventConnection<Args...>  Event<Args...>::Connect(delegate callback)
+template <typename delegate, typename ... Args>
+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>
-void Event<Args...>::Disconnect(connection &conn) {
+template <typename delegate, typename ... Args>
+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>
-class Event;
+template <typename delegate, typename ... Args>
+class BasicEvent;
 
-template <typename ... Args>
-class EventConnection {
+/// A type that represents a handle to an active event connection.
+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>
-EventConnection<Args...>::EventConnection(Event<Args...> *creator, EventConnection::delegate cb) : owner(creator), callback(std::move(cb)) {}
+template<typename delegate, typename... Args>
+Connection<delegate, Args...>::Connection(BasicEvent<delegate, Args...> *creator, delegate cb) : owner(creator), callback(std::move(cb)) {}
 
 
-template <typename... Args>
-void EventConnection<Args...>::Invoke(Args... e) { callback(e...); }
+template <typename delegate, typename... Args>
+void Connection<delegate, Args...>::Invoke(Args... e) { callback(e...); }
 
-template <typename ... Args>
-bool EventConnection<Args...>::Disconnect() {
+template <typename delegate, typename ... Args>
+bool Connection<delegate, Args...>::Disconnect() {
     if (active) {
         owner->Disconnect(this);
         active = false;