Struct slotmap::dense::DenseSlotMap [−][src]
pub struct DenseSlotMap<K: Key, V> { /* fields omitted */ }
Expand description
Dense slot map, storage with stable unique keys.
See crate documentation for more details.
Implementations
Construct a new, empty DenseSlotMap
.
Examples
let mut sm: DenseSlotMap<_, i32> = DenseSlotMap::new();
Creates an empty DenseSlotMap
with the given capacity.
The slot map will not reallocate until it holds at least capacity
elements.
Examples
let mut sm: DenseSlotMap<_, i32> = DenseSlotMap::with_capacity(10);
Constructs a new, empty DenseSlotMap
with a custom key type.
Examples
new_key_type! {
struct PositionKey;
}
let mut positions: DenseSlotMap<PositionKey, i32> = DenseSlotMap::with_key();
Creates an empty DenseSlotMap
with the given capacity and a custom key
type.
The slot map will not reallocate until it holds at least capacity
elements.
Examples
new_key_type! {
struct MessageKey;
}
let mut messages = DenseSlotMap::with_capacity_and_key(3);
let welcome: MessageKey = messages.insert("Welcome");
let good_day = messages.insert("Good day");
let hello = messages.insert("Hello");
Returns the number of elements in the slot map.
Examples
let mut sm = DenseSlotMap::with_capacity(10);
sm.insert("len() counts actual elements, not capacity");
let key = sm.insert("removed elements don't count either");
sm.remove(key);
assert_eq!(sm.len(), 1);
Returns if the slot map is empty.
Examples
let mut sm = DenseSlotMap::new();
let key = sm.insert("dummy");
assert_eq!(sm.is_empty(), false);
sm.remove(key);
assert_eq!(sm.is_empty(), true);
Returns the number of elements the DenseSlotMap
can hold without
reallocating.
Examples
let sm: DenseSlotMap<_, f64> = DenseSlotMap::with_capacity(10);
assert_eq!(sm.capacity(), 10);
Reserves capacity for at least additional
more elements to be inserted
in the DenseSlotMap
. The collection may reserve more space to
avoid frequent reallocations.
Panics
Panics if the new allocation size overflows usize
.
Examples
let mut sm = DenseSlotMap::new();
sm.insert("foo");
sm.reserve(32);
assert!(sm.capacity() >= 33);
Returns true
if the slot map contains key
.
Examples
let mut sm = DenseSlotMap::new();
let key = sm.insert(42);
assert_eq!(sm.contains_key(key), true);
sm.remove(key);
assert_eq!(sm.contains_key(key), false);
Inserts a value given by f
into the slot map. The key where the
value will be stored is passed into f
. This is useful to store values
that contain their own key.
Panics
Panics if the number of elements in the slot map equals 232 - 2.
Examples
let mut sm = DenseSlotMap::new();
let key = sm.insert_with_key(|k| (k, 20));
assert_eq!(sm[key], (key, 20));
Removes a key from the slot map, returning the value at the key if the key was not previously removed.
Examples
let mut sm = DenseSlotMap::new();
let key = sm.insert(42);
assert_eq!(sm.remove(key), Some(42));
assert_eq!(sm.remove(key), None);
Retains only the elements specified by the predicate.
In other words, remove all key-value pairs (k, v)
such that
f(k, &mut v)
returns false. This method invalidates any removed keys.
Examples
let mut sm = DenseSlotMap::new();
let k3 = sm.insert(2);
let k1 = sm.insert(0);
let k2 = sm.insert(1);
sm.retain(|key, val| key == k1 || *val == 1);
assert!(sm.contains_key(k1));
assert!(sm.contains_key(k2));
assert!(!sm.contains_key(k3));
assert_eq!(2, sm.len());
Clears the slot map. Keeps the allocated memory for reuse.
Examples
let mut sm = DenseSlotMap::new();
for i in 0..10 {
sm.insert(i);
}
assert_eq!(sm.len(), 10);
sm.clear();
assert_eq!(sm.len(), 0);
Clears the slot map, returning all key-value pairs in arbitrary order as an iterator. Keeps the allocated memory for reuse.
Examples
let mut sm = DenseSlotMap::new();
let k = sm.insert(0);
let v: Vec<_> = sm.drain().collect();
assert_eq!(sm.len(), 0);
assert_eq!(v, vec![(k, 0)]);
Returns a reference to the value corresponding to the key.
Examples
let mut sm = DenseSlotMap::new();
let key = sm.insert("bar");
assert_eq!(sm.get(key), Some(&"bar"));
sm.remove(key);
assert_eq!(sm.get(key), None);
Returns a reference to the value corresponding to the key without version or bounds checking.
Safety
This should only be used if contains_key(key)
is true. Otherwise it is
potentially unsafe.
Examples
let mut sm = DenseSlotMap::new();
let key = sm.insert("bar");
assert_eq!(unsafe { sm.get_unchecked(key) }, &"bar");
sm.remove(key);
// sm.get_unchecked(key) is now dangerous!
Returns a mutable reference to the value corresponding to the key.
Examples
let mut sm = DenseSlotMap::new();
let key = sm.insert(3.5);
if let Some(x) = sm.get_mut(key) {
*x += 3.0;
}
assert_eq!(sm[key], 6.5);
Returns a mutable reference to the value corresponding to the key without version or bounds checking.
Safety
This should only be used if contains_key(key)
is true. Otherwise it is
potentially unsafe.
Examples
let mut sm = DenseSlotMap::new();
let key = sm.insert("foo");
unsafe { *sm.get_unchecked_mut(key) = "bar" };
assert_eq!(sm[key], "bar");
sm.remove(key);
// sm.get_unchecked_mut(key) is now dangerous!
An iterator visiting all key-value pairs in arbitrary order. The
iterator element type is (K, &'a V)
.
Examples
let mut sm = DenseSlotMap::new();
let k0 = sm.insert(0);
let k1 = sm.insert(1);
let k2 = sm.insert(2);
let mut it = sm.iter();
for (k, v) in sm.iter() {
println!("key: {:?}, val: {}", k, v);
}
An iterator visiting all key-value pairs in arbitrary order, with
mutable references to the values. The iterator element type is
(K, &'a mut V)
.
Examples
let mut sm = DenseSlotMap::new();
let k0 = sm.insert(10);
let k1 = sm.insert(20);
let k2 = sm.insert(30);
for (k, v) in sm.iter_mut() {
if k != k1 {
*v *= -1;
}
}
assert_eq!(sm[k0], -10);
assert_eq!(sm[k1], 20);
assert_eq!(sm[k2], -30);
An iterator visiting all keys in arbitrary order. The iterator element type is K.
Examples
let mut sm = DenseSlotMap::new();
let k0 = sm.insert(10);
let k1 = sm.insert(20);
let k2 = sm.insert(30);
let keys: HashSet<_> = sm.keys().collect();
let check: HashSet<_> = vec![k0, k1, k2].into_iter().collect();
assert_eq!(keys, check);
An iterator visiting all values in arbitrary order. The iterator element
type is &'a V
.
Examples
let mut sm = DenseSlotMap::new();
let k0 = sm.insert(10);
let k1 = sm.insert(20);
let k2 = sm.insert(30);
let values: HashSet<_> = sm.values().collect();
let check: HashSet<_> = vec![&10, &20, &30].into_iter().collect();
assert_eq!(values, check);
An iterator visiting all values mutably in arbitrary order. The iterator
element type is &'a mut V
.
Examples
let mut sm = DenseSlotMap::new();
sm.insert(1);
sm.insert(2);
sm.insert(3);
sm.values_mut().for_each(|n| { *n *= 3 });
let values: HashSet<_> = sm.into_iter().map(|(_k, v)| v).collect();
let check: HashSet<_> = vec![3, 6, 9].into_iter().collect();
assert_eq!(values, check);
Trait Implementations
Auto Trait Implementations
impl<K, V> RefUnwindSafe for DenseSlotMap<K, V> where
K: RefUnwindSafe,
V: RefUnwindSafe,
impl<K, V> Send for DenseSlotMap<K, V> where
K: Send,
V: Send,
impl<K, V> Sync for DenseSlotMap<K, V> where
K: Sync,
V: Sync,
impl<K, V> Unpin for DenseSlotMap<K, V> where
K: Unpin,
V: Unpin,
impl<K, V> UnwindSafe for DenseSlotMap<K, V> where
K: UnwindSafe,
V: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more