kserd 0.5.0

Kurt's Self-Explanatory Rust Data
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

use super::*;

impl<'a, 'k> NodeInner<'a, 'k> {
    pub fn value<'nav, 'node>(
        &'node self,
        navigator: &'nav Navigator<'a, 'k>,
    ) -> NodeValue<'a, 'k, 'nav, 'node> {
        match &self.kserd.val {
            Value::Tuple(_) => NodeValue::Tuple(SeqIter {
                seq: self.value_children.iter(),
                nav: navigator,
            }),
            Value::Cntr(v) => NodeValue::Cntr(NamedIter {
                names: v.keys(),
                values: self.value_children.iter(),
                nav: navigator,
            }),
            Value::Seq(_) => NodeValue::Seq(SeqIter {
                seq: self.value_children.iter(),
                nav: navigator,
            }),
            Value::Map(_) => NodeValue::Map(KeyedIter {
                keys: self.key_children.iter(),
                values: self.value_children.iter(),
                nav: navigator,
            }),
            _ => NodeValue::Primitive,
        }
    }
}

impl<'a, 'k, 'nav, 'node> SeqIter<'a, 'k, 'nav, 'node> {
    /// The number of items.
    pub fn len(&self) -> usize {
        self.seq.len()
    }

    /// The iterator has no elements.
    pub fn is_empty(&self) -> bool {
        self.seq.as_ref().is_empty()
    }
}

impl<'a: 'node, 'k: 'node, 'nav: 'node, 'node> Iterator for SeqIter<'a, 'k, 'nav, 'node> {
    type Item = Node<'a, 'k, 'nav, 'node>;

    fn next(&mut self) -> Option<Node<'a, 'k, 'nav, 'node>> {
        self.seq
            .next()
            .and_then(|&idx| self.nav.inner.get(idx))
            .map(|node| Node {
                node,
                nav: self.nav,
            })
    }
}

impl<'a, 'k, 'nav, 'node> NamedIter<'a, 'k, 'nav, 'node> {
    /// The number of items.
    pub fn len(&self) -> usize {
        self.values.len()
    }

    /// The iterator has no elements.
    pub fn is_empty(&self) -> bool {
        self.values.as_ref().is_empty()
    }
}

impl<'a: 'node, 'k: 'node, 'nav: 'node, 'node> Iterator for NamedIter<'a, 'k, 'nav, 'node> {
    type Item = (&'node Kstr<'k>, Node<'a, 'k, 'nav, 'node>);

    fn next(&mut self) -> Option<(&'node Kstr<'k>, Node<'a, 'k, 'nav, 'node>)> {
        if let Some(name) = self.names.next() {
            self.values
                .next()
                .and_then(|&idx| self.nav.inner.get(idx))
                .map(|node| Node {
                    node,
                    nav: self.nav,
                })
                .map(|node| (name, node))
        } else {
            None
        }
    }
}

impl<'a, 'k, 'nav, 'node> KeyedIter<'a, 'k, 'nav, 'node> {
    /// The number of items.
    pub fn len(&self) -> usize {
        self.values.len()
    }

    /// The iterator has no elements.
    pub fn is_empty(&self) -> bool {
        self.values.as_ref().is_empty()
    }
}

impl<'a: 'node, 'k: 'node, 'nav: 'node, 'node> Iterator for KeyedIter<'a, 'k, 'nav, 'node> {
    type Item = (Node<'a, 'k, 'nav, 'node>, Node<'a, 'k, 'nav, 'node>);

    fn next(&mut self) -> Option<(Node<'a, 'k, 'nav, 'node>, Node<'a, 'k, 'nav, 'node>)> {
        let key = self
            .keys
            .next()
            .and_then(|&idx| self.nav.inner.get(idx))
            .map(|node| Node {
                node,
                nav: self.nav,
            });
        if let Some(key) = key {
            self.values
                .next()
                .and_then(|&idx| self.nav.inner.get(idx))
                .map(|node| Node {
                    node,
                    nav: self.nav,
                })
                .map(|value| (key, value))
        } else {
            None
        }
    }
}