std: Implement Extendable for hashmap, str and trie

3 files changed, 58 insertions, 21 deletions

diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index a9a11b611d6..e43293f3212 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -19,7 +19,7 @@ use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 use clone::Clone;
 use cmp::{Eq, Equiv};
 use hash::Hash;
-use iterator::{Iterator, IteratorUtil, FromIterator, Chain};
+use iterator::{Iterator, IteratorUtil, FromIterator, Extendable, Chain};
 use num;
 use option::{None, Option, Some};
 use rand::RngUtil;
@@ -618,15 +618,19 @@ impl<K> Iterator<K> for HashSetConsumeIterator<K> {
 }
 
 impl<K: Eq + Hash, V, T: Iterator<(K, V)>> FromIterator<(K, V), T> for HashMap<K, V> {
-    pub fn from_iterator(iter: &mut T) -> HashMap<K, V> {
+    fn from_iterator(iter: &mut T) -> HashMap<K, V> {
         let (lower, _) = iter.size_hint();
         let mut map = HashMap::with_capacity(lower);
+        map.extend(iter);
+        map
+    }
+}
 
+impl<K: Eq + Hash, V, T: Iterator<(K, V)>> Extendable<(K, V), T> for HashMap<K, V> {
+    fn extend(&mut self, iter: &mut T) {
         for iter.advance |(k, v)| {
-            map.insert(k, v);
+            self.insert(k, v);
         }
-
-        map
     }
 }
 
@@ -771,15 +775,19 @@ impl<T:Hash + Eq> HashSet<T> {
 }
 
 impl<K: Eq + Hash, T: Iterator<K>> FromIterator<K, T> for HashSet<K> {
-    pub fn from_iterator(iter: &mut T) -> HashSet<K> {
+    fn from_iterator(iter: &mut T) -> HashSet<K> {
         let (lower, _) = iter.size_hint();
         let mut set = HashSet::with_capacity(lower);
+        set.extend(iter);
+        set
+    }
+}
 
+impl<K: Eq + Hash, T: Iterator<K>> Extendable<K, T> for HashSet<K> {
+    fn extend(&mut self, iter: &mut T) {
         for iter.advance |k| {
-            set.insert(k);
+            self.insert(k);
         }
-
-        set
     }
 }
 
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 2aa5f586dd8..fff859321fb 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -23,7 +23,8 @@ use char::Char;
 use clone::Clone;
 use container::{Container, Mutable};
 use iter::Times;
-use iterator::{Iterator, FromIterator, IteratorUtil, Filter, AdditiveIterator, Map};
+use iterator::{Iterator, FromIterator, Extendable, IteratorUtil};
+use iterator::{Filter, AdditiveIterator, Map};
 use libc;
 use num::Zero;
 use option::{None, Option, Some};
@@ -2323,10 +2324,20 @@ impl<T: Iterator<char>> FromIterator<char, T> for ~str {
     fn from_iterator(iterator: &mut T) -> ~str {
         let (lower, _) = iterator.size_hint();
         let mut buf = with_capacity(lower);
+        buf.extend(iterator);
+        buf
+    }
+}
+
+impl<T: Iterator<char>> Extendable<char, T> for ~str {
+    #[inline]
+    fn extend(&mut self, iterator: &mut T) {
+        let (lower, _) = iterator.size_hint();
+        let reserve = lower + self.len();
+        self.reserve_at_least(reserve);
         for iterator.advance |ch| {
-            buf.push_char(ch)
+            self.push_char(ch)
         }
-        buf
     }
 }
 
@@ -2504,6 +2515,16 @@ mod tests {
     }
 
     #[test]
+    fn test_extend() {
+        let data = ~"ประเทศไทย中";
+        let mut cpy = data.clone();
+        let other = "abc";
+        let mut it = other.iter();
+        cpy.extend(&mut it);
+        assert_eq!(cpy, data + other);
+    }
+
+    #[test]
     fn test_clear() {
         let mut empty = ~"";
         empty.clear();
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index 4665f361340..6a0554a8c8d 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -11,7 +11,7 @@
 //! An ordered map and set for integer keys implemented as a radix trie
 
 use prelude::*;
-use iterator::{IteratorUtil, FromIterator};
+use iterator::{IteratorUtil, FromIterator, Extendable};
 use uint;
 use util::{swap, replace};
 
@@ -155,14 +155,18 @@ impl<T> TrieMap<T> {
 }
 
 impl<T, Iter: Iterator<(uint, T)>> FromIterator<(uint, T), Iter> for TrieMap<T> {
-    pub fn from_iterator(iter: &mut Iter) -> TrieMap<T> {
+    fn from_iterator(iter: &mut Iter) -> TrieMap<T> {
         let mut map = TrieMap::new();
+        map.extend(iter);
+        map
+    }
+}
 
+impl<T, Iter: Iterator<(uint, T)>> Extendable<(uint, T), Iter> for TrieMap<T> {
+    fn extend(&mut self, iter: &mut Iter) {
         for iter.advance |(k, v)| {
-            map.insert(k, v);
+            self.insert(k, v);
         }
-
-        map
     }
 }
 
@@ -222,14 +226,18 @@ impl TrieSet {
 }
 
 impl<Iter: Iterator<uint>> FromIterator<uint, Iter> for TrieSet {
-    pub fn from_iterator(iter: &mut Iter) -> TrieSet {
+    fn from_iterator(iter: &mut Iter) -> TrieSet {
         let mut set = TrieSet::new();
+        set.extend(iter);
+        set
+    }
+}
 
+impl<Iter: Iterator<uint>> Extendable<uint, Iter> for TrieSet {
+    fn extend(&mut self, iter: &mut Iter) {
         for iter.advance |elem| {
-            set.insert(elem);
+            self.insert(elem);
         }
-
-        set
     }
 }