Struct StopwatchStruct

Source

pub struct StopwatchStruct<T>where
    T: Fn(u32) + Send + Copy + 'static,{
    pub current_time: u32,
    pub status: StopwatchStatus,
    pub operation_on_stop: T,
}

Expand description

Represents a stopwatch that measures elapsed time.

It takes a generic type T which must be a closure that accepts a u32 (the final current_time when the stopwatch stops).

Fields§

§current_time: u32

The current elapsed time in seconds.

§status: StopwatchStatus

The current status of the stopwatch (Running or Stopped).

§operation_on_stop: T

A closure that will be executed when the stopwatch is stopped. It receives the final current_time as an argument.

Implementations§

Source §

impl<T> StopwatchStruct<T>
where T: Fn(u32) + Send + Copy + 'static,

Source

pub fn new(operation_on_stop: T) -> StopwatchStruct<T>

Creates a new StopwatchStruct instance.

§Arguments

operation_on_stop - A closure that will be called when the stopwatch status is set to Stopped. It receives the total elapsed time in seconds as its argument.

§Returns

A new StopwatchStruct initialized with current_time at 0 and status as Running.

§Examples

use clock-timer::stopwatch::{StopwatchStruct, StopwatchStatus}; // Replace clock-timer

let mut stopwatch = StopwatchStruct::new(|time| {
    println!("Stopwatch stopped at {} seconds.", time);
});

Source

pub fn start_timer<W: Write>(&mut self, writer: &mut W)

Starts the stopwatch.

The stopwatch will increment its current_time every second and print the elapsed time to the provided writer, overwriting the previous line.

The timer can be stopped in two ways:

Pressing Ctrl+C. This will execute the operation_on_stop closure and exit the process.
Programmatically by setting the status field to StopwatchStatus::Stopped. This will stop the loop and execute the operation_on_stop closure.

§Arguments

writer - A mutable reference to any type that implements the std::io::Write trait (e.g., &mut std::io::Stdout).

§Examples

use your_crate_name::stopwatch::{StopwatchStruct, StopwatchStatus}; // Replace your_crate_name
use std::{io::stdout, thread, time::Duration};

// This stopwatch will be stopped by another thread after 5 seconds.
let mut stopwatch = StopwatchStruct::new(|time| {
    println!("\nStopwatch finished at {} seconds!", time);
});

let mut stopwatch_clone = stopwatch.clone();
thread::spawn(move || {
    thread::sleep(Duration::from_secs(5));
    stopwatch_clone.status = StopwatchStatus::Stopped;
});

stopwatch.start_timer(&mut stdout());
println!("Stopwatch loop ended.");