[−][src]Struct griddle::HashMap
A HashMap
variant that spreads resize load across inserts.
See the crate-level documentation for details.
Examples
use griddle::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); }
Implementations
impl<K, V> HashMap<K, V, DefaultHashBuilder>
[src]
pub fn new() -> Self
[src]
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 griddle::HashMap; let mut map: HashMap<&str, i32> = HashMap::new();
pub fn with_capacity(capacity: usize) -> Self
[src]
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 griddle::HashMap; let mut map: HashMap<&str, i32> = HashMap::with_capacity(10);
impl<K, V, S> HashMap<K, V, S>
[src]
pub fn with_hasher(hash_builder: S) -> Self
[src]
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.
The hash_builder
passed should implement the BuildHasher
trait for
the HashMap to be useful, see its documentation for details.
Examples
use griddle::HashMap; use hashbrown::hash_map::DefaultHashBuilder; let s = DefaultHashBuilder::default(); let mut map = HashMap::with_hasher(s); map.insert(1, 2);
pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> Self
[src]
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.
The hash_builder
passed should implement the BuildHasher
trait for
the HashMap to be useful, see its documentation for details.
Examples
use griddle::HashMap; use hashbrown::hash_map::DefaultHashBuilder; let s = DefaultHashBuilder::default(); let mut map = HashMap::with_capacity_and_hasher(10, s); map.insert(1, 2);
pub fn hasher(&self) -> &S
[src]
Returns a reference to the map's BuildHasher
.
Examples
use griddle::HashMap; use hashbrown::hash_map::DefaultHashBuilder; let hasher = DefaultHashBuilder::default(); let map: HashMap<i32, i32> = HashMap::with_hasher(hasher); let hasher: &DefaultHashBuilder = map.hasher();
pub fn capacity(&self) -> usize
[src]
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 griddle::HashMap; let map: HashMap<i32, i32> = HashMap::with_capacity(100); assert!(map.capacity() >= 100);
pub fn keys(&self) -> Keys<K, V>
[src]
An iterator visiting all keys in arbitrary order.
The iterator element type is &'a K
.
Examples
use griddle::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); }
pub fn values(&self) -> Values<K, V>
[src]
An iterator visiting all values in arbitrary order.
The iterator element type is &'a V
.
Examples
use griddle::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); }
pub fn values_mut(&mut self) -> ValuesMut<K, V>
[src]
An iterator visiting all values mutably in arbitrary order.
The iterator element type is &'a mut V
.
Examples
use griddle::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); }
pub fn iter(&self) -> Iter<K, V>
[src]
An iterator visiting all key-value pairs in arbitrary order.
The iterator element type is (&'a K, &'a V)
.
Examples
use griddle::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); }
pub fn iter_mut(&mut self) -> IterMut<K, V>
[src]
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 griddle::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); }
pub fn len(&self) -> usize
[src]
Returns the number of elements in the map.
Examples
use griddle::HashMap; let mut a = HashMap::new(); assert_eq!(a.len(), 0); a.insert(1, "a"); assert_eq!(a.len(), 1);
pub fn is_empty(&self) -> bool
[src]
Returns true
if the map contains no elements.
Examples
use griddle::HashMap; let mut a = HashMap::new(); assert!(a.is_empty()); a.insert(1, "a"); assert!(!a.is_empty());
pub fn clear(&mut self)
[src]
Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.
Examples
use griddle::HashMap; let mut a = HashMap::new(); a.insert(1, "a"); a.clear(); assert!(a.is_empty());
impl<K, V, S> HashMap<K, V, S> where
K: Eq + Hash,
S: BuildHasher,
[src]
K: Eq + Hash,
S: BuildHasher,
pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V> where
K: Borrow<Q>,
Q: Hash + Eq,
[src]
K: Borrow<Q>,
Q: Hash + Eq,
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.
Examples
use griddle::HashMap; let mut map = HashMap::new(); map.insert(1, "a"); assert_eq!(map.get(&1), Some(&"a")); assert_eq!(map.get(&2), None);
pub fn get_key_value<Q: ?Sized>(&self, k: &Q) -> Option<(&K, &V)> where
K: Borrow<Q>,
Q: Hash + Eq,
[src]
K: Borrow<Q>,
Q: Hash + Eq,
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.
Examples
use griddle::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);
pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool where
K: Borrow<Q>,
Q: Hash + Eq,
[src]
K: Borrow<Q>,
Q: Hash + Eq,
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.
Examples
use griddle::HashMap; let mut map = HashMap::new(); map.insert(1, "a"); assert_eq!(map.contains_key(&1), true); assert_eq!(map.contains_key(&2), false);
pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V> where
K: Borrow<Q>,
Q: Hash + Eq,
[src]
K: Borrow<Q>,
Q: Hash + Eq,
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.
Examples
use griddle::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");
pub fn insert(&mut self, k: K, v: V) -> Option<V>
[src]
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.
Examples
use griddle::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");
pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V> where
K: Borrow<Q>,
Q: Hash + Eq,
[src]
K: Borrow<Q>,
Q: Hash + Eq,
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.
Examples
use griddle::HashMap; let mut map = HashMap::new(); map.insert(1, "a"); assert_eq!(map.remove(&1), Some("a")); assert_eq!(map.remove(&1), None);
pub fn remove_entry<Q: ?Sized>(&mut self, k: &Q) -> Option<(K, V)> where
K: Borrow<Q>,
Q: Hash + Eq,
[src]
K: Borrow<Q>,
Q: Hash + Eq,
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.
Examples
use griddle::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);
Trait Implementations
impl<K: Clone, V: Clone, S: Clone> Clone for HashMap<K, V, S>
[src]
fn clone(&self) -> Self
[src]
fn clone_from(&mut self, source: &Self)
[src]
impl<K, V, S> Debug for HashMap<K, V, S> where
K: Debug,
V: Debug,
[src]
K: Debug,
V: Debug,
impl<K, V, S> Default for HashMap<K, V, S> where
S: Default,
[src]
S: Default,
impl<K, V, S> Eq for HashMap<K, V, S> where
K: Eq + Hash,
V: Eq,
S: BuildHasher,
[src]
K: Eq + Hash,
V: Eq,
S: BuildHasher,
impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S> where
K: Eq + Hash,
S: BuildHasher + Default,
[src]
K: Eq + Hash,
S: BuildHasher + Default,
fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self
[src]
impl<'_, K, Q: ?Sized, V, S> Index<&'_ Q> for HashMap<K, V, S> where
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash,
S: BuildHasher,
[src]
K: Eq + Hash + Borrow<Q>,
Q: Eq + Hash,
S: BuildHasher,
type Output = V
The returned type after indexing.
fn index(&self, key: &Q) -> &V
[src]
Returns a reference to the value corresponding to the supplied key.
Panics
Panics if the key is not present in the HashMap
.
impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S>
[src]
type Item = (&'a K, &'a V)
The type of the elements being iterated over.
type IntoIter = Iter<'a, K, V>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Iter<'a, K, V>
[src]
impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S>
[src]
type Item = (&'a K, &'a mut V)
The type of the elements being iterated over.
type IntoIter = IterMut<'a, K, V>
Which kind of iterator are we turning this into?
fn into_iter(self) -> IterMut<'a, K, V>
[src]
impl<K, V, S> IntoIterator for HashMap<K, V, S>
[src]
type Item = (K, V)
The type of the elements being iterated over.
type IntoIter = IntoIter<K, V>
Which kind of iterator are we turning this into?
fn into_iter(self) -> IntoIter<K, V>
[src]
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 griddle::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();
impl<K, V, S> PartialEq<HashMap<K, V, S>> for HashMap<K, V, S> where
K: Eq + Hash,
V: PartialEq,
S: BuildHasher,
[src]
K: Eq + Hash,
V: PartialEq,
S: BuildHasher,
Auto Trait Implementations
impl<K, V, S> RefUnwindSafe for HashMap<K, V, S> where
K: RefUnwindSafe,
S: RefUnwindSafe,
V: RefUnwindSafe,
K: RefUnwindSafe,
S: RefUnwindSafe,
V: RefUnwindSafe,
impl<K, V, S> Send for HashMap<K, V, S> where
K: Send,
S: Send,
V: Send,
K: Send,
S: Send,
V: Send,
impl<K, V, S> Sync for HashMap<K, V, S> where
K: Sync,
S: Sync,
V: Sync,
K: Sync,
S: Sync,
V: Sync,
impl<K, V, S> Unpin for HashMap<K, V, S> where
K: Unpin,
S: Unpin,
V: Unpin,
K: Unpin,
S: Unpin,
V: Unpin,
impl<K, V, S> UnwindSafe for HashMap<K, V, S> where
K: RefUnwindSafe + UnwindSafe,
S: UnwindSafe,
V: RefUnwindSafe + UnwindSafe,
K: RefUnwindSafe + UnwindSafe,
S: UnwindSafe,
V: RefUnwindSafe + UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,