Refactor connectReflective

It now reuses the mechanism established by connectReflective.
KDAB · Jun 12, 2024 · 22837e0 · 22837e0
1 parent ad5a733
commit 22837e0
Show file tree

Hide file tree

Showing 2 changed files with 17 additions and 32 deletions.
diff --git a/src/kdbindings/connection_handle.h b/src/kdbindings/connection_handle.h
@@ -181,8 +181,6 @@ class ConnectionHandle
     template<typename...>
     friend class Signal;
 
-    std::weak_ptr<ConnectionHandle> self; // Allows for safe self-reference
-
     std::weak_ptr<Private::SignalImplBase> m_signalImpl;
     std::optional<Private::GenerationalIndex> m_id;
 
@@ -208,14 +206,6 @@ class ConnectionHandle
         }
         return nullptr;
     }
-
-    // Factory method to create a ConnectionHandle
-    static std::shared_ptr<ConnectionHandle> create(const std::weak_ptr<Private::SignalImplBase> &signalImpl, std::optional<Private::GenerationalIndex> id)
-    {
-        auto handle = std::shared_ptr<ConnectionHandle>(new ConnectionHandle(signalImpl, id));
-        handle->self = handle; // Keep a weak reference to self
-        return handle;
-    }
 };
 
 /**

diff --git a/src/kdbindings/signal.h b/src/kdbindings/signal.h
@@ -96,7 +96,7 @@ class Signal
         {
             auto weakEvaluator = std::weak_ptr<ConnectionEvaluator>(evaluator);
 
-            auto deferredSlot = [weakEvaluator = std::move(weakEvaluator), slot](const ConnectionHandle &handle, Args... args) {
+            auto deferredSlot = [weakEvaluator = std::move(weakEvaluator), slot](ConnectionHandle &handle, Args... args) {
                 if (auto evaluatorPtr = weakEvaluator.lock()) {
                     auto lambda = [slot, args...]() {
                         slot(args...);
@@ -109,7 +109,15 @@ class Signal
 
             Connection newConnection;
             newConnection.m_connectionEvaluator = evaluator;
-            newConnection.slotDeferred = deferredSlot;
+            newConnection.slotReflective = deferredSlot;
+
+            return m_connections.insert(std::move(newConnection));
+        }
+
+        Private::GenerationalIndex connectReflective(std::function<void(ConnectionHandle &handle, Args...)> const &slot)
+        {
+            Connection newConnection;
+            newConnection.slotReflective = slot;
 
             return m_connections.insert(std::move(newConnection));
         }
@@ -127,7 +135,7 @@ class Signal
 
                 // Retrieve the connection associated with this id
                 auto connection = m_connections.get(id);
-                if (connection && connection->slotDeferred) {
+                if (connection && connection->m_connectionEvaluator.lock()) {
                     if (auto evaluatorPtr = connection->m_connectionEvaluator.lock()) {
                         evaluatorPtr->dequeueSlotInvocation(handle);
                     }
@@ -138,7 +146,8 @@ class Signal
         }
 
         // Disconnects all previously connected functions
-        void disconnectAll()
+        void
+        disconnectAll()
         {
             const auto numEntries = m_connections.entriesSize();
 
@@ -194,10 +203,10 @@ class Signal
                     const auto con = m_connections.get(*index);
 
                     if (!con->blocked) {
-                        if (con->slotDeferred) {
+                        if (con->slotReflective) {
                             if (auto sharedThis = shared_from_this(); sharedThis) {
                                 ConnectionHandle handle(sharedThis, *index);
-                                con->slotDeferred(handle, p...);
+                                con->slotReflective(handle, p...);
                             }
                         } else if (con->slot) {
                             con->slot(p...);
@@ -211,7 +220,7 @@ class Signal
         friend class Signal;
         struct Connection {
             std::function<void(Args...)> slot;
-            std::function<void(const ConnectionHandle &, Args...)> slotDeferred;
+            std::function<void(ConnectionHandle &, Args...)> slotReflective;
             std::weak_ptr<ConnectionEvaluator> m_connectionEvaluator;
             bool blocked{ false };
         };
@@ -274,21 +283,7 @@ class Signal
     {
         ensureImpl();
 
-        // Create a new ConnectionHandle with no ID initially. This handle will be used to manage the connection lifecycle.
-        auto handle = ConnectionHandle::create(m_impl, std::nullopt);
-
-        // Prepare the lambda that matches the signature expected by m_impl->connect
-        auto wrappedSlot = [this, handle, slot](Args... args) mutable {
-            // Directly invoke the user-provided slot with the handle and args
-            slot(*handle, args...);
-        };
-
-        // Connect the wrapped slot to the signal implementation.
-        // The handle ID is set after successful connection to manage this connection specifically.
-        handle->setId(m_impl->connect(wrappedSlot));
-
-        // Return the ConnectionHandle, allowing the caller to manage the connection directly.
-        return *handle;
+        return ConnectionHandle{ m_impl, m_impl->connectReflective(slot) };
     }
 
     /**