From bbe03da9c6bad23d8e09077461c1616872e1aca0 Mon Sep 17 00:00:00 2001
From: =Mark Sinclair <mark.edward.x@gmail.com>
Date: Sun, 14 Jul 2013 13:18:50 -0400
Subject: [PATCH] Stripped trailing spaces; Implemented FromIterator for
 TreeMap and PriorityQueue

---
 src/libextra/priority_queue.rs | 27 +++++++++++++++++++
 src/libextra/treemap.rs        | 47 ++++++++++++++++++++++++++++++++++
 src/libstd/hashmap.rs          |  8 +++---
 src/libstd/trie.rs             |  4 +--
 4 files changed, 80 insertions(+), 6 deletions(-)

diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs
index 1f7ba9f65303..58bf4ba92472 100644
--- a/src/libextra/priority_queue.rs
+++ b/src/libextra/priority_queue.rs
@@ -16,6 +16,7 @@
 use std::unstable::intrinsics::{move_val_init, init};
 use std::util::{replace, swap};
 use std::vec;
+use std::iterator::FromIterator;
 
 /// A priority queue implemented with a binary heap
 pub struct PriorityQueue<T> {
@@ -191,6 +192,21 @@ impl<'self, T> Iterator<&'self T> for PriorityQueueIterator<'self, T> {
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
+impl<T: Ord, Iter: Iterator<T>> FromIterator<T, Iter> for PriorityQueue<T> {
+    pub fn from_iterator(iter: &mut Iter) -> PriorityQueue<T> {
+        let (lower, _) = iter.size_hint();
+
+        let mut q = PriorityQueue::new();
+        q.reserve_at_least(lower);
+
+        for iter.advance |elem| {
+            q.push(elem);
+        }
+
+        q
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use sort::merge_sort;
@@ -341,4 +357,15 @@ mod tests {
     #[should_fail]
     #[ignore(cfg(windows))]
     fn test_empty_replace() { let mut heap = PriorityQueue::new(); heap.replace(5); }
+
+    #[test]
+    fn test_from_iter() {
+        let xs = ~[9u, 8, 7, 6, 5, 4, 3, 2, 1];
+
+        let mut q: PriorityQueue<uint> = xs.rev_iter().transform(|&x| x).collect();
+
+        for xs.iter().advance |&x| {
+            assert_eq!(q.pop(), x);
+        }
+    }
 }
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
index 8fac055d26f6..d3d7dbfe402f 100644
--- a/src/libextra/treemap.rs
+++ b/src/libextra/treemap.rs
@@ -15,6 +15,7 @@
 
 use std::num;
 use std::util::{swap, replace};
+use std::iterator::FromIterator;
 
 // This is implemented as an AA tree, which is a simplified variation of
 // a red-black tree where red (horizontal) nodes can only be added
@@ -695,6 +696,30 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
     };
 }
 
+impl<K: TotalOrd, V, T: Iterator<(K, V)>> FromIterator<(K, V), T> for TreeMap<K, V> {
+    pub fn from_iterator(iter: &mut T) -> TreeMap<K, V> {
+        let mut map = TreeMap::new();
+
+        for iter.advance |(k, v)| {
+            map.insert(k, v);
+        }
+
+        map
+    }
+}
+
+impl<T: TotalOrd, Iter: Iterator<T>> FromIterator<T, Iter> for TreeSet<T> {
+    pub fn from_iterator(iter: &mut Iter) -> TreeSet<T> {
+        let mut set = TreeSet::new();
+
+        for iter.advance |elem| {
+            set.insert(elem);
+        }
+
+        set
+    }
+}
+
 #[cfg(test)]
 mod test_treemap {
 
@@ -1013,6 +1038,17 @@ mod test_treemap {
             i += 1;
         }
     }
+
+    #[test]
+    fn test_from_iter() {
+        let xs = ~[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+
+        let map: TreeMap<int, int> = xs.iter().transform(|&x| x).collect();
+
+        for xs.iter().advance |&(k, v)| {
+            assert_eq!(map.find(&k), Some(&v));
+        }
+    }
 }
 
 #[cfg(test)]
@@ -1240,4 +1276,15 @@ mod test_set {
         assert_eq!(m.pop(&1), Some(2));
         assert_eq!(m.pop(&1), None);
     }
+
+    #[test]
+    fn test_from_iter() {
+        let xs = ~[1, 2, 3, 4, 5, 6, 7, 8, 9];
+
+        let set: TreeSet<int> = xs.iter().transform(|&x| x).collect();
+
+        for xs.iter().advance |x: &int| {
+            assert!(set.contains(x));
+        }
+    }
 }
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index c219886cd03b..44161127c14e 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -621,7 +621,7 @@ impl<K: Eq + Hash, V, T: Iterator<(K, V)>> FromIterator<(K, V), T> for HashMap<K
 
         map
     }
-}        
+}
 
 /// An implementation of a hash set using the underlying representation of a
 /// HashMap where the value is (). As with the `HashMap` type, a `HashSet`
@@ -747,7 +747,7 @@ impl<K: Eq + Hash, T: Iterator<K>> FromIterator<K, T> for HashSet<K> {
         set
     }
 }
-  
+
 
 #[cfg(test)]
 mod test_map {
@@ -965,7 +965,7 @@ mod test_map {
     #[test]
     fn test_from_iter() {
         let xs = ~[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
-        
+
         let map: HashMap<int, int> = xs.iter().transform(|&x| x).collect();
 
         for xs.iter().advance |&(k, v)| {
@@ -1157,7 +1157,7 @@ mod test_set {
     #[test]
     fn test_from_iter() {
         let xs = ~[1, 2, 3, 4, 5, 6, 7, 8, 9];
-        
+
         let set: HashSet<int> = xs.iter().transform(|&x| x).collect();
 
         for xs.iter().advance |x: &int| {
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index fd2cfa08b309..ffacfe12ca2d 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -553,7 +553,7 @@ mod test_map {
     #[test]
     fn test_from_iter() {
         let xs = ~[(1u, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
-        
+
         let map: TrieMap<int> = xs.iter().transform(|&x| x).collect();
 
         for xs.iter().advance |&(k, v)| {
@@ -592,7 +592,7 @@ mod test_set {
     #[test]
     fn test_from_iter() {
         let xs = ~[9u, 8, 7, 6, 5, 4, 3, 2, 1];
-        
+
         let set: TrieSet = xs.iter().transform(|&x| x).collect();
 
         for xs.iter().advance |x| {