src_concurrent_qtconcurrenttask.cpp

Go to the documentation of this file.

// Copyright (C) 2020 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
QtConcurrent::task([]{ qDebug("Hello, world!"); }).spawn();
 
auto task = [](const QString &s){ qDebug() << ("Hello, " + s); };
QtConcurrent::task(std::move(task))
    .withArguments("world!")
    .spawn();
 
QString s("Hello, ");
QtConcurrent::task([](QString &s){ s.append("world!"); })
    .withArguments(std::ref(s))
    .spawn();
 
auto future = QtConcurrent::task([]{ return 42; }).spawn();
auto result = future.result(); // result == 42
 
std::is_invocable_v<std::decay_t<Task>, std::decay_t<Args>...>
 
QVariant value(42);
auto result = QtConcurrent::task([](const QVariant &var){return qvariant_cast<int>(var);})
                  .withArguments(value)
                  .spawn()
                  .result(); // result == 42
 
QString result("Hello, world!");
 
QtConcurrent::task(&QString::chop)
    .withArguments(&result, 8)
    .spawn()
    .waitForFinished(); // result == "Hello"
 
auto result = QtConcurrent::task(std::plus<int>())
                  .withArguments(40, 2)
                  .spawn()
                  .result() // result == 42
 
struct CallableWithState
{
    void operator()(int newState) { state = newState; }
 
    // ...
};
 
// ...
 
CallableWithState object;
 
QtConcurrent::task(std::ref(object))
   .withArguments(42)
   .spawn()
   .waitForFinished(); // The object's state is set to 42
 
QThreadPool pool;
QtConcurrent::task([]{ return 42; }).onThreadPool(pool).spawn();
 
QtConcurrent::task([]{ return 42; }).withPriority(10).spawn();
 
QtConcurrent::task([]{ qDebug("Hello, world!"); }).spawn(FutureResult::Ignore);
 
void increment(QPromise<int> &promise, int i)
{
    promise.addResult(i + 1);
}
 
int result = QtConcurrent::task(&increment).withArguments(10).spawn().result(); // result == 11