Struct slotmap::dense::DenseSlotMap [−][src]
pub struct DenseSlotMap<K: Key, V> { /* fields omitted */ }
Dense slot map, storage with stable unique keys.
See crate documentation for more details.
Implementations
impl<V> DenseSlotMap<DefaultKey, V>
[src]
impl<V> DenseSlotMap<DefaultKey, V>
[src]pub fn new() -> Self
[src]
Construct a new, empty DenseSlotMap
.
Examples
let mut sm: DenseSlotMap<_, i32> = DenseSlotMap::new();
pub fn with_capacity(capacity: usize) -> DenseSlotMap<DefaultKey, V>
[src]
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);
impl<K: Key, V> DenseSlotMap<K, V>
[src]
impl<K: Key, V> DenseSlotMap<K, V>
[src]pub fn with_key() -> Self
[src]
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();
pub fn with_capacity_and_key(capacity: usize) -> Self
[src]
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");
pub fn len(&self) -> usize
[src]
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);
pub fn is_empty(&self) -> bool
[src]
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);
pub fn capacity(&self) -> usize
[src]
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);
pub fn reserve(&mut self, additional: usize)
[src]
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);
pub fn contains_key(&self, key: K) -> bool
[src]
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);
pub fn insert(&mut self, value: V) -> K
[src]
Inserts a value into the slot map. Returns a unique key that can be used to access this value.
Panics
Panics if the number of elements in the slot map equals 232 - 2.
Examples
let mut sm = DenseSlotMap::new(); let key = sm.insert(42); assert_eq!(sm[key], 42);
pub fn insert_with_key<F>(&mut self, f: F) -> K where
F: FnOnce(K) -> V,
[src]
F: FnOnce(K) -> V,
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));
pub fn remove(&mut self, key: K) -> Option<V>
[src]
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);
pub fn retain<F>(&mut self, f: F) where
F: FnMut(K, &mut V) -> bool,
[src]
F: FnMut(K, &mut V) -> bool,
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());
pub fn clear(&mut self)
[src]
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);
pub fn drain(&mut self) -> Drain<'_, K, V>ⓘ
[src]
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)]);
pub fn get(&self, key: K) -> Option<&V>
[src]
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);
pub unsafe fn get_unchecked(&self, key: K) -> &V
[src]
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!
pub fn get_mut(&mut self, key: K) -> Option<&mut V>
[src]
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);
pub unsafe fn get_unchecked_mut(&mut self, key: K) -> &mut V
[src]
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!
pub fn iter(&self) -> Iter<'_, K, V>ⓘ
[src]
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); }
pub fn iter_mut(&mut self) -> IterMut<'_, K, V>ⓘ
[src]
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);
pub fn keys(&self) -> Keys<'_, K, V>ⓘ
[src]
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);
pub fn values(&self) -> Values<'_, K, V>ⓘ
[src]
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);
pub fn values_mut(&mut self) -> ValuesMut<'_, K, V>ⓘ
[src]
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
impl<K: Clone + Key, V: Clone> Clone for DenseSlotMap<K, V>
[src]
impl<K: Clone + Key, V: Clone> Clone for DenseSlotMap<K, V>
[src]fn clone(&self) -> DenseSlotMap<K, V>
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<K: Key, V> Index<K> for DenseSlotMap<K, V>
[src]
impl<K: Key, V> Index<K> for DenseSlotMap<K, V>
[src]impl<K: Key, V> IndexMut<K> for DenseSlotMap<K, V>
[src]
impl<K: Key, V> IndexMut<K> for DenseSlotMap<K, V>
[src]impl<'a, K: 'a + Key, V> IntoIterator for &'a DenseSlotMap<K, V>
[src]
impl<'a, K: 'a + Key, V> IntoIterator for &'a DenseSlotMap<K, V>
[src]impl<'a, K: 'a + Key, V> IntoIterator for &'a mut DenseSlotMap<K, V>
[src]
impl<'a, K: 'a + Key, V> IntoIterator for &'a mut DenseSlotMap<K, V>
[src]Auto Trait Implementations
impl<K, V> RefUnwindSafe for DenseSlotMap<K, V> where
K: RefUnwindSafe,
V: RefUnwindSafe,
K: RefUnwindSafe,
V: RefUnwindSafe,
impl<K, V> Send for DenseSlotMap<K, V> where
K: Send,
V: Send,
K: Send,
V: Send,
impl<K, V> Sync for DenseSlotMap<K, V> where
K: Sync,
V: Sync,
K: Sync,
V: Sync,
impl<K, V> Unpin for DenseSlotMap<K, V> where
K: Unpin,
V: Unpin,
K: Unpin,
V: Unpin,
impl<K, V> UnwindSafe for DenseSlotMap<K, V> where
K: UnwindSafe,
V: UnwindSafe,
K: UnwindSafe,
V: UnwindSafe,