Struct VacantEntry 

pub struct VacantEntry<'a, K, V>
where
    K: Key,
{ /* private fields */ }

A view into a vacant entry in a SecondaryMap. It is part of the Entry enum.

Implementations

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

where K: Key,

pub fn key(&self) -> K

Gets the key that would be used when inserting a value through the VacantEntry.

Examples

let mut sm = SlotMap::new();
let mut sec: SecondaryMap<_, ()> = SecondaryMap::new();

let k = sm.insert(1);

if let Entry::Vacant(v) = sec.entry(k).unwrap() {
    assert_eq!(v.key(), k);
}

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

Sets the value of the entry with the VacantEntry’s key, and returns a mutable reference to it.

Examples

let mut sm = SlotMap::new();
let mut sec = SecondaryMap::new();

let k = sm.insert(1);

if let Entry::Vacant(v) = sec.entry(k).unwrap() {
    let new_val = v.insert(3);
    assert_eq!(new_val, &mut 3);
}

pub fn remove_stale_entry(&mut self) -> Option<(K, V)>

Returns the stale key and data, if any, which would be overwritten by inserting using this VacantEntry.

This situation arises if the stale key was removed from the primary map, and a subsequent insert into the primary map reused the slot.

remove_stale_entry can be used to handle this situation specially — for example, if the application wants to lazily clean up tertiary data in another data structure indexed by the now-stale key, or by the value stored in the SecondaryMap.

Most applications will not need this.

Examples

let mut pri = SlotMap::new();
let mut sec = SecondaryMap::new();

let k1 = pri.insert(1);

let ent = sec.entry(k1);
let mut vacant = match ent { Some(Entry::Vacant(vac)) => vac, _ => panic!("1. {:?}", &ent) };
assert_eq!(vacant.remove_stale_entry(), None);

sec.insert(k1, 'a');
pri.remove(k1);
// Imagine we don't keep a note of k1, after this.
let k2 = pri.insert(2);

let ent = sec.entry(k2);
let mut vacant = match ent { Some(Entry::Vacant(vac)) => vac, _ => panic!("2. {:?}", &ent) };
// Now we have recovered k1 and the associated data:
assert_eq!(vacant.remove_stale_entry(), Some((k1, 'a')));
assert_eq!(vacant.remove_stale_entry(), None);

vacant.insert('b');
assert!(sec.entry(k1).is_none());

Trait Implementations

impl<'a, K, V> Debug for VacantEntry<'a, K, V>

where K: Debug + Key, V: Debug,

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

Formats the value using the given formatter.