replace use of std with core where required

Author: trappitsch

src/density.rs

@@ -73,7 +73,7 @@ impl Density {
 }
 
 // mass / volume = density
-impl ::std::ops::Div<Volume> for Mass {
+impl ::core::ops::Div<Volume> for Mass {
     type Output = Density;
 
     fn div(self, other: Volume) -> Density {
@@ -82,7 +82,7 @@ impl ::std::ops::Div<Volume> for Mass {
 }
 
 // mass / density = volume
-impl ::std::ops::Div<Density> for Mass {
+impl ::core::ops::Div<Density> for Mass {
     type Output = Volume;
 
     fn div(self, other: Density) -> Volume {
@@ -91,7 +91,7 @@ impl ::std::ops::Div<Density> for Mass {
 }
 
 // volume * density = mass
-impl ::std::ops::Mul<Density> for Volume {
+impl ::core::ops::Mul<Density> for Volume {
     type Output = Mass;
 
     fn mul(self, other: Density) -> Mass {
@@ -100,7 +100,7 @@ impl ::std::ops::Mul<Density> for Volume {
 }
 
 // density * volume = mass
-impl ::std::ops::Mul<Volume> for Density {
+impl ::core::ops::Mul<Volume> for Density {
     type Output = Mass;
 
     fn mul(self, other: Volume) -> Mass {

src/humidity.rs

@@ -163,15 +163,15 @@ impl Measurement for Humidity {
     }
 }
 
-impl ::std::cmp::Eq for Humidity {}
-impl ::std::cmp::PartialEq for Humidity {
+impl ::core::cmp::Eq for Humidity {}
+impl ::core::cmp::PartialEq for Humidity {
     fn eq(&self, other: &Self) -> bool {
         self.as_base_units() == other.as_base_units()
     }
 }
 
-impl ::std::cmp::PartialOrd for Humidity {
-    fn partial_cmp(&self, other: &Self) -> Option<::std::cmp::Ordering> {
+impl ::core::cmp::PartialOrd for Humidity {
+    fn partial_cmp(&self, other: &Self) -> Option<::core::cmp::Ordering> {
         self.as_base_units().partial_cmp(&other.as_base_units())
     }
 }

src/measurement.rs

@@ -7,12 +7,14 @@
 ///
 /// # Example
 /// ```
+/// extern crate core;
 /// // Importing the `implement_measurement` macro from the external crate is important
 /// #[macro_use]
 /// extern crate measurements;
 ///
 /// use measurements::Measurement;
 ///
+///
 /// struct Cubits {
 ///     forearms: f64
 /// }
@@ -38,9 +40,6 @@
 /// // You should't need it in your own code.
 /// fn main() { }
 /// ```
-///
-/// *Note*: If you are in a `no_std` environment, you have to
-/// `use core as std;` for the macros to run.
 pub trait Measurement {
     /// Returns a string containing the most appropriate units for this quantity,
     /// and a floating point value representing this quantity in those units.
@@ -80,13 +79,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)
@@ -103,15 +102,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 {
@@ -121,7 +120,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 {
@@ -131,7 +130,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 {
@@ -141,7 +140,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 {
@@ -150,23 +149,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/temperature.rs

@@ -159,47 +159,47 @@ impl Measurement for TemperatureDelta {
     }
 }
 
-impl ::std::ops::Add<TemperatureDelta> for Temperature {
+impl ::core::ops::Add<TemperatureDelta> for Temperature {
     type Output = Temperature;
 
     fn add(self, other: TemperatureDelta) -> Temperature {
         Temperature::from_kelvin(self.degrees_kelvin + other.kelvin_degrees)
     }
 }
 
-impl ::std::ops::Add<Temperature> for TemperatureDelta {
+impl ::core::ops::Add<Temperature> for TemperatureDelta {
     type Output = Temperature;
 
     fn add(self, other: Temperature) -> Temperature {
         other + self
     }
 }
 
-impl ::std::ops::Sub<TemperatureDelta> for Temperature {
+impl ::core::ops::Sub<TemperatureDelta> for Temperature {
     type Output = Temperature;
 
     fn sub(self, other: TemperatureDelta) -> Temperature {
         Temperature::from_kelvin(self.degrees_kelvin - other.kelvin_degrees)
     }
 }
 
-impl ::std::ops::Sub<Temperature> for Temperature {
+impl ::core::ops::Sub<Temperature> for Temperature {
     type Output = TemperatureDelta;
 
     fn sub(self, other: Temperature) -> TemperatureDelta {
         TemperatureDelta::from_kelvin(self.degrees_kelvin - other.degrees_kelvin)
     }
 }
 
-impl ::std::cmp::Eq for Temperature {}
-impl ::std::cmp::PartialEq for Temperature {
+impl ::core::cmp::Eq for Temperature {}
+impl ::core::cmp::PartialEq for Temperature {
     fn eq(&self, other: &Self) -> bool {
         self.as_base_units() == other.as_base_units()
     }
 }
 
-impl ::std::cmp::PartialOrd for Temperature {
-    fn partial_cmp(&self, other: &Self) -> Option<::std::cmp::Ordering> {
+impl ::core::cmp::PartialOrd for Temperature {
+    fn partial_cmp(&self, other: &Self) -> Option<::core::cmp::Ordering> {
         self.as_base_units().partial_cmp(&other.as_base_units())
     }
 }

src/torque_energy.rs

@@ -12,13 +12,13 @@ pub struct TorqueEnergy {
     newton_metres: f64,
 }
 
-impl std::convert::From<TorqueEnergy> for Torque {
+impl core::convert::From<TorqueEnergy> for Torque {
     fn from(t: TorqueEnergy) -> Torque {
         Torque::from_newton_metres(t.newton_metres)
     }
 }
 
-impl std::convert::From<TorqueEnergy> for Energy {
+impl core::convert::From<TorqueEnergy> for Energy {
     fn from(t: TorqueEnergy) -> Energy {
         Energy::from_joules(t.newton_metres)
     }