Merge remote-tracking branch 'origin/qds/dev'

Conflicts:
  coin/instructions/build.yaml
  doc/qtcreator/src/projects/creator-only/creator-projects-creating.qdoc
  share/qtcreator/qmldesigner/studio_templates/projects/common/CMakeLists.main.txt.tpl
  src/libs/CMakeLists.txt
  src/libs/advanceddockingsystem/dockmanager.cpp
  src/libs/advanceddockingsystem/workspacedialog.cpp
  src/plugins/coreplugin/manhattanstyle.cpp
  src/plugins/qmldesigner/CMakeLists.txt
  src/plugins/qmldesigner/components/formeditor/toolbox.cpp
  src/plugins/qmldesigner/components/itemlibrary/itemlibraryassetimporter.cpp
  src/plugins/qmldesigner/components/toolbar/toolbarbackend.cpp
  src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.h
  src/plugins/qmldesigner/qmldesignerexternaldependencies.cpp
  src/plugins/qmldesignerbase/qmldesignerbaseplugin.cpp
  src/plugins/qmldesignerbase/qmldesignerbaseplugin.h
  src/plugins/qmlprojectmanager/qmlproject.cpp
  src/tools/qml2puppet/CMakeLists.txt
  tests/unit/unittest/CMakeLists.txt

Change-Id: I2c5f18c4fca49471d02713ce5859032232cf7756

7 files changed, 82 insertions, 73 deletions

diff --git a/src/libs/sqlite/sqliteids.h b/src/libs/sqlite/sqliteids.h
index febc094242..e7a4f9fbae 100644
--- a/src/libs/sqlite/sqliteids.h
+++ b/src/libs/sqlite/sqliteids.h
@@ -56,7 +56,7 @@ public:
         return first.id - second.id;
     }
 
-    constexpr bool isValid() const { return id >= 0; }
+    constexpr bool isValid() const { return id > 0; }
 
     explicit operator bool() const { return isValid(); }
 
@@ -67,7 +67,7 @@ public:
     [[noreturn, deprecated]] InternalIntegerType operator&() const { throw std::exception{}; }
 
 private:
-    InternalIntegerType id = -1;
+    InternalIntegerType id = 0;
 };
 
 template<typename Container>
diff --git a/src/libs/sqlite/sqlitelibraryinitializer.cpp b/src/libs/sqlite/sqlitelibraryinitializer.cpp
index 927157dba7..0e90348c23 100644
--- a/src/libs/sqlite/sqlitelibraryinitializer.cpp
+++ b/src/libs/sqlite/sqlitelibraryinitializer.cpp
@@ -17,7 +17,7 @@ LibraryInitializer::LibraryInitializer()
     DatabaseBackend::initializeSqliteLibrary();
 }
 
-LibraryInitializer::~LibraryInitializer()
+LibraryInitializer::~LibraryInitializer() noexcept(false)
 {
     DatabaseBackend::shutdownSqliteLibrary();
 }
diff --git a/src/libs/sqlite/sqlitelibraryinitializer.h b/src/libs/sqlite/sqlitelibraryinitializer.h
index 27c891a1f4..bb42e822f8 100644
--- a/src/libs/sqlite/sqlitelibraryinitializer.h
+++ b/src/libs/sqlite/sqlitelibraryinitializer.h
@@ -14,7 +14,7 @@ public:
 
 private:
     LibraryInitializer();
-    ~LibraryInitializer();
+    ~LibraryInitializer() noexcept(false);
 };
 
 } // namespace Sqlite
