0.6.1 sort out type casting helpers (#9)

Author: maciejhirsz

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "json"
-version = "0.6.0"
+version = "0.6.1"
 authors = ["Maciej Hirsz <[email protected]>"]
 description = "JSON implementation in Rust"
 repository = "https://github.com/maciejhirsz/json-rust"

src/lib.rs

@@ -296,7 +296,7 @@ macro_rules! object {
 
 macro_rules! implement_extras {
     ($from:ty) => {
-        impl From<Option<$from>> for JsonValue{
+        impl From<Option<$from>> for JsonValue {
             fn from(val: Option<$from>) -> JsonValue {
                 match val {
                     Some(value) => value.into(),
@@ -305,7 +305,7 @@ macro_rules! implement_extras {
             }
         }
 
-        impl From<Vec<$from>> for JsonValue{
+        impl From<Vec<$from>> for JsonValue {
             fn from(mut val: Vec<$from>) -> JsonValue {
                 JsonValue::Array(val.drain(..)
                     .map(|value| value.into())

src/value.rs

@@ -2,6 +2,27 @@ use std::collections::BTreeMap;
 use std::ops::{ Index, IndexMut };
 use iterators::{ Members, MembersMut, Entries, EntriesMut };
 use { JsonResult, JsonError };
+use std::{ usize, u8, u16, u32, u64, isize, i8, i16, i32, i64, f32 };
+
+macro_rules! f64_to_unsinged {
+    ($unsigned:ident, $value:expr) => {
+        if $value < 0.0 || $value > $unsigned::MAX as f64 {
+            None
+        } else {
+            Some($value as $unsigned)
+        }
+    }
+}
+
+macro_rules! f64_to_singed {
+    ($signed:ident, $value:expr) => {
+        if $value < $signed::MIN as f64 || $value > $signed::MAX as f64 {
+            None
+        } else {
+            Some($value as $signed)
+        }
+    }
+}
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum JsonValue {
@@ -40,41 +61,111 @@ impl JsonValue {
         }
     }
 
+    /// Deprecated because the return type is planned to change to
+    /// `Option<String>` eventually down the road.
+    #[deprecated(since="0.6.1", note="Use `as_str` instead")]
     pub fn as_string(&self) -> JsonResult<&String> {
         match *self {
             JsonValue::String(ref value) => Ok(value),
             _ => Err(JsonError::wrong_type("String"))
         }
     }
 
+    pub fn as_str(&self) -> Option<&str> {
+        match *self {
+            JsonValue::String(ref value) => Some(value.as_ref()),
+            _                            => None
+        }
+    }
+
     pub fn is_number(&self) -> bool {
         match *self {
             JsonValue::Number(_) => true,
             _                    => false,
         }
     }
 
+    #[deprecated(since="0.6.1", note="Use `as_f64` instead")]
     pub fn as_number(&self) -> JsonResult<&f64> {
         match *self {
             JsonValue::Number(ref value) => Ok(value),
             _ => Err(JsonError::wrong_type("Number"))
         }
     }
 
+    pub fn as_f64(&self) -> Option<f64> {
+        match *self {
+            JsonValue::Number(ref value) => Some(*value),
+            _                            => None
+        }
+    }
+
+    pub fn as_f32(&self) -> Option<f32> {
+        self.as_f64().and_then(|value| f64_to_singed!(f32, value))
+    }
+
+    pub fn as_u64(&self) -> Option<u64> {
+        self.as_f64().and_then(|value| f64_to_unsinged!(u64, value))
+    }
+
+    pub fn as_u32(&self) -> Option<u32> {
+        self.as_f64().and_then(|value| f64_to_unsinged!(u32, value))
+    }
+
+    pub fn as_u16(&self) -> Option<u16> {
+        self.as_f64().and_then(|value| f64_to_unsinged!(u16, value))
+    }
+
+    pub fn as_u8(&self) -> Option<u8> {
+        self.as_f64().and_then(|value| f64_to_unsinged!(u8, value))
+    }
+
+    pub fn as_usize(&self) -> Option<usize> {
+        self.as_f64().and_then(|value| f64_to_unsinged!(usize, value))
+    }
+
+    pub fn as_i64(&self) -> Option<i64> {
+        self.as_f64().and_then(|value| f64_to_singed!(i64, value))
+    }
+
+    pub fn as_i32(&self) -> Option<i32> {
+        self.as_f64().and_then(|value| f64_to_singed!(i32, value))
+    }
+
+    pub fn as_i16(&self) -> Option<i16> {
+        self.as_f64().and_then(|value| f64_to_singed!(i16, value))
+    }
+
+    pub fn as_i8(&self) -> Option<i8> {
+        self.as_f64().and_then(|value| f64_to_singed!(i8, value))
+    }
+
+    pub fn as_isize(&self) -> Option<isize> {
+        self.as_f64().and_then(|value| f64_to_singed!(isize, value))
+    }
+
     pub fn is_boolean(&self) -> bool {
         match *self {
             JsonValue::Boolean(_) => true,
             _                     => false
         }
     }
 
+    #[deprecated(since="0.6.1", note="Unnecessary, use `as_bool` instead")]
     pub fn as_boolean(&self) -> JsonResult<&bool> {
         match *self {
             JsonValue::Boolean(ref value) => Ok(value),
             _ => Err(JsonError::wrong_type("Boolean"))
         }
     }
 
+    pub fn as_bool(&self) -> Option<bool> {
+        match *self {
+            JsonValue::Boolean(ref value) => Some(*value),
+            _                             => None
+        }
+    }
+
     pub fn is_null(&self) -> bool {
         match *self {
             JsonValue::Null => true,

tests/lib.rs

@@ -7,26 +7,58 @@ use json::{ stringify, stringify_pretty, parse, JsonValue, Null };
 
 #[test]
 fn is_as_string() {
-    let string = JsonValue::String("foo".to_string());
+    let string = JsonValue::from("foo");
 
     assert!(string.is_string());
-    assert_eq!(*string.as_string().unwrap(), "foo".to_string());
+    assert_eq!(string.as_str().unwrap(), "foo");
 }
 
 #[test]
 fn is_as_number() {
-    let number = JsonValue::Number(42.0);
+    let number = JsonValue::from(42);
 
     assert!(number.is_number());
-    assert_eq!(*number.as_number().unwrap(), 42.0);
+    assert_eq!(number.as_f64().unwrap(), 42.0f64);
+    assert_eq!(number.as_f32().unwrap(), 42.0f32);
+    assert_eq!(number.as_u64().unwrap(), 42u64);
+    assert_eq!(number.as_u32().unwrap(), 42u32);
+    assert_eq!(number.as_u16().unwrap(), 42u16);
+    assert_eq!(number.as_u8().unwrap(), 42u8);
+    assert_eq!(number.as_usize().unwrap(), 42usize);
+    assert_eq!(number.as_i64().unwrap(), 42i64);
+    assert_eq!(number.as_i32().unwrap(), 42i32);
+    assert_eq!(number.as_i16().unwrap(), 42i16);
+    assert_eq!(number.as_i8().unwrap(), 42i8);
+    assert_eq!(number.as_isize().unwrap(), 42isize);
+
+    let number = JsonValue::from(-1);
+
+    assert_eq!(number.as_u64(), None);
+    assert_eq!(number.as_u32(), None);
+    assert_eq!(number.as_u16(), None);
+    assert_eq!(number.as_u8(), None);
+    assert_eq!(number.as_usize(), None);
+    assert_eq!(number.as_i64(), Some(-1));
+    assert_eq!(number.as_i32(), Some(-1));
+    assert_eq!(number.as_i16(), Some(-1));
+    assert_eq!(number.as_i8(), Some(-1));
+    assert_eq!(number.as_isize(), Some(-1));
+
+    let number = JsonValue::from(40_000);
+
+    assert_eq!(number.as_u8(), None);
+    assert_eq!(number.as_u16(), Some(40_000));
+    assert_eq!(number.as_i8(), None);
+    assert_eq!(number.as_i16(), None);
+    assert_eq!(number.as_i32(), Some(40_000));
 }
 
 #[test]
 fn is_as_boolean() {
     let boolean = JsonValue::Boolean(true);
 
     assert!(boolean.is_boolean());
-    assert_eq!(*boolean.as_boolean().unwrap(), true);
+    assert_eq!(boolean.as_bool().unwrap(), true);
 }
 
 #[test]