Merge pull request #59 from imp/revmembers

Add support for DoubleEndedIterator over lists and objects

Author: maciejhirsz

src/iterators.rs

@@ -1,6 +1,6 @@
 use std::collections::btree_map;
 use std::slice;
-use std::iter::Iterator;
+use std::iter::{Iterator, DoubleEndedIterator};
 use JsonValue;
 
 pub enum Members<'a> {
@@ -34,6 +34,15 @@ impl<'a> Iterator for Members<'a> {
     }
 }
 
+impl<'a> DoubleEndedIterator for Members<'a> {
+    fn next_back(&mut self) -> Option<&'a JsonValue> {
+        match *self {
+            Members::Some(ref mut iter) => iter.next_back(),
+            Members::None               => None,
+        }
+    }
+}
+
 impl<'a> Iterator for MembersMut<'a> {
     type Item = &'a mut JsonValue;
 
@@ -45,6 +54,15 @@ impl<'a> Iterator for MembersMut<'a> {
     }
 }
 
+impl<'a> DoubleEndedIterator for MembersMut<'a> {
+    fn next_back(&mut self) -> Option<&'a mut JsonValue> {
+        match *self {
+            MembersMut::Some(ref mut iter) => iter.next_back(),
+            MembersMut::None               => None,
+        }
+    }
+}
+
 impl<'a> Iterator for Entries<'a> {
     type Item = (&'a String, &'a JsonValue);
 
@@ -56,6 +74,15 @@ impl<'a> Iterator for Entries<'a> {
     }
 }
 
+impl<'a> DoubleEndedIterator for Entries<'a> {
+    fn next_back(&mut self) -> Option<(&'a String, &'a JsonValue)> {
+        match *self {
+            Entries::Some(ref mut iter) => iter.next_back(),
+            Entries::None               => None
+        }
+    }
+}
+
 impl<'a> Iterator for EntriesMut<'a> {
     type Item = (&'a String, &'a mut JsonValue);
 
@@ -66,3 +93,12 @@ impl<'a> Iterator for EntriesMut<'a> {
         }
     }
 }
+
+impl<'a> DoubleEndedIterator for EntriesMut<'a> {
+    fn next_back(&mut self) -> Option<(&'a String, &'a mut JsonValue)> {
+        match *self {
+            EntriesMut::Some(ref mut iter) => iter.next_back(),
+            EntriesMut::None               => None
+        }
+    }
+}

tests/lib.rs

@@ -626,6 +626,21 @@ mod unit {
         assert!(members.next().is_none());
     }
 
+    #[test]
+    fn array_members_rev() {
+        let data = array![1, "foo"];
+
+        for member in data.members() {
+            assert!(!member.is_null());
+        }
+
+        let mut members = data.members().rev();
+
+        assert_eq!(members.next().unwrap(), "foo");
+        assert_eq!(members.next().unwrap(), 1);
+        assert!(members.next().is_none());
+    }
+
     #[test]
     fn array_members_mut() {
         let mut data = array![Null, Null];
@@ -638,6 +653,20 @@ mod unit {
         assert_eq!(data, array![100, 100]);
     }
 
+    #[test]
+    fn array_members_mut_rev() {
+        let mut data = array![Null, Null];
+        let mut item = 100;
+
+        for member in data.members_mut().rev() {
+            assert!(member.is_null());
+            *member = item.into();
+            item += 1;
+        }
+
+        assert_eq!(data, array![item - 1, item - 2]);
+    }
+
     #[test]
     fn object_len() {
         let data = object!{
@@ -683,6 +712,30 @@ mod unit {
         assert!(entries.next().is_none());
     }
 
+    #[test]
+    fn object_entries_rev() {
+        let data = object!{
+            "a" => 1,
+            "b" => "foo"
+        };
+
+        for (_, value) in data.entries().rev() {
+            assert!(!value.is_null());
+        }
+
+        let mut entries = data.entries().rev();
+
+        let (key, value) = entries.next().unwrap();
+        assert_eq!(key, "b");
+        assert_eq!(value, "foo");
+
+        let (key, value) = entries.next().unwrap();
+        assert_eq!(key, "a");
+        assert_eq!(value, 1);
+
+        assert!(entries.next().is_none());
+    }
+
     #[test]
     fn object_entries_mut() {
         let mut data = object!{
@@ -701,6 +754,26 @@ mod unit {
         });
     }
 
+    #[test]
+    fn object_entries_mut_rev() {
+        let mut data = object!{
+            "a" => Null,
+            "b" => Null
+        };
+        let mut item = 100;
+
+        for (_, value) in data.entries_mut().rev() {
+            assert!(value.is_null());
+            *value = item.into();
+            item += 1;
+        }
+
+        assert_eq!(data, object!{
+            "a" => item - 1,
+            "b" => item - 2
+        });
+    }
+
     #[test]
     fn object_dump_minified() {
         let object = object!{