Struct one_way_slot_map::SlotMap

#[repr(transparent)]
pub struct SlotMap<K, P, T> where
    K: SlotMapKey<P>,  { /* fields omitted */ }

Implementation of a slot map that limits the restrictions on slotted keys and values by preventing retrieval of original values without explicit replacement

Implementations

impl<K, P, T> SlotMap<K, P, T> where
    K: SlotMapKey<P>, 

pub fn new() -> SlotMap<K, P, T>

Create a new default simple slot map

pub fn len(&self) -> usize

Get the number of items in the slot map

let mut map = SlotMap::<TestKey,(),usize>::new();

let _ = map.insert((),10);
let _ = map.insert((),42);

assert_eq!(2, map.len());

pub fn is_empty(&self) -> bool

Tells if this map is empty

let mut map = SlotMap::<TestKey,(),usize>::new();

assert_eq!(true, map.is_empty());

let _ = map.insert((),10);
let _ = map.insert((),42);

assert_eq!(false, map.is_empty());

pub fn insert(&mut self, pointer: P, value: T) -> K

insert the given item into the slot map and return its key

define_key_type!(TestKey<String>);
let mut map = SlotMap::<TestKey,String,usize>::new();

let key = map.insert("My Key".to_owned(), 10);
assert_eq!("My Key", key.pointer);
assert_eq!(&SlotMapKeyData::from(0), key.borrow());

pub fn get(&self, key: &K) -> Option<&T>

Get a reference to the item in the map that corresponds to the given key if it exists

define_key_type!(TestKey<()>);
let mut map = SlotMap::<TestKey,(),&'static str>::new();

let key = map.insert((), "Hello!");

assert_eq!(Some(&"Hello!"), map.get(&key));

// Create a key that won't be in the map. This is non-ergonomic because
// it's not really a use case we expect,
let fake_key = TestKey::from(((), SlotMapKeyData::from(1u64)));

assert_eq!(None, map.get(&fake_key));

pub fn get_unbounded(&self, key: &impl Borrow<SlotMapKeyData>) -> Option<&T>

Same as get method, but doesn’t restrict input key to the type bound to this map. This method isn’t unsafe; it just doesn’t prevent you from getting data with a key of the wrong type

define_key_type!(TestKey<()>);
define_key_type!(OtherKey<()> : Default);
let mut map = SlotMap::<TestKey,(),&'static str>::new();

let _ = map.insert((), "Hello!");

assert_eq!(Some(&"Hello!"), map.get_unbounded(&OtherKey::default()));

// Create a key that won't be in the map. This is non-ergonomic because
// it's not really a use case we expect,
let fake_key = OtherKey::from(((), SlotMapKeyData::from(1u64)));

assert_eq!(None, map.get_unbounded(&fake_key));

pub fn get_raw(&self, key_data: &SlotMapKeyData) -> Option<&T>

Similar to get_unbounded, but only requires to slotmap key data

define_key_type!(TestKey<()>);
let mut map = SlotMap::<TestKey,(),&'static str>::new();

let _ = map.insert((), "Hello!");

assert_eq!(Some(&"Hello!"), map.get_raw(&SlotMapKeyData::default()));

// Create key data that won't be in the map. This is non-ergonomic
// because it's not really a use case we expect,
let fake_key_data = SlotMapKeyData::from(1u64);

assert_eq!(None, map.get_raw(&fake_key_data));

pub fn get_mut(&mut self, key: &K) -> Option<&mut T>

Get a mutable reference to the item in the map that corresponds to the given key if it exists

define_key_type!(TestKey<()>);
let mut map = SlotMap::<TestKey,(),&'static str>::new();

let key = map.insert((), "Hello!");

{
    if let Some(item) = map.get_mut(&key) {
        *item = "World?";
    }
}
assert_eq!(Some(&"World?"), map.get(&key));

// Create a key that won't be in the map. This is non-ergonomic because
// it's not really a use case we expect,
let fake_key = TestKey::from(((), SlotMapKeyData::from(1u64)));

assert_eq!(None, map.get_mut(&fake_key));

pub fn get_mut_unbounded(
    &mut self,
    key: &impl Borrow<SlotMapKeyData>
) -> Option<&mut T>

Same as get_mut method, but doesn’t restrict input key to the type bound to this map. This method isn’t unsafe; it just doesn’t prevent you from writing data with a key of the wrong type

define_key_type!(TestKey<()>);
define_key_type!(OtherKey<()> : Default);
let mut map = SlotMap::<TestKey,(),&'static str>::new();

let key = map.insert((), "Hello!");

{
    if let Some(item) = map.get_mut_unbounded(&OtherKey::default()) {
        *item = "World?";
    }
}
assert_eq!(Some(&"World?"), map.get(&key));

// Create a key that won't be in the map. This is non-ergonomic because
// it's not really a use case we expect,
let fake_key = TestKey::from(((), SlotMapKeyData::from(1u64)));

assert_eq!(None, map.get_mut(&fake_key));

pub fn get_mut_raw(&mut self, key_data: &SlotMapKeyData) -> Option<&mut T>

Similar to get_unbounded_mut, but only requires to slotmap key data

define_key_type!(TestKey<()>);
let mut map = SlotMap::<TestKey,(),&'static str>::new();

let key = map.insert((), "Hello!");

{
    if let Some(item) = map.get_mut_raw(&SlotMapKeyData::default()) {
        *item = "World?";
    }
}
assert_eq!(Some(&"World?"), map.get(&key));

