include/QtConcurrent/qtconcurrentfunctionwrappers.h

0001 // Copyright (C) 2016 The Qt Company Ltd.
0002 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
0003
0004 #ifndef QTCONCURRENT_FUNCTIONWRAPPERS_H
0005 #define QTCONCURRENT_FUNCTIONWRAPPERS_H
0006
0007 #include <QtConcurrent/qtconcurrentcompilertest.h>
0008 #include <QtConcurrent/qtconcurrentreducekernel.h>
0009 #include <QtCore/qfuture.h>
0010
0011 #include <tuple>
0012
0013 #if !defined(QT_NO_CONCURRENT) || defined(Q_QDOC)
0014
0015 QT_BEGIN_NAMESPACE
0016
0017 namespace QtPrivate {
0018
0019 struct PushBackWrapper
0020 {
0021     template <class C, class U>
0022     inline void operator()(C &c, const U &u) const
0023     {
0024         return c.push_back(u);
0025     }
0026
0027     template <class C, class U>
0028     inline void operator()(C &c, U &&u) const
0029     {
0030         return c.push_back(u);
0031     }
0032 };
0033
0034 // -- MapResultType
0035
0036 template <class T, class Enable = void>
0037 struct Argument
0038 {
0039     using Type = void;
0040 };
0041
0042 template <class Sequence>
0043 struct Argument<Sequence, typename std::enable_if<IsIterableValue<Sequence>>::type>
0044 {
0045     using Type = std::decay_t<decltype(*std::declval<Sequence>().begin())>;
0046 };
0047
0048 template <class Iterator>
0049 struct Argument<Iterator, typename std::enable_if<IsDereferenceableValue<Iterator>>::type>
0050 {
0051     using Type = std::decay_t<decltype(*std::declval<Iterator>())>;
0052 };
0053
0054 template <class T>
0055 using ArgumentType = typename Argument<T>::Type;
0056
0057 template <class T, class MapFunctor>
0058 struct MapResult
0059 {
0060     static_assert(std::is_invocable_v<std::decay_t<MapFunctor>, ArgumentType<T>>,
0061                   "It's not possible to invoke the function with passed argument.");
0062     using Type = std::invoke_result_t<std::decay_t<MapFunctor>, ArgumentType<T>>;
0063 };
0064
0065 template <class T, class MapFunctor>
0066 using MapResultType = typename MapResult<T, MapFunctor>::Type;
0067
0068 // -- ReduceResultType
0069
0070 template <class T>
0071 struct ReduceResultType;
0072
0073 template <class U, class V>
0074 struct ReduceResultType<void(*)(U&,V)>
0075 {
0076     using ResultType = U;
0077 };
0078
0079 template <class T, class C, class U>
0080 struct ReduceResultType<T(C::*)(U)>
0081 {
0082     using ResultType = C;
0083 };
0084
0085 template <class U, class V>
0086 struct ReduceResultType<std::function<void(U&, V)>>
0087 {
0088     using ResultType = U;
0089 };
0090
0091 template <typename R, typename ...A>
0092 struct ReduceResultType<R(*)(A...)>
0093 {
0094     using ResultType = typename std::tuple_element<0, std::tuple<A...>>::type;
0095 };
0096
0097 template <class U, class V>
0098 struct ReduceResultType<void(*)(U&,V) noexcept>
0099 {
0100     using ResultType = U;
0101 };
0102
0103 template <class T, class C, class U>
0104 struct ReduceResultType<T(C::*)(U) noexcept>
0105 {
0106     using ResultType = C;
0107 };
0108
0109 template<class T, class Enable = void>
0110 inline constexpr bool hasCallOperator_v = false;
0111
0112 template<class T>
0113 inline constexpr bool hasCallOperator_v<T, std::void_t<decltype(&T::operator())>> = true;
0114
0115 template<class T, class Enable = void>
0116 inline constexpr bool isIterator_v = false;
0117
0118 template<class T>
0119 inline constexpr bool isIterator_v<T, std::void_t<typename std::iterator_traits<T>::value_type>> =
0120         true;
0121
0122 template <class Callable, class Sequence>
0123 using isInvocable = std::is_invocable<Callable, typename std::decay_t<Sequence>::value_type>;
0124
0125 template <class InitialValueType, class ResultType>
0126 inline constexpr bool isInitialValueCompatible_v = std::conjunction_v<
0127         std::is_convertible<InitialValueType, ResultType>,
0128         std::negation<std::is_same<std::decay_t<InitialValueType>, QtConcurrent::ReduceOption>>>;
0129
0130 template<class Callable, class Enable = void>
0131 struct ReduceResultTypeHelper
0132 {
0133 };
0134
0135 template <class Callable>
0136 struct ReduceResultTypeHelper<Callable,
0137         typename std::enable_if_t<std::is_function_v<std::remove_pointer_t<std::decay_t<Callable>>>
0138                                   || std::is_member_function_pointer_v<std::decay_t<Callable>>>>
0139 {
0140     using type = typename QtPrivate::ReduceResultType<std::decay_t<Callable>>::ResultType;
0141 };
0142
0143 template <class Callable>
0144 struct ReduceResultTypeHelper<Callable,
0145         typename std::enable_if_t<!std::is_function_v<std::remove_pointer_t<std::decay_t<Callable>>>
0146                                   && hasCallOperator_v<std::decay_t<Callable>>>>
0147 {
0148     using type = std::decay_t<typename QtPrivate::ArgResolver<Callable>::First>;
0149 };
0150
0151 // -- MapSequenceResultType
0152
0153 template <class InputSequence, class MapFunctor>
0154 struct MapSequenceResultType
0155 {
0156     static_assert(std::is_same_v<typename InputSequence::value_type,
0157                                  QtPrivate::MapResultType<InputSequence, MapFunctor>>,
0158                   "Couldn't deduce the output sequence type, you must specify it explicitly.");
0159     typedef InputSequence ResultType;
0160 };
0161
0162 #ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
0163
0164 template <template <typename...> class InputSequence, typename MapFunctor, typename ...T>
0165 struct MapSequenceResultType<InputSequence<T...>, MapFunctor>
0166 {
0167     typedef InputSequence<QtPrivate::MapResultType<InputSequence<T...>, MapFunctor>> ResultType;
0168 };
0169
0170 #endif // QT_NO_TEMPLATE_TEMPLATE_PARAMETER
0171
0172 } // namespace QtPrivate.
0173
0174
0175 QT_END_NAMESPACE
0176
0177 #endif // QT_NO_CONCURRENT
0178
0179 #endif