Struct Index 

pub struct Index<T: Translator, V: Eq + Send + Sync> { /* private fields */ }

A memory-efficient index that uses an ordered map internally to map translated keys to arbitrary values.

Implementations

impl<T: Translator, V: Eq + Send + Sync> Index<T, V>

pub fn new(ctx: impl Metrics, translator: T) -> Self

Create a new Index with the given translator and metrics registry.

Trait Implementations

impl<T: Translator, V: Eq + Send + Sync> Drop for Index<T, V>

fn drop(&mut self)

To avoid stack overflow on keys with many collisions, we implement an iterative drop (in lieu of Rust’s default recursive drop).

impl<T: Translator, V: Eq + Send + Sync> Ordered for Index<T, V>

type Iterator<'a> = ImmutableCursor<'a, V> where Self: 'a

fn prev_translated_key<'a>( &'a self, key: &[u8], ) -> Option<(Self::Iterator<'a>, bool)>

where Self::Value: 'a,

fn next_translated_key<'a>( &'a self, key: &[u8], ) -> Option<(Self::Iterator<'a>, bool)>

where Self::Value: 'a,

For example, if the translator is looking only at the first byte of a key, and the index contains values for translated keys 0b, 1c, and 2d, then get_next([0b, 01, 02, ...]) would return the values associated with 1c, get_next([2a, 01, 02, ...]) would return the values associated with 2d, and get_next([2d]) would “cycle around” to the values associated with 0b, returning true for the bool. Because values associated with the same translated key can appear in any order, keys with the same first byte in this example would need to be ordered by the caller if a full ordering over the untranslated keyspace is desired.

fn first_translated_key<'a>(&'a self) -> Option<Self::Iterator<'a>>

where Self::Value: 'a,

fn last_translated_key<'a>(&'a self) -> Option<Self::Iterator<'a>>

where Self::Value: 'a,

impl<T: Translator, V: Eq + Send + Sync> Unordered for Index<T, V>

type Value = V

The type of values the index stores.

type Cursor<'a> = Cursor<'a, <T as Translator>::Key, V> where Self: 'a

The type of cursor returned by this index to iterate over values with conflicting keys.

fn get<'a>(&'a self, key: &[u8]) -> impl Iterator<Item = &'a V> + 'a

where V: 'a,

Returns an iterator over all values associated with a translated key.

fn get_mut<'a>(&'a mut self, key: &[u8]) -> Option<Self::Cursor<'a>>

Provides mutable access to the values associated with a translated key, if the key exists.

fn get_mut_or_insert<'a>( &'a mut self, key: &[u8], value: V, ) -> Option<Self::Cursor<'a>>

Provides mutable access to the values associated with a translated key (if the key exists), otherwise inserts a new value and returns None.

fn insert(&mut self, key: &[u8], value: V)

Inserts a new value at the current position.

fn insert_and_prune( &mut self, key: &[u8], value: V, predicate: impl Fn(&V) -> bool, )

Insert a value at the given translated key, and prune any values that are no longer valid.

fn prune(&mut self, key: &[u8], predicate: impl Fn(&V) -> bool)

Remove all values associated with a translated key that match predicate.

fn remove(&mut self, key: &[u8])

Remove all values associated with a translated key.