Struct RunningProgressLoop 

pub struct RunningProgressLoop { /* private fields */ }

Runs periodic running progress reports for work tracked elsewhere.

RunningProgressLoop is useful when worker threads update shared state and a separate reporter thread should periodically emit running events. The loop owns only the signal receiver. Callers provide a Progress instance and a snapshot closure that converts their domain state into ProgressCounters.

Use Self::spawn_scoped when the reporter thread can be scoped to the operation call. It returns a ScopedRunningProgress guard and cloneable crate::RunningProgressPoints handles for workers. Use Self::channel only when callers need to own the lower-level loop and notifier directly.

Examples

use std::{
    sync::{
        Arc,
        atomic::{
            AtomicUsize,
            Ordering,
        },
    },
    thread,
    time::Duration,
};

use qubit_progress::{
    NoOpProgressReporter,
    Progress,
    ProgressCounters,
    RunningProgressLoop,
};

let reporter = NoOpProgressReporter;
let completed = Arc::new(AtomicUsize::new(0));

thread::scope(|scope| {
    let loop_completed = Arc::clone(&completed);
    let progress = Progress::new(&reporter, Duration::ZERO);
    let running_progress =
        RunningProgressLoop::spawn_scoped(scope, progress, move || {
            // The background reporter thread does not own the operation
            // state. It only reads a fresh counter snapshot when the
            // interval is due or a worker sends a running point.
            ProgressCounters::new(Some(3))
                .with_completed_count(loop_completed.load(Ordering::Acquire))
        });
    let progress_points = running_progress.points();

    // Worker code updates domain state first, then wakes the loop. With a
    // zero interval, each running point may emit a `running` event.
    for _ in 0..3 {
        completed.fetch_add(1, Ordering::AcqRel);
        assert!(progress_points.running_point());
    }

    // Stop the loop before leaving the scope. Reporter panics are
    // propagated by `stop_and_join`.
    running_progress.stop_and_join();
});

Author

Haixing Hu

Implementations

impl RunningProgressLoop

pub fn channel() -> (Self, RunningProgressNotifier)

Creates a paired running progress loop and notifier.

Returns

A loop that owns the signal receiver and a notifier that sends wakeup or stop signals to that loop.

pub fn spawn_scoped<'scope, 'env, 'progress, F>( scope: &'scope Scope<'scope, 'env>, progress: Progress<'progress>, snapshot: F, ) -> ScopedRunningProgress<'scope>

where F: FnMut() -> ProgressCounters + Send + 'scope, 'progress: 'scope,

Spawns a scoped reporter thread for running progress events.

Parameters

• scope - Thread scope that owns the reporter thread.
• progress - Progress run used by the reporter thread.
• snapshot - Closure that returns current counters whenever a running event may be due.

Returns

A guard that can create worker point handles and stop the scoped reporter thread.

pub fn run<F>(self, progress: Progress<'_>, snapshot: F)

where F: FnMut() -> ProgressCounters,

Runs until a stop signal is received or every notifier is dropped.

Parameters

• progress - Progress run used to emit running events.
• snapshot - Closure that returns the current counters whenever a running event may be due.

Panics

Propagates panics from the configured reporter when a running event is due.