1use std::io::Write;
2use std::{io, marker};
3
4pub struct JsonWriter<Sink, State> {
5 sink: Sink,
6 reentrant: bool,
7 _state: marker::PhantomData<State>,
8}
9
10macro_rules! define_states {
11 ($($state:ident),*) => {
12 $(pub struct $state<Prev> {
13 _prev: marker::PhantomData<Prev>,
14 })*
15 };
16}
17
18macro_rules! ret {
19 ($sink:expr, $reentrant:expr) => {
20 Ok(JsonWriter {
21 sink: $sink,
22 reentrant: $reentrant,
23 _state: marker::PhantomData::default(),
24 })
25 };
26}
27
28macro_rules! impl_values {
29 ($next_state:ty) => {
30 pub fn number(mut self, value: f64) -> io::Result<JsonWriter<Sink, $next_state>> {
31 self.comma()?;
32 write!(self.sink, "{value}")?;
33 ret!(self.sink, true)
34 }
35
36 pub fn string(mut self, value: &str) -> io::Result<JsonWriter<Sink, $next_state>> {
37 self.comma()?;
38 write!(self.sink, "{value:?}")?;
39 ret!(self.sink, true)
40 }
41
42 pub fn null(mut self) -> io::Result<JsonWriter<Sink, $next_state>> {
43 self.comma()?;
44 write!(self.sink, "null")?;
45 ret!(self.sink, true)
46 }
47
48 pub fn array(mut self) -> io::Result<JsonWriter<Sink, Array<$next_state>>> {
49 self.comma()?;
50 write!(self.sink, "[")?;
51 ret!(self.sink, false)
52 }
53
54 pub fn object(mut self) -> io::Result<JsonWriter<Sink, Object<$next_state>>> {
55 self.comma()?;
56 write!(self.sink, "{{")?;
57 ret!(self.sink, false)
58 }
59 };
60}
61
62pub struct Root;
63define_states!(Field, Array, Object);
64
65pub fn new_root<Sink: Write>(mut sink: Sink) -> io::Result<JsonWriter<Sink, Root>> {
66 write!(sink, "{{")?;
67 ret!(sink, false)
68}
69
70impl<Sink: Write, State> JsonWriter<Sink, State> {
71 fn comma(&mut self) -> io::Result<()> {
72 if self.reentrant {
73 write!(self.sink, ", ")
74 } else {
75 Ok(())
76 }
77 }
78}
79
80impl<Sink: Write> JsonWriter<Sink, Root> {
81 pub fn field(mut self, name: &str) -> io::Result<JsonWriter<Sink, Field<Root>>> {
82 self.comma()?;
83 write!(self.sink, "\"{name}\": ")?;
84 ret!(self.sink, false)
85 }
86
87 pub fn end(mut self) -> io::Result<()> {
88 write!(self.sink, "}}")?;
89 self.sink.flush()
90 }
91}
92
93impl<Sink: Write, Prev> JsonWriter<Sink, Field<Prev>> {
94 impl_values!(Prev);
95}
96
97impl<Sink: Write, Prev> JsonWriter<Sink, Object<Prev>> {
98 pub fn field(mut self, name: &str) -> io::Result<JsonWriter<Sink, Field<Object<Prev>>>> {
99 self.comma()?;
100 write!(self.sink, "\"{name}\": ")?;
101 ret!(self.sink, false)
102 }
103
104 pub fn end(mut self) -> io::Result<JsonWriter<Sink, Prev>> {
105 write!(self.sink, "}}")?;
106 ret!(self.sink, true)
107 }
108}
109
110impl<Sink: Write, Prev> JsonWriter<Sink, Array<Prev>> {
111 impl_values!(Array<Prev>);
112
113 pub fn end(mut self) -> io::Result<JsonWriter<Sink, Prev>> {
114 write!(self.sink, "]")?;
115 ret!(self.sink, true)
116 }
117}
118
119#[cfg(test)]
120mod tests {
121 use super::*;
122
123 #[test]
124 fn flat_object() -> std::io::Result<()> {
125 const EXPECTED: &str = r#"{"retcode": 1337, "message": "OK", "data": null}"#;
126
127 let mut buffer: Vec<u8> = Vec::new();
128 new_root(&mut buffer)?
129 .field("retcode")?
130 .number(1337.0)?
131 .field("message")?
132 .string("OK")?
133 .field("data")?
134 .null()?
135 .end()?;
136
137 assert_eq!(String::from_utf8(buffer).unwrap(), EXPECTED);
138 Ok(())
139 }
140
141 #[test]
142 fn arrays() -> std::io::Result<()> {
143 const EXPECTED: &str = r#"{"numbers": [1, 3, 3, 7, 13.37], "strings": ["Hello", "World"], "etc": [777, "foo", {"bar": "baz", "something": "else"}, null, []]}"#;
144
145 let mut buffer: Vec<u8> = Vec::new();
146 new_root(&mut buffer)?
147 .field("numbers")?
148 .array()?
149 .number(1.0)?
150 .number(3.0)?
151 .number(3.0)?
152 .number(7.0)?
153 .number(13.37)?
154 .end()?
155 .field("strings")?
156 .array()?
157 .string("Hello")?
158 .string("World")?
159 .end()?
160 .field("etc")?
161 .array()?
162 .number(777.0)?
163 .string("foo")?
164 .object()?
165 .field("bar")?
166 .string("baz")?
167 .field("something")?
168 .string("else")?
169 .end()?
170 .null()?
171 .array()?
172 .end()?
173 .end()?
174 .end()?;
175
176 assert_eq!(String::from_utf8(buffer).unwrap(), EXPECTED);
177 Ok(())
178 }
179}