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;
        if (future_watcher_ && !future_watcher_->isFinished())
            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(); }
 
};
 
}