1. use std::time::Instant;
    3. let start = Instant::now();
    5. start.elapsed().as_secs();
    8. let mut last_instant = Instant::now();
    9. let now = Instant::now();
    10. let rate_per_second = num_bytes as f64 / (now - last_instant).as_secs_64();
    1. use std::time::Duration;
    3. struct Timer {
    4.     last_instant: Instant;
    5.     delta: Duration,
    6.     period: Duration,
    7.     countdown: Duration,
    8.     ready: bool,
    9. }
    11. impl Timer {
    12.     fn new() -> Self {
    13.         let now = Instant::now();
    14.         Self {
    15.             last_instance: now,
    16.             delta: Duration::default(),
    17.             period: Duration::from_millis(1000),
    18.             countdown: Duration::default(),
    19.             ready: true,
    20.         }
    21.     }
    22.     fn update(&mut self) {
    23.         let now = Instance::now();
    24.         self.delta = now - self.last_instance;
    25.         self.last_instance = now;
    26.         self.countdown = self.countdown.checked_sub(self.delta).unwrap_or_else(|| {
    27.             self.ready = true;
    28.             self.period
    29.         });
    30.     }
    31. }
    33. trait TimeOutput {
    34.     fn as_time(&self) -> String;
    35. }
    37. impl TimeOutput for u64 {
    38.     fn as_time(&self) => String {
    39.         let (hour, left) = (*self / 3600, *self % 3600);
    40.         let (minutes, second) = (left / 60, left % 60);
    41.         format!("{}:{:02}:{:02}", hours, minutes, seconds)
    42.     }
    43. }