From 280b55111f6414a4497becfb982a84735dd8a7f0 Mon Sep 17 00:00:00 2001 From: Sona Kurazyan Date: Mon, 6 Sep 2021 14:37:32 +0200 Subject: [PATCH] Fix QtConcurrent::blockingMapped to work with non-template sequences MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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 (cherry picked from commit 28e194d3b25f5fc6e17cce8dddba7f7e16002c43) Reviewed-by: Qt Cherry-pick Bot --- src/concurrent/qtconcurrentfunctionwrappers.h | 8 +- .../tst_qtconcurrentfilter.cpp | 103 ++++++++++++++++++ .../qtconcurrentmap/tst_qtconcurrentmap.cpp | 83 ++++++++++++++ tests/auto/concurrent/testhelper_functions.h | 9 ++ 4 files changed, 202 insertions(+), 1 deletion(-) diff --git a/src/concurrent/qtconcurrentfunctionwrappers.h b/src/concurrent/qtconcurrentfunctionwrappers.h index 194d020fb28..a00c1c6edc1 100644 --- a/src/concurrent/qtconcurrentfunctionwrappers.h +++ b/src/concurrent/qtconcurrentfunctionwrappers.h @@ -146,7 +146,13 @@ struct ReduceResultType // -- MapSequenceResultType template -struct MapSequenceResultType; +struct MapSequenceResultType +{ + static_assert(std::is_same_v>, + "Couldn't deduce the output sequence type, you must specify it explicitly."); + typedef InputSequence ResultType; +}; template struct MapSequenceResultType diff --git a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp index 6c278849776..a6c575fd4d7 100644 --- a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp +++ b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp @@ -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 }, diff --git a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp index 5bcf90c0d6d..8fdfd0ccc29 100644 --- a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp +++ b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp @@ -201,6 +201,13 @@ void tst_QtConcurrentMap::map() QCOMPARE(moveOnlyVector, MoveOnlyVector({ 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() << 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, diff --git a/tests/auto/concurrent/testhelper_functions.h b/tests/auto/concurrent/testhelper_functions.h index e890053e5ca..a34e0f4ce9d 100644 --- a/tests/auto/concurrent/testhelper_functions.h +++ b/tests/auto/concurrent/testhelper_functions.h @@ -28,6 +28,8 @@ #ifndef FUNCTIONS_H #define FUNCTIONS_H +#include + #include bool keepEvenIntegers(const int &x) @@ -196,4 +198,11 @@ private: std::vector data; }; +struct NonTemplateSequence : public QList +{ + NonTemplateSequence() = default; + + NonTemplateSequence(std::initializer_list args) : QList(args) { } +}; + #endif