Merge branch 'master' of https://github.com/rust-lang/hashbrown

Author: hansihe

.travis.yml

@@ -42,10 +42,6 @@ matrix:
       env: TARGET=x86_64-apple-darwin
       os: osx
       osx_image: xcode10
-    - name: "i686-apple-darwin"
-      env: TARGET=i686-apple-darwin
-      os: osx
-      osx_image: xcode10
     - name: "x86_64-pc-windows-msvc"
       env: TARGET=x86_64-pc-windows-msvc
       os: windows

CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [v0.7.0] - 2020-01-31
+
+### Added
+- Added a `drain_filter` function to `HashMap`. (#135)
+
+### Changed
+- Updated `ahash` dependency to 0.3. (#141)
+- Optimized set union and intersection. (#130)
+- `raw_entry` can now be used without requiring `S: BuildHasher`. (#123)
+- `RawTable::bucket_index` can now be used under the `raw` feature. (#128)
+
 ## [v0.6.3] - 2019-10-31
 
 ### Added
@@ -164,7 +175,8 @@ This release was _yanked_ due to a breaking change for users of `no-default-feat
 
 - Initial release
 
-[Unreleased]: https://github.com/rust-lang/hashbrown/compare/v0.6.3...HEAD
+[Unreleased]: https://github.com/rust-lang/hashbrown/compare/v0.7.0...HEAD
+[v0.7.0]: https://github.com/rust-lang/hashbrown/compare/v0.6.3...v0.7.0
 [v0.6.3]: https://github.com/rust-lang/hashbrown/compare/v0.6.2...v0.6.3
 [v0.6.2]: https://github.com/rust-lang/hashbrown/compare/v0.6.1...v0.6.2
 [v0.6.1]: https://github.com/rust-lang/hashbrown/compare/v0.6.0...v0.6.1

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hashbrown"
-version = "0.6.3"
+version = "0.7.0"
 authors = ["Amanieu d'Antras <amanieu@gmail.com>"]
 description = "A Rust port of Google's SwissTable hash map"
 license = "Apache-2.0/MIT"
@@ -14,7 +14,7 @@ build = "build.rs"
 
 [dependencies]
 # For the default hasher
-ahash = { version = "0.2.11", optional = true, default-features = false }
+ahash = { version = "0.3.2", optional = true, default-features = false }
 
 # For external trait impls
 rayon = { version = "1.0", optional = true }
@@ -26,11 +26,11 @@ compiler_builtins = { version = "0.1.2", optional = true }
 alloc = { version = "1.0.0", optional = true, package = "rustc-std-workspace-alloc" }
 
 [build-dependencies]
-autocfg = "0.1.4"
+autocfg = "1"
 
 [dev-dependencies]
 lazy_static = "1.2"
-rand = "0.5.1"
+rand = { version = "0.7.3", features = ["small_rng"] }
 rayon = "1.0"
 rustc-hash = "1.0"
 serde_test = "1.0"

README.md

@@ -84,7 +84,7 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-hashbrown = "0.6"
+hashbrown = "0.7"
 ```
 
 Then:

ci/miri.sh

@@ -12,4 +12,4 @@ rustup default "$MIRI_NIGHTLY"
 rustup component add miri
 cargo miri setup
 
-cargo miri test -- -- -Zunstable-options --exclude-should-panic
+cargo miri test

ci/run.sh

@@ -22,7 +22,7 @@ if [ "${CROSS}" = "1" ]; then
     export CARGO_NET_RETRY=5
     export CARGO_NET_TIMEOUT=10
 
-    cargo install cross
+    cargo install --git https://github.com/rust-embedded/cross.git
     CARGO=cross
 fi
 

src/map.rs

@@ -10,7 +10,7 @@ use core::ops::Index;
 
 /// Default hasher for `HashMap`.
 #[cfg(feature = "ahash")]
-pub type DefaultHashBuilder = ahash::ABuildHasher;
+pub type DefaultHashBuilder = ahash::RandomState;
 
 /// Dummy default hasher for `HashMap`.
 #[cfg(not(feature = "ahash"))]
@@ -956,6 +956,35 @@ where
             }
         }
     }
+    /// Drains elements which are false under the given predicate,
+    /// and returns an iterator over the removed items.
+    ///
+    /// In other words, move all pairs `(k, v)` such that `f(&k,&mut v)` returns `false` out
+    /// into another iterator.
+    ///
+    /// When the returned DrainedFilter is dropped, the elements that don't satisfy
+    /// the predicate are dropped from the table.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use hashbrown::HashMap;
+    ///
+    /// let mut map: HashMap<i32, i32> = (0..8).map(|x|(x, x*10)).collect();
+    /// let drained = map.drain_filter(|&k, _| k % 2 == 0);
+    /// assert_eq!(drained.count(), 4);
+    /// assert_eq!(map.len(), 4);
+    /// ```
+    pub fn drain_filter<F>(&mut self, f: F) -> DrainFilter<'_, K, V, F>
+    where
+        F: FnMut(&K, &mut V) -> bool,
+    {
+        DrainFilter {
+            f,
+            iter: unsafe { self.table.iter() },
+            table: &mut self.table,
+        }
+    }
 }
 
 impl<K, V, S> HashMap<K, V, S> {
@@ -1236,6 +1265,66 @@ impl<K, V> Drain<'_, K, V> {
     }
 }
 
