<QtConcurrentFilter> - Concurrent Filter and Filter-Reduce

Functions

 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);

 bool function(const T &t);

 bool allLowerCase(const QString &string)
 {
     return string.lowered() == string;
 }

 QStringList strings = ...;
 QFuture<QString> lowerCaseStrings = QtConcurrent::filtered(strings, allLowerCase);

 QStringList strings = ...;
 QFuture<void> future = QtConcurrent::filter(strings, allLowerCase);

 V function(T &result, const U &intermediate)

 void addToDictionary(QSet<QString> &dictionary, const QString &string)
 {
     dictionary.insert(string);
 }

 QStringList strings = ...;
 QFuture<QSet<QString> > dictionary = QtConcurrent::filteredReduced(strings, allLowerCase, addToDictionary);

 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);

 // 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);

 // 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);

 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")));

 bool QString::contains(const QRegExp &regexp) const;

 boost::bind(&QString::contains, QRegExp("^\\S+$")); // matches strings without whitespace

 bool contains(const QString &string)

 QStringList strings = ...;
 boost::bind(static_cast<bool(QString::*)(const QRegExp&)>( &QString::contains ), QRegExp("..." ));

Function Documentation

QFuture<void> QtConcurrent::filter ( Sequence & sequence, FilterFunction filterFunction )

Calls filterFunction once for each item in sequence. If filterFunction returns true, the item is kept in sequence; otherwise, the item is removed from sequence.

QFuture<T> QtConcurrent::filtered ( const Sequence & sequence, FilterFunction filterFunction )

Calls filterFunction once for each item in sequence and returns a new Sequence of kept items. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

QFuture<T> QtConcurrent::filtered ( ConstIterator begin, ConstIterator end, FilterFunction filterFunction )

Calls filterFunction once for each item from begin to end and returns a new Sequence of kept items. If filterFunction returns true, a copy of the item is put in the new Sequence. Otherwise, the item will not appear in the new Sequence.

QFuture<T> QtConcurrent::filteredReduced ( const Sequence & sequence, FilterFunction filterFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )

Calls filterFunction once for each item in sequence. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.

Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, reduceFunction is called in the order of the original sequence.

QFuture<T> QtConcurrent::filteredReduced ( ConstIterator begin, ConstIterator end, FilterFunction filterFunction, ReduceFunction reduceFunction, QtConcurrent::ReduceOptions reduceOptions = UnorderedReduce | SequentialReduce )

Calls filterFunction once for each item from begin to end. If filterFunction returns true for an item, that item is then passed to reduceFunction. In other words, the return value is the result of reduceFunction for each item where filterFunction returns true.

Note that while filterFunction is called concurrently, only one thread at a time will call reduceFunction. The order in which reduceFunction is called is undefined if reduceOptions is QtConcurrent::UnorderedReduce. If reduceOptions is QtConcurrent::OrderedReduce, the reduceFunction is called in the order of the original sequence.