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 clear_cached_data(&self) { ... }
    fn maybe_contains_key(&self, _key: &K) -> MaybeContainsKey { ... }
    fn has_bloom_filter(&self) -> 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 clear_cached_data(&self)

Immediately clears any in-memory cached data for this layer.

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

Returns whether the layer might contain records relevant to key. Note that this can return MaybeContainsKey::Maybe even if the layer has no records relevant to key, but it will never return MaybeContainsKey::False if there are such records. (As such, always returning MaybeContainsKey::Maybe is a trivially correct implementation.) If the key has too many hash partitions to check against the existence filter, returns MaybeContainsKey::RangeKeyTooLarge.

fn has_bloom_filter(&self) -> bool

Whether the bloom filter for the layer file is consulted or not. If this is false, then maybe_contains_key will always return MaybeContainsKey::Maybe. Note that the persistent layer file may still have a bloom filter, but it might be ignored (e.g. for a layer file on an older version).

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.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

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>

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