diff options
Diffstat (limited to 'src/concurrent')
| -rw-r--r-- | src/concurrent/concurrent.pro | 3 | ||||
| -rw-r--r-- | src/concurrent/doc/qtconcurrent.qdocconf | 92 | ||||
| -rw-r--r-- | src/concurrent/doc/snippets/code/src_concurrent_qfuture.cpp | 64 | ||||
| -rw-r--r-- | src/concurrent/doc/snippets/code/src_concurrent_qfuturesynchronizer.cpp | 53 | ||||
| -rw-r--r-- | src/concurrent/doc/snippets/code/src_concurrent_qfuturewatcher.cpp | 50 | ||||
| -rw-r--r-- | src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentexception.cpp | 75 | ||||
| -rw-r--r-- | src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentfilter.cpp | 171 | ||||
| -rw-r--r-- | src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentmap.cpp | 184 | ||||
| -rw-r--r-- | src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp | 98 | ||||
| -rw-r--r-- | src/concurrent/qfuture.cpp | 6 | ||||
| -rw-r--r-- | src/concurrent/qfuturesynchronizer.cpp | 2 | ||||
| -rw-r--r-- | src/concurrent/qfuturewatcher.cpp | 2 | ||||
| -rw-r--r-- | src/concurrent/qtconcurrentexception.cpp | 8 | ||||
| -rw-r--r-- | src/concurrent/qtconcurrentfilter.cpp | 28 | ||||
| -rw-r--r-- | src/concurrent/qtconcurrentmap.cpp | 32 | ||||
| -rw-r--r-- | src/concurrent/qtconcurrentrun.cpp | 14 |
16 files changed, 836 insertions, 46 deletions
diff --git a/src/concurrent/concurrent.pro b/src/concurrent/concurrent.pro index 6bf16e6a0a..54359f7d3b 100644 --- a/src/concurrent/concurrent.pro +++ b/src/concurrent/concurrent.pro @@ -57,6 +57,9 @@ HEADERS += \ qfutureinterface_p.h \ qfuturewatcher_p.h +QMAKE_DOCS = $$PWD/doc/qtconcurrent.qdocconf +QMAKE_DOCS_INDEX = ../../doc + contains(QT_CONFIG, clock-gettime) { linux-*|hpux-*|solaris-*:LIBS *= -lrt } diff --git a/src/concurrent/doc/qtconcurrent.qdocconf b/src/concurrent/doc/qtconcurrent.qdocconf new file mode 100644 index 0000000000..d8d66a92c9 --- /dev/null +++ b/src/concurrent/doc/qtconcurrent.qdocconf @@ -0,0 +1,92 @@ +include(../../../doc/global/qt-cpp-ignore.qdocconf) + +project = QtConcurrent +description = Qt Concurrent Reference Documentation +url = http://qt-project.org/doc/qt-5.0/qtconcurrent +version = 5.0.0 + +sourceencoding = UTF-8 +outputencoding = UTF-8 +naturallanguage = en_US +qhp.projects = QtConcurrent + +qhp.QtConcurrent.file = qtconcurrent.qhp +qhp.QtConcurrent.namespace = org.qt-project.qtconcurrent.500 +qhp.QtConcurrent.virtualFolder = qdoc +qhp.QtConcurrent.indexTitle = Qt Concurrent Reference Documentation +qhp.QtConcurrent.indexRoot = + +qhp.QtConcurrent.filterAttributes = qtconcurrent 5.0.0 qtrefdoc +qhp.QtConcurrent.customFilters.Qt.name = QtConcurrent 5.0.0 +qhp.QtConcurrent.customFilters.Qt.filterAttributes = qtconcurrent 5.0.0 +qhp.QtConcurrent.subprojects = classes overviews examples +qhp.QtConcurrent.subprojects.classes.title = Classes +qhp.QtConcurrent.subprojects.classes.indexTitle = Qt Concurrent's Classes +qhp.QtConcurrent.subprojects.classes.selectors = class fake:headerfile +qhp.QtConcurrent.subprojects.classes.sortPages = true +qhp.QtConcurrent.subprojects.overviews.title = Overviews +qhp.QtConcurrent.subprojects.overviews.indexTitle = All Overviews and HOWTOs +qhp.QtConcurrent.subprojects.overviews.selectors = fake:page,group,module +qhp.QtConcurrent.subprojects.examples.title = Qt Concurrent Examples +qhp.QtConcurrent.subprojects.examples.indexTitle = Qt Concurrent Examples +qhp.QtConcurrent.subprojects.examples.selectors = fake:example + +dita.metadata.default.author = Qt Project +dita.metadata.default.permissions = all +dita.metadata.default.publisher = Qt Project +dita.metadata.default.copyryear = 2012 +dita.metadata.default.copyrholder = Nokia +dita.metadata.default.audience = programmer + +sources.fileextensions = "*.c++ *.cc *.cpp *.cxx *.mm *.qml *.qdoc" +headers.fileextensions = "*.ch *.h *.h++ *.hh *.hpp *.hxx" + +examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp *.qml *.css" +examples.imageextensions = "*.png" + +outputdir = ../../../doc/qtconcurrent +tagfile = ../../../doc/qtconcurrent/qtconcurrent.tags + +HTML.generatemacrefs = "true" +HTML.nobreadcrumbs = "true" + +HTML.templatedir = . + +HTML.stylesheets = ../../../doc/global/style/offline.css + +HTML.headerstyles = \ + " <link rel=\"stylesheet\" type=\"text/css\" href=\"style/offline.css\" />\n" + +HTML.endheader = \ + "</head>\n" \ + +defines = Q_QDOC \ + QT_.*_SUPPORT \ + QT_.*_LIB \ + QT_COMPAT \ + QT_KEYPAD_NAVIGATION \ + QT_NO_EGL \ + Q_WS_.* \ + Q_OS_.* \ + Q_BYTE_ORDER \ + QT_DEPRECATED \ + QT_DEPRECATED_* \ + Q_NO_USING_KEYWORD \ + __cplusplus \ + Q_COMPILER_INITIALIZER_LISTS + +versionsym = QT_VERSION_STR + +codeindent = 1 + +depends += qtcore + +headerdirs += .. + +sourcedirs += .. + +exampledirs += ../../../examples \ + ../ \ + snippets + +imagedirs += images diff --git a/src/concurrent/doc/snippets/code/src_concurrent_qfuture.cpp b/src/concurrent/doc/snippets/code/src_concurrent_qfuture.cpp new file mode 100644 index 0000000000..ddf075b6ca --- /dev/null +++ b/src/concurrent/doc/snippets/code/src_concurrent_qfuture.cpp @@ -0,0 +1,64 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** 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 Nokia Corporation and its Subsidiary(-ies) 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] +QFuture<QString> future = ...; + +QFuture<QString>::const_iterator i; +for (i = future.constBegin(); i != future.constEnd(); ++i) + cout << *i << endl; +//! [0] + + +//! [1] +QFuture<QString> future; +... +QFutureIterator<QString> i(future); +while (i.hasNext()) + qDebug() << i.next(); +//! [1] + + +//! [2] +QFutureIterator<QString> i(future); +i.toBack(); +while (i.hasPrevious()) + qDebug() << i.previous(); +//! [2] diff --git a/src/concurrent/doc/snippets/code/src_concurrent_qfuturesynchronizer.cpp b/src/concurrent/doc/snippets/code/src_concurrent_qfuturesynchronizer.cpp new file mode 100644 index 0000000000..77003791e9 --- /dev/null +++ b/src/concurrent/doc/snippets/code/src_concurrent_qfuturesynchronizer.cpp @@ -0,0 +1,53 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** 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 Nokia Corporation and its Subsidiary(-ies) 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] +void someFunction() +{ + QFutureSynchronizer<void> synchronizer; + + ... + + synchronizer.addFuture(QtConcurrent::run(anotherFunction)); + synchronizer.addFuture(QtConcurrent::map(list, mapFunction)); + + return; // QFutureSynchronizer waits for all futures to finish +} +//! [0] diff --git a/src/concurrent/doc/snippets/code/src_concurrent_qfuturewatcher.cpp b/src/concurrent/doc/snippets/code/src_concurrent_qfuturewatcher.cpp new file mode 100644 index 0000000000..703275bc7a --- /dev/null +++ b/src/concurrent/doc/snippets/code/src_concurrent_qfuturewatcher.cpp @@ -0,0 +1,50 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** 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 Nokia Corporation and its Subsidiary(-ies) 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] +// Instantiate the objects and connect to the finished signal. +MyClass myObject; +QFutureWatcher<int> watcher; +connect(&watcher, SIGNAL(finished()), &myObject, SLOT(handleFinished())); + +// Start the computation. +QFuture<int> future = QtConcurrent::run(...); +watcher.setFuture(future); +//! [0] diff --git a/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentexception.cpp b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentexception.cpp new file mode 100644 index 0000000000..cf0257c45b --- /dev/null +++ b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentexception.cpp @@ -0,0 +1,75 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** 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 Nokia Corporation and its Subsidiary(-ies) 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] + +class MyException : public QtConcurrent::Exception +{ +public: + void raise() const { throw *this; } + Exception *clone() const { return new MyException(*this); } +}; + +//! [0] + + +//! [1] + +try { + QtConcurrent::blockingMap(list, throwFunction); // throwFunction throws MyException +} catch (MyException &e) { + // handle exception +} + +//! [1] + + +//! [2] + +void MyException::raise() const { throw *this; } + +//! [2] + + +//! [3] + +MyException *MyException::clone() const { return new MyException(*this); } + +//! [3] diff --git a/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentfilter.cpp b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentfilter.cpp new file mode 100644 index 0000000000..2acf467e9a --- /dev/null +++ b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentfilter.cpp @@ -0,0 +1,171 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** 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 Nokia Corporation and its Subsidiary(-ies) 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] +bool function(const T &t); +//! [0] + + +//! [1] +bool allLowerCase(const QString &string) +{ + return string.lowered() == string; +} + +QStringList strings = ...; +QFuture<QString> lowerCaseStrings = QtConcurrent::filtered(strings, allLowerCase); +//! [1] + + +//! [2] +QStringList strings = ...; +QFuture<void> future = QtConcurrent::filter(strings, allLowerCase); +//! [2] + + +//! [3] +V function(T &result, const U &intermediate) +//! [3] + + +//! [4] +void addToDictionary(QSet<QString> &dictionary, const QString &string) +{ + dictionary.insert(string); +} + +QStringList strings = ...; +QFuture<QSet<QString> > dictionary = QtConcurrent::filteredReduced(strings, allLowerCase, addToDictionary); +//! [4] + + +//! [5] +QStringList strings = ...; +QFuture<QString> lowerCaseStrings = QtConcurrent::filtered(strings.constBegin(), strings.constEnd(), allLowerCase); + +// filter in-place only works on non-const iterators +QFuture<void> future = QtConcurrent::filter(strings.begin(), strings.end(), allLowerCase); + +QFuture<QSet<QString> > dictionary = QtConcurrent::filteredReduced(strings.constBegin(), strings.constEnd(), allLowerCase, addToDictionary); +//! [5] + + +//! [6] +QStringList strings = ...; + +// each call blocks until the entire operation is finished +QStringList lowerCaseStrings = QtConcurrent::blockingFiltered(strings, allLowerCase); + + +QtConcurrent::blockingFilter(strings, allLowerCase); + +QSet<QString> dictionary = QtConcurrent::blockingFilteredReduced(strings, allLowerCase, addToDictionary); +//! [6] + + +//! [7] +// keep only images with an alpha channel +QList<QImage> images = ...; +QFuture<void> alphaImages = QtConcurrent::filter(strings, &QImage::hasAlphaChannel); + +// keep only gray scale images +QList<QImage> images = ...; +QFuture<QImage> grayscaleImages = QtConcurrent::filtered(images, &QImage::isGrayscale); + +// create a set of all printable characters +QList<QChar> characters = ...; +QFuture<QSet<QChar> > set = QtConcurrent::filteredReduced(characters, &QChar::isPrint, &QSet<QChar>::insert); +//! [7] + + +//! [8] +// can mix normal functions and member functions with QtConcurrent::filteredReduced() + +// create a dictionary of all lower cased strings +extern bool allLowerCase(const QString &string); +QStringList strings = ...; +QFuture<QSet<int> > averageWordLength = QtConcurrent::filteredReduced(strings, allLowerCase, QSet<QString>::insert); + +// create a collage of all gray scale images +extern void addToCollage(QImage &collage, const QImage &grayscaleImage); +QList<QImage> images = ...; +QFuture<QImage> collage = QtConcurrent::filteredReduced(images, &QImage::isGrayscale, addToCollage); +//! [8] + + +//! [9] +bool QString::contains(const QRegExp ®exp) const; +//! [9] + + +//! [10] +boost::bind(&QString::contains, QRegExp("^\\S+$")); // matches strings without whitespace +//! [10] + + +//! [11] +bool contains(const QString &string) +//! [11] + + +//! [12] +QStringList strings = ...; +boost::bind(static_cast<bool(QString::*)(const QRegExp&)>( &QString::contains ), QRegExp("..." )); +//! [12] + +//! [13] +struct StartsWith +{ + StartsWith(const QString &string) + : m_string(string) { } + + typedef bool result_type; + + bool operator()(const QString &testString) + { + return testString.startsWith(m_string); + } + + QString m_string; +}; + +QList<QString> strings = ...; +QFuture<QString> fooString = QtConcurrent::filtered(images, StartsWith(QLatin1String("Foo"))); +//! [13] diff --git a/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentmap.cpp b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentmap.cpp new file mode 100644 index 0000000000..9b83ad5bef --- /dev/null +++ b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentmap.cpp @@ -0,0 +1,184 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** 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 Nokia Corporation and its Subsidiary(-ies) 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] +U function(const T &t); +//! [0] + + +//! [1] +QImage scaled(const QImage &image) +{ + return image.scaled(100, 100); +} + +QList<QImage> images = ...; +QFuture<QImage> thumbnails = QtConcurrent::mapped(images, scaled); +//! [1] + + +//! [2] +U function(T &t); +//! [2] + + +//! [3] +void scale(QImage &image) +{ + image = image.scaled(100, 100); +} + +QList<QImage> images = ...; +QFuture<void> future = QtConcurrent::map(images, scale); +//! [3] + + +//! [4] +V function(T &result, const U &intermediate) +//! [4] + + +//! [5] +void addToCollage(QImage &collage, const QImage &thumbnail) +{ + QPainter p(&collage); + static QPoint offset = QPoint(0, 0); + p.drawImage(offset, thumbnail); + offset += ...; +} + +QList<QImage> images = ...; +QFuture<QImage> collage = QtConcurrent::mappedReduced(images, scaled, addToCollage); +//! [5] + + +//! [6] +QList<QImage> images = ...; + +QFuture<QImage> thumbnails = QtConcurrent::mapped(images.constBegin(), images.constEnd(), scaled); + +// map in-place only works on non-const iterators +QFuture<void> future = QtConcurrent::map(images.begin(), images.end(), scale); + +QFuture<QImage> collage = QtConcurrent::mappedReduced(images.constBegin(), images.constEnd(), scaled, addToCollage); +//! [6] + + +//! [7] +QList<QImage> images = ...; + +// each call blocks until the entire operation is finished +QList<QImage> future = QtConcurrent::blockingMapped(images, scaled); + +QtConcurrent::blockingMap(images, scale); + +QImage collage = QtConcurrent::blockingMappedReduced(images, scaled, addToCollage); +//! [7] + + +//! [8] +// squeeze all strings in a QStringList +QStringList strings = ...; +QFuture<void> squeezedStrings = QtConcurrent::map(strings, &QString::squeeze); + +// swap the rgb values of all pixels on a list of images +QList<QImage> images = ...; +QFuture<QImage> bgrImages = QtConcurrent::mapped(images, &QImage::rgbSwapped); + +// create a set of the lengths of all strings in a list +QStringList strings = ...; +QFuture<QSet<int> > wordLengths = QtConcurrent::mappedReduced(string, &QString::length, &QSet<int>::insert); +//! [8] + + +//! [9] +// can mix normal functions and member functions with QtConcurrent::mappedReduced() + +// compute the average length of a list of strings +extern void computeAverage(int &average, int length); +QStringList strings = ...; +QFuture<int> averageWordLength = QtConcurrent::mappedReduced(strings, &QString::length, computeAverage); + +// create a set of the color distribution of all images in a list +extern int colorDistribution(const QImage &string); +QList<QImage> images = ...; +QFuture<QSet<int> > totalColorDistribution = QtConcurrent::mappedReduced(images, colorDistribution, QSet<int>::insert); +//! [9] + + +//! [10] +QImage QImage::scaledToWidth(int width, Qt::TransformationMode) const; +//! [10] + + +//! [11] +boost::bind(&QImage::scaledToWidth, 100, Qt::SmoothTransformation) +//! [11] + + +//! [12] +QImage scaledToWith(const QImage &image) +//! [12] + + +//! [13] +QList<QImage> images = ...; +QFuture<QImage> thumbnails = QtConcurrent::mapped(images, boost::bind(&QImage::scaledToWidth, 100 Qt::SmoothTransformation)); +//! [13] + +//! [14] +struct Scaled +{ + Scaled(int size) + : m_size(size) { } + + typedef QImage result_type; + + QImage operator()(const QImage &image) + { + return image.scaled(m_size, m_size); + } + + int m_size; +}; + +QList<QImage> images = ...; +QFuture<QImage> thumbnails = QtConcurrent::mapped(images, Scaled(100)); +//! [14] diff --git a/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp new file mode 100644 index 0000000000..362f084092 --- /dev/null +++ b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp @@ -0,0 +1,98 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the documentation of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** 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 Nokia Corporation and its Subsidiary(-ies) 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] +extern void aFunction(); +QFuture<void> future = QtConcurrent::run(aFunction); +//! [0] + + +//! [1] +extern void aFunctionWithArguments(int arg1, double arg2, const QString &string); + +int integer = ...; +double floatingPoint = ...; +QString string = ...; + +QFuture<void> future = QtConcurrent::run(aFunctionWithArguments, integer, floatingPoint, string); +//! [1] + + +//! [2] +extern QString functionReturningAString(); +QFuture<QString> future = QtConcurrent::run(functionReturningAString); +... +QString result = future.result(); +//! [2] + + +//! [3] +extern QString someFunction(const QByteArray &input); + +QByteArray bytearray = ...; + +QFuture<QString> future = QtConcurrent::run(someFunction, bytearray); +... +QString result = future.result(); +//! [3] + +//! [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, ','); +... +QList<QByteArray> result = future.result(); +//! [4] + +//! [5] +// call 'void QImage::invertPixels(InvertMode mode)' in a separate thread +QImage image = ...; +QFuture<void> future = QtConcurrent::run(&image, &QImage::invertPixels, QImage::InvertRgba); +... +future.waitForFinished(); +// At this point, the pixels in 'image' have been inverted +//! [5] + + +//! [6] +void someFunction(int arg1, double arg2); +QFuture<void> future = QtConcurrent::run(boost::bind(someFunction, 1, 2.0)); +... +//! [6] diff --git a/src/concurrent/qfuture.cpp b/src/concurrent/qfuture.cpp index 9805454cb2..f8151f3228 100644 --- a/src/concurrent/qfuture.cpp +++ b/src/concurrent/qfuture.cpp @@ -374,7 +374,7 @@ QFuture::constBegin() or QFuture::constEnd() before you start iterating. Here's a typical loop that prints all the results available in a future: - \snippet doc/src/snippets/code/src_corelib_concurrent_qfuture.cpp 0 + \snippet code/src_concurrent_qfuture.cpp 0 \sa QFutureIterator, QFuture */ @@ -555,7 +555,7 @@ list (i.e. before the first result). Here's how to iterate over all the results sequentially: - \snippet doc/src/snippets/code/src_corelib_concurrent_qfuture.cpp 1 + \snippet code/src_concurrent_qfuture.cpp 1 The next() function returns the next result (waiting for it to become available, if necessary) from the future and advances the iterator. Unlike @@ -570,7 +570,7 @@ Here's how to iterate over the elements in reverse order: - \snippet doc/src/snippets/code/src_corelib_concurrent_qfuture.cpp 2 + \snippet code/src_concurrent_qfuture.cpp 2 If you want to find all occurrences of a particular value, use findNext() or findPrevious() in a loop. diff --git a/src/concurrent/qfuturesynchronizer.cpp b/src/concurrent/qfuturesynchronizer.cpp index 34b00daf4f..3bb81e06c4 100644 --- a/src/concurrent/qfuturesynchronizer.cpp +++ b/src/concurrent/qfuturesynchronizer.cpp @@ -57,7 +57,7 @@ an easy way to ensure that all futures have finished before returning from a function: - \snippet doc/src/snippets/code/src_corelib_concurrent_qfuturesynchronizer.cpp 0 + \snippet code/src_concurrent_qfuturesynchronizer.cpp 0 The behavior of waitForFinished() can be changed using the setCancelOnWait() function. Calling setCancelOnWait(true) will cause diff --git a/src/concurrent/qfuturewatcher.cpp b/src/concurrent/qfuturewatcher.cpp index 9153fe5d40..eb5fb0e18d 100644 --- a/src/concurrent/qfuturewatcher.cpp +++ b/src/concurrent/qfuturewatcher.cpp @@ -86,7 +86,7 @@ QT_BEGIN_NAMESPACE Example: Starting a computation and getting a slot callback when it's finished: - \snippet doc/src/snippets/code/src_corelib_concurrent_qfuturewatcher.cpp 0 + \snippet code/src_concurrent_qfuturewatcher.cpp 0 Be aware that not all asynchronous computations can be canceled or paused. For example, the future returned by QtConcurrent::run() cannot be diff --git a/src/concurrent/qtconcurrentexception.cpp b/src/concurrent/qtconcurrentexception.cpp index 57eb604d39..a13ddb3173 100644 --- a/src/concurrent/qtconcurrentexception.cpp +++ b/src/concurrent/qtconcurrentexception.cpp @@ -56,12 +56,12 @@ QT_BEGIN_NAMESPACE boundaries, provided that the exception inherit from QtConcurrent::Exception and implement two helper functions: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentexception.cpp 0 + \snippet code/src_concurrent_qtconcurrentexception.cpp 0 QtConcurrent::Exception subclasses must be thrown by value and caught by reference: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentexception.cpp 1 + \snippet code/src_concurrent_qtconcurrentexception.cpp 1 If you throw an exception that is not a subclass of QtConcurrent::Exception, the Qt Concurrent functions will throw a QtConcurrent::UnhandledException @@ -80,14 +80,14 @@ QT_BEGIN_NAMESPACE \fn QtConcurrent::Exception::raise() const In your QtConcurrent::Exception subclass, reimplement raise() like this: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentexception.cpp 2 + \snippet code/src_concurrent_qtconcurrentexception.cpp 2 */ /*! \fn QtConcurrent::Exception::clone() const In your QtConcurrent::Exception subclass, reimplement clone() like this: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentexception.cpp 3 + \snippet code/src_concurrent_qtconcurrentexception.cpp 3 */ /*! diff --git a/src/concurrent/qtconcurrentfilter.cpp b/src/concurrent/qtconcurrentfilter.cpp index 76ce8ca659..8a87af2868 100644 --- a/src/concurrent/qtconcurrentfilter.cpp +++ b/src/concurrent/qtconcurrentfilter.cpp @@ -60,7 +60,7 @@ result instead of a QFuture. You use them in the same way as the asynchronous variants. - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 6 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 6 Note that the result types above are not QFuture objects, but real result types (in this case, QStringList and QSet<QString>). @@ -73,7 +73,7 @@ The filter function must be of the form: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 0 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 0 T must match the type stored in the sequence. The function returns true if the item should be kept, false if it should be discarded. @@ -81,7 +81,7 @@ This example shows how to keep strings that are all lower-case from a QStringList: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 1 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 1 The results of the filter are made available through QFuture. See the QFuture and QFutureWatcher documentation for more information on how to @@ -89,7 +89,7 @@ If you want to modify a sequence in-place, use QtConcurrent::filter(): - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 2 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 2 Since the sequence is modified in place, QtConcurrent::filter() does not return any results via QFuture. However, you can still use QFuture and @@ -103,7 +103,7 @@ The reduce function must be of the form: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 3 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 3 T is the type of the final result, U is the type of items being filtered. Note that the return value and return type of the reduce function are not @@ -111,7 +111,7 @@ Call QtConcurrent::filteredReduced() like this: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 4 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 4 The reduce function will be called once for each result kept by the filter function, and should merge the \e{intermediate} into the \e{result} @@ -128,7 +128,7 @@ instead of a sequence. You use them in the same way as the sequence variants: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 5 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 5 \section2 Using Member Functions @@ -137,12 +137,12 @@ QtConcurrent::filteredReduced() accept pointers to member functions. The member function class type must match the type stored in the sequence: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 7 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 7 Note that when using QtConcurrent::filteredReduced(), you can mix the use of normal and member functions freely: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 8 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 8 \section2 Using Function Objects @@ -151,7 +151,7 @@ add state to a function call. The result_type typedef must define the result type of the function call operator: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 13 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 13 \section2 Using Bound Function Arguments @@ -167,7 +167,7 @@ As an example, we use QString::contains(): - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 9 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 9 QString::contains() takes 2 arguments (including the "this" pointer) and can't be used with QtConcurrent::filtered() directly, because @@ -175,17 +175,17 @@ use QString::contains() with QtConcurrent::filtered() we have to provide a value for the \e regexp argument: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 10 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 10 The return value from boost::bind() is a function object (functor) with the following signature: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 11 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 11 This matches what QtConcurrent::filtered() expects, and the complete example becomes: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentfilter.cpp 12 + \snippet code/src_concurrent_qtconcurrentfilter.cpp 12 */ /*! diff --git a/src/concurrent/qtconcurrentmap.cpp b/src/concurrent/qtconcurrentmap.cpp index 1758cb9e95..c446064327 100644 --- a/src/concurrent/qtconcurrentmap.cpp +++ b/src/concurrent/qtconcurrentmap.cpp @@ -95,7 +95,7 @@ the final result instead of a QFuture. You use them in the same way as the asynchronous variants. - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 7 + \snippet code/src_concurrent_qtconcurrentmap.cpp 7 Note that the result types above are not QFuture objects, but real result types (in this case, QList<QImage> and QImage). @@ -108,7 +108,7 @@ The map function must be of the form: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 0 + \snippet code/src_concurrent_qtconcurrentmap.cpp 0 T and U can be any type (and they can even be the same type), but T must match the type stored in the sequence. The function returns the modified @@ -117,7 +117,7 @@ This example shows how to apply a scale function to all the items in a sequence: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 1 + \snippet code/src_concurrent_qtconcurrentmap.cpp 1 The results of the map are made available through QFuture. See the QFuture and QFutureWatcher documentation for more information on how to @@ -126,14 +126,14 @@ If you want to modify a sequence in-place, use QtConcurrent::map(). The map function must then be of the form: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 2 + \snippet code/src_concurrent_qtconcurrentmap.cpp 2 Note that the return value and return type of the map function are not used. Using QtConcurrent::map() is similar to using QtConcurrent::mapped(): - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 3 + \snippet code/src_concurrent_qtconcurrentmap.cpp 3 Since the sequence is modified in place, QtConcurrent::map() does not return any results via QFuture. However, you can still use QFuture and @@ -147,7 +147,7 @@ The reduce function must be of the form: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 4 + \snippet code/src_concurrent_qtconcurrentmap.cpp 4 T is the type of the final result, U is the return type of the map function. Note that the return value and return type of the reduce @@ -155,7 +155,7 @@ Call QtConcurrent::mappedReduced() like this: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 5 + \snippet code/src_concurrent_qtconcurrentmap.cpp 5 The reduce function will be called once for each result returned by the map function, and should merge the \e{intermediate} into the \e{result} @@ -175,7 +175,7 @@ instead of a sequence. You use them in the same way as the sequence variants: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 6 + \snippet code/src_concurrent_qtconcurrentmap.cpp 6 \section2 Blocking Variants @@ -183,7 +183,7 @@ the final result instead of a QFuture. You use them in the same way as the asynchronous variants. - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 7 + \snippet code/src_concurrent_qtconcurrentmap.cpp 7 Note that the result types above are not QFuture objects, but real result types (in this case, QList<QImage> and QImage). @@ -194,12 +194,12 @@ QtConcurrent::mappedReduced() accept pointers to member functions. The member function class type must match the type stored in the sequence: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 8 + \snippet code/src_concurrent_qtconcurrentmap.cpp 8 Note that when using QtConcurrent::mappedReduced(), you can mix the use of normal and member functions freely: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 9 + \snippet code/src_concurrent_qtconcurrentmap.cpp 9 \section2 Using Function Objects @@ -208,7 +208,7 @@ add state to a function call. The result_type typedef must define the result type of the function call operator: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 14 + \snippet code/src_concurrent_qtconcurrentmap.cpp 14 \section2 Using Bound Function Arguments @@ -224,7 +224,7 @@ As an example, we'll use QImage::scaledToWidth(): - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 10 + \snippet code/src_concurrent_qtconcurrentmap.cpp 10 scaledToWidth takes three arguments (including the "this" pointer) and can't be used with QtConcurrent::mapped() directly, because @@ -232,17 +232,17 @@ QImage::scaledToWidth() with QtConcurrent::mapped() we have to provide a value for the \e{width} and the \e{transformation mode}: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 11 + \snippet code/src_concurrent_qtconcurrentmap.cpp 11 The return value from boost::bind() is a function object (functor) with the following signature: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 12 + \snippet code/src_concurrent_qtconcurrentmap.cpp 12 This matches what QtConcurrent::mapped() expects, and the complete example becomes: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentmap.cpp 13 + \snippet code/src_concurrent_qtconcurrentmap.cpp 13 */ /*! diff --git a/src/concurrent/qtconcurrentrun.cpp b/src/concurrent/qtconcurrentrun.cpp index 656ecf7370..2cf46ac5a1 100644 --- a/src/concurrent/qtconcurrentrun.cpp +++ b/src/concurrent/qtconcurrentrun.cpp @@ -57,7 +57,7 @@ To run a function in another thread, use QtConcurrent::run(): - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentrun.cpp 0 + \snippet code/src_concurrent_qtconcurrentrun.cpp 0 This will run \e aFunction in a separate thread obtained from the default QThreadPool. You can use the QFuture and QFutureWatcher classes to monitor @@ -68,7 +68,7 @@ Passing arguments to the function is done by adding them to the QtConcurrent::run() call immediately after the function name. For example: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentrun.cpp 1 + \snippet code/src_concurrent_qtconcurrentrun.cpp 1 A copy of each argument is made at the point where QtConcurrent::run() is called, and these values are passed to the thread when it begins executing @@ -79,11 +79,11 @@ Any return value from the function is available via QFuture: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentrun.cpp 2 + \snippet code/src_concurrent_qtconcurrentrun.cpp 2 As documented above, passing arguments is done like this: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentrun.cpp 3 + \snippet code/src_concurrent_qtconcurrentrun.cpp 3 Note that the QFuture::result() function blocks and waits for the result to become available. Use QFutureWatcher to get notification when the @@ -102,11 +102,11 @@ For example, calling QByteArray::split() (a const member function) in a separate thread is done like this: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentrun.cpp 4 + \snippet code/src_concurrent_qtconcurrentrun.cpp 4 Calling a non-const member function is done like this: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentrun.cpp 5 + \snippet code/src_concurrent_qtconcurrentrun.cpp 5 \section2 Using Bound Function Arguments @@ -131,7 +131,7 @@ Calling a bound function is done like this: - \snippet doc/src/snippets/code/src_corelib_concurrent_qtconcurrentrun.cpp 6 + \snippet code/src_concurrent_qtconcurrentrun.cpp 6 */ /*! |