[librsvg: 15/95] PropertyBag.iter() method

[Federico Mena Quintero <federico src gnome org>]

commit d5d5ecce1520a7799668d481b3a1e680a6083cf6
Author: Federico Mena Quintero <federico gnome org>
Date:   Mon Feb 12 19:05:53 2018 -0600

    PropertyBag.iter() method
    
    This wraps HashMap::iter(), but returns Item=(&str, &str) instead of
    HashMap's double-references to CStr.

 rust/src/property_bag.rs | 45 ++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 40 insertions(+), 5 deletions(-)
---
diff --git a/rust/src/property_bag.rs b/rust/src/property_bag.rs
index de509f1b..0f81a41b 100644
--- a/rust/src/property_bag.rs
+++ b/rust/src/property_bag.rs
@@ -1,6 +1,7 @@
 use libc;
 
 use std::collections::HashMap;
+use std::collections::hash_map;
 use std::ffi::{CStr, CString};
 use std::ops::Deref;
 use std::ptr;
@@ -12,6 +13,11 @@ pub struct PropertyBag<'a>(HashMap<&'a CStr, &'a CStr>);
 
 pub struct OwnedPropertyBag(HashMap<CString, CString>);
 
+pub struct PropertyBagIter<'a> {
+    pbag: &'a PropertyBag<'a>,
+    iter: hash_map::Iter<'a, &'a CStr, &'a CStr>
+}
+
 impl<'a> PropertyBag<'a> {
     pub unsafe fn new_from_key_value_pairs(pairs: *const *const libc::c_char) -> PropertyBag<'a> {
         let mut map = HashMap::new();
@@ -83,6 +89,21 @@ impl<'a> PropertyBag<'a> {
             enum_fn(k.as_ptr(), v.as_ptr(), data);
         }
     }
+
+    pub fn iter(&self) -> PropertyBagIter {
+        PropertyBagIter {
+            pbag: self,
+            iter: self.0.iter()
+        }
+    }
+}
+
+impl<'a> Iterator for PropertyBagIter<'a> {
+    type Item = (&'a str, &'a str);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next().map(|(k, v)| (k.to_str().unwrap(), v.to_str().unwrap()))
+    }
 }
 
 #[no_mangle]
@@ -187,7 +208,7 @@ mod tests {
     }
 
     #[test]
-    fn property_bag_lookups() {
+    fn property_bag_lookups_and_iters() {
         let pairs = [
             CString::new("alpha").unwrap(),
             CString::new("1").unwrap(),
@@ -203,10 +224,24 @@ mod tests {
 
         v.push(ptr::null());
 
-        let map = unsafe { PropertyBag::new_from_key_value_pairs(v.as_ptr()) };
+        let pbag = unsafe { PropertyBag::new_from_key_value_pairs(v.as_ptr()) };
+
+        assert_eq!(pbag.lookup("alpha"), Some("1"));
+        assert_eq!(pbag.lookup("beta"), Some("2"));
+        assert_eq!(pbag.lookup("gamma"), None);
+
+        let mut had_alpha: bool = false;
+        let mut had_beta: bool = false;
+
+        for (k, _) in pbag.iter() {
+            if k == "alpha" {
+                had_alpha = true;
+            } else if k == "beta" {
+                had_beta = true;
+            }
+        }
 
-        assert_eq!(map.lookup("alpha"), Some("1"));
-        assert_eq!(map.lookup("beta"), Some("2"));
-        assert_eq!(map.lookup("gamma"), None);
+        assert!(had_alpha);
+        assert!(had_beta);
     }
 }