1use std::fmt;
8
9#[derive(Clone, Debug, PartialEq)]
11pub enum Json {
12 Null,
13 Bool(bool),
14 Int(i64),
15 Float(f64),
16 Str(String),
17 Array(Vec<Json>),
18 Object(Vec<(String, Json)>),
19}
20
21impl Json {
22 pub fn object() -> Json {
24 Json::Object(Vec::new())
25 }
26
27 pub fn array() -> Json {
29 Json::Array(Vec::new())
30 }
31
32 pub fn is_null(&self) -> bool {
34 matches!(self, Json::Null)
35 }
36
37 pub fn as_str(&self) -> Option<&str> {
38 match self {
39 Json::Str(s) => Some(s),
40 _ => None,
41 }
42 }
43
44 pub fn as_i64(&self) -> Option<i64> {
45 match self {
46 Json::Int(n) => Some(*n),
47 Json::Float(f) if f.fract() == 0.0 => Some(*f as i64),
48 _ => None,
49 }
50 }
51
52 pub fn as_f64(&self) -> Option<f64> {
53 match self {
54 Json::Int(n) => Some(*n as f64),
55 Json::Float(f) => Some(*f),
56 _ => None,
57 }
58 }
59
60 pub fn as_bool(&self) -> Option<bool> {
61 match self {
62 Json::Bool(b) => Some(*b),
63 _ => None,
64 }
65 }
66
67 pub fn as_array(&self) -> Option<&Vec<Json>> {
68 match self {
69 Json::Array(a) => Some(a),
70 _ => None,
71 }
72 }
73
74 pub fn as_object(&self) -> Option<&Vec<(String, Json)>> {
75 match self {
76 Json::Object(o) => Some(o),
77 _ => None,
78 }
79 }
80
81 pub fn get(&self, key: &str) -> Option<&Json> {
83 match self {
84 Json::Object(o) => o.iter().find(|(k, _)| k == key).map(|(_, v)| v),
85 _ => None,
86 }
87 }
88
89 pub fn contains_key(&self, key: &str) -> bool {
90 self.get(key).is_some()
91 }
92
93 pub fn get_str(&self, key: &str) -> Option<&str> {
95 self.get(key).and_then(|v| v.as_str())
96 }
97
98 pub fn insert(&mut self, key: &str, value: impl Into<Json>) -> &mut Self {
100 if let Json::Null = self {
101 *self = Json::object();
102 }
103 if let Json::Object(o) = self {
104 let value = value.into();
105 if let Some(slot) = o.iter_mut().find(|(k, _)| k == key) {
106 slot.1 = value;
107 } else {
108 o.push((key.to_string(), value));
109 }
110 }
111 self
112 }
113
114 pub fn push(&mut self, value: impl Into<Json>) -> &mut Self {
116 if let Json::Null = self {
117 *self = Json::array();
118 }
119 if let Json::Array(a) = self {
120 a.push(value.into());
121 }
122 self
123 }
124
125 pub fn dump(&self) -> String {
128 let mut s = String::new();
129 self.write_to(&mut s);
130 s
131 }
132
133 fn write_to(&self, out: &mut String) {
134 match self {
135 Json::Null => out.push_str("null"),
136 Json::Bool(true) => out.push_str("true"),
137 Json::Bool(false) => out.push_str("false"),
138 Json::Int(n) => out.push_str(&n.to_string()),
139 Json::Float(f) => {
140 if f.is_finite() {
141 out.push_str(&f.to_string());
142 } else {
143 out.push_str("null"); }
145 }
146 Json::Str(s) => write_escaped(s, out),
147 Json::Array(a) => {
148 out.push('[');
149 for (i, v) in a.iter().enumerate() {
150 if i > 0 {
151 out.push(',');
152 }
153 v.write_to(out);
154 }
155 out.push(']');
156 }
157 Json::Object(o) => {
158 out.push('{');
159 for (i, (k, v)) in o.iter().enumerate() {
160 if i > 0 {
161 out.push(',');
162 }
163 write_escaped(k, out);
164 out.push(':');
165 v.write_to(out);
166 }
167 out.push('}');
168 }
169 }
170 }
171
172 pub fn parse(text: &str) -> Result<Json, String> {
174 let mut p = Parser {
175 b: text.as_bytes(),
176 i: 0,
177 };
178 p.skip_ws();
179 let v = p.parse_value()?;
180 p.skip_ws();
181 if p.i != p.b.len() {
182 return Err(format!("trailing data at byte {}", p.i));
183 }
184 Ok(v)
185 }
186}
187
188impl fmt::Display for Json {
189 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
190 f.write_str(&self.dump())
191 }
192}
193
194impl From<bool> for Json {
196 fn from(b: bool) -> Json {
197 Json::Bool(b)
198 }
199}
200impl From<i64> for Json {
201 fn from(n: i64) -> Json {
202 Json::Int(n)
203 }
204}
205impl From<i32> for Json {
206 fn from(n: i32) -> Json {
207 Json::Int(n as i64)
208 }
209}
210impl From<usize> for Json {
211 fn from(n: usize) -> Json {
212 Json::Int(n as i64)
213 }
214}
215impl From<f64> for Json {
216 fn from(f: f64) -> Json {
217 Json::Float(f)
218 }
219}
220impl From<&str> for Json {
221 fn from(s: &str) -> Json {
222 Json::Str(s.to_string())
223 }
224}
225impl From<String> for Json {
226 fn from(s: String) -> Json {
227 Json::Str(s)
228 }
229}
230impl From<&String> for Json {
231 fn from(s: &String) -> Json {
232 Json::Str(s.clone())
233 }
234}
235impl<T: Into<Json>> From<Vec<T>> for Json {
236 fn from(v: Vec<T>) -> Json {
237 Json::Array(v.into_iter().map(Into::into).collect())
238 }
239}
240
241fn write_escaped(s: &str, out: &mut String) {
242 out.push('"');
243 for c in s.chars() {
244 match c {
245 '"' => out.push_str("\\\""),
246 '\\' => out.push_str("\\\\"),
247 '\n' => out.push_str("\\n"),
248 '\r' => out.push_str("\\r"),
249 '\t' => out.push_str("\\t"),
250 '\u{08}' => out.push_str("\\b"),
251 '\u{0c}' => out.push_str("\\f"),
252 c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
253 c => out.push(c),
254 }
255 }
256 out.push('"');
257}
258
259struct Parser<'a> {
261 b: &'a [u8],
262 i: usize,
263}
264
265impl<'a> Parser<'a> {
266 fn skip_ws(&mut self) {
267 while self.i < self.b.len() && matches!(self.b[self.i], b' ' | b'\t' | b'\n' | b'\r') {
268 self.i += 1;
269 }
270 }
271
272 fn peek(&self) -> Option<u8> {
273 self.b.get(self.i).copied()
274 }
275
276 fn parse_value(&mut self) -> Result<Json, String> {
277 self.skip_ws();
278 match self.peek() {
279 Some(b'{') => self.parse_object(),
280 Some(b'[') => self.parse_array(),
281 Some(b'"') => Ok(Json::Str(self.parse_string()?)),
282 Some(b't') | Some(b'f') => self.parse_bool(),
283 Some(b'n') => self.parse_null(),
284 Some(c) if c == b'-' || c.is_ascii_digit() => self.parse_number(),
285 Some(c) => Err(format!("unexpected byte '{}' at {}", c as char, self.i)),
286 None => Err("unexpected end of input".to_string()),
287 }
288 }
289
290 fn expect(&mut self, lit: &[u8], value: Json) -> Result<Json, String> {
291 if self.b[self.i..].starts_with(lit) {
292 self.i += lit.len();
293 Ok(value)
294 } else {
295 Err(format!("invalid literal at {}", self.i))
296 }
297 }
298
299 fn parse_bool(&mut self) -> Result<Json, String> {
300 if self.peek() == Some(b't') {
301 self.expect(b"true", Json::Bool(true))
302 } else {
303 self.expect(b"false", Json::Bool(false))
304 }
305 }
306
307 fn parse_null(&mut self) -> Result<Json, String> {
308 self.expect(b"null", Json::Null)
309 }
310
311 fn parse_number(&mut self) -> Result<Json, String> {
312 let start = self.i;
313 let mut is_float = false;
314 while let Some(c) = self.peek() {
315 match c {
316 b'0'..=b'9' | b'-' | b'+' => self.i += 1,
317 b'.' | b'e' | b'E' => {
318 is_float = true;
319 self.i += 1;
320 }
321 _ => break,
322 }
323 }
324 let s = std::str::from_utf8(&self.b[start..self.i]).map_err(|e| e.to_string())?;
325 if !is_float {
326 if let Ok(n) = s.parse::<i64>() {
327 return Ok(Json::Int(n));
328 }
329 }
330 s.parse::<f64>()
331 .map(Json::Float)
332 .map_err(|_| format!("invalid number '{}'", s))
333 }
334
335 fn parse_string(&mut self) -> Result<String, String> {
336 self.i += 1; let mut out = String::new();
338 while let Some(c) = self.peek() {
339 self.i += 1;
340 match c {
341 b'"' => return Ok(out),
342 b'\\' => {
343 let esc = self.peek().ok_or("unterminated escape")?;
344 self.i += 1;
345 match esc {
346 b'"' => out.push('"'),
347 b'\\' => out.push('\\'),
348 b'/' => out.push('/'),
349 b'n' => out.push('\n'),
350 b'r' => out.push('\r'),
351 b't' => out.push('\t'),
352 b'b' => out.push('\u{08}'),
353 b'f' => out.push('\u{0c}'),
354 b'u' => {
355 let cp = self.parse_hex4()?;
356 if (0xD800..=0xDBFF).contains(&cp) {
357 if self.b[self.i..].starts_with(b"\\u") {
359 self.i += 2;
360 let lo = self.parse_hex4()?;
361 let c = 0x10000
362 + ((cp - 0xD800) << 10)
363 + (lo - 0xDC00);
364 out.push(char::from_u32(c).unwrap_or('\u{fffd}'));
365 } else {
366 out.push('\u{fffd}');
367 }
368 } else {
369 out.push(char::from_u32(cp).unwrap_or('\u{fffd}'));
370 }
371 }
372 other => return Err(format!("bad escape \\{}", other as char)),
373 }
374 }
375 c if c >= 0x80 => {
378 let n = if c >= 0xF0 {
379 3
380 } else if c >= 0xE0 {
381 2
382 } else {
383 1
384 };
385 let seq_start = self.i - 1;
386 self.i += n;
387 let slice = &self.b[seq_start..self.i];
388 out.push_str(std::str::from_utf8(slice).map_err(|e| e.to_string())?);
389 }
390 c => out.push(c as char),
391 }
392 }
393 Err("unterminated string".to_string())
394 }
395
396 fn parse_hex4(&mut self) -> Result<u32, String> {
397 if self.i + 4 > self.b.len() {
398 return Err("truncated \\u escape".to_string());
399 }
400 let s = std::str::from_utf8(&self.b[self.i..self.i + 4]).map_err(|e| e.to_string())?;
401 let cp = u32::from_str_radix(s, 16).map_err(|_| "bad \\u hex")?;
402 self.i += 4;
403 Ok(cp)
404 }
405
406 fn parse_array(&mut self) -> Result<Json, String> {
407 self.i += 1; let mut arr = Vec::new();
409 self.skip_ws();
410 if self.peek() == Some(b']') {
411 self.i += 1;
412 return Ok(Json::Array(arr));
413 }
414 loop {
415 arr.push(self.parse_value()?);
416 self.skip_ws();
417 match self.peek() {
418 Some(b',') => {
419 self.i += 1;
420 }
421 Some(b']') => {
422 self.i += 1;
423 return Ok(Json::Array(arr));
424 }
425 _ => return Err(format!("expected ',' or ']' at {}", self.i)),
426 }
427 }
428 }
429
430 fn parse_object(&mut self) -> Result<Json, String> {
431 self.i += 1; let mut obj = Vec::new();
433 self.skip_ws();
434 if self.peek() == Some(b'}') {
435 self.i += 1;
436 return Ok(Json::Object(obj));
437 }
438 loop {
439 self.skip_ws();
440 if self.peek() != Some(b'"') {
441 return Err(format!("expected object key at {}", self.i));
442 }
443 let key = self.parse_string()?;
444 self.skip_ws();
445 if self.peek() != Some(b':') {
446 return Err(format!("expected ':' at {}", self.i));
447 }
448 self.i += 1;
449 let val = self.parse_value()?;
450 obj.push((key, val));
451 self.skip_ws();
452 match self.peek() {
453 Some(b',') => {
454 self.i += 1;
455 }
456 Some(b'}') => {
457 self.i += 1;
458 return Ok(Json::Object(obj));
459 }
460 _ => return Err(format!("expected ',' or '}}' at {}", self.i)),
461 }
462 }
463 }
464}
465
466pub fn obj(pairs: &[(&str, Json)]) -> Json {
474 Json::Object(pairs.iter().map(|(k, v)| (k.to_string(), v.clone())).collect())
475}