<QtConcurrentMap> - Concurrent Map and Map-Reduce

Concurrent Map

QtConcurrent::mapped() takes an input sequence and a map function. This map function is then called for each item in the sequence, and a new sequence containing the return values from the map function is returned.

The map function must be of the form:

 U function(const T &t);

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 or mapped content.

This example shows how to apply a scale function to all the items in a sequence:

 QImage scaled(const QImage &image)
 {
     return image.scaled(100, 100);
 }

 QList<QImage> images = ...;
 QFuture<QImage> thumbnails = QtConcurrent::mapped(images, scaled);

The results of the map are made available through QFuture. See the QFuture and QFutureWatcher documentation for more information on how to use QFuture in your applications.

If you want to modify a sequence in-place, use QtConcurrent::map(). The map function must then be of the form:

 U function(T &t);

Note that the return value and return type of the map function are not used.

Using QtConcurrent::map() is similar to using QtConcurrent::mapped():

 void scale(QImage &image)
 {
     image = image.scaled(100, 100);
 }

 QList<QImage> images = ...;
 QFuture<void> future = QtConcurrent::map(images, scale);

Since the sequence is modified in place, QtConcurrent::map() does not return any results via QFuture. However, you can still use QFuture and QFutureWatcher to monitor the status of the map.

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

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

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

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

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

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

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

 QImage QImage::scaledToWidth(int width, Qt::TransformationMode) const;

 boost::bind(&QImage::scaledToWidth, 100, Qt::SmoothTransformation)

 QImage scaledToWith(const QImage &image)

 QList<QImage> images = ...;
 QFuture<QImage> thumbnails = QtConcurrent::mapped(images, boost::bind(&QImage::scaledToWidth, 100 Qt::SmoothTransformation));