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
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use mem;
use sys::cloudabi::abi;
use time::Duration;

const NSEC_PER_SEC: abi::timestamp = 1_000_000_000;

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub struct Instant {
    t: abi::timestamp,
}

pub fn dur2intervals(dur: &Duration) -> abi::timestamp {
    dur.as_secs()
        .checked_mul(NSEC_PER_SEC)
        .and_then(|nanos| nanos.checked_add(dur.subsec_nanos() as abi::timestamp))
        .expect("overflow converting duration to nanoseconds")
}

impl Instant {
    pub fn now() -> Instant {
        unsafe {
            let mut t = mem::uninitialized();
            let ret = abi::clock_time_get(abi::clockid::MONOTONIC, 0, &mut t);
            assert_eq!(ret, abi::errno::SUCCESS);
            Instant { t: t }
        }
    }

    pub fn sub_instant(&self, other: &Instant) -> Duration {
        let diff = self.t
            .checked_sub(other.t)
            .expect("second instant is later than self");
        Duration::new(diff / NSEC_PER_SEC, (diff % NSEC_PER_SEC) as u32)
    }

    pub fn add_duration(&self, other: &Duration) -> Instant {
        Instant {
            t: self.t
                .checked_add(dur2intervals(other))
                .expect("overflow when adding duration to instant"),
        }
    }

    pub fn sub_duration(&self, other: &Duration) -> Instant {
        Instant {
            t: self.t
                .checked_sub(dur2intervals(other))
                .expect("overflow when subtracting duration from instant"),
        }
    }
}

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub struct SystemTime {
    t: abi::timestamp,
}

impl SystemTime {
    pub fn now() -> SystemTime {
        unsafe {
            let mut t = mem::uninitialized();
            let ret = abi::clock_time_get(abi::clockid::REALTIME, 0, &mut t);
            assert_eq!(ret, abi::errno::SUCCESS);
            SystemTime { t: t }
        }
    }

    pub fn sub_time(&self, other: &SystemTime) -> Result<Duration, Duration> {
        if self.t >= other.t {
            let diff = self.t - other.t;
            Ok(Duration::new(
                diff / NSEC_PER_SEC,
                (diff % NSEC_PER_SEC) as u32,
            ))
        } else {
            let diff = other.t - self.t;
            Err(Duration::new(
                diff / NSEC_PER_SEC,
                (diff % NSEC_PER_SEC) as u32,
            ))
        }
    }

    pub fn add_duration(&self, other: &Duration) -> SystemTime {
        SystemTime {
            t: self.t
                .checked_add(dur2intervals(other))
                .expect("overflow when adding duration to instant"),
        }
    }

    pub fn sub_duration(&self, other: &Duration) -> SystemTime {
        SystemTime {
            t: self.t
                .checked_sub(dur2intervals(other))
                .expect("overflow when subtracting duration from instant"),
        }
    }
}

pub const UNIX_EPOCH: SystemTime = SystemTime { t: 0 };