diff options
Diffstat (limited to 'src/concurrent/doc')
3 files changed, 168 insertions, 4 deletions
diff --git a/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp index 5437822842..0b82766054 100644 --- a/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp +++ b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp @@ -93,7 +93,7 @@ QString result = future.result(); //! [4] // call 'QList<QByteArray> QByteArray::split(char sep) const' in a separate thread QByteArray bytearray = "hello world"; -QFuture<QList<QByteArray> > future = QtConcurrent::run(bytearray, &QByteArray::split, ','); +QFuture<QList<QByteArray> > future = QtConcurrent::run(&QByteArray::split, bytearray, ','); ... QList<QByteArray> result = future.result(); //! [4] @@ -101,16 +101,46 @@ QList<QByteArray> result = future.result(); //! [5] // call 'void QImage::invertPixels(InvertMode mode)' in a separate thread QImage image = ...; -QFuture<void> future = QtConcurrent::run(&image, &QImage::invertPixels, QImage::InvertRgba); +QFuture<void> future = QtConcurrent::run(&QImage::invertPixels, &image, QImage::InvertRgba); ... future.waitForFinished(); // At this point, the pixels in 'image' have been inverted //! [5] - //! [6] QFuture<void> future = QtConcurrent::run([=]() { // Code in this block will run in another thread }); ... //! [6] + +//! [7] +static void addOne(int &n) { ++n; } +... +int n = 42; +QtConcurrent::run(&addOne, std::ref(n)).waitForFinished(); // n == 43 +//! [7] + +//! [8] +struct TestClass +{ + void operator()(int s1) { s = s1; } + int s = 42; +}; + +... + +TestClass o; + +// Modify original object +QtConcurrent::run(std::ref(o), 15).waitForFinished(); // o.s == 15 + +// Modify a copy of the original object +QtConcurrent::run(o, 42).waitForFinished(); // o.s == 15 + +// Use a temporary object +QtConcurrent::run(TestClass(), 42).waitForFinished(); + +// Ill-formed +QtConcurrent::run(&o, 42).waitForFinished(); // compilation error +//! [8] diff --git a/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrenttask.cpp b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrenttask.cpp new file mode 100644 index 0000000000..bec45ba3bf --- /dev/null +++ b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrenttask.cpp @@ -0,0 +1,127 @@ +/**************************************************************************** +** +** Copyright (C) 2020 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** BSD License Usage +** Alternatively, you may use this file under the terms of the BSD license +** as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of The Qt Company Ltd nor the names of its +** contributors may be used to endorse or promote products derived +** from this software without specific prior written permission. +** +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +//! [0] +QtConcurrent::task([]{ qDebug("Hello, world!"); }).spawn(); +//! [0] + +//! [1] +auto task = [](const QString &s){ qDebug() << ("Hello, " + s); }; +QtConcurrent::task(std::move(task)) + .withArguments("world!") + .spawn(); +//! [1] + +//! [2] +QString s("Hello, "); +QtConcurrent::task([](QString &s){ s.append("world!"); }) + .withArguments(std::ref(s)) + .spawn(); +//! [2] + +//! [3] +auto future = QtConcurrent::task([]{ return 42; }).spawn(); +auto result = future.result(); // result == 42 +//! [3] + +//! [4] +std::is_invocable_v<std::decay_t<Task>, std::decay_t<Args>...> +//! [4] + +//! [5] +QVariant value(42); +auto result = QtConcurrent::task(&qvariant_cast<int>) + .withArguments(value) + .spawn() + .result(); // result == 42 +//! [5] + +//! [6] +QString result("Hello, world!"); + +QtConcurrent::task(&QString::chop) + .withArguments(&result, 8) + .spawn() + .waitForFinished(); // result == "Hello" +//! [6] + +//! [7] +auto result = QtConcurrent::task(std::plus<int>()) + .withArguments(40, 2) + .spawn() + .result() // result == 42 +//! [7] + +//! [8] +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 +//! [8] + +//! [9] +QThreadPool pool; +QtConcurrent::task([]{ return 42; }).onThreadPool(pool).spawn(); +//! [9] + +//! [10] +QtConcurrent::task([]{ return 42; }).withPriority(10).spawn(); +//! [10] diff --git a/src/concurrent/doc/src/qtconcurrent-index.qdoc b/src/concurrent/doc/src/qtconcurrent-index.qdoc index 3e4aa791f1..666eec533b 100644 --- a/src/concurrent/doc/src/qtconcurrent-index.qdoc +++ b/src/concurrent/doc/src/qtconcurrent-index.qdoc @@ -79,6 +79,13 @@ another thread. \endlist + \li \l {Concurrent Task} + \list + \li \l {QtConcurrent::task}{QtConcurrent::task()} creates an instance + of QtConcurrent::QTaskBuilder. This object can be used for adjusting + parameters and for kicking off a task in a separate thread. + \endlist + \li QFuture represents the result of an asynchronous computation. \li QFutureIterator allows iterating through results available via QFuture. @@ -115,7 +122,7 @@ \li Supported \row \li Bidirectional Iterator - \li QLinkedList, std::list + \li std::list \li Supported \row \li Random Access Iterator |