Make no_std.

Author: thejpster

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "measurements"
-version = "0.6.0"
+version = "0.7.0"
 authors = ["James O'Cull <[email protected]>",
           "Jonathan Pallant <[email protected]>",
           "Hannah McLaughlin <[email protected]>"]
@@ -10,3 +10,7 @@ keywords = ["measurements", "lengths", "weights", "temperatures", "volumes"]
 description = "Handle metric, imperial, and other measurements with ease! Types: Length, Temperature, Weight, Volume, Pressure"
 license = "MIT"
 readme = "README.md"
+
+
+[dependencies]
+time = "0.1"

examples/frequency.rs

@@ -6,7 +6,7 @@ fn main() {
     let d = measurements::Distance::from_millimeters(50.0);
     // Speed = PI * Frequency * Displacement
     // Speed = PI * Displacement / Period
-    let v = ::std::f64::consts::PI * d / f.as_period();
+    let v = std::f64::consts::PI * d / f.as_period();
     println!(
         "Maximum speed of a pendulum at {:.1} with max displacement {:.1} is {:.1}",
         f,

src/acceleration.rs

@@ -9,15 +9,19 @@ use super::length;
 /// # Example
 ///
 /// ```
+/// extern crate time;
+/// extern crate measurements;
 /// use measurements::{Acceleration, Length, Speed};
-/// use std::time::Duration;
+/// use time::Duration;
 ///
-/// // Standing quarter mile in 10.0 dead, at 120.0 mph
-/// let track = Length::from_miles(0.25);
-/// let finish = Speed::from_miles_per_hour(120.0);
-/// let time = Duration::new(10, 0);
-/// let accel: Acceleration = finish / time;
-/// println!("You accelerated over {} at an average of {}", track, accel);
+/// fn main() {
+///     // Standing quarter mile in 10.0 dead, at 120.0 mph
+///     let track = Length::from_miles(0.25);
+///     let finish = Speed::from_miles_per_hour(120.0);
+///     let time = Duration::seconds(10);
+///     let accel: Acceleration = finish / time;
+///     println!("You accelerated over {} at an average of {}", track, accel);
+///}
 /// ```
 #[derive(Copy, Clone, Debug)]
 pub struct Acceleration {
@@ -79,14 +83,14 @@ mod test {
 
     use super::*;
     use test_utils::assert_almost_eq;
-    use std::time::Duration;
+    use time::Duration;
     use speed::Speed;
 
     // Metric
     #[test]
     fn speed_over_time() {
         let s1 = Speed::from_meters_per_second(10.0);
-        let t1 = Duration::new(5, 0);
+        let t1 = Duration::seconds(5);
         let i1 = s1 / t1;
         let r1 = i1.as_meters_per_second_per_second();
         assert_almost_eq(r1, 2.0);

src/angle.rs

@@ -95,7 +95,7 @@ implement_measurement! { Angle }
 #[cfg(test)]
 mod test {
     use angle::*;
-    use std::f64::consts::PI;
+    use core::f64::consts::PI;
     use test_utils::assert_almost_eq;
 
     #[test]

src/angular_velocity.rs

@@ -1,7 +1,7 @@
 //! Types and constants for handling speed of rotation (angular velocity)
 
 use super::measurement::*;
-use std::f64::consts::PI;
+use core::f64::consts::PI;
 
 /// The 'AngularVelocity' struct can be used to deal with angular velocities in a common way.
 ///

src/frequency.rs

@@ -78,7 +78,7 @@ impl Frequency {
     }
 
     /// Create a new Frequency from a floating point value of the period in seconds.
-    pub fn from_period(period: ::std::time::Duration) -> Self {
+    pub fn from_period(period: ::time::Duration) -> Self {
         Self::from_hertz(1.0 / period.as_base_units())
     }
 
@@ -123,8 +123,8 @@ impl Frequency {
     }
 
     /// Convert this Frequency to a floating point value of the period in seconds.
-    pub fn as_period(&self) -> ::std::time::Duration {
-        ::std::time::Duration::from_base_units(1.0 / self.hertz)
+    pub fn as_period(&self) -> ::time::Duration {
+        ::time::Duration::from_base_units(1.0 / self.hertz)
     }
 }
 
@@ -245,7 +245,7 @@ mod test {
     pub fn period() {
         let i1 = Frequency::from_hertz(100.0);
         let r1 = i1.as_period().as_base_units();
-        let i2 = Frequency::from_period(::std::time::Duration::new(100, 0));
+        let i2 = Frequency::from_period(::time::Duration::seconds(100));
         let r2 = i2.as_hertz();
         assert_almost_eq(r1, 1e-2);
         assert_almost_eq(r2, 1e-2);

src/lib.rs

@@ -7,6 +7,9 @@
 //! by an Area to get a Pressure.
 
 #![deny(warnings, missing_docs)]
+#![no_std]
+
+extern crate time;
 
 #[macro_use]
 mod measurement;
@@ -73,15 +76,15 @@ pub mod test_utils;
 ///     - C = A / B
 macro_rules! impl_maths {
     ($a:ty, $b:ty) => {
-        impl ::std::ops::Mul<$b> for $b {
+        impl ::core::ops::Mul<$b> for $b {
             type Output = $a;
 
             fn mul(self, rhs: $b) -> Self::Output {
                 Self::Output::from_base_units(self.as_base_units() * rhs.as_base_units())
             }
         }
 
-        impl ::std::ops::Div<$b> for $a {
+        impl ::core::ops::Div<$b> for $a {
             type Output = $b;
 
             fn div(self, rhs: $b) -> Self::Output {
@@ -91,31 +94,31 @@ macro_rules! impl_maths {
     };
 
     ($a:ty, $b:ty, $c:ty) => {
-        impl ::std::ops::Mul<$b> for $c {
+        impl ::core::ops::Mul<$b> for $c {
             type Output = $a;
 
             fn mul(self, rhs: $b) -> Self::Output {
                 Self::Output::from_base_units(self.as_base_units() * rhs.as_base_units())
             }
         }
 
-        impl ::std::ops::Mul<$c> for $b {
+        impl ::core::ops::Mul<$c> for $b {
             type Output = $a;
 
             fn mul(self, rhs: $c) -> Self::Output {
                 Self::Output::from_base_units(self.as_base_units() * rhs.as_base_units())
             }
         }
 
-        impl ::std::ops::Div<$c> for $a {
+        impl ::core::ops::Div<$c> for $a {
             type Output = $b;
 
             fn div(self, rhs: $c) -> Self::Output {
                 Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
             }
         }
 
-        impl ::std::ops::Div<$b> for $a {
+        impl ::core::ops::Div<$b> for $a {
             type Output = $c;
 
             fn div(self, rhs: $b) -> Self::Output {
@@ -125,15 +128,13 @@ macro_rules! impl_maths {
     }
 }
 
-impl Measurement for std::time::Duration {
+impl Measurement for time::Duration {
     fn as_base_units(&self) -> f64 {
-        self.as_secs() as f64 + (f64::from(self.subsec_nanos()) * 1e-9)
+        (self.num_microseconds().unwrap() as f64) / 1e6
     }
 
     fn from_base_units(units: f64) -> Self {
-        let subsec_nanos = ((units * 1e9) % 1e9) as u32;
-        let secs = units as u64;
-        std::time::Duration::new(secs, subsec_nanos)
+        time::Duration::microseconds((units * 1e6) as i64)
     }
 
     fn get_base_units_name(&self) -> &'static str {
@@ -142,12 +143,12 @@ impl Measurement for std::time::Duration {
 }
 
 impl_maths!(Area, Length);
-impl_maths!(Energy, std::time::Duration, Power);
+impl_maths!(Energy, time::Duration, Power);
 impl_maths!(Force, Mass, Acceleration);
 impl_maths!(Force, Pressure, Area);
-impl_maths!(Length, std::time::Duration, Speed);
+impl_maths!(Length, time::Duration, Speed);
 impl_maths!(Power, Force, Speed);
-impl_maths!(Speed, std::time::Duration, Acceleration);
+impl_maths!(Speed, time::Duration, Acceleration);
 impl_maths!(Volume, Length, Area);
 impl_maths!(Power, AngularVelocity, Torque);
 
@@ -159,31 +160,31 @@ impl_maths!(TorqueEnergy, Force, Length);
 // Implement the divisions manually (the above macro only implemented the
 // TorqueEnergy / X operations).
 
-impl ::std::ops::Div<Length> for Torque {
+impl ::core::ops::Div<Length> for Torque {
     type Output = Force;
 
     fn div(self, rhs: Length) -> Self::Output {
         Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
     }
 }
 
-impl ::std::ops::Div<Force> for Torque {
+impl ::core::ops::Div<Force> for Torque {
     type Output = Length;
 
     fn div(self, rhs: Force) -> Self::Output {
         Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
     }
 }
 
-impl ::std::ops::Div<Length> for Energy {
+impl ::core::ops::Div<Length> for Energy {
     type Output = Force;
 
     fn div(self, rhs: Length) -> Self::Output {
         Self::Output::from_base_units(self.as_base_units() / rhs.as_base_units())
     }
 }
 
-impl ::std::ops::Div<Force> for Energy {
+impl ::core::ops::Div<Force> for Energy {
     type Output = Length;
 
     fn div(self, rhs: Force) -> Self::Output {

src/measurement.rs

@@ -3,6 +3,7 @@
 ///
 /// # Example
 /// ```
+/// #![no_std]
 /// // Importing the `implement_measurement` macro from the external crate is important
 /// #[macro_use]
 /// extern crate measurements;
@@ -73,13 +74,13 @@ pub trait Measurement {
 }
 
 /// This is a special macro that creates the code to implement
-/// `std::fmt::Display`.
+/// `core::fmt::Display`.
 #[macro_export]
 macro_rules! implement_display {
     ($($t:ty)*) => ($(
 
-        impl ::std::fmt::Display for $t {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        impl ::core::fmt::Display for $t {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                 let (unit, value) = self.get_appropriate_units();
                 value.fmt(f)?;      // Value
                 write!(f, "\u{00A0}{}", unit)
@@ -97,15 +98,15 @@ macro_rules! implement_measurement {
 
         implement_display!( $t );
 
-        impl ::std::ops::Add for $t {
+        impl ::core::ops::Add for $t {
             type Output = Self;
 
             fn add(self, rhs: Self) -> Self {
                 Self::from_base_units(self.as_base_units() + rhs.as_base_units())
             }
         }
 
-        impl ::std::ops::Sub for $t {
+        impl ::core::ops::Sub for $t {
             type Output = Self;
 
             fn sub(self, rhs: Self) -> Self {
@@ -115,7 +116,7 @@ macro_rules! implement_measurement {
 
         // Dividing a `$t` by another `$t` returns a ratio.
         //
-        impl ::std::ops::Div<$t> for $t {
+        impl ::core::ops::Div<$t> for $t {
             type Output = f64;
 
             fn div(self, rhs: Self) -> f64 {
@@ -125,7 +126,7 @@ macro_rules! implement_measurement {
 
         // Dividing a `$t` by a factor returns a new portion of the measurement.
         //
-        impl ::std::ops::Div<f64> for $t {
+        impl ::core::ops::Div<f64> for $t {
             type Output = Self;
 
             fn div(self, rhs: f64) -> Self {
@@ -135,7 +136,7 @@ macro_rules! implement_measurement {
 
         // Multiplying a `$t` by a factor increases (or decreases) that
         // measurement a number of times.
-        impl ::std::ops::Mul<f64> for $t {
+        impl ::core::ops::Mul<f64> for $t {
             type Output = Self;
 
             fn mul(self, rhs: f64) -> Self {
@@ -144,23 +145,23 @@ macro_rules! implement_measurement {
         }
 
         // Multiplying `$t` by a factor is commutative
-        impl ::std::ops::Mul<$t> for f64 {
+        impl ::core::ops::Mul<$t> for f64 {
             type Output = $t;
 
             fn mul(self, rhs: $t) -> $t {
                 rhs * self
             }
         }
 
-        impl ::std::cmp::Eq for $t { }
-        impl ::std::cmp::PartialEq for $t {
+        impl ::core::cmp::Eq for $t { }
+        impl ::core::cmp::PartialEq for $t {
             fn eq(&self, other: &Self) -> bool {
                 self.as_base_units() == other.as_base_units()
             }
         }
 
-        impl ::std::cmp::PartialOrd for $t {
-            fn partial_cmp(&self, other: &Self) -> Option<::std::cmp::Ordering> {
+        impl ::core::cmp::PartialOrd for $t {
+            fn partial_cmp(&self, other: &Self) -> Option<::core::cmp::Ordering> {
                 self.as_base_units().partial_cmp(&other.as_base_units())
             }
         }

src/speed.rs

@@ -116,7 +116,7 @@ implement_measurement! { Speed }
 mod test {
     use speed::*;
     use test_utils::assert_almost_eq;
-    use std::time::Duration;
+    use time::Duration;
     use length::Length;
 
     // Metric
@@ -135,7 +135,7 @@ mod test {
     #[test]
     fn length_over_time() {
         let l1 = Length::from_meters(3.0);
-        let t1 = Duration::new(1, 500_000_000);
+        let t1 = Duration::milliseconds(1500);
         let i1 = l1 / t1;
         let r1 = i1.as_meters_per_second();
         assert_almost_eq(r1, 2.0);
@@ -144,10 +144,10 @@ mod test {
     #[test]
     fn acceleration() {
         // To get to 100 m/s at 50 m/s/s takes 2.0 seconds
-        let s = Length::from_meters(100.0) / Duration::new(1, 0);
-        let a = Length::from_meters(50.0) / Duration::new(1, 0) / Duration::new(1, 0);
+        let s = Length::from_meters(100.0) / Duration::seconds(1);
+        let a = Length::from_meters(50.0) / Duration::seconds(1) / Duration::seconds(1);
         let t = s / a;
-        assert_eq!(t, Duration::new(2, 0));
+        assert_eq!(t, Duration::seconds(2));
     }
 
     #[test]