Struct algorithm::LfuCache

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

一个 lfu(least frequently used/最不经常使用页置换算法 ) 缓存的实现, 接口参照Hashmap保持一致 根据元素的访问次数进行按分组进行淘汰测试 在访问次数达到设定值时将全体所有的访问次数下降1处理 以使高频数据在一定时间后将过期处理

Examples

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    let _ = lru.get("hello");
    let _ = lru.get("this");
    lru.insert("now", "ok");
    lru.insert("auth", "tickbh");
    assert!(lru.len() == 3);
    assert_eq!(lru.get("hello"), Some(&"algorithm"));
    assert_eq!(lru.get("this"), Some(&"lru"));
    assert_eq!(lru.get("now"), None);
}

Implementations

impl<K: Hash + Eq, V> LfuCache<K, V, RandomState>

pub fn new(cap: usize) -> Self

impl<K, V, S> LfuCache<K, V, S>

pub fn with_hasher(cap: usize, hash_builder: S) -> LfuCache<K, V, S>

提供hash函数

pub fn set_default_count(&mut self, default_count: usize)

设定初始进入列表中默认的访问次数，防止出现一进入就权重过低的情况

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    assert!(lru.get_visit(&"this") == Some(5));
    assert!(lru.get_visit(&"hello") == Some(5));
}

pub fn get_default_count(&self) -> usize

pub fn set_reduce_count(&mut self, reduce_count: usize)

每多少访问存储中触发值， 如设置100次，那么将100次发生get或者put时将触发一次调整 每次调整时间复杂度为O(n)

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    lru.set_reduce_count(100);
    lru.set_reduce_step(100);
    assert!(lru.get_visit(&"hello") == Some(5));
    assert!(lru.get_visit(&"this") == Some(5));
    for _ in 0..100 {
        let _ = lru.get("this");
    }
    assert!(lru.get_visit(&"this") == Some(5));
    assert!(lru.get_visit(&"hello") == Some(0));
    let mut keys = lru.keys();
    assert!(keys.next()==Some(&"this"));
    assert!(keys.next()==Some(&"hello"));
    assert!(keys.next() == None);
}

pub fn get_reduce_count(&self) -> usize

pub fn set_reduce_step(&mut self, reduce_step: usize)

每次触发访问减少的值，如设置100，那所有元素中的访问次数将减少100 用于长时间不访问的数据能在一定时间后过期

pub fn get_reduce_step(&self) -> usize

pub fn capacity(&self) -> usize

获取当前容量

pub fn clear(&mut self)

清理当前数据

Examples

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("now", "ok");
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    assert!(lru.len() == 3);
    lru.clear();
    assert!(lru.len() == 0);
}

pub fn len(&self) -> usize

获取当前长度

pub fn reserve(&mut self, additional: usize)

扩展当前容量

pub fn iter(&self) -> Iter<'_, K, V, S>

遍历当前的所有值

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    for (k, v) in lru.iter() {
        assert!(k == &"hello" || k == &"this");
        assert!(v == &"algorithm" || v == &"lru");
    }
    assert!(lru.len() == 2);
}

pub fn keys(&self) -> Keys<'_, K, V, S>

遍历当前的key值

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    let _ = lru.get("this");
    let mut keys = lru.keys();
    assert!(keys.next()==Some(&"this"));
    assert!(keys.next()==Some(&"hello"));
    assert!(keys.next() == None);
}

pub fn values(&self) -> Values<'_, K, V, S>

遍历当前的valus值

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    let _ = lru.get("this");
    let mut values = lru.values();
    assert!(values.next()==Some(&"lru"));
    assert!(values.next()==Some(&"algorithm"));
    assert!(values.next() == None);
}

pub fn hasher(&self) -> &S

impl<K: Hash + Eq, V, S: BuildHasher> LfuCache<K, V, S>

pub fn drain(&mut self) -> Drain<'_, K, V, S>

排出当前数据

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    {
        let mut drain = lru.drain();
        assert!(drain.next()==Some(("hello", "algorithm")));
    }
    assert!(lru.len() == 1);
}

pub fn pop(&mut self) -> Option<(K, V)>

弹出栈顶上的数据, 最近使用的数据

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    let _ = lru.get("this");
    assert!(lru.pop()==Some(("this", "lru")));
    assert!(lru.len() == 1);
}

pub fn pop_last(&mut self) -> Option<(K, V)>

弹出栈尾上的数据, 最久未使用的数据

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    let _ = lru.get("this");
    assert!(lru.pop_last()==Some(("hello", "algorithm")));
    assert!(lru.len() == 1);
}

pub fn get_visit<Q>(&mut self, k: &Q) -> Option<usize>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

获取key值相对应的value值, 根本hash判定

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    assert!(lru.get_visit(&"this") == Some(5));
}

pub fn get<Q>(&mut self, k: &Q) -> Option<&V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

获取key值相对应的value值, 根本hash判定

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    assert!(lru.get(&"this") == Some(&"lru"));
}

pub fn get_key_value<Q>(&mut self, k: &Q) -> Option<(&K, &V)>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

获取key值相对应的key和value值, 根本hash判定

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    assert!(lru.get_key_value(&"this") == Some((&"this", &"lru")));
}

pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

获取key值相对应的value值, 根本hash判定, 可编辑被改变

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm".to_string());
    lru.insert("this", "lru".to_string());
    lru.get_mut(&"this").unwrap().insert_str(3, " good");
    assert!(lru.get_key_value(&"this") == Some((&"this", &"lru good".to_string())));
}

pub fn insert(&mut self, k: K, v: V) -> Option<V>

插入值, 如果值重复将返回原来的数据

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    assert!(lru.insert("this", "lru good") == Some(&"lru"));
}

pub fn capture_insert(&mut self, k: K, v: V) -> Option<(K, V)>

pub fn remove<Q>(&mut self, k: &Q) -> Option<(K, V)>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

移除元素

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    assert!(lru.remove("this") == Some(("this", "lru")));
    assert!(lru.len() == 1);
}

pub fn retain<F>(&mut self, f: F)

where F: FnMut(&K, &mut V) -> bool,

根据保留当前的元素, 返回false则表示抛弃元素

use algorithm::LfuCache;
fn main() {
    let mut lru = LfuCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    lru.insert("year", "2024");
    lru.retain(|_, v| *v == "2024" || *v == "lru");
    assert!(lru.len() == 2);
    assert!(lru.get("this") == Some(&"lru"));
}

Trait Implementations

impl<K: Clone + Hash + Eq, V: Clone, S: Clone + BuildHasher> Clone for LfuCache<K, V, S>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V, S> Drop for LfuCache<K, V, S>

fn drop(&mut self)

Executes the destructor for this type.