sn 0.1.2

zero-copy JSON parser
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::cmp::min;

/// A data stream.
/// Used by the Parser to iterate over the supplied JSON data and to parse it into Values.
pub struct Stream<'a, T> {
    index: usize,
    data: &'a [T],
}

impl<'a, T: Copy> Stream<'a, T> {
    /// Returns the current character.
    pub fn current_copied(&self) -> Option<T> {
        self.data.get(self.index).copied()
    }

    /// Returns the current element and panicks if it's out of range
    pub fn current_unchecked(&self) -> T {
        self.data[self.index]
    }

    /// Moves to the next character and returns it.
    pub fn next_copied(&mut self) -> Option<T> {
        self.skip();
        self.data.get(self.index).copied()
    }

    /// Returns a reference to the perevious entry in the stream
    pub fn peek_back_copied(&self) -> Option<T> {
        self.data.get(self.position() - 1).copied()
    }
}

impl<'a, T: Eq + Copy> Stream<'a, T> {
    /// Returns the current character and moves to the next character if the character matches
    /// the provided input.
    pub fn next_if_current_is(&mut self, expect: T) -> Option<T> {
        self.next_if_current_present_in(&[expect])
    }

    /// Returns the current character and moves to the next character if the character exists
    /// in the provided array.
    pub fn next_if_current_present_in(&mut self, expect: &[T]) -> Option<T> {
        let c = self.current_copied()?;

        if expect.contains(&c) {
            self.skip();
            return Some(c);
        }

        None
    }

    /// Skips the current character if it matches the input, and returns true in this case.
    /// Returns false and does not skip if the current character does not match the input.
    pub fn skip_if_current_is(&mut self, expect: T) -> bool {
        self.next_if_current_is(expect)
            .map(|c| c == expect)
            .unwrap_or(false)
    }
}

impl<'a, T> Stream<'a, T> {
    /// Creates a new stream
    pub fn new(data: &'a [T]) -> Stream<T> {
        Self { data, index: 0 }
    }

    /// Returns the current element
    pub fn current(&self) -> Option<&T> {
        self.data.get(self.index)
    }

    /// Checks whether the stream has reached the end
    pub fn is_eof(&self) -> bool {
        self.index >= self.data.len()
    }

    /// Get the length of the stream.
    pub fn length(&self) -> usize {
        self.data.len()
    }

    /// Returns the next element
    pub fn next_entry(&mut self) -> Option<&T> {
        self.data.get(self.index + 1).map(|c| {
            self.skip();
            c
        })
    }

    /// Returns the next element and panicks if it's out of bounds
    pub fn next_unchecked(&mut self) -> &T {
        self.skip();
        self.data.get(self.index).unwrap()
    }

    /// Returns a reference to the next entry in the stream
    pub fn peek(&self) -> Option<&T> {
        self.data.get(self.position() + 1)
    }

    /// Returns a reference to the previous entry in the stream
    pub fn peek_back(&self) -> Option<&T> {
        self.data.get(self.position() - 1)
    }

    /// The current position of the stream on the data
    pub fn position(&self) -> usize {
        self.index
    }

    /// Skips the current character and moves on to the next one
    pub fn skip(&mut self) {
        self.index += 1;
    }

    /// Skips n amount of characters
    pub fn skip_n(&mut self, n: usize) {
        self.index += n;
    }

    /// Moves back to the previous character
    pub fn unskip(&mut self) {
        self.index -= 1;
    }

    /// Returns a subslice of this stream but also checks stream length
    /// to prevent out of bounds panicking
    pub fn slice(&self, from: usize, to: usize) -> &'a [T] {
        &self.data[from..min(self.data.len(), to)]
    }

    /// Returns a subslice of this stream
    pub fn slice_unchecked(&self, from: usize, to: usize) -> &'a [T] {
        &self.data[from..to]
    }

    /// Same as slice, but the second argument is how many elements to slice
    pub fn slice_len(&self, from: usize, len: usize) -> &'a [T] {
        self.slice(from, self.index + len)
    }
}