Added Pressure.

Implement std::fmt::Display using SI units.

Also removed trailing whitespace.

Author: thejpster

src/length.rs

@@ -18,12 +18,12 @@ const METER_MILE_FACTOR: f64 = 0.000621371192237;
 
 /// The `Length` struct can be used to deal with lengths in a common way.
 /// Common metric and imperial units are supported.
-/// 
+///
 /// # Example
-/// 
+///
 /// ```
 /// use measurements::Length;
-/// 
+///
 /// let football_field = Length::from_yards(100.0);
 /// let meters = football_field.as_meters();
 /// println!("There are {} meters in a football field.", meters);
@@ -38,106 +38,106 @@ impl Length {
     pub fn from_meters(meters: f64) -> Self {
         Length { meters: meters }
     }
-    
+
     pub fn from_nanometers(nanometers: f64) -> Self {
         Self::from_meters(nanometers / METER_NANOMETER_FACTOR)
     }
-    
+
     pub fn from_micrometers(micrometers: f64) -> Self {
         Self::from_meters(micrometers / METER_MICROMETER_FACTOR)
     }
-    
+
     pub fn from_millimeters(millimeters: f64) -> Self {
         Self::from_meters(millimeters / METER_MILLIMETER_FACTOR)
     }
-    
+
     pub fn from_centimeters(centimeters: f64) -> Self {
         Self::from_meters(centimeters / METER_CENTIMETER_FACTOR)
     }
-    
+
     pub fn from_decameters(decameters: f64) -> Self {
         Self::from_meters(decameters / METER_DECAMETER_FACTOR)
     }
-    
+
     pub fn from_hectometers(hectometers: f64) -> Self {
         Self::from_meters(hectometers / METER_HECTOMETER_FACTOR)
     }
-    
+
     pub fn from_kilometers(kilometers: f64) -> Self {
         Self::from_meters(kilometers / METER_KILOMETER_FACTOR)
     }
-    
+
     // Inputs, imperial
     pub fn from_inches(inches: f64) -> Self {
         Self::from_meters(inches / METER_INCH_FACTOR)
     }
-    
+
     pub fn from_feet(feet: f64) -> Self {
         Self::from_meters(feet / METER_FEET_FACTOR)
     }
-    
+
     pub fn from_yards(yards: f64) -> Self {
         Self::from_meters(yards / METER_YARD_FACTOR)
     }
-    
+
     pub fn from_furlongs(furlongs: f64) -> Self {
         Self::from_meters(furlongs / METER_FURLONG_FACTOR)
     }
-    
+
     pub fn from_miles(miles: f64) -> Self {
         Self::from_meters(miles / METER_MILE_FACTOR)
     }
-    
+
     // Outputs, metric
     pub fn as_nanometers(&self) -> f64 {
         self.meters * METER_NANOMETER_FACTOR
     }
-    
+
     pub fn as_micrometers(&self) -> f64 {
         self.meters * METER_MICROMETER_FACTOR
     }
-    
+
     pub fn as_millimeters(&self) -> f64 {
         self.meters * METER_MILLIMETER_FACTOR
     }
-    
+
     pub fn as_centimeters(&self) -> f64 {
         self.meters * METER_CENTIMETER_FACTOR
     }
-    
+
     pub fn as_meters(&self) -> f64 {
         self.meters
     }
-    
+
     pub fn as_decameters(&self) -> f64 {
         self.meters * METER_DECAMETER_FACTOR
     }
-    
+
     pub fn as_hectometer(&self) -> f64 {
         self.meters * METER_HECTOMETER_FACTOR
     }
-    
+
     pub fn as_kilometers(&self) -> f64 {
         self.meters * METER_KILOMETER_FACTOR
     }
-    
+
     // Outputs, imperial
     pub fn as_inches(&self) -> f64 {
         self.meters * METER_INCH_FACTOR
     }
-    
+
     pub fn as_feet(&self) -> f64 {
         self.meters * METER_FEET_FACTOR
     }
-    
+
     pub fn as_yards(&self) -> f64 {
         self.meters * METER_YARD_FACTOR
     }
-    
+
     pub fn as_furlongs(&self) -> f64 {
         self.meters * METER_FURLONG_FACTOR
     }
-    
+
     pub fn as_miles(&self) -> f64 {
         self.meters * METER_MILE_FACTOR
     }
@@ -147,10 +147,16 @@ impl Measurement for Length {
     fn get_base_units(&self) -> f64 {
         self.meters
     }
-    
+
     fn from_base_units(units: f64) -> Self {
         Self::from_meters(units)
     }
 }
 
 implement_measurement! { Length }
+
+impl ::std::fmt::Display for Length {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "{:.1} m", self.as_meters())
+    }
+}

src/lib.rs

@@ -18,6 +18,10 @@ pub use weight::Weight;
 mod volume;
 pub use volume::Volume;
 
+#[allow(dead_code)]
+mod pressure;
+pub use pressure::Pressure;
+
 // Include when running tests, but don't export them
 #[cfg(test)]
 #[allow(dead_code)]

src/measurement.rs

@@ -1,23 +1,23 @@
 /// The `Measurement` trait and the `implement_measurement!` macro
 /// provides a common way for various measurements to be implemented.
