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 estimated_len(&self) -> ItemCount;
    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 estimated_len(&self) -> ItemCount

Returns the number of items in the layer file, or an estimate if not known. Old persistent layer formats did not keep track of how many entries they have, hence the estimate. If this is wrong, bloom filter sizing might be off, but that won’t affect correctness, and will wash out with future compactions anyways.

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>