| use crate::raw::{Bucket, RawDrain, RawIntoIter, RawIter, RawTable}; |
| use crate::CollectionAllocErr; |
| use core::borrow::Borrow; |
| use core::fmt::{self, Debug}; |
| use core::hash::{BuildHasher, Hash, Hasher}; |
| use core::iter::{FromIterator, FusedIterator}; |
| use core::marker::PhantomData; |
| use core::mem; |
| use core::ops::Index; |
| |
| /// Default hasher for `HashMap`. |
| #[cfg(feature = "ahash")] |
| pub type DefaultHashBuilder = ahash::RandomState; |
| |
| /// Dummy default hasher for `HashMap`. |
| #[cfg(not(feature = "ahash"))] |
| pub enum DefaultHashBuilder {} |
| |
| /// A hash map implemented with quadratic probing and SIMD lookup. |
| /// |
| /// The default hashing algorithm is currently [`AHash`], though this is |
| /// subject to change at any point in the future. This hash function is very |
| /// fast for all types of keys, but this algorithm will typically *not* protect |
| /// against attacks such as HashDoS. |
| /// |
| /// The hashing algorithm can be replaced on a per-`HashMap` basis using the |
| /// [`default`], [`with_hasher`], and [`with_capacity_and_hasher`] methods. Many |
| /// alternative algorithms are available on crates.io, such as the [`fnv`] crate. |
| /// |
| /// It is required that the keys implement the [`Eq`] and [`Hash`] traits, although |
| /// this can frequently be achieved by using `#[derive(PartialEq, Eq, Hash)]`. |
| /// If you implement these yourself, it is important that the following |
| /// property holds: |
| /// |
| /// ```text |
| /// k1 == k2 -> hash(k1) == hash(k2) |
| /// ``` |
| /// |
| /// In other words, if two keys are equal, their hashes must be equal. |
| /// |
| /// It is a logic error for a key to be modified in such a way that the key's |
| /// hash, as determined by the [`Hash`] trait, or its equality, as determined by |
| /// the [`Eq`] trait, changes while it is in the map. This is normally only |
| /// possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code. |
| /// |
| /// It is also a logic error for the [`Hash`] implementation of a key to panic. |
| /// This is generally only possible if the trait is implemented manually. If a |
| /// panic does occur then the contents of the `HashMap` may become corrupted and |
| /// some items may be dropped from the table. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// // Type inference lets us omit an explicit type signature (which |
| /// // would be `HashMap<String, String>` in this example). |
| /// let mut book_reviews = HashMap::new(); |
| /// |
| /// // Review some books. |
| /// book_reviews.insert( |
| /// "Adventures of Huckleberry Finn".to_string(), |
| /// "My favorite book.".to_string(), |
| /// ); |
| /// book_reviews.insert( |
| /// "Grimms' Fairy Tales".to_string(), |
| /// "Masterpiece.".to_string(), |
| /// ); |
| /// book_reviews.insert( |
| /// "Pride and Prejudice".to_string(), |
| /// "Very enjoyable.".to_string(), |
| /// ); |
| /// book_reviews.insert( |
| /// "The Adventures of Sherlock Holmes".to_string(), |
| /// "Eye lyked it alot.".to_string(), |
| /// ); |
| /// |
| /// // Check for a specific one. |
| /// // When collections store owned values (String), they can still be |
| /// // queried using references (&str). |
| /// if !book_reviews.contains_key("Les Misérables") { |
| /// println!("We've got {} reviews, but Les Misérables ain't one.", |
| /// book_reviews.len()); |
| /// } |
| /// |
| /// // oops, this review has a lot of spelling mistakes, let's delete it. |
| /// book_reviews.remove("The Adventures of Sherlock Holmes"); |
| /// |
| /// // Look up the values associated with some keys. |
| /// let to_find = ["Pride and Prejudice", "Alice's Adventure in Wonderland"]; |
| /// for &book in &to_find { |
| /// match book_reviews.get(book) { |
| /// Some(review) => println!("{}: {}", book, review), |
| /// None => println!("{} is unreviewed.", book) |
| /// } |
| /// } |
| /// |
| /// // Look up the value for a key (will panic if the key is not found). |
| /// println!("Review for Jane: {}", book_reviews["Pride and Prejudice"]); |
| /// |
| /// // Iterate over everything. |
| /// for (book, review) in &book_reviews { |
| /// println!("{}: \"{}\"", book, review); |
| /// } |
| /// ``` |
| /// |
| /// `HashMap` also implements an [`Entry API`](#method.entry), which allows |
| /// for more complex methods of getting, setting, updating and removing keys and |
| /// their values: |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// // type inference lets us omit an explicit type signature (which |
| /// // would be `HashMap<&str, u8>` in this example). |
| /// let mut player_stats = HashMap::new(); |
| /// |
| /// fn random_stat_buff() -> u8 { |
| /// // could actually return some random value here - let's just return |
| /// // some fixed value for now |
| /// 42 |
| /// } |
| /// |
| /// // insert a key only if it doesn't already exist |
| /// player_stats.entry("health").or_insert(100); |
| /// |
| /// // insert a key using a function that provides a new value only if it |
| /// // doesn't already exist |
| /// player_stats.entry("defence").or_insert_with(random_stat_buff); |
| /// |
| /// // update a key, guarding against the key possibly not being set |
| /// let stat = player_stats.entry("attack").or_insert(100); |
| /// *stat += random_stat_buff(); |
| /// ``` |
| /// |
| /// The easiest way to use `HashMap` with a custom key type is to derive [`Eq`] and [`Hash`]. |
| /// We must also derive [`PartialEq`]. |
| /// |
| /// [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html |
| /// [`Hash`]: https://doc.rust-lang.org/std/hash/trait.Hash.html |
| /// [`PartialEq`]: https://doc.rust-lang.org/std/cmp/trait.PartialEq.html |
| /// [`RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html |
| /// [`Cell`]: https://doc.rust-lang.org/std/cell/struct.Cell.html |
| /// [`default`]: #method.default |
| /// [`with_hasher`]: #method.with_hasher |
| /// [`with_capacity_and_hasher`]: #method.with_capacity_and_hasher |
| /// [`fnv`]: https://crates.io/crates/fnv |
| /// [`AHash`]: https://crates.io/crates/ahash |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// #[derive(Hash, Eq, PartialEq, Debug)] |
| /// struct Viking { |
| /// name: String, |
| /// country: String, |
| /// } |
| /// |
| /// impl Viking { |
| /// /// Creates a new Viking. |
| /// fn new(name: &str, country: &str) -> Viking { |
| /// Viking { name: name.to_string(), country: country.to_string() } |
| /// } |
| /// } |
| /// |
| /// // Use a HashMap to store the vikings' health points. |
| /// let mut vikings = HashMap::new(); |
| /// |
| /// vikings.insert(Viking::new("Einar", "Norway"), 25); |
| /// vikings.insert(Viking::new("Olaf", "Denmark"), 24); |
| /// vikings.insert(Viking::new("Harald", "Iceland"), 12); |
| /// |
| /// // Use derived implementation to print the status of the vikings. |
| /// for (viking, health) in &vikings { |
| /// println!("{:?} has {} hp", viking, health); |
| /// } |
| /// ``` |
| /// |
| /// A `HashMap` with fixed list of elements can be initialized from an array: |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let timber_resources: HashMap<&str, i32> = |
| /// [("Norway", 100), |
| /// ("Denmark", 50), |
| /// ("Iceland", 10)] |
| /// .iter().cloned().collect(); |
| /// // use the values stored in map |
| /// ``` |
| pub struct HashMap<K, V, S = DefaultHashBuilder> { |
| pub(crate) hash_builder: S, |
| pub(crate) table: RawTable<(K, V)>, |
| } |
| |
| impl<K: Clone, V: Clone, S: Clone> Clone for HashMap<K, V, S> { |
| fn clone(&self) -> Self { |
| HashMap { |
| hash_builder: self.hash_builder.clone(), |
| table: self.table.clone(), |
| } |
| } |
| |
| fn clone_from(&mut self, source: &Self) { |
| // We clone the hash_builder first since this might panic and we don't |
| // want the table to have elements hashed with the wrong hash_builder. |
| let hash_builder = source.hash_builder.clone(); |
| |
| #[cfg(not(feature = "nightly"))] |
| { |
| self.table.clone_from(&source.table); |
| } |
| #[cfg(feature = "nightly")] |
| { |
| trait HashClone<S> { |
| fn clone_from(&mut self, source: &Self, hash_builder: &S); |
| } |
| impl<K: Clone, V: Clone, S> HashClone<S> for HashMap<K, V, S> { |
| default fn clone_from(&mut self, source: &Self, _hash_builder: &S) { |
| self.table.clone_from(&source.table); |
| } |
| } |
| impl<K: Clone, V: Clone, S> HashClone<S> for HashMap<K, V, S> |
| where |
| K: Eq + Hash, |
| S: BuildHasher, |
| { |
| fn clone_from(&mut self, source: &Self, hash_builder: &S) { |
| self.table |
| .clone_from_with_hasher(&source.table, |x| make_hash(hash_builder, &x.0)); |
| } |
| } |
| HashClone::clone_from(self, source, &hash_builder); |
| } |
| |
| // Update hash_builder only if we successfully cloned all elements. |
| self.hash_builder = hash_builder; |
| } |
| } |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub(crate) fn make_hash<K: Hash + ?Sized>(hash_builder: &impl BuildHasher, val: &K) -> u64 { |
| let mut state = hash_builder.build_hasher(); |
| val.hash(&mut state); |
| state.finish() |
| } |
| |
| #[cfg(feature = "ahash")] |
| impl<K, V> HashMap<K, V, DefaultHashBuilder> { |
| /// Creates an empty `HashMap`. |
| /// |
| /// The hash map is initially created with a capacity of 0, so it will not allocate until it |
| /// is first inserted into. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// let mut map: HashMap<&str, i32> = HashMap::new(); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn new() -> Self { |
| Self::default() |
| } |
| |
| /// Creates an empty `HashMap` with the specified capacity. |
| /// |
| /// The hash map will be able to hold at least `capacity` elements without |
| /// reallocating. If `capacity` is 0, the hash map will not allocate. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// let mut map: HashMap<&str, i32> = HashMap::with_capacity(10); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn with_capacity(capacity: usize) -> Self { |
| Self::with_capacity_and_hasher(capacity, DefaultHashBuilder::default()) |
| } |
| } |
| |
| impl<K, V, S> HashMap<K, V, S> { |
| /// Creates an empty `HashMap` which will use the given hash builder to hash |
| /// keys. |
| /// |
| /// The created map has the default initial capacity. |
| /// |
| /// Warning: `hash_builder` is normally randomly generated, and |
| /// is designed to allow HashMaps to be resistant to attacks that |
| /// cause many collisions and very poor performance. Setting it |
| /// manually using this function can expose a DoS attack vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::DefaultHashBuilder; |
| /// |
| /// let s = DefaultHashBuilder::default(); |
| /// let mut map = HashMap::with_hasher(s); |
| /// map.insert(1, 2); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn with_hasher(hash_builder: S) -> Self { |
| Self { |
| hash_builder, |
| table: RawTable::new(), |
| } |
| } |
| |
| /// Creates an empty `HashMap` with the specified capacity, using `hash_builder` |
| /// to hash the keys. |
| /// |
| /// The hash map will be able to hold at least `capacity` elements without |
| /// reallocating. If `capacity` is 0, the hash map will not allocate. |
| /// |
| /// Warning: `hash_builder` is normally randomly generated, and |
| /// is designed to allow HashMaps to be resistant to attacks that |
| /// cause many collisions and very poor performance. Setting it |
| /// manually using this function can expose a DoS attack vector. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::DefaultHashBuilder; |
| /// |
| /// let s = DefaultHashBuilder::default(); |
| /// let mut map = HashMap::with_capacity_and_hasher(10, s); |
| /// map.insert(1, 2); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> Self { |
| Self { |
| hash_builder, |
| table: RawTable::with_capacity(capacity), |
| } |
| } |
| |
| /// Returns a reference to the map's [`BuildHasher`]. |
| /// |
| /// [`BuildHasher`]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::DefaultHashBuilder; |
| /// |
| /// let hasher = DefaultHashBuilder::default(); |
| /// let map: HashMap<i32, i32> = HashMap::with_hasher(hasher); |
| /// let hasher: &DefaultHashBuilder = map.hasher(); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn hasher(&self) -> &S { |
| &self.hash_builder |
| } |
| |
| /// Returns the number of elements the map can hold without reallocating. |
| /// |
| /// This number is a lower bound; the `HashMap<K, V>` might be able to hold |
| /// more, but is guaranteed to be able to hold at least this many. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// let map: HashMap<i32, i32> = HashMap::with_capacity(100); |
| /// assert!(map.capacity() >= 100); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn capacity(&self) -> usize { |
| self.table.capacity() |
| } |
| |
| /// An iterator visiting all keys in arbitrary order. |
| /// The iterator element type is `&'a K`. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert("a", 1); |
| /// map.insert("b", 2); |
| /// map.insert("c", 3); |
| /// |
| /// for key in map.keys() { |
| /// println!("{}", key); |
| /// } |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn keys(&self) -> Keys<'_, K, V> { |
| Keys { inner: self.iter() } |
| } |
| |
| /// An iterator visiting all values in arbitrary order. |
| /// The iterator element type is `&'a V`. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert("a", 1); |
| /// map.insert("b", 2); |
| /// map.insert("c", 3); |
| /// |
| /// for val in map.values() { |
| /// println!("{}", val); |
| /// } |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn values(&self) -> Values<'_, K, V> { |
| Values { inner: self.iter() } |
| } |
| |
| /// An iterator visiting all values mutably in arbitrary order. |
| /// The iterator element type is `&'a mut V`. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// |
| /// map.insert("a", 1); |
| /// map.insert("b", 2); |
| /// map.insert("c", 3); |
| /// |
| /// for val in map.values_mut() { |
| /// *val = *val + 10; |
| /// } |
| /// |
| /// for val in map.values() { |
| /// println!("{}", val); |
| /// } |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> { |
| ValuesMut { |
| inner: self.iter_mut(), |
| } |
| } |
| |
| /// An iterator visiting all key-value pairs in arbitrary order. |
| /// The iterator element type is `(&'a K, &'a V)`. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert("a", 1); |
| /// map.insert("b", 2); |
| /// map.insert("c", 3); |
| /// |
| /// for (key, val) in map.iter() { |
| /// println!("key: {} val: {}", key, val); |
| /// } |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn iter(&self) -> Iter<'_, K, V> { |
| // Here we tie the lifetime of self to the iter. |
| unsafe { |
| Iter { |
| inner: self.table.iter(), |
| marker: PhantomData, |
| } |
| } |
| } |
| |
| /// An iterator visiting all key-value pairs in arbitrary order, |
| /// with mutable references to the values. |
| /// The iterator element type is `(&'a K, &'a mut V)`. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert("a", 1); |
| /// map.insert("b", 2); |
| /// map.insert("c", 3); |
| /// |
| /// // Update all values |
| /// for (_, val) in map.iter_mut() { |
| /// *val *= 2; |
| /// } |
| /// |
| /// for (key, val) in &map { |
| /// println!("key: {} val: {}", key, val); |
| /// } |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn iter_mut(&mut self) -> IterMut<'_, K, V> { |
| // Here we tie the lifetime of self to the iter. |
| unsafe { |
| IterMut { |
| inner: self.table.iter(), |
| marker: PhantomData, |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn raw_capacity(&self) -> usize { |
| self.table.buckets() |
| } |
| |
| /// Returns the number of elements in the map. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut a = HashMap::new(); |
| /// assert_eq!(a.len(), 0); |
| /// a.insert(1, "a"); |
| /// assert_eq!(a.len(), 1); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn len(&self) -> usize { |
| self.table.len() |
| } |
| |
| /// Returns `true` if the map contains no elements. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut a = HashMap::new(); |
| /// assert!(a.is_empty()); |
| /// a.insert(1, "a"); |
| /// assert!(!a.is_empty()); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn is_empty(&self) -> bool { |
| self.len() == 0 |
| } |
| |
| /// Clears the map, returning all key-value pairs as an iterator. Keeps the |
| /// allocated memory for reuse. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut a = HashMap::new(); |
| /// a.insert(1, "a"); |
| /// a.insert(2, "b"); |
| /// |
| /// for (k, v) in a.drain().take(1) { |
| /// assert!(k == 1 || k == 2); |
| /// assert!(v == "a" || v == "b"); |
| /// } |
| /// |
| /// assert!(a.is_empty()); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn drain(&mut self) -> Drain<'_, K, V> { |
| // Here we tie the lifetime of self to the iter. |
| unsafe { |
| Drain { |
| inner: self.table.drain(), |
| } |
| } |
| } |
| |
| /// Clears the map, removing all key-value pairs. Keeps the allocated memory |
| /// for reuse. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut a = HashMap::new(); |
| /// a.insert(1, "a"); |
| /// a.clear(); |
| /// assert!(a.is_empty()); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn clear(&mut self) { |
| self.table.clear(); |
| } |
| } |
| |
| impl<K, V, S> HashMap<K, V, S> |
| where |
| K: Eq + Hash, |
| S: BuildHasher, |
| { |
| /// Reserves capacity for at least `additional` more elements to be inserted |
| /// in the `HashMap`. The collection may reserve more space to avoid |
| /// frequent reallocations. |
| /// |
| /// # Panics |
| /// |
| /// Panics if the new allocation size overflows [`usize`]. |
| /// |
| /// [`usize`]: https://doc.rust-lang.org/std/primitive.usize.html |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// let mut map: HashMap<&str, i32> = HashMap::new(); |
| /// map.reserve(10); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn reserve(&mut self, additional: usize) { |
| let hash_builder = &self.hash_builder; |
| self.table |
| .reserve(additional, |x| make_hash(hash_builder, &x.0)); |
| } |
| |
| /// Tries to reserve capacity for at least `additional` more elements to be inserted |
| /// in the given `HashMap<K,V>`. The collection may reserve more space to avoid |
| /// frequent reallocations. |
| /// |
| /// # Errors |
| /// |
| /// If the capacity overflows, or the allocator reports a failure, then an error |
| /// is returned. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// let mut map: HashMap<&str, isize> = HashMap::new(); |
| /// map.try_reserve(10).expect("why is the test harness OOMing on 10 bytes?"); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn try_reserve(&mut self, additional: usize) -> Result<(), CollectionAllocErr> { |
| let hash_builder = &self.hash_builder; |
| self.table |
| .try_reserve(additional, |x| make_hash(hash_builder, &x.0)) |
| } |
| |
| /// Shrinks the capacity of the map as much as possible. It will drop |
| /// down as much as possible while maintaining the internal rules |
| /// and possibly leaving some space in accordance with the resize policy. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<i32, i32> = HashMap::with_capacity(100); |
| /// map.insert(1, 2); |
| /// map.insert(3, 4); |
| /// assert!(map.capacity() >= 100); |
| /// map.shrink_to_fit(); |
| /// assert!(map.capacity() >= 2); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn shrink_to_fit(&mut self) { |
| let hash_builder = &self.hash_builder; |
| self.table.shrink_to(0, |x| make_hash(hash_builder, &x.0)); |
| } |
| |
| /// Shrinks the capacity of the map with a lower limit. It will drop |
| /// down no lower than the supplied limit while maintaining the internal rules |
| /// and possibly leaving some space in accordance with the resize policy. |
| /// |
| /// This function does nothing if the current capacity is smaller than the |
| /// supplied minimum capacity. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<i32, i32> = HashMap::with_capacity(100); |
| /// map.insert(1, 2); |
| /// map.insert(3, 4); |
| /// assert!(map.capacity() >= 100); |
| /// map.shrink_to(10); |
| /// assert!(map.capacity() >= 10); |
| /// map.shrink_to(0); |
| /// assert!(map.capacity() >= 2); |
| /// map.shrink_to(10); |
| /// assert!(map.capacity() >= 2); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn shrink_to(&mut self, min_capacity: usize) { |
| let hash_builder = &self.hash_builder; |
| self.table |
| .shrink_to(min_capacity, |x| make_hash(hash_builder, &x.0)); |
| } |
| |
| /// Gets the given key's corresponding entry in the map for in-place manipulation. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut letters = HashMap::new(); |
| /// |
| /// for ch in "a short treatise on fungi".chars() { |
| /// let counter = letters.entry(ch).or_insert(0); |
| /// *counter += 1; |
| /// } |
| /// |
| /// assert_eq!(letters[&'s'], 2); |
| /// assert_eq!(letters[&'t'], 3); |
| /// assert_eq!(letters[&'u'], 1); |
| /// assert_eq!(letters.get(&'y'), None); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn entry(&mut self, key: K) -> Entry<'_, K, V, S> { |
| let hash = make_hash(&self.hash_builder, &key); |
| if let Some(elem) = self.table.find(hash, |q| q.0.eq(&key)) { |
| Entry::Occupied(OccupiedEntry { |
| key: Some(key), |
| elem, |
| table: self, |
| }) |
| } else { |
| Entry::Vacant(VacantEntry { |
| hash, |
| key, |
| table: self, |
| }) |
| } |
| } |
| |
| /// Returns a reference to the value corresponding to the key. |
| /// |
| /// The key may be any borrowed form of the map's key type, but |
| /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for |
| /// the key type. |
| /// |
| /// [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html |
| /// [`Hash`]: https://doc.rust-lang.org/std/hash/trait.Hash.html |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert(1, "a"); |
| /// assert_eq!(map.get(&1), Some(&"a")); |
| /// assert_eq!(map.get(&2), None); |
| /// ``` |
| #[inline] |
| pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V> |
| where |
| K: Borrow<Q>, |
| Q: Hash + Eq, |
| { |
| self.get_key_value(k).map(|(_, v)| v) |
| } |
| |
| /// Returns the key-value pair corresponding to the supplied key. |
| /// |
| /// The supplied key may be any borrowed form of the map's key type, but |
| /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for |
| /// the key type. |
| /// |
| /// [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html |
| /// [`Hash`]: https://doc.rust-lang.org/std/hash/trait.Hash.html |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert(1, "a"); |
| /// assert_eq!(map.get_key_value(&1), Some((&1, &"a"))); |
| /// assert_eq!(map.get_key_value(&2), None); |
| /// ``` |
| #[inline] |
| pub fn get_key_value<Q: ?Sized>(&self, k: &Q) -> Option<(&K, &V)> |
| where |
| K: Borrow<Q>, |
| Q: Hash + Eq, |
| { |
| let hash = make_hash(&self.hash_builder, k); |
| self.table |
| .find(hash, |x| k.eq(x.0.borrow())) |
| .map(|item| unsafe { |
| let &(ref key, ref value) = item.as_ref(); |
| (key, value) |
| }) |
| } |
| |
| /// Returns the key-value pair corresponding to the supplied key, with a mutable reference to value. |
| /// |
| /// The supplied key may be any borrowed form of the map's key type, but |
| /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for |
| /// the key type. |
| /// |
| /// [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html |
| /// [`Hash`]: https://doc.rust-lang.org/std/hash/trait.Hash.html |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert(1, "a"); |
| /// let (k, v) = map.get_key_value_mut(&1).unwrap(); |
| /// assert_eq!(k, &1); |
| /// assert_eq!(v, &mut "a"); |
| /// *v = "b"; |
| /// assert_eq!(map.get_key_value_mut(&1), Some((&1, &mut "b"))); |
| /// assert_eq!(map.get_key_value_mut(&2), None); |
| /// ``` |
| #[inline] |
| pub fn get_key_value_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<(&K, &mut V)> |
| where |
| K: Borrow<Q>, |
| Q: Hash + Eq, |
| { |
| let hash = make_hash(&self.hash_builder, k); |
| self.table |
| .find(hash, |x| k.eq(x.0.borrow())) |
| .map(|item| unsafe { |
| let &mut (ref key, ref mut value) = item.as_mut(); |
| (key, value) |
| }) |
| } |
| |
| /// Returns `true` if the map contains a value for the specified key. |
| /// |
| /// The key may be any borrowed form of the map's key type, but |
| /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for |
| /// the key type. |
| /// |
| /// [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html |
| /// [`Hash`]: https://doc.rust-lang.org/std/hash/trait.Hash.html |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert(1, "a"); |
| /// assert_eq!(map.contains_key(&1), true); |
| /// assert_eq!(map.contains_key(&2), false); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool |
| where |
| K: Borrow<Q>, |
| Q: Hash + Eq, |
| { |
| self.get(k).is_some() |
| } |
| |
| /// Returns a mutable reference to the value corresponding to the key. |
| /// |
| /// The key may be any borrowed form of the map's key type, but |
| /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for |
| /// the key type. |
| /// |
| /// [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html |
| /// [`Hash`]: https://doc.rust-lang.org/std/hash/trait.Hash.html |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert(1, "a"); |
| /// if let Some(x) = map.get_mut(&1) { |
| /// *x = "b"; |
| /// } |
| /// assert_eq!(map[&1], "b"); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V> |
| where |
| K: Borrow<Q>, |
| Q: Hash + Eq, |
| { |
| let hash = make_hash(&self.hash_builder, k); |
| self.table |
| .find(hash, |x| k.eq(x.0.borrow())) |
| .map(|item| unsafe { &mut item.as_mut().1 }) |
| } |
| |
| /// Inserts a key-value pair into the map. |
| /// |
| /// If the map did not have this key present, [`None`] is returned. |
| /// |
| /// If the map did have this key present, the value is updated, and the old |
| /// value is returned. The key is not updated, though; this matters for |
| /// types that can be `==` without being identical. See the [module-level |
| /// documentation] for more. |
| /// |
| /// [`None`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.None |
| /// [module-level documentation]: index.html#insert-and-complex-keys |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// assert_eq!(map.insert(37, "a"), None); |
| /// assert_eq!(map.is_empty(), false); |
| /// |
| /// map.insert(37, "b"); |
| /// assert_eq!(map.insert(37, "c"), Some("b")); |
| /// assert_eq!(map[&37], "c"); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn insert(&mut self, k: K, v: V) -> Option<V> { |
| unsafe { |
| let hash = make_hash(&self.hash_builder, &k); |
| if let Some(item) = self.table.find(hash, |x| k.eq(&x.0)) { |
| Some(mem::replace(&mut item.as_mut().1, v)) |
| } else { |
| let hash_builder = &self.hash_builder; |
| self.table |
| .insert(hash, (k, v), |x| make_hash(hash_builder, &x.0)); |
| None |
| } |
| } |
| } |
| |
| /// Removes a key from the map, returning the value at the key if the key |
| /// was previously in the map. |
| /// |
| /// The key may be any borrowed form of the map's key type, but |
| /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for |
| /// the key type. |
| /// |
| /// [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html |
| /// [`Hash`]: https://doc.rust-lang.org/std/hash/trait.Hash.html |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert(1, "a"); |
| /// assert_eq!(map.remove(&1), Some("a")); |
| /// assert_eq!(map.remove(&1), None); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V> |
| where |
| K: Borrow<Q>, |
| Q: Hash + Eq, |
| { |
| self.remove_entry(k).map(|(_, v)| v) |
| } |
| |
| /// Removes a key from the map, returning the stored key and value if the |
| /// key was previously in the map. |
| /// |
| /// The key may be any borrowed form of the map's key type, but |
| /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for |
| /// the key type. |
| /// |
| /// [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html |
| /// [`Hash`]: https://doc.rust-lang.org/std/hash/trait.Hash.html |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert(1, "a"); |
| /// assert_eq!(map.remove_entry(&1), Some((1, "a"))); |
| /// assert_eq!(map.remove(&1), None); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn remove_entry<Q: ?Sized>(&mut self, k: &Q) -> Option<(K, V)> |
| where |
| K: Borrow<Q>, |
| Q: Hash + Eq, |
| { |
| unsafe { |
| let hash = make_hash(&self.hash_builder, &k); |
| if let Some(item) = self.table.find(hash, |x| k.eq(x.0.borrow())) { |
| self.table.erase_no_drop(&item); |
| Some(item.read()) |
| } else { |
| None |
| } |
| } |
| } |
| |
| /// Retains only the elements specified by the predicate. |
| /// |
| /// In other words, remove all pairs `(k, v)` such that `f(&k,&mut v)` returns `false`. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<i32, i32> = (0..8).map(|x|(x, x*10)).collect(); |
| /// map.retain(|&k, _| k % 2 == 0); |
| /// assert_eq!(map.len(), 4); |
| /// ``` |
| pub fn retain<F>(&mut self, mut f: F) |
| 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.iter() { |
| let &mut (ref key, ref mut value) = item.as_mut(); |
| if !f(key, value) { |
| // Erase the element from the table first since drop might panic. |
| self.table.erase_no_drop(&item); |
| item.drop(); |
| } |
| } |
| } |
| } |
| /// 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> { |
| /// Creates a raw entry builder for the HashMap. |
| /// |
| /// Raw entries provide the lowest level of control for searching and |
| /// manipulating a map. They must be manually initialized with a hash and |
| /// then manually searched. After this, insertions into a vacant entry |
| /// still require an owned key to be provided. |
| /// |
| /// Raw entries are useful for such exotic situations as: |
| /// |
| /// * Hash memoization |
| /// * Deferring the creation of an owned key until it is known to be required |
| /// * Using a search key that doesn't work with the Borrow trait |
| /// * Using custom comparison logic without newtype wrappers |
| /// |
| /// Because raw entries provide much more low-level control, it's much easier |
| /// to put the HashMap into an inconsistent state which, while memory-safe, |
| /// will cause the map to produce seemingly random results. Higher-level and |
| /// more foolproof APIs like `entry` should be preferred when possible. |
| /// |
| /// In particular, the hash used to initialized the raw entry must still be |
| /// consistent with the hash of the key that is ultimately stored in the entry. |
| /// This is because implementations of HashMap may need to recompute hashes |
| /// when resizing, at which point only the keys are available. |
| /// |
| /// Raw entries give mutable access to the keys. This must not be used |
| /// to modify how the key would compare or hash, as the map will not re-evaluate |
| /// where the key should go, meaning the keys may become "lost" if their |
| /// location does not reflect their state. For instance, if you change a key |
| /// so that the map now contains keys which compare equal, search may start |
| /// acting erratically, with two keys randomly masking each other. Implementations |
| /// are free to assume this doesn't happen (within the limits of memory-safety). |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn raw_entry_mut(&mut self) -> RawEntryBuilderMut<'_, K, V, S> { |
| RawEntryBuilderMut { map: self } |
| } |
| |
| /// Creates a raw immutable entry builder for the HashMap. |
| /// |
| /// Raw entries provide the lowest level of control for searching and |
| /// manipulating a map. They must be manually initialized with a hash and |
| /// then manually searched. |
| /// |
| /// This is useful for |
| /// * Hash memoization |
| /// * Using a search key that doesn't work with the Borrow trait |
| /// * Using custom comparison logic without newtype wrappers |
| /// |
| /// Unless you are in such a situation, higher-level and more foolproof APIs like |
| /// `get` should be preferred. |
| /// |
| /// Immutable raw entries have very limited use; you might instead want `raw_entry_mut`. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn raw_entry(&self) -> RawEntryBuilder<'_, K, V, S> { |
| RawEntryBuilder { map: self } |
| } |
| } |
| |
| impl<K, V, S> PartialEq for HashMap<K, V, S> |
| where |
| K: Eq + Hash, |
| V: PartialEq, |
| S: BuildHasher, |
| { |
| fn eq(&self, other: &Self) -> bool { |
| if self.len() != other.len() { |
| return false; |
| } |
| |
| self.iter() |
| .all(|(key, value)| other.get(key).map_or(false, |v| *value == *v)) |
| } |
| } |
| |
| impl<K, V, S> Eq for HashMap<K, V, S> |
| where |
| K: Eq + Hash, |
| V: Eq, |
| S: BuildHasher, |
| { |
| } |
| |
| impl<K, V, S> Debug for HashMap<K, V, S> |
| where |
| K: Debug, |
| V: Debug, |
| { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_map().entries(self.iter()).finish() |
| } |
| } |
| |
| impl<K, V, S> Default for HashMap<K, V, S> |
| where |
| S: Default, |
| { |
| /// Creates an empty `HashMap<K, V, S>`, with the `Default` value for the hasher. |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn default() -> Self { |
| Self::with_hasher(Default::default()) |
| } |
| } |
| |
| impl<K, Q: ?Sized, V, S> Index<&Q> for HashMap<K, V, S> |
| where |
| K: Eq + Hash + Borrow<Q>, |
| Q: Eq + Hash, |
| S: BuildHasher, |
| { |
| type Output = V; |
| |
| /// Returns a reference to the value corresponding to the supplied key. |
| /// |
| /// # Panics |
| /// |
| /// Panics if the key is not present in the `HashMap`. |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn index(&self, key: &Q) -> &V { |
| self.get(key).expect("no entry found for key") |
| } |
| } |
| |
| /// An iterator over the entries of a `HashMap`. |
| /// |
| /// This `struct` is created by the [`iter`] method on [`HashMap`]. See its |
| /// documentation for more. |
| /// |
| /// [`iter`]: struct.HashMap.html#method.iter |
| /// [`HashMap`]: struct.HashMap.html |
| pub struct Iter<'a, K, V> { |
| inner: RawIter<(K, V)>, |
| marker: PhantomData<(&'a K, &'a V)>, |
| } |
| |
| // FIXME(#26925) Remove in favor of `#[derive(Clone)]` |
| impl<K, V> Clone for Iter<'_, K, V> { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn clone(&self) -> Self { |
| Iter { |
| inner: self.inner.clone(), |
| marker: PhantomData, |
| } |
| } |
| } |
| |
| impl<K: Debug, V: Debug> fmt::Debug for Iter<'_, K, V> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_list().entries(self.clone()).finish() |
| } |
| } |
| |
| /// A mutable iterator over the entries of a `HashMap`. |
| /// |
| /// This `struct` is created by the [`iter_mut`] method on [`HashMap`]. See its |
| /// documentation for more. |
| /// |
| /// [`iter_mut`]: struct.HashMap.html#method.iter_mut |
| /// [`HashMap`]: struct.HashMap.html |
| pub struct IterMut<'a, K, V> { |
| inner: RawIter<(K, V)>, |
| // To ensure invariance with respect to V |
| marker: PhantomData<(&'a K, &'a mut V)>, |
| } |
| |
| // We override the default Send impl which has K: Sync instead of K: Send. Both |
| // are correct, but this one is more general since it allows keys which |
| // implement Send but not Sync. |
| unsafe impl<K: Send, V: Send> Send for IterMut<'_, K, V> {} |
| |
| impl<K, V> IterMut<'_, K, V> { |
| /// Returns a iterator of references over the remaining items. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub(super) fn iter(&self) -> Iter<'_, K, V> { |
| Iter { |
| inner: self.inner.clone(), |
| marker: PhantomData, |
| } |
| } |
| } |
| |
| /// An owning iterator over the entries of a `HashMap`. |
| /// |
| /// This `struct` is created by the [`into_iter`] method on [`HashMap`][`HashMap`] |
| /// (provided by the `IntoIterator` trait). See its documentation for more. |
| /// |
| /// [`into_iter`]: struct.HashMap.html#method.into_iter |
| /// [`HashMap`]: struct.HashMap.html |
| pub struct IntoIter<K, V> { |
| inner: RawIntoIter<(K, V)>, |
| } |
| |
| impl<K, V> IntoIter<K, V> { |
| /// Returns a iterator of references over the remaining items. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub(super) fn iter(&self) -> Iter<'_, K, V> { |
| Iter { |
| inner: self.inner.iter(), |
| marker: PhantomData, |
| } |
| } |
| } |
| |
| /// An iterator over the keys of a `HashMap`. |
| /// |
| /// This `struct` is created by the [`keys`] method on [`HashMap`]. See its |
| /// documentation for more. |
| /// |
| /// [`keys`]: struct.HashMap.html#method.keys |
| /// [`HashMap`]: struct.HashMap.html |
| pub struct Keys<'a, K, V> { |
| inner: Iter<'a, K, V>, |
| } |
| |
| // FIXME(#26925) Remove in favor of `#[derive(Clone)]` |
| impl<K, V> Clone for Keys<'_, K, V> { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn clone(&self) -> Self { |
| Keys { |
| inner: self.inner.clone(), |
| } |
| } |
| } |
| |
| impl<K: Debug, V> fmt::Debug for Keys<'_, K, V> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_list().entries(self.clone()).finish() |
| } |
| } |
| |
| /// An iterator over the values of a `HashMap`. |
| /// |
| /// This `struct` is created by the [`values`] method on [`HashMap`]. See its |
| /// documentation for more. |
| /// |
| /// [`values`]: struct.HashMap.html#method.values |
| /// [`HashMap`]: struct.HashMap.html |
| pub struct Values<'a, K, V> { |
| inner: Iter<'a, K, V>, |
| } |
| |
| // FIXME(#26925) Remove in favor of `#[derive(Clone)]` |
| impl<K, V> Clone for Values<'_, K, V> { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn clone(&self) -> Self { |
| Values { |
| inner: self.inner.clone(), |
| } |
| } |
| } |
| |
| impl<K, V: Debug> fmt::Debug for Values<'_, K, V> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_list().entries(self.clone()).finish() |
| } |
| } |
| |
| /// A draining iterator over the entries of a `HashMap`. |
| /// |
| /// This `struct` is created by the [`drain`] method on [`HashMap`]. See its |
| /// documentation for more. |
| /// |
| /// [`drain`]: struct.HashMap.html#method.drain |
| /// [`HashMap`]: struct.HashMap.html |
| pub struct Drain<'a, K, V> { |
| inner: RawDrain<'a, (K, V)>, |
| } |
| |
| impl<K, V> Drain<'_, K, V> { |
| /// Returns a iterator of references over the remaining items. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub(super) fn iter(&self) -> Iter<'_, K, V> { |
| Iter { |
| inner: self.inner.iter(), |
| marker: PhantomData, |
| } |
| } |
| } |
| |
| /// 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 |
| /// documentation for more. |
| /// |
| /// [`values_mut`]: struct.HashMap.html#method.values_mut |
| /// [`HashMap`]: struct.HashMap.html |
| pub struct ValuesMut<'a, K, V> { |
| inner: IterMut<'a, K, V>, |
| } |
| |
| /// A builder for computing where in a [`HashMap`] a key-value pair would be stored. |
| /// |
| /// See the [`HashMap::raw_entry_mut`] docs for usage examples. |
| /// |
| /// [`HashMap::raw_entry_mut`]: struct.HashMap.html#method.raw_entry_mut |
| pub struct RawEntryBuilderMut<'a, K, V, S> { |
| map: &'a mut HashMap<K, V, S>, |
| } |
| |
| /// A view into a single entry in a map, which may either be vacant or occupied. |
| /// |
| /// This is a lower-level version of [`Entry`]. |
| /// |
| /// This `enum` is constructed through the [`raw_entry_mut`] method on [`HashMap`], |
| /// then calling one of the methods of that [`RawEntryBuilderMut`]. |
| /// |
| /// [`HashMap`]: struct.HashMap.html |
| /// [`Entry`]: enum.Entry.html |
| /// [`raw_entry_mut`]: struct.HashMap.html#method.raw_entry_mut |
| /// [`RawEntryBuilderMut`]: struct.RawEntryBuilderMut.html |
| pub enum RawEntryMut<'a, K, V, S> { |
| /// An occupied entry. |
| Occupied(RawOccupiedEntryMut<'a, K, V>), |
| /// A vacant entry. |
| Vacant(RawVacantEntryMut<'a, K, V, S>), |
| } |
| |
| /// A view into an occupied entry in a `HashMap`. |
| /// It is part of the [`RawEntryMut`] enum. |
| /// |
| /// [`RawEntryMut`]: enum.RawEntryMut.html |
| pub struct RawOccupiedEntryMut<'a, K, V> { |
| elem: Bucket<(K, V)>, |
| table: &'a mut RawTable<(K, V)>, |
| } |
| |
| unsafe impl<K, V> Send for RawOccupiedEntryMut<'_, K, V> |
| where |
| K: Send, |
| V: Send, |
| { |
| } |
| unsafe impl<K, V> Sync for RawOccupiedEntryMut<'_, K, V> |
| where |
| K: Sync, |
| V: Sync, |
| { |
| } |
| |
| /// A view into a vacant entry in a `HashMap`. |
| /// It is part of the [`RawEntryMut`] enum. |
| /// |
| /// [`RawEntryMut`]: enum.RawEntryMut.html |
| pub struct RawVacantEntryMut<'a, K, V, S> { |
| table: &'a mut RawTable<(K, V)>, |
| hash_builder: &'a S, |
| } |
| |
| /// A builder for computing where in a [`HashMap`] a key-value pair would be stored. |
| /// |
| /// See the [`HashMap::raw_entry`] docs for usage examples. |
| /// |
| /// [`HashMap::raw_entry`]: struct.HashMap.html#method.raw_entry |
| pub struct RawEntryBuilder<'a, K, V, S> { |
| map: &'a HashMap<K, V, S>, |
| } |
| |
| impl<'a, K, V, S> RawEntryBuilderMut<'a, K, V, S> { |
| /// Creates a `RawEntryMut` from the given key. |
| #[cfg_attr(feature = "inline-more", inline)] |
| #[allow(clippy::wrong_self_convention)] |
| pub fn from_key<Q: ?Sized>(self, k: &Q) -> RawEntryMut<'a, K, V, S> |
| where |
| S: BuildHasher, |
| K: Borrow<Q>, |
| Q: Hash + Eq, |
| { |
| let mut hasher = self.map.hash_builder.build_hasher(); |
| k.hash(&mut hasher); |
| self.from_key_hashed_nocheck(hasher.finish(), k) |
| } |
| |
| /// Creates a `RawEntryMut` from the given key and its hash. |
| #[inline] |
| #[allow(clippy::wrong_self_convention)] |
| pub fn from_key_hashed_nocheck<Q: ?Sized>(self, hash: u64, k: &Q) -> RawEntryMut<'a, K, V, S> |
| where |
| K: Borrow<Q>, |
| Q: Eq, |
| { |
| self.from_hash(hash, |q| q.borrow().eq(k)) |
| } |
| } |
| |
| impl<'a, K, V, S> RawEntryBuilderMut<'a, K, V, S> { |
| /// Creates a `RawEntryMut` from the given hash. |
| #[cfg_attr(feature = "inline-more", inline)] |
| #[allow(clippy::wrong_self_convention)] |
| pub fn from_hash<F>(self, hash: u64, is_match: F) -> RawEntryMut<'a, K, V, S> |
| where |
| for<'b> F: FnMut(&'b K) -> bool, |
| { |
| self.search(hash, is_match) |
| } |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn search<F>(self, hash: u64, mut is_match: F) -> RawEntryMut<'a, K, V, S> |
| where |
| for<'b> F: FnMut(&'b K) -> bool, |
| { |
| match self.map.table.find(hash, |(k, _)| is_match(k)) { |
| Some(elem) => RawEntryMut::Occupied(RawOccupiedEntryMut { |
| elem, |
| table: &mut self.map.table, |
| }), |
| None => RawEntryMut::Vacant(RawVacantEntryMut { |
| table: &mut self.map.table, |
| hash_builder: &self.map.hash_builder, |
| }), |
| } |
| } |
| } |
| |
| impl<'a, K, V, S> RawEntryBuilder<'a, K, V, S> { |
| /// Access an entry by key. |
| #[cfg_attr(feature = "inline-more", inline)] |
| #[allow(clippy::wrong_self_convention)] |
| pub fn from_key<Q: ?Sized>(self, k: &Q) -> Option<(&'a K, &'a V)> |
| where |
| S: BuildHasher, |
| K: Borrow<Q>, |
| Q: Hash + Eq, |
| { |
| let mut hasher = self.map.hash_builder.build_hasher(); |
| k.hash(&mut hasher); |
| self.from_key_hashed_nocheck(hasher.finish(), k) |
| } |
| |
| /// Access an entry by a key and its hash. |
| #[cfg_attr(feature = "inline-more", inline)] |
| #[allow(clippy::wrong_self_convention)] |
| pub fn from_key_hashed_nocheck<Q: ?Sized>(self, hash: u64, k: &Q) -> Option<(&'a K, &'a V)> |
| where |
| K: Borrow<Q>, |
| Q: Hash + Eq, |
| { |
| self.from_hash(hash, |q| q.borrow().eq(k)) |
| } |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn search<F>(self, hash: u64, mut is_match: F) -> Option<(&'a K, &'a V)> |
| where |
| F: FnMut(&K) -> bool, |
| { |
| self.map |
| .table |
| .find(hash, |(k, _)| is_match(k)) |
| .map(|item| unsafe { |
| let &(ref key, ref value) = item.as_ref(); |
| (key, value) |
| }) |
| } |
| |
| /// Access an entry by hash. |
| #[cfg_attr(feature = "inline-more", inline)] |
| #[allow(clippy::wrong_self_convention)] |
| pub fn from_hash<F>(self, hash: u64, is_match: F) -> Option<(&'a K, &'a V)> |
| where |
| F: FnMut(&K) -> bool, |
| { |
| self.search(hash, is_match) |
| } |
| } |
| |
| impl<'a, K, V, S> RawEntryMut<'a, K, V, S> { |
| /// Sets the value of the entry, and returns a RawOccupiedEntryMut. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// let entry = map.raw_entry_mut().from_key("horseyland").insert("horseyland", 37); |
| /// |
| /// assert_eq!(entry.remove_entry(), ("horseyland", 37)); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn insert(self, key: K, value: V) -> RawOccupiedEntryMut<'a, K, V> |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| match self { |
| RawEntryMut::Occupied(mut entry) => { |
| entry.insert(value); |
| entry |
| } |
| RawEntryMut::Vacant(entry) => entry.insert_entry(key, value), |
| } |
| } |
| |
| /// Ensures a value is in the entry by inserting the default if empty, and returns |
| /// mutable references to the key and value in the entry. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// |
| /// map.raw_entry_mut().from_key("poneyland").or_insert("poneyland", 3); |
| /// assert_eq!(map["poneyland"], 3); |
| /// |
| /// *map.raw_entry_mut().from_key("poneyland").or_insert("poneyland", 10).1 *= 2; |
| /// assert_eq!(map["poneyland"], 6); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn or_insert(self, default_key: K, default_val: V) -> (&'a mut K, &'a mut V) |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| match self { |
| RawEntryMut::Occupied(entry) => entry.into_key_value(), |
| RawEntryMut::Vacant(entry) => entry.insert(default_key, default_val), |
| } |
| } |
| |
| /// Ensures a value is in the entry by inserting the result of the default function if empty, |
| /// and returns mutable references to the key and value in the entry. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, String> = HashMap::new(); |
| /// |
| /// map.raw_entry_mut().from_key("poneyland").or_insert_with(|| { |
| /// ("poneyland", "hoho".to_string()) |
| /// }); |
| /// |
| /// assert_eq!(map["poneyland"], "hoho".to_string()); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn or_insert_with<F>(self, default: F) -> (&'a mut K, &'a mut V) |
| where |
| F: FnOnce() -> (K, V), |
| K: Hash, |
| S: BuildHasher, |
| { |
| match self { |
| RawEntryMut::Occupied(entry) => entry.into_key_value(), |
| RawEntryMut::Vacant(entry) => { |
| let (k, v) = default(); |
| entry.insert(k, v) |
| } |
| } |
| } |
| |
| /// Provides in-place mutable access to an occupied entry before any |
| /// potential inserts into the map. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// |
| /// map.raw_entry_mut() |
| /// .from_key("poneyland") |
| /// .and_modify(|_k, v| { *v += 1 }) |
| /// .or_insert("poneyland", 42); |
| /// assert_eq!(map["poneyland"], 42); |
| /// |
| /// map.raw_entry_mut() |
| /// .from_key("poneyland") |
| /// .and_modify(|_k, v| { *v += 1 }) |
| /// .or_insert("poneyland", 0); |
| /// assert_eq!(map["poneyland"], 43); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn and_modify<F>(self, f: F) -> Self |
| where |
| F: FnOnce(&mut K, &mut V), |
| { |
| match self { |
| RawEntryMut::Occupied(mut entry) => { |
| { |
| let (k, v) = entry.get_key_value_mut(); |
| f(k, v); |
| } |
| RawEntryMut::Occupied(entry) |
| } |
| RawEntryMut::Vacant(entry) => RawEntryMut::Vacant(entry), |
| } |
| } |
| } |
| |
| impl<'a, K, V> RawOccupiedEntryMut<'a, K, V> { |
| /// Gets a reference to the key in the entry. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn key(&self) -> &K { |
| unsafe { &self.elem.as_ref().0 } |
| } |
| |
| /// Gets a mutable reference to the key in the entry. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn key_mut(&mut self) -> &mut K { |
| unsafe { &mut self.elem.as_mut().0 } |
| } |
| |
| /// Converts the entry into a mutable reference to the key in the entry |
| /// with a lifetime bound to the map itself. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn into_key(self) -> &'a mut K { |
| unsafe { &mut self.elem.as_mut().0 } |
| } |
| |
| /// Gets a reference to the value in the entry. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn get(&self) -> &V { |
| unsafe { &self.elem.as_ref().1 } |
| } |
| |
| /// Converts the OccupiedEntry into a mutable reference to the value in the entry |
| /// with a lifetime bound to the map itself. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn into_mut(self) -> &'a mut V { |
| unsafe { &mut self.elem.as_mut().1 } |
| } |
| |
| /// Gets a mutable reference to the value in the entry. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn get_mut(&mut self) -> &mut V { |
| unsafe { &mut self.elem.as_mut().1 } |
| } |
| |
| /// Gets a reference to the key and value in the entry. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn get_key_value(&mut self) -> (&K, &V) { |
| unsafe { |
| let &(ref key, ref value) = self.elem.as_ref(); |
| (key, value) |
| } |
| } |
| |
| /// Gets a mutable reference to the key and value in the entry. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn get_key_value_mut(&mut self) -> (&mut K, &mut V) { |
| unsafe { |
| let &mut (ref mut key, ref mut value) = self.elem.as_mut(); |
| (key, value) |
| } |
| } |
| |
| /// Converts the OccupiedEntry into a mutable reference to the key and value in the entry |
| /// with a lifetime bound to the map itself. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn into_key_value(self) -> (&'a mut K, &'a mut V) { |
| unsafe { |
| let &mut (ref mut key, ref mut value) = self.elem.as_mut(); |
| (key, value) |
| } |
| } |
| |
| /// Sets the value of the entry, and returns the entry's old value. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn insert(&mut self, value: V) -> V { |
| mem::replace(self.get_mut(), value) |
| } |
| |
| /// Sets the value of the entry, and returns the entry's old value. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn insert_key(&mut self, key: K) -> K { |
| mem::replace(self.key_mut(), key) |
| } |
| |
| /// Takes the value out of the entry, and returns it. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn remove(self) -> V { |
| self.remove_entry().1 |
| } |
| |
| /// Take the ownership of the key and value from the map. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn remove_entry(self) -> (K, V) { |
| unsafe { |
| self.table.erase_no_drop(&self.elem); |
| self.elem.read() |
| } |
| } |
| } |
| |
| impl<'a, K, V, S> RawVacantEntryMut<'a, K, V, S> { |
| /// Sets the value of the entry with the VacantEntry's key, |
| /// and returns a mutable reference to it. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn insert(self, key: K, value: V) -> (&'a mut K, &'a mut V) |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| let mut hasher = self.hash_builder.build_hasher(); |
| key.hash(&mut hasher); |
| self.insert_hashed_nocheck(hasher.finish(), key, value) |
| } |
| |
| /// Sets the value of the entry with the VacantEntry's key, |
| /// and returns a mutable reference to it. |
| #[cfg_attr(feature = "inline-more", inline)] |
| #[allow(clippy::shadow_unrelated)] |
| pub fn insert_hashed_nocheck(self, hash: u64, key: K, value: V) -> (&'a mut K, &'a mut V) |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| let hash_builder = self.hash_builder; |
| self.insert_with_hasher(hash, key, value, |k| make_hash(hash_builder, k)) |
| } |
| |
| /// Set the value of an entry with a custom hasher function. |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn insert_with_hasher<H>( |
| self, |
| hash: u64, |
| key: K, |
| value: V, |
| hasher: H, |
| ) -> (&'a mut K, &'a mut V) |
| where |
| H: Fn(&K) -> u64, |
| { |
| unsafe { |
| let elem = self.table.insert(hash, (key, value), |x| hasher(&x.0)); |
| let &mut (ref mut k, ref mut v) = elem.as_mut(); |
| (k, v) |
| } |
| } |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn insert_entry(self, key: K, value: V) -> RawOccupiedEntryMut<'a, K, V> |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| let hash_builder = self.hash_builder; |
| let mut hasher = self.hash_builder.build_hasher(); |
| key.hash(&mut hasher); |
| |
| let elem = self.table.insert(hasher.finish(), (key, value), |k| { |
| make_hash(hash_builder, &k.0) |
| }); |
| RawOccupiedEntryMut { |
| elem, |
| table: self.table, |
| } |
| } |
| } |
| |
| impl<K, V, S> Debug for RawEntryBuilderMut<'_, K, V, S> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_struct("RawEntryBuilder").finish() |
| } |
| } |
| |
| impl<K: Debug, V: Debug, S> Debug for RawEntryMut<'_, K, V, S> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| match *self { |
| RawEntryMut::Vacant(ref v) => f.debug_tuple("RawEntry").field(v).finish(), |
| RawEntryMut::Occupied(ref o) => f.debug_tuple("RawEntry").field(o).finish(), |
| } |
| } |
| } |
| |
| impl<K: Debug, V: Debug> Debug for RawOccupiedEntryMut<'_, K, V> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_struct("RawOccupiedEntryMut") |
| .field("key", self.key()) |
| .field("value", self.get()) |
| .finish() |
| } |
| } |
| |
| impl<K, V, S> Debug for RawVacantEntryMut<'_, K, V, S> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_struct("RawVacantEntryMut").finish() |
| } |
| } |
| |
| impl<K, V, S> Debug for RawEntryBuilder<'_, K, V, S> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_struct("RawEntryBuilder").finish() |
| } |
| } |
| |
| /// A view into a single entry in a map, which may either be vacant or occupied. |
| /// |
| /// This `enum` is constructed from the [`entry`] method on [`HashMap`]. |
| /// |
| /// [`HashMap`]: struct.HashMap.html |
| /// [`entry`]: struct.HashMap.html#method.entry |
| pub enum Entry<'a, K, V, S> { |
| /// An occupied entry. |
| Occupied(OccupiedEntry<'a, K, V, S>), |
| |
| /// A vacant entry. |
| Vacant(VacantEntry<'a, K, V, S>), |
| } |
| |
| impl<K: Debug, V: Debug, S> Debug for Entry<'_, K, V, S> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| match *self { |
| Entry::Vacant(ref v) => f.debug_tuple("Entry").field(v).finish(), |
| Entry::Occupied(ref o) => f.debug_tuple("Entry").field(o).finish(), |
| } |
| } |
| } |
| |
| /// A view into an occupied entry in a `HashMap`. |
| /// It is part of the [`Entry`] enum. |
| /// |
| /// [`Entry`]: enum.Entry.html |
| pub struct OccupiedEntry<'a, K, V, S> { |
| key: Option<K>, |
| elem: Bucket<(K, V)>, |
| table: &'a mut HashMap<K, V, S>, |
| } |
| |
| unsafe impl<K, V, S> Send for OccupiedEntry<'_, K, V, S> |
| where |
| K: Send, |
| V: Send, |
| S: Send, |
| { |
| } |
| unsafe impl<K, V, S> Sync for OccupiedEntry<'_, K, V, S> |
| where |
| K: Sync, |
| V: Sync, |
| S: Sync, |
| { |
| } |
| |
| impl<K: Debug, V: Debug, S> Debug for OccupiedEntry<'_, K, V, S> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_struct("OccupiedEntry") |
| .field("key", self.key()) |
| .field("value", self.get()) |
| .finish() |
| } |
| } |
| |
| /// A view into a vacant entry in a `HashMap`. |
| /// It is part of the [`Entry`] enum. |
| /// |
| /// [`Entry`]: enum.Entry.html |
| pub struct VacantEntry<'a, K, V, S> { |
| hash: u64, |
| key: K, |
| table: &'a mut HashMap<K, V, S>, |
| } |
| |
| impl<K: Debug, V, S> Debug for VacantEntry<'_, K, V, S> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_tuple("VacantEntry").field(self.key()).finish() |
| } |
| } |
| |
| impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S> { |
| type Item = (&'a K, &'a V); |
| type IntoIter = Iter<'a, K, V>; |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn into_iter(self) -> Iter<'a, K, V> { |
| self.iter() |
| } |
| } |
| |
| impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S> { |
| type Item = (&'a K, &'a mut V); |
| type IntoIter = IterMut<'a, K, V>; |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn into_iter(self) -> IterMut<'a, K, V> { |
| self.iter_mut() |
| } |
| } |
| |
| impl<K, V, S> IntoIterator for HashMap<K, V, S> { |
| type Item = (K, V); |
| type IntoIter = IntoIter<K, V>; |
| |
| /// Creates a consuming iterator, that is, one that moves each key-value |
| /// pair out of the map in arbitrary order. The map cannot be used after |
| /// calling this. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map = HashMap::new(); |
| /// map.insert("a", 1); |
| /// map.insert("b", 2); |
| /// map.insert("c", 3); |
| /// |
| /// // Not possible with .iter() |
| /// let vec: Vec<(&str, i32)> = map.into_iter().collect(); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn into_iter(self) -> IntoIter<K, V> { |
| IntoIter { |
| inner: self.table.into_iter(), |
| } |
| } |
| } |
| |
| impl<'a, K, V> Iterator for Iter<'a, K, V> { |
| type Item = (&'a K, &'a V); |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn next(&mut self) -> Option<(&'a K, &'a V)> { |
| self.inner.next().map(|x| unsafe { |
| let r = x.as_ref(); |
| (&r.0, &r.1) |
| }) |
| } |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.inner.size_hint() |
| } |
| } |
| impl<K, V> ExactSizeIterator for Iter<'_, K, V> { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn len(&self) -> usize { |
| self.inner.len() |
| } |
| } |
| |
| impl<K, V> FusedIterator for Iter<'_, K, V> {} |
| |
| impl<'a, K, V> Iterator for IterMut<'a, K, V> { |
| type Item = (&'a K, &'a mut V); |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn next(&mut self) -> Option<(&'a K, &'a mut V)> { |
| self.inner.next().map(|x| unsafe { |
| let r = x.as_mut(); |
| (&r.0, &mut r.1) |
| }) |
| } |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.inner.size_hint() |
| } |
| } |
| impl<K, V> ExactSizeIterator for IterMut<'_, K, V> { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn len(&self) -> usize { |
| self.inner.len() |
| } |
| } |
| impl<K, V> FusedIterator for IterMut<'_, K, V> {} |
| |
| impl<K, V> fmt::Debug for IterMut<'_, K, V> |
| where |
| K: fmt::Debug, |
| V: fmt::Debug, |
| { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_list().entries(self.iter()).finish() |
| } |
| } |
| |
| impl<K, V> Iterator for IntoIter<K, V> { |
| type Item = (K, V); |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn next(&mut self) -> Option<(K, V)> { |
| self.inner.next() |
| } |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.inner.size_hint() |
| } |
| } |
| impl<K, V> ExactSizeIterator for IntoIter<K, V> { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn len(&self) -> usize { |
| self.inner.len() |
| } |
| } |
| impl<K, V> FusedIterator for IntoIter<K, V> {} |
| |
| impl<K: Debug, V: Debug> fmt::Debug for IntoIter<K, V> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_list().entries(self.iter()).finish() |
| } |
| } |
| |
| impl<'a, K, V> Iterator for Keys<'a, K, V> { |
| type Item = &'a K; |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn next(&mut self) -> Option<&'a K> { |
| self.inner.next().map(|(k, _)| k) |
| } |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.inner.size_hint() |
| } |
| } |
| impl<K, V> ExactSizeIterator for Keys<'_, K, V> { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn len(&self) -> usize { |
| self.inner.len() |
| } |
| } |
| impl<K, V> FusedIterator for Keys<'_, K, V> {} |
| |
| impl<'a, K, V> Iterator for Values<'a, K, V> { |
| type Item = &'a V; |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn next(&mut self) -> Option<&'a V> { |
| self.inner.next().map(|(_, v)| v) |
| } |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.inner.size_hint() |
| } |
| } |
| impl<K, V> ExactSizeIterator for Values<'_, K, V> { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn len(&self) -> usize { |
| self.inner.len() |
| } |
| } |
| impl<K, V> FusedIterator for Values<'_, K, V> {} |
| |
| impl<'a, K, V> Iterator for ValuesMut<'a, K, V> { |
| type Item = &'a mut V; |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn next(&mut self) -> Option<&'a mut V> { |
| self.inner.next().map(|(_, v)| v) |
| } |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.inner.size_hint() |
| } |
| } |
| impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V> { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn len(&self) -> usize { |
| self.inner.len() |
| } |
| } |
| impl<K, V> FusedIterator for ValuesMut<'_, K, V> {} |
| |
| impl<K, V> fmt::Debug for ValuesMut<'_, K, V> |
| where |
| K: fmt::Debug, |
| V: fmt::Debug, |
| { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_list().entries(self.inner.iter()).finish() |
| } |
| } |
| |
| impl<'a, K, V> Iterator for Drain<'a, K, V> { |
| type Item = (K, V); |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn next(&mut self) -> Option<(K, V)> { |
| self.inner.next() |
| } |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn size_hint(&self) -> (usize, Option<usize>) { |
| self.inner.size_hint() |
| } |
| } |
| impl<K, V> ExactSizeIterator for Drain<'_, K, V> { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn len(&self) -> usize { |
| self.inner.len() |
| } |
| } |
| impl<K, V> FusedIterator for Drain<'_, K, V> {} |
| |
| impl<K, V> fmt::Debug for Drain<'_, K, V> |
| where |
| K: fmt::Debug, |
| V: fmt::Debug, |
| { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| f.debug_list().entries(self.iter()).finish() |
| } |
| } |
| |
| impl<'a, K, V, S> Entry<'a, K, V, S> { |
| /// Sets the value of the entry, and returns an OccupiedEntry. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// let entry = map.entry("horseyland").insert(37); |
| /// |
| /// assert_eq!(entry.key(), &"horseyland"); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn insert(self, value: V) -> OccupiedEntry<'a, K, V, S> |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| match self { |
| Entry::Occupied(mut entry) => { |
| entry.insert(value); |
| entry |
| } |
| Entry::Vacant(entry) => entry.insert_entry(value), |
| } |
| } |
| |
| /// Ensures a value is in the entry by inserting the default if empty, and returns |
| /// a mutable reference to the value in the entry. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// |
| /// map.entry("poneyland").or_insert(3); |
| /// assert_eq!(map["poneyland"], 3); |
| /// |
| /// *map.entry("poneyland").or_insert(10) *= 2; |
| /// assert_eq!(map["poneyland"], 6); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn or_insert(self, default: V) -> &'a mut V |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| match self { |
| Entry::Occupied(entry) => entry.into_mut(), |
| Entry::Vacant(entry) => entry.insert(default), |
| } |
| } |
| |
| /// Ensures a value is in the entry by inserting the result of the default function if empty, |
| /// and returns a mutable reference to the value in the entry. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, String> = HashMap::new(); |
| /// let s = "hoho".to_string(); |
| /// |
| /// map.entry("poneyland").or_insert_with(|| s); |
| /// |
| /// assert_eq!(map["poneyland"], "hoho".to_string()); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| match self { |
| Entry::Occupied(entry) => entry.into_mut(), |
| Entry::Vacant(entry) => entry.insert(default()), |
| } |
| } |
| |
| /// Returns a reference to this entry's key. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn key(&self) -> &K { |
| match *self { |
| Entry::Occupied(ref entry) => entry.key(), |
| Entry::Vacant(ref entry) => entry.key(), |
| } |
| } |
| |
| /// Provides in-place mutable access to an occupied entry before any |
| /// potential inserts into the map. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// |
| /// map.entry("poneyland") |
| /// .and_modify(|e| { *e += 1 }) |
| /// .or_insert(42); |
| /// assert_eq!(map["poneyland"], 42); |
| /// |
| /// map.entry("poneyland") |
| /// .and_modify(|e| { *e += 1 }) |
| /// .or_insert(42); |
| /// assert_eq!(map["poneyland"], 43); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn and_modify<F>(self, f: F) -> Self |
| where |
| F: FnOnce(&mut V), |
| { |
| match self { |
| Entry::Occupied(mut entry) => { |
| f(entry.get_mut()); |
| Entry::Occupied(entry) |
| } |
| Entry::Vacant(entry) => Entry::Vacant(entry), |
| } |
| } |
| } |
| |
| impl<'a, K, V: Default, S> Entry<'a, K, V, S> { |
| /// Ensures a value is in the entry by inserting the default value if empty, |
| /// and returns a mutable reference to the value in the entry. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, Option<u32>> = HashMap::new(); |
| /// map.entry("poneyland").or_default(); |
| /// |
| /// assert_eq!(map["poneyland"], None); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn or_default(self) -> &'a mut V |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| match self { |
| Entry::Occupied(entry) => entry.into_mut(), |
| Entry::Vacant(entry) => entry.insert(Default::default()), |
| } |
| } |
| } |
| |
| impl<'a, K, V, S> OccupiedEntry<'a, K, V, S> { |
| /// Gets a reference to the key in the entry. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// map.entry("poneyland").or_insert(12); |
| /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn key(&self) -> &K { |
| unsafe { &self.elem.as_ref().0 } |
| } |
| |
| /// Take the ownership of the key and value from the map. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::Entry; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// map.entry("poneyland").or_insert(12); |
| /// |
| /// if let Entry::Occupied(o) = map.entry("poneyland") { |
| /// // We delete the entry from the map. |
| /// o.remove_entry(); |
| /// } |
| /// |
| /// assert_eq!(map.contains_key("poneyland"), false); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn remove_entry(self) -> (K, V) { |
| unsafe { |
| self.table.table.erase_no_drop(&self.elem); |
| self.elem.read() |
| } |
| } |
| |
| /// Gets a reference to the value in the entry. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::Entry; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// map.entry("poneyland").or_insert(12); |
| /// |
| /// if let Entry::Occupied(o) = map.entry("poneyland") { |
| /// assert_eq!(o.get(), &12); |
| /// } |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn get(&self) -> &V { |
| unsafe { &self.elem.as_ref().1 } |
| } |
| |
| /// Gets a mutable reference to the value in the entry. |
| /// |
| /// If you need a reference to the `OccupiedEntry` which may outlive the |
| /// destruction of the `Entry` value, see [`into_mut`]. |
| /// |
| /// [`into_mut`]: #method.into_mut |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::Entry; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// map.entry("poneyland").or_insert(12); |
| /// |
| /// assert_eq!(map["poneyland"], 12); |
| /// if let Entry::Occupied(mut o) = map.entry("poneyland") { |
| /// *o.get_mut() += 10; |
| /// assert_eq!(*o.get(), 22); |
| /// |
| /// // We can use the same Entry multiple times. |
| /// *o.get_mut() += 2; |
| /// } |
| /// |
| /// assert_eq!(map["poneyland"], 24); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn get_mut(&mut self) -> &mut V { |
| unsafe { &mut self.elem.as_mut().1 } |
| } |
| |
| /// Converts the OccupiedEntry into a mutable reference to the value in the entry |
| /// with a lifetime bound to the map itself. |
| /// |
| /// If you need multiple references to the `OccupiedEntry`, see [`get_mut`]. |
| /// |
| /// [`get_mut`]: #method.get_mut |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::Entry; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// map.entry("poneyland").or_insert(12); |
| /// |
| /// assert_eq!(map["poneyland"], 12); |
| /// if let Entry::Occupied(o) = map.entry("poneyland") { |
| /// *o.into_mut() += 10; |
| /// } |
| /// |
| /// assert_eq!(map["poneyland"], 22); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn into_mut(self) -> &'a mut V { |
| unsafe { &mut self.elem.as_mut().1 } |
| } |
| |
| /// Sets the value of the entry, and returns the entry's old value. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::Entry; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// map.entry("poneyland").or_insert(12); |
| /// |
| /// if let Entry::Occupied(mut o) = map.entry("poneyland") { |
| /// assert_eq!(o.insert(15), 12); |
| /// } |
| /// |
| /// assert_eq!(map["poneyland"], 15); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn insert(&mut self, mut value: V) -> V { |
| let old_value = self.get_mut(); |
| mem::swap(&mut value, old_value); |
| value |
| } |
| |
| /// Takes the value out of the entry, and returns it. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::Entry; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// map.entry("poneyland").or_insert(12); |
| /// |
| /// if let Entry::Occupied(o) = map.entry("poneyland") { |
| /// assert_eq!(o.remove(), 12); |
| /// } |
| /// |
| /// assert_eq!(map.contains_key("poneyland"), false); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn remove(self) -> V { |
| self.remove_entry().1 |
| } |
| |
| /// Replaces the entry, returning the old key and value. The new key in the hash map will be |
| /// the key used to create this entry. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::hash_map::{Entry, HashMap}; |
| /// use std::rc::Rc; |
| /// |
| /// let mut map: HashMap<Rc<String>, u32> = HashMap::new(); |
| /// map.insert(Rc::new("Stringthing".to_string()), 15); |
| /// |
| /// let my_key = Rc::new("Stringthing".to_string()); |
| /// |
| /// if let Entry::Occupied(entry) = map.entry(my_key) { |
| /// // Also replace the key with a handle to our other key. |
| /// let (old_key, old_value): (Rc<String>, u32) = entry.replace_entry(16); |
| /// } |
| /// |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn replace_entry(self, value: V) -> (K, V) { |
| let entry = unsafe { self.elem.as_mut() }; |
| |
| let old_key = mem::replace(&mut entry.0, self.key.unwrap()); |
| let old_value = mem::replace(&mut entry.1, value); |
| |
| (old_key, old_value) |
| } |
| |
| /// Replaces the key in the hash map with the key used to create this entry. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::hash_map::{Entry, HashMap}; |
| /// use std::rc::Rc; |
| /// |
| /// let mut map: HashMap<Rc<String>, u32> = HashMap::new(); |
| /// let mut known_strings: Vec<Rc<String>> = Vec::new(); |
| /// |
| /// // Initialise known strings, run program, etc. |
| /// |
| /// reclaim_memory(&mut map, &known_strings); |
| /// |
| /// fn reclaim_memory(map: &mut HashMap<Rc<String>, u32>, known_strings: &[Rc<String>] ) { |
| /// for s in known_strings { |
| /// if let Entry::Occupied(entry) = map.entry(s.clone()) { |
| /// // Replaces the entry's key with our version of it in `known_strings`. |
| /// entry.replace_key(); |
| /// } |
| /// } |
| /// } |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn replace_key(self) -> K { |
| let entry = unsafe { self.elem.as_mut() }; |
| mem::replace(&mut entry.0, self.key.unwrap()) |
| } |
| } |
| |
| impl<'a, K, V, S> VacantEntry<'a, K, V, S> { |
| /// Gets a reference to the key that would be used when inserting a value |
| /// through the `VacantEntry`. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn key(&self) -> &K { |
| &self.key |
| } |
| |
| /// Take ownership of the key. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::Entry; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// |
| /// if let Entry::Vacant(v) = map.entry("poneyland") { |
| /// v.into_key(); |
| /// } |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn into_key(self) -> K { |
| self.key |
| } |
| |
| /// Sets the value of the entry with the VacantEntry's key, |
| /// and returns a mutable reference to it. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use hashbrown::HashMap; |
| /// use hashbrown::hash_map::Entry; |
| /// |
| /// let mut map: HashMap<&str, u32> = HashMap::new(); |
| /// |
| /// if let Entry::Vacant(o) = map.entry("poneyland") { |
| /// o.insert(37); |
| /// } |
| /// assert_eq!(map["poneyland"], 37); |
| /// ``` |
| #[cfg_attr(feature = "inline-more", inline)] |
| pub fn insert(self, value: V) -> &'a mut V |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| let hash_builder = &self.table.hash_builder; |
| let bucket = self.table.table.insert(self.hash, (self.key, value), |x| { |
| make_hash(hash_builder, &x.0) |
| }); |
| unsafe { &mut bucket.as_mut().1 } |
| } |
| |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V, S> |
| where |
| K: Hash, |
| S: BuildHasher, |
| { |
| let hash_builder = &self.table.hash_builder; |
| let elem = self.table.table.insert(self.hash, (self.key, value), |x| { |
| make_hash(hash_builder, &x.0) |
| }); |
| OccupiedEntry { |
| key: None, |
| elem, |
| table: self.table, |
| } |
| } |
| } |
| |
| impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S> |
| where |
| K: Eq + Hash, |
| S: BuildHasher + Default, |
| { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self { |
| let iter = iter.into_iter(); |
| let mut map = Self::with_capacity_and_hasher(iter.size_hint().0, S::default()); |
| iter.for_each(|(k, v)| { |
| map.insert(k, v); |
| }); |
| map |
| } |
| } |
| |
| impl<K, V, S> Extend<(K, V)> for HashMap<K, V, S> |
| where |
| K: Eq + Hash, |
| S: BuildHasher, |
| { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) { |
| // Keys may be already present or show multiple times in the iterator. |
| // Reserve the entire hint lower bound if the map is empty. |
| // Otherwise reserve half the hint (rounded up), so the map |
| // will only resize twice in the worst case. |
| let iter = iter.into_iter(); |
| let reserve = if self.is_empty() { |
| iter.size_hint().0 |
| } else { |
| (iter.size_hint().0 + 1) / 2 |
| }; |
| self.reserve(reserve); |
| iter.for_each(move |(k, v)| { |
| self.insert(k, v); |
| }); |
| } |
| } |
| |
| impl<'a, K, V, S> Extend<(&'a K, &'a V)> for HashMap<K, V, S> |
| where |
| K: Eq + Hash + Copy, |
| V: Copy, |
| S: BuildHasher, |
| { |
| #[cfg_attr(feature = "inline-more", inline)] |
| fn extend<T: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: T) { |
| self.extend(iter.into_iter().map(|(&key, &value)| (key, value))); |
| } |
| } |
| |
| #[allow(dead_code)] |
| fn assert_covariance() { |
| fn map_key<'new>(v: HashMap<&'static str, u8>) -> HashMap<&'new str, u8> { |
| v |
| } |
| fn map_val<'new>(v: HashMap<u8, &'static str>) -> HashMap<u8, &'new str> { |
| v |
| } |
| fn iter_key<'a, 'new>(v: Iter<'a, &'static str, u8>) -> Iter<'a, &'new str, u8> { |
| v |
| } |
| fn iter_val<'a, 'new>(v: Iter<'a, u8, &'static str>) -> Iter<'a, u8, &'new str> { |
| v |
| } |
| fn into_iter_key<'new>(v: IntoIter<&'static str, u8>) -> IntoIter<&'new str, u8> { |
| v |
| } |
| fn into_iter_val<'new>(v: IntoIter<u8, &'static str>) -> IntoIter<u8, &'new str> { |
| v |
| } |
| fn keys_key<'a, 'new>(v: Keys<'a, &'static str, u8>) -> Keys<'a, &'new str, u8> { |
| v |
| } |
| fn keys_val<'a, 'new>(v: Keys<'a, u8, &'static str>) -> Keys<'a, u8, &'new str> { |
| v |
| } |
| fn values_key<'a, 'new>(v: Values<'a, &'static str, u8>) -> Values<'a, &'new str, u8> { |
| v |
| } |
| fn values_val<'a, 'new>(v: Values<'a, u8, &'static str>) -> Values<'a, u8, &'new str> { |
| v |
| } |
| fn drain<'new>( |
| d: Drain<'static, &'static str, &'static str>, |
| ) -> Drain<'new, &'new str, &'new str> { |
| d |
| } |
| } |
| |
| #[cfg(test)] |
| mod test_map { |
| use super::DefaultHashBuilder; |
| use super::Entry::{Occupied, Vacant}; |
| use super::{HashMap, RawEntryMut}; |
| use crate::CollectionAllocErr::*; |
| use rand::{rngs::SmallRng, Rng, SeedableRng}; |
| use std::cell::RefCell; |
| use std::usize; |
| use std::vec::Vec; |
| |
| #[test] |
| fn test_zero_capacities() { |
| type HM = HashMap<i32, i32>; |
| |
| let m = HM::new(); |
| assert_eq!(m.capacity(), 0); |
| |
| let m = HM::default(); |
| assert_eq!(m.capacity(), 0); |
| |
| let m = HM::with_hasher(DefaultHashBuilder::default()); |
| assert_eq!(m.capacity(), 0); |
| |
| let m = HM::with_capacity(0); |
| assert_eq!(m.capacity(), 0); |
| |
| let m = HM::with_capacity_and_hasher(0, DefaultHashBuilder::default()); |
| assert_eq!(m.capacity(), 0); |
| |
| let mut m = HM::new(); |
| m.insert(1, 1); |
| m.insert(2, 2); |
| m.remove(&1); |
| m.remove(&2); |
| m.shrink_to_fit(); |
| assert_eq!(m.capacity(), 0); |
| |
| let mut m = HM::new(); |
| m.reserve(0); |
| assert_eq!(m.capacity(), 0); |
| } |
| |
| #[test] |
| fn test_create_capacity_zero() { |
| let mut m = HashMap::with_capacity(0); |
| |
| assert!(m.insert(1, 1).is_none()); |
| |
| assert!(m.contains_key(&1)); |
| assert!(!m.contains_key(&0)); |
| } |
| |
| #[test] |
| fn test_insert() { |
| let mut m = HashMap::new(); |
| assert_eq!(m.len(), 0); |
| assert!(m.insert(1, 2).is_none()); |
| assert_eq!(m.len(), 1); |
| assert!(m.insert(2, 4).is_none()); |
| assert_eq!(m.len(), 2); |
| assert_eq!(*m.get(&1).unwrap(), 2); |
| assert_eq!(*m.get(&2).unwrap(), 4); |
| } |
| |
| #[test] |
| fn test_clone() { |
| let mut m = HashMap::new(); |
| assert_eq!(m.len(), 0); |
| assert!(m.insert(1, 2).is_none()); |
| assert_eq!(m.len(), 1); |
| assert!(m.insert(2, 4).is_none()); |
| assert_eq!(m.len(), 2); |
| let m2 = m.clone(); |
| assert_eq!(*m2.get(&1).unwrap(), 2); |
| assert_eq!(*m2.get(&2).unwrap(), 4); |
| assert_eq!(m2.len(), 2); |
| } |
| |
| #[test] |
| fn test_clone_from() { |
| let mut m = HashMap::new(); |
| let mut m2 = HashMap::new(); |
| assert_eq!(m.len(), 0); |
| assert!(m.insert(1, 2).is_none()); |
| assert_eq!(m.len(), 1); |
| assert!(m.insert(2, 4).is_none()); |
| assert_eq!(m.len(), 2); |
| m2.clone_from(&m); |
| assert_eq!(*m2.get(&1).unwrap(), 2); |
| assert_eq!(*m2.get(&2).unwrap(), 4); |
| assert_eq!(m2.len(), 2); |
| } |
| |
| thread_local! { static DROP_VECTOR: RefCell<Vec<i32>> = RefCell::new(Vec::new()) } |
| |
| #[derive(Hash, PartialEq, Eq)] |
| struct Droppable { |
| k: usize, |
| } |
| |
| impl Droppable { |
| fn new(k: usize) -> Droppable { |
| DROP_VECTOR.with(|slot| { |
| slot.borrow_mut()[k] += 1; |
| }); |
| |
| Droppable { k } |
| } |
| } |
| |
| impl Drop for Droppable { |
| fn drop(&mut self) { |
| DROP_VECTOR.with(|slot| { |
| slot.borrow_mut()[self.k] -= 1; |
| }); |
| } |
| } |
| |
| impl Clone for Droppable { |
| fn clone(&self) -> Self { |
| Droppable::new(self.k) |
| } |
| } |
| |
| #[test] |
| fn test_drops() { |
| DROP_VECTOR.with(|slot| { |
| *slot.borrow_mut() = vec![0; 200]; |
| }); |
| |
| { |
| let mut m = HashMap::new(); |
| |
| DROP_VECTOR.with(|v| { |
| for i in 0..200 { |
| assert_eq!(v.borrow()[i], 0); |
| } |
| }); |
| |
| for i in 0..100 { |
| let d1 = Droppable::new(i); |
| let d2 = Droppable::new(i + 100); |
| m.insert(d1, d2); |
| } |
| |
| DROP_VECTOR.with(|v| { |
| for i in 0..200 { |
| assert_eq!(v.borrow()[i], 1); |
| } |
| }); |
| |
| for i in 0..50 { |
| let k = Droppable::new(i); |
| let v = m.remove(&k); |
| |
| assert!(v.is_some()); |
| |
| DROP_VECTOR.with(|v| { |
| assert_eq!(v.borrow()[i], 1); |
| assert_eq!(v.borrow()[i + 100], 1); |
| }); |
| } |
| |
| DROP_VECTOR.with(|v| { |
| for i in 0..50 { |
| assert_eq!(v.borrow()[i], 0); |
| assert_eq!(v.borrow()[i + 100], 0); |
| } |
| |
| for i in 50..100 { |
| assert_eq!(v.borrow()[i], 1); |
| assert_eq!(v.borrow()[i + 100], 1); |
| } |
| }); |
| } |
| |
| DROP_VECTOR.with(|v| { |
| for i in 0..200 { |
| assert_eq!(v.borrow()[i], 0); |
| } |
| }); |
| } |
| |
| #[test] |
| fn test_into_iter_drops() { |
| DROP_VECTOR.with(|v| { |
| *v.borrow_mut() = vec![0; 200]; |
| }); |
| |
| let hm = { |
| let mut hm = HashMap::new(); |
| |
| DROP_VECTOR.with(|v| { |
| for i in 0..200 { |
| assert_eq!(v.borrow()[i], 0); |
| } |
| }); |
| |
| for i in 0..100 { |
| let d1 = Droppable::new(i); |
| let d2 = Droppable::new(i + 100); |
| hm.insert(d1, d2); |
| } |
| |
| DROP_VECTOR.with(|v| { |
| for i in 0..200 { |
| assert_eq!(v.borrow()[i], 1); |
| } |
| }); |
| |
| hm |
| }; |
| |
| // By the way, ensure that cloning doesn't screw up the dropping. |
| drop(hm.clone()); |
| |
| { |
| let mut half = hm.into_iter().take(50); |
| |
| DROP_VECTOR.with(|v| { |
| for i in 0..200 { |
| assert_eq!(v.borrow()[i], 1); |
| } |
| }); |
| |
| for _ in half.by_ref() {} |
| |
| DROP_VECTOR.with(|v| { |
| let nk = (0..100).filter(|&i| v.borrow()[i] == 1).count(); |
| |
| let nv = (0..100).filter(|&i| v.borrow()[i + 100] == 1).count(); |
| |
| assert_eq!(nk, 50); |
| assert_eq!(nv, 50); |
| }); |
| }; |
| |
| DROP_VECTOR.with(|v| { |
| for i in 0..200 { |
| assert_eq!(v.borrow()[i], 0); |
| } |
| }); |
| } |
| |
| #[test] |
| fn test_empty_remove() { |
| let mut m: HashMap<i32, bool> = HashMap::new(); |
| assert_eq!(m.remove(&0), None); |
| } |
| |
| #[test] |
| fn test_empty_entry() { |
| let mut m: HashMap<i32, bool> = HashMap::new(); |
| match m.entry(0) { |
| Occupied(_) => panic!(), |
| Vacant(_) => {} |
| } |
| assert!(*m.entry(0).or_insert(true)); |
| assert_eq!(m.len(), 1); |
| } |
| |
| #[test] |
| fn test_empty_iter() { |
| let mut m: HashMap<i32, bool> = HashMap::new(); |
| assert_eq!(m.drain().next(), None); |
| assert_eq!(m.keys().next(), None); |
| assert_eq!(m.values().next(), None); |
| assert_eq!(m.values_mut().next(), None); |
| assert_eq!(m.iter().next(), None); |
| assert_eq!(m.iter_mut().next(), None); |
| assert_eq!(m.len(), 0); |
| assert!(m.is_empty()); |
| assert_eq!(m.into_iter().next(), None); |
| } |
| |
| #[test] |
| #[cfg_attr(miri, ignore)] // FIXME: takes too long |
| fn test_lots_of_insertions() { |
| let mut m = HashMap::new(); |
| |
| // Try this a few times to make sure we never screw up the hashmap's |
| // internal state. |
| for _ in 0..10 { |
| assert!(m.is_empty()); |
| |
| for i in 1..1001 { |
| assert!(m.insert(i, i).is_none()); |
| |
| for j in 1..=i { |
| let r = m.get(&j); |
| assert_eq!(r, Some(&j)); |
| } |
| |
| for j in i + 1..1001 { |
| let r = m.get(&j); |
| assert_eq!(r, None); |
| } |
| } |
| |
| for i in 1001..2001 { |
| assert!(!m.contains_key(&i)); |
| } |
| |
| // remove forwards |
| for i in 1..1001 { |
| assert!(m.remove(&i).is_some()); |
| |
| for j in 1..=i { |
| assert!(!m.contains_key(&j)); |
| } |
| |
| for j in i + 1..1001 { |
| assert!(m.contains_key(&j)); |
| } |
| } |
| |
| for i in 1..1001 { |
| assert!(!m.contains_key(&i)); |
| } |
| |
| for i in 1..1001 { |
| assert!(m.insert(i, i).is_none()); |
| } |
| |
| // remove backwards |
| for i in (1..1001).rev() { |
| assert!(m.remove(&i).is_some()); |
| |
| for j in i..1001 { |
| assert!(!m.contains_key(&j)); |
| } |
| |
| for j in 1..i { |
| assert!(m.contains_key(&j)); |
| } |
| } |
| } |
| } |
| |
| #[test] |
| fn test_find_mut() { |
| let mut m = HashMap::new(); |
| assert!(m.insert(1, 12).is_none()); |
| assert!(m.insert(2, 8).is_none()); |
| assert!(m.insert(5, 14).is_none()); |
| let new = 100; |
| match m.get_mut(&5) { |
| None => panic!(), |
| Some(x) => *x = new, |
| } |
| assert_eq!(m.get(&5), Some(&new)); |
| } |
| |
| #[test] |
| fn test_insert_overwrite() { |
| let mut m = HashMap::new(); |
| assert!(m.insert(1, 2).is_none()); |
| assert_eq!(*m.get(&1).unwrap(), 2); |
| assert!(!m.insert(1, 3).is_none()); |
| assert_eq!(*m.get(&1).unwrap(), 3); |
| } |
| |
| #[test] |
| fn test_insert_conflicts() { |
| let mut m = HashMap::with_capacity(4); |
| assert!(m.insert(1, 2).is_none()); |
| assert!(m.insert(5, 3).is_none()); |
| assert!(m.insert(9, 4).is_none()); |
| assert_eq!(*m.get(&9).unwrap(), 4); |
| assert_eq!(*m.get(&5).unwrap(), 3); |
| assert_eq!(*m.get(&1).unwrap(), 2); |
| } |
| |
| #[test] |
| fn test_conflict_remove() { |
| let mut m = HashMap::with_capacity(4); |
| assert!(m.insert(1, 2).is_none()); |
| assert_eq!(*m.get(&1).unwrap(), 2); |
| assert!(m.insert(5, 3).is_none()); |
| assert_eq!(*m.get(&1).unwrap(), 2); |
| assert_eq!(*m.get(&5).unwrap(), 3); |
| assert!(m.insert(9, 4).is_none()); |
| assert_eq!(*m.get(&1).unwrap(), 2); |
| assert_eq!(*m.get(&5).unwrap(), 3); |
| assert_eq!(*m.get(&9).unwrap(), 4); |
| assert!(m.remove(&1).is_some()); |
| assert_eq!(*m.get(&9).unwrap(), 4); |
| assert_eq!(*m.get(&5).unwrap(), 3); |
| } |
| |
| #[test] |
| fn test_is_empty() { |
| let mut m = HashMap::with_capacity(4); |
| assert!(m.insert(1, 2).is_none()); |
| assert!(!m.is_empty()); |
| assert!(m.remove(&1).is_some()); |
| assert!(m.is_empty()); |
| } |
| |
| #[test] |
| fn test_remove() { |
| let mut m = HashMap::new(); |
| m.insert(1, 2); |
| assert_eq!(m.remove(&1), Some(2)); |
| assert_eq!(m.remove(&1), None); |
| } |
| |
| #[test] |
| fn test_remove_entry() { |
| let mut m = HashMap::new(); |
| m.insert(1, 2); |
| assert_eq!(m.remove_entry(&1), Some((1, 2))); |
| assert_eq!(m.remove(&1), None); |
| } |
| |
| #[test] |
| fn test_iterate() { |
| let mut m = HashMap::with_capacity(4); |
| for i in 0..32 { |
| assert!(m.insert(i, i * 2).is_none()); |
| } |
| assert_eq!(m.len(), 32); |
| |
| let mut observed: u32 = 0; |
| |
| for (k, v) in &m { |
| assert_eq!(*v, *k * 2); |
| observed |= 1 << *k; |
| } |
| assert_eq!(observed, 0xFFFF_FFFF); |
| } |
| |
| #[test] |
| fn test_keys() { |
| let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; |
| let map: HashMap<_, _> = vec.into_iter().collect(); |
| let keys: Vec<_> = map.keys().cloned().collect(); |
| assert_eq!(keys.len(), 3); |
| assert!(keys.contains(&1)); |
| assert!(keys.contains(&2)); |
| assert!(keys.contains(&3)); |
| } |
| |
| #[test] |
| fn test_values() { |
| let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; |
| let map: HashMap<_, _> = vec.into_iter().collect(); |
| let values: Vec<_> = map.values().cloned().collect(); |
| assert_eq!(values.len(), 3); |
| assert!(values.contains(&'a')); |
| assert!(values.contains(&'b')); |
| assert!(values.contains(&'c')); |
| } |
| |
| #[test] |
| fn test_values_mut() { |
| let vec = vec![(1, 1), (2, 2), (3, 3)]; |
| let mut map: HashMap<_, _> = vec.into_iter().collect(); |
| for value in map.values_mut() { |
| *value = (*value) * 2 |
| } |
| let values: Vec<_> = map.values().cloned().collect(); |
| assert_eq!(values.len(), 3); |
| assert!(values.contains(&2)); |
| assert!(values.contains(&4)); |
| assert!(values.contains(&6)); |
| } |
| |
| #[test] |
| fn test_find() { |
| let mut m = HashMap::new(); |
| assert!(m.get(&1).is_none()); |
| m.insert(1, 2); |
| match m.get(&1) { |
| None => panic!(), |
| Some(v) => assert_eq!(*v, 2), |
| } |
| } |
| |
| #[test] |
| fn test_eq() { |
| let mut m1 = HashMap::new(); |
| m1.insert(1, 2); |
| m1.insert(2, 3); |
| m1.insert(3, 4); |
| |
| let mut m2 = HashMap::new(); |
| m2.insert(1, 2); |
| m2.insert(2, 3); |
| |
| assert!(m1 != m2); |
| |
| m2.insert(3, 4); |
| |
| assert_eq!(m1, m2); |
| } |
| |
| #[test] |
| fn test_show() { |
| let mut map = HashMap::new(); |
| let empty: HashMap<i32, i32> = HashMap::new(); |
| |
| map.insert(1, 2); |
| map.insert(3, 4); |
| |
| let map_str = format!("{:?}", map); |
| |
| assert!(map_str == "{1: 2, 3: 4}" || map_str == "{3: 4, 1: 2}"); |
| assert_eq!(format!("{:?}", empty), "{}"); |
| } |
| |
| #[test] |
| fn test_expand() { |
| let mut m = HashMap::new(); |
| |
| assert_eq!(m.len(), 0); |
| assert!(m.is_empty()); |
| |
| let mut i = 0; |
| let old_raw_cap = m.raw_capacity(); |
| while old_raw_cap == m.raw_capacity() { |
| m.insert(i, i); |
| i += 1; |
| } |
| |
| assert_eq!(m.len(), i); |
| assert!(!m.is_empty()); |
| } |
| |
| #[test] |
| fn test_behavior_resize_policy() { |
| let mut m = HashMap::new(); |
| |
| assert_eq!(m.len(), 0); |
| assert_eq!(m.raw_capacity(), 1); |
| assert!(m.is_empty()); |
| |
| m.insert(0, 0); |
| m.remove(&0); |
| assert!(m.is_empty()); |
| let initial_raw_cap = m.raw_capacity(); |
| m.reserve(initial_raw_cap); |
| let raw_cap = m.raw_capacity(); |
| |
| assert_eq!(raw_cap, initial_raw_cap * 2); |
| |
| let mut i = 0; |
| for _ in 0..raw_cap * 3 / 4 { |
| m.insert(i, i); |
| i += 1; |
| } |
| // three quarters full |
| |
| assert_eq!(m.len(), i); |
| assert_eq!(m.raw_capacity(), raw_cap); |
| |
| for _ in 0..raw_cap / 4 { |
| m.insert(i, i); |
| i += 1; |
| } |
| // half full |
| |
| let new_raw_cap = m.raw_capacity(); |
| assert_eq!(new_raw_cap, raw_cap * 2); |
| |
| for _ in 0..raw_cap / 2 - 1 { |
| i -= 1; |
| m.remove(&i); |
| assert_eq!(m.raw_capacity(), new_raw_cap); |
| } |
| // A little more than one quarter full. |
| m.shrink_to_fit(); |
| assert_eq!(m.raw_capacity(), raw_cap); |
| // again, a little more than half full |
| for _ in 0..raw_cap / 2 { |
| i -= 1; |
| m.remove(&i); |
| } |
| m.shrink_to_fit(); |
| |
| assert_eq!(m.len(), i); |
| assert!(!m.is_empty()); |
| assert_eq!(m.raw_capacity(), initial_raw_cap); |
| } |
| |
| #[test] |
| fn test_reserve_shrink_to_fit() { |
| let mut m = HashMap::new(); |
| m.insert(0, 0); |
| m.remove(&0); |
| assert!(m.capacity() >= m.len()); |
| for i in 0..128 { |
| m.insert(i, i); |
| } |
| m.reserve(256); |
| |
| let usable_cap = m.capacity(); |
| for i in 128..(128 + 256) { |
| m.insert(i, i); |
| assert_eq!(m.capacity(), usable_cap); |
| } |
| |
| for i in 100..(128 + 256) { |
| assert_eq!(m.remove(&i), Some(i)); |
| } |
| m.shrink_to_fit(); |
| |
| assert_eq!(m.len(), 100); |
| assert!(!m.is_empty()); |
| assert!(m.capacity() >= m.len()); |
| |
| for i in 0..100 { |
| assert_eq!(m.remove(&i), Some(i)); |
| } |
| m.shrink_to_fit(); |
| m.insert(0, 0); |
| |
| assert_eq!(m.len(), 1); |
| assert!(m.capacity() >= m.len()); |
| assert_eq!(m.remove(&0), Some(0)); |
| } |
| |
| #[test] |
| fn test_from_iter() { |
| let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; |
| |
| let map: HashMap<_, _> = xs.iter().cloned().collect(); |
| |
| for &(k, v) in &xs { |
| assert_eq!(map.get(&k), Some(&v)); |
| } |
| } |
| |
| #[test] |
| fn test_size_hint() { |
| let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; |
| |
| let map: HashMap<_, _> = xs.iter().cloned().collect(); |
| |
| let mut iter = map.iter(); |
| |
| for _ in iter.by_ref().take(3) {} |
| |
| assert_eq!(iter.size_hint(), (3, Some(3))); |
| } |
| |
| #[test] |
| fn test_iter_len() { |
| let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; |
| |
| let map: HashMap<_, _> = xs.iter().cloned().collect(); |
| |
| let mut iter = map.iter(); |
| |
| for _ in iter.by_ref().take(3) {} |
| |
| assert_eq!(iter.len(), 3); |
| } |
| |
| #[test] |
| fn test_mut_size_hint() { |
| let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; |
| |
| let mut map: HashMap<_, _> = xs.iter().cloned().collect(); |
| |
| let mut iter = map.iter_mut(); |
| |
| for _ in iter.by_ref().take(3) {} |
| |
| assert_eq!(iter.size_hint(), (3, Some(3))); |
| } |
| |
| #[test] |
| fn test_iter_mut_len() { |
| let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; |
| |
| let mut map: HashMap<_, _> = xs.iter().cloned().collect(); |
| |
| let mut iter = map.iter_mut(); |
| |
| for _ in iter.by_ref().take(3) {} |
| |
| assert_eq!(iter.len(), 3); |
| } |
| |
| #[test] |
| fn test_index() { |
| let mut map = HashMap::new(); |
| |
| map.insert(1, 2); |
| map.insert(2, 1); |
| map.insert(3, 4); |
| |
| assert_eq!(map[&2], 1); |
| } |
| |
| #[test] |
| #[should_panic] |
| fn test_index_nonexistent() { |
| let mut map = HashMap::new(); |
| |
| map.insert(1, 2); |
| map.insert(2, 1); |
| map.insert(3, 4); |
| |
| map[&4]; |
| } |
| |
| #[test] |
| fn test_entry() { |
| let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; |
| |
| let mut map: HashMap<_, _> = xs.iter().cloned().collect(); |
| |
| // Existing key (insert) |
| match map.entry(1) { |
| Vacant(_) => unreachable!(), |
| Occupied(mut view) => { |
| assert_eq!(view.get(), &10); |
| assert_eq!(view.insert(100), 10); |
| } |
| } |
| assert_eq!(map.get(&1).unwrap(), &100); |
| assert_eq!(map.len(), 6); |
| |
| // Existing key (update) |
| match map.entry(2) { |
| Vacant(_) => unreachable!(), |
| Occupied(mut view) => { |
| let v = view.get_mut(); |
| let new_v = (*v) * 10; |
| *v = new_v; |
| } |
| } |
| assert_eq!(map.get(&2).unwrap(), &200); |
| assert_eq!(map.len(), 6); |
| |
| // Existing key (take) |
| match map.entry(3) { |
| Vacant(_) => unreachable!(), |
| Occupied(view) => { |
| assert_eq!(view.remove(), 30); |
| } |
| } |
| assert_eq!(map.get(&3), None); |
| assert_eq!(map.len(), 5); |
| |
| // Inexistent key (insert) |
| match map.entry(10) { |
| Occupied(_) => unreachable!(), |
| Vacant(view) => { |
| assert_eq!(*view.insert(1000), 1000); |
| } |
| } |
| assert_eq!(map.get(&10).unwrap(), &1000); |
| assert_eq!(map.len(), 6); |
| } |
| |
| #[test] |
| fn test_entry_take_doesnt_corrupt() { |
| #![allow(deprecated)] //rand |
| // Test for #19292 |
| fn check(m: &HashMap<i32, ()>) { |
| for k in m.keys() { |
| assert!(m.contains_key(k), "{} is in keys() but not in the map?", k); |
| } |
| } |
| |
| let mut m = HashMap::new(); |
| |
| 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) |
| }; |
| |
| // Populate the map with some items. |
| for _ in 0..50 { |
| let x = rng.gen_range(-10, 10); |
| m.insert(x, ()); |
| } |
| |
| for _ in 0..1000 { |
| let x = rng.gen_range(-10, 10); |
| match m.entry(x) { |
| Vacant(_) => {} |
| Occupied(e) => { |
| e.remove(); |
| } |
| } |
| |
| check(&m); |
| } |
| } |
| |
| #[test] |
| fn test_extend_ref() { |
| let mut a = HashMap::new(); |
| a.insert(1, "one"); |
| let mut b = HashMap::new(); |
| b.insert(2, "two"); |
| b.insert(3, "three"); |
| |
| a.extend(&b); |
| |
| assert_eq!(a.len(), 3); |
| assert_eq!(a[&1], "one"); |
| assert_eq!(a[&2], "two"); |
| assert_eq!(a[&3], "three"); |
| } |
| |
| #[test] |
| fn test_capacity_not_less_than_len() { |
| let mut a = HashMap::new(); |
| let mut item = 0; |
| |
| for _ in 0..116 { |
| a.insert(item, 0); |
| item += 1; |
| } |
| |
| assert!(a.capacity() > a.len()); |
| |
| let free = a.capacity() - a.len(); |
| for _ in 0..free { |
| a.insert(item, 0); |
| item += 1; |
| } |
| |
| assert_eq!(a.len(), a.capacity()); |
| |
| // Insert at capacity should cause allocation. |
| a.insert(item, 0); |
| assert!(a.capacity() > a.len()); |
| } |
| |
| #[test] |
| fn test_occupied_entry_key() { |
| let mut a = HashMap::new(); |
| let key = "hello there"; |
| let value = "value goes here"; |
| assert!(a.is_empty()); |
| a.insert(key.clone(), value.clone()); |
| assert_eq!(a.len(), 1); |
| assert_eq!(a[key], value); |
| |
| match a.entry(key.clone()) { |
| Vacant(_) => panic!(), |
| Occupied(e) => assert_eq!(key, *e.key()), |
| } |
| assert_eq!(a.len(), 1); |
| assert_eq!(a[key], value); |
| } |
| |
| #[test] |
| fn test_vacant_entry_key() { |
| let mut a = HashMap::new(); |
| let key = "hello there"; |
| let value = "value goes here"; |
| |
| assert!(a.is_empty()); |
| match a.entry(key.clone()) { |
| Occupied(_) => panic!(), |
| Vacant(e) => { |
| assert_eq!(key, *e.key()); |
| e.insert(value.clone()); |
| } |
| } |
| assert_eq!(a.len(), 1); |
| assert_eq!(a[key], value); |
| } |
| |
| #[test] |
| fn test_retain() { |
| let mut map: HashMap<i32, i32> = (0..100).map(|x| (x, x * 10)).collect(); |
| |
| map.retain(|&k, _| k % 2 == 0); |
| assert_eq!(map.len(), 50); |
| assert_eq!(map[&2], 20); |
| assert_eq!(map[&4], 40); |
| assert_eq!(map[&6], 60); |
| } |
| |
| #[test] |
| 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(); |
| |
| const MAX_USIZE: usize = usize::MAX; |
| |
| if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_USIZE) { |
| } else { |
| panic!("usize::MAX should trigger an overflow!"); |
| } |
| |
| if let Err(AllocErr { .. }) = empty_bytes.try_reserve(MAX_USIZE / 8) { |
| } else { |
| // This may succeed if there is enough free memory. Attempt to |
| // allocate a second hashmap to ensure the allocation will fail. |
| let mut empty_bytes2: HashMap<u8, u8> = HashMap::new(); |
| if let Err(AllocErr { .. }) = empty_bytes2.try_reserve(MAX_USIZE / 8) { |
| } else { |
| panic!("usize::MAX / 8 should trigger an OOM!"); |
| } |
| } |
| } |
| |
| #[test] |
| fn test_raw_entry() { |
| use super::RawEntryMut::{Occupied, Vacant}; |
| |
| let xs = [(1i32, 10i32), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; |
| |
| let mut map: HashMap<_, _> = xs.iter().cloned().collect(); |
| |
| let compute_hash = |map: &HashMap<i32, i32>, k: i32| -> u64 { |
| use core::hash::{BuildHasher, Hash, Hasher}; |
| |
| let mut hasher = map.hasher().build_hasher(); |
| k.hash(&mut hasher); |
| hasher.finish() |
| }; |
| |
| // Existing key (insert) |
| match map.raw_entry_mut().from_key(&1) { |
| Vacant(_) => unreachable!(), |
| Occupied(mut view) => { |
| assert_eq!(view.get(), &10); |
| assert_eq!(view.insert(100), 10); |
| } |
| } |
| let hash1 = compute_hash(&map, 1); |
| assert_eq!(map.raw_entry().from_key(&1).unwrap(), (&1, &100)); |
| assert_eq!( |
| map.raw_entry().from_hash(hash1, |k| *k == 1).unwrap(), |
| (&1, &100) |
| ); |
| assert_eq!( |
| map.raw_entry().from_key_hashed_nocheck(hash1, &1).unwrap(), |
| (&1, &100) |
| ); |
| assert_eq!(map.len(), 6); |
| |
| // Existing key (update) |
| match map.raw_entry_mut().from_key(&2) { |
| Vacant(_) => unreachable!(), |
| Occupied(mut view) => { |
| let v = view.get_mut(); |
| let new_v = (*v) * 10; |
| *v = new_v; |
| } |
| } |
| let hash2 = compute_hash(&map, 2); |
| assert_eq!(map.raw_entry().from_key(&2).unwrap(), (&2, &200)); |
| assert_eq!( |
| map.raw_entry().from_hash(hash2, |k| *k == 2).unwrap(), |
| (&2, &200) |
| ); |
| assert_eq!( |
| map.raw_entry().from_key_hashed_nocheck(hash2, &2).unwrap(), |
| (&2, &200) |
| ); |
| assert_eq!(map.len(), 6); |
| |
| // Existing key (take) |
| let hash3 = compute_hash(&map, 3); |
| match map.raw_entry_mut().from_key_hashed_nocheck(hash3, &3) { |
| Vacant(_) => unreachable!(), |
| Occupied(view) => { |
| assert_eq!(view.remove_entry(), (3, 30)); |
| } |
| } |
| assert_eq!(map.raw_entry().from_key(&3), None); |
| assert_eq!(map.raw_entry().from_hash(hash3, |k| *k == 3), None); |
| assert_eq!(map.raw_entry().from_key_hashed_nocheck(hash3, &3), None); |
| assert_eq!(map.len(), 5); |
| |
| // Nonexistent key (insert) |
| match map.raw_entry_mut().from_key(&10) { |
| Occupied(_) => unreachable!(), |
| Vacant(view) => { |
| assert_eq!(view.insert(10, 1000), (&mut 10, &mut 1000)); |
| } |
| } |
| assert_eq!(map.raw_entry().from_key(&10).unwrap(), (&10, &1000)); |
| assert_eq!(map.len(), 6); |
| |
| // Ensure all lookup methods produce equivalent results. |
| for k in 0..12 { |
| let hash = compute_hash(&map, k); |
| let v = map.get(&k).cloned(); |
| let kv = v.as_ref().map(|v| (&k, v)); |
| |
| assert_eq!(map.raw_entry().from_key(&k), kv); |
| assert_eq!(map.raw_entry().from_hash(hash, |q| *q == k), kv); |
| assert_eq!(map.raw_entry().from_key_hashed_nocheck(hash, &k), kv); |
| |
| match map.raw_entry_mut().from_key(&k) { |
| Occupied(mut o) => assert_eq!(Some(o.get_key_value()), kv), |
| Vacant(_) => assert_eq!(v, None), |
| } |
| match map.raw_entry_mut().from_key_hashed_nocheck(hash, &k) { |
| Occupied(mut o) => assert_eq!(Some(o.get_key_value()), kv), |
| Vacant(_) => assert_eq!(v, None), |
| } |
| match map.raw_entry_mut().from_hash(hash, |q| *q == k) { |
| Occupied(mut o) => assert_eq!(Some(o.get_key_value()), kv), |
| Vacant(_) => assert_eq!(v, None), |
| } |
| } |
| } |
| |
| #[test] |
| fn test_key_without_hash_impl() { |
| #[derive(Debug)] |
| struct IntWrapper(u64); |
| |
| let mut m: HashMap<IntWrapper, (), ()> = HashMap::default(); |
| { |
| assert!(m.raw_entry().from_hash(0, |k| k.0 == 0).is_none()); |
| } |
| { |
| let vacant_entry = match m.raw_entry_mut().from_hash(0, |k| k.0 == 0) { |
| RawEntryMut::Occupied(..) => panic!("Found entry for key 0"), |
| RawEntryMut::Vacant(e) => e, |
| }; |
| vacant_entry.insert_with_hasher(0, IntWrapper(0), (), |k| k.0); |
| } |
| { |
| assert!(m.raw_entry().from_hash(0, |k| k.0 == 0).is_some()); |
| assert!(m.raw_entry().from_hash(1, |k| k.0 == 1).is_none()); |
| assert!(m.raw_entry().from_hash(2, |k| k.0 == 2).is_none()); |
| } |
| { |
| let vacant_entry = match m.raw_entry_mut().from_hash(1, |k| k.0 == 1) { |
| RawEntryMut::Occupied(..) => panic!("Found entry for key 1"), |
| RawEntryMut::Vacant(e) => e, |
| }; |
| vacant_entry.insert_with_hasher(1, IntWrapper(1), (), |k| k.0); |
| } |
| { |
| assert!(m.raw_entry().from_hash(0, |k| k.0 == 0).is_some()); |
| assert!(m.raw_entry().from_hash(1, |k| k.0 == 1).is_some()); |
| assert!(m.raw_entry().from_hash(2, |k| k.0 == 2).is_none()); |
| } |
| { |
| let occupied_entry = match m.raw_entry_mut().from_hash(0, |k| k.0 == 0) { |
| RawEntryMut::Occupied(e) => e, |
| RawEntryMut::Vacant(..) => panic!("Couldn't find entry for key 0"), |
| }; |
| occupied_entry.remove(); |
| } |
| assert!(m.raw_entry().from_hash(0, |k| k.0 == 0).is_none()); |
| assert!(m.raw_entry().from_hash(1, |k| k.0 == 1).is_some()); |
| assert!(m.raw_entry().from_hash(2, |k| k.0 == 2).is_none()); |
| } |
| } |