Struct SlotMap

pub struct SlotMap<T, C: Collector<T> = DefaultCollector> { /* private fields */ }

Implementations

impl<T> SlotMap<T, DefaultCollector>

pub fn new(max_capacity: u32) -> Self

pub fn with_global(max_capacity: u32, global: GlobalHandle) -> Self

impl<T, C: Collector<T>> SlotMap<T, C>

pub fn with_collector(max_capacity: u32, collector: C) -> Self

pub fn with_global_and_collector( max_capacity: u32, global: GlobalHandle, collector: C, ) -> Self

pub fn capacity(&self) -> u32

pub fn len(&self) -> u32

pub fn is_empty(&self) -> bool

pub fn global(&self) -> &GlobalHandle

pub fn collector(&self) -> &C

pub fn insert<'a>( &'a self, value: T, guard: impl Into<Cow<'a, Guard<'a>>>, ) -> SlotId

Panics

Panics if guard.global() does not equal self.global().

pub fn insert_with_tag<'a>( &'a self, value: T, tag: u32, guard: impl Into<Cow<'a, Guard<'a>>>, ) -> SlotId

Panics

• Panics if guard.global() does not equal self.global().
• Panics if tag has more than the low 8 bits set.

pub fn insert_mut(&mut self, value: T) -> SlotId

pub fn insert_with_tag_mut(&mut self, value: T, tag: u32) -> SlotId

Panics

Panics if tag has more than the low 8 bits set.

pub fn remove<'a>( &'a self, id: SlotId, guard: impl Into<Cow<'a, Guard<'a>>>, ) -> Option<Ref<'a, T>>

Panics

Panics if guard.global() does not equal self.global().

pub fn try_collect(&self, guard: &Guard<'_>)

Panics

Panics if guard.global() does not equal self.global().

pub fn remove_mut(&mut self, id: SlotId) -> Option<T>

pub fn get<'a>( &'a self, id: SlotId, guard: impl Into<Cow<'a, Guard<'a>>>, ) -> Option<Ref<'a, T>>

Panics

Panics if guard.global() does not equal self.global().

pub unsafe fn get_unprotected(&self, id: SlotId) -> Option<&T>

Safety

You must ensure that the epoch is pinned before you call this method and that the returned reference doesn’t outlive all epoch::Guards active on the thread, or that all accesses to self are externally synchronized (for example through the use of a Mutex or by being single-threaded).

pub fn get_mut(&mut self, id: SlotId) -> Option<&mut T>

pub fn get_many_mut<const N: usize>( &mut self, ids: [SlotId; N], ) -> Option<[&mut T; N]>

pub fn index<'a>( &'a self, index: u32, guard: impl Into<Cow<'a, Guard<'a>>>, ) -> Option<Ref<'a, T>>

Panics

Panics if guard.global() does not equal self.global().

pub unsafe fn index_unprotected(&self, index: u32) -> Option<&T>

Safety

You must ensure that the epoch is pinned before you call this method and that the returned reference doesn’t outlive all epoch::Guards active on the thread, or that all accesses to self are externally synchronized (for example through the use of a Mutex or by being single-threaded).

pub fn index_mut(&mut self, index: u32) -> Option<&mut T>

pub unsafe fn index_unchecked<'a>( &'a self, index: u32, guard: impl Into<Cow<'a, Guard<'a>>>, ) -> Ref<'a, T>

Safety

index must be in bounds of the slots vector and the slot must have been initialized and must not be free.

Panics

Panics if guard.global() does not equal self.global().

pub unsafe fn index_unchecked_unprotected(&self, index: u32) -> &T

Safety

• index must be in bounds of the slots vector and the slot must have been initialized and must not be free.
• You must ensure that the epoch is pinned before you call this method and that the returned reference doesn’t outlive all epoch::Guards active on the thread, or that all accesses to self are externally synchronized (for example through the use of a Mutex or by being single-threaded).

pub unsafe fn index_unchecked_mut(&mut self, index: u32) -> &mut T

Safety

index must be in bounds of the slots vector and the slot must have been initialized and must not be free.

pub fn iter<'a>(&'a self, guard: impl Into<Cow<'a, Guard<'a>>>) -> Iter<'a, T>

Panics

Panics if guard.global() does not equal self.global().

pub unsafe fn iter_unprotected(&self) -> IterUnprotected<'_, T>

Safety

You must ensure that the epoch is [pinned] before you call this method and that the returned reference doesn’t outlive all epoch::Guards active on the thread, or that all accesses to self are externally synchronized (for example through the use of a Mutex or by being single-threaded).

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Trait Implementations

impl<T: Debug, C: Collector<T>> Debug for SlotMap<T, C>

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

Formats the value using the given formatter.

impl<T, C: Collector<T>> Drop for SlotMap<T, C>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T, C: Collector<T>> IntoIterator for &'a mut SlotMap<T, C>

type Item = (SlotId, &'a mut T)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, C: Collector<T>> RefUnwindSafe for SlotMap<T, C>

impl<T, C: Collector<T>> UnwindSafe for SlotMap<T, C>