Call HashTable methods where exact matches exist

Author: clarfonthey

src/map.rs

@@ -506,7 +506,7 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     /// Returns a reference to the underlying allocator.
     #[inline]
     pub fn allocator(&self) -> &A {
-        self.table.raw.allocator()
+        self.table.allocator()
     }
 
     /// Creates an empty `HashMap` which will use the given hash builder to hash
@@ -614,7 +614,7 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn capacity(&self) -> usize {
-        self.table.raw.capacity()
+        self.table.capacity()
     }
 
     /// An iterator visiting all keys in arbitrary order.
@@ -807,7 +807,7 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     #[cfg(test)]
     #[cfg_attr(feature = "inline-more", inline)]
     fn raw_capacity(&self) -> usize {
-        self.table.raw.num_buckets()
+        self.table.num_buckets()
     }
 
     /// Returns the number of elements in the map.
@@ -824,7 +824,7 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn len(&self) -> usize {
-        self.table.raw.len()
+        self.table.len()
     }
 
     /// Returns `true` if the map contains no elements.
@@ -916,15 +916,8 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     where
         F: FnMut(&K, &mut V) -> bool,
     {
-        // Here we only use `iter` as a temporary, preventing use-after-free
-        unsafe {
-            for item in self.table.raw.iter() {
-                let &mut (ref key, ref mut value) = item.as_mut();
-                if !f(key, value) {
-                    self.table.raw.erase(item);
-                }
-            }
-        }
+        self.table
+            .retain(move |&mut (ref key, ref mut val)| f(key, val))
     }
 
     /// Drains elements which are true under the given predicate,
@@ -1005,7 +998,7 @@ impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn clear(&mut self) {
-        self.table.raw.clear();
+        self.table.clear();
     }
 
     /// Creates a consuming iterator visiting all the keys in arbitrary order.
@@ -1304,9 +1297,9 @@ where
         Q: Hash + Equivalent<K> + ?Sized,
     {
         // Avoid `Option::map` because it bloats LLVM IR.
-        if !self.table.raw.is_empty() {
+        if !self.table.is_empty() {
             let hash = make_hash::<Q, S>(&self.hash_builder, k);
-            match self.table.raw.get(hash, equivalent_key(k)) {
+            match self.table.find(hash, equivalent_key(k)) {
                 Some((_, v)) => Some(v),
                 None => None,
             }
@@ -1340,9 +1333,9 @@ where
         Q: Hash + Equivalent<K> + ?Sized,
     {
         // Avoid `Option::map` because it bloats LLVM IR.
-        if !self.table.raw.is_empty() {
+        if !self.table.is_empty() {
             let hash = make_hash::<Q, S>(&self.hash_builder, k);
-            match self.table.raw.get(hash, equivalent_key(k)) {
+            match self.table.find(hash, equivalent_key(k)) {
                 Some((key, value)) => Some((key, value)),
                 None => None,
             }
@@ -1380,9 +1373,9 @@ where
         Q: Hash + Equivalent<K> + ?Sized,
     {
         // Avoid `Option::map` because it bloats LLVM IR.
-        if !self.table.raw.is_empty() {
+        if !self.table.is_empty() {
             let hash = make_hash::<Q, S>(&self.hash_builder, k);
-            match self.table.raw.get_mut(hash, equivalent_key(k)) {
+            match self.table.find_mut(hash, equivalent_key(k)) {
                 Some(&mut (ref key, ref mut value)) => Some((key, value)),
                 None => None,
             }
@@ -1415,9 +1408,9 @@ where
     where
         Q: Hash + Equivalent<K> + ?Sized,
     {
-        if !self.table.raw.is_empty() {
+        if !self.table.is_empty() {
             let hash = make_hash::<Q, S>(&self.hash_builder, k);
-            self.table.raw.get(hash, equivalent_key(k)).is_some()
+            self.table.find(hash, equivalent_key(k)).is_some()
         } else {
             false
         }
@@ -1452,9 +1445,9 @@ where
         Q: Hash + Equivalent<K> + ?Sized,
     {
         // Avoid `Option::map` because it bloats LLVM IR.
-        if !self.table.raw.is_empty() {
+        if !self.table.is_empty() {
             let hash = make_hash::<Q, S>(&self.hash_builder, k);
-            match self.table.raw.get_mut(hash, equivalent_key(k)) {
+            match self.table.find_mut(hash, equivalent_key(k)) {
                 Some(&mut (_, ref mut v)) => Some(v),
                 None => None,
             }
@@ -2055,7 +2048,7 @@ where
     /// primarily used for memory profiling.
     #[inline]
     pub fn allocation_size(&self) -> usize {
-        self.table.raw.allocation_size()
+        self.table.allocation_size()
     }
 }