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