adjusting_clock 0.1.0

Measure time, while synchronizing it with an external source, for example adjusting the clock of a client to match the time one of a server.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

//! Simulating a time source that has a clock that differs from the local one.

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

fn run(rate: f64, realtime: bool) {
    let mut clock = Clock::new(Instant::now(), ConstantRate(rate));
    let start = Instant::now();
    let mut ahead = false;
    for iteration in 0..200 {
        let now = if realtime {
            Instant::now()
        } else {
            // Simulate that the local clock advances 100 ms per iteration.
            start + Duration::from_millis(100 * iteration)
        };

        let elapsed = clock.elapsed(now);
        println!("{iteration}: Current time is {0} ms", elapsed.as_millis(),);

        match iteration % 100 {
            50 | 90 | 95 => {
                // In our simulation, the clock source's time fluctuates
                let request = if ahead {
                    now.duration_since(start) + Duration::from_millis(10)
                } else {
                    now.duration_since(start) - Duration::from_millis(10)
                };
                println!(
                    "Clock source says time is {0}. Adjusting...",
                    request.as_millis()
                );
                clock.set_target(now, request);
                ahead = !ahead;
            }
            _ => {}
        }
        if realtime {
            thread::sleep(Duration::from_millis(100));
        }
    }
    println!("Example done");
}

pub fn main() {
    run(0.01, false);
}