Add files using upload-large-folder tool

qt/6.8.1/msvc2022_64/include/QtConcurrent/QtConcurrent

@@ -0,0 +1,20 @@
+#ifndef QT_QTCONCURRENT_MODULE_H
+#define QT_QTCONCURRENT_MODULE_H
+#include <QtConcurrent/QtConcurrentDepends>
+#include "qtaskbuilder.h"
+#include "qtconcurrentcompilertest.h"
+#include "qtconcurrentfilter.h"
+#include "qtconcurrentfilterkernel.h"
+#include "qtconcurrentfunctionwrappers.h"
+#include "qtconcurrentiteratekernel.h"
+#include "qtconcurrentmap.h"
+#include "qtconcurrentmapkernel.h"
+#include "qtconcurrentmedian.h"
+#include "qtconcurrentreducekernel.h"
+#include "qtconcurrentrun.h"
+#include "qtconcurrentrunbase.h"
+#include "qtconcurrentstoredfunctioncall.h"
+#include "qtconcurrenttask.h"
+#include "qtconcurrentthreadengine.h"
+#include "qtconcurrentversion.h"
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/QtConcurrentDepends

@@ -0,0 +1,4 @@
+/* This file was generated by cmake with the info from Concurrent target. */
+#ifdef __cplusplus /* create empty PCH in C mode */
+#  include <QtCore/QtCore>
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/QtConcurrentFilter

@@ -0,0 +1 @@
+#include "qtconcurrentfilter.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtConcurrent/QtConcurrentMap

@@ -0,0 +1 @@
+#include "qtconcurrentmap.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtConcurrent/QtConcurrentRun

@@ -0,0 +1 @@
+#include "qtconcurrentrun.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtConcurrent/QtConcurrentVersion

@@ -0,0 +1 @@
+#include "qtconcurrentversion.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtaskbuilder.h

@@ -0,0 +1,135 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTBASE_QTTASKBUILDER_H
+#define QTBASE_QTTASKBUILDER_H
+
+#if !defined(QT_NO_CONCURRENT) || defined(Q_QDOC)
+
+#include <QtConcurrent/qtconcurrentstoredfunctioncall.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifdef Q_QDOC
+
+namespace QtConcurrent {
+
+enum class FutureResult { Ignore };
+
+using InvokeResultType = int;
+
+template <class Task, class ...Args>
+class QTaskBuilder
+{
+public:
+    [[nodiscard]]
+    QFuture<InvokeResultType> spawn();
+
+    void spawn(FutureResult);
+
+    template <class ...ExtraArgs>
+    [[nodiscard]]
+    QTaskBuilder<Task, ExtraArgs...> withArguments(ExtraArgs &&...args);
+
+    [[nodiscard]]
+    QTaskBuilder<Task, Args...> &onThreadPool(QThreadPool &newThreadPool);
+
+    [[nodiscard]]
+    QTaskBuilder<Task, Args...> &withPriority(int newPriority);
+};
+
+} // namespace QtConcurrent
+
+#else
+
+namespace QtConcurrent {
+
+enum class FutureResult { Ignore };
+
+template <class Task, class ...Args>
+class QTaskBuilder
+{
+public:
+    [[nodiscard]]
+    auto spawn()
+    {
+        return TaskResolver<std::decay_t<Task>, std::decay_t<Args>...>::run(
+                    std::move(taskWithArgs), startParameters);
+    }
+
+    // We don't want to run with promise when we don't return a QFuture
+    void spawn(FutureResult)
+    {
+        (new StoredFunctionCall<Task, Args...>(std::move(taskWithArgs)))
+            ->start(startParameters);
+    }
+
+    template <class ...ExtraArgs>
+    [[nodiscard]]
+    constexpr auto withArguments(ExtraArgs &&...args)
+    {
+        static_assert(std::tuple_size_v<TaskWithArgs> == 1,
+                      "This function cannot be invoked if "
+                      "arguments have already been passed.");
+
+        static_assert(sizeof...(ExtraArgs) >= 1,
+                      "One or more arguments must be passed.");
+
+        // We have to re-create a builder, because the type has changed
+        return QTaskBuilder<Task, ExtraArgs...>(
+                   startParameters,
+                   std::get<0>(std::move(taskWithArgs)),
+                   std::forward<ExtraArgs>(args)...
+               );
+    }
+
+    [[nodiscard]]
+    constexpr auto &onThreadPool(QThreadPool &newThreadPool)
+    {
+        startParameters.threadPool = &newThreadPool;
+        return *this;
+    }
+
+    [[nodiscard]]
+    constexpr auto &withPriority(int newPriority)
+    {
+        startParameters.priority = newPriority;
+        return *this;
+    }
+
+protected: // Methods
+    constexpr explicit QTaskBuilder(Task &&task, Args &&...arguments)
+        : taskWithArgs{std::forward<Task>(task), std::forward<Args>(arguments)...}
+    {}
+
+    constexpr QTaskBuilder(
+        const TaskStartParameters &parameters, Task &&task, Args &&...arguments)
+        : taskWithArgs{std::forward<Task>(task), std::forward<Args>(arguments)...}
+        , startParameters{parameters}
+    {}
+
+private: // Methods
+    // Required for creating a builder from "task" function
+    template <class T>
+    friend constexpr auto task(T &&t);
+
+    // Required for creating a new builder from "withArguments" function
+    template <class T, class ...A>
+    friend class QTaskBuilder;
+
+private: // Data
+    using TaskWithArgs = DecayedTuple<Task, Args...>;
+
+    TaskWithArgs taskWithArgs;
+    TaskStartParameters startParameters;
+};
+
+} // namespace QtConcurrent
+
+#endif // Q_QDOC
+
+QT_END_NAMESPACE
+
+#endif // !defined(QT_NO_CONCURRENT)
+
+#endif //QTBASE_QTTASKBUILDER_H

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrent_global.h

@@ -0,0 +1,10 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_GLOBAL_H
+#define QTCONCURRENT_GLOBAL_H
+
+#include <QtCore/qglobal.h>
+#include <QtConcurrent/qtconcurrentexports.h>
+
+#endif // include guard

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentcompilertest.h

@@ -0,0 +1,41 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_COMPILERTEST_H
+#define QTCONCURRENT_COMPILERTEST_H
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#ifndef QT_NO_CONCURRENT
+
+QT_BEGIN_NAMESPACE
+
+namespace QtPrivate {
+
+    template <class T, typename = void>
+    struct IsIterable : std::false_type {};
+    template <class T>
+    struct IsIterable<T, std::void_t<decltype(std::declval<T>().begin()),
+        decltype(std::declval<T>().end())>>
+        : std::true_type
+    { };
+
+    template <class T>
+    inline constexpr bool IsIterableValue = IsIterable<T>::value;
+
+    template <class T, typename = void>
+    struct IsDereferenceable : std::false_type {};
+    template <class T>
+    struct IsDereferenceable<T, std::void_t<decltype(*std::declval<T>())>>
+        : std::true_type
+    { };
+
+    template <class T>
+    inline constexpr bool IsDereferenceableValue = IsDereferenceable<T>::value;
+}
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentexports.h

@@ -0,0 +1,50 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENTEXPORTS_H
+#define QTCONCURRENTEXPORTS_H
+
+#include <QtCore/qcompilerdetection.h>
+#include <QtCore/qtconfigmacros.h> // Q_CONCURRENT_EXPORT
+#include <QtCore/qtdeprecationmarkers.h> // QT_IF_DEPRECATED_SINCE
+
+#if defined(QT_SHARED) || !defined(QT_STATIC)
+#  if defined(QT_BUILD_CONCURRENT_LIB)
+#    define Q_CONCURRENT_EXPORT Q_DECL_EXPORT
+#  else
+#    define Q_CONCURRENT_EXPORT Q_DECL_IMPORT
+#  endif
+#else
+#  define Q_CONCURRENT_EXPORT
+#endif
+
+#if !defined(QT_BUILD_CONCURRENT_LIB) && !defined(QT_STATIC)
+/* outside library -> inline decl + defi */
+/* static builds treat everything as part of the library, so they never inline */
+#  define QT_CONCURRENT_INLINE_SINCE(major, minor) inline
+#  define QT_CONCURRENT_INLINE_IMPL_SINCE(major, minor) 1
+#elif defined(QT_CONCURRENT_BUILD_REMOVED_API)
+/* inside library, inside removed_api.cpp:
+ * keep deprecated API -> non-inline decl;
+ * remove deprecated API -> inline decl;
+ * definition is always available */
+#  define QT_CONCURRENT_INLINE_SINCE(major, minor) \
+    QT_IF_DEPRECATED_SINCE(major, minor, inline, /* not inline */)
+#  define QT_CONCURRENT_INLINE_IMPL_SINCE(major, minor) 1
+#else
+/* inside library, outside removed_api.cpp:
+ * keep deprecated API -> non-inline decl, no defi;
+ * remove deprecated API -> inline decl, defi */
+#  define QT_CONCURRENT_INLINE_SINCE(major, minor) \
+    QT_IF_DEPRECATED_SINCE(major, minor, inline, /* not inline */)
+#  define QT_CONCURRENT_INLINE_IMPL_SINCE(major, minor) \
+    QT_IF_DEPRECATED_SINCE(major, minor, 1, 0)
+#endif
+
+#ifdef QT_CONCURRENT_BUILD_REMOVED_API
+#  define QT_CONCURRENT_REMOVED_SINCE(major, minor) QT_DEPRECATED_SINCE(major, minor)
+#else
+#  define QT_CONCURRENT_REMOVED_SINCE(major, minor) 0
+#endif
+
+#endif // QTCONCURRENTEXPORTS_H

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentfilter.h

