Struct PersistentLayer 

pub struct PersistentLayer<K, V> { /* private fields */ }

A handle to a persistent layer.

Implementations

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

pub async fn open( handle: impl ReadObjectHandle + 'static, ) -> Result<Arc<Self>, Error>

pub 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 true. 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).

Trait Implementations

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

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 seek<'a, 'life0, 'async_trait>( &'a self, bound: Bound<&'life0 K>, ) -> Pin<Box<dyn Future<Output = Result<BoxedLayerIterator<'a, K, V>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: '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 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 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

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

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