Enum TryInsertError

pub enum TryInsertError<K, V> {
    OccupiedEntry {
        key: K,
        value: V,
    },
    WouldEjectLru {
        key: K,
        value: V,
        entry_size: usize,
        free_memory: usize,
    },
    EntryTooLarge {
        key: K,
        value: V,
        entry_size: usize,
        max_size: usize,
    },
}

An enumeration of the different errors that can occur when calling LruCache::try_insert.

Variants

OccupiedEntry

This error is raised if the cache already contained an entry with a key equal to the given one.

Fields

key: K

The key of the entry to insert.

value: V

The value of the entry to insert.

WouldEjectLru

This error is raised if the cache cannot fit the given entry without ejecting the LRU element.

Fields

key: K

The key of the entry to insert.

value: V

The value of the entry to insert.

entry_size: usize

The computed size requirement of the entry if it were in the cache in bytes.

free_memory: usize

The remaining free memory of the cache in bytes.

EntryTooLarge

This error is raised if the amount of memory required to store an entry to be inserted is larger than the maximum of the cache.

Fields

key: K

The key of the entry which was too large.

value: V

The value of the entry which was too large.

entry_size: usize

The computed size requirement of the entry if it were in the cache in bytes.

max_size: usize

The maximum size of the cache in bytes.

Implementations

impl<K, V> TryInsertError<K, V>

pub fn entry(&self) -> (&K, &V)

Gets references to the key and value of the entry for which LruCache::try_insert failed.

Example

use lru_mem::LruCache;

let mut cache = LruCache::new(1024);
cache.insert("apple", "sweet").unwrap();
let err = cache.try_insert("apple", "sour").unwrap_err();

assert_eq!((&"apple", &"sour"), err.entry());

pub fn key(&self) -> &K

Gets a reference to the key of the entry for which LruCache::try_insert failed.

Example

use lru_mem::LruCache;

let mut cache = LruCache::new(1024);
cache.insert("apple", "sweet").unwrap();
let err = cache.try_insert("apple", "sour").unwrap_err();

assert_eq!(&"apple", err.key());

pub fn value(&self) -> &V

Gets a reference to the value of the entry for which LruCache::try_insert failed.

Example

use lru_mem::LruCache;

let mut cache = LruCache::new(1024);
cache.insert("apple", "sweet").unwrap();
let err = cache.try_insert("apple", "sour").unwrap_err();

assert_eq!(&"sour", err.value());

pub fn into_entry(self) -> (K, V)

Takes ownership of the error and returns the key and value of the entry for which LruCache::try_insert failed.

Example

use lru_mem::LruCache;

let mut cache = LruCache::new(1024);
cache.insert("apple", "sweet").unwrap();
let err = cache.try_insert("apple", "sour").unwrap_err();

assert_eq!(("apple", "sour"), err.into_entry());

pub fn into_key(self) -> K

Takes ownership of the error and returns the key of the entry for which LruCache::try_insert failed.

Example

use lru_mem::LruCache;

let mut cache = LruCache::new(1024);
cache.insert("apple", "sweet").unwrap();
let err = cache.try_insert("apple", "sour").unwrap_err();

assert_eq!("apple", err.into_key());

pub fn into_value(self) -> V

Takes ownership of the error and returns the value of the entry for which LruCache::try_insert failed.

Example

use lru_mem::LruCache;

let mut cache = LruCache::new(1024);
cache.insert("apple", "sweet").unwrap();
let err = cache.try_insert("apple", "sour").unwrap_err();

assert_eq!("sour", err.into_value());

Trait Implementations

impl<K: Clone, V: Clone> Clone for TryInsertError<K, V>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for TryInsertError<K, V>

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

Formats the value using the given formatter.

impl<K, V> Display for TryInsertError<K, V>

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

Formats the value using the given formatter.

impl<K: Debug, V: Debug> Error for TryInsertError<K, V>

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl<K: PartialEq, V: PartialEq> PartialEq for TryInsertError<K, V>

fn eq(&self, other: &TryInsertError<K, V>) -> 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> Eq for TryInsertError<K, V>

impl<K, V> StructuralPartialEq for TryInsertError<K, V>