futures.h

Go to the documentation of this file.

/**********************************************************************
 * LeechCraft - modular cross-platform feature rich internet client.
 * Copyright (C) 2006-2014  Georg Rudoy
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 **********************************************************************/
 
#pragma once
 
#include <type_traits>
#include <functional>
#include <memory>
#include <optional>
#include <QFutureInterface>
#include <QFutureWatcher>
#include <util/sll/slotclosure.h>
#include <util/sll/detector.h>
#include "threadsconfig.h"
#include "concurrentexception.h"
 
namespace LC::Util
{
    template<typename R, typename F, typename... Args>
    void ReportFutureResult (QFutureInterface<R>& iface, F&& f, Args&&... args)
    {
        try
        {
            constexpr bool isVoid = std::is_same_v<R, void>;
            if constexpr (!isVoid && !std::is_invocable_v<std::decay_t<F>, Args...>)
            {
                static_assert (std::is_constructible_v<R, F>);
                static_assert (sizeof... (Args) == 0,
                        "Extra args when a value is passed. Perhaps you wanted to pass in a function?");
 
                const R result { std::forward<F> (f) };
                iface.reportResult (result);
            }
            else if constexpr (!isVoid)
            {
                const auto result = std::invoke (std::forward<F> (f), std::forward<Args> (args)...);
                iface.reportResult (result);
            }
            else
                std::invoke (std::forward<F> (f), std::forward<Args> (args)...);
        }
        catch (const QtException_t& e)
        {
            iface.reportException (e);
        }
        catch (const std::exception& e)
        {
            iface.reportException (ConcurrentStdException { e });
        }
 
        iface.reportFinished ();
    }
 
    namespace detail
    {
        template<typename T>
        struct UnwrapFutureTypeBase {};
 
        template<typename T>
        struct UnwrapFutureTypeBase<QFuture<T>>
        {
            using type = T;
        };
 
        template<typename T>
        struct UnwrapFutureType : UnwrapFutureTypeBase<std::decay_t<T>>
        {
        };
    }
 
    template<typename T>
    using UnwrapFutureType_t = typename detail::UnwrapFutureType<T>::type;
 
    namespace detail
    {
        template<typename Future>
        class Sequencer final : public QObject
        {
        public:
            using RetType_t = UnwrapFutureType_t<Future>;
        private:
            Future Future_;
            QFutureWatcher<RetType_t> BaseWatcher_;
            QFutureWatcherBase *LastWatcher_ = &BaseWatcher_;
        public:
            Sequencer (const Future& future, QObject *parent)
            : QObject { parent }
            , Future_ { future }
            , BaseWatcher_ { this }
            {
            }
 
            void Start ()
            {
                connect (LastWatcher_,
                        &QFutureWatcherBase::finished,
                        this,
                        &QObject::deleteLater);
                BaseWatcher_.setFuture (Future_);
            }
 
            template<typename RetT, typename ArgT>
            void Then (const std::function<QFuture<RetT> (ArgT)>& action)
            {
                const auto last = dynamic_cast<QFutureWatcher<ArgT>*> (LastWatcher_);
                if (!last)
                {
                    deleteLater ();
                    throw std::runtime_error { std::string { "invalid type in " } + Q_FUNC_INFO };
                }
 
                const auto watcher = new QFutureWatcher<RetT> { this };
                LastWatcher_ = watcher;
 
                new SlotClosure<DeleteLaterPolicy>
                {
                    [this, last, watcher, action]
                    {
                        if (static_cast<QObject*> (last) != &BaseWatcher_)
                            last->deleteLater ();
                        watcher->setFuture (action (last->result ()));
                    },
                    last,
                    SIGNAL (finished ()),
                    last
                };
            }
 
