Merge pull request #85 from KDAB/wip/eventLoop

Author: MiKom

.github/workflows/linters.yml

@@ -77,7 +77,6 @@ jobs:
           cppcheck --quiet --language=c++ --force --inline-suppr
           --enable=warning,performance,portability,information
           --disable=missingInclude  --check-level=exhaustive
-          --suppress="ctuOneDefinitionRuleViolation:tests/*"
           -i build --library=std.cfg --error-exitcode=42 .
 
           if($LASTEXITCODE -eq 42) {

src/KDFoundation/CMakeLists.txt

@@ -12,6 +12,7 @@ find_package(Threads)
 
 set(SOURCES
     core_application.cpp
+    event_loop.cpp
     event_receiver.cpp
     event.cpp
     file_descriptor_notifier.cpp
@@ -25,6 +26,7 @@ set(HEADERS
     constexpr_sort.h
     core_application.h
     destruction_helpers.h
+    event_loop.h
     event_queue.h
     event_receiver.h
     event.h

src/KDFoundation/core_application.cpp

@@ -27,10 +27,27 @@ using namespace KDFoundation;
 
 CoreApplication *CoreApplication::ms_application = nullptr;
 
-CoreApplication::CoreApplication(std::unique_ptr<AbstractPlatformIntegration> &&platformIntegration)
+namespace {
+std::unique_ptr<AbstractPlatformIntegration> createPlatformIntegration()
+{
+// Create a platform integration
+#if defined(PLATFORM_LINUX)
+    return std::make_unique<LinuxPlatformIntegration>();
+#elif defined(PLATFORM_WIN32)
+    return std::make_unique<Win32PlatformIntegration>();
+#elif defined(PLATFORM_MACOS)
+    return std::make_unique<MacOSPlatformIntegration>();
+#else
+    static_assert(false, "No valid platform integration could be found.");
+#endif
+}
+} // namespace
+
+CoreApplication::CoreApplication(std::unique_ptr<AbstractPlatformIntegration> &&platformIntegration, std::unique_ptr<KDFoundation::AbstractPlatformEventLoop> &&platformEventLoop)
     : m_defaultLogger{ KDUtils::Logger::logger("default_log", spdlog::level::info) }
-    , m_platformIntegration{ std::move(platformIntegration) }
+    , m_platformIntegration{ platformIntegration ? std::move(platformIntegration) : createPlatformIntegration() }
     , m_logger{ KDUtils::Logger::logger("core_application") }
+    , m_eventLoop{ platformEventLoop ? std::move(platformEventLoop) : m_platformIntegration->createPlatformEventLoop() }
 {
     assert(ms_application == nullptr);
     ms_application = this;
@@ -41,25 +58,7 @@ CoreApplication::CoreApplication(std::unique_ptr<AbstractPlatformIntegration> &&
     if (const char *display = std::getenv("DISPLAY")) // NOLINT(concurrency-mt-unsafe)
         SPDLOG_LOGGER_INFO(m_logger, "DISPLAY={}", display);
 
-    // Create a default postman object
-    m_postman = std::make_unique<Postman>();
-
-    // Create a platform integration
-    if (!m_platformIntegration) {
-#if defined(PLATFORM_LINUX)
-        m_platformIntegration = std::make_unique<LinuxPlatformIntegration>();
-#elif defined(PLATFORM_WIN32)
-        m_platformIntegration = std::make_unique<Win32PlatformIntegration>();
-#elif defined(PLATFORM_MACOS)
-        m_platformIntegration = std::make_unique<MacOSPlatformIntegration>();
-#endif
-    }
-
-    // Ask the platform integration to create us a suitable event loop
-    assert(m_platformIntegration);
-    m_platformEventLoop = m_platformIntegration->createPlatformEventLoop();
     m_platformIntegration->init();
-    m_platformEventLoop->setPostman(m_postman.get());
 }
 
 CoreApplication::~CoreApplication()
@@ -68,60 +67,34 @@ CoreApplication::~CoreApplication()
     // and immediately return after processing events (timeout = 0).
     processEvents(0);
 
-    // Destroy the event loop and platform integration before removing the app instance
-    m_platformEventLoop = std::unique_ptr<AbstractPlatformEventLoop>();
-    m_platformIntegration = std::unique_ptr<AbstractPlatformIntegration>();
+    // Destroy the platform integration before removing the app instance
+    m_platformIntegration.reset();
     ms_application = nullptr;
 }
 
 std::shared_ptr<KDBindings::ConnectionEvaluator> CoreApplication::connectionEvaluator()
 {
-    return eventLoop()->connectionEvaluator();
+    return m_eventLoop.connectionEvaluator();
 }
 
 void CoreApplication::postEvent(EventReceiver *target, std::unique_ptr<Event> &&event)
 {
-    assert(target != nullptr);
-    assert(event->type() != Event::Type::Invalid);
-    m_eventQueue.push(target, std::forward<std::unique_ptr<Event>>(event));
-    m_platformEventLoop->wakeUp();
+    m_eventLoop.postEvent(target, std::forward<std::unique_ptr<Event>>(event));
 }
 
 void CoreApplication::sendEvent(EventReceiver *target, Event *event)
 {
-    SPDLOG_LOGGER_TRACE(m_logger, "{}()", __FUNCTION__);
-    m_postman->deliverEvent(target, event);
+    m_eventLoop.sendEvent(target, event);
 }
 
 void CoreApplication::processEvents(int timeout)
 {
-    // Deliver any events that have already been posted
-    for (size_t eventIndex = 0, eventCount = m_eventQueue.size(); eventIndex < eventCount; ++eventIndex) {
-        auto postedEvent = m_eventQueue.tryPop();
-        if (!postedEvent)
-            break;
-        const auto target = postedEvent->target();
-        const auto ev = postedEvent->wrappedEvent();
-
-        m_postman->deliverEvent(target, ev);
-    }
-
-    // Poll/wait for new events
-    if (!m_platformEventLoop)
-        return;
-    m_platformEventLoop->waitForEvents(timeout);
+    m_eventLoop.processEvents(timeout);
 }
 
 int CoreApplication::exec()
 {
-    if (!m_platformEventLoop)
-        return 1;
-
-    while (!m_quitRequested)
-        processEvents(-1);
-    m_quitRequested = false;
-
-    return 0;
+    return m_eventLoop.exec();
 }
 
 void CoreApplication::quit()
@@ -137,12 +110,7 @@ AbstractPlatformIntegration *CoreApplication::platformIntegration()
 void CoreApplication::event(EventReceiver *target, Event *event)
 {
     if (event->type() == Event::Type::Quit) {
-        // After setting the quit flag to true, we must wake up the event loop once more,
-        // because processEvents() goes back into waitForEvents() after processing the
-        // queued events. Without the wakeUp() call it would wait until some other event
-        // woke it up again. Let's kick it ourselves.
-        m_quitRequested = true;
-        m_platformEventLoop->wakeUp();
+        m_eventLoop.quit();
         event->setAccepted(true);
     }
 

src/KDFoundation/core_application.h

@@ -13,6 +13,7 @@
 
 #include <KDFoundation/kdfoundation_global.h>
 #include <KDFoundation/object.h>
+#include <KDFoundation/event_loop.h>
 #include <KDFoundation/event_queue.h>
 #include <KDFoundation/platform/abstract_platform_integration.h>
 
@@ -37,19 +38,22 @@ class KDFOUNDATION_API CoreApplication : public Object
     KDBindings::Property<std::string> applicationName{};
     KDBindings::Property<std::string> organizationName{};
 
-    CoreApplication(std::unique_ptr<AbstractPlatformIntegration> &&platformIntegration = {});
+    CoreApplication(std::unique_ptr<AbstractPlatformIntegration> &&platformIntegration = {}, std::unique_ptr<KDFoundation::AbstractPlatformEventLoop> &&platformEventLoop = {});
     ~CoreApplication() override;
 
     static inline CoreApplication *instance() { return ms_application; }
 
-    const AbstractPlatformEventLoop *eventLoop() const { return m_platformEventLoop.get(); }
-    AbstractPlatformEventLoop *eventLoop() { return m_platformEventLoop.get(); }
+    const EventLoop *eventLoop() const { return &m_eventLoop; }
+    EventLoop *eventLoop() { return &m_eventLoop; }
 
-    Postman *postman() { return m_postman.get(); }
+    const AbstractPlatformEventLoop *platformEventLoop() const { return m_eventLoop.platformEventLoop(); }
+    AbstractPlatformEventLoop *platformEventLoop() { return m_eventLoop.platformEventLoop(); }
+
+    Postman *postman() { return m_eventLoop.postman(); }
 
     void postEvent(EventReceiver *target, std::unique_ptr<Event> &&event);
-    void removeAllEventsTargeting(EventReceiver &evReceiver) { m_eventQueue.removeAllEventsTargeting(evReceiver); }
-    EventQueue::size_type eventQueueSize() const { return m_eventQueue.size(); }
+    void removeAllEventsTargeting(EventReceiver &evReceiver) { m_eventLoop.removeAllEventsTargeting(evReceiver); }
+    EventQueue::size_type eventQueueSize() const { return m_eventLoop.eventQueueSize(); }
 
     void sendEvent(EventReceiver *target, Event *event);
 
@@ -68,14 +72,10 @@ class KDFOUNDATION_API CoreApplication : public Object
     std::shared_ptr<spdlog::logger> m_defaultLogger;
 
 private:
-    void init();
     void event(EventReceiver *target, Event *event) override;
 
-    EventQueue m_eventQueue;
-    bool m_quitRequested{ false };
     std::unique_ptr<AbstractPlatformIntegration> m_platformIntegration;
-    std::unique_ptr<AbstractPlatformEventLoop> m_platformEventLoop;
-    std::unique_ptr<Postman> m_postman;
+    EventLoop m_eventLoop;
     std::shared_ptr<spdlog::logger> m_logger;
 };
 

src/KDFoundation/event_loop.cpp

@@ -0,0 +1,126 @@
+/*
+ *  This file is part of KDUtils.
+ *
+ *  SPDX-FileCopyrightText: 2025 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
+ *  Author: Anton Kreuzkamp <anton.kreuzkamp@kdab.com>
+ *  Author: Paul Lemire <paul.lemire@kdab.com>
+ *
+ *  SPDX-License-Identifier: MIT
+ *
+ *  Contact KDAB at <info@kdab.com> for commercial licensing options.
+ */
+
+#include <KDFoundation/event_loop.h>
+#include <KDFoundation/core_application.h>
+#include <KDFoundation/platform/abstract_platform_event_loop.h>
+#include "postman.h"
+
+#if defined(PLATFORM_LINUX)
+#include <KDFoundation/platform/linux/linux_platform_integration.h>
+#elif defined(PLATFORM_WIN32)
+#include <KDFoundation/platform/win32/win32_platform_integration.h>
+#elif defined(PLATFORM_MACOS)
+#include <KDFoundation/platform/macos/macos_platform_integration.h>
+#endif
+
+#include <cassert>
+
+using namespace KDFoundation;
+
+namespace {
+thread_local EventLoop *s_eventLoopInstance = nullptr;
+}
+
+EventLoop *EventLoop::instance()
+{
+    return s_eventLoopInstance;
+}
+
+namespace {
+std::unique_ptr<AbstractPlatformEventLoop> createPlatformEventLoop()
+{
+    // Ask the platform integration to create us a suitable event loop
+    CoreApplication *app = CoreApplication::instance();
+    assert(app && "Cannot use EventLoop without a CoreApplication.");
+    AbstractPlatformIntegration *platformIntegration = app->platformIntegration();
+    assert(platformIntegration);
+    return platformIntegration->createPlatformEventLoop();
+}
+} // namespace
+
+EventLoop::EventLoop(std::unique_ptr<AbstractPlatformEventLoop> platformEventLoop)
+    : m_platformEventLoop(platformEventLoop ? std::move(platformEventLoop) : createPlatformEventLoop())
+{
+    // Create a default postman object
+    m_postman = std::make_unique<Postman>();
+    m_platformEventLoop->setPostman(m_postman.get());
+
+    assert(s_eventLoopInstance == nullptr && "Cannot have more than one event loop per thread.");
+    s_eventLoopInstance = this;
+}
+
+EventLoop::~EventLoop()
+{
+    // Destroy the platform event loop before removing the event loop instance
+    m_platformEventLoop.reset();
+    s_eventLoopInstance = nullptr;
+}
+
+std::shared_ptr<KDBindings::ConnectionEvaluator> EventLoop::connectionEvaluator()
+{
+    return m_platformEventLoop->connectionEvaluator();
+}
+
+void EventLoop::postEvent(EventReceiver *target, std::unique_ptr<Event> &&event)
+{
+    assert(target != nullptr);
+    assert(event->type() != Event::Type::Invalid);
+    m_eventQueue.push(target, std::forward<std::unique_ptr<Event>>(event));
+    m_platformEventLoop->wakeUp();
+}
+
+void EventLoop::sendEvent(EventReceiver *target, Event *event)
+{
+    m_postman->deliverEvent(target, event);
+}
+
+void EventLoop::processEvents(int timeout)
+{
+    // Deliver any events that have already been posted
+    for (size_t eventIndex = 0, eventCount = m_eventQueue.size(); eventIndex < eventCount; ++eventIndex) {
+        auto postedEvent = m_eventQueue.tryPop();
+        if (!postedEvent)
+            break;
+        const auto target = postedEvent->target();
+        const auto ev = postedEvent->wrappedEvent();
+
+        m_postman->deliverEvent(target, ev);
+    }
+
+    // Poll/wait for new events
+    if (!m_platformEventLoop)
+        return;
+    m_platformEventLoop->waitForEvents(timeout);
+}
+
+int EventLoop::exec()
+{
+    if (!m_platformEventLoop)
+        return 1;
+
+    while (!m_quitRequested)
+        processEvents(-1);
+    m_quitRequested = false;
+
+    return 0;
+}
+
+void EventLoop::quit()
+{
+    // After setting the quit flag to true, we must wake up the event loop once more,
+    // because processEvents() goes back into waitForEvents() after processing the
+    // queued events. Without the wakeUp() call it would wait until some other event
+    // woke it up again. Let's kick it ourselves.
+    m_quitRequested = true;
+    m_platformEventLoop->wakeUp();
+}