doesnt work by value

Author: pczarn

src/libstd/collections/hash/map.rs

@@ -867,7 +867,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     pub fn iter(&self) -> Iter<K, V> {
         Iter {
             elems_left: self.table.size(),
-            inner: self.table.raw_full_buckets(),
+            inner: Bucket::raw_full_buckets(&self.table),
         }
     }
 
@@ -898,7 +898,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     pub fn iter_mut(&mut self) -> IterMut<K, V> {
         IterMut {
             elems_left: self.table.size(),
-            inner: self.table.raw_full_buckets_mut(),
+            inner: Bucket::raw_full_buckets(&mut self.table),
         }
     }
 

src/libstd/collections/hash/table.rs

@@ -17,13 +17,12 @@ use cmp;
 use hash::{Hash, Hasher};
 use iter::{Iterator, IteratorExt, ExactSizeIterator, count};
 use marker::{Copy, Sized};
-use mem::{min_align_of, size_of};
-use mem;
+use mem::{self, min_align_of, size_of};
 use num::{Int, UnsignedInt};
 use ops::{Deref, DerefMut, Drop};
-use option::Option;
-use option::Option::{Some, None};
+use option::Option::{self, Some, None};
 use ptr::{self, Unique, PtrExt, copy_memory, copy_nonoverlapping_memory, zero_memory};
+use result::Result::{self, Ok, Err};
 use rt::heap::{allocate, deallocate, reallocate_inplace};
 use collections::hash_state::HashState;
 use core::nonzero::NonZero;
@@ -95,6 +94,7 @@ impl<K,V,M:Copy,S> Copy for Bucket<K,V,M,S> {}
 mod bucket {
     pub enum Empty {}
     pub enum Full {}
+    pub enum TableIsEmpty {}
 }
 
 pub type EmptyBucket<K, V, M> = Bucket<K, V, M, bucket::Empty>;
@@ -151,6 +151,14 @@ fn can_alias_safehash_as_option() {
     assert_eq!(size_of::<SafeHash>(), size_of::<Option<SafeHash>>())
 }
 
+impl<K, V> Deref for RawTable<K, V> {
+    type Target = RawTable<K, V>;
+
+    fn deref(&self) -> &RawTable<K, V> {
+        self
+    }
+}
+
 impl<K, V, M> RawBucket<K, V, M> {
     unsafe fn offset(self, count: int) -> RawBucket<K, V, M> {
         RawBucket {
@@ -210,29 +218,47 @@ impl<K, V, M, S> Bucket<K, V, M, S> {
     pub fn index(&self) -> uint {
         self.0.idx
     }
+    /// Turn the bucket into an iterator over full buckets.
+    pub fn into_iter(self) -> RawFullBuckets<K, V, M> {
+        RawFullBuckets {
+            raw: self.raw,
+            hashes_end: unsafe {
+                self.raw.hash.offset(self.0.capacity as int - self.index() as int)
+            },
+            table: self.table,
+        }
+    }
 }
 
 impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> {
     pub fn new(table: M, hash: SafeHash) -> Option<Bucket<K, V, M>> {
-        Bucket::at_index(table, *hash as usize)
+        Bucket::at_index(table, *hash as usize).ok()
     }
 
-    pub fn at_index(table: M, ib_index: uint) -> Option<Bucket<K, V, M>> {
+    pub fn at_index(table: M, ib_index: uint)
+                   -> Result<Bucket<K, V, M>, Bucket<K, V, M, bucket::TableIsEmpty>>
+    {
+        let ib_index = ib_index & (table.capacity() - 1);
+        let bb = BareBucket {
+            raw: unsafe {
+               table.first_bucket_raw().offset(ib_index as int)
+            },
+            idx: ib_index,
+            capacity: table.capacity(),
+            table: table,
+        };
+
         if table.capacity() == 0 {
-            None
+            Err(Bucket(bb))
         } else {
-            let ib_index = ib_index & (table.capacity() - 1);
-            Some(Bucket(BareBucket {
-                raw: unsafe {
-                   table.first_bucket_raw().offset(ib_index as int)
-                },
-                idx: ib_index,
-                capacity: table.capacity(),
-                table: table
-            }))
+            Ok(Bucket(bb))
         }
     }
 
+    pub fn raw_full_buckets(table: M) -> RawFullBuckets<K, V, M> {
+        Bucket::at_index(table, 0).map(|b| b.into_iter()).unwrap_or_else(|b| b.into_iter())
+    }
+
     /// Narrows down the range of iteration, which must be a power of 2.
     pub fn iter_to(mut self, limit: usize) -> Bucket<K, V, M> {
         assert!(limit <= self.capacity);
@@ -461,7 +487,7 @@ impl<K, V> RawTable<K, V> {
     }
 
     #[inline]
-    fn first_bucket_raw<M>(&self) -> RawBucket<K, V, M> {
+    unsafe fn first_bucket_raw<M>(&self) -> RawBucket<K, V, M> {
         if self.capacity() == 0 {
             RawBucket {
                 hash: ptr::null_mut(),
@@ -539,18 +565,10 @@ impl<K, V> RawTable<K, V> {
         self.size
     }
 
-    pub fn raw_full_buckets(&self) -> RawFullBuckets<K, V, &RawTable<K, V>> {
-        full_buckets(self.first_bucket_raw(), self.capacity, self)
-    }
-
-    pub fn raw_full_buckets_mut(&mut self) -> RawFullBuckets<K, V, &mut RawTable<K, V>> {
-        full_buckets(self.first_bucket_raw(), self.capacity, self)
-    }
-
     pub fn into_iter(self) -> IntoIter<K, V> {
         // Replace the marker regardless of lifetime bounds on parameters.
         IntoIter {
-            iter: full_buckets(self.first_bucket_raw(), self.capacity, self)
+            iter: Bucket::raw_full_buckets(self),
         }
     }
 }
@@ -596,14 +614,7 @@ fn align<K, V>() -> usize {
     cmp::max(mem::min_align_of::<(K, V)>(), mem::min_align_of::<u64>())
 }
 
-pub fn full_buckets<K, V, M>(raw: RawBucket<K, V, M>, cap: usize, t: M) -> RawFullBuckets<K, V, M> {
-    RawFullBuckets {
-        raw: raw,
-        hashes_end: unsafe { raw.hash.offset(cap as int) },
-        table: t,
-    }
-}
-
+/// A newtyped RawBucket. Not copyable.
 pub struct RawFullBucket<K, V, M>(RawBucket<K, V, M>);
 
 impl<K, V, M> Deref for RawFullBucket<K, V, M> {
@@ -670,7 +681,7 @@ impl<K, V> Iterator for IntoIter<K, V> {
         self.iter.next().map(|bucket| {
             self.iter.table.size -= 1;
             unsafe {
-                let (k, v) = ptr::read(bucket.kval as *const (K, V));
+                let (k, v) = ptr::read(bucket.kval);
                 (*(bucket.hash as *mut SafeHash), k, v)
             }
         })
@@ -742,8 +753,8 @@ impl<K, V> Drop for RawTable<K, V> {
         // Avoid double drop of elements that have been already moved out.
         unsafe {
             if self.size != 0 {
-                for bucket in self.raw_full_buckets_mut() {
-                    ptr::read(bucket.kval as *const (K, V));
+                for bucket in Bucket::raw_full_buckets(self) {
+                    ptr::read(bucket.kval);
                 }
             }
         }