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

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.