QTaskBuilder::spawn: add an overload that doesn't return a future object

Fixes: QTBUG-83175
Change-Id: Idf85e47a2732742884272200d5c753805eaa640b
Reviewed-by: Sona Kurazyan <sona.kurazyan@qt.io>

src/concurrent/doc/snippets/code/src_concurrent_qtconcurrenttask.cpp

@@ -125,3 +125,7 @@ QtConcurrent::task([]{ return 42; }).onThreadPool(pool).spawn();
 //! [10]
 QtConcurrent::task([]{ return 42; }).withPriority(10).spawn();
 //! [10]
+
+//! [11]
+QtConcurrent::task([]{ qDebug("Hello, world!"); }).spawn(FutureResult::Ignore);
+//! [11]

src/concurrent/qtaskbuilder.h

@@ -52,6 +52,8 @@ QT_BEGIN_NAMESPACE
 
 namespace QtConcurrent {
 
+enum class FutureResult { Ignore };
+
 using InvokeResultType = int;
 
 template <class Task, class ...Args>
@@ -61,6 +63,8 @@ public:
     [[nodiscard]]
     QFuture<InvokeResultType> spawn();
 
+    void spawn(FutureResult);
+
     template <class ...ExtraArgs>
     [[nodiscard]]
     QTaskBuilder<Task, ExtraArgs...> withArguments(ExtraArgs &&...args);
@@ -78,6 +82,8 @@ public:
 
 namespace QtConcurrent {
 
+enum class FutureResult { Ignore };
+
 template <class Task, class ...Args>
 class QTaskBuilder
 {
@@ -89,6 +95,12 @@ public:
                    ->start(startParameters);
     }
 
+    void spawn(FutureResult)
+    {
+        (new StoredFunctionCall<Task, Args...>(std::move(taskWithArgs)))
+            ->start(startParameters);
+    }
+
     template <class ...ExtraArgs>
     [[nodiscard]]
     constexpr auto withArguments(ExtraArgs &&...args)

src/concurrent/qtaskbuilder.qdoc

@@ -44,6 +44,13 @@
     This is a non-blocking call. The task might not start immediately.
 */
 
+/*!
+    \fn template <class Task, class ...Args> void QtConcurrent::QTaskBuilder<Task, Args...>::spawn(QtConcurrent::FutureResult)
+
+    Runs the task in a separate thread. This is a non-blocking call.
+    The task might not start immediately.
+*/
+
 /*!
     \fn template <class Task, class ...Args> template <class ...ExtraArgs> [[nodiscard]] QTaskBuilder<Task, ExtraArgs...> QtConcurrent::QTaskBuilder<Task, Args...>::withArguments(ExtraArgs &&...args)
 
@@ -80,3 +87,15 @@
     The real implementation also contains a compile-time check for
     whether the task can be invoked with the specified arguments or not.
 */
+
+/*!
+    \enum QtConcurrent::FutureResult
+
+    This enum type is used to invoke a special overload of
+    QtConcurrent::QTaskBuilder::spawn(QtConcurrent::FutureResult)
+    that doesn't return a future object.
+
+    \value Ignore
+           An auxiliary tag which introduced to improve code
+           readability.
+*/

src/concurrent/qtconcurrenttask.qdoc

@@ -143,6 +143,11 @@
     You can set the priority for a task:
 
     \snippet code/src_concurrent_qtconcurrenttask.cpp 10
+
+    If you don't need a future object, you can call
+    QtConcurrent::QTaskBuilder::spawn(QtConcurrent::FutureResult::Ignore):
+
+    \snippet code/src_concurrent_qtconcurrenttask.cpp 11
 */
 
 /*!

tests/auto/concurrent/qtconcurrenttask/tst_qtconcurrenttask.cpp

@@ -43,6 +43,7 @@ private Q_SLOTS:
     void useCustomThreadPool();
     void setPriority();
     void adjustAllSettings();
+    void ignoreFutureResult();
 };
 
 using namespace QtConcurrent;
@@ -155,6 +156,20 @@ void tst_QtConcurrentTask::adjustAllSettings()
 
     QCOMPARE(result, QVector<int>({1, 2, 3}));
 }
+void tst_QtConcurrentTask::ignoreFutureResult()
+{
+    QThreadPool pool;
+
+    std::atomic_int value = 0;
+    for (std::size_t i = 0; i < 10; ++i)
+        task([&value]{ ++value; })
+            .onThreadPool(pool)
+            .spawn(FutureResult::Ignore);
+
+    pool.waitForDone();
+
+    QCOMPARE(value, 10);
+}
 
 QTEST_MAIN(tst_QtConcurrentTask)
 #include "tst_qtconcurrenttask.moc"