Deferred connection evaluation

src/kdbindings/CMakeLists.txt

@@ -18,6 +18,7 @@ set(HEADERS
     property.h
     property_updater.h
     signal.h
+    connection_evaluator.h
     utils.h
 )
 

src/kdbindings/connection_evaluator.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <functional>
+#include <list>
+#include <mutex>
+
+namespace KDBindings {
+
+/**
+ * @brief Manages and evaluates conditions for deferred connections.
+ *
+ * The ConnectionEvaluator class is responsible for managing and evaluating conditions
+ * that determine when deferred connections should be executed. It provides mechanisms
+ * to evaluate connections based on specific criteria. This class is
+ * used in conjunction with the Signal class to establish and control connections.
+ */
+class ConnectionEvaluator
+{
+
+public:
+    ConnectionEvaluator() = default;
+
+    ConnectionEvaluator(const ConnectionEvaluator &) noexcept = default;
+
+    ConnectionEvaluator &operator=(const ConnectionEvaluator &) noexcept = default;
+
+    ConnectionEvaluator(ConnectionEvaluator &&other) noexcept = delete;
+
+    ConnectionEvaluator &operator=(ConnectionEvaluator &&other) noexcept = delete;
+
+    /**
+     * @brief Evaluate and execute deferred connections.
+     *
+     * This function is responsible for evaluating and executing deferred connections.
+     * It locks the `connectionsMutex` to ensure thread safety while accessing the list
+     * of deferred connections. It then copies the list of connections to avoid
+     * interference with reentrant emissions. Finally, it iterates through the copied
+     * connections and executes each one by calling the associated function object.
+     */
+    void evaluateDeferredConnections()
+    {
+        std::list<std::function<void()>> copiedConnections;
+        {
+            std::lock_guard<std::mutex> lock(connectionsMutex);
+            copiedConnections = connections;
+        }
+
+        for (auto &connection : copiedConnections) {
+            connection();
+        }
+    }
+
+private:
+    template<typename...>
+    friend class Signal;
+
+    void addConnection(std::function<void()> connection)
+    {
+        connections.push_back(connection);
+    }
+
+    std::list<std::function<void()>> connections;
+    std::mutex connectionsMutex;
+};
+} // namespace KDBindings

src/kdbindings/signal.h

@@ -18,7 +18,9 @@
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
+#include <mutex>
 
+#include <kdbindings/connection_evaluator.h>
 #include <kdbindings/genindex_array.h>
 #include <kdbindings/utils.h>
 
@@ -242,6 +244,22 @@ class Signal
             return m_connections.insert({ slot });
         }
 
+        // Establish a deferred connection between signal and slot, where ConnectionEvaluator object
+        // used to queue all the connection to evaluate later. The returned
+        // value can be used to disconnect the function again.
+        Private::GenerationalIndex connectDeferred(ConnectionEvaluator &evaluator, std::function<void(Args...)> const &slot)
+        {
+            std::lock_guard<std::mutex> lock(connectionMutex);
+            auto connection = [&evaluator, slot](Args... args) {
+                auto lambda = [slot, args...]() {
+                    slot(args...);
+                };
+
+                evaluator.addConnection(lambda);
+            };
+            return m_connections.insert({ connection, true });
+        }
+
         // Disconnects a previously connected function
         void disconnect(const Private::GenerationalIndex &id) override
         {
@@ -284,6 +302,8 @@ class Signal
         // Calls all connected functions
         void emit(Args... p) const
         {
+            std::lock_guard<std::mutex> lock(connectionMutex);
+
             const auto numEntries = m_connections.entriesSize();
 
             // This loop can tolerate signal handles being disconnected inside a slot,
@@ -294,18 +314,21 @@ class Signal
                 if (index) {
                     const auto con = m_connections.get(*index);
 
-                    if (!con->blocked)
+                    if (!con->blocked) {
                         con->slot(p...);
+                    }
                 }
             }
         }
 
     private:
         struct Connection {
             std::function<void(Args...)> slot;
+            bool isDeferred{ false };
             bool blocked{ false };
         };
         mutable Private::GenerationalIndexArray<Connection> m_connections;
+        mutable std::mutex connectionMutex;
     };
 
 public:
@@ -349,6 +372,25 @@ class Signal
         return ConnectionHandle{ m_impl, m_impl->connect(slot) };
     }
 
+    /**
+     * @brief Establishes a deferred connection between the provided evaluator and slot.
+     *
+     * This function allows connecting an evaluator and a slot such that the slot's execution
+     * is deferred until the conditions evaluated by the `evaluator` are met.
+     *
+     * First argument to the function is reference to the `ConnectionEvaluator` responsible for determining
+     * when the slot should be executed.
+     * 
+     * @return An instance of ConnectionHandle, that can be used to disconnect
+     * or temporarily block the connection.
+     */
+    ConnectionHandle connectDeferred(ConnectionEvaluator &evaluator, std::function<void(Args...)> const &slot)
+    {
+        ensureImpl();
+
+        return ConnectionHandle(m_impl, m_impl->connectDeferred(evaluator, slot));
+    }
+
     /**
      * A template overload of Signal::connect that makes it easier to connect arbitrary functions to this
      * Signal.

tests/signal/tst_signal.cpp

@@ -11,9 +11,11 @@
 
 #include "kdbindings/utils.h"
 #include <kdbindings/signal.h>
+#include <kdbindings/connection_evaluator.h>
 
 #include <stdexcept>
 #include <string>
+#include <thread>
 
 #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
 #include <doctest.h>
@@ -77,6 +79,57 @@ TEST_CASE("Signal connections")
         REQUIRE(lambdaCalled == true);
     }
 
+    SUBCASE("Deferred Connections")
+    {
+        ConnectionEvaluator evaluator;
+        Signal<int> signal1;
+        Signal<std::string> signal2;
+        Signal<int, std::string> signal3;
+        int val = 4;
+
+        std::thread thread1([&] {
+            signal1.connectDeferred(evaluator, [&val](int value) {
+                val--;
+            });
+        });
+
+        std::thread thread2([&] {
+            signal2.connectDeferred(evaluator, [&val](std::string) {
+                val++;
+            });
+        });
+
+        // Wait for threads to finish connecting
+        thread1.join();
+        thread2.join();
+
+        const auto result = signal3.connectDeferred(evaluator, [&val](int, std::string) {
+            val++;
+        });
+
+        REQUIRE(result.isActive());
+
+        signal3.disconnect(result);
+
+        // Emit signals(reentrant) in different threads
+        std::thread thread3([&] {
+            signal1.emit(42);
+        });
+
+        std::thread thread4([&] {
+            signal2.emit("Hi");
+        });
+
+        thread3.join();
+        thread4.join();
+
+        REQUIRE(!result.isActive());
+        signal3.emit(1, "Hi"); // it does not affect, as the signal3 already disconnected
+
+        evaluator.evaluateDeferredConnections();
+        REQUIRE(val == 4);
+    }
+
     SUBCASE("A signal with arguments can be connected to a lambda and invoked with l-value args")
     {
         Signal<std::string, int> signal;