Use macros to implement fmt::Display.

Author: thejpster

examples/format_test.rs

@@ -6,14 +6,10 @@ use measurements::Volume;
 fn main() {
 	let t = Temperature::from_celsius(123.456);
 	let d = Length::from_meters(123.456);
-	let p = Pressure::from_pascals(123.456);
-	let v = Volume::from_cubic_meters(123.456);
+	let p = Pressure::from_millibars(123.456);
+	let v = Volume::from_litres(123.456);
 	println!("Temp of {0:.5} outside", t);
-	println!("Temp of {0:.5} C outside", t.as_celsius());
 	println!("Distance of {0:.5}", d);
-	println!("Distance of {0:.5} m", d.as_meters());
 	println!("Pressure of {0:.5}", p);
-	println!("Pressure of {0:.5} Pa", p.as_pascals());
 	println!("Volume of {0:.5}", v);
-	println!("Volume of {0:.5} m3", v.as_cubic_meters());
 }

src/length.rs

@@ -151,14 +151,11 @@ impl Measurement for Length {
     fn from_base_units(units: f64) -> Self {
         Self::from_meters(units)
     }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "m"
+    }
 }
 
 implement_measurement! { Length }
 
-impl ::std::fmt::Display for Length {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        let p = f.precision().unwrap_or(1);
-        let w = f.width().unwrap_or(0);
-        write!(f, "{value:width$.prec$}\u{00A0}m", prec=p, width=w, value=self.as_meters())
-    }
-}

src/measurement.rs

@@ -21,6 +21,10 @@
 ///     fn from_base_units(units: f64) -> Self {
 ///         Cubits { forearms: units }
 ///     }
+///
+///    fn get_base_units_name(&self) -> &'static str {
+///        "cu"
+///    }
 /// }
 ///
 /// // Invoke the macro to automatically implement Add, Sub, etc...
@@ -31,15 +35,43 @@
 /// fn main() { }
 /// ```
 pub trait Measurement {
+    fn get_appropriate_units_name(&self) -> &'static str {
+        self.get_base_units_name()
+    }
+    fn get_appropriate_units(&self) -> f64 {
+        self.get_base_units()
+    }
+    fn get_base_units_name(&self) -> &'static str;
     fn get_base_units(&self) -> f64;
     fn from_base_units(units: f64) -> Self;
 }
 
+/// This is a special macro that creates the code to implement
+/// std::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 {
+                let p = f.precision().unwrap_or(1);
+                let w = f.width().unwrap_or(0);
+                write!(f, "{value:width$.prec$}\u{00A0}{unit}",
+                    prec=p, width=w, value=self.get_appropriate_units(), unit=self.get_appropriate_units_name())
+            }
+        }
+    )*)
+}
+
+
 /// This is a special macro that creates the code to implement
 /// operator and comparison overrides.
 #[macro_export]
 macro_rules! implement_measurement {
     ($($t:ty)*) => ($(
+
+        implement_display!( $t );
+
         impl ::std::ops::Add for $t {
             type Output = Self;
 

src/pressure.rs

@@ -83,14 +83,11 @@ impl Measurement for Pressure {
     fn from_base_units(units: f64) -> Self {
         Self::from_millibars(units)
     }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "mbar"
+    }
 }
 
 implement_measurement! { Pressure }
 
-impl ::std::fmt::Display for Pressure {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        let p = f.precision().unwrap_or(1);
-        let w = f.width().unwrap_or(0);
-        write!(f, "{value:width$.prec$}\u{00A0}Pa", prec=p, width=w, value=self.as_pascals())
-    }
-}

src/temperature.rs

@@ -110,6 +110,25 @@ impl Measurement for Temperature {
     fn from_base_units(degrees_kelvin: f64) -> Self {
         Self::from_kelvin(degrees_kelvin)
     }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "K"
+    }
+
+}
+
+impl Measurement for TemperatureDelta {
+    fn get_base_units(&self) -> f64 {
+        self.kelvin_degrees
+    }
+
+    fn from_base_units(kelvin_degrees: f64) -> Self {
+        Self::from_kelvin(kelvin_degrees)
+    }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "K"
+    }
 }
 
 impl ::std::ops::Add<TemperatureDelta> for Temperature {
@@ -162,18 +181,5 @@ impl ::std::cmp::PartialOrd for TemperatureDelta {
     }
 }
 
-impl ::std::fmt::Display for Temperature {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        let p = f.precision().unwrap_or(1);
-        let w = f.width().unwrap_or(0);
-        write!(f, "{temp:width$.prec$}\u{00A0}\u{00B0}C", prec=p, width=w, temp=self.as_celsius())
-    }
-}
-
-impl ::std::fmt::Display for TemperatureDelta {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        let p = f.precision().unwrap_or(1);
-        let w = f.width().unwrap_or(0);
-        write!(f, "{temp:width$.prec$}\u{00A0}\u{00B0}C", prec=p, width=w, temp=self.as_celsius())
-    }
-}
+implement_display!( Temperature );
+implement_display!( TemperatureDelta );

src/volume.rs

@@ -205,14 +205,12 @@ impl Measurement for Volume {
     fn from_base_units(units: f64) -> Self {
         Self::from_litres(units)
     }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "l"
+    }
+
 }
 
 implement_measurement! { Volume }
 
-impl ::std::fmt::Display for Volume {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        let p = f.precision().unwrap_or(1);
-        let w = f.width().unwrap_or(0);
-        write!(f, "{volume:width$.prec$}\u{00A0}m\u{00B3}", prec=p, width=w, volume=self.as_cubic_meters())
-    }
-}

src/weight.rs

@@ -151,12 +151,12 @@ impl Measurement for Weight {
     fn from_base_units(units: f64) -> Self {
         Self::from_kilograms(units)
     }
+
+    fn get_base_units_name(&self) -> &'static str {
+        "kg"
+    }
+
 }
 
 implement_measurement! { Weight }
 
-impl ::std::fmt::Display for Weight {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        write!(f, "{:.1} kg", self.as_kilograms())
-    }
-}