diff options
Diffstat (limited to 'src/concurrent/qtconcurrentfunctionwrappers.h')
| -rw-r--r-- | src/concurrent/qtconcurrentfunctionwrappers.h | 375 |
1 files changed, 87 insertions, 288 deletions
diff --git a/src/concurrent/qtconcurrentfunctionwrappers.h b/src/concurrent/qtconcurrentfunctionwrappers.h index 734bb29df1..78900c239b 100644 --- a/src/concurrent/qtconcurrentfunctionwrappers.h +++ b/src/concurrent/qtconcurrentfunctionwrappers.h @@ -1,243 +1,71 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtConcurrent module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// 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 <QtCore/QStringList> +#include <QtConcurrent/qtconcurrentreducekernel.h> +#include <QtCore/qfuture.h> -#if !defined(QT_NO_CONCURRENT) || defined(Q_CLANG_QDOC) +#include <tuple> + +#if !defined(QT_NO_CONCURRENT) || defined(Q_QDOC) QT_BEGIN_NAMESPACE -namespace QtConcurrent { +namespace QtPrivate { -template <typename T> -class FunctionWrapper0 +struct PushBackWrapper { -public: - typedef T (*FunctionPointerType)(); - typedef T result_type; - inline FunctionWrapper0(FunctionPointerType _functionPointer) - :functionPointer(_functionPointer) { } - - inline T operator()() + template <class C, class U> + inline void operator()(C &c, const U &u) const { - return functionPointer(); + return c.push_back(u); } -private: - FunctionPointerType functionPointer; -}; - -template <typename T, typename U> -class FunctionWrapper1 -{ -public: - typedef T (*FunctionPointerType)(U u); - typedef T result_type; - inline FunctionWrapper1(FunctionPointerType _functionPointer) - :functionPointer(_functionPointer) { } - inline T operator()(U u) + template <class C, class U> + inline void operator()(C &c, U &&u) const { - return functionPointer(u); + return c.push_back(u); } - -private: - FunctionPointerType functionPointer; }; -template <typename T, typename U, typename V> -class FunctionWrapper2 -{ -public: - typedef T (*FunctionPointerType)(U u, V v); - typedef T result_type; - inline FunctionWrapper2(FunctionPointerType _functionPointer) - :functionPointer(_functionPointer) { } +// -- MapResultType - inline T operator()(U u, V v) - { - return functionPointer(u, v); - } -private: - FunctionPointerType functionPointer; -}; - -template <typename T, typename C> -class MemberFunctionWrapper +template <class T, class Enable = void> +struct Argument { -public: - typedef T (C::*FunctionPointerType)(); - typedef T result_type; - inline MemberFunctionWrapper(FunctionPointerType _functionPointer) - :functionPointer(_functionPointer) { } - - inline T operator()(C &c) - { - return (c.*functionPointer)(); - } -private: - FunctionPointerType functionPointer; + using Type = void; }; -template <typename T, typename C, typename U> -class MemberFunctionWrapper1 +template <class Sequence> +struct Argument<Sequence, typename std::enable_if<IsIterableValue<Sequence>>::type> { -public: - typedef T (C::*FunctionPointerType)(U); - typedef T result_type; - - inline MemberFunctionWrapper1(FunctionPointerType _functionPointer) - : functionPointer(_functionPointer) - { } - - inline T operator()(C &c, U u) - { - return (c.*functionPointer)(u); - } - -private: - FunctionPointerType functionPointer; + using Type = std::decay_t<decltype(*std::declval<Sequence>().begin())>; }; -template <typename T, typename C> -class ConstMemberFunctionWrapper +template <class Iterator> +struct Argument<Iterator, typename std::enable_if<IsDereferenceableValue<Iterator>>::type> { -public: - typedef T (C::*FunctionPointerType)() const; - typedef T result_type; - inline ConstMemberFunctionWrapper(FunctionPointerType _functionPointer) - :functionPointer(_functionPointer) { } - - inline T operator()(const C &c) const - { - return (c.*functionPointer)(); - } -private: - FunctionPointerType functionPointer; + using Type = std::decay_t<decltype(*std::declval<Iterator>())>; }; -} // namespace QtConcurrent. - -namespace QtPrivate { - -template <typename T> -const T& createFunctionWrapper(const T& t) -{ - return t; -} - -template <typename T, typename U> -QtConcurrent::FunctionWrapper1<T, U> createFunctionWrapper(T (*func)(U)) -{ - return QtConcurrent::FunctionWrapper1<T, U>(func); -} - -template <typename T, typename C> -QtConcurrent::MemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)()) -{ - return QtConcurrent::MemberFunctionWrapper<T, C>(func); -} - -template <typename T, typename C, typename U> -QtConcurrent::MemberFunctionWrapper1<T, C, U> createFunctionWrapper(T (C::*func)(U)) -{ - return QtConcurrent::MemberFunctionWrapper1<T, C, U>(func); -} - -template <typename T, typename C> -QtConcurrent::ConstMemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)() const) -{ - return QtConcurrent::ConstMemberFunctionWrapper<T, C>(func); -} - -#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 -template <typename T, typename U> -QtConcurrent::FunctionWrapper1<T, U> createFunctionWrapper(T (*func)(U) noexcept) -{ - return QtConcurrent::FunctionWrapper1<T, U>(func); -} - -template <typename T, typename C> -QtConcurrent::MemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)() noexcept) -{ - return QtConcurrent::MemberFunctionWrapper<T, C>(func); -} - -template <typename T, typename C, typename U> -QtConcurrent::MemberFunctionWrapper1<T, C, U> createFunctionWrapper(T (C::*func)(U) noexcept) -{ - return QtConcurrent::MemberFunctionWrapper1<T, C, U>(func); -} - -template <typename T, typename C> -QtConcurrent::ConstMemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)() const noexcept) -{ - return QtConcurrent::ConstMemberFunctionWrapper<T, C>(func); -} -#endif +template <class T> +using ArgumentType = typename Argument<T>::Type; -struct PushBackWrapper +template <class T, class MapFunctor> +struct MapResult { - typedef void result_type; - - template <class C, class U> - inline void operator()(C &c, const U &u) const - { - return c.push_back(u); - } - -#ifdef Q_COMPILER_RVALUE_REFS - template <class C, class U> - inline void operator()(C &c, U &&u) const - { - return c.push_back(u); - } -#endif + 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 <typename Functor, bool foo = HasResultType<Functor>::Value> -struct LazyResultType { typedef typename Functor::result_type Type; }; -template <typename Functor> -struct LazyResultType<Functor, false> { typedef void Type; }; +template <class T, class MapFunctor> +using MapResultType = typename MapResult<T, MapFunctor>::Type; + +// -- ReduceResultType template <class T> struct ReduceResultType; @@ -245,130 +73,101 @@ struct ReduceResultType; template <class U, class V> struct ReduceResultType<void(*)(U&,V)> { - typedef U ResultType; + using ResultType = U; }; template <class T, class C, class U> struct ReduceResultType<T(C::*)(U)> { - typedef C ResultType; + using ResultType = C; }; -#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 template <class U, class V> -struct ReduceResultType<void(*)(U&,V) noexcept> +struct ReduceResultType<std::function<void(U&, V)>> { - typedef U ResultType; + using ResultType = U; }; -template <class T, class C, class U> -struct ReduceResultType<T(C::*)(U) noexcept> +template <typename R, typename ...A> +struct ReduceResultType<R(*)(A...)> { - typedef C ResultType; -}; -#endif - -template <class InputSequence, class MapFunctor> -struct MapResultType -{ - typedef typename LazyResultType<MapFunctor>::Type ResultType; + using ResultType = typename std::tuple_element<0, std::tuple<A...>>::type; }; template <class U, class V> -struct MapResultType<void, U (*)(V)> -{ - typedef U ResultType; -}; - -template <class T, class C> -struct MapResultType<void, T(C::*)() const> +struct ReduceResultType<void(*)(U&,V) noexcept> { - typedef T ResultType; + using ResultType = U; }; -#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 -template <class U, class V> -struct MapResultType<void, U (*)(V) noexcept> +template <class T, class C, class U> +struct ReduceResultType<T(C::*)(U) noexcept> { - typedef U ResultType; + using ResultType = C; }; -template <class T, class C> -struct MapResultType<void, T(C::*)() const noexcept> -{ - typedef T ResultType; -}; -#endif +template<class T, class Enable = void> +inline constexpr bool hasCallOperator_v = false; -#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS +template<class T> +inline constexpr bool hasCallOperator_v<T, std::void_t<decltype(&T::operator())>> = true; -template <template <typename> class InputSequence, typename MapFunctor, typename T> -struct MapResultType<InputSequence<T>, MapFunctor> -{ - typedef InputSequence<typename LazyResultType<MapFunctor>::Type> ResultType; -}; +template<class T, class Enable = void> +inline constexpr bool isIterator_v = false; -template <template <typename> class InputSequence, class T, class U, class V> -struct MapResultType<InputSequence<T>, U (*)(V)> -{ - typedef InputSequence<U> ResultType; -}; +template<class T> +inline constexpr bool isIterator_v<T, std::void_t<typename std::iterator_traits<T>::value_type>> = + true; -template <template <typename> class InputSequence, class T, class U, class C> -struct MapResultType<InputSequence<T>, U(C::*)() const> -{ - typedef InputSequence<U> ResultType; -}; +template <class Callable, class Sequence> +using isInvocable = std::is_invocable<Callable, typename std::decay_t<Sequence>::value_type>; -#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 +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 <template <typename> class InputSequence, class T, class U, class V> -struct MapResultType<InputSequence<T>, U (*)(V) noexcept> +template<class Callable, class Enable = void> +struct ReduceResultTypeHelper { - typedef InputSequence<U> ResultType; }; -template <template <typename> class InputSequence, class T, class U, class C> -struct MapResultType<InputSequence<T>, U(C::*)() const noexcept> +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>>>> { - typedef InputSequence<U> ResultType; + using type = typename QtPrivate::ReduceResultType<std::decay_t<Callable>>::ResultType; }; -#endif - -#endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER -template <class MapFunctor> -struct MapResultType<QStringList, MapFunctor> +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>>>> { - typedef QList<typename LazyResultType<MapFunctor>::Type> ResultType; + using type = std::decay_t<typename QtPrivate::ArgResolver<Callable>::First>; }; -template <class U, class V> -struct MapResultType<QStringList, U (*)(V)> -{ - typedef QList<U> ResultType; -}; +// -- MapSequenceResultType -template <class U, class C> -struct MapResultType<QStringList, U(C::*)() const> +template <class InputSequence, class MapFunctor> +struct MapSequenceResultType { - typedef QList<U> ResultType; + 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; }; -#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510 +#ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS -template <class U, class V> -struct MapResultType<QStringList, U (*)(V) noexcept> +template <template <typename...> class InputSequence, typename MapFunctor, typename ...T> +struct MapSequenceResultType<InputSequence<T...>, MapFunctor> { - typedef QList<U> ResultType; + typedef InputSequence<QtPrivate::MapResultType<InputSequence<T...>, MapFunctor>> ResultType; }; -template <class U, class C> -struct MapResultType<QStringList, U(C::*)() const noexcept> -{ - typedef QList<U> ResultType; -}; -#endif +#endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER } // namespace QtPrivate. |