Struct ScopedRunningProgress 

pub struct ScopedRunningProgress<'scope> { /* private fields */ }

Owns a scoped running progress reporter thread.

ScopedRunningProgress is a lifecycle guard for a reporter thread created by crate::RunningProgressLoop::spawn_scoped. Keep this guard on the coordinating thread, pass RunningProgressPoints clones to workers, and call Self::stop_and_join after worker execution completes.

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 || {
            ProgressCounters::new(Some(1))
                .with_completed_count(loop_completed.load(Ordering::Acquire))
        });
    let progress_points = running_progress.points();

    completed.store(1, Ordering::Release);
    assert!(progress_points.running_point());

    running_progress.stop_and_join();
});

Author

Haixing Hu

Implementations

impl<'scope> ScopedRunningProgress<'scope>

pub fn points(&self) -> RunningProgressPoints

Returns a worker-side running point handle.

Returns

A cloneable handle that wakes the reporter loop for zero intervals and becomes a no-op for positive intervals.

pub fn stop_and_join(self)

Stops the reporter loop and joins the scoped reporter thread.

Panics

Propagates any panic raised by the reporter thread.