Struct Dump

pub struct Dump<K, V> {
    pub capacity: usize,
    pub data: Vec<(K, V)>,
}

Complete dump of a LRU cache, easily (de)serializable.

It reflects the complete current state of the cache, including key/value pairs but also capacity and order.

Can be used to import/export the cache and serialize/unserialize it.

Examples

use hashlru::{Cache, Dump};

let mut cache: Cache<&str, usize> = Cache::new(10);
cache.insert("x", 1);
cache.insert("y", 10);
cache.insert("z", 100);

let dump: Dump<&str, usize> = Dump::from(cache);
assert_eq!("Dump { capacity: 10, data: [(\"x\", 1), (\"y\", 10), (\"z\", 100)] }", format!("{:?}", dump));
let restore: Cache<&str, usize> = Cache::from(dump);
assert_eq!(10, restore.capacity());
assert_eq!("[x: 1, y: 10, z: 100]", format!("{}", &restore));

Fields

capacity: usize

data: Vec<(K, V)>

Trait Implementations

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

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

Formats the value using the given formatter.

impl<'de, K, V> Deserialize<'de> for Dump<K, V>

where K: Deserialize<'de>, V: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V> From<Cache<K, V>> for Dump<K, V>

where K: Hash + Eq,

fn from(cache: Cache<K, V>) -> Dump<K, V>

Converts to this type from the input type.

impl<K, V> From<Dump<K, V>> for Cache<K, V>

where K: Hash + Eq,

fn from(dump: Dump<K, V>) -> Cache<K, V>

Converts to this type from the input type.

impl<K, V> From<Dump<K, V>> for SyncCache<K, V>

where K: Hash + Eq + Clone, V: Clone,

fn from(dump: Dump<K, V>) -> SyncCache<K, V>

Converts to this type from the input type.

impl<K, V> PartialEq for Dump<K, V>

where K: Hash + Eq, V: PartialEq,

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

where K: Serialize, V: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V> Eq for Dump<K, V>

where K: Hash + Eq + Clone, V: Eq,