json 0.3.3

JSON implementation in Rust
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

use JsonValue;

pub struct Generator {
    pub minify: bool,
    code: String,
    dent: u16,
}

impl Generator {
    pub fn new(minify: bool) -> Self {
        Generator {
            minify: minify,
            code: String::new(),
            dent: 0,
        }
    }

    pub fn new_line(&mut self) {
        if !self.minify {
            self.code.push('\n');
            for _ in 0..self.dent {
                self.code.push_str("    ");
            }
        }
    }

    pub fn write_json(&mut self, json: &JsonValue) {
        match *json {
            JsonValue::String(ref string) => self.write(&format!("{:?}", string)),
            JsonValue::Number(ref number) => self.write(&number.to_string()),
            JsonValue::Boolean(ref value) => self.write(if *value { "true" } else { "false" }),
            JsonValue::Null               => self.write("null"),
            JsonValue::Array(ref array)   => {
                self.write_char('[');
                let mut first = true;
                for item in array {
                    if first {
                        first = false;
                    } else {
                        self.write_min(", ", ",");
                    }
                    self.write_json(item);
                }
                self.write_char(']');
            },
            JsonValue::Object(ref object) => {
                let mut first = true;
                self.write_char('{');
                self.indent();
                for (key, value) in object.iter() {
                    if first {
                        first = false;
                    } else {
                        self.write_min(", ", ",");
                    }
                    self.write(&format!("{:?}", key));
                    self.write_min(": ", ":");
                    self.write_json(value);
                }
                self.dedent();
                self.new_line();
                self.write_char('}');
            }
        }
    }

    pub fn write(&mut self, slice: &str) {
        self.code.push_str(slice);
    }

    pub fn write_min(&mut self, slice: &str, minslice: &str) {
        if self.minify {
            self.write(minslice);
        } else {
            self.write(slice);
        }
    }

    pub fn write_char(&mut self, ch: char) {
        self.code.push(ch);
    }

    pub fn indent(&mut self) {
        self.dent += 1;
    }

    pub fn dedent(&mut self) {
        self.dent -= 1;
    }

    pub fn consume(self) -> String {
        self.code
    }
}