diff --git a/src/libs/sqlite/sqlitereadstatement.h b/src/libs/sqlite/sqlitereadstatement.h
index ac764166ce..3df47efc74 100644
--- a/src/libs/sqlite/sqlitereadstatement.h
+++ b/src/libs/sqlite/sqlitereadstatement.h
@@ -34,57 +34,39 @@ public:
     template<typename ResultType, typename... QueryTypes>
     auto valueWithTransaction(const QueryTypes &...queryValues)
     {
-        DeferredTransaction transaction{Base::database()};
-
-        auto resultValue = Base::template value<ResultType>(queryValues...);
-
-        transaction.commit();
-
-        return resultValue;
+        return withDeferredTransaction(Base::database(), [&] {
+            return Base::template value<ResultType>(queryValues...);
+        });
     }
 
     template<typename ResultType, typename... QueryTypes>
     auto optionalValueWithTransaction(const QueryTypes &...queryValues)
     {
-        DeferredTransaction transaction{Base::database()};
-
-        auto resultValue = Base::template optionalValue<ResultType>(queryValues...);
-
-        transaction.commit();
-
-        return resultValue;
+        return withDeferredTransaction(Base::database(), [&] {
+            return Base::template optionalValue<ResultType>(queryValues...);
+        });
     }
 
     template<typename ResultType, typename... QueryTypes>
     auto valuesWithTransaction(std::size_t reserveSize, const QueryTypes &...queryValues)
     {
-        DeferredTransaction transaction{Base::database()};
-
-        auto resultValues = Base::template values<ResultType>(reserveSize, queryValues...);
-
-        transaction.commit();
-
-        return resultValues;
+        return withDeferredTransaction(Base::database(), [&] {
+            return Base::template values<ResultType>(reserveSize, queryValues...);
+        });
     }
 
     template<typename Callable, typename... QueryTypes>
     void readCallbackWithTransaction(Callable &&callable, const QueryTypes &...queryValues)
     {
-        DeferredTransaction transaction{Base::database()};
-
-        Base::readCallback(std::forward<Callable>(callable), queryValues...);
-
-        transaction.commit();
+        withDeferredTransaction(Base::database(), [&] {
+            Base::readCallback(std::forward<Callable>(callable), queryValues...);
+        });
     }
 
     template<typename Container, typename... QueryTypes>
     void readToWithTransaction(Container &container, const QueryTypes &...queryValues)
     {
-        DeferredTransaction transaction{Base::database()};
-
-        Base::readTo(container, queryValues...);
-
-        transaction.commit();
+        withDeferredTransaction(Base::database(), [&] { Base::readTo(container, queryValues...); });
     }
 
 protected:
diff --git a/src/libs/sqlite/sqlitereadwritestatement.h b/src/libs/sqlite/sqlitereadwritestatement.h
index 69d4865d6c..08f1aeda04 100644
--- a/src/libs/sqlite/sqlitereadwritestatement.h
+++ b/src/libs/sqlite/sqlitereadwritestatement.h
@@ -34,66 +34,48 @@ public:
     template<typename ResultType, typename... QueryTypes>
     auto valueWithTransaction(const QueryTypes &...queryValues)
     {
-        ImmediateTransaction transaction{Base::database()};
-
-        auto resultValue = Base::template value<ResultType>(queryValues...);
-
-        transaction.commit();
-
-        return resultValue;
+        return withImmediateTransaction(Base::database(), [&] {
+            return Base::template value<ResultType>(queryValues...);
+        });
     }
 
     template<typename ResultType, typename... QueryTypes>
     auto optionalValueWithTransaction(const QueryTypes &...queryValues)
     {
-        ImmediateTransaction transaction{Base::database()};
-
-        auto resultValue = Base::template optionalValue<ResultType>(queryValues...);
-
-        transaction.commit();
-
-        return resultValue;
+        return withImmediateTransaction(Base::database(), [&] {
+            return Base::template optionalValue<ResultType>(queryValues...);
+        });
     }
 
     template<typename ResultType, typename... QueryTypes>
     auto valuesWithTransaction(std::size_t reserveSize, const QueryTypes &...queryValues)
     {
-        ImmediateTransaction transaction{Base::database()};
-
-        auto resultValues = Base::template values<ResultType>(reserveSize, queryValues...);
-
-        transaction.commit();
-
-        return resultValues;
+        return withImmediateTransaction(Base::database(), [&] {
+            return Base::template values<ResultType>(reserveSize, queryValues...);
+        });
     }
 
     template<typename Callable, typename... QueryTypes>
     void readCallbackWithTransaction(Callable &&callable, const QueryTypes &...queryValues)
     {
-        ImmediateTransaction transaction{Base::database()};
-
-        Base::readCallback(std::forward<Callable>(callable), queryValues...);
-
-        transaction.commit();
+        withImmediateTransaction(Base::database(), [&] {
+            Base::readCallback(std::forward<Callable>(callable), queryValues...);
+        });
     }
 
     template<typename Container, typename... QueryTypes>
     void readToWithTransaction(Container &container, const QueryTypes &...queryValues)
     {
-        ImmediateTransaction transaction{Base::database()};
-
-        Base::readTo(container, queryValues...);
-
-        transaction.commit();
+        withImmediateTransaction(Base::database(), [&] {
+            Base::readTo(container, queryValues...);
+        });
     }
 
     void executeWithTransaction()
     {
-        ImmediateTransaction transaction{Base::database()};
-
-        Base::execute();
-
-        transaction.commit();
+        withImmediateTransaction(Base::database(), [&] {
+            Base::execute();
+        });
     }
 };
 
