Return empty iterators, again #64

Author: maciejhirsz

src/object.rs

@@ -500,6 +500,15 @@ pub struct Iter<'a> {
     inner: slice::Iter<'a, Node>
 }
 
+impl<'a> Iter<'a> {
+    /// Create an empty iterator that always returns `None`
+    pub fn empty() -> Self {
+        Iter {
+            inner: [].iter()
+        }
+    }
+}
+
 impl<'a> Iterator for Iter<'a> {
     type Item = (&'a str, &'a JsonValue);
 
@@ -520,6 +529,15 @@ pub struct IterMut<'a> {
     inner: slice::IterMut<'a, Node>
 }
 
+impl<'a> IterMut<'a> {
+    /// Create an empty iterator that always returns `None`
+    pub fn empty() -> Self {
+        IterMut {
+            inner: [].iter_mut()
+        }
+    }
+}
+
 impl<'a> Iterator for IterMut<'a> {
     type Item = (&'a str, &'a mut JsonValue);
 

src/value.rs

@@ -287,43 +287,47 @@ impl JsonValue {
     }
 
     /// Works on `JsonValue::Array` - returns an iterator over members.
-    pub fn members(&self) -> Option<Members> {
+    /// Will return an empty iterator if called on non-array types.
+    pub fn members(&self) -> Members {
         match *self {
             JsonValue::Array(ref vec) => {
-                Some(vec.iter())
+                vec.iter()
             },
-            _ => None
+            _ => [].iter()
         }
     }
 
     /// Works on `JsonValue::Array` - returns a mutable iterator over members.
-    pub fn members_mut(&mut self) -> Option<MembersMut> {
+    /// Will return an empty iterator if called on non-array types.
+    pub fn members_mut(&mut self) -> MembersMut {
         match *self {
             JsonValue::Array(ref mut vec) => {
-                Some(vec.iter_mut())
+                vec.iter_mut()
             },
-            _ => None
+            _ => [].iter_mut()
         }
     }
 
     /// Works on `JsonValue::Object` - returns an iterator over key value pairs.
-    pub fn entries(&self) -> Option<Entries> {
+    /// Will return an empty iterator if called on non-object types.
+    pub fn entries(&self) -> Entries {
         match *self {
             JsonValue::Object(ref object) => {
-                Some(object.iter())
+                object.iter()
             },
-            _ => None
+            _ => Entries::empty()
         }
     }
 
     /// Works on `JsonValue::Object` - returns a mutable iterator over
     /// key value pairs.
-    pub fn entries_mut(&mut self) -> Option<EntriesMut> {
+    /// Will return an empty iterator if called on non-object types.
+    pub fn entries_mut(&mut self) -> EntriesMut {
         match *self {
             JsonValue::Object(ref mut object) => {
-                Some(object.iter_mut())
+                object.iter_mut()
             },
-            _ => None
+            _ => EntriesMut::empty()
         }
     }
 
@@ -502,17 +506,3 @@ impl<'a> IndexMut<&'a String> for JsonValue {
         self.index_mut(index.deref())
     }
 }
-
-impl IntoIterator for JsonValue {
-    type Item = JsonValue;
-    type IntoIter = ::std::vec::IntoIter<JsonValue>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        match self {
-            JsonValue::Array(vec) => {
-                vec.into_iter()
-            },
-            _ => Vec::new().into_iter()
-        }
-    }
-}

tests/lib.rs

@@ -632,11 +632,11 @@ mod unit {
     fn array_members() {
         let data = array![1, "foo"];
 
-        for member in data.members().unwrap() {
+        for member in data.members() {
             assert!(!member.is_null());
         }
 
-        let mut members = data.members().unwrap();
+        let mut members = data.members();
 
         assert_eq!(members.next().unwrap(), 1);
         assert_eq!(members.next().unwrap(), "foo");
@@ -647,11 +647,11 @@ mod unit {
     fn array_members_rev() {
         let data = array![1, "foo"];
 
-        for member in data.members().unwrap() {
+        for member in data.members() {
             assert!(!member.is_null());
         }
 
-        let mut members = data.members().unwrap().rev();
+        let mut members = data.members().rev();
 
         assert_eq!(members.next().unwrap(), "foo");
         assert_eq!(members.next().unwrap(), 1);
@@ -662,7 +662,7 @@ mod unit {
     fn array_members_mut() {
         let mut data = array![Null, Null];
 
-        for member in data.members_mut().unwrap() {
+        for member in data.members_mut() {
             assert!(member.is_null());
             *member = 100.into();
         }
@@ -675,7 +675,7 @@ mod unit {
         let mut data = array![Null, Null];
         let mut item = 100;
 
-        for member in data.members_mut().unwrap().rev() {
+        for member in data.members_mut().rev() {
             assert!(member.is_null());
             *member = item.into();
             item += 1;
@@ -712,11 +712,11 @@ mod unit {
             "b" => "foo"
         };
 
-        for (_, value) in data.entries().unwrap() {
+        for (_, value) in data.entries() {
             assert!(!value.is_null());
         }
 
-        let mut entries = data.entries().unwrap();
+        let mut entries = data.entries();
 
         let (key, value) = entries.next().unwrap();
         assert_eq!(key, "a");
@@ -736,11 +736,11 @@ mod unit {
             "b" => "foo"
         };
 
-        for (_, value) in data.entries().unwrap().rev() {
+        for (_, value) in data.entries().rev() {
             assert!(!value.is_null());
         }
 
-        let mut entries = data.entries().unwrap().rev();
+        let mut entries = data.entries().rev();
 
         let (key, value) = entries.next().unwrap();
         assert_eq!(key, "b");
@@ -760,7 +760,7 @@ mod unit {
             "b" => Null
         };
 
-        for (_, value) in data.entries_mut().unwrap() {
+        for (_, value) in data.entries_mut() {
             assert!(value.is_null());
             *value = 100.into();
         }
@@ -779,7 +779,7 @@ mod unit {
         };
         let mut item = 100;
 
-        for (_, value) in data.entries_mut().unwrap().rev() {
+        for (_, value) in data.entries_mut().rev() {
             assert!(value.is_null());
             *value = item.into();
             item += 1;