Struct Stopwatch 

pub struct Stopwatch {
    pub elapsed: Duration,
    pub timer: Instant,
    pub is_running: bool,
}

A simple stopwatch implementation.

Usage

use ticky::Stopwatch;
let mut sw = Stopwatch::start_new();
// Do something …
sw.stop();
println!("Elapsed time: {}ms", sw.elapsed_ms_whole());

Fields

elapsed: Duration

The total elapsed time.

timer: Instant

The time at which the stopwatch was last started.

is_running: bool

Whether the stopwatch is currently running.

Implementations

impl Stopwatch

pub fn start(&mut self)

Starts (or resumes) the stopwatch.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch (pausing it)
assert!(sw.elapsed_ms_whole().abs_diff(1_000) < 100); // Allow for some error (± 100 milliseconds)
sw.start(); // Start the stopwatch again (resuming it)
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_ms_whole().abs_diff(2_000) < 100); // Allow for some error (± 100 milliseconds)

pub fn stop(&mut self)

Stops (or pauses) the stopwatch.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch (pausing it)
assert!(sw.elapsed_ms_whole().abs_diff(1_000) < 100); // Allow for some error (± 100 milliseconds)
sw.start(); // Start the stopwatch again (resuming it)
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_ms_whole().abs_diff(2_000) < 100); // Allow for some error (± 100 milliseconds)

pub fn elapsed(&self) -> Duration

Returns the total elapsed time.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed().as_millis().abs_diff(1_000) < 100); // Allow for some error (± 100 milliseconds)

pub fn elapsed_ms_whole(&mut self) -> u128

Returns the total elapsed time in milliseconds.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_ms_whole().abs_diff(1_000) < 100); // Allow for some error (± 100 milliseconds)

pub fn elapsed_us_whole(&mut self) -> u128

Returns the total elapsed time in microseconds.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_micros(1_000_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_us_whole().abs_diff(1_000_000) < 10_000); // Allow for some error (± 10,000 microseconds)

pub fn elapsed_ns_whole(&mut self) -> u128

Returns the total elapsed time in nanoseconds.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_nanos(1_000_000_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_ns_whole().abs_diff(1_000_000_000) < 100_000_000); // Allow for some error (± 100,000,000 nanoseconds)

pub fn elapsed_s(&mut self) -> f64

Returns the total elapsed time in fractional seconds.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_500)); // Wait for 1.5 seconds
sw.stop(); // Stop the stopwatch
assert!((sw.elapsed_s() - 1.5).abs() < 0.01); // Allow for some error (± 0.01 seconds)

pub fn elapsed_s_whole(&self) -> u64

Returns the total elapsed time in whole seconds.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_500)); // Wait for 1.5 seconds
sw.stop(); // Stop the stopwatch
assert_eq!(sw.elapsed_s_whole(), 1);

impl Stopwatch

pub fn new() -> Stopwatch

Creates a new stopwatch.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_ms_whole().abs_diff(1_000) < 10); // Allow for some error (± 10 milliseconds)

pub fn start_new() -> Stopwatch

Creates a new stopwatch and starts it.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::start_new(); // Create a new stopwatch, and start it
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_ms_whole().abs_diff(1_000) < 10); // Allow for some error (± 10 milliseconds)

pub fn reset(&mut self)

Resets the stopwatch.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_ms_whole().abs_diff(1_000) < 10); // Allow for some error (± 10 milliseconds)
sw.reset(); // Reset the stopwatch
assert!(sw.elapsed_ms_whole().abs_diff(0) < 10); // Allow for some error (± 10 milliseconds)
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_ms_whole().abs_diff(1_000) < 10); // Allow for some error (± 10 milliseconds)

pub fn restart(&mut self)

Resets and starts the stopwatch.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
sw.start(); // Start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_ms_whole().abs_diff(1_000) < 10); // Allow for some error (± 10 milliseconds)
sw.restart(); // Reset and start the stopwatch
std::thread::sleep(std::time::Duration::from_millis(1_000)); // Wait for 1 second
sw.stop(); // Stop the stopwatch
assert!(sw.elapsed_ms_whole().abs_diff(1_000) < 10); // Allow for some error (± 10 milliseconds)

pub fn is_running(&mut self) -> bool

Returns true if the stopwatch is running, and false if not.

Example

use ticky::Stopwatch;

let mut sw = Stopwatch::new(); // Create a new stopwatch
assert_eq!(sw.is_running(), false); // The stopwatch is not running
sw.start(); // Start the stopwatch
assert_eq!(sw.is_running(), true); // The stopwatch is running
sw.stop(); // Stop the stopwatch
assert_eq!(sw.is_running(), false); // The stopwatch is not running

Trait Implementations

impl Clone for Stopwatch

fn clone(&self) -> Stopwatch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stopwatch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Stopwatch

fn default() -> Self

Returns the “default value” for a type.

impl Display for Stopwatch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Duration> for Stopwatch

fn from(dur: Duration) -> Self

Converts to this type from the input type.

impl From<Stopwatch> for Duration

fn from(sw: Stopwatch) -> Self

Converts to this type from the input type.

impl Hash for Stopwatch

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Stopwatch

fn cmp(&self, other: &Stopwatch) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Stopwatch

fn eq(&self, other: &Stopwatch) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Stopwatch

fn partial_cmp(&self, other: &Stopwatch) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Stopwatch

impl Eq for Stopwatch

impl StructuralPartialEq for Stopwatch