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
use crate::elements::Node;
use alloc::vec::Vec;
use indexmap::map::Iter;
pub struct SliceIter<'a, T> {
inner_iter: Iter<'a, &'a str, Vec<T>>,
}
impl<'a, T> SliceIter<'a, T> {
#[doc(hidden)]
pub(crate) fn new(inner_iter: Iter<'a, &'a str, Vec<T>>) -> Self {
SliceIter { inner_iter }
}
}
impl<'a, T> Iterator for SliceIter<'a, T> {
type Item = (&'a str, &'a [T]);
fn next(&mut self) -> Option<Self::Item> {
if let Some((&k, v)) = self.inner_iter.next() {
Some((k, v))
} else {
None
}
}
}
pub struct EntryIter<'a, K, V> {
inner_iter: Iter<'a, K, V>,
}
impl<'a, K, V> EntryIter<'a, K, V> {
#[doc(hidden)]
pub(crate) fn new(inner_iter: Iter<'a, K, V>) -> Self {
EntryIter { inner_iter }
}
}
impl<'a, K, V> Iterator for EntryIter<'a, &'a K, V>
where
K: ?Sized,
{
type Item = (&'a K, &'a V);
fn next(&mut self) -> Option<Self::Item> {
if let Some((&k, v)) = self.inner_iter.next() {
Some((k, v))
} else {
None
}
}
}
pub struct NodeIter<'a, T> {
node: &'a Node<T>,
dead: bool,
multi_idx: usize,
}
impl<'a, T> NodeIter<'a, T> {
#[doc(hidden)]
pub(crate) fn new(node: &'a Node<T>) -> Self {
NodeIter {
node,
dead: false,
multi_idx: 0,
}
}
}
impl<'a, T> Iterator for NodeIter<'a, T> {
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
if self.dead {
return None;
}
match self.node {
Node::Unique(entry) => {
self.dead = true;
Some(entry)
}
Node::Many(vec) => {
let get = vec.get(self.multi_idx);
self.multi_idx += 1;
if get.is_none() {
self.dead = true;
}
get
}
}
}
}