Enum abi_stable::std_types::map::REntry

source ·

#[repr(C)]pub enum REntry<'a, K, V> {
    Occupied(ROccupiedEntry<'a, K, V>),
    Vacant(RVacantEntry<'a, K, V>),
}

Expand description

A handle into an entry in a map, which is either vacant or occupied.

Variants§

§

Occupied(ROccupiedEntry<'a, K, V>)

An occupied entry

§

Vacant(RVacantEntry<'a, K, V>)

A vacnt entry

Implementations§

source §

impl<'a, K, V> REntry<'a, K, V>

source

pub fn get(&self) -> Option<&V>

Returns a reference to the value in the entry.

§Example

use abi_stable::std_types::RHashMap;

let mut map: RHashMap<u32, u32> = vec![(1, 100)].into_iter().collect();

assert_eq!(map.entry(0).get(), None);
assert_eq!(map.entry(1).get(), Some(&100));

source

pub fn get_mut(&mut self) -> Option<&mut V>

Returns a mutable reference to the value in the entry.

§Example

use abi_stable::std_types::RHashMap;

let mut map: RHashMap<u32, u32> = vec![(1, 100)].into_iter().collect();

assert_eq!(map.entry(0).get_mut(), None);
assert_eq!(map.entry(1).get_mut(), Some(&mut 100));

source

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

Inserts default as the value in the entry if it wasn’t occupied, returning a mutable reference to the value in the entry.

§Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();

assert_eq!(map.entry(0).or_insert(100), &mut 100);

assert_eq!(map.entry(0).or_insert(400), &mut 100);

source

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

Inserts default() as the value in the entry if it wasn’t occupied, returning a mutable reference to the value in the entry.

§Example

use abi_stable::std_types::{RHashMap, RString};

let mut map = RHashMap::<u32, RString>::new();

assert_eq!(
    map.entry(0).or_insert_with(|| "foo".into()),
    &mut RString::from("foo")
);

assert_eq!(
    map.entry(0).or_insert_with(|| "bar".into()),
    &mut RString::from("foo")
);

source

pub fn key(&self) -> &K

Gets the key of the entry.

§Example

use abi_stable::std_types::{RHashMap, RString};

let mut map = RHashMap::<RString, RString>::new();
map.insert("foo".into(), "bar".into());

assert_eq!(map.entry("foo".into()).key(), &RString::from("foo"));

source

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

Allows mutating an occupied entry before doing other operations.

This is a no-op on a vacant entry.

§Example

use abi_stable::std_types::{RHashMap, RString};

let mut map = RHashMap::<RString, RString>::new();
map.insert("foo".into(), "bar".into());

assert_eq!(
    map.entry("foo".into())
        .and_modify(|x| x.push_str("hoo"))
        .get(),
    Some(&RString::from("barhoo"))
);

source

pub fn or_default(self) -> &'a mut V
where V: Default,

Inserts the V::default() value in the entry if it wasn’t occupied, returning a mutable reference to the value in the entry.

§Example

use abi_stable::std_types::RHashMap;

let mut map = RHashMap::<u32, u32>::new();

assert_eq!(map.entry(0).or_insert(100), &mut 100);
assert_eq!(map.entry(0).or_default(), &mut 100);

assert_eq!(map.entry(1).or_default(), &mut 0);