Struct concread::hashmap::asynch::HashMapWriteTxn

pub struct HashMapWriteTxn<'a, K, V> where
    K: Hash + Eq + Clone + Debug + Sync + Send + 'static,
    V: Clone + Sync + Send + 'static,  { /* private fields */ }

An active write transaction for a HashMap. The data in this tree may be modified exclusively through this transaction without affecting readers. The write may be rolledback/aborted by dropping this guard without calling commit(). Once commit() is called, readers will be able to access and percieve changes in new transactions.

Implementations

impl<'a, K: Hash + Eq + Clone + Debug + Sync + Send + 'static, V: Clone + Sync + Send + 'static> HashMapWriteTxn<'a, K, V>

pub fn get<'b, Q: ?Sized>(&'a self, k: &'b Q) -> Option<&'a V> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Retrieve a value from the map. If the value exists, a reference is returned as Some(&V), otherwise if not present None is returned.

pub fn contains_key<'b, Q: ?Sized>(&'a self, k: &'b Q) -> bool where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Assert if a key exists in the map.

pub fn len(&self) -> usize

returns the current number of k:v pairs in the tree

pub fn is_empty(&self) -> bool

Determine if the set is currently empty

pub fn iter(&self) -> Iter<'_, K, V>

Iterator over (&K, &V) of the set

pub fn values(&self) -> ValueIter<'_, K, V>

Iterator over &K

pub fn keys(&self) -> KeyIter<'_, K, V>

Iterator over &V

pub fn clear(&mut self)

Reset this map to an empty state. As this is within the transaction this change only takes effect once commited. Once cleared, you can begin adding new writes and changes, again, that will only be visible once commited.

pub fn insert(&mut self, k: K, v: V) -> Option<V>

Insert or update a value by key. If the value previously existed it is returned as Some(V). If the value did not previously exist this returns None.

pub fn remove(&mut self, k: &K) -> Option<V>

Remove a key if it exists in the tree. If the value exists, we return it as Some(V), and if it did not exist, we return None

pub fn get_mut(&mut self, k: &K) -> Option<&mut V>

Get a mutable reference to a value in the tree. This is correctly, and safely cloned before you attempt to mutate the value, isolating it from other transactions.

pub fn to_snapshot(&'a self) -> HashMapReadSnapshot<'_, K, V>

Create a read-snapshot of the current map. This does NOT guarantee the map may not be mutated during the read, so you MUST guarantee that no functions of the write txn are called while this snapshot is active.

impl<'a, K: Hash + Eq + Clone + Debug + Sync + Send + 'static, V: Clone + Sync + Send + 'static> HashMapWriteTxn<'a, K, V>

pub async fn commit(self)

Commit the changes from this write transaction. Readers after this point will be able to percieve these changes.

To abort (unstage changes), just do not call this function.

Trait Implementations

impl<'a, K: Hash + Eq + Clone + Debug + Sync + Send + 'static, V: Clone + Sync + Send + 'static> Extend<(K, V)> for HashMapWriteTxn<'a, K, V>

fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.