            template<typename ArgT>
            void Then (const std::function<void (ArgT)>& action)
            {
                const auto last = dynamic_cast<QFutureWatcher<ArgT>*> (LastWatcher_);
                if (!last)
                {
                    deleteLater ();
                    throw std::runtime_error { std::string { "invalid type in " } + Q_FUNC_INFO };
                }
 
                new SlotClosure<DeleteLaterPolicy>
                {
                    [last, action]
                    {
                        action (last->result ());
                    },
                    LastWatcher_,
                    SIGNAL (finished ()),
                    LastWatcher_
                };
            }
 
            void Then (const std::function<void ()>& action)
            {
                const auto last = dynamic_cast<QFutureWatcher<void>*> (LastWatcher_);
                if (!last)
                {
                    deleteLater ();
                    throw std::runtime_error { std::string { "invalid type in " } + Q_FUNC_INFO };
                }
 
                new SlotClosure<DeleteLaterPolicy>
                {
                    action,
                    LastWatcher_,
                    SIGNAL (finished ()),
                    LastWatcher_
                };
            }
 
            template<typename Handler>
            void MultipleResults (const Handler& handler,
                    const std::function<void ()>& finishHandler = {},
                    const std::function<void ()>& startHandler = {})
            {
                if (LastWatcher_ != &BaseWatcher_)
                {
                    qWarning () << Q_FUNC_INFO
                            << "multiple results handler should be chained directly to the source";
                    throw std::runtime_error { "invalid multiple results handler chaining" };
                }
 
                connect (&BaseWatcher_,
                        &QFutureWatcherBase::resultReadyAt,
                        &BaseWatcher_,
                        [handler, this] (int index) { handler (BaseWatcher_.resultAt (index)); });
 
                if (finishHandler)
                    new Util::SlotClosure<Util::DeleteLaterPolicy>
                    {
                        finishHandler,
                        &BaseWatcher_,
                        SIGNAL (finished ()),
                        &BaseWatcher_
                    };
 
                if (startHandler)
                    new Util::SlotClosure<Util::DeleteLaterPolicy>
                    {
                        startHandler,
                        &BaseWatcher_,
                        SIGNAL (started ()),
                        &BaseWatcher_
                    };
 
                connect (&BaseWatcher_,
                        SIGNAL (finished ()),
                        this,
                        SLOT (deleteLater ()));
            }
        };
 
        template<typename T>
        using SequencerRetType_t = typename Sequencer<T>::RetType_t;
 
        struct EmptyDestructionTag;
 
        template<typename Ret, typename Future, typename DestructionTag>
        class SequenceProxy
        {
            template<typename, typename, typename>
            friend class SequenceProxy;
 
            std::shared_ptr<void> ExecuteGuard_;
            Sequencer<Future> * const Seq_;
 
            std::optional<QFuture<Ret>> ThisFuture_;
 
            std::function<DestructionTag ()> DestrHandler_;
 
            SequenceProxy (const std::shared_ptr<void>& guard, Sequencer<Future> *seq,
                    const std::function<DestructionTag ()>& destrHandler)
            : ExecuteGuard_ { guard }
            , Seq_ { seq }
            , DestrHandler_ { destrHandler }
            {
            }
 
            template<typename F1, typename Ret1>
            using ReturnsFutureDetector_t = UnwrapFutureType_t<std::result_of_t<F1 (Ret1)>>;
 
            template<typename F, typename... Args>
            using ReturnsVoidDetector_t = std::result_of_t<F (Args...)>;
        public:
            using Ret_t = Ret;
 
            SequenceProxy (Sequencer<Future> *sequencer)
            : ExecuteGuard_ { nullptr, [sequencer] (void*) { sequencer->Start (); } }
            , Seq_ { sequencer }
            {
            }
 
            SequenceProxy (const SequenceProxy& proxy) = delete;
 
            SequenceProxy (SequenceProxy&& proxy) = default;
 
