evicting_cache_map 0.6.0

An Evicting LRU cache supporting prune hooks
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use ordered_hash_map::ordered_map;

use core::fmt;
use core::iter::FusedIterator;

/// An ordered iterator over the elements of the OrderedHashMap.
///
/// Created by the [`iter`] method of [`EvictingCacheMap`]. See its documentation for details.
///
/// [`iter`]: super::EvictingCacheMap::iter
/// [`EvictingCacheMap`]: super::EvictingCacheMap
pub struct Iter<'a, K, V> {
    inner: ordered_map::Iter<'a, K, V>,
}

impl<K, V> Clone for Iter<'_, K, V> {
    fn clone(&self) -> Self {
        Self {
            inner: self.inner.clone(),
        }
    }
}

impl<K, V> fmt::Debug for Iter<'_, K, V>
where
    K: fmt::Debug,
    V: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.inner.fmt(f)
    }
}

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

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next()
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.inner.size_hint()
    }
}

impl<K, V> DoubleEndedIterator for Iter<'_, K, V> {
    #[inline]
    fn next_back(&mut self) -> Option<Self::Item> {
        self.inner.next_back()
    }
}

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

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

impl<'a, K, V, const N: usize, F, S> IntoIterator for &'a super::EvictingCacheMap<K, V, N, F, S>
where
    F: Fn(K, V),
{
    type Item = (&'a K, &'a V);
    type IntoIter = Iter<'a, K, V>;

    fn into_iter(self) -> Self::IntoIter {
        Self::IntoIter {
            inner: self.inner.iter(),
        }
    }
}

/// An ordered, mutable iterator over the elements of the OrderedHashMap.
///
/// Note that mutation through this iterator does not promote keys.
///
/// Created by the [`iter_mut`] method of [`EvictingCacheMap`]. See its documentation for details.
///
/// [`iter_mut`]: super::EvictingCacheMap::iter_mut
/// [`EvictingCacheMap`]: super::EvictingCacheMap
pub struct IterMut<'a, K, V> {
    inner: ordered_map::IterMut<'a, K, V>,
}

impl<K, V> fmt::Debug for IterMut<'_, K, V>
where
    K: fmt::Debug,
    V: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.inner.fmt(f)
    }
}

impl<'a, K, V> Iterator for IterMut<'a, K, V> {
    type Item = (&'a K, &'a mut V);

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next()
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.inner.size_hint()
    }
}

impl<K, V> DoubleEndedIterator for IterMut<'_, K, V> {
    #[inline]
    fn next_back(&mut self) -> Option<Self::Item> {
        self.inner.next_back()
    }
}

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

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

impl<'a, K, V, const N: usize, F, S> IntoIterator for &'a mut super::EvictingCacheMap<K, V, N, F, S>
where
    F: Fn(K, V),
{
    type Item = (&'a K, &'a mut V);
    type IntoIter = IterMut<'a, K, V>;

    fn into_iter(self) -> Self::IntoIter {
        Self::IntoIter {
            inner: self.inner.iter_mut(),
        }
    }
}