Add library with basic API

Author: KyrietS

.gitignore

@@ -0,0 +1,2 @@
+build/
+.idea/

CMakeLists.txt

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.11)
+
+project(tinyevents)
+
+set(CMAKE_CXX_STANDARD 17)
+add_library(tinyevents INTERFACE include/tinyevents/tinyevents.hpp)
+target_include_directories(tinyevents INTERFACE include)

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2023 KyrietS.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,139 @@
+# TinyEvents - A Simple Event-Dispatcher System for C++
+
+*TinyEvents* is a simple header-only library for C++ that provides a basic, yet powerfull, event-dispatcher system. It is designed to be easy to use and to have minimal dependencies. It is written in C++17 and has no dependencies other than the standard library.
+
+In *TinyEvents* any type can be used as an event. The events are dispatched to listeners that are registered for a specific event type. Asynchronous (deferred) dispatching using a queue is also supported.
+
+## Basic Usage
+
+```cpp
+#include <tinyevents/tinyevents.hpp>
+
+struct MyEvent {
+    int value;
+};
+
+int maint() {
+    tinyevents::Dispatcher dispatcher;
+
+    dispatcher.listen<MyEvent>([](const auto& event) {
+        std::cout << "Received MyEvent: " << event.value << std::endl;
+    });
+
+    dispatcher.queue(MyEvent{77});
+    dispatcher.dispatch(MyEvent{42});  // Prints "Received MyEvent: 42"
+    dispatcher.process();              // Prints "Received MyEvent: 77"
+
+    dispatcher.dispatch(123);          // No listener for this event, so nothing happens
+
+    return 0;
+}
+```
+
+## Getting Started
+
+### Manual Installation
+Just copy the `include/tinyevents` folder to your project and add the `include` folder to your include path. The library is header-only, so no compilation is needed.
+
+### CMake
+If you use CMake, you can use the `FetchContent` module to download the library and add it to your project. For example:
+
+```cmake
+include(FetchContent)
+FetchContent_Declare(
+  tinyevents
+  GIT_REPOSITORY https://github.com/KyrietS/tinyevents.git
+  GIT_TAG        master
+)
+FetchContent_MakeAvailable(tinyevents)
+target_link_libraries(${TARGET} PRIVATE tinyevents)
+```
+
+Or you can just clone this repository manually and add it as a subdirectory to your CMake project.
+```cmake
+add_subdirectory(tinyevents)
+target_link_libraries(${TARGET} PRIVATE tinyevents)
+```
+
+Don't forget to change the `${TARGET}` to the name of your target.
+
+## Documentation
+
+### Listening to Events
+
+Register a listener for a specific event type. The listener will be called when an event of the specified type is dispatched.
+
+```cpp
+template<typename Event>
+void listen(const std::function<void(const Event&)>& listener)
+```
+
+##### Parameters
+* listener - A callable object that will be called when an event of type `Event` is dispatched. The object must be copyable.
+
+##### Example
+```cpp
+Dispatcher dispatcher;
+dispatcher.listen<int>([](const int& n){ /* ... */ });
+```
+
+### Dispatching Events
+
+Immediately dispatch an event to all the listeners that are registered for the event type.
+
+```cpp
+template<typename Event>
+void send(const Event& event)
+```
+##### Parameters
+* event - The event to dispatch.
+
+##### Example
+```cpp
+Dispatcher dispatcher;
+dispatcher.send(2137);
+```
+
+### Queueing Events
+
+Add an event to the queue. The event will be dispatched once `process()` is called.
+
+```cpp
+template<typename Event>
+void queue(const Event& event)
+```
+##### Parameters
+* event - The event to queue. The event will be copied and stored in the queue.
+
+##### Example
+```cpp
+Dispatcher dispatcher;
+dispatcher.queue(2137);
+```
+
+### Processing the Queue
+
+Processing the queue will dispatch all the events that were queued using `queue()`. The events will be dispatched in the order they were queued.
+
+```cpp
+void process()
+```
+
+## Tests
+
+Tests are written using Google Test. The library is fetched automatically by CMake during the configuration step of the tests.
+
+In order to run the tests with CMake, you can use the following commands:
+```
+cd tests
+cmake -B build
+cd build
+cmake --build .
+ctest
+```
+
+## License
+Copyright © 2023 KyrietS\
+Use of this software is granted under the terms of the MIT License.
+
+See the [LICENSE](LICENSE) file for more details.

