backgroundexecutor.h

// SPDX-FileCopyrightText: 2025 Manuel Schneider
// SPDX-License-Identifier: MIT
 
#pragma once
#include <QFutureWatcher>
#include <QtConcurrentRun>
#include <atomic>
#include <functional>
 
namespace albert
{
 
template<typename T>
class BackgroundExecutor
{
    std::unique_ptr<QFutureWatcher<T>> future_watcher_;
    bool rerun_ = false;
    std::atomic_bool stop_ = false;
 
public:
 
    std::function<T(const bool &abort)> parallel;
 
    std::function<void()> finish;
 
 
    BackgroundExecutor() = default;
 
    ~BackgroundExecutor()
    {
        stop_ = true;
        rerun_ = false;
 
        // Qt 6.4 QFutureWatcher is broken.
        // isFinished returns wrong values and waitForFinished blocks forever on finished futures.
        // TODO(26.04): Remove workaround when dropping Qt < 6.5 support.
        if (future_watcher_
#if QT_VERSION >= QT_VERSION_CHECK(6, 5, 0)
            && !future_watcher_->isFinished())
#else
            && future_watcher_->isRunning())
#endif
            future_watcher_->waitForFinished();
    }
 
    void run()
    {
        if (isRunning())
        {
            stop_ = true;
            rerun_ = true;
        }
        else
        {
            stop_ = false;
            rerun_ = false;
 
            future_watcher_ = std::make_unique<QFutureWatcher<T>>();
 
            QObject::connect(future_watcher_.get(), &QFutureWatcher<T>::finished,
                             future_watcher_.get(), [this]
            {
                if (rerun_)
                {
                    future_watcher_.reset();
                    run();  // discard results and rerun
                }
                else
                {
                    try {
                        finish();  // may throw
                    } catch (...) {}
                    future_watcher_.reset();
                }
            });
 
            future_watcher_->setFuture(QtConcurrent::run([this]{ return parallel(stop_); }));
 
        }
    }
 
    inline void stop() { stop_ = true; }
 
    inline bool isRunning() const { return future_watcher_.get(); }
 
    inline void waitForFinished()
    {
        if (future_watcher_)
            future_watcher_->waitForFinished();
    }
 
    inline T takeResult() { return future_watcher_->future().takeResult(); }
 
};
 
}