processing_observer.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 Povl Filip Sonne-Frederiksen
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
// PCL-free core observer interface (STANDARDS §1: core/ must not pull PCL).
// The progress-reporting interface lives here; the PCL/Eigen-typed
// visualization payloads live in core/visual_observer.hpp, which core headers
// never include. The visual-observer registry below only traffics in an opaque
// IVisualObserver* (forward-declared), so this header stays PCL-free.
 
#include "reusex/core/stages.hpp"
 
#include <cstddef>
 
namespace reusex::core {
 
// Forward declaration: the full definition (with PCL/Eigen payloads) lives in
// core/visual_observer.hpp. Consumers that emit visualization events include
// that header; the registry here only stores/returns the pointer.
class IVisualObserver;
 
enum class EventType {
  process,
  progress,
  visualization
  //
};
 
class IObserver {};
 
class IProgressObserver;

class ProgressObserver {
    public:
  explicit ProgressObserver(Stage stage, size_t total = 0);
  ~ProgressObserver();
 
  ProgressObserver(const ProgressObserver &) = delete;
  ProgressObserver &operator=(const ProgressObserver &) = delete;
 
  void update(size_t progress = 1);
 
  inline void operator++() { update(1); };
  inline void operator+=(size_t increment) { update(increment); };
 
    private:
  Stage stage_;
  size_t total_ = 0;
  IProgressObserver *observer_ = nullptr; 
};
 
class IProgressObserver : IObserver {
    public:
  virtual ~IProgressObserver() = default;
 
  // Progress bar callbacks
  virtual void on_process_started(Stage, size_t) {}
  virtual void on_process_finished(Stage) {}
  virtual void on_process_updated(Stage, size_t) {}
};
 
// Register a global processing observer. The caller retains ownership and must
// keep the observer alive until reset or replacement. Passing nullptr clears
// it.
//
// The global observer is the fallback for a thread with no
// ScopedProgressObserver installed — the rux CLI's progress bar. A server that
// runs several stages at once (ruxd's job scheduler) must not use it: it would
// interleave every job's progress into one observer. It installs a
// ScopedProgressObserver per job instead.
 
void set_visual_observer(IVisualObserver *observer);
void set_progress_observer(IProgressObserver *observer);
 
void reset_visual_observer();
void reset_progress_observer();
 
auto get_visual_observer() -> IVisualObserver *;
auto get_progress_observer() -> IProgressObserver *;

auto current_progress_observer() -> IProgressObserver *;

class ScopedProgressObserver {
    public:
  explicit ScopedProgressObserver(IProgressObserver *observer);
  ~ScopedProgressObserver();
 
  ScopedProgressObserver(const ScopedProgressObserver &) = delete;
  ScopedProgressObserver &operator=(const ScopedProgressObserver &) = delete;
 
    private:
  IProgressObserver *previous_ = nullptr;
  bool previous_set_ = false;
};
 
} // namespace reusex::core