+/// A draining iterator over entries of a `HashMap` which don't satisfy the predicate `f`.
+///
+/// This `struct` is created by the [`drain_filter`] method on [`HashMap`]. See its
+/// documentation for more.
+///
+/// [`drain_filter`]: struct.HashMap.html#method.drain_filter
+/// [`HashMap`]: struct.HashMap.html
+pub struct DrainFilter<'a, K, V, F>
+where
+    F: FnMut(&K, &mut V) -> bool,
+{
+    f: F,
+    iter: RawIter<(K, V)>,
+    table: &'a mut RawTable<(K, V)>,
+}
+
+impl<'a, K, V, F> Drop for DrainFilter<'a, K, V, F>
+where
+    F: FnMut(&K, &mut V) -> bool,
+{
+    fn drop(&mut self) {
+        struct DropGuard<'r, 'a, K, V, F>(&'r mut DrainFilter<'a, K, V, F>)
+        where
+            F: FnMut(&K, &mut V) -> bool;
+
+        impl<'r, 'a, K, V, F> Drop for DropGuard<'r, 'a, K, V, F>
+        where
+            F: FnMut(&K, &mut V) -> bool,
+        {
+            fn drop(&mut self) {
+                while let Some(_) = self.0.next() {}
+            }
+        }
+        while let Some(item) = self.next() {
+            let guard = DropGuard(self);
+            drop(item);
+            mem::forget(guard);
+        }
+    }
+}
+
+impl<K, V, F> Iterator for DrainFilter<'_, K, V, F>
+where
+    F: FnMut(&K, &mut V) -> bool,
+{
+    type Item = (K, V);
+    fn next(&mut self) -> Option<Self::Item> {
+        unsafe {
+            while let Some(item) = self.iter.next() {
+                let &mut (ref key, ref mut value) = item.as_mut();
+                if !(self.f)(key, value) {
+                    self.table.erase_no_drop(&item);
+                    return Some(item.read());
+                }
+            }
+        }
+        None
+    }
+}
+
 /// A mutable iterator over the values of a `HashMap`.
 ///
 /// This `struct` is created by the [`values_mut`] method on [`HashMap`]. See its
@@ -2625,7 +2714,6 @@ mod test_map {
     use super::DefaultHashBuilder;
     use super::Entry::{Occupied, Vacant};
     use super::{HashMap, RawEntryMut};
-    #[cfg(not(miri))]
     use crate::CollectionAllocErr::*;
     use rand::{rngs::SmallRng, Rng, SeedableRng};
     use std::cell::RefCell;
@@ -2883,7 +2971,7 @@ mod test_map {
     }
 
     #[test]
-    #[cfg(not(miri))] // FIXME: https://github.com/rust-lang/miri/issues/654
+    #[cfg_attr(miri, ignore)] // FIXME: takes too long
     fn test_lots_of_insertions() {
         let mut m = HashMap::new();
 
@@ -3377,7 +3465,6 @@ mod test_map {
 
         let mut m = HashMap::new();
 
-        // FIXME: https://github.com/rust-lang/miri/issues/653
         let mut rng = {
             let seed = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
             SmallRng::from_seed(seed)
@@ -3491,7 +3578,24 @@ mod test_map {
     }
 
     #[test]
-    #[cfg(not(miri))] // FIXME: https://github.com/rust-lang/miri/issues/655
+    fn test_drain_filter() {
+        {
+            let mut map: HashMap<i32, i32> = (0..8).map(|x| (x, x * 10)).collect();
+            let drained = map.drain_filter(|&k, _| k % 2 == 0);
+            let mut out = drained.collect::<Vec<_>>();
+            out.sort_unstable();
+            assert_eq!(vec![(1, 10), (3, 30), (5, 50), (7, 70)], out);
+            assert_eq!(map.len(), 4);
+        }
+        {
+            let mut map: HashMap<i32, i32> = (0..8).map(|x| (x, x * 10)).collect();
+            drop(map.drain_filter(|&k, _| k % 2 == 0));
+            assert_eq!(map.len(), 4);
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // FIXME: no OOM signalling (https://github.com/rust-lang/miri/issues/613)
     fn test_try_reserve() {
         let mut empty_bytes: HashMap<u8, u8> = HashMap::new();
 

tests/set.rs

@@ -1,7 +1,7 @@
 #![cfg(not(miri))] // FIXME: takes too long
 
 use hashbrown::HashSet;
-use rand::{distributions::Alphanumeric, Rng, SeedableRng, XorShiftRng};
+use rand::{distributions::Alphanumeric, rngs::SmallRng, Rng, SeedableRng};
 
 #[test]
 fn test_hashset_insert_remove() {
@@ -12,8 +12,7 @@ fn test_hashset_insert_remove() {
         130, 220, 246, 217, 111, 124, 221, 189, 190, 234, 121, 93, 67, 95, 100, 43,
     ];
 
-    let mut rng: XorShiftRng = SeedableRng::from_seed(seed);
-    //let mut rng: XorShiftRng = XorShiftRng::new_unseeded();
+    let rng = &mut SmallRng::from_seed(seed);
     let tx: Vec<Vec<char>> = (0..4096)
         .map(|_| (rng.sample_iter(&Alphanumeric).take(32).collect()))
         .collect();