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

QtConcurrent: fix support for callables with deduced return type

Browse Source 
Commit 6ebe3d0f0806069f906522dfe9b81baa3f3478de introduced extra
SFINAE checks on the template conditions.
However, it broke the case of using callables with deduced return
type, because SFINAE does not work for such conditions and treated
as a hard error instead.

Fix by explicitly providing all template parameters, so that compiler
could figure a better overload on its own.

Only QtConcurrent::blockingMapped() seems to be affected, but add
unit-tests to check all other methods as well.

Fixes: QTBUG-130766
Pick-to: 6.9 6.8 6.5
Change-Id: I1ddbe712d8ce04ac96ba13841cb569d728cfb943
Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
This commit is contained in:
Ivan Solovev 2024-12-20 16:15:08 +01:00
parent a80d1bf271
commit f73765682e
3 changed files with 168 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/concurrent/qtconcurrentmap.h
View File

@ -433,9 +433,9 @@ ResultType blockingMappedReduced(QThreadPool *pool,
| SequentialReduce))
{
QFuture<ResultType> future =
mappedReduced<ResultType>(pool, std::forward<Sequence>(sequence),
std::forward<MapFunctor>(map),
std::forward<ReduceFunctor>(reduce), options);
mappedReduced<ResultType, Sequence, MapFunctor, ReduceFunctor>(
pool, std::forward<Sequence>(sequence), std::forward<MapFunctor>(map),
std::forward<ReduceFunctor>(reduce), options);
return future.takeResult();
}

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