include/tinyevents/tinyevents.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <functional>
+#include <list>
+#include <map>
+#include <typeindex>
+
+namespace tinyevents
+{
+    class Dispatcher {
+    public:
+        Dispatcher() = default;
+        Dispatcher(Dispatcher &&) noexcept = default;
+        Dispatcher(const Dispatcher &) = delete;
+        Dispatcher &operator=(Dispatcher &&) noexcept = default;
+
+        template<typename T>
+        void listen(const std::function<void(const T &)> &listener) {
+            listenersByType[std::type_index(typeid(T))].push_back([listener](const auto &msg) {
+                const T *concreteMessage = static_cast<const T *>(msg);
+                listener(*concreteMessage);
+            });
+        }
+
+        template<typename T>
+        void send(const T &msg) {
+            const auto &listeners = listenersByType.find(std::type_index(typeid(T)));
+            if (listeners != listenersByType.end()) {
+                for (auto &listener: listeners->second) {
+                    listener(&msg);
+                }
+            }
+        }
+
+        template<typename T>
+        void queue(const T &msg) {
+            queuedDispatches.push_back([msg](Dispatcher& dispatcher) {
+                dispatcher.send(msg);
+            });
+        }
+
+        void process() {
+            for (auto &queuedDispatch: queuedDispatches) {
+                queuedDispatch(*this);
+            }
+            queuedDispatches.clear();
+        }
+
+    private:
+        using Listeners = std::list<std::function<void(const void *)>>;
+        std::map<std::type_index, Listeners> listenersByType;
+        std::list<std::function<void(Dispatcher&)>> queuedDispatches;
+    };
+}// namespace tinyevents

tests/CMakeLists.txt

@@ -0,0 +1,34 @@
+cmake_minimum_required(VERSION 3.11)
+include(FetchContent)
+
+FetchContent_Declare(
+  googletest
+  GIT_REPOSITORY https://github.com/google/googletest.git
+  GIT_TAG        release-1.12.1
+)
+
+set(TEST_TARGET tinyevents_tests)
+
+project(${TEST_TARGET})
+set(CMAKE_CXX_STANDARD 17)
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT ${TEST_TARGET})
+
+add_executable(${TEST_TARGET}
+        TestEventDispatch.cpp
+        TestEventDispatchQueue.cpp
+        TestEventDispatcherMove.cpp
+)
+
+# tinyevents
+add_subdirectory(../ tinyevents)
+target_link_libraries(${TEST_TARGET} PRIVATE tinyevents)
+
+# GoogleTest
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+target_link_libraries(${TEST_TARGET} PRIVATE gtest gtest_main gmock)
+
+enable_testing()
+include(GoogleTest)
+gtest_discover_tests(${TEST_TARGET})

tests/TestEventDispatch.cpp

