Struct OccupiedEntry

pub struct OccupiedEntry<'a, K, V> { /* private fields */ }

A view into an occupied entry in a VecMap. It is part of the Entry enum.

Implementations

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

pub fn key(&self) -> &K

Gets a reference to the key in the entry.

Examples

use vecmap::VecMap;

let mut map: VecMap<&str, u32> = VecMap::new();
map.entry("poneyland").or_insert(12);
assert_eq!(map.entry("poneyland").key(), &"poneyland");

pub fn index(&self) -> usize

Gets the index of the entry.

Examples

use vecmap::VecMap;

let mut map: VecMap<&str, u32> = VecMap::new();
map.entry("poneyland").or_insert(12);
assert_eq!(map.entry("poneyland").index(), 0);

pub fn into_key(self) -> K

Take ownership of the key.

Examples

use vecmap::VecMap;
use vecmap::map::Entry;

let mut map: VecMap<&str, u32> = VecMap::new();
map.insert("foo", 1);

if let Entry::Occupied(v) = map.entry("foo") {
    v.into_key();
}

pub fn get(&self) -> &V

Gets a reference to the value in the entry.

Examples

use vecmap::VecMap;
use vecmap::map::Entry;

let mut map: VecMap<&str, u32> = VecMap::new();
map.entry("poneyland").or_insert(12);

if let Entry::Occupied(o) = map.entry("poneyland") {
    assert_eq!(o.get(), &12);
}

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

Gets a mutable reference to the value in the entry.

If you need a reference to the OccupiedEntry which may outlive the destruction of the Entry value, see into_mut.

Examples

use vecmap::VecMap;
use vecmap::map::Entry;

let mut map: VecMap<&str, u32> = VecMap::new();
map.entry("poneyland").or_insert(12);

assert_eq!(map["poneyland"], 12);
if let Entry::Occupied(mut o) = map.entry("poneyland") {
    *o.get_mut() += 10;
    assert_eq!(*o.get(), 22);

    // We can use the same Entry multiple times.
    *o.get_mut() += 2;
}

assert_eq!(map["poneyland"], 24);

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

Converts the OccupiedEntry into a mutable reference to the value in the entry with a lifetime bound to the map itself.

If you need multiple references to the OccupiedEntry, see get_mut.

Examples

use vecmap::VecMap;
use vecmap::map::Entry;

let mut map: VecMap<&str, u32> = VecMap::new();
map.entry("poneyland").or_insert(12);

assert_eq!(map["poneyland"], 12);
if let Entry::Occupied(o) = map.entry("poneyland") {
    *o.into_mut() += 10;
}

assert_eq!(map["poneyland"], 22);

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

Sets the value of the entry, and returns the entry’s old value.

Examples

use vecmap::VecMap;
use vecmap::map::Entry;

let mut map: VecMap<&str, u32> = VecMap::new();
map.entry("poneyland").or_insert(12);

if let Entry::Occupied(mut o) = map.entry("poneyland") {
    assert_eq!(o.insert(15), 12);
}

assert_eq!(map["poneyland"], 15);

pub fn swap_remove_entry(self) -> (K, V)

Removes and return the key-value pair stored in the map for this entry.

Like Vec::swap_remove, the pair is removed by swapping it with the last element of the map and popping it off. This perturbs the position of what used to be the last element!

Examples

use vecmap::VecMap;
use vecmap::map::Entry;

let mut map: VecMap<&str, u32> = VecMap::new();
map.entry("poneyland").or_insert(12);
map.entry("foo").or_insert(13);
map.entry("bar").or_insert(14);

if let Entry::Occupied(o) = map.entry("poneyland") {
    // We delete the entry from the map.
    o.swap_remove_entry();
}

assert_eq!(map.contains_key("poneyland"), false);
assert_eq!(map.get_index_of("foo"), Some(1));
assert_eq!(map.get_index_of("bar"), Some(0));

pub fn remove_entry(self) -> (K, V)

Removes and return the key-value pair stored in the map for this entry.

Like Vec::remove, the pair is removed by shifting all of the elements that follow it, preserving their relative order. This perturbs the index of all of those elements!

Examples

use vecmap::VecMap;
use vecmap::map::Entry;

let mut map: VecMap<&str, u32> = VecMap::new();
map.entry("poneyland").or_insert(12);
map.entry("foo").or_insert(13);
map.entry("bar").or_insert(14);

if let Entry::Occupied(o) = map.entry("poneyland") {
    // We delete the entry from the map.
    o.remove_entry();
}

assert_eq!(map.contains_key("poneyland"), false);
assert_eq!(map.get_index_of("foo"), Some(0));
assert_eq!(map.get_index_of("bar"), Some(1));

pub fn swap_remove(self) -> V

Removes the key-value pair stored in the map for this entry, and return the value.

Like Vec::swap_remove, the pair is removed by swapping it with the last element of the map and popping it off. This perturbs the position of what used to be the last element!

Examples

use vecmap::VecMap;
use vecmap::map::Entry;

let mut map: VecMap<&str, u32> = VecMap::new();
map.entry("poneyland").or_insert(12);
map.entry("foo").or_insert(13);
map.entry("bar").or_insert(14);

if let Entry::Occupied(o) = map.entry("poneyland") {
    assert_eq!(o.swap_remove(), 12);
}

assert_eq!(map.contains_key("poneyland"), false);
assert_eq!(map.get_index_of("foo"), Some(1));
assert_eq!(map.get_index_of("bar"), Some(0));

pub fn remove(self) -> V

Removes the key-value pair stored in the map for this entry, and return the value.

Like Vec::remove, the pair is removed by shifting all of the elements that follow it, preserving their relative order. This perturbs the index of all of those elements!

Examples

use vecmap::VecMap;
use vecmap::map::Entry;

let mut map: VecMap<&str, u32> = VecMap::new();
map.entry("poneyland").or_insert(12);
map.entry("foo").or_insert(13);
map.entry("bar").or_insert(14);

if let Entry::Occupied(o) = map.entry("poneyland") {
    assert_eq!(o.remove(), 12);
}

assert_eq!(map.contains_key("poneyland"), false);
assert_eq!(map.get_index_of("foo"), Some(0));
assert_eq!(map.get_index_of("bar"), Some(1));

Trait Implementations

impl<'a, K: Debug, V: Debug> Debug for OccupiedEntry<'a, K, V>

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

Formats the value using the given formatter.