Struct SkipListLayer 

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

Implementations

impl<K, V> SkipListLayer<K, V>

pub fn new(max_item_count: usize) -> Arc<SkipListLayer<K, V>>

pub fn len(&self) -> usize

impl<K: Eq + Key + OrdLowerBound, V: LayerValue> SkipListLayer<K, V>

pub fn erase(&self, key: &K)

where K: Eq,

pub fn insert(&self, item: Item<K, V>) -> Result<(), Error>

Inserts the given item.

pub fn replace_or_insert(&self, item: Item<K, V>)

Replaces or inserts the given item.

pub fn merge_into( &self, item: Item<K, V>, lower_bound: &K, merge_fn: MergeFn<K, V>, )

Merges the item into the layer.

impl<K: OrdUpperBound, V> SkipListLayer<K, V>

pub fn seek<'a>(&'a self, bound: Bound<&K>) -> SkipListLayerIter<'a, K, V>

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

This is an inherent version of the Layer::seek trait method which avoids returning a boxed future and boxed iterator.

Trait Implementations

impl<K, V> Drop for SkipListLayer<K, V>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

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

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 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 len(&self) -> usize

Returns the number of items in the layer file.

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.

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