Struct Index 

pub struct Index<K, V, R: Rng = StdRng> { /* private fields */ }

An index into a CommonCache.

This should be used when an Entry is not sufficient due to life time problems. Note however that all indexes to a cache will be invalidated whenever the cache is altered in any way. Including insertian of new elements and promotion of existing elements. This is because the index is just a pointer to a specific level and index in that level of the cache. If some element is inserted or promoted, a few other elements will randomly be moved down some levels in the cache, causing their indexes to be invalid and potentially point to other items. However, this happens randomly, so tests might not recognize such a bug, and it will not be reproduceable.

The solution is to use an internal counter, (generation), which increments each time the cache is altered. Each index has the generation of the cache when the index was created, and if the index is used with a newer version of the cache it will be invalid.

Implementations

impl<K: Eq + Hash, V, R: Rng> Index<K, V, R>

pub fn entry(self, cache: &mut CommonCache<K, V, R>) -> Entry<'_, K, V, R>

Get an entry corresponding to this index.

Panics

Panics if the generation of the cache and this index differs, I.E that something has been inserted or promoted in the cache since this index was created.

Might also panic when trying to read the entry if the item corresponding to this index has been removed.

pub fn peek_key_value<'a>( &'a self, cache: &'a CommonCache<K, V, R>, ) -> (&'a K, &'a V)

Read the key and value at the index without touching the rest of the cache. This operation will hence not be taken into account when considering which elements are most commonly used.

pub fn peek_key<'a>(&'a self, cache: &'a CommonCache<K, V, R>) -> &'a K

Silently read the key at this index.

pub fn peek_value<'a>(&'a self, cache: &'a CommonCache<K, V, R>) -> &'a V

Read the value at the index without touching the rest of the cache. This operation will hence not be taken into account when considering which elements are most commonly used.

pub fn peek_key_value_mut<'a>( &'a self, cache: &'a mut CommonCache<K, V, R>, ) -> (&'a K, &'a mut V)

Read the item at this index mutably without touching the rest of the cache. This operation will not be taken into account when considering which elements are most commonly used.

Note that this does not count as altering the cache so the index is still valid after this.

pub fn peek_value_mut<'a>( &'a self, cache: &'a mut CommonCache<K, V, R>, ) -> &'a mut V

Read the value at this index mutably without touching the rest of the cache. This operation will not be taken into account when considering which elements are most commonly used.

Note that this does not count as altering the cache so the index is still valid after this.

pub fn get_key_value(self, cache: &mut CommonCache<K, V, R>) -> (&K, &mut V)

Get the key and value at this index and promote the item to a higher level in the cache.

This function will promote the item to a higher level in the cache and based on some probability move other items down in the cache.

The index will be invalidated after this operation.

pub fn get_value(self, cache: &mut CommonCache<K, V, R>) -> &mut V

Get the value at this index and promote this index to a higher level in the cache.

This function will promote this index to a higher level in the cache and based on some probability move other items down in the cache.

Trait Implementations

impl<K: Clone, V: Clone, R: Clone + Rng> Clone for Index<K, V, R>

fn clone(&self) -> Index<K, V, R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K: Debug, V: Debug, R: Debug + Rng> Debug for Index<K, V, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K: Hash, V: Hash, R: Hash + Rng> Hash for Index<K, V, R>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<K: PartialEq, V: PartialEq, R: PartialEq + Rng> PartialEq for Index<K, V, R>

fn eq(&self, other: &Index<K, V, R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K: Eq, V: Eq, R: Eq + Rng> Eq for Index<K, V, R>

impl<K, V, R: Rng> StructuralPartialEq for Index<K, V, R>