Struct slab_typesafe::Slab
source · Expand description
A wrapper for pre-allocated storage for a uniform data type
See module documentation for more details.
Implementations
sourceimpl<K: Into<usize> + From<usize>, V> Slab<K, V>
impl<K: Into<usize> + From<usize>, V> Slab<K, V>
sourcepub fn new() -> Slab<K, V>
pub fn new() -> Slab<K, V>
Construct a new, empty Slab
.
The function does not allocate and the returned slab will have no
capacity until insert
is called or capacity is explicitly reserved.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let slab: Slab<MyIndex, i32> = Slab::new();
sourcepub fn with_capacity(capacity: usize) -> Slab<K, V>
pub fn with_capacity(capacity: usize) -> Slab<K, V>
Construct a new, empty Slab
with the specified capacity.
The returned slab will be able to store exactly capacity
without
reallocating. If capacity
is 0, the slab will not allocate.
It is important to note that this function does not specify the length of the returned slab, but only the capacity. For an explanation of the difference between length and capacity, see Capacity and reallocation.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab = Slab::<MyIndex, _>::with_capacity(10);
// The slab contains no values, even though it has capacity for more
assert_eq!(slab.len(), 0);
// These are all done without reallocating...
for i in 0..10 {
slab.insert(i);
}
// ...but this may make the slab reallocate
slab.insert(11);
sourcepub fn capacity(&self) -> usize
pub fn capacity(&self) -> usize
Returns the number of values the slab can store without reallocating.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let slab: Slab<MyIndex, i32> = Slab::with_capacity(10);
assert_eq!(slab.capacity(), 10);
sourcepub fn reserve(&mut self, additional: usize)
pub fn reserve(&mut self, additional: usize)
Reserves capacity for at least additional
more values to be stored
without allocating.
reserve
does nothing if the slab already has sufficient capcity for
additional
more values. If more capacity is required, a new segment of
memory will be allocated and all existing values will be copied into it.
As such, if the slab is already very large, a call to reserve
can end
up being expensive.
The slab may reserve more than additional
extra space in order to
avoid frequent reallocations. Use reserve_exact
instead to guarantee
that only the requested space is allocated.
Panics
Panics if the new capacity overflows usize
.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, _> = Slab::new();
slab.insert("hello");
slab.reserve(10);
assert!(slab.capacity() >= 11);
sourcepub fn reserve_exact(&mut self, additional: usize)
pub fn reserve_exact(&mut self, additional: usize)
Reserves the minimum capacity required to store exactly additional
more values.
reserve_exact
does nothing if the slab already has sufficient capacity
for additional
more valus. If more capacity is required, a new segment
of memory will be allocated and all existing values will be copied into
it. As such, if the slab is already very large, a call to reserve
can
end up being expensive.
Note that the allocator may give the slab more space than it requests.
Therefore capacity can not be relied upon to be precisely minimal.
Prefer reserve
if future insertions are expected.
Panics
Panics if the new capacity overflows usize
.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, _> = Slab::new();
slab.insert("hello");
slab.reserve_exact(10);
assert!(slab.capacity() >= 11);
sourcepub fn shrink_to_fit(&mut self)
pub fn shrink_to_fit(&mut self)
Shrinks the capacity of the slab as much as possible.
It will drop down as close as possible to the length but the allocator may still inform the vector that there is space for a few more elements. Also, since values are not moved, the slab cannot shrink past any stored values.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, i32> = Slab::with_capacity(10);
for i in 0..3 {
slab.insert(i);
}
assert_eq!(slab.capacity(), 10);
slab.shrink_to_fit();
assert!(slab.capacity() >= 3);
In this case, even though two values are removed, the slab cannot shrink past the last value.
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, i32> = Slab::with_capacity(10);
for i in 0..3 {
slab.insert(i);
}
slab.remove(0.into());
slab.remove(1.into());
assert_eq!(slab.capacity(), 10);
slab.shrink_to_fit();
assert!(slab.capacity() >= 3);
sourcepub fn clear(&mut self)
pub fn clear(&mut self)
Clear the slab of all values
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, _> = Slab::new();
for i in 0..3 {
slab.insert(i);
}
slab.clear();
assert!(slab.is_empty());
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Returns the number of stored values
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, _> = Slab::new();
for i in 0..3 {
slab.insert(i);
}
assert_eq!(3, slab.len());
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true
if no values are stored in the slab
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, usize> = Slab::new();
assert!(slab.is_empty());
slab.insert(1);
assert!(!slab.is_empty());
sourcepub fn iter(&self) -> Iter<'_, K, V> ⓘ
pub fn iter(&self) -> Iter<'_, K, V> ⓘ
Returns an iterator over the slab
This function should generally be avoided as it is not efficient. Iterators must iterate over every slot in the slab even if it is vaccant. As such, a slab with a capacity of 1 million but only one stored value must still iterate the million slots.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, u32> = Slab::new();
for i in 0..3 {
slab.insert(i);
}
let mut iterator = slab.iter();
assert_eq!(iterator.next(), Some((0.into(), &0)));
assert_eq!(iterator.next(), Some((1.into(), &1)));
assert_eq!(iterator.next(), Some((2.into(), &2)));
assert_eq!(iterator.next(), None);
sourcepub fn iter_mut(&mut self) -> IterMut<'_, K, V> ⓘ
pub fn iter_mut(&mut self) -> IterMut<'_, K, V> ⓘ
Returns an iterator that allows modifying each value.
This function should generally be avoided as it is not efficient. Iterators must iterate over every slot in the slab even if it is vaccant. As such, a slab with a capacity of 1 million but only one stored value must still iterate the million slots.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, u32> = Slab::new();
let key1 = slab.insert(0);
let key2 = slab.insert(1);
for (key, val) in slab.iter_mut() {
if key == key1 {
*val += 2;
}
}
assert_eq!(slab[key1], 2);
assert_eq!(slab[key2], 1);
sourcepub fn get(&self, key: K) -> Option<&V>
pub fn get(&self, key: K) -> Option<&V>
Returns a reference to the value associated with the given key
If the given key is not associated with a value, then None
is
returned.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, _> = Slab::new();
let key : MyIndex = slab.insert("hello");
assert_eq!(slab.get(key), Some(&"hello"));
assert_eq!(slab.get(123.into()), None);
sourcepub fn get_mut(&mut self, key: K) -> Option<&mut V>
pub fn get_mut(&mut self, key: K) -> Option<&mut V>
Returns a mutable reference to the value associated with the given key
If the given key is not associated with a value, then None
is
returned.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, &'static str> = Slab::new();
let key : MyIndex = slab.insert("hello");
*slab.get_mut(key).unwrap() = "world";
assert_eq!(slab[key], "world");
assert_eq!(slab.get_mut(123.into()), None);
sourcepub unsafe fn get_unchecked(&self, key: K) -> &V
pub unsafe fn get_unchecked(&self, key: K) -> &V
Returns a reference to the value associated with the given key without performing bounds checking.
This function should be used with care.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex,_> = Slab::new();
let key : MyIndex = slab.insert(2);
unsafe {
assert_eq!(slab.get_unchecked(key), &2);
}
sourcepub unsafe fn get_unchecked_mut(&mut self, key: K) -> &mut V
pub unsafe fn get_unchecked_mut(&mut self, key: K) -> &mut V
Returns a mutable reference to the value associated with the given key without performing bounds checking.
This function should be used with care.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab < MyIndex, u16> = Slab::new();
let key = slab.insert(2);
unsafe {
let val = slab.get_unchecked_mut(key);
*val = 13;
}
assert_eq!(slab[key], 13);
sourcepub fn insert(&mut self, val: V) -> K
pub fn insert(&mut self, val: V) -> K
Insert a value in the slab, returning key assigned to the value
The returned key can later be used to retrieve or remove the value using indexed
lookup and remove
. Additional capacity is allocated if needed. See
Capacity and reallocation.
Panics
Panics if the number of elements in the vector overflows a usize
.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, _> = Slab::new();
let key : MyIndex = slab.insert("hello");
assert_eq!(slab[key], "hello");
sourcepub fn vacant_entry(&mut self) -> VacantEntry<'_, K, V>
pub fn vacant_entry(&mut self) -> VacantEntry<'_, K, V>
Returns a handle to a vacant entry allowing for further manipulation.
This function is useful when creating values that must contain their
slab key. The returned VaccantEntry
reserves a slot in the slab and is
able to query the associated key.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, _> = Slab::new();
let hello = {
let entry = slab.vacant_entry();
let key : MyIndex = entry.key();
entry.insert((key, "hello"));
key
};
assert_eq!(hello, slab[hello].0);
assert_eq!("hello", slab[hello].1);
sourcepub fn remove(&mut self, key: K) -> V
pub fn remove(&mut self, key: K) -> V
Removes and returns the value associated with the given key.
The key is then released and may be associated with future stored values.
Panics
Panics if key
is not associated with a value.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex,_> = Slab::new();
let hello : MyIndex = slab.insert("hello");
assert_eq!(slab.remove(hello), "hello");
assert!(!slab.contains(hello));
sourcepub fn try_remove(&mut self, key: K) -> Option<V>
pub fn try_remove(&mut self, key: K) -> Option<V>
Removes and returns the value associated with the given key, if it exists.
The key is then released and may be associated with future stored values.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex,_> = Slab::new();
let hello : MyIndex = slab.insert("hello");
assert_eq!(slab.try_remove(hello), Some("hello"));
assert_eq!(slab.try_remove(hello), None);
sourcepub fn contains(&self, key: K) -> bool
pub fn contains(&self, key: K) -> bool
Returns true
if a value is associated with the given key.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex,_> = Slab::new();
let hello : MyIndex = slab.insert("hello");
assert!(slab.contains(hello));
slab.remove(hello);
assert!(!slab.contains(hello));
sourcepub fn retain<F>(&mut self, f: F)where
F: FnMut(K, &mut V) -> bool,
pub fn retain<F>(&mut self, f: F)where
F: FnMut(K, &mut V) -> bool,
Retain only the elements specified by the predicate.
In other words, remove all elements e
such that f(usize, &mut e)
returns false. This method operates in place and preserves the key
associated with the retained values.
Examples
#[macro_use] extern crate slab_typesafe;
declare_slab_token!(MyIndex);
let mut slab : Slab<MyIndex, _> = Slab::new();
let k1 : MyIndex = slab.insert(0);
let k2 : MyIndex = slab.insert(1);
let k3 : MyIndex = slab.insert(2);
slab.retain(|key, val| key == k1 || *val == 1);
assert!(slab.contains(k1));
assert!(slab.contains(k2));
assert!(!slab.contains(k3));
assert_eq!(2, slab.len());
sourceimpl<K: Into<usize> + From<usize>, V> Slab<K, V>
impl<K: Into<usize> + From<usize>, V> Slab<K, V>
sourcepub fn into_unwrapped(self) -> Slab<V>
pub fn into_unwrapped(self) -> Slab<V>
Extract underlying unwrapped map
sourcepub fn from_unwrapped(s: Slab<V>) -> Self
pub fn from_unwrapped(s: Slab<V>) -> Self
Wrap the slab. You are responsible that it is one with correct keys.
sourcepub fn unwrapped_mut(&mut self) -> &mut Slab<V>
pub fn unwrapped_mut(&mut self) -> &mut Slab<V>
Temporarily use the map without the safety wrapper