// Create a key that won't be in the map. This is non-ergonomic because
// it's not really a use case we expect,
let fake_key_data = SlotMapKeyData::from(1u64);

assert_eq!(None, map.get_mut_raw(&fake_key_data));

pub fn remove(&mut self, key: &K) -> Option<&mut T>

Remove the item at the given index and return a mutable ref to the item removed if there was one

let mut map = SlotMap::<TestKey,(),&'static str>::new();

let key = map.insert((), "Hello!");

assert!(map.get(&key).is_some());

assert_eq!(Some(&mut "Hello!"), map.remove(&key));

assert_eq!(None, map.get(&key));

pub fn remove_unbounded(
    &mut self,
    key: &impl Borrow<SlotMapKeyData>
) -> Option<&mut T>

Same as remove method, but doesn’t restrict input key to the type bound to this map. This method isn’t unsafe; it just doesn’t prevent you from writing data with a key of the wrong type

define_key_type!(TestKey<()>);
define_key_type!(OtherKey<()> : Default);
let mut map = SlotMap::<TestKey,(),&'static str>::new();

let key = map.insert((), "Hello!");

assert!(map.get(&key).is_some());

assert_eq!(Some(&mut "Hello!"), map.remove_unbounded(&OtherKey::default()));

assert_eq!(None, map.get(&key));

pub fn remove_raw(&mut self, key_data: &SlotMapKeyData) -> Option<&mut T>

Similar to remove_unbounded but only requires the slot map key data

let mut map = SlotMap::<TestKey,(),&'static str>::new();

let key = map.insert((), "Hello!");

assert!(map.get(&key).is_some());

assert_eq!(Some(&mut "Hello!"), map.remove_raw(&SlotMapKeyData::default()));

assert_eq!(None, map.get(&key));

pub fn contains_key(&self, key: &K) -> bool

Check to see if the given key is still valid in this map

define_key_type!(TestKey<()>);
let mut map = SlotMap::<TestKey,(),&'static str>::new();

let key = map.insert((), "Hello!");

assert!(map.contains_key(&key));

// Create a key that won't be in the map. This is non-ergonomic because
// it's not really a use case we expect,
let fake_key = TestKey::from(((), SlotMapKeyData::from(1u64)));

assert!(!map.contains_key(&fake_key));

pub fn contains_key_unbounded(&self, key: &impl Borrow<SlotMapKeyData>) -> bool

Same as contains_key method, but doesn’t restrict input key to the type bound to this map. This method isn’t unsafe; it just doesn’t prevent you from getting data with a key of the wrong type

define_key_type!(TestKey<()>);
define_key_type!(OtherKey<()> : Default);

let mut map = SlotMap::<TestKey,(),&'static str>::new();

let key = map.insert((), "Hello!");

assert!(map.contains_key_unbounded(&OtherKey::default()));

// Create a key that won't be in the map. This is non-ergonomic because
// it's not really a use case we expect,
let fake_key = OtherKey::from(((), SlotMapKeyData::from(1u64)));

assert!(!map.contains_key_unbounded(&fake_key));

pub fn contains_key_raw(&self, key_data: &SlotMapKeyData) -> bool

Similar to contains_key_unbounded but only requires slot map key data

define_key_type!(TestKey<()>);

let mut map = SlotMap::<TestKey,(),&'static str>::new();

let key = map.insert((), "Hello!");

assert!(map.contains_key_raw(&SlotMapKeyData::default()));

// Create a key that won't be in the map. This is non-ergonomic because
// it's not really a use case we expect,
let fake_key_data = SlotMapKeyData::from(1u64);

assert!(!map.contains_key_raw(&fake_key_data));

pub fn drain(&mut self) -> impl Iterator<Item = &mut T>

Remove all items from this map and process them one-by-one

pub fn clear(&mut self)

Clears all the values in the slot map. This can be a memory intensive operation because we will have to write information for every non-empty slot into the queue of slots that can now be used

pub fn iter<F>(&self, pointer_finder: F) -> impl Iterator<Item = (K, &T)> where
    F: FnMut(&T) -> P, 

Get an iterator over keys and values given a way to get the pointer from the stored value.

pub fn iter_mut<F>(
    &mut self,
    pointer_finder: F
) -> impl Iterator<Item = (K, &mut T)> where
    F: FnMut(&T) -> P, 

Get an iterator over keys and mutable values given a way to get the pointer from the stored value.

pub fn iter_raw(&self) -> impl Iterator<Item = (SlotMapKeyData, &T)>

Create an iterator over all raw key data and values for items present in the slot map

pub fn iter_mut_raw(&mut self) -> impl Iterator<Item = (SlotMapKeyData, &mut T)>

Create an iterator over all raw key data and mutable values for items present in the slot map

pub fn values(&self) -> impl Iterator<Item = &T>

Create an iterator over all items in the items in the map

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut T>

Construct an iterator over all the values in the slot map as mutable references

pub fn map<F, R>(&self, mapper: F) -> SlotMap<K, P, R> where
    F: FnMut(&T) -> R, 

Create a new map that has the same structure as this one, but with the values mapped with the given closure

Trait Implementations

impl<K, P, T> Clone for SlotMap<K, P, T> where
    K: SlotMapKey<P>,
    T: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K, P, T> Debug for SlotMap<K, P, T> where
    T: Debug,
    K: SlotMapKey<P>, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K, P, T> Default for SlotMap<K, P, T> where
    K: SlotMapKey<P>, 

fn default() -> Self

Returns the “default value” for a type.