qtconcurrentstoredfunctioncall.h

Go to the documentation of this file.

// 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
// Qt-Security score:significant reason:default
 
#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