time: add TimeSpec

Author: abbradar

src/sys/time.rs

@@ -1,6 +1,7 @@
 use std::{fmt, ops};
-use libc::{time_t, suseconds_t, timeval};
+use libc::{time_t, c_long, suseconds_t, timeval, timespec};
 
+const NANOS_PER_SEC: i64 = 1_000_000_000;
 const MICROS_PER_SEC: i64 = 1_000_000;
 const SECS_PER_MINUTE: i64 = 60;
 const SECS_PER_HOUR: i64 = 3600;
@@ -183,6 +184,193 @@ impl PartialEq for TimeVal {
 
 impl Eq for TimeVal { }
 
+#[derive(Clone, Copy)]
+pub struct TimeSpec {
+    spec: timespec,
+}
+
+impl AsRef<timespec> for TimeSpec {
+    fn as_ref(&self) -> &timespec {
+        &self.spec
+    }
+}
+
+impl TimeSpec {
+    #[inline]
+    pub fn zero() -> TimeSpec {
+        TimeSpec::nanoseconds(0)
+    }
+
+    #[inline]
+    pub fn hours(hours: i64) -> TimeSpec {
+        let secs = hours.checked_mul(SECS_PER_HOUR)
+            .expect("TimeSpec::hours ouf of bounds");
+
+        TimeSpec::seconds(secs)
+    }
+
+    #[inline]
+    pub fn minutes(minutes: i64) -> TimeSpec {
+        let secs = minutes.checked_mul(SECS_PER_MINUTE)
+            .expect("TimeSpec::minutes out of bounds");
+
+        TimeSpec::seconds(secs)
+    }
+
+    #[inline]
+    pub fn seconds(seconds: i64) -> TimeSpec {
+        assert!(seconds >= time_t::min_value() && seconds <= time_t::max_value(), "TimeSpec out of bounds; seconds={}", seconds);
+        TimeSpec { spec: timespec { tv_sec: seconds as time_t, tv_nsec: 0 } }
+    }
+
+    #[inline]
+    pub fn milliseconds(milliseconds: i64) -> TimeSpec {
+        let nanoseconds = milliseconds.checked_mul(1_000_000)
+            .expect("TimeSpec::milliseconds out of bounds");
+
+        TimeSpec::nanoseconds(nanoseconds)
+    }
+
+    #[inline]
+    pub fn microseconds(microseconds: i64) -> TimeSpec {
+        let nanoseconds = microseconds.checked_mul(1_000)
+            .expect("TimeSpec::microseconds out of bounds");
+
+        TimeSpec::nanoseconds(nanoseconds)
+    }
+
+
+    /// Makes a new `TimeSpec` with given number of nanoseconds.
+    #[inline]
+    pub fn nanoseconds(nanoseconds: i64) -> TimeSpec {
+        let (secs, nanos) = div_mod_floor_64(nanoseconds, NANOS_PER_SEC);
+        assert!(secs >= time_t::min_value() && secs <= time_t::max_value(), "TimeSpec out of bounds; seconds={}", secs);
+        TimeSpec { spec: timespec { tv_sec: secs as time_t, tv_nsec: nanos as c_long } }
+    }
+
+    pub fn num_hours(&self) -> i64 {
+        self.num_seconds() / 3600
+    }
+
+    pub fn num_minutes(&self) -> i64 {
+        self.num_seconds() / 60
+    }
+
+    pub fn num_seconds(&self) -> i64 {
+        if self.spec.tv_sec < 0 && self.spec.tv_nsec > 0 {
+            (self.spec.tv_sec + 1) as i64
+        } else {
+            self.spec.tv_sec as i64
+        }
+    }
+
+    pub fn num_milliseconds(&self) -> i64 {
+        self.num_nanoseconds() / 1_000_000
+    }
+
+    pub fn num_microseconds(&self) -> i64 {
+        self.num_nanoseconds() / 1_000
+    }
+
+    pub fn num_nanoseconds(&self) -> i64 {
+        let secs = self.num_seconds() * NANOS_PER_SEC;
+        let nsec = self.nanos_mod_sec();
+        secs + nsec as i64
+    }
+
+    fn nanos_mod_sec(&self) -> suseconds_t {
+        if self.spec.tv_sec < 0 && self.spec.tv_nsec > 0 {
+            self.spec.tv_nsec - NANOS_PER_SEC as c_long
+        } else {
+            self.spec.tv_nsec
+        }
+    }
+}
+
+impl ops::Neg for TimeSpec {
+    type Output = TimeSpec;
+
+    fn neg(self) -> TimeSpec {
+        TimeSpec::nanoseconds(-self.num_nanoseconds())
+    }
+}
+
+impl ops::Add for TimeSpec {
+    type Output = TimeSpec;
+
+    fn add(self, rhs: TimeSpec) -> TimeSpec {
+        TimeSpec::nanoseconds(
+            self.num_nanoseconds() + rhs.num_nanoseconds())
+    }
+}
+
+impl ops::Sub for TimeSpec {
+    type Output = TimeSpec;
+
+    fn sub(self, rhs: TimeSpec) -> TimeSpec {
+        TimeSpec::nanoseconds(
+            self.num_nanoseconds() - rhs.num_nanoseconds())
+    }
+}
+
+impl ops::Mul<i32> for TimeSpec {
+    type Output = TimeSpec;
+
+    fn mul(self, rhs: i32) -> TimeSpec {
+        let nsec = self.num_nanoseconds().checked_mul(rhs as i64)
+            .expect("TimeSpec multiply out of bounds");
+
+        TimeSpec::nanoseconds(nsec)
+    }
+}
+
+impl ops::Div<i32> for TimeSpec {
+    type Output = TimeSpec;
+
+    fn div(self, rhs: i32) -> TimeSpec {
+        let nsec = self.num_nanoseconds() / rhs as i64;
+        TimeSpec::nanoseconds(nsec)
+    }
+}
+
+impl fmt::Display for TimeSpec {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let (abs, sign) = if self.spec.tv_sec < 0 {
+            (-*self, "-")
+        } else {
+            (*self, "")
+        };
+
+        let sec = abs.spec.tv_sec;
+
+        try!(write!(f, "{}", sign));
+
+        if abs.spec.tv_nsec == 0 {
+            if abs.spec.tv_sec == 1 {
+                try!(write!(f, "{} second", sec));
+            } else {
+                try!(write!(f, "{} seconds", sec));
+            }
+        } else if abs.spec.tv_nsec % 1_000_000 == 0 {
+            try!(write!(f, "{}.{:03} seconds", sec, abs.spec.tv_nsec / 1_000_000));
+        } else if abs.spec.tv_nsec % 1_000 == 0 {
+            try!(write!(f, "{}.{:06} seconds", sec, abs.spec.tv_nsec / 1_000));
+        } else {
+            try!(write!(f, "{}.{:09} seconds", sec, abs.spec.tv_nsec));
+        }
+
+        Ok(())
+    }
+}
+
+impl PartialEq for TimeSpec {
+    fn eq(&self, rhs: &TimeSpec) -> bool {
+        self.spec.tv_sec == rhs.spec.tv_sec && self.spec.tv_nsec == rhs.spec.tv_nsec
+    }
+}
+
+impl Eq for TimeSpec { }
+
 #[inline]
 fn div_mod_floor_64(this: i64, other: i64) -> (i64, i64) {
     (div_floor_64(this, other), mod_floor_64(this, other))
@@ -213,7 +401,7 @@ fn div_rem_64(this: i64, other: i64) -> (i64, i64) {
 
 #[cfg(test)]
 mod test {
-    use super::TimeVal;
+    use super::{TimeVal, TimeSpec};
 
     #[test]
     pub fn test_time_val() {
@@ -238,4 +426,29 @@ mod test {
         assert_eq!(TimeVal::microseconds(42).to_string(), "0.000042 seconds");
         assert_eq!(TimeVal::seconds(-86401).to_string(), "-86401 seconds");
     }
+
+    #[test]
+    pub fn test_time_spec() {
+        assert!(TimeSpec::seconds(1) != TimeSpec::zero());
+        assert!(TimeSpec::seconds(1) + TimeSpec::seconds(2) == TimeSpec::seconds(3));
+        assert!(TimeSpec::minutes(3) + TimeSpec::seconds(2) == TimeSpec::seconds(182));
+    }
+
+    #[test]
+    pub fn test_time_spec_neg() {
+        let a = TimeSpec::seconds(1) + TimeSpec::nanoseconds(123);
+        let b = TimeSpec::seconds(-1) + TimeSpec::nanoseconds(-123);
+
+        assert!(a == -b);
+    }
+
+    #[test]
+    pub fn test_time_spec_fmt() {
+        assert_eq!(TimeSpec::zero().to_string(), "0 seconds");
+        assert_eq!(TimeSpec::seconds(42).to_string(), "42 seconds");
+        assert_eq!(TimeSpec::milliseconds(42).to_string(), "0.042 seconds");
+        assert_eq!(TimeSpec::microseconds(42).to_string(), "0.000042 seconds");
+        assert_eq!(TimeSpec::nanoseconds(42).to_string(), "0.000000042 seconds");
+        assert_eq!(TimeSpec::seconds(-86401).to_string(), "-86401 seconds");
+    }
 }