Struct ev_slotmap::WriteHandle

pub struct WriteHandle<K, P, V> where
    K: Key<P>,
    V: ShallowCopy,  { /* fields omitted */ }

A handle that may be used to modify the concurrent map.

When the WriteHandle is dropped, the map is immediately (but safely) taken away from all readers, causing all future lookups to return None.

Implementations

impl<K, P, V> WriteHandle<K, P, V> where
    K: Key<P>,
    V: ShallowCopy, 

pub fn insert(&mut self, p: P, v: V) -> K

Insert the given value into the slot map and return the associated key

pub fn update(&mut self, k: K, v: V)

Replace the value of the given key with the given value.

pub fn clear(&mut self)

Clear the slot map.

pub fn remove(&mut self, k: &K)

Remove the value from the map for the given key

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

Get an iterator over all the items in the slot map directly without using an intermediate object. This is safe only because we are taking exclusive access to the writer to ensure no writes can occur while we are reading

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

Get an iterator over all the keys and values in the slot map as long as you have a way to create the pointer value from the stored value. This is done directly without needing an intermediate object, and is safe only because we are taking exclusive access to the writer to ensure no writes can occur while we are reading

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

Get an iterator over all the raw key data and values in the map directly without using an intermediate object. This is safe only because we are taking exclusive access to the writer to ensure no writes can occur while we are reading

Methods from Deref<Target = ReadHandle<K, P, V>>

pub fn factory(&self) -> ReadHandleFactory<K, P, V>

Create a new Sync type that can produce additional ReadHandles for use in other threads.

pub fn read(&self) -> Option<MapReadRef<'_, K, P, V>>

Take out a guarded live reference to the read side of the map.

This lets you perform more complex read operations on the map.

While the reference lives, the map cannot be refreshed.

If no refresh has happened, or the map has been destroyed, this function returns None.

See MapReadRef.

pub fn len(&self) -> usize

Returns the number of non-empty keys present in the map.

pub fn is_empty(&self) -> bool

Returns true if the map contains no non-empty keys.

pub fn get<'rh>(&'rh self, key: &K) -> Option<ReadGuard<'rh, V>>

Returns a guarded reference to the value corresponding to the key.

While the guard lives, the map cannot be refreshed.

If no writes have happened or if the write handle has been dropped, then None is returned here

pub fn is_destroyed(&self) -> bool

Returns true if the writer has destroyed this map (This happens when the writer is dropped).

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

Returns true if the map contains a value for the specified key.

Trait Implementations

impl<K, P, V> Debug for WriteHandle<K, P, V> where
    K: Key<P> + Debug,
    V: Debug + ShallowCopy, 

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

Formats the value using the given formatter.

impl<K, P, V> Deref for WriteHandle<K, P, V> where
    K: Key<P>,
    V: ShallowCopy, 

type Target = ReadHandle<K, P, V>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<K, P, V> Drop for WriteHandle<K, P, V> where
    K: Key<P>,
    V: ShallowCopy, 

fn drop(&mut self)

Executes the destructor for this type.