Struct abi_stable::std_types::map::ROccupiedEntry

#[repr(C)]
pub struct ROccupiedEntry<'a, K, V> { /* private fields */ }

A handle into an occupied entry in a map.

Implementations

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

pub fn key(&self) -> &K

Gets a reference to the key of the entry.

Example

use abi_stable::std_types::map::{REntry, RHashMap};

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

map.insert(0, 100);

match map.entry(0) {
    REntry::Occupied(entry) => {
        assert_eq!(entry.key(), &0);
    }
    REntry::Vacant(_) => unreachable!(),
};

pub fn get(&self) -> &V

Gets a reference to the value in the entry.

Example

use abi_stable::std_types::map::{REntry, RHashMap};

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

map.insert(6, 15);

match map.entry(6) {
    REntry::Occupied(entry) => {
        assert_eq!(entry.get(), &15);
    }
    REntry::Vacant(_) => unreachable!(),
};

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

Gets a mutable reference to the value in the entry. To borrow with the lifetime of the map, use ROccupiedEntry::into_mut.

Example

use abi_stable::std_types::map::{REntry, RHashMap};

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

map.insert(6, 15);

match map.entry(6) {
    REntry::Occupied(mut entry) => {
        assert_eq!(entry.get_mut(), &mut 15);
    }
    REntry::Vacant(_) => unreachable!(),
};

pub fn into_mut(self) -> &'a mut V

Gets a mutable reference to the value in the entry, that borrows with the lifetime of the map instead of borrowing from this ROccupiedEntry.

Example

use abi_stable::std_types::map::{REntry, RHashMap};

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

map.insert("baz".into(), 0xDEAD);

match map.entry("baz".into()) {
    REntry::Occupied(entry) => {
        assert_eq!(entry.into_mut(), &mut 0xDEAD);
    }
    REntry::Vacant(_) => unreachable!(),
};

pub fn insert(&mut self, value: V) -> V

Replaces the current value of the entry with value, returning the previous value.

Example

use abi_stable::std_types::map::{REntry, RHashMap};

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

map.insert("baz".into(), 0xD00D);

match map.entry("baz".into()) {
    REntry::Occupied(mut entry) => {
        assert_eq!(entry.insert(0xDEAD), 0xD00D);
    }
    REntry::Vacant(_) => {
        unreachable!();
    }
}

assert_eq!(map.get("baz"), Some(&0xDEAD));

pub fn remove(self) -> V

Removes the entry from the map, returns the value.

Example

use abi_stable::std_types::map::{REntry, RHashMap};

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

map.insert("baz".into(), 0xDEAD);

match map.entry("baz".into()) {
    REntry::Occupied(entry) => {
        assert_eq!(entry.remove(), 0xDEAD);
    }
    REntry::Vacant(_) => {
        unreachable!();
    }
}

assert!(!map.contains_key("baz"));

Trait Implementations

impl<K, V> Debug for ROccupiedEntry<'_, K, V>

where K: Debug, V: Debug,

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

Formats the value using the given formatter.

impl<'a, K, V> Drop for ROccupiedEntry<'a, K, V>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, K, V> GetStaticEquivalent_ for ROccupiedEntry<'a, K, V>

where K: __StableAbi + 'a, V: __StableAbi + 'a,

type StaticEquivalent = _static_ROccupiedEntry<'static, <K as GetStaticEquivalent_>::StaticEquivalent, <V as GetStaticEquivalent_>::StaticEquivalent>

The 'static equivalent of Self

impl<'a, K, V> StableAbi for ROccupiedEntry<'a, K, V>

where K: __StableAbi + 'a, V: __StableAbi + 'a,

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.