ImJson 0.0.1

Immediate Mode Json deserializer and serializer
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
95
96
97
98
99
100
101
102

pub struct Deserializer<'a> {
    current_pos: usize,
    s: &'a str,
}

impl<'a> Deserializer<'a> {
    pub fn new(s: &str) -> Deserializer {
        Deserializer { current_pos: 0, s }
    }

    pub fn get_next_token(&mut self) -> Option<&str> {
        if self.current_pos == self.s.len() {
            return None;
        }

        // Skip WhiteSpace
        if self.current_char().is_ascii_whitespace() {
            let advance = self.seek_none_whitespace(self.current_pos + 1);
            self.current_pos += advance + 1;
        }

        let current_char = self.current_char();
        let old_pos = self.current_pos;

        match current_char {
            b'{' | b'}' | b':' | b'[' | b']' | b',' => {
                self.current_pos += 1;
                return Some(&self.s[old_pos..old_pos + 1]);
            }
            b'\"' => {
                let advance = self.seek_str_end(old_pos + 1);
                self.current_pos += advance + 2;
                return Some(&self.s[old_pos..self.current_pos]);
            }
            _ => {
                if current_char.is_ascii_digit() {
                    let advance = self.seek_number_end(old_pos + 1);
                    self.current_pos += advance + 1;
                    return Some(&self.s[old_pos..self.current_pos]);
                }
            }
        }

        panic!()
    }

    pub fn expect_begin_array(&mut self) -> Option<&str> {
        let str = self.get_next_token();
        match str {
            Some("[") => str,
            _ => None,
        }
    }

    pub fn expect_end_array(&mut self) -> Option<&str> {
        let str = self.get_next_token();
        match str {
            Some("]") => str,
            _ => None,
        }
    }

    pub fn expect_i64(&mut self) -> Option<i64> {
        let str = self.get_next_token()?;
        if str == "," {
            self.expect_i64()
        } else {
            str.parse::<i64>().ok()
        }
    }

    fn current_char(&self) -> u8 {
        self.s.as_bytes()[self.current_pos]
    }

    fn seek_str_end(&self, start: usize) -> usize {
        for (i, c) in self.s.as_bytes()[start..self.s.len()].iter().enumerate() {
            if *c == b'\"' {
                return i;
            }
        }
        todo!();
    }

    fn seek_none_whitespace(&self, start: usize) -> usize {
        for (i, c) in self.s.as_bytes()[start..self.s.len()].iter().enumerate() {
            if !c.is_ascii_whitespace() {
                return i;
            }
        }
        todo!();
    }

    fn seek_number_end(&self, start: usize) -> usize {
        for (i, c) in self.s.as_bytes()[start..self.s.len()].iter().enumerate() {
            if !c.is_ascii_digit() {
                return i;
            }
        }
        todo!()
    }
}