Use std::optional to check for receivers

dantti · dantti · commit da6fdeacfc75 · 2025-07-07T09:23:03.000-03:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: MIT
 
 cmake_minimum_required(VERSION 3.26)
-project(libasql VERSION 0.101.0 LANGUAGES CXX)
+project(libasql VERSION 0.102.0 LANGUAGES CXX)
 
 include(GNUInstallDirs)
 include(GenerateExportHeader)
diff --git a/src/ADriverSqlite.cpp b/src/ADriverSqlite.cpp
@@ -27,7 +27,7 @@ ADriverSqlite::ADriverSqlite(const QString &connInfo)
         QMutexLocker _(&m_worker.m_promisesMutex);
         while (!m_worker.m_promisesReady.isEmpty()) {
             QueryPromise promise = m_worker.m_promisesReady.dequeue();
-            if (!promise.checkReceiver || !promise.receiver.isNull()) {
+            if (!promise.receiver.has_value() || !promise.receiver->isNull()) {
                 if (promise.cb) {
                     AResult result{promise.result};
                     promise.cb(result);
@@ -82,19 +82,21 @@ void ADriverSqlite::open(const std::shared_ptr<ADriver> &driver,
     selfDriver = driver;
 
     OpenPromise promise{
-        .cb            = cb,
-        .receiver      = receiver,
-        .checkReceiver = static_cast<bool>(receiver),
+        .cb = cb,
     };
 
+    if (receiver) {
+        promise.receiver = receiver;
+    }
+
     connect(&m_worker, &ASqliteThread::openned, this, [this, promise](bool isOpen, QString error) {
         if (isOpen) {
             setState(ADatabase::State::Connected, {});
         } else {
             setState(ADatabase::State::Disconnected, error);
         }
 
-        if (!promise.checkReceiver || !promise.receiver.isNull()) {
+        if (!promise.receiver.has_value() || !promise.receiver->isNull()) {
             if (promise.cb) {
                 promise.cb(isOpen, error);
             }
@@ -124,7 +126,8 @@ bool ADriverSqlite::isOpen() const
 void ADriverSqlite::setState(ADatabase::State state, const QString &status)
 {
     m_state = state;
-    if (m_stateChangedCb && (!m_stateChangedReceiverSet || !m_stateChangedReceiver.isNull())) {
+    if (m_stateChangedCb &&
+        (!m_stateChangedReceiver.has_value() || !m_stateChangedReceiver->isNull())) {
         m_stateChangedCb(state, status);
     }
 }
@@ -137,9 +140,10 @@ ADatabase::State ADriverSqlite::state() const
 void ADriverSqlite::onStateChanged(QObject *receiver,
                                    std::function<void(ADatabase::State, const QString &)> cb)
 {
-    m_stateChangedCb          = cb;
-    m_stateChangedReceiver    = receiver;
-    m_stateChangedReceiverSet = receiver;
+    m_stateChangedCb = cb;
+    if (receiver) {
+        m_stateChangedReceiver = receiver;
+    }
 }
 
 void ADriverSqlite::begin(const std::shared_ptr<ADriver> &db, QObject *receiver, AResultFn cb)
@@ -166,11 +170,12 @@ void ADriverSqlite::exec(const std::shared_ptr<ADriver> &db,
     selfDriver = db;
 
     QueryPromise data{
-        .cb            = cb,
-        .result        = std::make_shared<AResultSqlite>(),
-        .receiver      = receiver,
-        .checkReceiver = static_cast<bool>(receiver),
+        .cb     = cb,
+        .result = std::make_shared<AResultSqlite>(),
     };
+    if (receiver) {
+        data.receiver = receiver;
+    }
     data.result->m_query.setRawData(query.data(), query.size());
 
 #if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
@@ -191,11 +196,12 @@ void ADriverSqlite::exec(const std::shared_ptr<ADriver> &db,
     selfDriver = db;
 
     QueryPromise data{
-        .cb            = cb,
-        .result        = std::make_shared<AResultSqlite>(),
-        .receiver      = receiver,
-        .checkReceiver = static_cast<bool>(receiver),
+        .cb     = cb,
+        .result = std::make_shared<AResultSqlite>(),
     };
+    if (receiver) {
+        data.receiver = receiver;
+    }
     data.result->m_query = query.toUtf8();
 
 #if QT_VERSION >= QT_VERSION_CHECK(6, 7, 0)
@@ -217,11 +223,12 @@ void ADriverSqlite::exec(const std::shared_ptr<ADriver> &db,
     selfDriver = db;
 
     QueryPromise data{
-        .cb            = cb,
-        .result        = std::make_shared<AResultSqlite>(),
-        .receiver      = receiver,
-        .checkReceiver = static_cast<bool>(receiver),
+        .cb     = cb,
+        .result = std::make_shared<AResultSqlite>(),
     };
+    if (receiver) {
+        data.receiver = receiver;
+    }
     data.result->m_query.setRawData(query.data(), query.size());
     data.result->m_queryArgs = params;
 
@@ -244,11 +251,12 @@ void ADriverSqlite::exec(const std::shared_ptr<ADriver> &db,
     selfDriver = db;
 
     QueryPromise data{
-        .cb            = cb,
-        .result        = std::make_shared<AResultSqlite>(),
-        .receiver      = receiver,
-        .checkReceiver = static_cast<bool>(receiver),
+        .cb     = cb,
+        .result = std::make_shared<AResultSqlite>(),
     };
+    if (receiver) {
+        data.receiver = receiver;
+    }
     data.result->m_query     = query.toUtf8();
     data.result->m_queryArgs = params;
 
@@ -274,9 +282,10 @@ void ADriverSqlite::exec(const std::shared_ptr<ADriver> &db,
         .preparedQuery = query,
         .cb            = cb,
         .result        = std::make_shared<AResultSqlite>(),
-        .receiver      = receiver,
-        .checkReceiver = static_cast<bool>(receiver),
     };
+    if (receiver) {
+        data.receiver = receiver;
+    }
     data.result->m_query     = query.query();
     data.result->m_queryArgs = params;
 
diff --git a/src/ADriverSqlite.hpp b/src/ADriverSqlite.hpp
@@ -68,16 +68,14 @@ class AResultSqlite final : public AResultPrivate
 
 struct OpenPromise {
     ADatabaseOpenFn cb;
-    QPointer<QObject> receiver;
-    bool checkReceiver;
+    std::optional<QPointer<QObject>> receiver;
 };
 
 struct QueryPromise {
     std::optional<APreparedQuery> preparedQuery;
     AResultFn cb;
     std::shared_ptr<AResultSqlite> result;
-    QPointer<QObject> receiver;
-    bool checkReceiver;
+    std::optional<QPointer<QObject>> receiver;
 };
 
 class ASqliteThread final : public QThread
@@ -191,18 +189,17 @@ class ADriverSqlite final : public ADriver
                                      const QString &name) override;
 
 private:
-    QPointer<QObject> m_stateChangedReceiver;
+    std::optional<QPointer<QObject>> m_stateChangedReceiver;
     std::function<void(ADatabase::State, const QString &)> m_stateChangedCb;
     std::shared_ptr<ADriver> selfDriver;
     ASqliteThread m_worker;
     QThread m_thread;
-    ADatabase::State m_state       = ADatabase::State::Disconnected;
-    int m_pipelineSync             = 0;
-    int m_queueSize                = 0;
-    bool m_stateChangedReceiverSet = false;
-    bool m_flush                   = false;
-    bool m_queryRunning            = false;
-    bool m_notificationPtrSet      = false;
+    ADatabase::State m_state  = ADatabase::State::Disconnected;
+    int m_pipelineSync        = 0;
+    int m_queueSize           = 0;
+    bool m_flush              = false;
+    bool m_queryRunning       = false;
+    bool m_notificationPtrSet = false;
 };
 
 } // namespace ASql
diff --git a/src/adriverpg.cpp b/src/adriverpg.cpp
@@ -158,11 +158,12 @@ void ADriverPg::open(const std::shared_ptr<ADriver> &driver, QObject *receiver,
     qDebug(ASQL_PG) << "Open" << connectionInfo();
     m_conn = std::make_unique<APgConn>(connectionInfo());
     if (m_conn->conn()) {
-        m_openCaller                = std::make_unique<OpenCaller>();
-        m_openCaller->driver        = driver;
-        m_openCaller->cb            = cb;
-        m_openCaller->receiverPtr   = receiver;
-        m_openCaller->checkReceiver = static_cast<bool>(receiver);
+        m_openCaller         = std::make_unique<OpenCaller>();
+        m_openCaller->driver = driver;
+        m_openCaller->cb     = cb;
+        if (receiver) {
+            m_openCaller->receiverPtr = receiver;
+        }
 
         const auto socket = m_conn->socket();
         if (socket > 0) {
@@ -383,7 +384,8 @@ bool ADriverPg::isOpen() const
 void ADriverPg::setState(ADatabase::State state, const QString &status)
 {
     m_state = state;
-    if (m_stateChangedCb && (!m_stateChangedReceiverSet || !m_stateChangedReceiver.isNull())) {
+    if (m_stateChangedCb &&
+        (!m_stateChangedReceiver.has_value() || !m_stateChangedReceiver->isNull())) {
         m_stateChangedCb(state, status);
     }
 }
@@ -396,9 +398,10 @@ ADatabase::State ADriverPg::state() const
 void ADriverPg::onStateChanged(QObject *receiver,
                                std::function<void(ADatabase::State, const QString &)> cb)
 {
-    m_stateChangedCb          = cb;
-    m_stateChangedReceiver    = receiver;
-    m_stateChangedReceiverSet = receiver;
+    m_stateChangedCb = cb;
+    if (receiver) {
+        m_stateChangedReceiver = receiver;
+    }
 }
 
 void ADriverPg::begin(const std::shared_ptr<ADriver> &db, QObject *receiver, AResultFn cb)
diff --git a/src/adriverpg.h b/src/adriverpg.h
@@ -216,19 +216,18 @@ class ADriverPg final : public ADriver
     struct OpenCaller {
         std::shared_ptr<ADriver> driver;
         ADatabaseOpenFn cb;
-        QPointer<QObject> receiverPtr;
-        bool checkReceiver = false;
+        std::optional<QPointer<QObject>> receiverPtr;
 
         void emit(bool isOpen, const QString &error)
         {
-            if (cb && (!checkReceiver || !receiverPtr.isNull())) {
+            if (cb && (!receiverPtr.has_value() || !receiverPtr->isNull())) {
                 cb(isOpen, error);
             }
         }
     };
     std::unique_ptr<OpenCaller> m_openCaller;
 
-    QPointer<QObject> m_stateChangedReceiver;
+    std::optional<QPointer<QObject>> m_stateChangedReceiver;
     std::function<void(ADatabase::State, const QString &)> m_stateChangedCb;
     QHash<QString, ANotificationFn> m_subscribedNotifications;
     std::queue<APGQuery> m_queuedQueries;
@@ -238,12 +237,11 @@ class ADriverPg final : public ADriver
     std::unique_ptr<QSocketNotifier> m_readNotify;
     std::unique_ptr<QTimer> m_autoSyncTimer;
     std::unique_ptr<APgConn> m_conn;
-    ADatabase::State m_state       = ADatabase::State::Disconnected;
-    int m_pipelineSync             = 0;
-    bool m_stateChangedReceiverSet = false;
-    bool m_flush                   = false;
-    bool m_queryRunning            = false;
-    bool m_notificationPtrSet      = false;
+    ADatabase::State m_state  = ADatabase::State::Disconnected;
+    int m_pipelineSync        = 0;
+    bool m_flush              = false;
+    bool m_queryRunning       = false;
+    bool m_notificationPtrSet = false;
 };
 
 } // namespace ASql
diff --git a/tests/sqlite_tst.cpp b/tests/sqlite_tst.cpp
@@ -53,8 +53,10 @@ void TestSqlite::cleanupTest()
 
 void TestSqlite::testQueries()
 {
+
     QEventLoop loop;
     {
+        // CP.51 this only works because qScopeGuard increases the finished ref count.
         auto finished = std::make_shared<QObject>();
         connect(finished.get(), &QObject::destroyed, &loop, &QEventLoop::quit);
 

Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,10 @@ void TestSqlite::cleanupTest()`
`53`	`53`
`54`	`54`	`void TestSqlite::testQueries()`
`55`	`55`	`{`
	`56`	`+`
`56`	`57`	`QEventLoop loop;`
`57`	`58`	`{`
	`59`	`+ // CP.51 this only works because qScopeGuard increases the finished ref count.`
`58`	`60`	`auto finished = std::make_shared<QObject>();`
`59`	`61`	`connect(finished.get(), &QObject::destroyed, &loop, &QEventLoop::quit);`
`60`	`62`