Trait Layer 

pub trait Layer<K, V>: Send + Sync {
    // Required methods
    fn seek<'life0, 'life1, 'async_trait>(
        &'life0 self,
        bound: Bound<&'life1 K>,
    ) -> Pin<Box<dyn Future<Output = Result<BoxedLayerIterator<'_, K, V>, Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn len(&self) -> usize;
    fn key_exists<'life0, 'life1, 'async_trait>(
        &'life0 self,
        key: &'life1 K,
    ) -> Pin<Box<dyn Future<Output = Result<Existence, Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn lock(&self) -> Option<Arc<DropEvent>>;
    fn close<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_version(&self) -> Version;

    // Provided methods
    fn handle(&self) -> Option<&dyn ReadObjectHandle> { ... }
    fn purge_cached_data(&self) { ... }
    fn maybe_contains_key(&self, _key: &K) -> bool { ... }
    fn record_inspect_data(self: Arc<Self>, _node: &Node) { ... }
}

Layer is a trait that all layers need to implement (mutable and immutable).

Required Methods

fn seek<'life0, 'life1, 'async_trait>( &'life0 self, bound: Bound<&'life1 K>, ) -> Pin<Box<dyn Future<Output = Result<BoxedLayerIterator<'_, K, V>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Searches for a key. Bound::Excluded is not supported. Bound::Unbounded positions the iterator on the first item in the layer.

fn len(&self) -> usize

Returns the number of items in the layer file.

fn key_exists<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 K, ) -> Pin<Box<dyn Future<Output = Result<Existence, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

This is similar to maybe_contains_key except that there must be a key and possible state where this will indicate the key is missing i.e. always returning Existence::MaybeExists is not a correct implementation. If an implementation has a low cost way to determine if the key might exist, then it may use that, but if not, it must use a slower algorithm. This method was introduced to allow for an efficient way of determining if a particular key is free to be used. maybe_contains_key cannot be used for this purpose because implementations might always return true which would mean it would be impossible to ever find a key that is free to use. It might not be appropriate to use this with range based keys: implementations should use cmp_upper_bound and test for equality, which might not give the desired results for range based keys.

fn lock(&self) -> Option<Arc<DropEvent>>

Locks the layer preventing it from being closed. This will never block i.e. there can be many locks concurrently. The lock is purely advisory: seek will still work even if lock has not been called; it merely causes close to wait until all locks are released. Returns None if close has been called for the layer.

fn close<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Waits for existing locks readers to finish and then returns. Subsequent calls to lock will return None.

fn get_version(&self) -> Version

Returns the version number used by structs in this layer

Provided Methods

fn handle(&self) -> Option<&dyn ReadObjectHandle>

If the layer is persistent, returns the handle to its contents. Returns None for in-memory layers.

fn purge_cached_data(&self)

Some layer implementations may choose to cache data in-memory. Calling this function will request that the layer purges unused cached data. This is intended to run on a timer.

fn maybe_contains_key(&self, _key: &K) -> bool

Returns whether the layer might contain records relevant to key. Note that this can return true even if the layer has no records relevant to key, but it will never return false if there are such records. (As such, always returning true is a trivially correct implementation.)

fn record_inspect_data(self: Arc<Self>, _node: &Node)

Records inspect data for the layer into node. Called lazily when inspect is queried.

Trait Implementations

impl<K, V> AsRef<dyn Layer<K, V>> for LockedLayer<K, V>

fn as_ref(&self) -> &(dyn Layer<K, V> + 'static)

Converts this type into a shared reference of the (usually inferred) input type.

Implementors

impl<K: Key, V: LayerValue> Layer<K, V> for PersistentLayer<K, V>

impl<K: Key, V: LayerValue> Layer<K, V> for SkipListLayer<K, V>