f.

Author: pczarn

src/libstd/collections/hash/table.rs

@@ -77,20 +77,15 @@ struct RawBucket<K, V> {
     kval: *mut (K, V),
 }
 
-impl<K, V> Copy for RawBucket<K, V> {}
-
-#[derive(Clone)]
-pub struct TableRef<M>(pub M);
-
-impl<M: Copy> Copy for TableRef<M> {}
-
 pub struct Bucket<K, V, M, S = ()> {
     raw: RawBucket<K, V>,
     idx: usize,
     capacity: usize,
-    table: TableRef<M>,
+    table: M,
 }
 
+impl<K, V> Copy for RawBucket<K, V> {}
+
 impl<K, V, M: Copy, S> Copy for Bucket<K,V,M,S> where M: Borrow<RawTable<K, V>> {}
 
 mod bucket {
@@ -170,20 +165,6 @@ fn can_alias_safehash_as_option() {
     assert_eq!(size_of::<SafeHash>(), size_of::<Option<SafeHash>>())
 }
 
-impl<K, V, M> Deref for TableRef<M> where M: Borrow<RawTable<K, V>> {
-    type Target = RawTable<K, V>;
-
-    fn deref(&self) -> &RawTable<K, V> {
-        self.0.borrow()
-    }
-}
-
-impl<K, V, M> DerefMut for TableRef<M> where M: Borrow<RawTable<K, V>> {
-    fn deref_mut(&mut self) -> &mut RawTable<K, V> {
-        self.0.borrow_mut()
-    }
-}
-
 impl<K, V> RawBucket<K, V> {
     unsafe fn offset(self, count: isize) -> RawBucket<K, V> {
         RawBucket {
@@ -199,15 +180,15 @@ impl<K, V, M, S> Borrow<RawTable<K, V>> for Bucket<K, V, M, S>
     where M: Borrow<RawTable<K, V>>
 {
     fn borrow(&self) -> &RawTable<K, V> {
-        self.table.0.borrow()
+        self.table.borrow()
     }
 }
 
 impl<K, V, M, S> BorrowMut<RawTable<K, V>> for Bucket<K, V, M, S>
     where M: Borrow<RawTable<K, V>>
 {
     fn borrow_mut(&mut self) -> &mut RawTable<K, V> {
-        self.table.0.borrow_mut()
+        self.table.borrow_mut()
     }
 }
 
@@ -221,11 +202,11 @@ impl<K, V, M: Put> Put for FullBucket<K, V, M> {}
 impl<K, V, M, S> Bucket<K, V, M, S> {
     /// Borrow a reference to the table.
     pub fn table(&self) -> &M {
-        &self.table.0
+        &self.table
     }
     /// Move out the reference to the table.
     pub fn into_table(self) -> M {
-        self.table.0
+        self.table
     }
     /// Get the raw index.
     pub fn index(&self) -> usize {
@@ -251,11 +232,10 @@ impl<K, V, M> Bucket<K, V, M> where M: Borrow<RawTable<K, V>> {
     pub fn at_index(table: M, ib_index: uint)
                    -> Result<Bucket<K, V, M>, Bucket<K, V, M, bucket::TableIsEmpty>>
     {
-        let table = TableRef(table);
-        let capacity = table.capacity();
+        let capacity = table.borrow().capacity();
         let idx = ib_index & (capacity - 1);
         let bucket: Bucket<K, V, M> = Bucket {
-            raw: unsafe { table.first_bucket_raw().offset(idx as isize) },
+            raw: unsafe { table.borrow().first_bucket_raw().offset(idx as isize) },
             idx: idx,
             capacity: capacity,
             table: table,
@@ -273,7 +253,7 @@ impl<K, V, M> Bucket<K, V, M> where M: Borrow<RawTable<K, V>> {
 
     /// 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.table.capacity());
+        assert!(limit <= self.table.borrow().capacity());
         assert!(limit.is_power_of_two());
         self.capacity = limit;
         self
@@ -334,15 +314,15 @@ impl<K, V, M, S> Bucket<K, V, M, S> where M: Borrow<RawTable<K, V>> {
             raw: self.raw,
             idx: self.idx,
             capacity: self.capacity,
-            table: TableRef(self),
+            table: self,
         }
     }
 }
 
 impl<K, V, M> EmptyBucket<K, V, M> where M: Borrow<RawTable<K, V>> {
     pub fn gap_peek(self) -> Option<GapThenFull<K, V, M>> {
         let gap = Bucket {
-            table: TableRef(()),
+            table: (),
             idx: self.idx,
             capacity: self.capacity,
             raw: self.raw,
@@ -360,7 +340,7 @@ impl<K, V, M> EmptyBucket<K, V, M> where M: Borrow<RawTable<K, V>> {
     }
 }
 
-impl<K, V, M> EmptyBucket<K, V, M> where M: Borrow<RawTable<K, V>>, M: Put {
+impl<K, V, M> EmptyBucket<K, V, M> where M: BorrowMut<RawTable<K, V>>, M: Put {
     /// Puts given key and value pair, along with the key's hash,
     /// into this bucket in the hashtable. Note how `self` is 'moved' into
     /// this function, because this slot will no longer be empty when
@@ -375,7 +355,7 @@ impl<K, V, M> EmptyBucket<K, V, M> where M: Borrow<RawTable<K, V>>, M: Put {
             ptr::write(self.raw.kval, (key, value));
         }
 
-        self.table.size += 1;
+        self.table.borrow_mut().size += 1;
 
         self.unsafe_cast()
     }
@@ -432,7 +412,7 @@ impl<'t, K, V, M: 't> FullBucket<K, V, M> where M: BorrowMut<RawTable<K, V>> {
     /// This works similarly to `put`, building an `EmptyBucket` out of the
     /// taken bucket.
     pub fn take(mut self) -> (EmptyBucket<K, V, M>, K, V) {
-        self.table.size -= 1;
+        self.table.borrow_mut().size -= 1;
 
         unsafe {
             *self.raw.hash = None;
@@ -637,7 +617,7 @@ impl<'t, K, V, M: 't> RawFullBucket<K, V, M> where M: BorrowMut<RawTable<K, V>>
 pub struct RawFullBuckets<K, V, M> {
     raw: RawBucket<K, V>,
     hashes_end: *mut Option<SafeHash>,
-    table: TableRef<M>,
+    table: M,
 }
 
 // FIXME(#19839) Remove in favor of `#[derive(Clone)]`