Enum Entry

pub enum Entry<'a, K: 'a, V: 'a, A: Allocator = Global>

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.

Variants

Occupied(OccupiedEntry<'a, K, V, A>)

An occupied entry.

Vacant(VacantEntry<'a, K, V, A>)

A vacant entry.

Implementations

impl<'a, K, V, A: Allocator> Entry<'a, K, V, A>

fn or_insert(self, default: V) -> &'a mut V

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 std::collections::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);

fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V

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 std::collections::HashMap;

let mut map = HashMap::new();
let value = "hoho";

map.entry("poneyland").or_insert_with(|| value);

assert_eq!(map["poneyland"], "hoho");

fn or_try_insert_with<F: FnOnce() -> Result<V, E>, E>(self, default: F) -> Result<&'a mut V, E>

Ensures a value is in the entry by inserting the result of a fallible default function if empty, and returns a mutable reference to the value in the entry.

This method works identically to or_insert_with except that the default function should return a Result and, in the case of an error, the error is propagated.

Examples

#![feature(try_entry)]
# fn main() -> Result<(), std::num::ParseIntError> {
use std::collections::HashMap;

let mut map: HashMap<&str, usize> = HashMap::new();
let value = "42";

map.entry("poneyland").or_try_insert_with(|| value.parse())?;

assert_eq!(map["poneyland"], 42);
# Ok(())
# }

fn or_insert_with_key<F: FnOnce(&K) -> V>(self, default: F) -> &'a mut V

Ensures a value is in the entry by inserting, if empty, the result of the default function. This method allows for generating key-derived values for insertion by providing the default function a reference to the key that was moved during the .entry(key) method call.

The reference to the moved key is provided so that cloning or copying the key is unnecessary, unlike with .or_insert_with(|| ... ).

Examples

use std::collections::HashMap;

let mut map: HashMap<&str, usize> = HashMap::new();

map.entry("poneyland").or_insert_with_key(|key| key.chars().count());

assert_eq!(map["poneyland"], 9);

fn or_try_insert_with_key<F: FnOnce(&K) -> Result<V, E>, E>(self, default: F) -> Result<&'a mut V, E>

Ensures a value is in the entry by inserting, if empty, the result of the default function. This method allows for generating key-derived values for insertion by providing the default function a reference to the key that was moved during the entry(key) method call.

This method works identically to or_insert_with_key except that the default function should return a Result and, in the case of an error, the error is propagated.

Examples

#![feature(try_entry)]
# fn main() -> Result<(), std::num::ParseIntError> {
use std::collections::HashMap;

let mut map: HashMap<&str, usize> = HashMap::new();

map.entry("42").or_try_insert_with_key(|key| key.parse())?;

assert_eq!(map["42"], 42);
# Ok(())
# }

fn key(&self) -> &K

Returns a reference to this entry's key.

Examples

use std::collections::HashMap;

let mut map: HashMap<&str, u32> = HashMap::new();
assert_eq!(map.entry("poneyland").key(), &"poneyland");

fn and_modify<F>(self, f: F) -> Self
where
    F: FnOnce(&mut V),

Provides in-place mutable access to an occupied entry before any potential inserts into the map.

Examples

use std::collections::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);

fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V, A>

Sets the value of the entry, and returns an OccupiedEntry.

Examples

use std::collections::HashMap;

let mut map: HashMap<&str, String> = HashMap::new();
let entry = map.entry("poneyland").insert_entry("hoho".to_string());

assert_eq!(entry.key(), &"poneyland");

impl<'a, K, V: Default> Entry<'a, K, V>

fn or_default(self) -> &'a mut V

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

# fn main() {
use std::collections::HashMap;

let mut map: HashMap<&str, Option<u32>> = HashMap::new();
map.entry("poneyland").or_default();

assert_eq!(map["poneyland"], None);
# }

Trait Implementations

impl<K: Debug, V: Debug> Debug for Entry<'_, K, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Auto Trait Implementations

impl<'a, K, V, A = Global> !UnwindSafe for Entry<'a, K, V, A>

impl<'a, K, V, A> Freeze for Entry<'a, K, V, A> where OccupiedEntry<'a, K, V, A>: Freeze, VacantEntry<'a, K, V, A>: Freeze,

impl<'a, K, V, A> RefUnwindSafe for Entry<'a, K, V, A> where OccupiedEntry<'a, K, V, A>: RefUnwindSafe, VacantEntry<'a, K, V, A>: RefUnwindSafe,

impl<'a, K, V, A> Send for Entry<'a, K, V, A> where OccupiedEntry<'a, K, V, A>: Send, VacantEntry<'a, K, V, A>: Send,

impl<'a, K, V, A> Sync for Entry<'a, K, V, A> where OccupiedEntry<'a, K, V, A>: Sync, VacantEntry<'a, K, V, A>: Sync,

impl<'a, K, V, A> Unpin for Entry<'a, K, V, A> where OccupiedEntry<'a, K, V, A>: Unpin, VacantEntry<'a, K, V, A>: Unpin,

impl<'a, K, V, A> UnsafeUnpin for Entry<'a, K, V, A> where OccupiedEntry<'a, K, V, A>: UnsafeUnpin, VacantEntry<'a, K, V, A>: UnsafeUnpin,

Blanket Implementations

impl<T> Any for Entry<'a, K, V, A> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Entry<'a, K, V, A> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Entry<'a, K, V, A> where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for Entry<'a, K, V, A>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SizeHint for Entry<'a, K, V, A> where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for Entry<'a, K, V, A>

impl<T, U> Into<U> for Entry<'a, K, V, A> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for Entry<'a, K, V, A> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Entry<'a, K, V, A> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>