@@ -0,0 +1,719 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_FILTER_H
+#define QTCONCURRENT_FILTER_H
+
+#if 0
+#pragma qt_class(QtConcurrentFilter)
+#endif
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#if !defined(QT_NO_CONCURRENT) || defined(Q_QDOC)
+
+#include <QtConcurrent/qtconcurrentfilterkernel.h>
+#include <QtConcurrent/qtconcurrentfunctionwrappers.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtConcurrent {
+
+//! [QtConcurrent-1]
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+ThreadEngineStarter<void> filterInternal(QThreadPool *pool, Sequence &sequence,
+                                         KeepFunctor &&keep, ReduceFunctor &&reduce)
+{
+    typedef FilterKernel<Sequence, std::decay_t<KeepFunctor>, std::decay_t<ReduceFunctor>>
+            KernelType;
+    return startThreadEngine(new KernelType(pool, sequence, std::forward<KeepFunctor>(keep),
+                                            std::forward<ReduceFunctor>(reduce)));
+}
+
+// filter() on sequences
+template <typename Sequence, typename KeepFunctor>
+QFuture<void> filter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&keep)
+{
+    return filterInternal(pool, sequence, std::forward<KeepFunctor>(keep),
+                          QtPrivate::PushBackWrapper());
+}
+
+template <typename Sequence, typename KeepFunctor>
+QFuture<void> filter(Sequence &sequence, KeepFunctor &&keep)
+{
+    return filterInternal(QThreadPool::globalInstance(),
+                          sequence, std::forward<KeepFunctor>(keep), QtPrivate::PushBackWrapper());
+}
+
+// filteredReduced() on sequences
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+QFuture<ResultType> filteredReduced(QThreadPool *pool,
+                                    Sequence &&sequence,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(pool, std::forward<Sequence>(sequence),
+                                            std::forward<KeepFunctor>(keep),
+                                            std::forward<ReduceFunctor>(reduce), options);
+}
+
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+QFuture<ResultType> filteredReduced(Sequence &&sequence,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(
+            QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+            std::forward<KeepFunctor>(keep), std::forward<ReduceFunctor>(reduce), options);
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> filteredReduced(QThreadPool *pool,
+                                    Sequence &&sequence,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    InitialValueType &&initialValue,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(
+            pool, std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> filteredReduced(Sequence &&sequence,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    InitialValueType &&initialValue,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(
+            QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+            std::forward<KeepFunctor>(keep), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+#ifndef Q_QDOC
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+QFuture<ResultType> filteredReduced(QThreadPool *pool,
+                                    Sequence &&sequence,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(pool, std::forward<Sequence>(sequence),
+                                            std::forward<KeepFunctor>(keep),
+                                            std::forward<ReduceFunctor>(reduce), options);
+}
+
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+QFuture<ResultType> filteredReduced(Sequence &&sequence,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(
+            QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+            std::forward<KeepFunctor>(keep), std::forward<ReduceFunctor>(reduce), options);
+}
+
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+QFuture<ResultType> filteredReduced(QThreadPool *pool,
+                                    Sequence &&sequence,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    InitialValueType &&initialValue,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(
+            pool, std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+QFuture<ResultType> filteredReduced(Sequence &&sequence,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    InitialValueType &&initialValue,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(
+            QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+            std::forward<KeepFunctor>(keep), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+#endif
+
+// filteredReduced() on iterators
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>
+QFuture<ResultType> filteredReduced(QThreadPool *pool,
+                                    Iterator begin,
+                                    Iterator end,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(pool, begin, end, std::forward<KeepFunctor>(keep),
+                                            std::forward<ReduceFunctor>(reduce), options);
+}
+
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>
+QFuture<ResultType> filteredReduced(Iterator begin,
+                                    Iterator end,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(QThreadPool::globalInstance(), begin, end,
+                                            std::forward<KeepFunctor>(keep),
+                                            std::forward<ReduceFunctor>(reduce), options);
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> filteredReduced(QThreadPool *pool,
+                                    Iterator begin,
+                                    Iterator end,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    InitialValueType &&initialValue,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(
+            pool, begin, end, std::forward<KeepFunctor>(keep), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> filteredReduced(Iterator begin,
+                                    Iterator end,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    InitialValueType &&initialValue,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(
+            QThreadPool::globalInstance(), begin, end, std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+#ifndef Q_QDOC
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+QFuture<ResultType> filteredReduced(QThreadPool *pool,
+                                    Iterator begin,
+                                    Iterator end,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+   return startFilteredReduced<ResultType>(pool, begin, end, std::forward<KeepFunctor>(keep),
+                                           std::forward<ReduceFunctor>(reduce), options);
+}
+
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+QFuture<ResultType> filteredReduced(Iterator begin,
+                                    Iterator end,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+   return startFilteredReduced<ResultType>(QThreadPool::globalInstance(), begin, end,
+                                           std::forward<KeepFunctor>(keep),
+                                           std::forward<ReduceFunctor>(reduce), options);
+}
+
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+QFuture<ResultType> filteredReduced(QThreadPool *pool,
+                                    Iterator begin,
+                                    Iterator end,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    InitialValueType &&initialValue,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(
+            pool, begin, end, std::forward<KeepFunctor>(keep), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          std::enable_if_t<QtPrivate::isIterator_v<Iterator>, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+QFuture<ResultType> filteredReduced(Iterator begin,
+                                    Iterator end,
+                                    KeepFunctor &&keep,
+                                    ReduceFunctor &&reduce,
+                                    InitialValueType &&initialValue,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                          | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(
+            QThreadPool::globalInstance(), begin, end, std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+#endif
+
+// filtered() on sequences
+template <typename Sequence, typename KeepFunctor>
+QFuture<typename std::decay_t<Sequence>::value_type> filtered(QThreadPool *pool,Sequence &&sequence,
+                                                              KeepFunctor &&keep)
+{
+    return startFiltered(pool, std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep));
+}
+
+template <typename Sequence, typename KeepFunctor>
+QFuture<typename std::decay_t<Sequence>::value_type> filtered(Sequence &&sequence,
+                                                              KeepFunctor &&keep)
+{
+    return startFiltered(QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+                         std::forward<KeepFunctor>(keep));
+}
+
+// filtered() on iterators
+template <typename Iterator, typename KeepFunctor>
+QFuture<typename qValueType<Iterator>::value_type> filtered(QThreadPool *pool,
+                                                            Iterator begin,
+                                                            Iterator end,
+                                                            KeepFunctor &&keep)
+{
+    return startFiltered(pool, begin, end, std::forward<KeepFunctor>(keep));
+}
+
+template <typename Iterator, typename KeepFunctor>
+QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin,
+                                                            Iterator end,
+                                                            KeepFunctor &&keep)
+{
+    return startFiltered(QThreadPool::globalInstance(), begin, end,
+                         std::forward<KeepFunctor>(keep));
+}
+
+// blocking filter() on sequences
+template <typename Sequence, typename KeepFunctor>
+void blockingFilter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&keep)
+{
+    QFuture<void> future = filter(pool, sequence, std::forward<KeepFunctor>(keep));
+    future.waitForFinished();
+}
+
+template <typename Sequence, typename KeepFunctor>
+void blockingFilter(Sequence &sequence, KeepFunctor &&keep)
+{
+    QFuture<void> future = filter(sequence, std::forward<KeepFunctor>(keep));
+    future.waitForFinished();
+}
+
+// blocking filteredReduced() on sequences
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+ResultType blockingFilteredReduced(QThreadPool *pool,
+                                   Sequence &&sequence,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            pool, std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+ResultType blockingFilteredReduced(Sequence &&sequence,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingFilteredReduced(QThreadPool *pool,
+                                   Sequence &&sequence,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   InitialValueType &&initialValue,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            pool, std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingFilteredReduced(Sequence &&sequence,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   InitialValueType &&initialValue,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+#ifndef Q_QDOC
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+ResultType blockingFilteredReduced(QThreadPool *pool,
+                                   Sequence &&sequence,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            pool, std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+ResultType blockingFilteredReduced(Sequence &&sequence,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+ResultType blockingFilteredReduced(QThreadPool *pool,
+                                   Sequence &&sequence,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   InitialValueType &&initialValue,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            pool, std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+ResultType blockingFilteredReduced(Sequence &&sequence,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   InitialValueType &&initialValue,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+#endif
+
+// blocking filteredReduced() on iterators
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>
+ResultType blockingFilteredReduced(QThreadPool *pool,
+                                   Iterator begin,
+                                   Iterator end,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            filteredReduced<ResultType>(pool, begin, end, std::forward<KeepFunctor>(keep),
+                                        std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>
+ResultType blockingFilteredReduced(Iterator begin,
+                                   Iterator end,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            filteredReduced<ResultType>(begin, end, std::forward<KeepFunctor>(keep),
+                                        std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingFilteredReduced(QThreadPool *pool,
+                                   Iterator begin,
+                                   Iterator end,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   InitialValueType &&initialValue,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            pool, begin, end, std::forward<KeepFunctor>(keep), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingFilteredReduced(Iterator begin,
+                                   Iterator end,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   InitialValueType &&initialValue,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            begin, end, std::forward<KeepFunctor>(keep), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+#ifndef Q_QDOC
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+ResultType blockingFilteredReduced(QThreadPool *pool,
+                                   Iterator begin,
+                                   Iterator end,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            filteredReduced<ResultType>(pool, begin, end, std::forward<KeepFunctor>(keep),
+                                        std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+ResultType blockingFilteredReduced(Iterator begin,
+                                   Iterator end,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            filteredReduced<ResultType>(begin, end, std::forward<KeepFunctor>(keep),
+                                        std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+ResultType blockingFilteredReduced(QThreadPool *pool,
+                                   Iterator begin,
+                                   Iterator end, KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   InitialValueType &&initialValue,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            pool, begin, end, std::forward<KeepFunctor>(keep), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
+          std::enable_if_t<QtPrivate::isIterator_v<Iterator>, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+ResultType blockingFilteredReduced(Iterator begin,
+                                   Iterator end,
+                                   KeepFunctor &&keep,
+                                   ReduceFunctor &&reduce,
+                                   InitialValueType &&initialValue,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                         | SequentialReduce))
+{
+    QFuture<ResultType> future = filteredReduced<ResultType>(
+            begin, end, std::forward<KeepFunctor>(keep), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+#endif
+
+// blocking filtered() on sequences
+template <typename Sequence, typename KeepFunctor>
+std::decay_t<Sequence> blockingFiltered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep)
+{
+    return blockingFilteredReduced<std::decay_t<Sequence>>(
+            pool, std::forward<Sequence>(sequence), std::forward<KeepFunctor>(keep),
+            QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename Sequence, typename KeepFunctor>
+std::decay_t<Sequence> blockingFiltered(Sequence &&sequence, KeepFunctor &&keep)
+{
+    return blockingFilteredReduced<std::decay_t<Sequence>>(
+            QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+            std::forward<KeepFunctor>(keep), QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+// blocking filtered() on iterators
+template <typename OutputSequence, typename Iterator, typename KeepFunctor>
+OutputSequence blockingFiltered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&keep)
+{
+    return blockingFilteredReduced<OutputSequence>(pool, begin, end,
+                                                   std::forward<KeepFunctor>(keep),
+                                                   QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename OutputSequence, typename Iterator, typename KeepFunctor>
+OutputSequence blockingFiltered(Iterator begin, Iterator end, KeepFunctor &&keep)
+{
+    return blockingFilteredReduced<OutputSequence>(QThreadPool::globalInstance(), begin, end,
+                                                   std::forward<KeepFunctor>(keep),
+                                                   QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+} // namespace QtConcurrent
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentfilterkernel.h

@@ -0,0 +1,386 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_FILTERKERNEL_H
+#define QTCONCURRENT_FILTERKERNEL_H
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#if !defined(QT_NO_CONCURRENT) || defined (Q_QDOC)
+
+#include <QtConcurrent/qtconcurrentiteratekernel.h>
+#include <QtConcurrent/qtconcurrentmapkernel.h>
+#include <QtConcurrent/qtconcurrentreducekernel.h>
+
+QT_BEGIN_NAMESPACE
+
+
+
+namespace QtConcurrent {
+
+template <typename T>
+struct qValueType
+{
+    typedef typename T::value_type value_type;
+};
+
+template <typename T>
+struct qValueType<const T*>
+{
+    typedef T value_type;
+};
+
+template <typename T>
+struct qValueType<T*>
+{
+    typedef T value_type;
+};
+
+// Implementation of filter
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+class FilterKernel : public IterateKernel<typename Sequence::const_iterator, void>
+{
+    typedef ReduceKernel<ReduceFunctor, Sequence, typename Sequence::value_type> Reducer;
+    typedef IterateKernel<typename Sequence::const_iterator, void> IterateKernelType;
+    typedef void T;
+
+    Sequence reducedResult;
+    Sequence &sequence;
+    KeepFunctor keep;
+    ReduceFunctor reduce;
+    Reducer reducer;
+
+public:
+    template <typename Keep = KeepFunctor, typename Reduce = ReduceFunctor>
+    FilterKernel(QThreadPool *pool, Sequence &_sequence, Keep &&_keep, Reduce &&_reduce)
+        : IterateKernelType(pool, const_cast<const Sequence &>(_sequence).begin(),
+                            const_cast<const Sequence &>(_sequence).end()), reducedResult(),
+          sequence(_sequence),
+          keep(std::forward<Keep>(_keep)),
+          reduce(std::forward<Reduce>(_reduce)),
+          reducer(pool, OrderedReduce)
+    { }
+
+    bool runIteration(typename Sequence::const_iterator it, int index, T *) override
+    {
+        IntermediateResults<typename Sequence::value_type> results;
+        results.begin = index;
+        results.end = index + 1;
+
+        if (std::invoke(keep, *it))
+            results.vector.append(*it);
+
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+
+    bool runIterations(typename Sequence::const_iterator sequenceBeginIterator, int begin, int end, T *) override
+    {
+        IntermediateResults<typename Sequence::value_type> results;
+        results.begin = begin;
+        results.end = end;
+        results.vector.reserve(end - begin);
+
+
+        typename Sequence::const_iterator it = sequenceBeginIterator;
+        std::advance(it, begin);
+        for (int i = begin; i < end; ++i) {
+            if (std::invoke(keep, *it))
+                results.vector.append(*it);
+            std::advance(it, 1);
+        }
+
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+
+    void finish() override
+    {
+        reducer.finish(reduce, reducedResult);
+        sequence = std::move(reducedResult);
+    }
+
+    inline bool shouldThrottleThread() override
+    {
+        return IterateKernelType::shouldThrottleThread() || reducer.shouldThrottle();
+    }
+
+    inline bool shouldStartThread() override
+    {
+        return IterateKernelType::shouldStartThread() && reducer.shouldStartThread();
+    }
+
+    typedef void ReturnType;
+    typedef void ResultType;
+};
+
+// Implementation of filter-reduce
+template <typename ReducedResultType,
+          typename Iterator,
+          typename KeepFunctor,
+          typename ReduceFunctor,
+          typename Reducer = ReduceKernel<ReduceFunctor,
+                                          ReducedResultType,
+                                          typename qValueType<Iterator>::value_type> >
+class FilteredReducedKernel : public IterateKernel<Iterator, ReducedResultType>
+{
+    ReducedResultType &reducedResult;
+    KeepFunctor keep;
+    ReduceFunctor reduce;
+    Reducer reducer;
+    typedef IterateKernel<Iterator, ReducedResultType> IterateKernelType;
+
+public:
+    template<typename Keep = KeepFunctor, typename Reduce = ReduceFunctor>
+    FilteredReducedKernel(QThreadPool *pool, Iterator begin, Iterator end, Keep &&_keep,
+                          Reduce &&_reduce, ReduceOptions reduceOption)
+        : IterateKernelType(pool, begin, end),
+          reducedResult(this->defaultValue.value),
+          keep(std::forward<Keep>(_keep)),
+          reduce(std::forward<Reduce>(_reduce)),
+          reducer(pool, reduceOption)
+    { }
+
+    template <typename Keep = KeepFunctor, typename Reduce = ReduceFunctor>
+    FilteredReducedKernel(QThreadPool *pool, Iterator begin, Iterator end, Keep &&_keep,
+                          Reduce &&_reduce, ReducedResultType &&initialValue,
+                          ReduceOptions reduceOption)
+        : IterateKernelType(pool, begin, end, std::forward<ReducedResultType>(initialValue)),
+          reducedResult(this->defaultValue.value),
+          keep(std::forward<Keep>(_keep)),
+          reduce(std::forward<Reduce>(_reduce)),
+          reducer(pool, reduceOption)
+    {
+    }
+
+    bool runIteration(Iterator it, int index, ReducedResultType *) override
+    {
+        IntermediateResults<typename qValueType<Iterator>::value_type> results;
+        results.begin = index;
+        results.end = index + 1;
+
+        if (std::invoke(keep, *it))
+            results.vector.append(*it);
+
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+
+    bool runIterations(Iterator sequenceBeginIterator, int begin, int end, ReducedResultType *) override
+    {
+        IntermediateResults<typename qValueType<Iterator>::value_type> results;
+        results.begin = begin;
+        results.end = end;
+        results.vector.reserve(end - begin);
+
+        Iterator it = sequenceBeginIterator;
+        std::advance(it, begin);
+        for (int i = begin; i < end; ++i) {
+            if (std::invoke(keep, *it))
+                results.vector.append(*it);
+            std::advance(it, 1);
+        }
+
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+
+    void finish() override
+    {
+        reducer.finish(reduce, reducedResult);
+    }
+
+    inline bool shouldThrottleThread() override
+    {
+        return IterateKernelType::shouldThrottleThread() || reducer.shouldThrottle();
+    }
+
+    inline bool shouldStartThread() override
+    {
+        return IterateKernelType::shouldStartThread() && reducer.shouldStartThread();
+    }
+
+    typedef ReducedResultType ReturnType;
+    typedef ReducedResultType ResultType;
+    ReducedResultType *result() override
+    {
+        return &reducedResult;
+    }
+};
+
+// Implementation of filter that reports individual results via QFutureInterface
+template <typename Iterator, typename KeepFunctor>
+class FilteredEachKernel : public IterateKernel<Iterator, typename qValueType<Iterator>::value_type>
+{
+    typedef typename qValueType<Iterator>::value_type T;
+    typedef IterateKernel<Iterator, T> IterateKernelType;
+
+    KeepFunctor keep;
+
+public:
+    typedef T ReturnType;
+    typedef T ResultType;
+
+    template <typename Keep = KeepFunctor>
+    FilteredEachKernel(QThreadPool *pool, Iterator begin, Iterator end, Keep &&_keep)
+        : IterateKernelType(pool, begin, end), keep(std::forward<Keep>(_keep))
+    { }
+
+    void start() override
+    {
+        if (this->futureInterface)
+            this->futureInterface->setFilterMode(true);
+        IterateKernelType::start();
+    }
+
+    bool runIteration(Iterator it, int index, T *) override
+    {
+        if (std::invoke(keep, *it))
+            this->reportResult(&(*it), index);
+        else
+            this->reportResult(nullptr, index);
+        return false;
+    }
+
+    bool runIterations(Iterator sequenceBeginIterator, int begin, int end, T *) override
+    {
+        const int count = end - begin;
+        IntermediateResults<typename qValueType<Iterator>::value_type> results;
+        results.begin = begin;
+        results.end = end;
+        results.vector.reserve(count);
+
+        Iterator it = sequenceBeginIterator;
+        std::advance(it, begin);
+        for (int i = begin; i < end; ++i) {
+            if (std::invoke(keep, *it))
+                results.vector.append(*it);
+            std::advance(it, 1);
+        }
+
+        this->reportResults(results.vector, begin, count);
+        return false;
+    }
+};
+
+//! [QtConcurrent-2]
+template <typename Iterator, typename KeepFunctor>
+inline
+ThreadEngineStarter<typename qValueType<Iterator>::value_type>
+startFiltered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&functor)
+{
+    return startThreadEngine(new FilteredEachKernel<Iterator, std::decay_t<KeepFunctor>>
+                             (pool, begin, end, std::forward<KeepFunctor>(functor)));
+}
+
+//! [QtConcurrent-3]
+template <typename Sequence, typename KeepFunctor>
+inline decltype(auto) startFiltered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&functor)
+{
+    using DecayedSequence = std::decay_t<Sequence>;
+    using DecayedFunctor = std::decay_t<KeepFunctor>;
+    using SequenceHolderType = SequenceHolder1<DecayedSequence,
+            FilteredEachKernel<typename DecayedSequence::const_iterator, DecayedFunctor>,
+            DecayedFunctor>;
+    return startThreadEngine(new SequenceHolderType(pool, std::forward<Sequence>(sequence),
+                                                    std::forward<KeepFunctor>(functor)));
+}
+
+//! [QtConcurrent-4]
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startFilteredReduced(QThreadPool *pool,
+                                                            Sequence &&sequence,
+                                                            MapFunctor &&mapFunctor,
+                                                            ReduceFunctor &&reduceFunctor,
+                                                            ReduceOptions options)
+{
+    using DecayedSequence = std::decay_t<Sequence>;
+    using DecayedMapFunctor = std::decay_t<MapFunctor>;
+    using DecayedReduceFunctor = std::decay_t<ReduceFunctor>;
+    using Iterator = typename DecayedSequence::const_iterator;
+    using Reducer = ReduceKernel<DecayedReduceFunctor, ResultType,
+                                 typename qValueType<Iterator>::value_type>;
+    using FilteredReduceType = FilteredReducedKernel<ResultType, Iterator, DecayedMapFunctor,
+                                                     DecayedReduceFunctor, Reducer>;
+    using SequenceHolderType = SequenceHolder2<DecayedSequence, FilteredReduceType,
+                                               DecayedMapFunctor, DecayedReduceFunctor>;
+    return startThreadEngine(new SequenceHolderType(pool, std::forward<Sequence>(sequence),
+                                                    std::forward<MapFunctor>(mapFunctor),
+                                                    std::forward<ReduceFunctor>(reduceFunctor),
+                                                    options));
+}
+
+
+//! [QtConcurrent-5]
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startFilteredReduced(QThreadPool *pool,
+                                                            Iterator begin,
+                                                            Iterator end,
+                                                            MapFunctor &&mapFunctor,
+                                                            ReduceFunctor &&reduceFunctor,
+                                                            ReduceOptions options)
+{
+    using Reducer = ReduceKernel<std::decay_t<ReduceFunctor>, ResultType,
+                                 typename qValueType<Iterator>::value_type>;
+    using FilteredReduceType = FilteredReducedKernel<ResultType, Iterator, std::decay_t<MapFunctor>,
+                                                     std::decay_t<ReduceFunctor>, Reducer>;
+    return startThreadEngine(
+            new FilteredReduceType(pool, begin, end, std::forward<MapFunctor>(mapFunctor),
+                                   std::forward<ReduceFunctor>(reduceFunctor), options));
+}
+
+// Repeat the two functions above, but now with an initial value!
+//! [QtConcurrent-6]
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startFilteredReduced(QThreadPool *pool,
+                                                            Sequence &&sequence,
+                                                            MapFunctor &&mapFunctor,
+                                                            ReduceFunctor &&reduceFunctor,
+                                                            ResultType &&initialValue,
+                                                            ReduceOptions options)
+{
+    using DecayedSequence = std::decay_t<Sequence>;
+    using DecayedMapFunctor = std::decay_t<MapFunctor>;
+    using DecayedReduceFunctor = std::decay_t<ReduceFunctor>;
+    using Iterator = typename DecayedSequence::const_iterator;
+    using Reducer = ReduceKernel<DecayedReduceFunctor, ResultType,
+                                 typename qValueType<Iterator>::value_type>;
+    using FilteredReduceType = FilteredReducedKernel<ResultType, Iterator, DecayedMapFunctor,
+                                                     DecayedReduceFunctor, Reducer>;
+    using SequenceHolderType = SequenceHolder2<DecayedSequence, FilteredReduceType,
+                                               DecayedMapFunctor, DecayedReduceFunctor>;
+    return startThreadEngine(new SequenceHolderType(
+            pool, std::forward<Sequence>(sequence), std::forward<MapFunctor>(mapFunctor),
+            std::forward<ReduceFunctor>(reduceFunctor), std::forward<ResultType>(initialValue),
+            options));
+}
+
+//! [QtConcurrent-7]
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startFilteredReduced(QThreadPool *pool,
+                                                            Iterator begin,
+                                                            Iterator end,
+                                                            MapFunctor &&mapFunctor,
+                                                            ReduceFunctor &&reduceFunctor,
+                                                            ResultType &&initialValue,
+                                                            ReduceOptions options)
+{
+    using Reducer = ReduceKernel<std::decay_t<ReduceFunctor>, ResultType,
+                                 typename qValueType<Iterator>::value_type>;
+    using FilteredReduceType = FilteredReducedKernel<ResultType, Iterator, std::decay_t<MapFunctor>,
+                                                     std::decay_t<ReduceFunctor>, Reducer>;
+    return startThreadEngine(
+            new FilteredReduceType(pool, begin, end, std::forward<MapFunctor>(mapFunctor),
+                                   std::forward<ReduceFunctor>(reduceFunctor),
+                                   std::forward<ResultType>(initialValue), options));
+}
+
+
+} // namespace QtConcurrent
+
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentfunctionwrappers.h

@@ -0,0 +1,179 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_FUNCTIONWRAPPERS_H
+#define QTCONCURRENT_FUNCTIONWRAPPERS_H
+
+#include <QtConcurrent/qtconcurrentcompilertest.h>
+#include <QtConcurrent/qtconcurrentreducekernel.h>
+#include <QtCore/qfuture.h>
+
+#include <tuple>
+
+#if !defined(QT_NO_CONCURRENT) || defined(Q_QDOC)
+
+QT_BEGIN_NAMESPACE
+
+namespace QtPrivate {
+
+struct PushBackWrapper
+{
+    template <class C, class U>
+    inline void operator()(C &c, const U &u) const
+    {
+        return c.push_back(u);
+    }
+
+    template <class C, class U>
+    inline void operator()(C &c, U &&u) const
+    {
+        return c.push_back(u);
+    }
+};
+
+// -- MapResultType
+
+template <class T, class Enable = void>
+struct Argument
+{
+    using Type = void;
+};
+
+template <class Sequence>
+struct Argument<Sequence, typename std::enable_if<IsIterableValue<Sequence>>::type>
+{
+    using Type = std::decay_t<decltype(*std::declval<Sequence>().begin())>;
+};
+
+template <class Iterator>
+struct Argument<Iterator, typename std::enable_if<IsDereferenceableValue<Iterator>>::type>
+{
+    using Type = std::decay_t<decltype(*std::declval<Iterator>())>;
+};
+
+template <class T>
+using ArgumentType = typename Argument<T>::Type;
+
+template <class T, class MapFunctor>
+struct MapResult
+{
+    static_assert(std::is_invocable_v<std::decay_t<MapFunctor>, ArgumentType<T>>,
+                  "It's not possible to invoke the function with passed argument.");
+    using Type = std::invoke_result_t<std::decay_t<MapFunctor>, ArgumentType<T>>;
+};
+
+template <class T, class MapFunctor>
+using MapResultType = typename MapResult<T, MapFunctor>::Type;
+
+// -- ReduceResultType
+
+template <class T>
+struct ReduceResultType;
+
+template <class U, class V>
+struct ReduceResultType<void(*)(U&,V)>
+{
+    using ResultType = U;
+};
+
+template <class T, class C, class U>
+struct ReduceResultType<T(C::*)(U)>
+{
+    using ResultType = C;
+};
+
+template <class U, class V>
+struct ReduceResultType<std::function<void(U&, V)>>
+{
+    using ResultType = U;
+};
+
+template <typename R, typename ...A>
+struct ReduceResultType<R(*)(A...)>
+{
+    using ResultType = typename std::tuple_element<0, std::tuple<A...>>::type;
+};
+
+template <class U, class V>
+struct ReduceResultType<void(*)(U&,V) noexcept>
+{
+    using ResultType = U;
+};
+
+template <class T, class C, class U>
+struct ReduceResultType<T(C::*)(U) noexcept>
+{
+    using ResultType = C;
+};
+
+template<class T, class Enable = void>
+inline constexpr bool hasCallOperator_v = false;
+
+template<class T>
+inline constexpr bool hasCallOperator_v<T, std::void_t<decltype(&T::operator())>> = true;
+
+template<class T, class Enable = void>
+inline constexpr bool isIterator_v = false;
+
+template<class T>
+inline constexpr bool isIterator_v<T, std::void_t<typename std::iterator_traits<T>::value_type>> =
+        true;
+
+template <class Callable, class Sequence>
+using isInvocable = std::is_invocable<Callable, typename std::decay_t<Sequence>::value_type>;
+
+template <class InitialValueType, class ResultType>
+inline constexpr bool isInitialValueCompatible_v = std::conjunction_v<
+        std::is_convertible<InitialValueType, ResultType>,
+        std::negation<std::is_same<std::decay_t<InitialValueType>, QtConcurrent::ReduceOption>>>;
+
+template<class Callable, class Enable = void>
+struct ReduceResultTypeHelper
+{
+};
+
+template <class Callable>
+struct ReduceResultTypeHelper<Callable,
+        typename std::enable_if_t<std::is_function_v<std::remove_pointer_t<std::decay_t<Callable>>>
+                                  || std::is_member_function_pointer_v<std::decay_t<Callable>>>>
+{
+    using type = typename QtPrivate::ReduceResultType<std::decay_t<Callable>>::ResultType;
+};
+
+template <class Callable>
+struct ReduceResultTypeHelper<Callable,
+        typename std::enable_if_t<!std::is_function_v<std::remove_pointer_t<std::decay_t<Callable>>>
+                                  && hasCallOperator_v<std::decay_t<Callable>>>>
+{
+    using type = std::decay_t<typename QtPrivate::ArgResolver<Callable>::First>;
+};
+
+// -- MapSequenceResultType
+
+template <class InputSequence, class MapFunctor>
+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;
+};
+
+#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
+
+template <template <typename...> class InputSequence, typename MapFunctor, typename ...T>
+struct MapSequenceResultType<InputSequence<T...>, MapFunctor>
+{
+    typedef InputSequence<QtPrivate::MapResultType<InputSequence<T...>, MapFunctor>> ResultType;
+};
+
+#endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER
+
+} // namespace QtPrivate.
+
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentiteratekernel.h

@@ -0,0 +1,335 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_ITERATEKERNEL_H
+#define QTCONCURRENT_ITERATEKERNEL_H
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#if !defined(QT_NO_CONCURRENT) || defined(Q_QDOC)
+
+#include <QtCore/qatomic.h>
+#include <QtConcurrent/qtconcurrentmedian.h>
+#include <QtConcurrent/qtconcurrentthreadengine.h>
+
+#include <iterator>
+
+QT_BEGIN_NAMESPACE
+
+
+
+namespace QtConcurrent {
+
+/*
+    The BlockSizeManager class manages how many iterations a thread should
+    reserve and process at a time. This is done by measuring the time spent
+    in the user code versus the control part code, and then increasing
+    the block size if the ratio between them is to small. The block size
+    management is done on the basis of the median of several timing measurements,
+    and it is done individually for each thread.
+*/
+class Q_CONCURRENT_EXPORT BlockSizeManager
+{
+public:
+    explicit BlockSizeManager(QThreadPool *pool, int iterationCount);
+
+    void timeBeforeUser();
+    void timeAfterUser();
+    int blockSize();
+
+private:
+    inline bool blockSizeMaxed()
+    {
+        return (m_blockSize >= maxBlockSize);
+    }
+
+    const int maxBlockSize;
+    qint64 beforeUser;
+    qint64 afterUser;
+    Median controlPartElapsed;
+    Median userPartElapsed;
+    int m_blockSize;
+
+    Q_DISABLE_COPY(BlockSizeManager)
+};
+
+template <typename T>
+class ResultReporter
+{
+public:
+    ResultReporter(ThreadEngine<T> *_threadEngine, T &_defaultValue)
+        : threadEngine(_threadEngine), defaultValue(_defaultValue)
+    {
+    }
+
+    void reserveSpace(int resultCount)
+    {
+        currentResultCount = resultCount;
+        resizeList(qMax(resultCount, vector.size()));
+    }
+
+    void reportResults(int begin)
+    {
+        const int useVectorThreshold = 4; // Tunable parameter.
+        if (currentResultCount > useVectorThreshold) {
+            resizeList(currentResultCount);
+            threadEngine->reportResults(vector, begin);
+        } else {
+            for (int i = 0; i < currentResultCount; ++i)
+                threadEngine->reportResult(&vector.at(i), begin + i);
+        }
+    }
+
+    inline T * getPointer()
+    {
+        return vector.data();
+    }
+
+    int currentResultCount = 0;
+    ThreadEngine<T> *threadEngine;
+    QList<T> vector;
+
+private:
+    void resizeList(qsizetype size)
+    {
+        if constexpr (std::is_default_constructible_v<T>)
+            vector.resize(size);
+        else
+            vector.resize(size, defaultValue);
+    }
+
+    T &defaultValue;
+};
+
+template <>
+class ResultReporter<void>
+{
+public:
+    inline ResultReporter(ThreadEngine<void> *) { }
+    inline void reserveSpace(int) { }
+    inline void reportResults(int) { }
+    inline void * getPointer() { return nullptr; }
+};
+
+template<typename T>
+struct DefaultValueContainer
+{
+    template<typename U = T>
+    DefaultValueContainer(U &&_value) : value(std::forward<U>(_value))
+    {
+    }
+
+    T value;
+};
+
+template<>
+struct DefaultValueContainer<void>
+{
+};
+
+inline bool selectIteration(std::bidirectional_iterator_tag)
+{
+    return false; // while
+}
+
+inline bool selectIteration(std::forward_iterator_tag)
+{
+    return false; // while
+}
+
+inline bool selectIteration(std::random_access_iterator_tag)
+{
+    return true; // for
+}
+
+template <typename Iterator, typename T>
+class IterateKernel : public ThreadEngine<T>
+{
+    using IteratorCategory = typename std::iterator_traits<Iterator>::iterator_category;
+
+public:
+    typedef T ResultType;
+
+    template<typename U = T, std::enable_if_t<std::is_same_v<U, void>, bool> = true>
+    IterateKernel(QThreadPool *pool, Iterator _begin, Iterator _end)
+        : ThreadEngine<U>(pool),
+          begin(_begin),
+          end(_end),
+          current(_begin),
+          iterationCount(selectIteration(IteratorCategory()) ? static_cast<int>(std::distance(_begin, _end)) : 0),
+          forIteration(selectIteration(IteratorCategory())),
+          progressReportingEnabled(true)
+    {
+    }
+
+    template<typename U = T, std::enable_if_t<!std::is_same_v<U, void>, bool> = true>
+    IterateKernel(QThreadPool *pool, Iterator _begin, Iterator _end)
+        : ThreadEngine<U>(pool),
+          begin(_begin),
+          end(_end),
+          current(_begin),
+          iterationCount(selectIteration(IteratorCategory()) ? static_cast<int>(std::distance(_begin, _end)) : 0),
+          forIteration(selectIteration(IteratorCategory())),
+          progressReportingEnabled(true),
+          defaultValue(U())
+    {
+    }
+
+    template<typename U = T, std::enable_if_t<!std::is_same_v<U, void>, bool> = true>
+    IterateKernel(QThreadPool *pool, Iterator _begin, Iterator _end, U &&_defaultValue)
+        : ThreadEngine<U>(pool),
+          begin(_begin),
+          end(_end),
+          current(_begin),
+          iterationCount(selectIteration(IteratorCategory()) ? static_cast<int>(std::distance(_begin, _end)) : 0),
+          forIteration(selectIteration(IteratorCategory())),
+          progressReportingEnabled(true),
+          defaultValue(std::forward<U>(_defaultValue))
+    {
+    }
+
+    virtual ~IterateKernel() { }
+
+    virtual bool runIteration(Iterator, int , T *) { return false; }
+    virtual bool runIterations(Iterator, int, int, T *) { return false; }
+
+    void start() override
+    {
+        progressReportingEnabled = this->isProgressReportingEnabled();
+        if (progressReportingEnabled && iterationCount > 0)
+            this->setProgressRange(0, iterationCount);
+    }
+
+    bool shouldStartThread() override
+    {
+        if (forIteration)
+            return (currentIndex.loadRelaxed() < iterationCount) && !this->shouldThrottleThread();
+        else // whileIteration
+            return (iteratorThreads.loadRelaxed() == 0);
+    }
+
+    ThreadFunctionResult threadFunction() override
+    {
+        if (forIteration)
+            return this->forThreadFunction();
+        else // whileIteration
+            return this->whileThreadFunction();
+    }
+
+    ThreadFunctionResult forThreadFunction()
+    {
+        BlockSizeManager blockSizeManager(ThreadEngineBase::threadPool, iterationCount);
+        ResultReporter<T> resultReporter = createResultsReporter();
+
+        for(;;) {
+            if (this->isCanceled())
+                break;
+
+            const int currentBlockSize = blockSizeManager.blockSize();
+
+            if (currentIndex.loadRelaxed() >= iterationCount)
+                break;
+
+            // Atomically reserve a block of iterationCount for this thread.
+            const int beginIndex = currentIndex.fetchAndAddRelease(currentBlockSize);
+            const int endIndex = qMin(beginIndex + currentBlockSize, iterationCount);
+
+            if (beginIndex >= endIndex) {
+                // No more work
+                break;
+            }
+
+            this->waitForResume(); // (only waits if the qfuture is paused.)
+
+            if (shouldStartThread())
+                this->startThread();
+
+            const int finalBlockSize = endIndex - beginIndex; // block size adjusted for possible end-of-range
+            resultReporter.reserveSpace(finalBlockSize);
+
+            // Call user code with the current iteration range.
+            blockSizeManager.timeBeforeUser();
+            const bool resultsAvailable = this->runIterations(begin, beginIndex, endIndex, resultReporter.getPointer());
+            blockSizeManager.timeAfterUser();
+
+            if (resultsAvailable)
+                resultReporter.reportResults(beginIndex);
+
+            // Report progress if progress reporting enabled.
+            if (progressReportingEnabled) {
+                completed.fetchAndAddAcquire(finalBlockSize);
+                this->setProgressValue(this->completed.loadRelaxed());
+            }
+
+            if (this->shouldThrottleThread())
+                return ThrottleThread;
+        }
+        return ThreadFinished;
+    }
+
+    ThreadFunctionResult whileThreadFunction()
+    {
+        if (iteratorThreads.testAndSetAcquire(0, 1) == false)
+            return ThreadFinished;
+
+        ResultReporter<T> resultReporter = createResultsReporter();
+        resultReporter.reserveSpace(1);
+
+        while (current != end) {
+            // The following two lines breaks support for input iterators according to
+            // the sgi docs: dereferencing prev after calling ++current is not allowed
+            // on input iterators. (prev is dereferenced inside user.runIteration())
+            Iterator prev = current;
+            ++current;
+            int index = currentIndex.fetchAndAddRelaxed(1);
+            iteratorThreads.testAndSetRelease(1, 0);
+
+            this->waitForResume(); // (only waits if the qfuture is paused.)
+
+            if (shouldStartThread())
+                this->startThread();
+
+            const bool resultAavailable = this->runIteration(prev, index, resultReporter.getPointer());
+            if (resultAavailable)
+                resultReporter.reportResults(index);
+
+            if (this->shouldThrottleThread())
+                return ThrottleThread;
+
+            if (iteratorThreads.testAndSetAcquire(0, 1) == false)
+                return ThreadFinished;
+        }
+
+        return ThreadFinished;
+    }
+
+private:
+    ResultReporter<T> createResultsReporter()
+    {
+        if constexpr (!std::is_same_v<T, void>)
+            return ResultReporter<T>(this, defaultValue.value);
+        else
+            return ResultReporter<T>(this);
+    }
+
+public:
+    const Iterator begin;
+    const Iterator end;
+    Iterator current;
+    QAtomicInt currentIndex;
+    QAtomicInt iteratorThreads;
+    QAtomicInt completed;
+    const int iterationCount;
+    const bool forIteration;
+    bool progressReportingEnabled;
+    DefaultValueContainer<ResultType> defaultValue;
+};
+
+} // namespace QtConcurrent
+
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentmap.h

@@ -0,0 +1,823 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_MAP_H
+#define QTCONCURRENT_MAP_H
+
+#if 0
+#pragma qt_class(QtConcurrentMap)
+#endif
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#if !defined(QT_NO_CONCURRENT) || defined(Q_QDOC)
+
+#include <QtConcurrent/qtconcurrentmapkernel.h>
+#include <QtConcurrent/qtconcurrentreducekernel.h>
+#include <QtConcurrent/qtconcurrentfunctionwrappers.h>
+
+QT_BEGIN_NAMESPACE
+
+
+
+namespace QtConcurrent {
+
+// map() on sequences
+template <typename Sequence, typename MapFunctor>
+QFuture<void> map(QThreadPool *pool, Sequence &&sequence, MapFunctor &&map)
+{
+    return startMap(pool, sequence.begin(), sequence.end(), std::forward<MapFunctor>(map));
+}
+
+template <typename Sequence, typename MapFunctor>
+QFuture<void> map(Sequence &&sequence, MapFunctor &&map)
+{
+    return startMap(QThreadPool::globalInstance(), sequence.begin(), sequence.end(),
+                    std::forward<MapFunctor>(map));
+}
+
+// map() on iterators
+template <typename Iterator, typename MapFunctor>
+QFuture<void> map(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map)
+{
+    return startMap(pool, begin, end, std::forward<MapFunctor>(map));
+}
+
+template <typename Iterator, typename MapFunctor>
+QFuture<void> map(Iterator begin, Iterator end, MapFunctor &&map)
+{
+    return startMap(QThreadPool::globalInstance(), begin, end, std::forward<MapFunctor>(map));
+}
+
+// mappedReduced() for sequences.
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  Sequence &&sequence,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (pool, std::forward<Sequence>(sequence), std::forward<MapFunctor>(map),
+         std::forward<ReduceFunctor>(reduce), options);
+}
+
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+QFuture<ResultType> mappedReduced(Sequence &&sequence,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+         std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce), options);
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  Sequence &&sequence,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>(
+            pool, std::forward<Sequence>(sequence), std::forward<MapFunctor>(map),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+#ifdef Q_QDOC
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> mappedReduced(Sequence &&sequence,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+         std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce),
+         ResultType(std::forward<InitialValueType>(initialValue)),  options);
+}
+
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  Sequence &&sequence,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (pool, std::forward<Sequence>(sequence), std::forward<MapFunctor>(map),
+         std::forward<ReduceFunctor>(reduce), options);
+}
+
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+QFuture<ResultType> mappedReduced(Sequence &&sequence,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+         std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce), options);
+}
+
+#ifdef Q_QDOC
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor, typename ResultType,
+          typename InitialValueType>
+#else
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  Sequence &&sequence,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>(
+            pool, std::forward<Sequence>(sequence), std::forward<MapFunctor>(map),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+#ifdef Q_QDOC
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor, typename ResultType,
+          typename InitialValueType>
+#else
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> mappedReduced(Sequence &&sequence,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Sequence, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+         std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce),
+         ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+// mappedReduced() for iterators
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (pool, begin, end, std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce),
+         options);
+}
+
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+QFuture<ResultType> mappedReduced(Iterator begin,
+                                  Iterator end,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), begin, end, std::forward<MapFunctor>(map),
+         std::forward<ReduceFunctor>(reduce), options);
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (pool, begin, end, std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce),
+         ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> mappedReduced(Iterator begin,
+                                  Iterator end,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), begin, end, std::forward<MapFunctor>(map),
+         std::forward<ReduceFunctor>(reduce),
+         ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>(
+            pool, begin, end, std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce),
+            options);
+}
+
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+QFuture<ResultType> mappedReduced(Iterator begin,
+                                  Iterator end,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), begin, end, std::forward<MapFunctor>(map),
+         std::forward<ReduceFunctor>(reduce), options);
+}
+
+#ifdef Q_QDOC
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor, typename ResultType,
+          typename InitialValueType>
+#else
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+QFuture<ResultType> mappedReduced(QThreadPool *pool,
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (pool, begin, end, std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce),
+         ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+#ifdef Q_QDOC
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor, typename ResultType,
+          typename InitialValueType>
+#else
+template<typename Iterator, typename MapFunctor, typename ReduceFunctor,
+         std::enable_if_t<QtPrivate::isIterator_v<Iterator>, int> = 0,
+         typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+         typename InitialValueType,
+         std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                          int> = 0>
+#endif
+QFuture<ResultType> mappedReduced(Iterator begin,
+                                  Iterator end,
+                                  MapFunctor &&map,
+                                  ReduceFunctor &&reduce,
+                                  InitialValueType &&initialValue,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                        | SequentialReduce))
+{
+    return startMappedReduced<QtPrivate::MapResultType<Iterator, MapFunctor>, ResultType>
+        (QThreadPool::globalInstance(), begin, end, std::forward<MapFunctor>(map),
+         std::forward<ReduceFunctor>(reduce),
+         ResultType(std::forward<InitialValueType>(initialValue)), options);
+}
+
+// mapped() for sequences
+template <typename Sequence, typename MapFunctor>
+QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> mapped(
+                                  QThreadPool *pool,
+                                  Sequence &&sequence,
+                                  MapFunctor &&map)
+{
+    return startMapped<QtPrivate::MapResultType<Sequence, MapFunctor>>(
+            pool, std::forward<Sequence>(sequence), std::forward<MapFunctor>(map));
+}
+
+template <typename Sequence, typename MapFunctor>
+QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> mapped(
+                                  Sequence &&sequence,
+                                  MapFunctor &&map)
+{
+    return startMapped<QtPrivate::MapResultType<Sequence, MapFunctor>>
+        (QThreadPool::globalInstance(), std::forward<Sequence>(sequence),
+         std::forward<MapFunctor>(map));
+}
+
+// mapped() for iterator ranges.
+template <typename Iterator, typename MapFunctor>
+QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> mapped(
+                                  QThreadPool *pool,
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor &&map)
+{
+    return startMapped<QtPrivate::MapResultType<Iterator, MapFunctor>>(
+            pool, begin, end, std::forward<MapFunctor>(map));
+}
+
+template <typename Iterator, typename MapFunctor>
+QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> mapped(
+                                  Iterator begin,
+                                  Iterator end,
+                                  MapFunctor &&map)
+{
+    return startMapped<QtPrivate::MapResultType<Iterator, MapFunctor>>
+        (QThreadPool::globalInstance(), begin, end, std::forward<MapFunctor>(map));
+}
+
+// blockingMap() for sequences
+template <typename Sequence, typename MapFunctor>
+void blockingMap(QThreadPool *pool, Sequence &&sequence, MapFunctor map)
+{
+    QFuture<void> future =
+            startMap(pool, sequence.begin(), sequence.end(), std::forward<MapFunctor>(map));
+    future.waitForFinished();
+}
+
+template <typename Sequence, typename MapFunctor>
+void blockingMap(Sequence &&sequence, MapFunctor &&map)
+{
+    QFuture<void> future = startMap(QThreadPool::globalInstance(), sequence.begin(), sequence.end(),
+                                    std::forward<MapFunctor>(map));
+    future.waitForFinished();
+}
+
+// blockingMap() for iterator ranges
+template <typename Iterator, typename MapFunctor>
+void blockingMap(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map)
+{
+    QFuture<void> future = startMap(pool, begin, end, map);
+    future.waitForFinished();
+}
+
+template <typename Iterator, typename MapFunctor>
+void blockingMap(Iterator begin, Iterator end, MapFunctor &&map)
+{
+    QFuture<void> future = startMap(QThreadPool::globalInstance(), begin, end,
+                                    std::forward<MapFunctor>(map));
+    future.waitForFinished();
+}
+
+// blockingMappedReduced() for sequences
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 Sequence &&sequence,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            mappedReduced<ResultType>(pool, std::forward<Sequence>(sequence),
+                                      std::forward<MapFunctor>(map),
+                                      std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+ResultType blockingMappedReduced(Sequence &&sequence,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            mappedReduced<ResultType>(std::forward<Sequence>(sequence),
+                                      std::forward<MapFunctor>(map),
+                                      std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 Sequence &&sequence,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future = mappedReduced<ResultType>(
+            pool, std::forward<Sequence>(sequence), std::forward<MapFunctor>(map),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingMappedReduced(Sequence &&sequence,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future = mappedReduced<ResultType>(
+            std::forward<Sequence>(sequence), std::forward<MapFunctor>(map),
+                std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence,
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 Sequence &&sequence,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            mappedReduced<ResultType>(pool, std::forward<Sequence>(sequence),
+                                      std::forward<MapFunctor>(map),
+                                      std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence,
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+ResultType blockingMappedReduced(Sequence &&sequence,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            mappedReduced<ResultType>(std::forward<Sequence>(sequence),
+                                      std::forward<MapFunctor>(map),
+                                      std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence, typename ResultType,
+          typename InitialValueType>
+#else
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence, typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 Sequence &&sequence,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future = mappedReduced<ResultType>(
+            pool, std::forward<Sequence>(sequence), std::forward<MapFunctor>(map),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence, typename ResultType,
+          typename InitialValueType>
+#else
+template<typename MapFunctor, typename ReduceFunctor, typename Sequence, typename InitialValueType,
+         std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+         typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+         std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                          int> = 0>
+#endif
+ResultType blockingMappedReduced(Sequence &&sequence,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future = mappedReduced<ResultType>(
+            std::forward<Sequence>(sequence), std::forward<MapFunctor>(map),
+            std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+// blockingMappedReduced() for iterator ranges
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 Iterator begin,
+                                 Iterator end,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            mappedReduced<ResultType>(pool, begin, end, std::forward<MapFunctor>(map),
+                                      std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+ResultType blockingMappedReduced(Iterator begin,
+                                 Iterator end,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            mappedReduced<ResultType>(begin, end, std::forward<MapFunctor>(map),
+                                      std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 Iterator begin,
+                                 Iterator end,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future = mappedReduced<ResultType>(
+            pool, begin, end, std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)),
+            options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType>
+#else
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingMappedReduced(Iterator begin,
+                                 Iterator end,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future = mappedReduced<ResultType>(
+            begin, end, std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)),
+            options);
+    return future.takeResult();
+}
+
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 Iterator begin,
+                                 Iterator end,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            mappedReduced<ResultType>(pool, begin, end, std::forward<MapFunctor>(map),
+                                      std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
+ResultType blockingMappedReduced(Iterator begin,
+                                 Iterator end,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future =
+            mappedReduced<ResultType>(begin, end, std::forward<MapFunctor>(map),
+                                      std::forward<ReduceFunctor>(reduce), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor, typename ResultType,
+          typename InitialValueType>
+#else
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingMappedReduced(QThreadPool *pool,
+                                 Iterator begin,
+                                 Iterator end,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future = mappedReduced<ResultType>(
+            pool, begin, end, std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+#ifdef Q_QDOC
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor, typename ResultType,
+          typename InitialValueType>
+#else
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
+          std::enable_if_t<QtPrivate::isIterator_v<Iterator>, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
+          typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInitialValueCompatible_v<InitialValueType, ResultType>,
+                           int> = 0>
+#endif
+ResultType blockingMappedReduced(Iterator begin,
+                                 Iterator end,
+                                 MapFunctor &&map,
+                                 ReduceFunctor &&reduce,
+                                 InitialValueType &&initialValue,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce
+                                                                       | SequentialReduce))
+{
+    QFuture<ResultType> future = mappedReduced<ResultType>(
+            begin, end, std::forward<MapFunctor>(map), std::forward<ReduceFunctor>(reduce),
+            ResultType(std::forward<InitialValueType>(initialValue)), options);
+    return future.takeResult();
+}
+
+// mapped() for sequences with a different putput sequence type.
+template <typename OutputSequence, typename InputSequence, typename MapFunctor>
+OutputSequence blockingMapped(QThreadPool *pool, InputSequence &&sequence, MapFunctor &&map)
+{
+    return blockingMappedReduced<OutputSequence>(pool, std::forward<InputSequence>(sequence),
+                                                 std::forward<MapFunctor>(map),
+                                                 QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename OutputSequence, typename InputSequence, typename MapFunctor>
+OutputSequence blockingMapped(InputSequence &&sequence, MapFunctor &&map)
+{
+    return blockingMappedReduced<OutputSequence>(
+            QThreadPool::globalInstance(), std::forward<InputSequence>(sequence),
+            std::forward<MapFunctor>(map), QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename MapFunctor, typename InputSequence>
+auto blockingMapped(QThreadPool *pool, InputSequence &&sequence, MapFunctor &&map)
+{
+    using OutputSequence = typename QtPrivate::MapSequenceResultType<std::decay_t<InputSequence>,
+                                                                     MapFunctor>::ResultType;
+    return blockingMappedReduced<OutputSequence>(pool, std::forward<InputSequence>(sequence),
+                                                 std::forward<MapFunctor>(map),
+                                                 QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename MapFunctor, typename InputSequence>
+auto blockingMapped(InputSequence &&sequence, MapFunctor &&map)
+{
+    using OutputSequence = typename QtPrivate::MapSequenceResultType<std::decay_t<InputSequence>,
+                                                                     MapFunctor>::ResultType;
+    return blockingMappedReduced<OutputSequence>(QThreadPool::globalInstance(),
+                                                 std::forward<InputSequence>(sequence),
+                                                 std::forward<MapFunctor>(map),
+                                                 QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+// mapped()  for iterator ranges
+template <typename Sequence, typename Iterator, typename MapFunctor>
+Sequence blockingMapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map)
+{
+    return blockingMappedReduced<Sequence>(pool, begin, end, std::forward<MapFunctor>(map),
+        QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename Sequence, typename Iterator, typename MapFunctor>
+Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor &&map)
+{
+    return blockingMappedReduced<Sequence>(QThreadPool::globalInstance(), begin, end,
+                                           std::forward<MapFunctor>(map),
+                                           QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename Iterator, typename MapFunctor>
+auto blockingMapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&map)
+{
+    using OutputSequence = QtPrivate::MapResultType<Iterator, MapFunctor>;
+    return blockingMappedReduced<OutputSequence>(pool, begin, end, std::forward<MapFunctor>(map),
+        QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+template <typename Iterator, typename MapFunctor>
+auto blockingMapped(Iterator begin, Iterator end, MapFunctor &&map)
+{
+    using OutputSequence = QtPrivate::MapResultType<Iterator, MapFunctor>;
+    return blockingMappedReduced<OutputSequence>(QThreadPool::globalInstance(), begin, end,
+                                                 std::forward<MapFunctor>(map),
+                                                 QtPrivate::PushBackWrapper(), OrderedReduce);
+}
+
+} // namespace QtConcurrent
+
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentmapkernel.h

@@ -0,0 +1,327 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_MAPKERNEL_H
+#define QTCONCURRENT_MAPKERNEL_H
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#if !defined(QT_NO_CONCURRENT) || defined (Q_QDOC)
+
+#include <QtConcurrent/qtconcurrentiteratekernel.h>
+#include <QtConcurrent/qtconcurrentreducekernel.h>
+#include <QtConcurrent/qtconcurrentfunctionwrappers.h>
+
+QT_BEGIN_NAMESPACE
+
+
+namespace QtConcurrent {
+
+// map kernel, works with both parallel-for and parallel-while
+template <typename Iterator, typename MapFunctor>
+class MapKernel : public IterateKernel<Iterator, void>
+{
+    MapFunctor map;
+public:
+    typedef void ReturnType;
+    template <typename F = MapFunctor>
+    MapKernel(QThreadPool *pool, Iterator begin, Iterator end, F &&_map)
+        : IterateKernel<Iterator, void>(pool, begin, end), map(std::forward<F>(_map))
+    { }
+
+    bool runIteration(Iterator it, int, void *) override
+    {
+        std::invoke(map, *it);
+        return false;
+    }
+
+    bool runIterations(Iterator sequenceBeginIterator, int beginIndex, int endIndex, void *) override
+    {
+        Iterator it = sequenceBeginIterator;
+        std::advance(it, beginIndex);
+        for (int i = beginIndex; i < endIndex; ++i) {
+            runIteration(it, i, nullptr);
+            std::advance(it, 1);
+        }
+
+        return false;
+    }
+};
+
+template <typename ReducedResultType,
+          typename Iterator,
+          typename MapFunctor,
+          typename ReduceFunctor,
+          typename Reducer = ReduceKernel<ReduceFunctor,
+                                          ReducedResultType,
+                                          QtPrivate::MapResultType<Iterator, MapFunctor>>>
+class MappedReducedKernel : public IterateKernel<Iterator, ReducedResultType>
+{
+    ReducedResultType &reducedResult;
+    MapFunctor map;
+    ReduceFunctor reduce;
+    Reducer reducer;
+    using IntermediateResultsType = QtPrivate::MapResultType<Iterator, MapFunctor>;
+
+public:
+    typedef ReducedResultType ReturnType;
+
+    template<typename F1 = MapFunctor, typename F2 = ReduceFunctor>
+    MappedReducedKernel(QThreadPool *pool, Iterator begin, Iterator end, F1 &&_map, F2 &&_reduce,
+                        ReduceOptions reduceOptions)
+        : IterateKernel<Iterator, ReducedResultType>(pool, begin, end),
+          reducedResult(this->defaultValue.value),
+          map(std::forward<F1>(_map)),
+          reduce(std::forward<F2>(_reduce)),
+          reducer(pool, reduceOptions)
+    { }
+
+    template<typename F1 = MapFunctor, typename F2 = ReduceFunctor>
+    MappedReducedKernel(QThreadPool *pool, Iterator begin, Iterator end, F1 &&_map, F2 &&_reduce,
+                        ReducedResultType &&initialValue, ReduceOptions reduceOptions)
+        : IterateKernel<Iterator, ReducedResultType>(pool, begin, end,
+                                                     std::forward<ReducedResultType>(initialValue)),
+          reducedResult(this->defaultValue.value),
+          map(std::forward<F1>(_map)),
+          reduce(std::forward<F2>(_reduce)),
+          reducer(pool, reduceOptions)
+    {
+    }
+
+    bool runIteration(Iterator it, int index, ReducedResultType *) override
+    {
+        IntermediateResults<IntermediateResultsType> results;
+        results.begin = index;
+        results.end = index + 1;
+
+        results.vector.append(std::invoke(map, *it));
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+
+    bool runIterations(Iterator sequenceBeginIterator, int beginIndex, int endIndex, ReducedResultType *) override
+    {
+        IntermediateResults<IntermediateResultsType> results;
+        results.begin = beginIndex;
+        results.end = endIndex;
+        results.vector.reserve(endIndex - beginIndex);
+
+        Iterator it = sequenceBeginIterator;
+        std::advance(it, beginIndex);
+        for (int i = beginIndex; i < endIndex; ++i) {
+            results.vector.append(std::invoke(map, *it));
+            std::advance(it, 1);
+        }
+
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+
+    void finish() override
+    {
+        reducer.finish(reduce, reducedResult);
+    }
+
+    bool shouldThrottleThread() override
+    {
+        return IterateKernel<Iterator, ReducedResultType>::shouldThrottleThread() || reducer.shouldThrottle();
+    }
+
+    bool shouldStartThread() override
+    {
+        return IterateKernel<Iterator, ReducedResultType>::shouldStartThread() && reducer.shouldStartThread();
+    }
+
+    typedef ReducedResultType ResultType;
+    ReducedResultType *result() override
+    {
+        return &reducedResult;
+    }
+};
+
+template <typename Iterator, typename MapFunctor>
+class MappedEachKernel : public IterateKernel<Iterator, QtPrivate::MapResultType<Iterator, MapFunctor>>
+{
+    MapFunctor map;
+    using T = QtPrivate::MapResultType<Iterator, MapFunctor>;
+
+public:
+    template <typename F = MapFunctor>
+    MappedEachKernel(QThreadPool *pool, Iterator begin, Iterator end, F &&_map)
+        : IterateKernel<Iterator, T>(pool, begin, end), map(std::forward<F>(_map))
+    { }
+
+    bool runIteration(Iterator it, int,  T *result) override
+    {
+        *result = std::invoke(map, *it);
+        return true;
+    }
+
+    bool runIterations(Iterator sequenceBeginIterator, int beginIndex, int endIndex, T *results) override
+    {
+
+        Iterator it = sequenceBeginIterator;
+        std::advance(it, beginIndex);
+        for (int i = beginIndex; i < endIndex; ++i) {
+            runIteration(it, i, results + (i - beginIndex));
+            std::advance(it, 1);
+        }
+
+        return true;
+    }
+};
+
+//! [qtconcurrentmapkernel-1]
+template <typename Iterator, typename Functor>
+inline ThreadEngineStarter<void> startMap(QThreadPool *pool, Iterator begin,
+                                          Iterator end, Functor &&functor)
+{
+    return startThreadEngine(new MapKernel<Iterator, std::decay_t<Functor>>(
+            pool, begin, end, std::forward<Functor>(functor)));
+}
+
+//! [qtconcurrentmapkernel-2]
+template <typename T, typename Iterator, typename Functor>
+inline ThreadEngineStarter<T> startMapped(QThreadPool *pool, Iterator begin,
+                                          Iterator end, Functor &&functor)
+{
+    return startThreadEngine(new MappedEachKernel<Iterator, std::decay_t<Functor>>(
+            pool, begin, end, std::forward<Functor>(functor)));
+}
+
+/*
+    The SequnceHolder class is used to hold a reference to the
+    sequence we are working on.
+*/
+template <typename Sequence, typename Base, typename Functor>
+struct SequenceHolder1 : private QtPrivate::SequenceHolder<Sequence>, public Base
+{
+    template<typename S = Sequence, typename F = Functor>
+    SequenceHolder1(QThreadPool *pool, S &&_sequence, F &&functor)
+        : QtPrivate::SequenceHolder<Sequence>(std::forward<S>(_sequence)),
+          Base(pool, this->sequence.cbegin(), this->sequence.cend(), std::forward<F>(functor))
+    { }
+
+    void finish() override
+    {
+        Base::finish();
+        // Clear the sequence to make sure all temporaries are destroyed
+        // before finished is signaled.
+        this->sequence = Sequence();
+    }
+};
+
+//! [qtconcurrentmapkernel-3]
+template <typename T, typename Sequence, typename Functor>
+inline ThreadEngineStarter<T> startMapped(QThreadPool *pool, Sequence &&sequence,
+                                          Functor &&functor)
+{
+    using DecayedSequence = std::decay_t<Sequence>;
+    using DecayedFunctor = std::decay_t<Functor>;
+    using SequenceHolderType = SequenceHolder1<
+            DecayedSequence,
+            MappedEachKernel<typename DecayedSequence::const_iterator, DecayedFunctor>,
+            DecayedFunctor>;
+
+    return startThreadEngine(new SequenceHolderType(pool, std::forward<Sequence>(sequence),
+                                                    std::forward<Functor>(functor)));
+}
+
+//! [qtconcurrentmapkernel-4]
+template <typename IntermediateType, typename ResultType, typename Sequence, typename MapFunctor,
+          typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startMappedReduced(QThreadPool *pool,
+                                                          Sequence &&sequence,
+                                                          MapFunctor &&mapFunctor,
+                                                          ReduceFunctor &&reduceFunctor,
+                                                          ReduceOptions options)
+{
+    using DecayedSequence = std::decay_t<Sequence>;
+    using DecayedMapFunctor = std::decay_t<MapFunctor>;
+    using DecayedReduceFunctor = std::decay_t<ReduceFunctor>;
+    using Iterator = typename DecayedSequence::const_iterator;
+    using Reducer = ReduceKernel<DecayedReduceFunctor, ResultType, IntermediateType>;
+    using MappedReduceType = MappedReducedKernel<ResultType, Iterator, DecayedMapFunctor,
+                                                 DecayedReduceFunctor, Reducer>;
+    using SequenceHolderType = SequenceHolder2<DecayedSequence, MappedReduceType, DecayedMapFunctor,
+                                               DecayedReduceFunctor>;
+    return startThreadEngine(new SequenceHolderType(pool, std::forward<Sequence>(sequence),
+                                                    std::forward<MapFunctor>(mapFunctor),
+                                                    std::forward<ReduceFunctor>(reduceFunctor),
+                                                    options));
+}
+
+//! [qtconcurrentmapkernel-5]
+template <typename IntermediateType, typename ResultType, typename Iterator, typename MapFunctor,
+          typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startMappedReduced(QThreadPool *pool,
+                                                          Iterator begin,
+                                                          Iterator end,
+                                                          MapFunctor &&mapFunctor,
+                                                          ReduceFunctor &&reduceFunctor,
+                                                          ReduceOptions options)
+{
+    using Reducer =
+            ReduceKernel<std::decay_t<ReduceFunctor>, std::decay_t<ResultType>, IntermediateType>;
+    using MappedReduceType = MappedReducedKernel<ResultType, Iterator, std::decay_t<MapFunctor>,
+                                                 std::decay_t<ReduceFunctor>, Reducer>;
+    return startThreadEngine(new MappedReduceType(pool, begin, end,
+                                                  std::forward<MapFunctor>(mapFunctor),
+                                                  std::forward<ReduceFunctor>(reduceFunctor),
+                                                  options));
+}
+
+//! [qtconcurrentmapkernel-6]
+template <typename IntermediateType, typename ResultType, typename Sequence, typename MapFunctor,
+          typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startMappedReduced(QThreadPool *pool,
+                                                          Sequence &&sequence,
+                                                          MapFunctor &&mapFunctor,
+                                                          ReduceFunctor &&reduceFunctor,
+                                                          ResultType &&initialValue,
+                                                          ReduceOptions options)
+{
+    using DecayedSequence = std::decay_t<Sequence>;
+    using DecayedMapFunctor = std::decay_t<MapFunctor>;
+    using DecayedReduceFunctor = std::decay_t<ReduceFunctor>;
+    using Iterator = typename DecayedSequence::const_iterator;
+    using Reducer = ReduceKernel<DecayedReduceFunctor, ResultType, IntermediateType>;
+    using MappedReduceType = MappedReducedKernel<ResultType, Iterator, DecayedMapFunctor,
+                                                 DecayedReduceFunctor, Reducer>;
+    using SequenceHolderType = SequenceHolder2<DecayedSequence, MappedReduceType, DecayedMapFunctor,
+                                               DecayedReduceFunctor>;
+    return startThreadEngine(
+            new SequenceHolderType(pool, std::forward<Sequence>(sequence),
+                                   std::forward<MapFunctor>(mapFunctor),
+                                   std::forward<ReduceFunctor>(reduceFunctor),
+                                   std::forward<ResultType>(initialValue), options));
+}
+
+//! [qtconcurrentmapkernel-7]
+template <typename IntermediateType, typename ResultType, typename Iterator, typename MapFunctor,
+          typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startMappedReduced(QThreadPool *pool,
+                                                          Iterator begin,
+                                                          Iterator end,
+                                                          MapFunctor &&mapFunctor,
+                                                          ReduceFunctor &&reduceFunctor,
+                                                          ResultType &&initialValue,
+                                                          ReduceOptions options)
+{
+    using Reducer = ReduceKernel<std::decay_t<ReduceFunctor>, ResultType, IntermediateType>;
+    using MappedReduceType = MappedReducedKernel<ResultType, Iterator, std::decay_t<MapFunctor>,
+                                                 std::decay_t<ReduceFunctor>, Reducer>;
+    return startThreadEngine(new MappedReduceType(pool, begin, end,
+                                                  std::forward<MapFunctor>(mapFunctor),
+                                                  std::forward<ReduceFunctor>(reduceFunctor),
+                                                  std::forward<ResultType>(initialValue), options));
+}
+
+} // namespace QtConcurrent
+
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentmedian.h

@@ -0,0 +1,90 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_MEDIAN_H
+#define QTCONCURRENT_MEDIAN_H
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#if !defined(QT_NO_CONCURRENT) || defined(Q_QDOC)
+
+#include <algorithm>
+#include <cstring>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtConcurrent {
+
+class Median
+{
+public:
+    enum { BufferSize = 7 };
+
+    Median()
+        : currentMedian(), currentIndex(0), valid(false), dirty(true)
+    {
+        std::fill_n(values, static_cast<int>(BufferSize), 0.0);
+    }
+
+    void reset()
+    {
+        std::fill_n(values, static_cast<int>(BufferSize), 0.0);
+        currentIndex = 0;
+        valid = false;
+        dirty = true;
+    }
+
+    void addValue(double value)
+    {
+        ++currentIndex;
+        if (currentIndex == BufferSize) {
+            currentIndex = 0;
+            valid = true;
+        }
+
+        // Only update the cached median value when we have to, that
+        // is when the new value is on then other side of the median
+        // compared to the current value at the index.
+        const double currentIndexValue = values[currentIndex];
+        if ((currentIndexValue > currentMedian && currentMedian > value)
+            || (currentMedian > currentIndexValue && value > currentMedian)) {
+            dirty = true;
+        }
+
+        values[currentIndex] = value;
+    }
+
+    bool isMedianValid() const
+    {
+        return valid;
+    }
+
+    double median()
+    {
+        if (dirty) {
+            dirty = false;
+
+            double sorted[BufferSize];
+            ::memcpy(&sorted, &values, sizeof(sorted));
+            std::sort(sorted, sorted + static_cast<int>(BufferSize));
+            currentMedian = sorted[BufferSize / 2];
+        }
+
+        return currentMedian;
+    }
+
+private:
+    double values[BufferSize];
+    double currentMedian;
+    int currentIndex;
+    bool valid;
+    bool dirty;
+};
+
+} // namespace QtConcurrent
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentreducekernel.h

@@ -0,0 +1,237 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_REDUCEKERNEL_H
+#define QTCONCURRENT_REDUCEKERNEL_H
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#if !defined(QT_NO_CONCURRENT) || defined(Q_QDOC)
+
+#include <QtCore/qatomic.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qmap.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qthread.h>
+#include <QtCore/qthreadpool.h>
+
+#include <mutex>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtPrivate {
+
+template<typename Sequence>
+struct SequenceHolder
+{
+    SequenceHolder(const Sequence &s) : sequence(s) { }
+    SequenceHolder(Sequence &&s) : sequence(std::move(s)) { }
+    Sequence sequence;
+};
+
+}
+
+namespace QtConcurrent {
+
+/*
+    The ReduceQueueStartLimit and ReduceQueueThrottleLimit constants
+    limit the reduce queue size for MapReduce. When the number of
+    reduce blocks in the queue exceeds ReduceQueueStartLimit,
+    MapReduce won't start any new threads, and when it exceeds
+    ReduceQueueThrottleLimit running threads will be stopped.
+*/
+#ifdef Q_QDOC
+enum ReduceQueueLimits {
+    ReduceQueueStartLimit = 20,
+    ReduceQueueThrottleLimit = 30
+};
+#else
+enum {
+    ReduceQueueStartLimit = 20,
+    ReduceQueueThrottleLimit = 30
+};
+#endif
+
+// IntermediateResults holds a block of intermediate results from a
+// map or filter functor. The begin/end offsets indicates the origin
+// and range of the block.
+template <typename T>
+class IntermediateResults
+{
+public:
+    int begin, end;
+    QList<T> vector;
+};
+
+enum ReduceOption {
+    UnorderedReduce = 0x1,
+    OrderedReduce = 0x2,
+    SequentialReduce = 0x4
+    // ParallelReduce = 0x8
+};
+Q_DECLARE_FLAGS(ReduceOptions, ReduceOption)
+#ifndef Q_QDOC
+Q_DECLARE_OPERATORS_FOR_FLAGS(ReduceOptions)
+#endif
+// supports both ordered and out-of-order reduction
+template <typename ReduceFunctor, typename ReduceResultType, typename T>
+class ReduceKernel
+{
+    typedef QMap<int, IntermediateResults<T> > ResultsMap;
+
+    const ReduceOptions reduceOptions;
+
+    QMutex mutex;
+    int progress, resultsMapSize;
+    const int threadCount;
+    ResultsMap resultsMap;
+
+    bool canReduce(int begin) const
+    {
+        return (((reduceOptions & UnorderedReduce)
+                 && progress == 0)
+                || ((reduceOptions & OrderedReduce)
+                    && progress == begin));
+    }
+
+    void reduceResult(ReduceFunctor &reduce,
+                      ReduceResultType &r,
+                      const IntermediateResults<T> &result)
+    {
+        for (int i = 0; i < result.vector.size(); ++i) {
+            std::invoke(reduce, r, result.vector.at(i));
+        }
+    }
+
+    void reduceResults(ReduceFunctor &reduce,
+                       ReduceResultType &r,
+                       ResultsMap &map)
+    {
+        typename ResultsMap::iterator it = map.begin();
+        while (it != map.end()) {
+            reduceResult(reduce, r, it.value());
+            ++it;
+        }
+    }
+
+public:
+    ReduceKernel(QThreadPool *pool, ReduceOptions _reduceOptions)
+        : reduceOptions(_reduceOptions), progress(0), resultsMapSize(0),
+          threadCount(std::max(pool->maxThreadCount(), 1))
+    { }
+
+    void runReduce(ReduceFunctor &reduce,
+                   ReduceResultType &r,
+                   const IntermediateResults<T> &result)
+    {
+        std::unique_lock<QMutex> locker(mutex);
+        if (!canReduce(result.begin)) {
+            ++resultsMapSize;
+            resultsMap.insert(result.begin, result);
+            return;
+        }
+
+        if (reduceOptions & UnorderedReduce) {
+            // UnorderedReduce
+            progress = -1;
+
+            // reduce this result
+            locker.unlock();
+            reduceResult(reduce, r, result);
+            locker.lock();
+
+            // reduce all stored results as well
+            while (!resultsMap.isEmpty()) {
+                ResultsMap resultsMapCopy = resultsMap;
+                resultsMap.clear();
+
+                locker.unlock();
+                reduceResults(reduce, r, resultsMapCopy);
+                locker.lock();
+
+                resultsMapSize -= resultsMapCopy.size();
+            }
+
+            progress = 0;
+        } else {
+            // reduce this result
+            locker.unlock();
+            reduceResult(reduce, r, result);
+            locker.lock();
+
+            // OrderedReduce
+            progress += result.end - result.begin;
+
+            // reduce as many other results as possible
+            typename ResultsMap::iterator it = resultsMap.begin();
+            while (it != resultsMap.end()) {
+                if (it.value().begin != progress)
+                    break;
+
+                locker.unlock();
+                reduceResult(reduce, r, it.value());
+                locker.lock();
+
+                --resultsMapSize;
+                progress += it.value().end - it.value().begin;
+                it = resultsMap.erase(it);
+            }
+        }
+    }
+
+    // final reduction
+    void finish(ReduceFunctor &reduce, ReduceResultType &r)
+    {
+        reduceResults(reduce, r, resultsMap);
+    }
+
+    inline bool shouldThrottle()
+    {
+        std::lock_guard<QMutex> locker(mutex);
+        return (resultsMapSize > (ReduceQueueThrottleLimit * threadCount));
+    }
+
+    inline bool shouldStartThread()
+    {
+        std::lock_guard<QMutex> locker(mutex);
+        return (resultsMapSize <= (ReduceQueueStartLimit * threadCount));
+    }
+};
+
+template <typename Sequence, typename Base, typename Functor1, typename Functor2>
+struct SequenceHolder2 : private QtPrivate::SequenceHolder<Sequence>, public Base
+{
+    template<typename S = Sequence, typename F1 = Functor1, typename F2 = Functor2>
+    SequenceHolder2(QThreadPool *pool, S &&_sequence, F1 &&functor1, F2 &&functor2,
+                    ReduceOptions reduceOptions)
+        : QtPrivate::SequenceHolder<Sequence>(std::forward<S>(_sequence)),
+          Base(pool, this->sequence.cbegin(), this->sequence.cend(),
+               std::forward<F1>(functor1), std::forward<F2>(functor2), reduceOptions)
+    { }
+
+    template<typename InitialValueType, typename S = Sequence,
+             typename F1 = Functor1, typename F2 = Functor2>
+    SequenceHolder2(QThreadPool *pool, S &&_sequence, F1 &&functor1, F2 &&functor2,
+                    InitialValueType &&initialValue, ReduceOptions reduceOptions)
+        : QtPrivate::SequenceHolder<Sequence>(std::forward<S>(_sequence)),
+          Base(pool, this->sequence.cbegin(), this->sequence.cend(),
+               std::forward<F1>(functor1), std::forward<F2>(functor2),
+               std::forward<InitialValueType>(initialValue), reduceOptions)
+    { }
+
+    void finish() override
+    {
+        Base::finish();
+        // Clear the sequence to make sure all temporaries are destroyed
+        // before finished is signaled.
+        this->sequence = Sequence();
+    }
+};
+
+} // namespace QtConcurrent
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentrun.h

@@ -0,0 +1,96 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_RUN_H
+#define QTCONCURRENT_RUN_H
+
+#if 0
+#pragma qt_class(QtConcurrentRun)
+#endif
+
+#include <QtConcurrent/qtconcurrentcompilertest.h>
+
+#if !defined(QT_NO_CONCURRENT) || defined(Q_QDOC)
+
+#include <QtConcurrent/qtconcurrentrunbase.h>
+#include <QtConcurrent/qtconcurrentstoredfunctioncall.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifdef Q_QDOC
+
+typedef int Function;
+
+namespace QtConcurrent {
+
+    template <typename T>
+    QFuture<T> run(Function function, ...);
+
+    template <typename T>
+    QFuture<T> run(QThreadPool *pool, Function function, ...);
+
+} // namespace QtConcurrent
+
+#else
+
+namespace QtConcurrent {
+
+#define QTCONCURRENT_RUN_NODISCARD \
+    Q_NODISCARD_X("Use QThreadPool::start(Callable&&) if you don't need the returned QFuture")
+
+template <class Function, class ...Args>
+QTCONCURRENT_RUN_NODISCARD
+auto run(QThreadPool *pool, Function &&f, Args &&...args)
+{
+    DecayedTuple<Function, Args...> tuple { std::forward<Function>(f),
+                                            std::forward<Args>(args)... };
+    return TaskResolver<std::decay_t<Function>, std::decay_t<Args>...>::run(
+                std::move(tuple), TaskStartParameters { pool });
+}
+
+template <class Function, class ...Args>
+QTCONCURRENT_RUN_NODISCARD
+auto run(QThreadPool *pool, std::reference_wrapper<const Function> &&functionWrapper,
+         Args &&...args)
+{
+    return run(pool, std::forward<const Function>(functionWrapper.get()),
+               std::forward<Args>(args)...);
+}
+
+template <class Function, class ...Args>
+QTCONCURRENT_RUN_NODISCARD
+auto run(Function &&f, Args &&...args)
+{
+    return run(QThreadPool::globalInstance(), std::forward<Function>(f),
+               std::forward<Args>(args)...);
+}
+
+// overload with a Promise Type hint, takes thread pool
+template <class PromiseType, class Function, class ...Args>
+QTCONCURRENT_RUN_NODISCARD
+auto run(QThreadPool *pool, Function &&f, Args &&...args)
+{
+    return (new StoredFunctionCallWithPromise<Function, PromiseType, Args...>(
+                std::forward<Function>(f), std::forward<Args>(args)...))->start(pool);
+}
+
+// overload with a Promise Type hint, uses global thread pool
+template <class PromiseType, class Function, class ...Args>
+QTCONCURRENT_RUN_NODISCARD
+auto run(Function &&f, Args &&...args)
+{
+    return run<PromiseType>(QThreadPool::globalInstance(), std::forward<Function>(f),
+                            std::forward<Args>(args)...);
+}
+
+#undef QTCONCURRENT_RUN_NODISCARD
+
+} //namespace QtConcurrent
+
+#endif // Q_QDOC
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentrunbase.h

@@ -0,0 +1,108 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_RUNBASE_H
+#define QTCONCURRENT_RUNBASE_H
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#ifndef QT_NO_CONCURRENT
+
+#include <QtCore/qfuture.h>
+#include <QtCore/qrunnable.h>
+#include <QtCore/qthreadpool.h>
+
+#include <type_traits>
+#include <utility>
+
+QT_BEGIN_NAMESPACE
+
+
+#ifndef Q_QDOC
+
+namespace QtConcurrent {
+
+template <typename T>
+struct SelectSpecialization
+{
+    template <class Normal, class Void>
+    struct Type { typedef Normal type; };
+};
+
+template <>
+struct SelectSpecialization<void>
+{
+    template <class Normal, class Void>
+    struct Type { typedef Void type; };
+};
+
+struct TaskStartParameters
+{
+    QThreadPool *threadPool = QThreadPool::globalInstance();
+    int priority = 0;
+};
+
+template <typename T>
+class RunFunctionTaskBase : public QRunnable
+{
+public:
+    QFuture<T> start()
+    {
+        return start(TaskStartParameters());
+    }
+
+    QFuture<T> start(const TaskStartParameters &parameters)
+    {
+        promise.setThreadPool(parameters.threadPool);
+        promise.setRunnable(this);
+        promise.reportStarted();
+        QFuture<T> theFuture = promise.future();
+
+        if (parameters.threadPool) {
+            parameters.threadPool->start(this, parameters.priority);
+        } else {
+            promise.reportCanceled();
+            promise.reportFinished();
+            delete this;
+        }
+        return theFuture;
+    }
+
+    // For backward compatibility
+    QFuture<T> start(QThreadPool *pool) { return start({pool, 0});  }
+
+    void run() override
+    {
+        if (promise.isCanceled()) {
+            promise.reportFinished();
+            return;
+        }
+#ifndef QT_NO_EXCEPTIONS
+        try {
+#endif
+            runFunctor();
+#ifndef QT_NO_EXCEPTIONS
+        } catch (QException &e) {
+            promise.reportException(e);
+        } catch (...) {
+            promise.reportException(QUnhandledException(std::current_exception()));
+        }
+#endif
+        promise.reportFinished();
+    }
+
+protected:
+    virtual void runFunctor() = 0;
+
+    QFutureInterface<T> promise;
+};
+
+} //namespace QtConcurrent
+
+#endif //Q_QDOC
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentstoredfunctioncall.h

@@ -0,0 +1,230 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_STOREDFUNCTIONCALL_H
+#define QTCONCURRENT_STOREDFUNCTIONCALL_H
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#ifndef QT_NO_CONCURRENT
+#include <QtConcurrent/qtconcurrentrunbase.h>
+#include <QtCore/qpromise.h>
+
+#include <type_traits>
+
+QT_BEGIN_NAMESPACE
+
+#ifndef Q_QDOC
+
+namespace QtConcurrent {
+
+template<typename...>
+struct NonMemberFunctionResolver;
+
+template <class Function, class PromiseType, class... Args>
+struct NonMemberFunctionResolver<Function, PromiseType, Args...>
+{
+    using Type = std::tuple<std::decay_t<Function>, QPromise<PromiseType> &, std::decay_t<Args>...>;
+    static_assert(std::is_invocable_v<std::decay_t<Function>, QPromise<PromiseType> &, std::decay_t<Args>...>,
+                  "It's not possible to invoke the function with passed arguments.");
+    static_assert(std::is_void_v<std::invoke_result_t<std::decay_t<Function>, QPromise<PromiseType> &, std::decay_t<Args>...>>,
+                  "The function must return void type.");
+
+    static constexpr void invoke(std::decay_t<Function> function, QPromise<PromiseType> &promise,
+                                 std::decay_t<Args>... args)
+    {
+        std::invoke(function, promise, args...);
+    }
+    static Type initData(Function &&f, QPromise<PromiseType> &promise, Args &&...args)
+    {
+        return Type { std::forward<Function>(f), std::ref(promise), std::forward<Args>(args)... };
+    }
+};
+
+template<typename...>
+struct MemberFunctionResolver;
+
+template <typename Function, typename PromiseType, typename Arg, typename ... Args>
+struct MemberFunctionResolver<Function, PromiseType, Arg, Args...>
+{
+    using Type = std::tuple<std::decay_t<Function>, std::decay_t<Arg>, QPromise<PromiseType> &, std::decay_t<Args>...>;
+    static_assert(std::is_invocable_v<std::decay_t<Function>, std::decay_t<Arg>, QPromise<PromiseType> &, std::decay_t<Args>...>,
+                  "It's not possible to invoke the function with passed arguments.");
+    static_assert(std::is_void_v<std::invoke_result_t<std::decay_t<Function>, std::decay_t<Arg>, QPromise<PromiseType> &, std::decay_t<Args>...>>,
+                  "The function must return void type.");
+
+    static constexpr void invoke(std::decay_t<Function> function, std::decay_t<Arg> object,
+                                 QPromise<PromiseType> &promise, std::decay_t<Args>... args)
+    {
+        std::invoke(function, object, promise, args...);
+    }
+    static Type initData(Function &&f, QPromise<PromiseType> &promise, Arg &&fa, Args &&...args)
+    {
+        return Type { std::forward<Function>(f), std::forward<Arg>(fa), std::ref(promise), std::forward<Args>(args)... };
+    }
+};
+
+template <class IsMember, class Function, class PromiseType, class... Args>
+struct FunctionResolverHelper;
+
+template <class Function, class PromiseType, class... Args>
+struct FunctionResolverHelper<std::false_type, Function, PromiseType, Args...>
+        : public NonMemberFunctionResolver<Function, PromiseType, Args...>
+{
+};
+
+template <class Function, class PromiseType, class... Args>
+struct FunctionResolverHelper<std::true_type, Function, PromiseType, Args...>
+        : public MemberFunctionResolver<Function, PromiseType, Args...>
+{
+};
+
+template <class Function, class PromiseType, class... Args>
+struct FunctionResolver
+        : public FunctionResolverHelper<typename std::is_member_function_pointer<
+                 std::decay_t<Function>>::type, Function, PromiseType, Args...>
+{
+};
+
+template <class Function, class ...Args>
+struct InvokeResult
+{
+    static_assert(std::is_invocable_v<std::decay_t<Function>, std::decay_t<Args>...>,
+                  "It's not possible to invoke the function with passed arguments.");
+
+    using Type = std::invoke_result_t<std::decay_t<Function>, std::decay_t<Args>...>;
+};
+
+template <class Function, class ...Args>
+using InvokeResultType = typename InvokeResult<Function, Args...>::Type;
+
+template <class ...Types>
+using DecayedTuple = std::tuple<std::decay_t<Types>...>;
+
+template <class Function, class ...Args>
+struct StoredFunctionCall : public RunFunctionTaskBase<InvokeResultType<Function, Args...>>
+{
+    StoredFunctionCall(DecayedTuple<Function, Args...> &&_data)
+        : data(std::move(_data))
+    {}
+
+protected:
+    void runFunctor() override
+    {
+        constexpr auto invoke = [] (std::decay_t<Function> function,
+                                    std::decay_t<Args>... args) -> auto {
+            return std::invoke(function, args...);
+        };
+
+        if constexpr (std::is_void_v<InvokeResultType<Function, Args...>>) {
+            std::apply(invoke, std::move(data));
+        } else {
+            auto result = std::apply(invoke, std::move(data));
+
+            using T = InvokeResultType<Function, Args...>;
+            if constexpr (std::is_move_constructible_v<T>)
+                this->promise.reportAndMoveResult(std::move(result));
+            else if constexpr (std::is_copy_constructible_v<T>)
+                this->promise.reportResult(result);
+        }
+    }
+
+private:
+    DecayedTuple<Function, Args...> data;
+};
+
+template <class Function, class PromiseType, class ...Args>
+struct StoredFunctionCallWithPromise : public RunFunctionTaskBase<PromiseType>
+{
+    using Resolver = FunctionResolver<Function, PromiseType, Args...>;
+    using DataType = typename Resolver::Type;
+    StoredFunctionCallWithPromise(Function &&f, Args &&...args)
+        : prom(this->promise),
+          data(std::move(Resolver::initData(std::forward<Function>(f), std::ref(prom),
+                                            std::forward<Args>(args)...)))
+    {}
+
+    StoredFunctionCallWithPromise(DecayedTuple<Function, Args...> &&_data)
+        : StoredFunctionCallWithPromise(std::move(_data),
+               std::index_sequence_for<std::decay_t<Function>, std::decay_t<Args>...>())
+    {}
+
+protected:
+    void runFunctor() override
+    {
+        std::apply(Resolver::invoke, std::move(data));
+    }
+
+private:
+    // helper to pack back the tuple into parameter pack
+    template<std::size_t... Is>
+    StoredFunctionCallWithPromise(DecayedTuple<Function, Args...> &&_data,
+                                  std::index_sequence<Is...>)
+        : StoredFunctionCallWithPromise(std::move(std::get<Is>(_data))...)
+    {}
+
+    QPromise<PromiseType> prom;
+    DataType data;
+};
+
+template<typename...>
+struct NonPromiseTaskResolver;
+
+template <typename Function, typename ... Args>
+struct NonPromiseTaskResolver<Function, Args...>
+{
+    using TaskWithArgs = DecayedTuple<Function, Args...>;
+    static auto run(TaskWithArgs &&args, const TaskStartParameters &startParameters) {
+        return (new StoredFunctionCall<Function, Args...>(std::move(args)))
+                ->start(startParameters);
+    }
+};
+
+template<typename...>
+struct PromiseTaskResolver;
+
+template <typename Function, typename ... Args>
+struct PromiseTaskResolver<Function, Args...>
+{
+    static_assert(QtPrivate::ArgResolver<Function>::IsPromise::value,
+        "The first argument of passed callable object isn't a QPromise<T> & type. "
+        "Did you intend to pass a callable which takes a QPromise<T> & type as a first argument? "
+        "Otherwise it's not possible to invoke the function with passed arguments.");
+    using TaskWithArgs = DecayedTuple<Function, Args...>;
+    static auto run(TaskWithArgs &&args, const TaskStartParameters &startParameters) {
+        using PromiseType = typename QtPrivate::ArgResolver<Function>::PromiseType;
+        return (new StoredFunctionCallWithPromise<Function, PromiseType, Args...>(std::move(args)))
+                   ->start(startParameters);
+    }
+};
+
+template <class IsDirectlyInvocable, class Function, class... Args>
+struct TaskResolverHelper;
+
+template <class Function, class... Args>
+struct TaskResolverHelper<std::true_type, Function, Args...>
+        : public NonPromiseTaskResolver<Function, Args...>
+{
+};
+
+template <class Function, class... Args>
+struct TaskResolverHelper<std::false_type, Function, Args...>
+        : public PromiseTaskResolver<Function, Args...>
+{
+};
+
+template <class Function, class... Args>
+struct TaskResolver : public TaskResolverHelper<typename std::is_invocable<std::decay_t<Function>,
+        std::decay_t<Args>...>::type, Function, Args...>
+{
+};
+
+} //namespace QtConcurrent
+
+#endif // Q_QDOC
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrenttask.h

@@ -0,0 +1,39 @@
+// Copyright (C) 2020 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENTTASK_H
+#define QTCONCURRENTTASK_H
+
+#if !defined(QT_NO_CONCURRENT)
+
+#include <QtConcurrent/qtaskbuilder.h>
+
+QT_BEGIN_NAMESPACE
+
+#ifdef Q_QDOC
+
+namespace QtConcurrent {
+
+template <class Task>
+[[nodiscard]]
+QTaskBuilder<Task> task(Task &&task);
+
+} // namespace QtConcurrent
+
+#else
+
+namespace QtConcurrent {
+
+template <class Task>
+[[nodiscard]]
+constexpr auto task(Task &&t) { return QTaskBuilder(std::forward<Task>(t)); }
+
+} // namespace QtConcurrent
+
+#endif // Q_QDOC
+
+QT_END_NAMESPACE
+
+#endif // !defined(QT_NO_CONCURRENT)
+
+#endif // QTCONCURRENTTASK_H

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentthreadengine.h

@@ -0,0 +1,224 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTCONCURRENT_THREADENGINE_H
+#define QTCONCURRENT_THREADENGINE_H
+
+#include <QtConcurrent/qtconcurrent_global.h>
+
+#if !defined(QT_NO_CONCURRENT) ||defined(Q_QDOC)
+
+#include <QtCore/qthreadpool.h>
+#include <QtCore/qfuture.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qexception.h>
+#include <QtCore/qwaitcondition.h>
+#include <QtCore/qatomic.h>
+#include <QtCore/qsemaphore.h>
+
+QT_BEGIN_NAMESPACE
+
+
+namespace QtConcurrent {
+
+// The ThreadEngineBarrier counts worker threads, and allows one
+// thread to wait for all others to finish. Tested for its use in
+// QtConcurrent, requires more testing for use as a general class.
+class ThreadEngineBarrier
+{
+private:
+    // The thread count is maintained as an integer in the count atomic
+    // variable. The count can be either positive or negative - a negative
+    // count signals that a thread is waiting on the barrier.
+
+    QAtomicInt count;
+    QSemaphore semaphore;
+public:
+    ThreadEngineBarrier();
+    void acquire();
+    int release();
+    void wait();
+    int currentCount();
+    bool releaseUnlessLast();
+};
+
+enum ThreadFunctionResult { ThrottleThread, ThreadFinished };
+
+// The ThreadEngine controls the threads used in the computation.
+// Can be run in three modes: single threaded, multi-threaded blocking
+// and multi-threaded asynchronous.
+// The code for the single threaded mode is
+class Q_CONCURRENT_EXPORT ThreadEngineBase: public QRunnable
+{
+public:
+    // Public API:
+    ThreadEngineBase(QThreadPool *pool);
+    virtual ~ThreadEngineBase();
+    void startSingleThreaded();
+    void startThread();
+    bool isCanceled();
+    void waitForResume();
+    bool isProgressReportingEnabled();
+    void setProgressValue(int progress);
+    void setProgressRange(int minimum, int maximum);
+    void acquireBarrierSemaphore();
+    void reportIfSuspensionDone() const;
+
+protected: // The user overrides these:
+    virtual void start() {}
+    virtual void finish() {}
+    virtual ThreadFunctionResult threadFunction() { return ThreadFinished; }
+    virtual bool shouldStartThread() { return !shouldThrottleThread(); }
+    virtual bool shouldThrottleThread()
+    {
+        return futureInterface ? (futureInterface->isSuspending() || futureInterface->isSuspended())
+                               : false;
+    }
+
+private:
+    bool startThreadInternal();
+    void startThreads();
+    void threadExit();
+    bool threadThrottleExit();
+    void run() override;
+    virtual void asynchronousFinish() = 0;
+#ifndef QT_NO_EXCEPTIONS
+    void handleException(const QException &exception);
+#endif
+protected:
+    QFutureInterfaceBase *futureInterface;
+    QThreadPool *threadPool;
+    ThreadEngineBarrier barrier;
+    QtPrivate::ExceptionStore exceptionStore;
+    QBasicMutex mutex;
+};
+
+
+template <typename T>
+class ThreadEngine : public ThreadEngineBase
+{
+public:
+    typedef T ResultType;
+
+    ThreadEngine(QThreadPool *pool) : ThreadEngineBase(pool) {}
+
+    virtual T *result() { return nullptr; }
+
+    QFutureInterface<T> *futureInterfaceTyped()
+    {
+        return static_cast<QFutureInterface<T> *>(futureInterface);
+    }
+
+    // Runs the user algorithm using a single thread.
+    T *startSingleThreaded()
+    {
+        ThreadEngineBase::startSingleThreaded();
+        return result();
+    }
+
+    // Runs the user algorithm using multiple threads.
+    // Does not block, returns a future.
+    QFuture<T> startAsynchronously()
+    {
+        futureInterface = new QFutureInterface<T>();
+
+        // reportStart() must be called before starting threads, otherwise the
+        // user algorithm might finish while reportStart() is running, which
+        // is very bad.
+        futureInterface->reportStarted();
+        QFuture<T> future = QFuture<T>(futureInterfaceTyped());
+        start();
+
+        acquireBarrierSemaphore();
+        threadPool->start(this);
+        return future;
+    }
+
+    void asynchronousFinish() override
+    {
+        finish();
+        futureInterfaceTyped()->reportFinished(result());
+        delete futureInterfaceTyped();
+        delete this;
+    }
+
+
+    void reportResult(const T *_result, int index = -1)
+    {
+        if (futureInterface)
+            futureInterfaceTyped()->reportResult(_result, index);
+    }
+
+    void reportResults(const QList<T> &_result, int index = -1, int count = -1)
+    {
+        if (futureInterface)
+            futureInterfaceTyped()->reportResults(_result, index, count);
+    }
+};
+
+// The ThreadEngineStarter class ecapsulates the return type
+// from the thread engine.
+// Depending on how the it is used, it will run
+// the engine in either blocking mode or asynchronous mode.
+template <typename T>
+class ThreadEngineStarterBase
+{
+public:
+    ThreadEngineStarterBase(ThreadEngine<T> *_threadEngine)
+    : threadEngine(_threadEngine) { }
+
+    inline ThreadEngineStarterBase(const ThreadEngineStarterBase &other)
+    : threadEngine(other.threadEngine) { }
+
+    QFuture<T> startAsynchronously()
+    {
+        return threadEngine->startAsynchronously();
+    }
+
+    operator QFuture<T>()
+    {
+        return startAsynchronously();
+    }
+
+protected:
+    ThreadEngine<T> *threadEngine;
+};
+
+
+// We need to factor out the code that dereferences the T pointer,
+// with a specialization where T is void. (code that dereferences a void *
+// won't compile)
+template <typename T>
+class ThreadEngineStarter : public ThreadEngineStarterBase<T>
+{
+    typedef ThreadEngineStarterBase<T> Base;
+    typedef ThreadEngine<T> TypedThreadEngine;
+public:
+    ThreadEngineStarter(TypedThreadEngine *eng)
+        : Base(eng) { }
+};
+
+// Full template specialization where T is void.
+template <>
+class ThreadEngineStarter<void> : public ThreadEngineStarterBase<void>
+{
+public:
+    ThreadEngineStarter(ThreadEngine<void> *_threadEngine)
+        : ThreadEngineStarterBase<void>(_threadEngine) {}
+};
+
+//! [qtconcurrentthreadengine-1]
+template <typename ThreadEngine>
+inline ThreadEngineStarter<typename ThreadEngine::ResultType> startThreadEngine(ThreadEngine *threadEngine)
+{
+    return ThreadEngineStarter<typename ThreadEngine::ResultType>(threadEngine);
+}
+
+} // namespace QtConcurrent
+
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_CONCURRENT
+
+#endif

qt/6.8.1/msvc2022_64/include/QtConcurrent/qtconcurrentversion.h

@@ -0,0 +1,9 @@
+/* This file was generated by syncqt. */
+#ifndef QT_QTCONCURRENT_VERSION_H
+#define QT_QTCONCURRENT_VERSION_H
+
+#define QTCONCURRENT_VERSION_STR "6.8.1"
+
+#define QTCONCURRENT_VERSION 0x060801
+
+#endif // QT_QTCONCURRENT_VERSION_H

qt/6.8.1/msvc2022_64/include/QtCore/QAbstractAnimation

@@ -0,0 +1 @@
+#include "qabstractanimation.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QAbstractEventDispatcher

@@ -0,0 +1 @@
+#include "qabstracteventdispatcher.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QAbstractEventDispatcherV2

@@ -0,0 +1 @@
+#include "qabstracteventdispatcher.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QAbstractItemModel

@@ -0,0 +1 @@
+#include "qabstractitemmodel.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QAbstractListModel

@@ -0,0 +1 @@
+#include "qabstractitemmodel.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QAbstractNativeEventFilter

@@ -0,0 +1 @@
+#include "qabstractnativeeventfilter.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QAbstractProxyModel

@@ -0,0 +1 @@
+#include "qabstractproxymodel.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QAbstractTableModel

@@ -0,0 +1 @@
+#include "qabstractitemmodel.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QAnimationDriver

@@ -0,0 +1 @@
+#include "qabstractanimation.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QAnimationGroup

@@ -0,0 +1 @@
+#include "qanimationgroup.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QAnyStringView

@@ -0,0 +1 @@
+#include "qanystringview.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QApplicationStatic

@@ -0,0 +1 @@
+#include "qapplicationstatic.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QArgument

@@ -0,0 +1 @@
+#include "qobjectdefs.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QArrayData

@@ -0,0 +1 @@
+#include "qarraydata.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/QArrayDataOps

@@ -0,0 +1 @@
+#include "qarraydataops.h" // IWYU pragma: export

qt/6.8.1/msvc2022_64/include/QtCore/q20algorithm.h

@@ -0,0 +1,191 @@
+// Copyright (C) 2021 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@kdab.com>
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+#ifndef Q20ALGORITHM_H
+#define Q20ALGORITHM_H
+
+#include <QtCore/qglobal.h>
+
+#include <algorithm>
+#include <QtCore/q20functional.h>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+namespace q20 {
+// like std::<algorithm> (ie. not ranged, but constexpr)
+#ifdef __cpp_lib_constexpr_algorithms
+using std::copy;
+using std::copy_if;
+using std::copy_n;
+using std::fill;
+using std::fill_n;
+using std::is_sorted_until;
+using std::is_sorted;
+using std::transform;
+#else
+template <typename InputIterator, typename OutputIterator>
+constexpr OutputIterator
+copy(InputIterator first, InputIterator last, OutputIterator dest)
+{
+    while (first != last) {
+        *dest = *first;
+        ++first;
+        ++dest;
+    }
+    return dest;
+}
+
+template <typename InputIterator, typename OutputIterator, typename UnaryPredicate>
+constexpr OutputIterator
+copy_if(InputIterator first, InputIterator last, OutputIterator dest, UnaryPredicate pred)
+{
+    while (first != last) {
+        if (pred(*first)) {
+            *dest = *first;
+            ++dest;
+        }
+        ++first;
+    }
+    return dest;
+}
+
+template <typename InputIterator, typename Size, typename OutputIterator>
+constexpr OutputIterator
+copy_n(InputIterator first, Size n, OutputIterator dest)
+{
+    while (n > Size{0}) {
+        *dest = *first;
+        ++first;
+        ++dest;
+        --n;
+    }
+    return dest;
+}
+
+template <typename ForwardIterator, typename Value>
+constexpr void
+fill(ForwardIterator first, ForwardIterator last, const Value &value)
+{
+    while (first != last) {
+        *first = value;
+        ++first;
+    }
+}
+
+template <typename OutputIterator, typename Size, typename Value>
+constexpr OutputIterator
+fill_n(OutputIterator first, Size n, const Value &value)
+{
+    while (n > Size{0}) {
+        *first = value;
+        ++first;
+        --n;
+    }
+    return first;
+}
+
+template <typename ForwardIterator, typename BinaryPredicate = std::less<>>
+constexpr ForwardIterator
+is_sorted_until(ForwardIterator first, ForwardIterator last, BinaryPredicate p = {})
+{
+    if (first == last)
+        return first;
+    auto prev = first;
+    while (++first != last) {
+        if (p(*first, *prev))
+            return first;
+        prev = first;
+    }
+    return first;
+}
+
+template <typename ForwardIterator, typename BinaryPredicate = std::less<>>
+constexpr bool is_sorted(ForwardIterator first, ForwardIterator last, BinaryPredicate p = {})
+{
+    return q20::is_sorted_until(first, last, p) == last;
+}
+
+template <typename InputIterator, typename OutputIterator, typename UnaryFunction>
+constexpr OutputIterator
+transform(InputIterator first, InputIterator last, OutputIterator dest, UnaryFunction op)
+{
+    while (first != last) {
+        *dest = op(*first);
+        ++first;
+        ++dest;
+    }
+    return dest;
+}
+
+// binary transform missing on purpose (no users)
+
+#endif
+}
+
+namespace q20::ranges {
+// like std::ranges::{any,all,none}_of, just unconstrained, so no range-overload
+#ifdef __cpp_lib_ranges
+using std::ranges::any_of;
+using std::ranges::all_of;
+using std::ranges::none_of;
+#else
+[[maybe_unused]] inline constexpr struct { // Niebloid
+    template <typename InputIterator, typename Sentinel,
+              typename Predicate, typename Projection = q20::identity>
+    [[maybe_unused]] constexpr bool operator()(InputIterator first, Sentinel last, Predicate pred, Projection proj = {}) const
+    {
+        while (first != last) {
+            if (std::invoke(pred, std::invoke(proj, *first)))
+                return true;
+            ++first;
+        }
+        return false;
+    }
+} any_of;
+[[maybe_unused]] inline constexpr struct { // Niebloid
+    template <typename InputIterator, typename Sentinel,
+              typename Predicate, typename Projection = q20::identity>
+    [[maybe_unused]] constexpr bool operator()(InputIterator first, Sentinel last, Predicate pred, Projection proj = {}) const
+    {
+        while (first != last) {
+            if (!std::invoke(pred, std::invoke(proj, *first)))
+                return false;
+            ++first;
+        }
+        return true;
+    }
+} all_of;
+[[maybe_unused]] inline constexpr struct { // Niebloid
+    template <typename InputIterator, typename Sentinel,
+              typename Predicate, typename Projection = q20::identity>
+    [[maybe_unused]] constexpr bool operator()(InputIterator first, Sentinel last, Predicate pred, Projection proj = {}) const
+    {
+        while (first != last) {
+            if (std::invoke(pred, std::invoke(proj, *first)))
+                return false;
+            ++first;
+        }
+        return true;
+    }
+} none_of;
+#endif // __cpp_lib_ranges
+} // namespace q20::ranges
+
+QT_END_NAMESPACE
+
+#endif /* Q20ALGORITHM_H */

qt/6.8.1/msvc2022_64/include/QtCore/q20chrono.h

@@ -0,0 +1,62 @@
+// Copyright (C) 2023 Ahmad Samir <a.samirh78@gmail.com>
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef Q20CHRONO_H
+#define Q20CHRONO_H
+
+#include <QtCore/qtconfigmacros.h>
+
+#include <chrono>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+namespace q20 {
+namespace chrono {
+
+#if defined(__GLIBCXX__)
+// https://gcc.gnu.org/git/?p=gcc.git;a=blob;f=libstdc%2B%2B-v3/include/bits/chrono.h
+using IntRep = int64_t;
+#else
+// https://github.com/llvm/llvm-project/blob/main/libcxx/include/__chrono/duration.h
+// https://github.com/microsoft/STL/blob/main/stl/inc/__msvc_chrono.hpp
+using IntRep = int;
+#endif
+
+#if __cpp_lib_chrono >= 201907L
+using std::chrono::days;
+using std::chrono::weeks;
+using std::chrono::years;
+using std::chrono::months;
+
+static_assert(std::is_same_v<days::rep, IntRep>);
+static_assert(std::is_same_v<weeks::rep, IntRep>);
+static_assert(std::is_same_v<years::rep, IntRep>);
+static_assert(std::is_same_v<months::rep, IntRep>);
+#else
+using days = std::chrono::duration<IntRep, std::ratio<86400>>;
+using weeks = std::chrono::duration<IntRep, std::ratio_multiply<std::ratio<7>, days::period>>;
+using years = std::chrono::duration<IntRep, std::ratio_multiply<std::ratio<146097, 400>, days::period>>;
+using months = std::chrono::duration<IntRep, std::ratio_divide<years::period, std::ratio<12>>>;
+#endif // __cpp_lib_chrono >= 201907L
+} // namespace chrono
+} // namespace q20
+
+QT_END_NAMESPACE
+
+#endif /* Q20CHRONO_H */

qt/6.8.1/msvc2022_64/include/QtCore/q20functional.h

@@ -0,0 +1,46 @@
+// Copyright (C) 2021 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@kdab.com>
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+#ifndef Q20FUNCTIONAL_H
+#define Q20FUNCTIONAL_H
+
+#include <QtCore/qglobal.h>
+
+#include <functional>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+#include <functional>
+
+QT_BEGIN_NAMESPACE
+
+namespace q20 {
+// like std::identity
+#ifdef __cpp_lib_ranges
+using std::identity;
+#else
+struct identity
+{
+    struct is_transparent {};
+    template <typename T>
+    constexpr T &&operator()(T&& t) const noexcept { return std::forward<T>(t); }
+};
+#endif // __cpp_lib_ranges
+} // namespace q20
+
+QT_END_NAMESPACE
+
+#endif /* Q20FUNCTIONAL_H */

qt/6.8.1/msvc2022_64/include/QtCore/q20iterator.h

@@ -0,0 +1,54 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+#ifndef Q20ITERATOR_H
+#define Q20ITERATOR_H
+
+#include <QtCore/qglobal.h>
+
+#include <iterator>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+// like std::ssize
+namespace q20 {
+#ifdef __cpp_lib_ssize
+    using std::ssize;
+#else
+    template<class C> constexpr auto ssize(const C &c)
+      -> std::common_type_t<std::ptrdiff_t, std::make_signed_t<decltype(c.size())>>
+    { return static_cast<std::common_type_t<std::ptrdiff_t, std::make_signed_t<decltype(c.size())>>>(c.size()); }
+
+    template<class T, std::ptrdiff_t N> constexpr std::ptrdiff_t ssize(const T (&)[N]) noexcept
+    { return N; }
+#endif
+} // namespace q20
+
+// like q20::iter_reference_t
+namespace q20 {
+#ifdef __cpp_lib_ranges
+    using std::iter_reference_t;
+#else
+    template <typename Dereferencable> // unconstrained (constraint requires concepts)
+    using iter_reference_t = decltype(*std::declval<Dereferencable&>());
+#endif // __cpp_lib_ranges
+} // namespace q20
+
+QT_END_NAMESPACE
+
+#endif /* Q20ITERATOR_H */

qt/6.8.1/msvc2022_64/include/QtCore/q20map.h

@@ -0,0 +1,72 @@
+// Copyright (C) 2023 Ahmad Samir <a.samirh78@gmail.com>
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef Q20MAP_H
+#define Q20MAP_H
+
+#include <QtCore/qtconfigmacros.h>
+
+#include <map>
+#if __has_include(<memory_resource>)
+#  include <memory_resource>
+#endif
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+namespace q20 {
+// like std::erase/std::erase_if for std::map
+#if defined(__cpp_lib_erase_if) && __cpp_lib_erase_if >= 202002L // the one returning size_type
+using std::erase_if;
+#else
+
+// Make it more specialized than the compiler's, so that our implementation is preferred over
+// the compiler's (which may be present, but return void instead of the number of erased elements).
+
+#define MAKE_OVERLOAD(map, allocator) \
+    template <typename Key, typename T, typename Compare, typename Pred> \
+    constexpr typename std::map<Key, T, Compare, std::allocator<std::pair<const Key, T>>>::size_type \
+    erase_if(std::map<Key, T, Compare, std::allocator<std::pair<const Key, T>>> &c, Pred p) \
+    { \
+        const auto origSize = c.size(); \
+        for (auto it = c.begin(), end = c.end(); it != end; /* erasing */) { \
+            if (p(*it)) \
+                it = c.erase(it); \
+            else \
+                ++it; \
+        } \
+        return origSize - c.size(); \
+    } \
+    /* end */
+
+MAKE_OVERLOAD(map, allocator)
+MAKE_OVERLOAD(multimap, allocator)
+#ifdef __cpp_lib_polymorphic_allocator
+MAKE_OVERLOAD(map, pmr::polymorphic_allocator)
+MAKE_OVERLOAD(multimap, pmr::polymorphic_allocator)
+#endif // __cpp_lib_polymorphic_allocator
+
+#undef MAKE_OVERLOAD
+
+#endif // __cpp_lib_erase_if
+} // namespace q20
+
+QT_END_NAMESPACE
+
+#endif /* Q20MAP_H */

qt/6.8.1/msvc2022_64/include/QtCore/q20memory.h

@@ -0,0 +1,93 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@kdab.com>
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef Q20MEMORY_H
+#define Q20MEMORY_H
+
+#include <QtCore/qtconfigmacros.h>
+
+#include <memory>
+
+#include <type_traits>
+#include <utility>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+// like std::construct_at (but not whitelisted for constexpr)
+namespace q20 {
+#ifdef __cpp_lib_constexpr_dynamic_alloc
+using std::construct_at;
+#else
+template <typename T,
+          typename... Args,
+          typename Enable = std::void_t<decltype(::new (std::declval<void *>()) T(std::declval<Args>()...))> >
+T *construct_at(T *ptr, Args && ... args)
+{
+    return ::new (const_cast<void *>(static_cast<const volatile void *>(ptr)))
+                                                                T(std::forward<Args>(args)...);
+}
+#endif // __cpp_lib_constexpr_dynamic_alloc
+} // namespace q20
+
+
+namespace q20 {
+// like std::to_address
+#ifdef __cpp_lib_to_address
+using std::to_address;
+#else
+// http://eel.is/c++draft/pointer.conversion
+template <typename T>
+constexpr T *to_address(T *p) noexcept {
+    // http://eel.is/c++draft/pointer.conversion#1:
+    //    Mandates: T is not a function type.
+    static_assert(!std::is_function_v<T>, "to_address must not be used on function types");
+    return p;
+}
+
+template <typename Ptr, typename std::enable_if_t<!std::is_pointer_v<Ptr>, bool> = true>
+constexpr auto to_address(const Ptr &ptr) noexcept; // fwd declared
+
+namespace detail {
+    // http://eel.is/c++draft/pointer.conversion#3
+    template <typename Ptr, typename = void>
+    struct to_address_helper {
+        static auto get(const Ptr &ptr) noexcept
+        { return q20::to_address(ptr.operator->()); }
+    };
+    template <typename Ptr>
+    struct to_address_helper<Ptr, std::void_t<
+            decltype(std::pointer_traits<Ptr>::to_address(std::declval<const Ptr&>()))
+        >>
+    {
+        static auto get(const Ptr &ptr) noexcept
+        { return std::pointer_traits<Ptr>::to_address(ptr); }
+    };
+} // namespace detail
+
+template <typename Ptr, typename std::enable_if_t<!std::is_pointer_v<Ptr>, bool>>
+constexpr auto to_address(const Ptr &ptr) noexcept
+{ return detail::to_address_helper<Ptr>::get(ptr); }
+
+#endif // __cpp_lib_to_address
+} // namespace q20
+
+QT_END_NAMESPACE
+
+#endif /* Q20MEMORY_H */

qt/6.8.1/msvc2022_64/include/QtCore/q20type_traits.h

@@ -0,0 +1,81 @@
+// Copyright (C) 2021 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@kdab.com>
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+#ifndef Q20TYPE_TRAITS_H
+#define Q20TYPE_TRAITS_H
+
+#include <QtCore/qcompilerdetection.h>
+#include <QtCore/qsystemdetection.h>
+#include <QtCore/qtconfigmacros.h>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+#include <type_traits>
+
+QT_BEGIN_NAMESPACE
+
+namespace q20 {
+// like std::is_constant_evaluated
+#ifdef __cpp_lib_is_constant_evaluated
+using std::is_constant_evaluated;
+#define QT_SUPPORTS_IS_CONSTANT_EVALUATED
+#else
+constexpr bool is_constant_evaluated() noexcept
+{
+#ifdef Q_OS_INTEGRITY
+    // Integrity complains "calling __has_builtin() from a constant expression".
+    // Avoid the __has_builtin check until we know what's going on.
+    return false;
+#elif __has_builtin(__builtin_is_constant_evaluated) || \
+    (defined(Q_CC_MSVC_ONLY) /* >= 1925, but we require 1927 in qglobal.h */)
+#  define QT_SUPPORTS_IS_CONSTANT_EVALUATED
+    return __builtin_is_constant_evaluated();
+#else
+    return false;
+#endif
+}
+#endif // __cpp_lib_is_constant_evaluated
+}
+
+namespace q20 {
+// like std::remove_cvref(_t)
+#ifdef __cpp_lib_remove_cvref
+using std::remove_cvref;
+using std::remove_cvref_t;
+#else
+template <typename T>
+using remove_cvref = std::remove_cv<std::remove_reference_t<T>>;
+template <typename T>
+using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+#endif // __cpp_lib_remove_cvref
+}
+
+namespace q20 {
+// like std::type_identity(_t)
+#ifdef __cpp_lib_type_identity
+using std::type_identity;
+using std::type_identity_t;
+#else
+template <typename T>
+struct type_identity { using type = T; };
+template <typename T>
+using type_identity_t = typename type_identity<T>::type;
+#endif // __cpp_lib_type_identity
+}
+
+QT_END_NAMESPACE
+
+#endif /* Q20TYPE_TRAITS_H */

qt/6.8.1/msvc2022_64/include/QtCore/q20vector.h

@@ -0,0 +1,90 @@
+// Copyright (C) 2023 Ahmad Samir <a.samirh78@gmail.com>
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef Q20VECTOR_H
+#define Q20VECTOR_H
+
+#include <QtCore/qtconfigmacros.h>
+
+#include <algorithm>
+#include <vector>
+#if __has_include(<memory_resource>)
+#  include <memory_resource>
+#endif
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+namespace q20 {
+// like std::erase/std::erase_if for std::vector
+#if defined(__cpp_lib_erase_if) && __cpp_lib_erase_if >= 202002L // the one returning size_type
+using std::erase;
+using std::erase_if;
+#else
+
+// Make it more specialized than the compiler's, so that our implementation is preferred over
+// the compiler's (which may be present, but return void instead of the number of erased elements).
+
+template <typename T, typename U>
+constexpr typename std::vector<T, std::allocator<T>>::size_type
+erase(std::vector<T, std::allocator<T>> &c, const U &value)
+{
+    const auto origSize = c.size();
+    auto it = std::remove(c.begin(), c.end(), value);
+    c.erase(it, c.end());
+    return origSize - c.size();
+}
+
+template <typename T, typename Pred>
+constexpr typename std::vector<T, std::allocator<T>>::size_type
+erase_if(std::vector<T, std::allocator<T>> &c, Pred pred)
+{
+    const auto origSize = c.size();
+    auto it = std::remove_if(c.begin(), c.end(), pred);
+    c.erase(it, c.end());
+    return origSize - c.size();
+}
+
+#ifdef __cpp_lib_polymorphic_allocator
+template <typename T, typename U>
+constexpr typename std::vector<T, std::pmr::polymorphic_allocator<T>>::size_type
+erase(std::vector<T, std::pmr::polymorphic_allocator<T>> &c, const U &value)
+{
+    const auto origSize = c.size();
+    auto it = std::remove(c.begin(), c.end(), value);
+    c.erase(it, c.end());
+    return origSize - c.size();
+}
+
+template <typename T, typename Pred>
+constexpr typename std::vector<T, std::pmr::polymorphic_allocator<T>>::size_type
+erase_if(std::vector<T, std::pmr::polymorphic_allocator<T>> &c, Pred pred)
+{
+    const auto origSize = c.size();
+    auto it = std::remove_if(c.begin(), c.end(), pred);
+    c.erase(it, c.end());
+    return origSize - c.size();
+}
+#endif // __cpp_lib_polymorphic_allocator
+
+#endif // __cpp_lib_erase_if
+} // namespace q20
+
+QT_END_NAMESPACE
+
+#endif /* Q20VECTOR_H */

qt/6.8.1/msvc2022_64/include/QtCore/q23functional.h

@@ -0,0 +1,49 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+#ifndef Q23FUNCTIONAL_H
+#define Q23FUNCTIONAL_H
+
+#include <QtCore/qglobal.h>
+#include <QtCore/q20functional.h>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+namespace q23 {
+// like std::invoke_r
+#ifdef __cpp_lib_invoke_r
+using std::invoke_r;
+#else
+template <typename R, typename F, typename...Args>
+constexpr
+std::enable_if_t<std::is_invocable_r_v<R, F, Args...>, R>
+invoke_r(F&& f, Args&&... args)
+    noexcept(std::is_nothrow_invocable_r_v<R, F, Args...>)
+{
+    // ### use q20::invoke for a constexpr std::invoke
+    if constexpr (std::is_void_v<R>)
+        std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
+    else
+        return std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
+}
+#endif // __cpp_lib_invoke_r
+} // namespace q23
+
+QT_END_NAMESPACE
+
+#endif /* Q23FUNCTIONAL_H */

qt/6.8.1/msvc2022_64/include/QtCore/q23utility.h

@@ -0,0 +1,75 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+#ifndef Q23UTILITY_H
+#define Q23UTILITY_H
+
+#include <QtCore/qtconfigmacros.h>
+
+#include <utility>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+namespace q23 {
+// like std::forward_like
+#ifdef __cpp_lib_forward_like
+using std::forward_like;
+#else
+
+namespace _detail {
+
+// [forward]/6.1 COPY_CONST
+template <typename A, typename B>
+using copy_const_t = std::conditional_t<
+        std::is_const_v<A>, const B,
+        /* else */          B
+    >;
+
+// [forward]/6.2 OVERRIDE_REF
+template <typename A, typename B>
+using override_ref_t = std::conditional_t<
+        std::is_rvalue_reference_v<A>, std::remove_reference_t<B>&&,
+        /* else */                     B&
+    >;
+
+// [forward]/6.3 "V"
+template <typename T, typename U>
+using forward_like_ret_t = override_ref_t<
+        T&&,
+        copy_const_t<
+            std::remove_reference_t<T>,
+            std::remove_reference_t<U>
+        >
+    >;
+
+} // namespace detail
+
+// http://eel.is/c++draft/forward#lib:forward_like
+template <class T, class U>
+[[nodiscard]] constexpr auto forward_like(U &&x) noexcept
+    -> _detail::forward_like_ret_t<T, U>
+{
+    using V = _detail::forward_like_ret_t<T, U>;
+    return static_cast<V>(x);
+}
+#endif // __cpp_lib_forward_like
+} // namespace q23
+
+QT_END_NAMESPACE
+
+#endif /* Q23UTILITY_H */

qt/6.8.1/msvc2022_64/include/QtCore/q26numeric.h

@@ -0,0 +1,69 @@
+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+#ifndef Q26NUMERIC_H
+#define Q26NUMERIC_H
+
+#include <QtCore/qglobal.h>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. Types and functions defined in this
+// file can reliably be replaced by their std counterparts, once available.
+// You may use these definitions in your own code, but be aware that we
+// will remove them once Qt depends on the C++ version that supports
+// them in namespace std. There will be NO deprecation warning, the
+// definitions will JUST go away.
+//
+// If you can't agree to these terms, don't use these definitions!
+//
+// We mean it.
+//
+
+#include <numeric>
+#include <limits>
+#include <type_traits>
+
+QT_BEGIN_NAMESPACE
+
+namespace q26 {
+
+// Like std::saturate_cast
+#ifdef __cpp_lib_saturation_arithmetic
+using std::saturate_cast;
+#else
+template <typename To, typename From>
+constexpr auto saturate_cast(From x)
+{
+    static_assert(std::is_integral_v<To>);
+    static_assert(std::is_integral_v<From>);
+
+    [[maybe_unused]]
+    constexpr auto Lo = (std::numeric_limits<To>::min)();
+    constexpr auto Hi = (std::numeric_limits<To>::max)();
+
+    if constexpr (std::is_signed_v<From> == std::is_signed_v<To>) {
+        // same signedness, we can accept regular integer conversion rules
+        return x < Lo  ? Lo :
+               x > Hi  ? Hi :
+               /*else*/  To(x);
+    } else {
+        if constexpr (std::is_signed_v<From>) { // ie. !is_signed_v<To>
+            if (x < From{0})
+                return To{0};
+        }
+
+        // from here on, x >= 0
+        using FromU = std::make_unsigned_t<From>;
+        using ToU = std::make_unsigned_t<To>;
+        return FromU(x) > ToU(Hi) ? Hi : To(x); // assumes Hi >= 0
+    }
+}
+#endif // __cpp_lib_saturation_arithmetic
+
+} // namespace q26
+
+QT_END_NAMESPACE
+
+#endif /* Q26NUMERIC_H */