futures.h

Go to the documentation of this file.

/**********************************************************************
 * LeechCraft - modular cross-platform feature rich internet client.
 * Copyright (C) 2006-2014  Georg Rudoy
 *
 * Boost Software License - Version 1.0 - August 17th, 2003
 *
 * Permission is hereby granted, free of charge, to any person or organization
 * obtaining a copy of the software and accompanying documentation covered by
 * this license (the "Software") to use, reproduce, display, distribute,
 * execute, and transmit the Software, and to prepare derivative works of the
 * Software, and to permit third-parties to whom the Software is furnished to
 * do so, all subject to the following:
 *
 * The copyright notices in the Software and this entire statement, including
 * the above license grant, this restriction and the following disclaimer,
 * must be included in all copies of the Software, in whole or in part, and
 * all derivative works of the Software, unless such copies or derivative
 * works are solely in the form of machine-executable object code generated by
 * a source language processor.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
 * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 **********************************************************************/

#pragma once

#include <type_traits>
#include <functional>
#include <memory>
#include <boost/optional.hpp>
#include <QFutureInterface>
#include <QFutureWatcher>
#include <util/sll/oldcppkludges.h>
#include <util/sll/slotclosure.h>
#include "threadsconfig.h"
#include "concurrentexception.h"

namespace LeechCraft
{
namespace Util
{
    template<typename R, typename F, typename... Args>
    std::enable_if_t<!std::is_same<R, void>::value>
        ReportFutureResult (QFutureInterface<R>& iface, F&& f, Args&&... args)
    {
        try
        {
            const auto result = Invoke (std::forward<F> (f), std::forward<Args> (args)...);
            iface.reportFinished (&result);
        }
        catch (const QtException_t& e)
        {
            iface.reportException (e);
            iface.reportFinished ();
        }
        catch (const std::exception& e)
        {
            iface.reportException (ConcurrentStdException { e });
            iface.reportFinished ();
        }
    }

    template<typename F, typename... Args>
    void ReportFutureResult (QFutureInterface<void>& iface, F&& f, Args&&... args)
    {
        try
        {
            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>
        constexpr bool IsCallableImpl (int, std::result_of_t<T ()>* = nullptr)
        {
            return true;
        }

        template<typename T>
        constexpr bool IsCallableImpl (float)
        {
            return false;
        }

        template<typename T>
        constexpr bool IsCallable ()
        {
            return IsCallableImpl<T> (0);
        }
    }

    template<typename R, typename U>
    std::enable_if_t<std::is_constructible<R, U>::value && !detail::IsCallable<U> ()>
        ReportFutureResult (QFutureInterface<R>& iface, U&& value)
    {
        const R result { std::forward<U> (value) };
        iface.reportFinished (&result);
    }

    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 T>
        struct IsFuture
        {
            constexpr static bool Result_ = false;
        };

        template<typename T>
        struct IsFuture<QFuture<T>>
        {
            constexpr static bool Result_ = true;
        };

        template<typename RetType, typename ResultHandler>
        struct HandlerInvoker
        {
            void operator() (const ResultHandler& rh, QFutureWatcher<RetType> *watcher) const
            {
                rh (watcher->result ());
            }
        };

        template<typename ResultHandler>
        struct HandlerInvoker<void, ResultHandler>
        {
            void operator() (const ResultHandler& rh, QFutureWatcher<void>*) const
            {
                rh ();
            }
        };

        template<typename ResultHandler, typename RetType, typename = std::result_of_t<ResultHandler (RetType)>>
        constexpr bool IsCompatibleImpl (int)
        {
            return true;
        }

        template<typename, typename>
        constexpr bool IsCompatibleImpl (float)
        {
            return false;
        }

        template<typename ResultHandler, typename = std::result_of_t<ResultHandler ()>>
        constexpr bool IsCompatibleImplVoid (int)
        {
            return true;
        }

        template<typename>
        constexpr bool IsCompatibleImplVoid (float)
        {
            return false;
        }

        template<typename ResultHandler, typename RetType>
        constexpr bool IsCompatible ()
        {
            return std::is_same<void, RetType>::value ?
                    IsCompatibleImplVoid<ResultHandler> (0) :
                    IsCompatibleImpl<ResultHandler, RetType> (0);
        }
    }

