Skip to main content

format/
format.rs

1use core::{cell::RefCell, fmt};
2
3use zjson::{any::Any, document::Document, literal, number};
4
5fn main() {
6    let json = r#"{
7        "one": 1,
8        "array": [true, false, null],
9        "object": {"pi": 3.14, "exp": 1e5}
10    }"#;
11
12    let mut document = Document::new(json);
13    let root = document
14        .next()
15        .expect("failed to parse document")
16        .expect("failed to get root from document");
17
18    let format = Format(RefCell::new(root));
19    println!("{format:?}");
20
21    document.finish().expect("failed to parse document");
22}
23
24struct Format<'json, 'p>(RefCell<Any<'json, 'p>>);
25
26impl<'json, 'p> fmt::Debug for Format<'json, 'p> {
27    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
28        match &mut *self.0.borrow_mut() {
29            Any::String(string) => {
30                let parsed = string.get().expect("failed to parse string");
31                let raw = parsed.unescaped();
32                write!(f, "{raw:?}")
33            }
34
35            Any::Number(number) => {
36                let parsed = number.get().expect("failed to parse number");
37                <number::ParsedNumber as fmt::Display>::fmt(&parsed, f)
38            }
39
40            Any::Object(object) => {
41                let mut map = f.debug_map();
42
43                while let Some((key, value)) = object.next().expect("failed to parse an object") {
44                    let raw_key = key.unescaped();
45                    map.entry(&raw_key, &Format(RefCell::new(value)));
46                }
47
48                map.finish()
49            }
50
51            Any::Array(array) => {
52                let mut list = f.debug_list();
53
54                while let Some(value) = array.next().expect("failed to parse an array") {
55                    list.entry(&Format(RefCell::new(value)));
56                }
57
58                list.finish()
59            }
60
61            Any::Literal(literal) => {
62                let parsed = literal.get().expect("failed to parse literal");
63                <literal::ParsedLiteral as fmt::Display>::fmt(&parsed, f)
64            }
65        }
66    }
67}
68
69// Test the example
70#[test]
71fn test() {
72    main();
73}