@@ -0,0 +1,113 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <tinyevents/tinyevents.hpp>
+
+using namespace tinyevents;
+using namespace testing;
+
+struct DispatcherTest : public Test {
+    Dispatcher dispatcher{};
+};
+
+TEST_F(DispatcherTest, MessagesIgnoredWhenNoListeners) {
+    dispatcher.send(123);
+    dispatcher.send(123.0f);
+    dispatcher.send("abc");
+
+    struct CustomType { };
+    dispatcher.send(CustomType{});
+}
+
+TEST_F(DispatcherTest, MessagesAreDispatchedToSingleListeners) {
+    dispatcher.listen<int>([](const auto &msg) {
+        EXPECT_EQ(msg, 123);
+    });
+    dispatcher.send(123);
+
+    int n = 123;
+    dispatcher.listen<int>([&n](const auto &msg) {
+        EXPECT_EQ(msg, n);
+    });
+    dispatcher.send(n);
+}
+
+TEST_F(DispatcherTest, TheSameListenerCanBeAddedMultipleTimes) {
+    MockFunction<void(const int &)> intCallback;
+    EXPECT_CALL(intCallback, Call(123)).Times(2);
+
+    dispatcher.listen(intCallback.AsStdFunction());
+    dispatcher.listen(intCallback.AsStdFunction());
+
+    dispatcher.send(123);
+}
+
+TEST_F(DispatcherTest, DifferentListenersOfSameTypeAreCalled) {
+    StrictMock<MockFunction<void(const int &)>> intCallback1;
+    StrictMock<MockFunction<void(const int &)>> intCallback2;
+    EXPECT_CALL(intCallback1, Call(123)).Times(1);
+    EXPECT_CALL(intCallback2, Call(123)).Times(1);
+
+    dispatcher.listen(intCallback1.AsStdFunction());
+    dispatcher.listen(intCallback2.AsStdFunction());
+
+    dispatcher.send(123);
+}
+
+TEST_F(DispatcherTest, DifferentListenersOfDifferentTypesAreCalled) {
+    StrictMock<MockFunction<void(const int &)>> intCallback;
+    StrictMock<MockFunction<void(const float &)>> floatCallback;
+
+
+    dispatcher.listen(intCallback.AsStdFunction());
+    dispatcher.listen(floatCallback.AsStdFunction());
+
+    EXPECT_CALL(intCallback, Call(1)).Times(1);
+    dispatcher.send(1);
+
+    EXPECT_CALL(floatCallback, Call(2.0f)).Times(1);
+    dispatcher.send(2.0f);
+}
+
+
+TEST_F(DispatcherTest, ListenerWithCustomEmptyType) {
+    struct EmptyType { };
+
+    StrictMock<MockFunction<void(const EmptyType &)>> emptyTypeCallback;
+    dispatcher.listen(emptyTypeCallback.AsStdFunction());
+
+    EXPECT_CALL(emptyTypeCallback, Call(A<const EmptyType &>())).Times(1);
+    dispatcher.send(EmptyType{});
+
+    EXPECT_CALL(emptyTypeCallback, Call(A<const EmptyType &>())).Times(1);
+    dispatcher.send(EmptyType{});
+}
+
+TEST_F(DispatcherTest, ListenerWithCustomType) {
+    struct CustomType {
+        int n;
+    };
+
+    StrictMock<MockFunction<void(const CustomType &)>> customTypeCallback;
+    dispatcher.listen(customTypeCallback.AsStdFunction());
+
+    EXPECT_CALL(customTypeCallback, Call(Field(&CustomType::n, 111))).Times(1);
+    dispatcher.send(CustomType{ 111 });
+
+    EXPECT_CALL(customTypeCallback, Call(Field(&CustomType::n, 222))).Times(1);
+    dispatcher.send(CustomType{ 222 });
+
+    dispatcher.send(333);
+}
+
+TEST_F(DispatcherTest, ParentMessageTypeListenerShouldNotBeCalledForChildMessage) {
+    struct Parent { };
+    struct Child : Parent { };
+
+    StrictMock<MockFunction<void(const Parent &)>> parentCallback;
+    StrictMock<MockFunction<void(const Child &)>> childCallback;
+    dispatcher.listen(parentCallback.AsStdFunction());
+    dispatcher.listen(childCallback.AsStdFunction());
+
+    EXPECT_CALL(childCallback, Call(A<const Child &>())).Times(1);
+    dispatcher.send(Child{});
+}

tests/TestEventDispatchQueue.cpp