    template<typename Executor, typename ResultHandler, typename... Args>
    void ExecuteFuture (Executor f, ResultHandler rh, QObject *parent, Args... args)
    {
        static_assert (detail::IsFuture<decltype (f (args...))>::Result_,
                "The passed functor should return a QFuture.");

        // Don't replace result_of with decltype, this triggers a gcc bug leading to segfault:
        // http://leechcraft.org:8080/job/leechcraft/=debian_unstable/1998/console
        using RetType_t = UnwrapFutureType_t<typename std::result_of<Executor (Args...)>::type>;

        static_assert (detail::IsCompatible<ResultHandler, RetType_t> (),
                "Executor's watcher type and result handler argument type are not compatible.");

        const auto watcher = new QFutureWatcher<RetType_t> { parent };

        new SlotClosure<DeleteLaterPolicy>
        {
            [watcher, rh]
            {
                watcher->deleteLater ();
                detail::HandlerInvoker<RetType_t, ResultHandler> {} (rh, watcher);
            },
            watcher,
            SIGNAL (finished ()),
            watcher
        };

        watcher->setFuture (f (args...));
    }

    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 ()
            {
                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, this]
                    {
                        action (last->result ());
                        deleteLater ();
                    },
                    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, this]
                    {
                        action ();
                        deleteLater ();
                    },
                    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 T>
        using IsEmptyDestr_t = std::is_same<EmptyDestructionTag, T>;

        template<typename Ret, typename DestrType, typename = std::enable_if_t<IsEmptyDestr_t<DestrType>::value>>
        void InvokeDestructionHandler (const std::function<DestrType ()>&, QFutureInterface<Ret>&, float)
        {
        }

        template<typename Ret, typename DestrType, typename = std::enable_if_t<!IsEmptyDestr_t<DestrType>::value>>
        void InvokeDestructionHandler (const std::function<DestrType ()>& handler, QFutureInterface<Ret>& iface, int)
        {
            const auto res = handler ();
            iface.reportFinished (&res);
        }

        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_;

            boost::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 }
            {
            }
        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) -> SequenceProxy<UnwrapFutureType_t<decltype (f (std::declval<Ret> ()))>, Future, DestructionTag>
            {
                if (ThisFuture_)
                    throw std::runtime_error { "SequenceProxy::Then(): cannot chain more after being converted to a QFuture" };

                Seq_->template Then<UnwrapFutureType_t<decltype (f (std::declval<Ret> ()))>, Ret> (f);
                return { ExecuteGuard_, Seq_, DestrHandler_ };
            }

            template<typename F>
            auto Then (F&& f) -> std::enable_if_t<std::is_same<void, decltype (f (std::declval<Ret> ()))>::value>
            {
                if (ThisFuture_)
                    throw std::runtime_error { "SequenceProxy::Then(): cannot chain more after being converted to a QFuture" };

                Seq_->template Then<Ret> (f);
            }

            template<typename F>
            auto Then (F&& f) -> std::enable_if_t<std::is_same<void, Ret>::value && std::is_same<void, decltype (f ())>::value>
            {
                if (ThisFuture_)
                    throw std::runtime_error { "SequenceProxy::Then(): cannot chain more after being converted to a QFuture" };

                Seq_->Then (std::function<void ()> { f });
            }

            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 (!isEmptyDestr)
                {
                    deleteGuard = new SlotClosure<DeleteLaterPolicy>
                    {
                        [destrHandler = DestrHandler_, iface] () mutable
                        {
                            if (iface.isFinished ())
                                return;

                            InvokeDestructionHandler<Ret, DestructionTag> (destrHandler, iface, 0);
                        },
                        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 ();
    }
}
}