Struct abi_stable::std_types::map::ROccupiedEntry

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

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, 

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

Formats the value using the given formatter.

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

pub fn drop(&mut self)

Executes the destructor for this type.

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

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

impl<'a, K, V> StableAbi for ROccupiedEntry<'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.