Struct MemoryMap

pub struct MemoryMap<K, V>
where
    K: Copy + Clone + PartialEq + Eq + Hash + Serialize + for<'de> Deserialize<'de> + Send + Sync,
    V: Clone + PartialEq + Eq + Serialize + for<'de> Deserialize<'de> + Send + Sync,
{ /* private fields */ }

Trait Implementations

impl<K, V> Clone for MemoryMap<K, V>

where K: Clone + Copy + PartialEq + Eq + Hash + Serialize + for<'de> Deserialize<'de> + Send + Sync, V: Clone + PartialEq + Eq + Serialize + for<'de> Deserialize<'de> + Send + Sync,

fn clone(&self) -> MemoryMap<K, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Default for MemoryMap<K, V>

where K: Copy + Clone + PartialEq + Eq + Hash + Serialize + for<'de> Deserialize<'de> + Send + Sync, V: Clone + PartialEq + Eq + Serialize + for<'de> Deserialize<'de> + Send + Sync,

fn default() -> MemoryMap<K, V>

Returns the “default value” for a type.

impl<K, V> Deref for MemoryMap<K, V>

where K: Copy + Clone + PartialEq + Eq + Hash + Serialize + for<'de> Deserialize<'de> + Send + Sync, V: Clone + PartialEq + Eq + Serialize + for<'de> Deserialize<'de> + Send + Sync,

type Target = Arc<RwLock<RawRwLock, BTreeMap<Vec<u8>, V>>>

The resulting type after dereferencing.

fn deref(&self) -> &<MemoryMap<K, V> as Deref>::Target

Dereferences the value.

impl<K, V> FromIterator<(K, V)> for MemoryMap<K, V>

where K: Copy + Clone + PartialEq + Eq + Hash + Serialize + for<'de> Deserialize<'de> + Send + Sync, V: Clone + PartialEq + Eq + Serialize + for<'de> Deserialize<'de> + Send + Sync,

fn from_iter<I>(iter: I) -> MemoryMap<K, V>

where I: IntoIterator<Item = (K, V)>,

Initializes a new MemoryMap from the given iterator.

impl<'a, K, V> Map<'a, K, V> for MemoryMap<K, V>

where K: 'a + Copy + Clone + PartialEq + Eq + Hash + Serialize + for<'de> Deserialize<'de> + Send + Sync, V: 'a + Clone + PartialEq + Eq + Serialize + for<'de> Deserialize<'de> + Send + Sync,

fn insert(&self, key: K, value: V) -> Result<(), Error>

Inserts the given key-value pair into the map.

fn remove(&self, key: &K) -> Result<(), Error>

Removes the key-value pair for the given key from the map.

fn start_atomic(&self)

Begins an atomic operation. Any further calls to insert and remove will be queued without an actual write taking place until finish_atomic is called.

fn is_atomic_in_progress(&self) -> bool

Checks whether an atomic operation is currently in progress. This can be done to ensure that lower-level operations don’t start and finish their individual atomic write batch if they are already part of a larger one.

fn atomic_checkpoint(&self)

Saves the current list of pending operations, so that if atomic_rewind is called, we roll back all future operations, and return to the start of this checkpoint.

fn clear_latest_checkpoint(&self)

Removes the latest atomic checkpoint.

fn atomic_rewind(&self)

Removes all pending operations to the last atomic_checkpoint (or to start_atomic if no checkpoints have been created).

fn abort_atomic(&self)

Aborts the current atomic operation.

fn finish_atomic(&self) -> Result<(), Error>

Finishes an atomic operation, performing all the queued writes.

fn pause_atomic_writes(&self) -> Result<(), Error>

Once called, the subsequent atomic write batches will be queued instead of being executed at the end of their scope. unpause_atomic_writes needs to be called in order to restore the usual behavior.

fn unpause_atomic_writes<const DISCARD_BATCH: bool>(&self) -> Result<(), Error>

Executes all of the queued writes as a single atomic operation and restores the usual behavior of atomic write batches that was altered by calling pause_atomic_writes.

impl<'a, K, V> MapRead<'a, K, V> for MemoryMap<K, V>

where K: 'a + Copy + Clone + PartialEq + Eq + Hash + Serialize + for<'de> Deserialize<'de> + Send + Sync, V: 'a + Clone + PartialEq + Eq + Serialize + for<'de> Deserialize<'de> + Send + Sync,

fn len_confirmed(&self) -> usize

Returns the number of confirmed entries in the map.

fn contains_key_confirmed<Q>(&self, key: &Q) -> Result<bool, Error>

where K: Borrow<Q>, Q: PartialEq + Eq + Hash + Serialize + ?Sized,

Returns true if the given key exists in the map.

fn contains_key_speculative<Q>(&self, key: &Q) -> Result<bool, Error>

where K: Borrow<Q>, Q: PartialEq + Eq + Hash + Serialize + ?Sized,

Returns true if the given key exists in the map. This method first checks the atomic batch, and if it does not exist, then checks the map.

fn get_confirmed<Q>(&'a self, key: &Q) -> Result<Option<Cow<'a, V>>, Error>

where K: Borrow<Q>, Q: PartialEq + Eq + Hash + Serialize + ?Sized,

Returns the value for the given key from the map, if it exists.

fn get_pending<Q>(&self, key: &Q) -> Option<Option<V>>

where K: Borrow<Q>, Q: PartialEq + Eq + Hash + Serialize + ?Sized,

Returns the current value for the given key if it is scheduled to be inserted as part of an atomic batch.

If the key does not exist, returns None. If the key is removed in the batch, returns Some(None). If the key is inserted in the batch, returns Some(Some(value)).

fn iter_pending( &'a self, ) -> <MemoryMap<K, V> as MapRead<'a, K, V>>::PendingIterator

Returns an iterator visiting each key-value pair in the atomic batch.

fn iter_confirmed(&'a self) -> <MemoryMap<K, V> as MapRead<'a, K, V>>::Iterator

Returns an iterator visiting each key-value pair in the map.

fn keys_confirmed(&'a self) -> <MemoryMap<K, V> as MapRead<'a, K, V>>::Keys

Returns an iterator over each key in the map.

fn values_confirmed(&'a self) -> <MemoryMap<K, V> as MapRead<'a, K, V>>::Values

Returns an iterator over each value in the map.

type Iterator = Map<IntoIter<Vec<u8>, V>, fn(_: (Vec<u8>, V)) -> (Cow<'a, K>, Cow<'a, V>)>

type Keys = Map<IntoKeys<Vec<u8>, V>, fn(_: Vec<u8>) -> Cow<'a, K>>

type PendingIterator = Map<IntoIter<K, Option<V>>, fn(_: (K, Option<V>)) -> (Cow<'a, K>, Option<Cow<'a, V>>)>

type Values = Map<IntoValues<Vec<u8>, V>, fn(_: V) -> Cow<'a, V>>

fn is_empty_confirmed(&self) -> bool

Checks whether there are any confirmed entries in the map.

fn get_speculative<Q>(&'a self, key: &Q) -> Result<Option<Cow<'a, V>>, Error>

where K: Borrow<Q>, Q: PartialEq + Eq + Hash + Serialize + ?Sized,

Returns the value for the given key from the atomic batch first, if it exists, or return from the map, otherwise.