streaming_serde_json 0.1.2

This is a streaming alternative to serde_json for processing JSON data sources that are too large to fit in memory.
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

use std::collections::VecDeque;

use serde::Serialize;

pub struct KeyValuePairWriter<T, Iter>
where
    Iter: IntoIterator<Item = (String, T)>,
    T: Serialize,
{
    state: ValueWriterState,
    iter: Iter::IntoIter,
    queued: VecDeque<String>,
    value: Option<T>,
}

enum ValueWriterState {
    Start,
    FirstKey,
    Key,
    Colon,
    Value,
    EndingBracket,
    End,
}

impl<T, Iter> KeyValuePairWriter<T, Iter>
where
    Iter: IntoIterator<Item = (String, T)>,
    T: Serialize,
{
    pub(crate) fn new(values: Iter) -> Self {
        Self {
            state: ValueWriterState::Start,
            iter: values.into_iter(),
            queued: VecDeque::with_capacity(3),
            value: None,
        }
    }
}

impl<T, Iter> Iterator for KeyValuePairWriter<T, Iter>
where
    Iter: IntoIterator<Item = (String, T)>,
    T: Serialize,
{
    type Item = Result<String, serde_json::Error>;
    fn next(&mut self) -> Option<Self::Item> {
        if let Some(queued) = self.queued.pop_front() {
            return Some(Ok(queued));
        }

        loop {
            match self.state {
                ValueWriterState::Start => {
                    self.state = ValueWriterState::FirstKey;
                    return Some(Ok("{".to_string()));
                }
                ValueWriterState::FirstKey => {
                    if let Some(next) = self.iter.next() {
                        self.state = ValueWriterState::Colon;
                        self.value = Some(next.1);
                        self.queued.push_back(next.0);
                        self.queued.push_back("\"".to_string());
                        return Some(Ok("\"".to_string()));
                    }

                    self.state = ValueWriterState::EndingBracket;
                }
                ValueWriterState::Key => {
                    if let Some(next) = self.iter.next() {
                        self.state = ValueWriterState::Colon;
                        self.value = Some(next.1);

                        let string = match serde_json::to_string(&next.0) {
                            Err(err) => return Some(Err(err)),
                            Ok(val) => val,
                        };

                        self.queued.push_back("\"".to_string());
                        self.queued.push_back(string);
                        self.queued.push_back("\"".to_string());
                        return Some(Ok(",".to_string()));
                    }

                    self.state = ValueWriterState::EndingBracket;
                }
                ValueWriterState::Colon => {
                    self.state = ValueWriterState::Value;
                    return Some(Ok(":".to_string()));
                }
                ValueWriterState::Value => {
                    if let Some(next) = std::mem::take(&mut self.value) {
                        self.state = ValueWriterState::Key;
                        return Some(serde_json::to_string(&next));
                    }

                    self.state = ValueWriterState::EndingBracket;
                }
                ValueWriterState::EndingBracket => {
                    self.state = ValueWriterState::End;
                    return Some(Ok("}".to_string()));
                }
                ValueWriterState::End => {
                    return None;
                }
            }
        }
    }
}