Added as_fixed_point_u64 and as_fixed_point_i64 methods #79

Author: maciejhirsz

src/number.rs

@@ -42,7 +42,7 @@ impl Number {
 
     #[inline]
     pub fn is_zero(&self) -> bool {
-        self.mantissa == 0
+        self.mantissa == 0 && !self.is_nan()
     }
 
     #[inline]
@@ -52,7 +52,47 @@ impl Number {
 
     #[inline]
     pub fn is_empty(&self) -> bool {
-        self.is_zero() || self.is_nan()
+        self.mantissa == 0 || self.is_nan()
+    }
+
+    pub fn as_fixed_point_u64(&self, point: u16) -> Option<u64> {
+        if self.category != POSITIVE {
+            return None;
+        }
+
+        let e_diff = point as i16 + self.exponent;
+
+        Some(if e_diff == 0 {
+            self.mantissa
+        } else if e_diff < 0 {
+            // TODO: use cached powers
+            self.mantissa.wrapping_div(10u64.pow(-e_diff as u32))
+        } else {
+            // TODO: use cached powers
+            self.mantissa.wrapping_mul(10u64.pow(e_diff as u32))
+        })
+    }
+
+    pub fn as_fixed_point_i64(&self, point: u16) -> Option<i64> {
+        if self.is_nan() {
+            return None;
+        }
+
+        let num = if self.is_sign_positive() {
+            self.mantissa as i64
+        } else {
+            -(self.mantissa as i64)
+        };
+
+        let e_diff = point as i16 + self.exponent;
+
+        Some(if e_diff == 0 {
+            num
+        } else if e_diff < 0 {
+            num.wrapping_div(10i64.pow(-e_diff as u32))
+        } else {
+            num.wrapping_mul(10i64.pow(e_diff as u32))
+        })
     }
 }
 

src/value.rs

@@ -195,6 +195,20 @@ impl JsonValue {
         }
     }
 
+    pub fn as_fixed_point_u64(&self, point: u16) -> Option<u64> {
+        match *self {
+            JsonValue::Number(ref value) => value.as_fixed_point_u64(point),
+            _                            => None
+        }
+    }
+
+    pub fn as_fixed_point_i64(&self, point: u16) -> Option<i64> {
+        match *self {
+            JsonValue::Number(ref value) => value.as_fixed_point_i64(point),
+            _                            => None
+        }
+    }
+
     /// Take over the ownership of the value, leaving `Null` in it's place.
     ///
     /// ## Example

tests/lib.rs

@@ -58,6 +58,29 @@ mod unit {
         assert_eq!(number.as_i32(), Some(40_000));
     }
 
+    #[test]
+    fn as_fixed_point() {
+        let number = JsonValue::from(3.14);
+
+        assert_eq!(number.as_fixed_point_u64(4).unwrap(), 31400_u64);
+        assert_eq!(number.as_fixed_point_u64(2).unwrap(), 314_u64);
+        assert_eq!(number.as_fixed_point_u64(0).unwrap(), 3_u64);
+
+        assert_eq!(number.as_fixed_point_i64(4).unwrap(), 31400_i64);
+        assert_eq!(number.as_fixed_point_i64(2).unwrap(), 314_i64);
+        assert_eq!(number.as_fixed_point_i64(0).unwrap(), 3_i64);
+
+        let number = JsonValue::from(-3.14);
+
+        assert_eq!(number.as_fixed_point_u64(4), None);
+        assert_eq!(number.as_fixed_point_u64(2), None);
+        assert_eq!(number.as_fixed_point_u64(0), None);
+
+        assert_eq!(number.as_fixed_point_i64(4).unwrap(), -31400_i64);
+        assert_eq!(number.as_fixed_point_i64(2).unwrap(), -314_i64);
+        assert_eq!(number.as_fixed_point_i64(0).unwrap(), -3_i64);
+    }
+
     #[test]
     fn is_as_boolean() {
         let boolean = JsonValue::Boolean(true);
@@ -1261,6 +1284,30 @@ mod json_checker_pass {
 
 mod number {
     use super::json::number::Number;
+    use std::f64;
+
+    #[test]
+    fn is_nan() {
+        assert!(Number::from(f64::NAN).is_nan());
+    }
+
+    #[test]
+    fn is_zero() {
+        assert!(Number::from(0).is_zero());
+        assert!(Number::from_parts(true, 0, 0).is_zero());
+        assert!(Number::from_parts(true, 0, 100).is_zero());
+        assert!(Number::from_parts(true, 0, -100).is_zero());
+        assert!(Number::from_parts(false, 0, 0).is_zero());
+        assert!(Number::from_parts(false, 0, 100).is_zero());
+        assert!(Number::from_parts(false, 0, -100).is_zero());
+        assert!(!Number::from(f64::NAN).is_zero());
+    }
+
+    #[test]
+    fn is_empty() {
+        assert!(Number::from(0).is_empty());
+        assert!(Number::from(f64::NAN).is_empty());
+    }
 
     #[test]
     fn eq() {
@@ -1328,4 +1375,32 @@ mod number {
 
         assert_eq!(f64::from(number), 2.225073858507201e-308);
     }
+
+    #[test]
+    fn as_fixed_point_u64() {
+        assert_eq!(Number::from(1.2345).as_fixed_point_u64(4).unwrap(), 12345);
+        assert_eq!(Number::from(1.2345).as_fixed_point_u64(2).unwrap(), 123);
+        assert_eq!(Number::from(1.2345).as_fixed_point_u64(0).unwrap(), 1);
+
+        assert_eq!(Number::from(5).as_fixed_point_u64(0).unwrap(), 5);
+        assert_eq!(Number::from(5).as_fixed_point_u64(2).unwrap(), 500);
+        assert_eq!(Number::from(5).as_fixed_point_u64(4).unwrap(), 50000);
+
+        assert_eq!(Number::from(-1).as_fixed_point_u64(0), None);
+        assert_eq!(Number::from(f64::NAN).as_fixed_point_u64(0), None);
+    }
+
+    #[test]
+    fn as_fixed_point_i64() {
+        assert_eq!(Number::from(-1.2345).as_fixed_point_i64(4).unwrap(), -12345);
+        assert_eq!(Number::from(-1.2345).as_fixed_point_i64(2).unwrap(), -123);
+        assert_eq!(Number::from(-1.2345).as_fixed_point_i64(0).unwrap(), -1);
+
+        assert_eq!(Number::from(-5).as_fixed_point_i64(0).unwrap(), -5);
+        assert_eq!(Number::from(-5).as_fixed_point_i64(2).unwrap(), -500);
+        assert_eq!(Number::from(-5).as_fixed_point_i64(4).unwrap(), -50000);
+
+        assert_eq!(Number::from(-1).as_fixed_point_i64(0), Some(-1));
+        assert_eq!(Number::from(f64::NAN).as_fixed_point_i64(0), None);
+    }
 }