@ -19,9 +19,11 @@ private slots:
void filtered();
void filteredThreadPool();
void filteredWithMoveOnlyCallable();
void filteredWithGenericCallable();
void filteredReduced();
void filteredReducedThreadPool();
void filteredReducedWithMoveOnlyCallables();
void filteredReducedWithGenericCallable();
void filteredReducedDifferentType();
void filteredReducedInitialValue();
void filteredReducedInitialValueThreadPool();
@ -428,6 +430,53 @@ void tst_QtConcurrentFilter::filteredWithMoveOnlyCallable()
}
}
void tst_QtConcurrentFilter::filteredWithGenericCallable()
{
const QList<int> intList { 1, 2, 3, 4 };
const QList<int> intListEven { 2, 4 };
auto keepEven = [](auto val) { return (val & 1) == 0; };
{
const auto result = QtConcurrent::filtered(intList, keepEven).results();
QCOMPARE(result, intListEven);
}
{
const auto result = QtConcurrent::filtered(intList.begin(), intList.end(),
keepEven).results();
QCOMPARE(result, intListEven);
}
{
const auto result = QtConcurrent::blockingFiltered(intList, keepEven);
QCOMPARE(result, intListEven);
}
{
const auto result = QtConcurrent::blockingFiltered<QList<int>>(intList.begin(),
intList.end(),
keepEven);
QCOMPARE(result, intListEven);
}
QThreadPool pool;
{
const auto result = QtConcurrent::filtered(&pool, intList, keepEven).results();
QCOMPARE(result, intListEven);
}
{
const auto result = QtConcurrent::filtered(&pool, intList.begin(), intList.end(),
keepEven).results();
QCOMPARE(result, intListEven);
}
{
const auto result = QtConcurrent::blockingFiltered(&pool, intList, keepEven);
QCOMPARE(result, intListEven);
}
{
const auto result = QtConcurrent::blockingFiltered<QList<int>>(&pool, intList.begin(),
intList.end(), keepEven);
QCOMPARE(result, intListEven);
}
}
template <typename SourceObject,
typename ResultObject,
typename FilterObject,
@ -819,6 +868,60 @@ void tst_QtConcurrentFilter::filteredReducedWithMoveOnlyCallables()
}
}
void tst_QtConcurrentFilter::filteredReducedWithGenericCallable()
{
const QList<int> intList { 1, 2, 3, 4 };
const auto sum = 6;
auto keepEven = [](auto val) { return (val & 1) == 0; };
auto sumValues = [](auto &sum, auto val) { sum += val; };
{
const auto result = QtConcurrent::filteredReduced<int>(intList, keepEven,
sumValues).result();
QCOMPARE(result, sum);
}
{
const auto result = QtConcurrent::filteredReduced<int>(intList.begin(), intList.end(),
keepEven, sumValues).result();
QCOMPARE(result, sum);
}
{
const auto result = QtConcurrent::blockingFilteredReduced<int>(intList, keepEven, sumValues);
QCOMPARE(result, sum);
}
{
const auto result = QtConcurrent::blockingFilteredReduced<int>(intList.begin(),
intList.end(),
keepEven, sumValues);
QCOMPARE(result, sum);
}
QThreadPool pool;
{
const auto result = QtConcurrent::filteredReduced<int>(&pool, intList, keepEven,
sumValues).result();
QCOMPARE(result, sum);
}
{
const auto result = QtConcurrent::filteredReduced<int>(&pool, intList.begin(),
intList.end(), keepEven,
sumValues).result();
QCOMPARE(result, sum);
}
{
const auto result = QtConcurrent::blockingFilteredReduced<int>(&pool, intList,
keepEven, sumValues);
QCOMPARE(result, sum);
}
{
const auto result = QtConcurrent::blockingFilteredReduced<int>(&pool, intList.begin(),
intList.end(), keepEven,
sumValues);
QCOMPARE(result, sum);
}
}
void tst_QtConcurrentFilter::filteredReducedDifferentType()
{
const QList<Number> numberList {1, 2, 3, 4};

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

@ -22,9 +22,11 @@ private slots:
void mapped();
void mappedThreadPool();
void mappedWithMoveOnlyCallable();
void mappedWithGenericCallable();
void mappedReduced();
void mappedReducedThreadPool();
void mappedReducedWithMoveOnlyCallable();
void mappedReducedWithGenericCallable();
void mappedReducedDifferentType();
void mappedReducedInitialValue();
void mappedReducedInitialValueThreadPool();
@ -754,6 +756,32 @@ void tst_QtConcurrentMap::mappedWithMoveOnlyCallable()
}
}
void tst_QtConcurrentMap::mappedWithGenericCallable()
{
QList<int> intList{1, 2, 3};
QList<std::string> expectedResult{"1", "2", "3"};
auto toString = [](const auto &el) { return std::to_string(el); };
{
const auto res = QtConcurrent::mapped(intList, toString).results();
QCOMPARE_EQ(res, expectedResult);
}
{
const auto res = QtConcurrent::blockingMapped(intList, toString);
QCOMPARE_EQ(res, expectedResult);
}
QThreadPool pool;
{
const auto res = QtConcurrent::mapped(&pool, intList, toString).results();
QCOMPARE_EQ(res, expectedResult);
}
{
const auto res = QtConcurrent::blockingMapped(&pool, intList, toString);
QCOMPARE_EQ(res, expectedResult);
}
}
int intSquare(int x)
{
return x * x;
@ -1149,6 +1177,40 @@ void tst_QtConcurrentMap::mappedReducedWithMoveOnlyCallable()
}
}
void tst_QtConcurrentMap::mappedReducedWithGenericCallable()
{
QList<int> intList{1, 2, 3};
const std::string expectedResult{"123"};
auto toString = [](const auto &el) { return std::to_string(el); };
auto appendString = [](auto &res, const auto &el) { res.append(el); };
{
const auto res = QtConcurrent::mappedReduced<std::string>(intList, toString, appendString,
OrderedReduce).result();
QCOMPARE_EQ(res, expectedResult);
}
{
const auto res = QtConcurrent::blockingMappedReduced<std::string>(intList, toString,
appendString,
OrderedReduce);
QCOMPARE_EQ(res, expectedResult);
}
QThreadPool pool;
{
const auto res = QtConcurrent::mappedReduced<std::string>(&pool, intList, toString,
appendString,
OrderedReduce).result();
QCOMPARE_EQ(res, expectedResult);
}
{
const auto res = QtConcurrent::blockingMappedReduced<std::string>(&pool, intList, toString,
appendString,
OrderedReduce);
QCOMPARE_EQ(res, expectedResult);
}
}
void tst_QtConcurrentMap::mappedReducedDifferentType()
{
const QList<int> intList {1, 2, 3};