Expand description

A Rust crate for measuring time, while synchronizing it with an external source, for example adjusting the clock of a client to match the time one of a server.

The `Clock` struct works as a stopwatch. After you create an instance of it, you can query how much time has passed since it started. The clock returns this as a `std::time::Duration`.

``````use adjusting_clock::{Clock, ConstantRate};
use std::time::Instant;

let clock = Clock::new(Instant::now(), ConstantRate(0.001));
// ... after a while:
let current = clock.elapsed(Instant::now());``````

The usefulness of `Clock` comes from its ability to smoothly adjust its current time to match the time of another source:

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

// Create a clock that adjusts at a speed of 10 ms per second:
let t0 = Instant::now();
let mut clock = Clock::new(t0, ConstantRate(0.01));
// Request the current time to be 10 ms.
// As the clock just started at 0, this is an adjustment of +10 ms from the current time:
clock.set_target(t0, Duration::from_millis(10));
// After taking time to adjust at a rate of 10 ms per second,
// the current time will have been adjusted:
let elapsed = clock.elapsed(Instant::now());
//assert_eq!(elapsed, Duration::from_millis(1010)); // approx.
println!("Current time: {0} ms", elapsed.as_millis());
// Will print approximately 1010 ms, which is the sum of
// 10 because that's what the `set_target` call requested,
// and 1000 because that's how long time has passed since then.``````

See the test cases for more examples.

Structs

Measures the current time.

Adjusts the clock at a constant rate. The rate is a ratio, i.e. how many seconds the clock adjusts per second (or other unit of time, as the rate is unitless).

Traits

Specifies how the clock adjusts to the requested target time.