@@ -0,0 +1,62 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <tinyevents/tinyevents.hpp>
+
+using namespace tinyevents;
+using namespace testing;
+
+struct DispatcherQueueTest : public testing::Test {
+    Dispatcher dispatcher{};
+};
+
+TEST_F(DispatcherQueueTest, MessagesQueuedAndThenIgnoredWhenNoListeners) {
+    dispatcher.queue(123);
+    dispatcher.queue(123.0f);
+    dispatcher.queue("abc");
+
+    struct CustomType { };
+    dispatcher.queue(CustomType{});
+
+    dispatcher.process();
+}
+
+TEST_F(DispatcherQueueTest, ShouldNotSendAnythingWhenNoMessagesQueued) {
+    StrictMock<MockFunction<void(const int &)>> intCallback;
+
+    dispatcher.listen(intCallback.AsStdFunction());
+    dispatcher.process();
+}
+
+TEST_F(DispatcherQueueTest, ShouldSendMessageQueued) {
+    StrictMock<MockFunction<void(const int &)>> intCallback;
+
+    dispatcher.listen(intCallback.AsStdFunction());
+    dispatcher.queue(123);
+    dispatcher.queue(123);
+    dispatcher.queue(123);
+
+    EXPECT_CALL(intCallback, Call(123)).Times(3);
+    dispatcher.process();
+}
+
+TEST_F(DispatcherQueueTest, ShouldSendQueuedMessagesOfDifferentTypes) {
+    StrictMock<MockFunction<void(const int &)>> intCallback;
+
+    dispatcher.listen(intCallback.AsStdFunction());
+    dispatcher.queue(123);
+    dispatcher.queue(123.0f);
+    dispatcher.queue("123");
+
+    EXPECT_CALL(intCallback, Call(123)).Times(1);
+    dispatcher.process();
+}
+
+TEST_F(DispatcherQueueTest, MessageQeuedBeforeListenerAddedAndThenSent) {
+    StrictMock<MockFunction<void(const int &)>> intCallback;
+
+    dispatcher.queue(123);
+    dispatcher.listen(intCallback.AsStdFunction());
+
+    EXPECT_CALL(intCallback, Call(123)).Times(1);
+    dispatcher.process();
+}

tests/TestEventDispatcherMove.cpp

@@ -0,0 +1,48 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <tinyevents/tinyevents.hpp>
+
+using namespace tinyevents;
+using namespace testing;
+
+
+TEST(TestDispatcherCopyAndMove, VerifyDispatcherPredicates) {
+    // Check if Dispatcher is movable
+    EXPECT_TRUE(std::is_move_constructible_v<Dispatcher>);
+    EXPECT_TRUE(std::is_move_assignable_v<Dispatcher>);
+
+    // Check if Dispatcher is NOT copyable
+    EXPECT_FALSE(std::is_copy_constructible_v<Dispatcher>);
+    EXPECT_FALSE(std::is_copy_assignable_v<Dispatcher>);
+}
+
+TEST(TestDispatcherCopyAndMove, WhenDispatcherIsMovedThenListenersAreMoved) {
+    Dispatcher movedDispatcher;
+    StrictMock<MockFunction<void(const int &)>> intCallback;
+
+    movedDispatcher.listen(intCallback.AsStdFunction());
+    Dispatcher dispatcher = std::move(movedDispatcher);
+
+    // Should not call the listener
+    EXPECT_CALL(intCallback, Call(222)).Times(0);
+    movedDispatcher.send(222); // NOLINT(*-use-after-move)
+
+    EXPECT_CALL(intCallback, Call(111)).Times(1);
+    dispatcher.send(111);
+}
+
+TEST(TestDispatcherCopyAndMove, WhenDispatcherIsMovedThenQueuedMessagesAreMoved) {
+    Dispatcher movedDispatcher;
+    StrictMock<MockFunction<void(const int &)>> intCallback;
+
+    movedDispatcher.listen(intCallback.AsStdFunction());
+    movedDispatcher.queue(111);
+    Dispatcher dispatcher = std::move(movedDispatcher);
+
+    // Should not call the listener
+    EXPECT_CALL(intCallback, Call(222)).Times(0);
+    movedDispatcher.process(); // NOLINT(*-use-after-move)
+
+    EXPECT_CALL(intCallback, Call(111)).Times(1);
+    dispatcher.process();
+}