Added weight conversion. Doesn't have tests or docs yet.

Author: James O'Cull

src/length.rs

@@ -25,56 +25,56 @@ pub struct Length {
 
 impl Length {
     // Inputs, metric
-    pub fn from_meters(meters: f64) -> Length {
+    pub fn from_meters(meters: f64) -> Self {
         Length { meters: meters }
     }
 
-    pub fn from_nanometers(nanometers: f64) -> Length {
+    pub fn from_nanometers(nanometers: f64) -> Self {
         Self::from_meters(nanometers / METER_NANOMETER_FACTOR)
     }
 
-    pub fn from_micrometers(micrometers: f64) -> Length {
+    pub fn from_micrometers(micrometers: f64) -> Self {
         Self::from_meters(micrometers / METER_MICROMETER_FACTOR)
     }
 
-    pub fn from_millimeters(millimeters: f64) -> Length {
+    pub fn from_millimeters(millimeters: f64) -> Self {
         Self::from_meters(millimeters / METER_MILLIMETER_FACTOR)
     }
 
-    pub fn from_centimeters(centimeters: f64) -> Length {
+    pub fn from_centimeters(centimeters: f64) -> Self {
         Self::from_meters(centimeters / METER_CENTIMETER_FACTOR)
     }
 
-    pub fn from_decameters(decameters: f64) -> Length {
+    pub fn from_decameters(decameters: f64) -> Self {
         Self::from_meters(decameters / METER_DECAMETER_FACTOR)
     }
 
-    pub fn from_hectometers(hectometers: f64) -> Length {
+    pub fn from_hectometers(hectometers: f64) -> Self {
         Self::from_meters(hectometers / METER_HECTOMETER_FACTOR)
     }
 
-    pub fn from_kilometers(kilometers: f64) -> Length {
+    pub fn from_kilometers(kilometers: f64) -> Self {
         Self::from_meters(kilometers / METER_KILOMETER_FACTOR)
     }
 
     // Inputs, imperial
-    pub fn from_inches(inches: f64) -> Length {
+    pub fn from_inches(inches: f64) -> Self {
         Self::from_meters(inches / METER_INCH_FACTOR)
     }
 
-    pub fn from_feet(feet: f64) -> Length {
+    pub fn from_feet(feet: f64) -> Self {
         Self::from_meters(feet / METER_FEET_FACTOR)
     }
 
-    pub fn from_yards(yards: f64) -> Length {
+    pub fn from_yards(yards: f64) -> Self {
         Self::from_meters(yards / METER_YARD_FACTOR)
     }
 
-    pub fn from_furlongs(furlongs: f64) -> Length {
+    pub fn from_furlongs(furlongs: f64) -> Self {
         Self::from_meters(furlongs / METER_FURLONG_FACTOR)
     }
 
-    pub fn from_miles(miles: f64) -> Length {
+    pub fn from_miles(miles: f64) -> Self {
         Self::from_meters(miles / METER_MILE_FACTOR)
     }
 

src/lib.rs

@@ -38,7 +38,6 @@ pub mod measurement;
 /// let meters = football_field.as_meters();
 /// println!("There are {} meters in a football field.", meters);
 /// ```
-
 #[allow(dead_code)]
 pub mod length;
 
@@ -53,10 +52,14 @@ pub mod length;
 /// let fahrenheit = boiling_water.as_fahrenheit();
 /// println!("Boiling water measures at {} degrees fahrenheit.", fahrenheit);
 /// ```
-
 #[allow(dead_code)]
 pub mod temperature;
 
+/// TODO: Provide docs and examples for this.
+/// 
+#[allow(dead_code)]
+pub mod weight;
+
 // Include when running tests, but don't export them
 #[cfg(test)]
 mod tests;

src/temperature.rs

@@ -7,19 +7,19 @@ pub struct Temperature {
 }
 
 impl Temperature {
-    pub fn from_kelvin(kelvin: f64) -> Temperature {
+    pub fn from_kelvin(kelvin: f64) -> Self {
         Temperature { kelvin: kelvin }
     }
 
-    pub fn from_celsius(celsius: f64) -> Temperature {
+    pub fn from_celsius(celsius: f64) -> Self {
         Self::from_kelvin(celsius + 273.15)
     }
 
-    pub fn from_fahrenheit(fahrenheit: f64) -> Temperature {
+    pub fn from_fahrenheit(fahrenheit: f64) -> Self {
         Self::from_kelvin((fahrenheit - 32.0) / 1.8 + 273.15)
     }
 
-    pub fn from_rankine(rankine: f64) -> Temperature {
+    pub fn from_rankine(rankine: f64) -> Self {
         Self::from_kelvin((rankine - 491.67) / 1.8 + 273.15)
     }
 

src/weight.rs

@@ -0,0 +1,145 @@
+use super::measurement::*;
+
+/// The `Weight` struct can be used to deal with weights in a common way.
+#[derive(Copy, Clone, Debug)]
+pub struct Weight {
+    kilograms: f64
+}
+
+impl Weight {
+    // Inputs, metric
+    pub fn from_kilograms(kilograms: f64) -> Self {
+        Weight { kilograms: kilograms }
+    }
+    
+    pub fn from_micrograms(micrograms: f64) -> Self {
+        Self::from_kilograms(micrograms / 1000000000.0)
+    }
+    
+    pub fn from_milligrams(milligrams: f64) -> Self {
+        Self::from_kilograms(milligrams / 1000000.0)
+    }
+    
+    pub fn from_carats(carats: f64) -> Self {
+        Self::from_kilograms(carats / 5000.0)
+    }
+    
+    pub fn from_grams(grams: f64) -> Self {
+        Self::from_kilograms(grams / 1000.0)
+    }
+    
+    pub fn from_metric_tons(metric_tons: f64) -> Self {
+        Self::from_kilograms(metric_tons * 1000.0)
+    }
+    
+    // Inputs, imperial
+    pub fn from_grains(grains: f64) -> Self {
+        Self::from_kilograms(grains / 15432.358)
+    }
+    
+    pub fn from_pennyweights(pennyweights: f64) -> Self {
+        Self::from_kilograms(pennyweights / 643.01493)
+    }
+    
+    pub fn from_ounces(ounces: f64) -> Self {
+        Self::from_kilograms(ounces / 35.273962)
+    }
+    
+    pub fn from_troy_ounces(troy_ounces: f64) -> Self {
+        Self::from_kilograms(troy_ounces / 32.150747)
+    }
+    
+    pub fn from_pounds(pounds: f64) -> Self {
+        Self::from_kilograms(pounds / 2.2046228)
+    }
+    
+    pub fn from_troy_pounds(troy_pounds: f64) -> Self {
+        Self::from_kilograms(troy_pounds / 2.6792289)
+    }
+    
+    pub fn from_stones(stones: f64) -> Self {
+        Self::from_kilograms(stones / 0.15747304)
+    }
+    
+    pub fn from_short_tons(short_tons: f64) -> Self {
+        Self::from_short_tons(short_tons * 907.18475)
+    }
+    
+    pub fn from_long_tons(long_tons: f64) -> Self {
+        Self::from_kilograms(long_tons * 1016.0469)
+    }
+    
+    // Outputs, metric
+    pub fn as_micrograms(&self) -> f64 {
+        self.kilograms * 1000000000.0
+    }
+    
+    pub fn as_milligrams(&self) -> f64 {
+        self.kilograms * 1000000.0
+    }
+    
+    pub fn as_carats(&self) -> f64 {
+        self.kilograms * 5000.0
+    }
+    
+    pub fn as_grams(&self) -> f64 {
+        self.kilograms * 1000.0
+    }
+    
+    pub fn as_kilograms(&self) -> f64 {
+        self.kilograms
+    }
+    
+    pub fn as_metric_tons(&self) -> f64 {
+        self.kilograms / 1000.0
+    }
+    
+    // Outputs, imperial
+    pub fn as_grains(&self) -> f64 {
+        self.kilograms * 15432.358
+    }
+    
+    pub fn as_pennyweights(&self) -> f64 {
+        self.kilograms * 643.01493
+    }
+    
+    pub fn as_ounces(&self) -> f64 {
+        self.kilograms * 35.273962
+    }
+    
+    pub fn as_pounds(&self) -> f64 {
+        self.kilograms * 2.2046228
+    }
+    
+    pub fn as_troy_ounces(&self) -> f64 {
+        self.kilograms * 32.150747
+    }
+    
+    pub fn as_troy_pounds(&self) -> f64 {
+        self.kilograms * 2.6792289
+    }
+    
+    pub fn as_stones(&self) -> f64 {
+        self.kilograms * 0.15747304
+    }
+    
+    pub fn as_short_tons(&self) -> f64 {
+        self.kilograms / 907.18475
+    }
+    
+    pub fn as_long_tons(&self) -> f64 {
+        self.kilograms / 1016.0469
+    }
+}
+
+impl Measurement for Weight {
+    fn get_base_units(&self) -> f64 {
+        self.kilograms
+    }
+    
+    fn from_base_units(units: f64) -> Self {
+        Self::from_kilograms(units)
+    }
+}
+
+implement_measurement! { Weight }