-/// 
+///
 /// # Example
 /// ```
 /// // Importing the `implement_measurement` macro from the external crate is important
 /// #[macro_use]
 /// extern crate measurements;
-/// 
+///
 /// use measurements::Measurement;
-/// 
+///
 /// struct Cubits {
 ///     forearms: f64
 /// }
-/// 
+///
 /// impl Measurement for Cubits {
 ///     fn get_base_units(&self) -> f64 {
 ///         self.forearms
 ///     }
-///     
+///
 ///     fn from_base_units(units: f64) -> Self {
 ///         Cubits { forearms: units }
 ///     }
@@ -42,59 +42,59 @@ macro_rules! implement_measurement {
     ($($t:ty)*) => ($(
         impl ::std::ops::Add for $t {
             type Output = Self;
-            
+
             fn add(self, rhs: Self) -> Self {
                 Self::from_base_units(self.get_base_units() + rhs.get_base_units())
             }
         }
 
         impl ::std::ops::Sub for $t {
             type Output = Self;
-            
+
             fn sub(self, rhs: Self) -> Self {
                 Self::from_base_units(self.get_base_units() - rhs.get_base_units())
             }
         }
 
-        /// 
+        ///
         /// Dividing a `$t` by another `$` returns a ratio.
-        /// 
+        ///
         impl ::std::ops::Div<$t> for $t {
             type Output = f64;
-            
+
             fn div(self, rhs: Self) -> f64 {
                 self.get_base_units() / rhs.get_base_units()
             }
         }
 
-        /// 
+        ///
         /// Dividing a `$` by a factor returns a new portion of the measurement.
-        /// 
+        ///
         impl ::std::ops::Div<f64> for $t {
             type Output = Self;
-            
+
             fn div(self, rhs: f64) -> Self {
                 Self::from_base_units(self.get_base_units() / rhs)
             }
         }
 
-        /// 
+        ///
         /// Multiplying a `$t` by another `$t` returns the product of those measurements.
-        /// 
+        ///
         impl ::std::ops::Mul<$t> for $t {
             type Output = Self;
-            
+
             fn mul(self, rhs: Self) -> Self {
                 Self::from_base_units(self.get_base_units() * rhs.get_base_units())
             }
         }
 
-        /// 
+        ///
         /// Multiplying a `$t` by a factor increases (or decreases) that measurement a number of times.
-        /// 
+        ///
         impl ::std::ops::Mul<f64> for $t {
             type Output = Self;
-            
+
             fn mul(self, rhs: f64) -> Self {
                 Self::from_base_units(self.get_base_units() * rhs)
             }

src/pressure.rs

@@ -0,0 +1,94 @@
+use super::measurement::*;
+
+/// The `Pressure` struct can be used to deal with presssures in a common way.
+/// Common metric and imperial units are supported.
+///
+/// # Example
+///
+/// ```
+/// use measurements::Pressure;
+///
+/// let earth = Pressue::from_atmospheres(1.0);
+/// let mbar = earth.as_mbar();
+/// println!("Atmospheric pressure is {} mbar.", mbar);
+/// ```
+#[derive(Copy, Clone, Debug)]
+pub struct Pressure {
+    millibars: f64
+}
+
+impl Pressure {
+    pub fn from_hectopascals(hectopascals: f64) -> Pressure {
+        Self::from_millibars(hectopascals)
+    }
+
+    pub fn from_pascals(pascals: f64) -> Pressure {
+        Self::from_hectopascals(pascals * 100.0)
+    }
+
+    pub fn from_kilopascals(kilopascals: f64) -> Pressure {
+        Self::from_hectopascals(kilopascals / 10.0)
+    }
+
+    pub fn from_millibars(millibars: f64) -> Pressure {
+        Pressure { millibars: millibars }
+    }
+
+    pub fn from_bars(bars: f64) -> Pressure {
+        Self::from_millibars(bars * 1000.0)
+    }
+
+    pub fn from_psi(psi: f64) -> Pressure {
+        Self::from_millibars(psi / 0.0145038)
+    }
+
+    pub fn from_atmospheres(atmospheres: f64) -> Pressure {
+        Self::from_millibars(atmospheres * 1013.25)
+    }
+
+    pub fn as_hectopascals(&self) -> f64 {
+        self.millibars
+    }
+
+    pub fn as_pascals(&self) -> f64 {
+        self.millibars * 100.0
+    }
+
+    pub fn as_kilopascals(&self) -> f64 {
+        self.millibars / 10.0
+    }
+
+    pub fn as_millibars(&self) -> f64 {
+        self.millibars
+    }
+
+    pub fn as_bars(&self) -> f64 {
+        self.millibars / 1000.0
+    }
+
+    pub fn as_psi(&self) -> f64 {
+        self.millibars * 0.0145038
+    }
+
+    pub fn as_atmospheres(&self) -> f64 {
+        self.millibars / 1013.25
+    }
+}
+
+impl Measurement for Pressure {
+    fn get_base_units(&self) -> f64 {
+        self.millibars
+    }
+
+    fn from_base_units(units: f64) -> Self {
+        Self::from_millibars(units)
+    }
+}
+
+implement_measurement! { Pressure }
+
+impl ::std::fmt::Display for Pressure {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        write!(f, "{:.1} Pa", self.as_pascals())
+    }
+}