Struct OccupiedEntry

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

A view into an occupied entry in a KeyedVecSet. 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 vecset::KeyedVecSet;

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

pub fn index(&self) -> usize

Gets the index of the entry.

Examples

use vecset::KeyedVecSet;

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

pub fn into_key(self) -> K

Take ownership of the key.

Examples

use vecset::KeyedVecSet;
use vecset::keyed::Entry;

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

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 vecset::KeyedVecSet;
use vecset::keyed::Entry;

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

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

pub unsafe 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.

Safety

Changing key may cause the map to be unsorted or have duplicate keys. Those states will make KeyedVecSet working unspecified way.

Panics

Panics if the key doesn’t exist (which should not happen for an OccupiedEntry).

Examples

use vecset::KeyedVecSet;
use vecset::keyed::Entry;

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

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

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

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

pub unsafe 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.

Safety

Changing key may cause the map to be unsorted or have duplicate keys. Those states will make KeyedVecSet working unspecified way.

Panics

Panics if the key doesn’t exist (which should not happen for an OccupiedEntry).

Examples

use vecset::KeyedVecSet;
use vecset::keyed::Entry;

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

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

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

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

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

Examples

use vecset::KeyedVecSet;
use vecset::keyed::Entry;

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

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

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

pub fn remove_entry(self) -> 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 vecset::KeyedVecSet;
use vecset::keyed::Entry;

let mut map: KeyedVecSet<&str, (&str, u32)> = KeyedVecSet::new();
map.entry("poneyland").or_insert(("poneyland", 12));
map.entry("foo").or_insert(("foo", 13));
map.entry("bar").or_insert(("bar", 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.binary_search("bar"), Ok(0));
assert_eq!(map.binary_search("foo"), Ok(1));

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 vecset::KeyedVecSet;
use vecset::keyed::Entry;

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

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

assert_eq!(map.contains_key("poneyland"), false);
assert_eq!(map.binary_search("bar"), Ok(0));
assert_eq!(map.binary_search("foo"), Ok(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.