worker.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2014 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_WORKER_H
#define SWIFT_MISC_WORKER_H
 
#include <algorithm>
#include <atomic>
#include <functional>
#include <future>
#include <memory>
#include <type_traits>
 
#include <QMetaObject>
#include <QMetaType>
#include <QMutex>
#include <QMutexLocker>
#include <QObject>
#include <QPointer>
#include <QString>
#include <QThread>
#include <QTimer>
#include <QVariant>
#include <QtGlobal>
 
#include "misc/invoke.h"
#include "misc/promise.h"
#include "misc/swiftmiscexport.h"
 
namespace swift::misc
{
    class SWIFT_MISC_EXPORT CRegularThread : public QThread
    {
        Q_OBJECT
 
    public:
        CRegularThread(QObject *parent = nullptr) : QThread(parent) {}
 
        ~CRegularThread() override;
 
    protected:
        void run() override;
 
    private:
        std::atomic<void *> m_handle { nullptr };
    };
 
    class SWIFT_MISC_EXPORT CWorkerBase : public QObject
    {
        Q_OBJECT
 
    public:
        static const QStringList &getLogCategories();
 
        template <typename T, typename F>
        void then(T *context, F functor)
        {
            Q_ASSERT(context->thread() == QThread::currentThread());
            QMutexLocker lock(&m_finishedMutex);
            connect(this, &CWorkerBase::finished, context, functor);
            if (m_finished) { private_ns::invokeSlot(functor, context); }
        }
 
        template <typename F>
        void then(F functor)
        {
            QMutexLocker lock(&m_finishedMutex);
            connect(this, &CWorkerBase::finished, functor);
            if (m_finished) { functor(); }
        }
 
        bool isFinished() const
        {
            QMutexLocker lock(&m_finishedMutex);
            return m_finished;
        }
 
        template <typename F>
        void doIfFinished(F functor) const
        {
            QMutexLocker lock(&m_finishedMutex);
            if (m_finished) { functor(); }
        }
 
        template <typename F>
        void doIfNotFinished(F functor) const
        {
            QMutexLocker lock(&m_finishedMutex);
            if (!m_finished) { functor(); }
        }
 
        template <typename F1, typename F2>
        void doIfFinishedElse(F1 ifFunctor, F2 elseFunctor) const
        {
            QMutexLocker lock(&m_finishedMutex);
            if (m_finished) { ifFunctor(); }
            else { elseFunctor(); }
        }
 
        void waitForFinished() noexcept;
 
        void abandon() noexcept;
 
        void abandonAndWait() noexcept;
 
        static const QSet<CWorkerBase *> &allWorkers() { return s_allWorkers; }
 
    signals:
        void aboutToStart();
 
        void finished();
 
    protected:
        CWorkerBase();
 
        ~CWorkerBase() override;
 
        bool isAbandoned() const;
 
        bool hasStarted() const { return m_started; }
 
        void setStarted() { m_started = true; }
 
        void setFinished()
        {
            QMutexLocker lock(&m_finishedMutex);
            m_finished = true;
            emit finished();
        }
 
    private:
        virtual void quit() noexcept {}
        virtual void quitAndWait() noexcept { waitForFinished(); }
 
        bool m_started = false;
        bool m_finished = false;
        mutable QRecursiveMutex m_finishedMutex;
        static QSet<CWorkerBase *> s_allWorkers;
    };
 
    class SWIFT_MISC_EXPORT CWorker final : public CWorkerBase
    {
        Q_OBJECT
 
    public:
        template <typename F>
        static CWorker *fromTask(QObject *owner, const QString &name, F &&task)
        {
            int typeId = qMetaTypeId<std::decay_t<decltype(std::forward<F>(task)())>>();
            return fromTaskImpl(owner, name, typeId, [task = std::forward<F>(task)]() mutable {
                if constexpr (std::is_void_v<decltype(task())>)
                {
                    std::move(task)();
                    return QVariant();
                }
                else { return QVariant::fromValue(std::move(task)()); }
            });
        }
 
        template <typename R, typename F>
        void thenWithResult(F functor)
        {
            Q_ASSERT_X(m_result.canConvert<R>(), Q_FUNC_INFO, "Type in thenWithResult must match return type of task");
            then([this, functor]() { functor(this->resultNoWait<R>()); });
        }
 
        template <typename R, typename T, typename F>
        void thenWithResult(T *context, F functor)
        {
            Q_ASSERT_X(m_result.canConvert<R>(), Q_FUNC_INFO, "Type in thenWithResult must match return type of task");
 
            // MS 2018-10 It is possible that a queued finished() signal will be delivered after the worker was
            //            destroyed, so we can't refer to the this pointer inside the contextual then() lambda.
            //            Therefore we use a promise to extract the result from a non-contextual then(). See T414.
            auto promise = std::make_shared<std::promise<R>>();
            auto future = promise->get_future().share();
            then([this, promise]() { promise->set_value(this->resultNoWait<R>()); });
            then(context, [context, functor, future]() { private_ns::invokeSlot(functor, context, future.get()); });
        }
 
        template <typename R>
        R result()
        {
            waitForFinished();
            return this->resultNoWait<R>();
        }
 
    private slots:
        void ps_runTask();
 
    private:
        CWorker(const std::function<QVariant()> &task) : m_task(task) {}
        static CWorker *fromTaskImpl(QObject *owner, const QString &name, int typeId,
                                     const std::function<QVariant()> &task);
 
        template <typename R>
        R resultNoWait()
        {
            Q_ASSERT(m_result.canConvert<R>());
            return m_result.value<R>();
        }
 
        std::function<QVariant()> m_task;
        QVariant m_result;
    };
 
    class SWIFT_MISC_EXPORT CContinuousWorker : public CWorkerBase
    {
        Q_OBJECT
 
    public:
        CContinuousWorker(QObject *owner, const QString &name);
 
        void start(QThread::Priority priority = QThread::InheritPriority);
 
        void quit() noexcept final;
 
        void quitAndWait() noexcept final;
 
        bool isEnabled() const { return m_enabled; }
 
        void setEnabled(bool enabled) { m_enabled = enabled; }
 
        void startUpdating(int updateTimeSecs);
 
        const QString &getName() { return m_name; }
 
        const QObject *owner() const { return m_owner; }
 
    protected:
        virtual void initialize() {}
 
        virtual void cleanup() {}
 
        virtual void beforeQuit() noexcept {}
 
        virtual unsigned long waitTimeoutMs() const { return 15 * 1000; }
 
        void stopUpdateTimer();
 
        QTimer m_updateTimer { this }; 
 
    private:
        void finish();
 
        using CWorkerBase::hasStarted;
        using CWorkerBase::setStarted;
        using CWorkerBase::setFinished;
 
        QObject *m_owner = nullptr; 
        QString m_name; 
        std::atomic<bool> m_enabled { true }; 
    };
} // namespace swift::misc
 
#endif // SWIFT_MISC_WORKER_H