diff --git a/src/libs/sqlite/sqlitesessions.cpp b/src/libs/sqlite/sqlitesessions.cpp
index 0dea908e5f..96119cd20f 100644
--- a/src/libs/sqlite/sqlitesessions.cpp
+++ b/src/libs/sqlite/sqlitesessions.cpp
@@ -67,7 +67,7 @@ void Sessions::create()
 {
     sqlite3_session *newSession = nullptr;
     int resultCode = sqlite3session_create(database.backend().sqliteDatabaseHandle(),
-                                           std::string(databaseName.data()).c_str(),
+                                           std::string(databaseName).c_str(),
                                            &newSession);
     session.reset(newSession);
 
diff --git a/src/libs/sqlite/sqlitetransaction.h b/src/libs/sqlite/sqlitetransaction.h
index 45f8eebc33..2cc4a7bf5f 100644
--- a/src/libs/sqlite/sqlitetransaction.h
+++ b/src/libs/sqlite/sqlitetransaction.h
@@ -60,7 +60,6 @@ protected:
     {
     }
 
-
 protected:
     TransactionInterface &m_interface;
     std::unique_lock<TransactionInterface> m_locker{m_interface};
@@ -183,6 +182,38 @@ public:
     using Base::Base;
 };
 
+template<typename Transaction, typename TransactionInterface, typename Callable>
+auto withTransaction(TransactionInterface &transactionInterface, Callable &&callable)
+    -> std::invoke_result_t<Callable>
+{
+    Transaction transaction{transactionInterface};
+
+    if constexpr (std::is_void_v<std::invoke_result_t<Callable>>) {
+        callable();
+
+        transaction.commit();
+    } else {
+        auto results = callable();
+
+        transaction.commit();
+
+        return results;
+    }
+}
+
+template<typename TransactionInterface, typename Callable>
+auto withDeferredTransaction(TransactionInterface &transactionInterface, Callable &&callable)
+{
+    if constexpr (std::is_void_v<std::invoke_result_t<Callable>>) {
+        withTransaction<DeferredTransaction<TransactionInterface>>(transactionInterface,
+                                                                   std::forward<Callable>(callable));
+    } else {
+        return withTransaction<DeferredTransaction<TransactionInterface>>(transactionInterface,
+                                                                          std::forward<Callable>(
+                                                                              callable));
+    }
+}
+
 template<typename TransactionInterface>
 DeferredTransaction(TransactionInterface &) -> DeferredTransaction<TransactionInterface>;
 
@@ -226,6 +257,20 @@ public:
     using Base::Base;
 };
 
+template<typename TransactionInterface, typename Callable>
+auto withImmediateTransaction(TransactionInterface &transactionInterface, Callable &&callable)
+{
+    if constexpr (std::is_void_v<std::invoke_result_t<Callable>>) {
+        withTransaction<ImmediateTransaction<TransactionInterface>>(transactionInterface,
+                                                                    std::forward<Callable>(
+                                                                        callable));
+    } else {
+        return withTransaction<ImmediateTransaction<TransactionInterface>>(transactionInterface,
+                                                                           std::forward<Callable>(
+                                                                               callable));
+    }
+}
+
 template<typename TransactionInterface>
 ImmediateTransaction(TransactionInterface &) -> ImmediateTransaction<TransactionInterface>;