const-lru 1.0.0

A simple no_std, non-hashing, constant-capacity, constant-memory-usage LRU cache.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use num_traits::{PrimInt, Unsigned};

use crate::ConstLru;

/// assumes:
/// from_head: consume then increment
/// from_tail: decrement then consume
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct DoubleEndedIterCursors<I, const CAP: usize> {
    /// from_head == from_tail means ended
    from_head: I,
    from_tail: I,
}

impl<I: PrimInt + Unsigned, const CAP: usize> DoubleEndedIterCursors<I, CAP> {
    pub fn new<K, V>(const_lru: &ConstLru<K, V, CAP, I>) -> Self {
        let (from_head, from_tail) = if const_lru.is_empty() {
            (I::zero(), I::zero())
        } else if const_lru.is_full() {
            (const_lru.head, const_lru.cap())
        } else {
            (
                const_lru.head,
                const_lru.nexts[const_lru.tail.to_usize().unwrap()],
            )
        };
        Self {
            from_head,
            from_tail,
        }
    }

    /// assumes next is valid
    pub fn advance_from_head<K, V>(&mut self, const_lru: &ConstLru<K, V, CAP, I>) {
        self.from_head = const_lru.nexts[self.get_from_head_idx()];
    }

    pub fn retreat_from_tail<K, V>(&mut self, const_lru: &ConstLru<K, V, CAP, I>) {
        self.from_tail = if self.from_tail == const_lru.cap() {
            const_lru.tail
        } else {
            const_lru.prevs[self.get_from_tail_idx()]
        };
    }

    pub fn get_from_head_idx(&self) -> usize {
        self.from_head.to_usize().unwrap()
    }

    pub fn get_from_tail_idx(&self) -> usize {
        self.from_tail.to_usize().unwrap()
    }

    pub fn has_ended(&self) -> bool {
        self.from_head == self.from_tail
    }

    pub fn get_from_head(&self) -> I {
        self.from_head
    }
}