1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix QtConcurrent::blockingMapped to work with non-template sequences

Browse Source 
The code for deducing the type of output sequence was assuming that the
input sequence is always a template class and was trying to use the
corresponding container type for the output sequence. Fixed the
deduction code, to assume that the output sequence has the same type as
the input sequence, when it's not a template class. Also added tests to
verify that all QtConcurrent functions support non-template input
sequences.

Fixes: QTBUG-30617
Change-Id: I486fe99f3207cfff5dcceb3712cc7de863067edb
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
(cherry picked from commit 28e194d3b25f5fc6e17cce8dddba7f7e16002c43)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>
This commit is contained in:
Sona Kurazyan 2021-09-06 14:37:32 +02:00 committed by Qt Cherry-pick Bot
parent f1244e54e5
commit 280b55111f
4 changed files with 202 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/concurrent/qtconcurrentfunctionwrappers.h
View File

@ -146,7 +146,13 @@ struct ReduceResultType<T(C::*)(U) noexcept>
// -- MapSequenceResultType
template <class InputSequence, class MapFunctor>
struct MapSequenceResultType;
struct MapSequenceResultType
{
static_assert(std::is_same_v<typename InputSequence::value_type,
QtPrivate::MapResultType<InputSequence, MapFunctor>>,
"Couldn't deduce the output sequence type, you must specify it explicitly.");
typedef InputSequence ResultType;
};
template <class MapFunctor>
struct MapSequenceResultType<QStringList, MapFunctor>

103
tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
View File

