Struct RunningProgressPointHandle 

pub struct RunningProgressPointHandle { /* private fields */ }

Worker-side handle for reporting running progress points.

RunningProgressPointHandle deliberately cannot stop or join the reporter thread. It only wakes the reporter loop for zero-interval progress. For positive intervals, Self::report is a no-op because the reporter loop wakes itself on timeout.

Examples

use std::{
    thread,
    time::Duration,
};

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

let reporter = NoOpProgressReporter;

thread::scope(|scope| {
    let progress = Progress::new(&reporter, Duration::ZERO);
    let running_progress =
        progress.spawn_running_reporter(scope, || {
            ProgressCounters::new(Some(1)).with_completed_count(1)
        });
    let progress_point_handle = running_progress.point_handle();

    let worker = scope.spawn({
        let progress_point_handle = progress_point_handle.clone();
        move || {
            assert!(progress_point_handle.report());
        }
    });
    worker.join().unwrap();

    running_progress.stop_and_join();
});

Author

Haixing Hu

Implementations

impl RunningProgressPointHandle

pub fn report(&self) -> bool

Reports one worker running progress point.

Returns

true when the point was accepted or no point signal is required. Returns false only when a required zero-interval signal could not be sent because the reporter loop has already stopped.

Trait Implementations

impl Clone for RunningProgressPointHandle

fn clone(&self) -> RunningProgressPointHandle

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.