Struct CountdownWait 

pub struct CountdownWait<'a> { /* private fields */ }

A blocking wait that reports the time left every tick and stops early when a CancelToken is cancelled.

Time is counted from the sleeps themselves, so an injected sleeper makes the wait instant and deterministic:

use std::time::Duration;
use rich_ext::countdown::{CountdownWait, WaitOutcome};

let mut ticks = Vec::new();
let outcome = CountdownWait::new(Duration::from_secs(2))
    .tick(Duration::from_secs(1))
    .sleeper(|_| {})
    .run(|left| ticks.push(left.as_secs()));
assert_eq!(outcome, WaitOutcome::Elapsed);
assert_eq!(ticks, [2, 1, 0]);

Implementations

impl<'a> CountdownWait<'a>

pub fn new(total: Duration) -> Self

Wait total, ticking every 250 ms with std::thread::sleep.

pub fn tick(self, tick: Duration) -> Self

Report (and check for cancellation) every tick (at least 1 ms).

pub fn cancel(self, token: CancelToken) -> Self

Stop early once token is cancelled.

pub fn sleeper(self, sleep: impl FnMut(Duration) + 'a) -> Self

Sleep with sleep instead of std::thread::sleep.

pub fn run(self, on_tick: impl FnMut(Duration)) -> WaitOutcome

Wait, calling on_tick with the time left before each sleep and once with zero at the end.

pub fn run_live<W: Write, R: Renderable>( self, live: &mut LiveCoordinator<W>, target: &RenderTarget, motion: Motion, frame: impl Fn(Duration) -> R, ) -> Result<WaitOutcome, LiveError>

Wait while showing frame(time_left) through live.

Motion::Animated draws the frame in a new region, updates it every tick and removes it at the end. Motion::Static prints the first frame once as an ordinary line, which a log keeps.