            template<typename F>
            auto Then (F&& f)
            {
                if (ThisFuture_)
                    throw std::runtime_error { "SequenceProxy::Then(): cannot chain more after being converted to a QFuture" };
 
                if constexpr (IsDetected_v<ReturnsFutureDetector_t, F, Ret>)
                {
                    using Next_t = UnwrapFutureType_t<decltype (f (std::declval<Ret> ()))>;
                    Seq_->template Then<Next_t, Ret> (f);
                    return SequenceProxy<Next_t, Future, DestructionTag> { ExecuteGuard_, Seq_, DestrHandler_ };
                }
                else if constexpr (std::is_same<IsDetected_t<struct Dummy, ReturnsVoidDetector_t, F, Ret>, void> {})
                    Seq_->template Then<Ret> (f);
                else if constexpr (std::is_same<void, Ret>::value &&
                        std::is_same<IsDetected_t<struct Dummy, ReturnsVoidDetector_t, F>, void> {})
                    Seq_->Then (std::function<void ()> { f });
                else
                    static_assert (std::is_same<F, struct Dummy> {}, "Invalid functor passed to SequenceProxy::Then()");
            }
 
            template<typename F>
            auto operator>> (F&& f) -> decltype (this->Then (std::forward<F> (f)))
            {
                return Then (std::forward<F> (f));
            }
 
            template<typename F>
            SequenceProxy<Ret, Future, std::result_of_t<F ()>> DestructionValue (F&& f)
            {
                static_assert (std::is_same<DestructionTag, EmptyDestructionTag>::value,
                        "Destruction handling function has been already set.");
 
                return { ExecuteGuard_, Seq_, std::forward<F> (f) };
            }
 
            template<typename F>
            void MultipleResults (F&& f)
            {
                Seq_->MultipleResults (std::forward<F> (f));
            }
 
            template<typename F, typename Finish>
            void MultipleResults (F&& f, Finish&& finish)
            {
                Seq_->MultipleResults (std::forward<F> (f),
                        std::forward<Finish> (finish));
            }
 
            template<typename F, typename Finish, typename Start>
            void MultipleResults (F&& f, Finish&& finish, Start&& start)
            {
                Seq_->MultipleResults (std::forward<F> (f),
                        std::forward<Finish> (finish),
                        std::forward<Start> (start));
            }
 
            operator QFuture<Ret> ()
            {
                constexpr bool isEmptyDestr = std::is_same<DestructionTag, EmptyDestructionTag>::value;
                static_assert (std::is_same<DestructionTag, Ret>::value || isEmptyDestr,
                        "Destruction handler's return type doesn't match expected future type.");
 
                if (ThisFuture_)
                    return *ThisFuture_;
 
                QFutureInterface<Ret> iface;
                iface.reportStarted ();
 
                SlotClosure<DeleteLaterPolicy> *deleteGuard = nullptr;
                if constexpr (!isEmptyDestr)
                {
                    deleteGuard = new SlotClosure<DeleteLaterPolicy>
                    {
                        [destrHandler = DestrHandler_, iface] () mutable
                        {
                            if (iface.isFinished ())
                                return;
 
                            const auto res = destrHandler ();
                            iface.reportFinished (&res);
                        },
                        Seq_->parent (),
                        SIGNAL (destroyed ()),
                        Seq_
                    };
                }
 
                Then ([deleteGuard, iface] (const Ret& ret) mutable
                        {
                            iface.reportFinished (&ret);
 
                            delete deleteGuard;
                        });
 
                const auto& future = iface.future ();
                ThisFuture_ = future;
                return future;
            }
        };
    }
 
    template<typename T>
    detail::SequenceProxy<
            detail::SequencerRetType_t<QFuture<T>>,
            QFuture<T>,
            detail::EmptyDestructionTag
        >
        Sequence (QObject *parent, const QFuture<T>& future)
    {
        return { new detail::Sequencer<QFuture<T>> { future, parent } };
    }
 
    template<typename T>
    QFuture<T> MakeReadyFuture (const T& t)
    {
        QFutureInterface<T> iface;
        iface.reportStarted ();
        iface.reportFinished (&t);
        return iface.future ();
    }
}