Trait MapRead 

pub trait MapRead<'a, K, V>
where
    K: 'a + Copy + Clone + PartialEq + Eq + Hash + Serialize + Deserialize<'a> + Sync,
    V: 'a + Clone + PartialEq + Eq + Serialize + Deserialize<'a> + Sync,
{
    type PendingIterator: Iterator<Item = (Cow<'a, K>, Option<Cow<'a, V>>)>;
    type Iterator: Iterator<Item = (Cow<'a, K>, Cow<'a, V>)>;
    type Keys: Iterator<Item = Cow<'a, K>>;
    type Values: Iterator<Item = Cow<'a, V>>;

    // Required methods
    fn contains_key_confirmed<Q>(&self, key: &Q) -> Result<bool, Error>
       where K: Borrow<Q>,
             Q: PartialEq + Eq + Hash + Serialize + ?Sized;
    fn contains_key_speculative<Q>(&self, key: &Q) -> Result<bool, Error>
       where K: Borrow<Q>,
             Q: PartialEq + Eq + Hash + Serialize + ?Sized;
    fn get_confirmed<Q>(&'a self, key: &Q) -> Result<Option<Cow<'a, V>>, Error>
       where K: Borrow<Q>,
             Q: PartialEq + Eq + Hash + Serialize + ?Sized;
    fn get_pending<Q>(&self, key: &Q) -> Option<Option<V>>
       where K: Borrow<Q>,
             Q: PartialEq + Eq + Hash + Serialize + ?Sized;
    fn iter_pending(&'a self) -> Self::PendingIterator;
    fn iter_confirmed(&'a self) -> Self::Iterator;
    fn keys_confirmed(&'a self) -> Self::Keys;
    fn values_confirmed(&'a self) -> Self::Values;

    // Provided method
    fn get_speculative<Q>(
        &'a self,
        key: &Q,
    ) -> Result<Option<Cow<'a, V>>, Error>
       where K: Borrow<Q>,
             Q: PartialEq + Eq + Hash + Serialize + ?Sized { ... }
}

A trait representing map-like storage operations with read-only capabilities.

Required Associated Types

type PendingIterator: Iterator<Item = (Cow<'a, K>, Option<Cow<'a, V>>)>

type Iterator: Iterator<Item = (Cow<'a, K>, Cow<'a, V>)>

type Keys: Iterator<Item = Cow<'a, K>>

type Values: Iterator<Item = Cow<'a, V>>

Required Methods

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) -> Self::PendingIterator

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

fn iter_confirmed(&'a self) -> Self::Iterator

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

fn keys_confirmed(&'a self) -> Self::Keys

Returns an iterator over each key in the map.

fn values_confirmed(&'a self) -> Self::Values

Returns an iterator over each value in the map.

Provided Methods

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

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,

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>>