Struct LruCache

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

LRU 全称是Least Recently Used，即最近最久未使用的意思 一个 LRU 缓存普通级的实现, 接口参照Hashmap保持一致 设置容量之后将最大保持该容量大小的数据 后进的数据将会淘汰最久没有被访问的数据

Examples

use algorithm::LruCache;
fn main() {
    let mut lru = LruCache::new(3);
    lru.insert("now", "ok");
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    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> LruCache<K, V, DefaultHasher>

pub fn new(cap: usize) -> Self

impl<K, V, S> LruCache<K, V, S>

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

提供hash函数

pub fn get_check_step(&self) -> u64

获取当前检查lru的间隔

pub fn set_check_step(&mut self, check_step: u64)

设置当前检查lru的间隔 单位为秒，意思就是每隔多少秒会清理一次数据 如果数据太大的话遍历一次可能会比较久的时长 一次清理时间复杂度O(n) 仅仅在插入时触发检查，获取时仅检查当前元素

pub fn capacity(&self) -> usize

获取当前容量

pub fn clear(&mut self)

清理当前数据

Examples

use algorithm::LruCache;
fn main() {
    let mut lru = LruCache::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 is_full(&self) -> bool

pub fn is_empty(&self) -> bool

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

扩展当前容量

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

遍历当前的所有值

use algorithm::LruCache;
fn main() {
    let mut lru = LruCache::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 iter_mut(&mut self) -> IterMut<'_, K, V>

遍历当前的所有值, 可变

use algorithm::LruCache;
fn main() {
    let mut lru = LruCache::new(3);
    lru.insert("hello", "algorithm".to_string());
    lru.insert("this", "lru".to_string());
    for (k, v) in lru.iter_mut() {
        v.push_str(" ok");
    }
    assert!(lru.len() == 2);
    assert!(lru.get(&"this") == Some(&"lru ok".to_string()));
    assert!(lru.get(&"hello") == Some(&"algorithm ok".to_string()));
}

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

遍历当前的key值

use algorithm::LruCache;
fn main() {
    let mut lru = LruCache::new(3);
    lru.insert("hello", "algorithm");
    lru.insert("this", "lru");
    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>

遍历当前的valus值

use algorithm::LruCache;
fn main() {
    let vec = vec![(1, 1), (2, 2), (3, 3)];
    let mut map: LruCache<_, _, _> = vec.into_iter().collect();
    for value in map.values_mut() {
    *value = (*value) * 2
    }
    let values: Vec<_> = map.values().cloned().collect();
    assert_eq!(values.len(), 3);
    assert!(values.contains(&2));
    assert!(values.contains(&4));
    assert!(values.contains(&6));
}

pub fn values_mut(&mut self) -> ValuesMut<'_, K, V>

遍历当前的valus值

use algorithm::LruCache;
fn main() {
    let mut lru = LruCache::new(3);
    lru.insert("hello", "algorithm".to_string());
    lru.insert("this", "lru".to_string());
    {
        let mut values = lru.values_mut();
        values.next().unwrap().push_str(" ok");
        values.next().unwrap().push_str(" ok");
        assert!(values.next() == None);
    }
    assert_eq!(lru.get(&"this"), Some(&"lru ok".to_string()))
}

pub fn hasher(&self) -> &S

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

pub fn full_increase(&mut self)

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

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

排出当前数据

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn contains_key<Q>(&mut self, k: &Q) -> bool

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

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

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

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

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

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

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

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

use algorithm::LruCache;
fn main() {
    let mut lru = LruCache::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::LruCache;
fn main() {
    let mut lru = LruCache::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::LruCache;
fn main() {
    let mut lru = LruCache::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 get_mut_key_value<Q>(&mut self, k: &Q) -> Option<(&K, &mut V)>

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

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

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

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

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

插入带有生存时间的元素 每次获取像redis一样，并不会更新生存时间 如果需要更新则需要手动的进行重新设置

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

pub fn capture_insert_with_ttl( &mut self, k: K, v: V, ttl: u64, ) -> Option<(K, V, bool)>

pub fn get_or_insert<F>(&mut self, k: K, f: F) -> &V

where F: FnOnce() -> V,

pub fn get_or_insert_mut<'a, F>(&'a mut self, k: K, f: F) -> &mut V

where F: FnOnce() -> V,

pub fn clear_expire(&mut self)

pub fn del_ttl<Q>(&mut self, k: &Q)

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

pub fn set_ttl<Q>(&mut self, k: &Q, expire: u64) -> bool

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

pub fn get_ttl<Q>(&mut self, k: &Q) -> Option<u64>

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

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

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

移除元素

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

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

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

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

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

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

use algorithm::LruCache;
fn main() {
    let mut lru = LruCache::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"));
}

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

pub fn get_or_insert_default(&mut self, k: K) -> &V

pub fn get_or_insert_default_mut(&mut self, k: K) -> &mut V

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, S> Debug for LruCache<K, V, S>

where K: Ord + Debug, V: Debug,

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

Formats the value using the given formatter.

impl<K: Hash + Eq, V> Default for LruCache<K, V, DefaultHasher>

fn default() -> Self

Returns the “default value” for a type.

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

fn drop(&mut self)

Executes the destructor for this type.

impl<K: Hash + Eq, V> Extend<(K, V)> for LruCache<K, V, DefaultHasher>

fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<K: Hash + Eq, V> FromIterator<(K, V)> for LruCache<K, V, DefaultHasher>

fn from_iter<T: IntoIterator<Item = (K, V)>>( iter: T, ) -> LruCache<K, V, DefaultHasher>

Creates a value from an iterator.

impl<'a, K, V, S> Index<&'a K> for LruCache<K, V, S>

where K: Hash + Eq, S: BuildHasher,

type Output = V

The returned type after indexing.

fn index(&self, index: &K) -> &V

Performs the indexing (container[index]) operation.

impl<'a, K, V, S> IndexMut<&'a K> for LruCache<K, V, S>

where K: Hash + Eq, S: BuildHasher,

fn index_mut(&mut self, index: &K) -> &mut V

Performs the mutable indexing (container[index]) operation.

impl<K: Hash + Eq, V, S: BuildHasher> IntoIterator for LruCache<K, V, S>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<K, V, S>

Creates an iterator from a value.

impl<K, V, S> PartialEq for LruCache<K, V, S>

where K: Eq + Hash, V: PartialEq, S: BuildHasher,

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

where K: Eq + Hash, V: PartialEq, S: BuildHasher,

impl<K: Send, V: Send, S: Send> Send for LruCache<K, V, S>

impl<K: Sync, V: Sync, S: Sync> Sync for LruCache<K, V, S>