Add support to create AngularVelocity from string

Again behind the from_str feature. Tests included.

Author: drodil

src/angular_velocity.rs

@@ -1,7 +1,11 @@
 //! Types and constants for handling speed of rotation (angular velocity)
 
 use super::measurement::*;
-use ::PI;
+#[cfg(feature = "from_str")]
+use regex::Regex;
+#[cfg(feature = "from_str")]
+use std::str::FromStr;
+use PI;
 
 /// The 'AngularVelocity' struct can be used to deal with angular velocities in a common way.
 ///
@@ -69,6 +73,36 @@ impl Measurement for AngularVelocity {
     }
 }
 
+#[cfg(feature = "from_str")]
+impl FromStr for AngularVelocity {
+    type Err = std::num::ParseFloatError;
+
+    /// Create a new AngularVelocity from a string
+    /// Plain numbers in string are considered to be radians per second
+    fn from_str(val: &str) -> Result<Self, Self::Err> {
+        if val.is_empty() {
+            return Ok(AngularVelocity::from_radians_per_second(0.0));
+        }
+
+        let re = Regex::new(r"(?i)\s*([0-9.]*)\s?([radspmhz/]{1,5})\s*$").unwrap();
+        if let Some(caps) = re.captures(val) {
+            let float_val = caps.get(1).unwrap().as_str();
+            return Ok(
+                match caps.get(2).unwrap().as_str().to_lowercase().as_str() {
+                    "rad/s" => AngularVelocity::from_radians_per_second(float_val.parse::<f64>()?),
+                    "rpm" => AngularVelocity::from_rpm(float_val.parse::<f64>()?),
+                    "hz" => AngularVelocity::from_hertz(float_val.parse::<f64>()?),
+                    _ => AngularVelocity::from_radians_per_second(val.parse::<f64>()?),
+                },
+            );
+        }
+
+        Ok(AngularVelocity::from_radians_per_second(
+            val.parse::<f64>()?,
+        ))
+    }
+}
+
 implement_measurement! { AngularVelocity }
 
 #[cfg(test)]
@@ -85,4 +119,51 @@ mod test {
         assert_almost_eq(r1, 628.31853);
         assert_almost_eq(r2, 954.929659642538);
     }
+
+    #[test]
+    #[cfg(feature = "from_str")]
+    fn empty_str() {
+        let t = AngularVelocity::from_str("");
+        assert!(t.is_ok());
+
+        let o = t.unwrap().as_radians_per_second();
+        assert_eq!(o, 0.0);
+    }
+
+    #[test]
+    #[cfg(feature = "from_str")]
+    fn rad_per_second_string() {
+        let t = AngularVelocity::from_str("100 rad/s");
+        assert!(t.is_ok());
+
+        let o = t.unwrap().as_radians_per_second();
+        assert_almost_eq(o, 100.0);
+    }
+
+    #[test]
+    #[cfg(feature = "from_str")]
+    fn rpm_string() {
+        let t = AngularVelocity::from_str("100rpm");
+        assert!(t.is_ok());
+
+        let o = t.unwrap().as_rpm();
+        assert_almost_eq(o, 100.0);
+    }
+
+    #[test]
+    #[cfg(feature = "from_str")]
+    fn hertz_string() {
+        let t = AngularVelocity::from_str("100 Hz");
+        assert!(t.is_ok());
+
+        let o = t.unwrap().as_hertz();
+        assert_almost_eq(o, 100.0);
+    }
+
+    #[test]
+    #[cfg(feature = "from_str")]
+    fn invalid_str() {
+        let t = AngularVelocity::from_str("abcd");
+        assert!(t.is_err());
+    }
 }