@ -102,6 +102,19 @@ void tst_QtConcurrentFilter::filter()
CHECK_FAIL("member");
testFilter(intList, intListEven, lambdaIsEven);
CHECK_FAIL("lambda");
// non-template sequences
{
NonTemplateSequence list({ 1, 2, 3, 4 });
QtConcurrent::filter(list, keepEvenNumbers).waitForFinished();
QCOMPARE(list, NonTemplateSequence({ 2, 4 }));
}
{
NonTemplateSequence list({ 1, 2, 3, 4 });
QtConcurrent::blockingFilter(list, keepEvenNumbers);
QCOMPARE(list, NonTemplateSequence({ 2, 4 }));
}
}
static QSemaphore semaphore(1);
@ -179,6 +192,19 @@ void tst_QtConcurrentFilter::filterThreadPool()
CHECK_FAIL("function");
testFilterThreadPool(&pool, intList, intListEven, lambdaIsOdd);
CHECK_FAIL("lambda");
// non-template sequences
{
NonTemplateSequence list({ 1, 2, 3, 4 });
QtConcurrent::filter(list, keepEvenIntegers).waitForFinished();
QCOMPARE(list, NonTemplateSequence({ 2, 4 }));
}
{
NonTemplateSequence list({ 1, 2, 3, 4 });
QtConcurrent::blockingFilter(list, keepEvenIntegers);
QCOMPARE(list, NonTemplateSequence({ 2, 4 }));
}
}
void tst_QtConcurrentFilter::filterWithMoveOnlyCallable()
@ -254,6 +280,18 @@ void tst_QtConcurrentFilter::filtered()
testFiltered(intList, intListEven, lambdaIsEven);
CHECK_FAIL("lambda");
// non-template sequences
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto future = QtConcurrent::filtered(list, keepEvenIntegers);
QCOMPARE(future.results(), QList({ 2, 4 }));
}
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto result = QtConcurrent::blockingFiltered(list, keepEvenIntegers);
QCOMPARE(result, NonTemplateSequence({ 2, 4 }));
}
{
// rvalue sequences
auto future = QtConcurrent::filtered(std::vector { 1, 2, 3, 4 }, keepEvenIntegers);
@ -329,6 +367,18 @@ void tst_QtConcurrentFilter::filteredThreadPool()
testFilteredThreadPool(&pool, intList, intListEven, lambdaIsOdd);
CHECK_FAIL("lambda");
// non-template sequences
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto future = QtConcurrent::filtered(&pool, list, keepEvenIntegers);
QCOMPARE(future.results(), QList({ 2, 4 }));
}
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto result = QtConcurrent::blockingFiltered(&pool, list, keepEvenIntegers);
QCOMPARE(result, NonTemplateSequence({ 2, 4 }));
}
{
// rvalue sequences
auto future = QtConcurrent::filtered(&pool, std::vector { 1, 2, 3, 4 }, keepEvenIntegers);
@ -537,6 +587,18 @@ void tst_QtConcurrentFilter::filteredReduced()
testFilteredReduced(intList, intSum, lambdaIsEven, lambdaIntSumReduce);
CHECK_FAIL("lambda-lambda");
// non-template sequences
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto future = QtConcurrent::filteredReduced(list, keepEvenIntegers, intSumReduce);
QCOMPARE(future.result(), intSum);
}
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto result = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, intSumReduce);
QCOMPARE(result, intSum);
}
{
// rvalue sequences
auto future = QtConcurrent::filteredReduced(std::vector { 1, 2, 3, 4 }, keepEvenIntegers,
@ -636,6 +698,19 @@ void tst_QtConcurrentFilter::filteredReducedThreadPool()
testFilteredReducedThreadPool(&pool, intList, intSum, lambdaIsOdd, lambdaSumReduce);
CHECK_FAIL("lambda-lambda");
// non-template sequences
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto future = QtConcurrent::filteredReduced(&pool, list, keepOddIntegers, intSumReduce);
QCOMPARE(future.result(), intSum);
}
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto result =
QtConcurrent::blockingFilteredReduced(&pool, list, keepOddIntegers, intSumReduce);
QCOMPARE(result, intSum);
}
{
// rvalue sequences
auto future = QtConcurrent::filteredReduced(&pool, std::vector { 1, 2, 3, 4 },
@ -910,6 +985,20 @@ void tst_QtConcurrentFilter::filteredReducedInitialValue()
lambdaIntSumReduce, intInitial);
CHECK_FAIL("lambda-lambda");
// non-template sequences
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto future =
QtConcurrent::filteredReduced(list, keepEvenIntegers, intSumReduce, intInitial);
QCOMPARE(future.result(), intSum);
}
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto result = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, intSumReduce,
intInitial);
QCOMPARE(result, intSum);
}
{
// rvalue sequences
auto future = QtConcurrent::filteredReduced(std::vector { 1, 2, 3, 4 }, keepEvenIntegers,
@ -1021,6 +1110,20 @@ void tst_QtConcurrentFilter::filteredReducedInitialValueThreadPool()
lambdaSumReduce, intInitial);
CHECK_FAIL("lambda-lambda");
// non-template sequences
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto future =
QtConcurrent::filteredReduced(list, keepOddIntegers, intSumReduce, intInitial);
QCOMPARE(future.result(), intSum);
}
{
NonTemplateSequence list({ 1, 2, 3, 4 });
auto result = QtConcurrent::blockingFilteredReduced(list, keepOddIntegers, intSumReduce,
intInitial);
QCOMPARE(result, intSum);
}
{
// rvalue sequences
auto future = QtConcurrent::filteredReduced(&pool, std::vector { 1, 2, 3, 4 },

83
tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
View File

@ -201,6 +201,13 @@ void tst_QtConcurrentMap::map()
QCOMPARE(moveOnlyVector, MoveOnlyVector<int>({ 2, 4, 6 }));
}
// non-template sequences
{
NonTemplateSequence list { 1, 2, 3 };
QtConcurrent::map(list, multiplyBy2InPlace).waitForFinished();
QCOMPARE(list, NonTemplateSequence({ 2, 4, 6 }));
}
#if 0
// not allowed: map() with immutable sequences makes no sense
{
@ -331,6 +338,13 @@ void tst_QtConcurrentMap::blockingMap()
QCOMPARE(list, QList<int>() << 1 << 2 << 3);
}
// non-template sequences
{
NonTemplateSequence list { 1, 2, 3 };
QtConcurrent::blockingMap(list, multiplyBy2InPlace);
QCOMPARE(list, NonTemplateSequence({ 2, 4, 6 }));
}
#if 0
// not allowed: map() with immutable sequences makes no sense
{
@ -563,6 +577,17 @@ void tst_QtConcurrentMap::mapped()
CHECK_FAIL("member");
#endif
{
// non-template sequences
NonTemplateSequence list { 1, 2, 3 };
auto future = QtConcurrent::mapped(list, multiplyBy2);
QCOMPARE(future.results(), QList({ 2, 4, 6 }));
auto result = QtConcurrent::blockingMapped(list, multiplyBy2);
QCOMPARE(result, NonTemplateSequence({ 2, 4, 6 }));
}
{
// rvalue sequences
auto future = QtConcurrent::mapped(std::vector { 1, 2, 3 }, multiplyBy2);
@ -666,6 +691,17 @@ void tst_QtConcurrentMap::mappedThreadPool()
testMappedThreadPool(&pool, intList, intListMultipiedBy3, lambdaMultiplyBy3);
CHECK_FAIL("lambda");
{
// non-template sequences
NonTemplateSequence list { 1, 2, 3 };
auto future = QtConcurrent::mapped(&pool, list, multiplyBy2);
QCOMPARE(future.results(), QList({ 2, 4, 6 }));
auto result = QtConcurrent::blockingMapped(&pool, list, multiplyBy2);
QCOMPARE(result, NonTemplateSequence({ 2, 4, 6 }));
}
{
// rvalue sequences
auto future = QtConcurrent::mapped(&pool, std::vector { 1, 2, 3 }, multiplyBy2);
@ -857,6 +893,17 @@ void tst_QtConcurrentMap::mappedReduced()
testMappedReduced(intList, sumOfSquares, lambdaSquare, lambdaSumReduce);
CHECK_FAIL("lambda-lambda");
{
// non-template sequences
NonTemplateSequence list { 1, 2, 3 };
auto future = QtConcurrent::mappedReduced(list, multiplyBy2, intSumReduce);
QCOMPARE(future.result(), 12);
auto result = QtConcurrent::blockingMappedReduced(list, multiplyBy2, intSumReduce);
QCOMPARE(result, 12);
}
{
// rvalue sequences
auto future = QtConcurrent::mappedReduced(std::vector { 1, 2, 3 }, intSquare, intSumReduce);
@ -966,6 +1013,17 @@ void tst_QtConcurrentMap::mappedReducedThreadPool()
testMappedReducedThreadPool(&pool, intList, sumOfCubes, lambdaCube, lambdaSumReduce);
CHECK_FAIL("lambda-lambda");
{
// non-template sequences
NonTemplateSequence list { 1, 2, 3 };
auto future = QtConcurrent::mappedReduced(&pool, list, multiplyBy2, intSumReduce);
QCOMPARE(future.result(), 12);
auto result = QtConcurrent::blockingMappedReduced(&pool, list, multiplyBy2, intSumReduce);
QCOMPARE(result, 12);
}
{
// rvalue sequences
auto future =
@ -1203,6 +1261,18 @@ void tst_QtConcurrentMap::mappedReducedInitialValue()
testMappedReducedInitialValue(intList, sumOfSquares, lambdaSquare, lambdaSumReduce, intInitial);
CHECK_FAIL("lambda-lambda");
{
// non-template sequences
NonTemplateSequence list { 1, 2, 3 };
auto future = QtConcurrent::mappedReduced(list, multiplyBy2, intSumReduce, intInitial);
QCOMPARE(future.result(), intInitial + 12);
auto result =
QtConcurrent::blockingMappedReduced(list, multiplyBy2, intSumReduce, intInitial);
QCOMPARE(result, intInitial + 12);
}
{
// rvalue sequences
auto future = QtConcurrent::mappedReduced(std::vector { 1, 2, 3 }, intSquare, intSumReduce,
@ -1311,6 +1381,19 @@ void tst_QtConcurrentMap::mappedReducedInitialValueThreadPool()
lambdaSumReduce, intInitial);
CHECK_FAIL("lambda-lambda");
{
// non-template sequences
NonTemplateSequence list { 1, 2, 3 };
auto future =
QtConcurrent::mappedReduced(&pool, list, multiplyBy2, intSumReduce, intInitial);
QCOMPARE(future.result(), intInitial + 12);
auto result = QtConcurrent::blockingMappedReduced(&pool, list, multiplyBy2, intSumReduce,
intInitial);
QCOMPARE(result, intInitial + 12);
}
{
// rvalue sequences
auto future = QtConcurrent::mappedReduced(&pool, std::vector { 1, 2, 3 }, intCube,

9
tests/auto/concurrent/testhelper_functions.h
View File

@ -28,6 +28,8 @@
#ifndef FUNCTIONS_H
#define FUNCTIONS_H
#include <QList>
#include <vector>
bool keepEvenIntegers(const int &x)
@ -196,4 +198,11 @@ private:
std::vector<T> data;
};
struct NonTemplateSequence : public QList<int>
{
NonTemplateSequence() = default;
NonTemplateSequence(std::initializer_list<int> args) : QList(args) { }
};
#endif