Enum abi_stable::std_types::map::REntry

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

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

Variants

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

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

Implementations

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

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));

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));

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);

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")
);

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")
);

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"))
);

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);

Trait Implementations

impl<K, V> Debug for REntry<'_, K, V> where
    K: Debug,
    V: Debug, 

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

Formats the value using the given formatter.

impl<'a, K, V> GetStaticEquivalent_ for REntry<'a, K, V> where
    K: __StableAbi,
    V: __StableAbi,
    K: 'a,
    V: 'a, 

type StaticEquivalent = _static_REntry<'static, __GetStaticEquivalent<K>, __GetStaticEquivalent<V>>

impl<'a, K, V> StableAbi for REntry<'a, K, V> where
    K: __StableAbi,
    V: __StableAbi,
    K: 'a,
    V: 'a, 

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

pub const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

pub const ABI_CONSTS: AbiConsts

const-equivalents of the associated types.