cleanup: to be rebased

Author: pczarn

src/libstd/collections/hash/map.rs

@@ -19,7 +19,7 @@ use cmp::{max, Eq, PartialEq};
 use default::Default;
 use fmt::{self, Debug};
 use hash::{self, Hash, SipHasher};
-use iter::{self, Iterator, ExactSizeIterator, IntoIterator, IteratorExt, FromIterator, Extend, Map};
+use iter::{Iterator, ExactSizeIterator, IntoIterator, IteratorExt, FromIterator, Extend, Map};
 use marker::Sized;
 use mem::{self, replace};
 use num::{Int, UnsignedInt};
@@ -38,6 +38,8 @@ use super::table::{
     RawTable,
     SafeHash,
     TableRef,
+    PartialRawTable,
+    Put,
 };
 use super::table::BucketState::{
     Empty,
@@ -307,7 +309,6 @@ fn test_resize_policy() {
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-#[derive(Clone)]
 pub struct HashMap<K, V, S = RandomState> {
     // All hashes are keyed on these values, to prevent hash collision attacks.
     hash_state: S,
@@ -389,7 +390,7 @@ fn pop_internal<K, V>(starting_bucket: FullBucketMut<K, V>) -> (K, V) {
 /// to recalculate it.
 ///
 /// `hash`, `k`, and `v` are the elements to "robin hood" into the hashtable.
-fn robin_hood<'a, K: 'a, V: 'a>(mut bucket: FullBucketMut<'a, K, V>,
+fn robin_hood<'a, K: 'a, V: 'a>(bucket: FullBucketMut<'a, K, V>,
                         mut ib: usize,
                         mut hash: SafeHash,
                         mut k: K,
@@ -400,9 +401,10 @@ fn robin_hood<'a, K: 'a, V: 'a>(mut bucket: FullBucketMut<'a, K, V>,
         let table = bucket.table(); // FIXME "lifetime too short".
         table.size()
     };
-    // There can be at most `size - dib` buckets to displace, because
+    let mut bucket = bucket.stash();
+    // There can be at most `size - displacement` buckets to displace, because
     // in the worst case, there are `size` elements and we already are
-    // `distance` buckets away from the initial one.
+    // `displacement` buckets away from the initial one.
     let idx_end = starting_index + size - bucket.displacement();
 
     loop {
@@ -420,14 +422,7 @@ fn robin_hood<'a, K: 'a, V: 'a>(mut bucket: FullBucketMut<'a, K, V>,
                     let b = bucket.put(old_hash, old_key, old_val);
                     // Now that it's stolen, just read the value's pointer
                     // right out of the table!
-                    let starting_bucket = Bucket::at_index(b.into_table(), starting_index).ok()
-                                                                                          .unwrap()
-                                                                                          .peek();
-                    if let Full(starting_bucket) = starting_bucket {
-                        return starting_bucket.into_mut_refs().1;
-                    } else {
-                        panic!("Expected full bucket");
-                    }
+                    return b.into_table().into_mut_refs().1;
                 },
                 Full(bucket) => bucket
             };
@@ -450,7 +445,7 @@ fn robin_hood<'a, K: 'a, V: 'a>(mut bucket: FullBucketMut<'a, K, V>,
 
 // Performs insertion with relaxed requirements.
 // The caller should ensure that invariants of Robin Hood linear probing hold.
-fn insert_hashed_ordered<M, K, V>(arg: M, h: SafeHash, k: K, v: V) -> M
+fn insert_hashed_ordered<M: Put, K, V>(arg: M, h: SafeHash, k: K, v: V) -> M
     where RawTable<K, V>: BorrowFromMut<M>
 {
     let table = TableRef(arg);
@@ -720,27 +715,34 @@ impl<K, V, S, H> HashMap<K, V, S>
         //    ^ exit once table.size == 0
         let idx_end = bucket.index() + old_capacity;
 
-        while bucket.index() != idx_end {
-            bucket = match bucket.peek() {
-                Full(bucket) => {
-                    let h = *bucket.read().0;
-                    let (b, k, v) = bucket.take();
-
-                    if let Some(ref mut dest) = destination {
-                        insert_hashed_ordered(dest, h, k, v);
+        if let Some(mut dest) = destination {
+            while bucket.index() != idx_end {
+                bucket = match bucket.peek() {
+                    Full(bucket) => {
+                        let h = *bucket.read().0;
+                        let (b, k, v) = bucket.take();
+                        insert_hashed_ordered(&mut dest, h, k, v);
                         b.into_bucket()
-                    } else {
-                        // Resizing in-place.
-                        insert_hashed_ordered(b.into_bucket(), h, k, v)
                     }
-                }
-                Empty(b) => b.into_bucket()
-            };
-            bucket.next(); // wraps at old_capacity
-        }
+                    Empty(b) => b.into_bucket()
+                };
+                bucket.next(); // wraps at old_capacity
+            }
 
-        if let Some(dest) = destination {
             replace(bucket.into_table(), dest);
+        } else {
+            while bucket.index() != idx_end {
+                bucket = match bucket.peek() {
+                    Full(bucket) => {
+                        let h = *bucket.read().0;
+                        let (b, k, v) = bucket.take();
+                        // Resizing in-place.
+                        insert_hashed_ordered(b.into_bucket(), h, k, v)
+                    }
+                    Empty(b) => b.into_bucket()
+                };
+                bucket.next(); // wraps at old_capacity
+            }
         }
     }
 
@@ -769,11 +771,12 @@ impl<K, V, S, H> HashMap<K, V, S>
         debug_assert!(self.len() <= min_capacity);
 
         if self.table.capacity() != min_capacity {
-            let old_table = replace(&mut self.table, RawTable::new(min_capacity));
+            let mut old_table = PartialRawTable::new(replace(&mut self.table,
+                                                             RawTable::new(min_capacity)));
             let old_size = old_table.size();
 
             // Shrink the table. Naive algorithm for resizing:
-            for (h, k, v) in old_table.into_iter() {
+            while let Some((h, k, v)) = old_table.take_front() {
                 self.insert_hashed_nocheck(h, k, v);
             }
 
@@ -925,11 +928,8 @@ impl<K, V, S, H> HashMap<K, V, S>
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn into_iter(self) -> IntoIter<K, V> {
-        fn last_two<A, B, C>((_, b, c): (A, B, C)) -> (B, C) { (b, c) }
-        let last_two: fn((SafeHash, K, V)) -> (K, V) = last_two;
-
         IntoIter {
-            inner: self.table.into_iter().map(last_two)
+            table: PartialRawTable::new(self.table)
         }
     }
 
@@ -1231,6 +1231,37 @@ impl<K, V, S, H, Q: ?Sized> IndexMut<Q> for HashMap<K, V, S>
     }
 }
 
+impl<K: Clone, V: Clone, S: Clone> Clone for HashMap<K, V, S> {
+    fn clone(&self) -> HashMap<K, V, S> {
+        let mut new_ht = RawTable::new_uninitialized(self.table.capacity());
+
+        let cap = self.table.capacity();
+        if let Ok(mut buckets) = Bucket::at_index(&self.table, 0) {
+            while buckets.index() != cap {
+                match buckets.peek() {
+                    Full(full) => {
+                        let (h, k, v) = {
+                            let (h, k, v) = full.read();
+                            (*h, k.clone(), v.clone())
+                        };
+                        new_ht.push_back(Some((h, k, v)));
+                    }
+                    Empty(..) => {
+                        new_ht.push_back(None);
+                    }
+                }
+                buckets.next();
+            }
+        }
+
+        HashMap {
+            table: new_ht.unwrap(),
+            hash_state: self.hash_state.clone(),
+            resize_policy: self.resize_policy.clone(),
+        }
+    }
+}
+
 /// HashMap iterator.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Iter<'a, K: 'a, V: 'a> {
@@ -1258,7 +1289,7 @@ pub struct IterMut<'a, K: 'a, V: 'a> {
 /// HashMap move iterator.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct IntoIter<K, V> {
-    inner: iter::Map<table::IntoIter<K, V>, fn((SafeHash, K, V)) -> (K, V)>
+    table: PartialRawTable<K, V>,
 }
 
 /// HashMap keys iterator.
@@ -1427,17 +1458,17 @@ impl<K, V> Iterator for IntoIter<K, V> {
 
     #[inline]
     fn next(&mut self) -> Option<(K, V)> {
-        self.inner.next()
+        self.table.take_front().map(|(_, k, v)| (k, v))
     }
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        self.inner.size_hint()
+        (self.table.size(), Some(self.table.size()))
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<K, V> ExactSizeIterator for IntoIter<K, V> {
-    #[inline] fn len(&self) -> usize { self.inner.len() }
+    #[inline] fn len(&self) -> usize { self.table.size() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1469,13 +1500,19 @@ impl<'a, K, V> Iterator for Drain<'a, K, V> {
     type Item = (K, V);
 
     fn next(&mut self) -> Option<(K, V)> {
-        if let Some(ref mut bucket) = self.inner {
+        if let Some(mut bucket) = self.inner.take() {
             let cap = bucket.table().capacity();
             while bucket.index() < cap {
-                if let Some(kv_pair) = bucket.peek_take() {
-                    return Some(kv_pair);
+                match bucket.peek() {
+                    Full(bucket) => {
+                        let (empty, k, v) = bucket.take();
+                        self.inner = Some(empty.into_bucket());
+                        return Some((k, v));
+                    }
+                    Empty(empty) => {
+                        bucket = empty.into_next();
+                    }
                 }
-                bucket.next();
             }
         }