micro-moka 1.2.0

A predictable, safe-Rust single-threaded cache with bounded SIEVE admission
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

use super::SlabEntry;
use std::iter::FusedIterator;

pub struct Iter<'i, K, V> {
    inner: std::slice::Iter<'i, Option<SlabEntry<K, V>>>,
    remaining: usize,
}

impl<'i, K, V> Iter<'i, K, V> {
    pub(crate) fn new(entries: &'i [Option<SlabEntry<K, V>>], remaining: usize) -> Self {
        Self {
            inner: entries.iter(),
            remaining,
        }
    }
}

impl<'i, K, V> Iterator for Iter<'i, K, V> {
    type Item = (&'i K, &'i V);

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            match self.inner.next() {
                Some(Some(entry)) => {
                    self.remaining -= 1;
                    return Some((&entry.key, &entry.value));
                }
                Some(None) => continue,
                None => return None,
            }
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        (self.remaining, Some(self.remaining))
    }
}

impl<K, V> ExactSizeIterator for Iter<'_, K, V> {}
impl<K, V> FusedIterator for Iter<'_, K, V> {}