promise.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2017 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_PROMISE_H
#define SWIFT_MISC_PROMISE_H
 
#include <utility>
 
#include <QCoreApplication>
#include <QFuture>
#include <QFutureWatcher>
#include <QObject>
#include <QSharedPointer>
 
namespace swift::misc
{
 
    namespace private_ns
    {
        template <typename T>
        class CPromiseData final : public QFutureInterface<T>
        {
        public:
            CPromiseData() { this->reportStarted(); }
            ~CPromiseData()
            {
                if (this->isRunning()) { this->cancel(); }
            }
 
            CPromiseData(const CPromiseData &) = delete;
            CPromiseData &operator=(const CPromiseData &) = delete;
        };
 
        template <typename T, typename F>
        void doAfter(QFuture<T> future, QObject *context, F &&func)
        {
            QSharedPointer<QFutureWatcher<T>> watcher(new QFutureWatcher<T>, &QObject::deleteLater);
            if (!context) { context = watcher.data(); }
            QObject::connect(watcher.data(), &QFutureWatcher<T>::finished, context,
                             [watcher, func = std::forward<F>(func)]() mutable {
                                 if (!watcher->isCanceled()) { func(watcher->future()); }
                                 watcher.reset();
                             });
            watcher->setFuture(future);
            QCoreApplication::sendPostedEvents(watcher.data());
        }
    } // namespace private_ns
 
    template <typename T, typename F>
    void doAfter(QFuture<T> future, QObject *context, F &&func)
    {
        private_ns::doAfter(future, context, std::forward<F>(func));
    }
 
    template <typename F>
    void doAfter(QFuture<void> future, QObject *context, F &&func)
    {
        private_ns::doAfter(future, context, [func = std::forward<F>(func)](auto &&) { func(); });
    }
 
    template <typename T>
    class CPromise
    {
    public:
        QFuture<T> future() { return m_data->future(); }
 
        void abandon()
        {
            m_data->cancel();
            m_data->reportFinished();
        }
 
        void setResult(const T &value) { m_data->reportFinished(&value); }
 
        template <typename U>
        void setResult(QFuture<U> future)
        {
            future.waitForFinished();
            future.isCanceled() ? abandon() : setResult(future.result());
        }
 
        template <typename U>
        void chainResult(QFuture<U> future)
        {
            doAfter(future, nullptr, [*this](auto &&f) mutable { setResult(f); });
        }
 
        template <typename F>
        void setResultFrom(F &&func)
        {
            setResult(std::forward<F>(func)());
        }
 
    private:
        QSharedPointer<private_ns::CPromiseData<T>> m_data { new private_ns::CPromiseData<T> };
    };
 
    template <>
    class CPromise<void>
    {
    public:
        QFuture<void> future() { return m_data->future(); }
 
        void abandon()
        {
            m_data->cancel();
            m_data->reportFinished();
        }
 
        void setResult() { m_data->reportFinished(); }
 
        template <typename U>
        void setResult(QFuture<U> future)
        {
            future.waitForFinished();
            future.isCanceled() ? abandon() : setResult();
        }
 
        template <typename U>
        void chainResult(QFuture<U> future)
        {
            doAfter(future, nullptr, [this](auto &&f) { setResult(f); });
        }
 
        template <typename F>
        void setResultFrom(F &&func)
        {
            std::forward<F>(func)();
            setResult();
        }
 
    private:
        QSharedPointer<private_ns::CPromiseData<void>> m_data { new private_ns::CPromiseData<void> };
    };
 
} // namespace swift::misc
 
#endif // SWIFT_MISC_PROMISE_H