f.

Author: pczarn

src/libstd/collections/hash/map.rs

@@ -37,7 +37,6 @@ use super::table::{
     FullBucketMut,
     RawTable,
     SafeHash,
-    TableRef,
     PartialRawTable,
     Put,
 };
@@ -322,13 +321,12 @@ fn search_hashed<K, V, M, F>(table: M,
                              hash: SafeHash,
                              mut is_match: F)
                              -> InternalEntry<K, V, M> where
-    RawTable<K, V>: BorrowFrom<M>,
+    M: Borrow<RawTable<K, V>>,
     F: FnMut(&K) -> bool,
 {
     // Worst case, we'll find one empty bucket among `size + 1` buckets.
-    let table = TableRef(table);
-    let size = table.size();
-    let mut probe = match Bucket::new(table.0, hash) {
+    let size = table.borrow().size();
+    let mut probe = match Bucket::new(table, hash) {
         Some(probe) => probe,
         None => return InternalEntry::TableIsEmpty,
     };
@@ -411,7 +409,7 @@ fn robin_hood<'a, K: 'a, V: 'a>(bucket: FullBucketMut<'a, K, V>,
             let (h_ref, k_ref, v_ref) = bucket.read_mut();
             swap(h_ref, &mut hash);
             swap(k_ref, &mut key);
-            swap(v_ref, &mut val));
+            swap(v_ref, &mut val);
         };
         loop {
             let probe = bucket.into_next();
@@ -443,12 +441,11 @@ fn robin_hood<'a, K: 'a, V: 'a>(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: Put, K, V>(arg: M, h: SafeHash, k: K, v: V) -> M
-    where RawTable<K, V>: BorrowFromMut<M>
+fn insert_hashed_ordered<M: Put, K, V>(arg: M, hash: SafeHash, key: K, val: V) -> M
+    where M: BorrowMut<RawTable<K, V>>
 {
-    let table = TableRef(arg);
-    let cap = table.capacity();
-    let mut buckets = Bucket::new(table.0, h).unwrap();
+    let cap = table.borrow().capacity();
+    let mut buckets = Bucket::new(table, h).unwrap();
     let ib = buckets.index();
 
     while buckets.index() != ib + cap {
@@ -1567,7 +1564,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
 
 #[unstable(feature = "std_misc",
            reason = "matches collection reform v2 specification, waiting for dust to settle")]
-impl<'a, K: 'a, V: 'a, M: 'a> OccupiedEntryState<K, V, M> where RawTable<K, V>: BorrowFromMut<M> {
+impl<'a, K: 'a, V: 'a, M: 'a> OccupiedEntryState<K, V, M> where M: BorrowMut<RawTable<K, V>> {
     /// Gets a mutable reference to the value in the entry.
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn get_mut(&mut self) -> &mut V {

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 {
@@ -151,20 +146,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 {
@@ -180,15 +161,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()
     }
 }
 
@@ -202,11 +183,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 {
@@ -232,11 +213,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,
@@ -254,7 +234,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
@@ -315,15 +295,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,
@@ -341,7 +321,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
@@ -356,7 +336,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()
     }
@@ -413,7 +393,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;
@@ -618,7 +598,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)]`