Implement support for connecting void-args functions on Events. The use case is to shorten the function signature in cases where the user does not care about the event arguments.

# Conflicts:
#	include/Event.h
#	main.cpp

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.18..3.27)
 project(Event
     VERSION 1.0
     LANGUAGES CXX

README.md

@@ -0,0 +1,98 @@
+# Event
+### A C++20 Event system inspired by C# syntax.
+![](https://img.shields.io/badge/Redacted-Software-black)
+![Static Badge](https://img.shields.io/badge/Lit-Based-%20)
+![C++](https://img.shields.io/badge/C%2B%2B-20-blue)
+[![License: Unlicense](https://img.shields.io/badge/license-Unlicense-blue)](http://unlicense.org/)
+
+## Features
+* Fast
+  * (TODO: Profile!)
+* Flexible
+  * Event delegate can be of any ![FunctionObject](https://en.cppreference.com/w/cpp/named_req/FunctionObject) type.
+  * Supports any set of parameters via templates.
+* Easy To Use
+  * Written in portable and standard C++, no hacks or quirks.
+  * Utilizes Modern C++ features for elegant design.
+  * Zero dependencies. Fully self-contained.
+* Unrestricted
+  * No GNU Copyleft communism. Totally Free & Public Domain.
+
+## Coming Soon
+
+* Event Filters / Policy
+* Asynchronous
+* Thread-Safe Version
+* Priority Queue
+* Auto disconnecting
+
+## Supported Compilers
+
+* GCC 14.2.1 (RedHat)
+* MSVC 19.40
+
+## Usage
+
+This project is designed to be integrated via [CMake Package Manager](https://github.com/cpm-cmake/CPM.cmake).
+
+```cmake
+CPMAddPackage(
+        NAME Event
+        URL https://git.redacted.cc/josh/Event/archive/Release-7.zip
+)
+```
+This snippet will automatically download a stable release of Event into your project's build directory, so it won't clutter your sources.
+
+Take note of the release version and make sure it's the latest available in the Releases tab above.
+
+```cmake
+target_include_directories(${PROJECT_NAME} PUBLIC ${Event_SOURCE_DIR}/include)
+target_link_libraries(${PROJECT_NAME} PUBLIC Event)
+```
+
+This snippet will import the headers, and then link the library to your library/executable. You should now be able to use Event.
+
+The C++ snippet below reads input from the terminal and fires an event that received the input message.
+
+```cpp
+#include <Event.h>
+#include <EventConnection.h>
+
+void ReadMessage(const std::string& message) {
+    std::cout << "Received: " << message << std::endl;
+}
+
+int main()
+{
+    Event<std::string> OnInput; // This and the declaration below are equivalent.
+    BasicEvent<std::function<void(std::string)>, std::string> OnInput2;
+    bool running = true;
+    while (running) {
+        std::string input;
+        std::cin >> input;
+        OnInput.Invoke(input);
+        OnInput(input); // Call operator is defined as well.
+    }
+    return 0;
+}
+
+More advanced examples can be found in the main.cpp file.
+
+```
+
+## Documentation
+
+Documentation is automatically generated from latest commit and is hosted at https://doc.redacted.cc/event .
+
+## Contributing
+
+Contributions to this project are welcome! If you find a bug, have a feature request, or would like to contribute code, please submit an issue or pull request to the GitHub repository.
+
+## License
+
+Event is expressly licensed to the Public Domain under the Unlicense. See the LICENSE file for details.
+
+## Acknowledgements
+
+Event is developed and maintained by Joshua O'Leary @ Redacted Software, and contributors.
+Special thanks to Maxine Hayes.

include/Event.h

@@ -1,8 +1,8 @@
-/// @file        Event.hpp
-/// @description Templated Event Hook Class modeled after C# events
+/// @file        Connection.hpp
+/// @description Callback handler for event connections
 /// @author      Josh O'Leary - Redacted Software
 /// @revision    3
-/// @lastedit    2024-06-01
+/// @lastedit    2024-02-21
 /// @license     Unlicense - Public Domain
 
 #pragma once
@@ -11,53 +11,101 @@
 #include <functional>
 #include <memory>
 
-// TODO: Document & Explain this
-
-#include <EventConnection.h>
-
-template <typename ... Args>
-class EventConnection;
-
-template <typename ... Args>
-class Event {
+/// A delegate can be any function object or function-like object. The Args are the arguments accepted by that object
+template <typename delegate, typename ... Args>
+class BasicEvent {
 public:
-    using delegate = std::function<void(Args...)>;
-    using connection = EventConnection<Args ...>;
-    using event_ptr = std::shared_ptr<connection>;
+    /// A type that represents a handle to an active event connection.
+    class Connection {
+    public:
+        Connection(BasicEvent<delegate, Args...> *creator, delegate cb);
+        bool Disconnect(); // Breaks the event connection, but does not destroy the instance
+        // If improperly used could lead to run away events? - Maxine
+        void Invoke(Args... e);
+    public:
+        // This is made public in the case of function-like objects which store extra data.
+        // This allows us to access members of the object when desired. See JTest's usage of the event system for an example.
+        delegate callback;
+    private:
+        BasicEvent<delegate, Args...> *owner;
+        bool active = true;
+    };
+
+    using EventPtr = std::shared_ptr<Connection>;
 public:
-    void Await(Args& ... arg);
-    void Invoke(Args... args);
+    // See JTest Unit for why making this virtual is convenient
+    virtual void Invoke(Args... args);
     void operator()(Args... args);
-    connection Connect(delegate callback);
-    void Disconnect(connection &conn);
-    connection operator+=(delegate callback);
-private:
-    std::vector<event_ptr> listeners;
-    uint64_t listenerCounter = 0;
+    Connection Connect(delegate callback);
+    void Disconnect(Connection &conn);
+    Connection operator+=(delegate callback);
+
+    /// Also support binding callbacks that don't read in arguments, as a shorthand.
+    // TODO: No need to wrap the callback if the template args type is void.
+    Connection Connect(const std::function<void()>& default_callback);
+    /// Also support binding callbacks that don't read in arguments, as a shorthand.
+    // TODO: No need to wrap the callback if the template args type is void.
+    Connection operator += (const std::function<void()>& default_callback);
+
+protected:
+    std::vector<EventPtr> listeners;
 };
 
-template<typename... Args>
-EventConnection<Args...> Event<Args...>::operator+=(Event::delegate callback) { return Connect(callback); }
+template<typename delegate, typename... Args>
+BasicEvent<delegate, Args...>::Connection::Connection(BasicEvent<delegate, Args...> *creator, delegate cb) : owner(creator), callback(std::move(cb)) {}
 
-template<typename... Args>
-void Event<Args...>::operator()(Args... args) { Invoke(args...);}
+template <typename delegate, typename... Args>
+void BasicEvent<delegate, Args...>::Connection::Invoke(Args... e) { callback(e...); }
 
-template <typename ... Args>
-void Event<Args...>::Invoke(Args... args) {
-    for (event_ptr &connection_ptr: this->listeners) {
+template <typename delegate, typename ... Args>
+bool BasicEvent<delegate, Args...>::Connection::Disconnect() {
+    if (active) {
+        owner->Disconnect(this);
+        active = false;
+        return true;
+    }
+    return false;
+}
+
+template<typename delegate, typename... Args>
+BasicEvent<delegate, Args...>::Connection BasicEvent<delegate, Args...>::operator+=(delegate callback) { return Connect(callback); }
+
+template<typename delegate, typename ... Args>
+typename BasicEvent<delegate, Args...>::Connection BasicEvent<delegate, Args...>::Connect(
+    const std::function<void()> &default_callback) {
+    delegate wrapper = [default_callback] (Args... args) { default_callback(); };
+    return Connect(wrapper);
+}
+
+template<typename delegate, typename ... Args>
+typename BasicEvent<delegate, Args...>::Connection BasicEvent<delegate, Args...>::operator+=(
+    const std::function<void()> &default_callback) {
+    return Connect(default_callback);
+}
+
+template<typename delegate, typename... Args>
+void BasicEvent<delegate, Args...>::operator()(Args... args) { Invoke(args...); }
+
+template <typename delegate, typename ... Args>
+void BasicEvent<delegate, Args...>::Invoke(Args... args) {
+    for (EventPtr &connection_ptr: this->listeners) {
         connection_ptr->Invoke(args...);
     }
 }
 
-template <typename ... Args>
-EventConnection<Args...>  Event<Args...>::Connect(delegate callback)
-{
-    event_ptr retval(new connection(this, callback));
+template <typename delegate, typename ... Args>
+BasicEvent<delegate, Args...>::Connection BasicEvent<delegate, Args...>::Connect(delegate callback) {
+    EventPtr 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(BasicEvent<delegate, Args...>::Connection &conn) {
     listeners.erase(std::remove(listeners.begin(), listeners.end(), 99), listeners.end());
-}
+}
+
+/// Event is a generic event type. It is more often we will be using a void function rather than a function-like object.
+template <typename ... Args>
+using Event = BasicEvent<std::function<void(Args...)>, Args...>;
+

include/EventConnection.h

@@ -1,45 +0,0 @@
-/// @file        EventConnection.hpp
-/// @description Callback handler for event connections
-/// @author      Josh O'Leary - Redacted Software
-/// @revision    3
-/// @lastedit    2024-02-21
-/// @license     Unlicense - Public Domain
-
-#pragma once
-
-#include <functional>
-#include <Event.h>
-
-template <typename ... Args>
-class Event;
-
-template <typename ... Args>
-class EventConnection {
-private:
-    using delegate = std::function<void(Args...)>;
-public:
-    EventConnection(Event<Args...> *creator, delegate cb);
-    bool Disconnect(); // Breaks the event connection, but does not destroy the instance
-    void Invoke(Args... e);
-private:
-    Event<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... Args>
-void EventConnection<Args...>::Invoke(Args... e) { callback(e...); }
-
-template <typename ... Args>
-bool EventConnection<Args...>::Disconnect() {
-    if (active) {
-        owner->Disconnect(this);
-        active = false;
-        return true;
-    }
-    return false;
-}

main.cpp

@@ -1,15 +1,20 @@
 #include <iostream>
-
+#include <functional>
 #include <Event.h>
+//#include <EventConnection.h>
+//#include "bullshit.h"
+#include "stack"
 
 void ProcessMessage(const std::string& message)
 {
     std::cout << "Received: " << message << std::endl;
 }
 
-int main() {
+// TODO: BasicEvent tests here.
 
-    Event<std::string> OnMessage;
+int main() {
+    BasicEvent<std::function<void(std::string)>, std::string> OnMessage;
+    BasicEvent<std::function<void()>> VoidDelegate;
 
     bool run = true;
 
@@ -19,13 +24,21 @@ int main() {
     };
     auto handler2 = OnMessage += ProcessMessage;
 
+    auto handler3 = OnMessage += [&] {
+        std::cout << "Connect to event, with default callback, if we don't care about using the provided arguments." << std::endl;
+    };
+
     while (run)
     {
         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>
+#include <Event.h>
+
+

src/EventConnection.cpp

@@ -1 +0,0 @@
-#include <EventConnection.h>