background_scanner.hpp

Go to the documentation of this file.

#pragma once
 
// Background plugin scanning.
//
// Wraps any scan function in a worker-thread driver with cooperative
// cancellation and progress callbacks. Settings-panel UIs subscribe to
// progress events, run a scan without blocking the UI thread, and cancel
// mid-flight when the user closes the dialog or adds/removes a search
// path.
//
// Not tied to PluginScanner concretely — accepts any callable of shape
//   std::vector<PluginInfo>(const CancelToken&, ProgressSink).
// This keeps tests fast (fake scanners) and lets consumers swap in
// cached-scan paths later.
 
#include <pulp/host/scanner.hpp>
 
#include <atomic>
#include <functional>
#include <mutex>
#include <string>
#include <thread>
#include <vector>
 
namespace pulp::host {

class CancelToken {
public:
    void request() { flag_.store(true, std::memory_order_release); }
    bool requested() const { return flag_.load(std::memory_order_acquire); }
    void reset() { flag_.store(false, std::memory_order_release); }
 
private:
    std::atomic<bool> flag_{false};
};

using ScanProgressCallback = std::function<void(
    const std::string& current_path, int scanned, int total)>;

using ScanCompletionCallback = std::function<void(
    std::vector<PluginInfo> results, bool cancelled)>;

using ScanWorkerFn = std::function<std::vector<PluginInfo>(
    const CancelToken& token, const ScanProgressCallback& progress)>;
 
class BackgroundScanner {
public:
    BackgroundScanner() = default;
    ~BackgroundScanner() { stop_and_join(); }
 
    BackgroundScanner(const BackgroundScanner&) = delete;
    BackgroundScanner& operator=(const BackgroundScanner&) = delete;

    bool start(ScanWorkerFn worker,
               ScanProgressCallback progress,
               ScanCompletionCallback completion);

    void cancel();

    bool is_running() const {
        return running_.load(std::memory_order_acquire);
    }

    void join();
 
private:
    void stop_and_join();
 
    std::thread worker_;
    CancelToken token_;
    std::atomic<bool> running_{false};
    std::mutex start_mutex_;  // serializes start() vs stop_and_join()
};
 
} // namespace pulp::host