1use std::fmt::{self, Write as _};
3
4#[derive(Debug, Clone, PartialEq, Default)]
6pub enum Json {
7 #[default]
8 Null,
9 Bool(bool),
10 Num(f64),
11 Str(String),
12 Arr(Vec<Json>),
13 Obj(Vec<(String, Json)>),
14}
15
16impl Json {
17 pub fn obj() -> Json {
19 Json::Obj(Vec::new())
20 }
21 pub fn with(mut self, key: &str, v: impl Into<Json>) -> Json {
23 self.set(key, v);
24 self
25 }
26 pub fn set(&mut self, key: &str, v: impl Into<Json>) {
27 if !matches!(self, Json::Obj(_)) {
28 *self = Json::obj();
29 }
30 if let Json::Obj(o) = self {
31 let v = v.into();
32 match o.iter_mut().find(|(k, _)| k == key) {
33 Some(slot) => slot.1 = v,
34 None => o.push((key.to_string(), v)),
35 }
36 }
37 }
38 pub fn get(&self, key: &str) -> Option<&Json> {
39 match self {
40 Json::Obj(o) => o.iter().find(|(k, _)| k == key).map(|(_, v)| v),
41 _ => None,
42 }
43 }
44 pub fn is_null(&self) -> bool {
45 matches!(self, Json::Null)
46 }
47 pub fn as_f64(&self) -> Option<f64> {
48 match self {
49 Json::Num(n) => Some(*n),
50 Json::Bool(b) => Some(if *b { 1.0 } else { 0.0 }),
51 Json::Str(s) => s.trim().parse().ok(),
52 _ => None,
53 }
54 }
55 pub fn as_i64(&self) -> Option<i64> {
56 self.as_f64().map(|f| f as i64)
57 }
58 pub fn as_bool(&self) -> Option<bool> {
59 match self {
60 Json::Bool(b) => Some(*b),
61 Json::Num(n) => Some(*n != 0.0),
62 _ => None,
63 }
64 }
65 pub fn as_str(&self) -> Option<&str> {
66 match self {
67 Json::Str(s) => Some(s),
68 _ => None,
69 }
70 }
71 pub fn as_array(&self) -> Option<&[Json]> {
72 match self {
73 Json::Arr(a) => Some(a),
74 _ => None,
75 }
76 }
77 pub fn as_object(&self) -> Option<&[(String, Json)]> {
78 match self {
79 Json::Obj(o) => Some(o),
80 _ => None,
81 }
82 }
83 pub fn text(&self) -> String {
85 match self {
86 Json::Null => String::new(),
87 Json::Str(s) => s.clone(),
88 other => other.to_string(),
89 }
90 }
91
92 pub fn parse(s: &str) -> Result<Json, String> {
94 let mut p = Parser { b: s.as_bytes(), i: 0 };
95 p.ws();
96 let v = p.value(0)?;
97 p.ws();
98 if p.i != p.b.len() {
99 return Err(format!("unexpected text at byte {}", p.i));
100 }
101 Ok(v)
102 }
103}
104
105impl From<f64> for Json {
106 fn from(v: f64) -> Self {
107 Json::Num(v)
108 }
109}
110impl From<i64> for Json {
111 fn from(v: i64) -> Self {
112 Json::Num(v as f64)
113 }
114}
115impl From<usize> for Json {
116 fn from(v: usize) -> Self {
117 Json::Num(v as f64)
118 }
119}
120impl From<bool> for Json {
121 fn from(v: bool) -> Self {
122 Json::Bool(v)
123 }
124}
125impl From<&str> for Json {
126 fn from(v: &str) -> Self {
127 Json::Str(v.to_string())
128 }
129}
130impl From<String> for Json {
131 fn from(v: String) -> Self {
132 Json::Str(v)
133 }
134}
135impl<T: Into<Json>> From<Vec<T>> for Json {
136 fn from(v: Vec<T>) -> Self {
137 Json::Arr(v.into_iter().map(Into::into).collect())
138 }
139}
140impl<T: Into<Json>> From<Option<T>> for Json {
141 fn from(v: Option<T>) -> Self {
142 v.map(Into::into).unwrap_or(Json::Null)
143 }
144}
145
146fn write_str(f: &mut fmt::Formatter<'_>, s: &str) -> fmt::Result {
147 f.write_char('"')?;
148 for c in s.chars() {
149 match c {
150 '"' => f.write_str("\\\"")?,
151 '\\' => f.write_str("\\\\")?,
152 '\n' => f.write_str("\\n")?,
153 '\r' => f.write_str("\\r")?,
154 '\t' => f.write_str("\\t")?,
155 c if (c as u32) < 0x20 => write!(f, "\\u{:04x}", c as u32)?,
156 c => f.write_char(c)?,
157 }
158 }
159 f.write_char('"')
160}
161
162impl fmt::Display for Json {
163 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
164 match self {
165 Json::Null => f.write_str("null"),
166 Json::Bool(b) => write!(f, "{b}"),
167 Json::Num(n) if !n.is_finite() => f.write_str("null"),
168 Json::Num(n) if n.fract() == 0.0 && n.abs() < 9.0e15 => write!(f, "{}", *n as i64),
169 Json::Num(n) => write!(f, "{n}"),
170 Json::Str(s) => write_str(f, s),
171 Json::Arr(a) => {
172 f.write_char('[')?;
173 for (i, v) in a.iter().enumerate() {
174 if i > 0 {
175 f.write_char(',')?;
176 }
177 write!(f, "{v}")?;
178 }
179 f.write_char(']')
180 }
181 Json::Obj(o) => {
182 f.write_char('{')?;
183 for (i, (k, v)) in o.iter().enumerate() {
184 if i > 0 {
185 f.write_char(',')?;
186 }
187 write_str(f, k)?;
188 write!(f, ":{v}")?;
189 }
190 f.write_char('}')
191 }
192 }
193 }
194}
195
196struct Parser<'a> {
197 b: &'a [u8],
198 i: usize,
199}
200
201impl Parser<'_> {
202 fn ws(&mut self) {
203 while self.i < self.b.len() && matches!(self.b[self.i], b' ' | b'\n' | b'\r' | b'\t') {
204 self.i += 1;
205 }
206 }
207 fn err<T>(&self, what: &str) -> Result<T, String> {
208 Err(format!("{what} at byte {}", self.i))
209 }
210 fn eat(&mut self, lit: &str) -> bool {
211 if self.b[self.i..].starts_with(lit.as_bytes()) {
212 self.i += lit.len();
213 true
214 } else {
215 false
216 }
217 }
218 fn value(&mut self, depth: usize) -> Result<Json, String> {
219 if depth > 128 {
220 return self.err("nested too deeply");
221 }
222 self.ws();
223 let Some(&c) = self.b.get(self.i) else { return self.err("unexpected end") };
224 match c {
225 b'n' if self.eat("null") => Ok(Json::Null),
226 b't' if self.eat("true") => Ok(Json::Bool(true)),
227 b'f' if self.eat("false") => Ok(Json::Bool(false)),
228 b'"' => self.string().map(Json::Str),
229 b'[' => {
230 self.i += 1;
231 let mut v = Vec::new();
232 self.ws();
233 if self.eat("]") {
234 return Ok(Json::Arr(v));
235 }
236 loop {
237 v.push(self.value(depth + 1)?);
238 self.ws();
239 if self.eat(",") {
240 continue;
241 }
242 if self.eat("]") {
243 return Ok(Json::Arr(v));
244 }
245 return self.err("expected , or ]");
246 }
247 }
248 b'{' => {
249 self.i += 1;
250 let mut o = Vec::new();
251 self.ws();
252 if self.eat("}") {
253 return Ok(Json::Obj(o));
254 }
255 loop {
256 self.ws();
257 if self.b.get(self.i) != Some(&b'"') {
258 return self.err("expected a key");
259 }
260 let k = self.string()?;
261 self.ws();
262 if !self.eat(":") {
263 return self.err("expected :");
264 }
265 let v = self.value(depth + 1)?;
266 o.push((k, v));
267 self.ws();
268 if self.eat(",") {
269 continue;
270 }
271 if self.eat("}") {
272 return Ok(Json::Obj(o));
273 }
274 return self.err("expected , or }");
275 }
276 }
277 b'-' | b'0'..=b'9' => {
278 let start = self.i;
279 while self.i < self.b.len() && matches!(self.b[self.i], b'-' | b'+' | b'.' | b'e' | b'E' | b'0'..=b'9') {
280 self.i += 1;
281 }
282 let s = std::str::from_utf8(&self.b[start..self.i]).unwrap_or("");
283 s.parse::<f64>().map(Json::Num).map_err(|_| format!("bad number `{s}` at byte {start}"))
284 }
285 _ => self.err("unexpected character"),
286 }
287 }
288 fn hex4(&mut self) -> Result<u32, String> {
289 let h = self.b.get(self.i..self.i + 4).ok_or("short \\u escape")?;
290 let s = std::str::from_utf8(h).map_err(|_| "bad \\u escape")?;
291 self.i += 4;
292 u32::from_str_radix(s, 16).map_err(|_| "bad \\u escape".to_string())
293 }
294 fn string(&mut self) -> Result<String, String> {
295 self.i += 1;
296 let mut out = String::new();
297 loop {
298 let start = self.i;
299 while self.i < self.b.len() && self.b[self.i] != b'"' && self.b[self.i] != b'\\' {
300 self.i += 1;
301 }
302 out.push_str(std::str::from_utf8(&self.b[start..self.i]).map_err(|_| "invalid UTF-8".to_string())?);
303 match self.b.get(self.i) {
304 None => return self.err("unterminated string"),
305 Some(b'"') => {
306 self.i += 1;
307 return Ok(out);
308 }
309 _ => {
310 self.i += 1;
311 let Some(&e) = self.b.get(self.i) else { return self.err("unterminated escape") };
312 self.i += 1;
313 match e {
314 b'"' => out.push('"'),
315 b'\\' => out.push('\\'),
316 b'/' => out.push('/'),
317 b'b' => out.push('\u{8}'),
318 b'f' => out.push('\u{c}'),
319 b'n' => out.push('\n'),
320 b'r' => out.push('\r'),
321 b't' => out.push('\t'),
322 b'u' => {
323 let mut c = self.hex4()?;
324 if (0xD800..0xDC00).contains(&c) && self.eat("\\u") {
325 let lo = self.hex4()?;
326 c = 0x10000 + ((c - 0xD800) << 10) + (lo.wrapping_sub(0xDC00) & 0x3FF);
327 }
328 out.push(char::from_u32(c).unwrap_or('\u{FFFD}'));
329 }
330 _ => return self.err("bad escape"),
331 }
332 }
333 }
334 }
335 }
336}
337
338#[cfg(test)]
339mod tests {
340 use super::Json;
341
342 #[test]
343 fn round_trip() {
344 let s = r#"{"a":[1,2.5,-3e2,true,null],"b":"x\"y\n\u00e9\ud83d\ude00","c":{}}"#;
345 let v = Json::parse(s).unwrap();
346 assert_eq!(v.get("a").unwrap().as_array().unwrap()[2].as_f64(), Some(-300.0));
347 assert_eq!(v.get("b").unwrap().as_str(), Some("x\"y\né😀"));
348 let again = Json::parse(&v.to_string()).unwrap();
349 assert_eq!(v, again);
350 assert!(Json::parse("[1,").is_err());
351 assert!(Json::parse("{} x").is_err());
352 assert_eq!(Json::Num(f64::NAN).to_string(), "null");
353 assert_eq!(Json::obj().with("k", 2.0).with("k", "v").to_string(), r#"{"k":"v"}"#);
354 }
355}