zjson 0.1.5

Parse JSON with zero allocation.
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

use crate::{debug::debug_impl, Parent};

mod error;
mod machine;
mod parsed;
pub use error::ParseLiteralError;
use machine::Machine;
pub use parsed::ParsedLiteral;

/// A JSON literal, either `null`, `true` or `false`.
pub struct Literal<'json, 'p> {
    parent: &'p mut dyn Parent<'json>,
    remaining: &'json str,
}

impl<'json, 'p> Literal<'json, 'p> {
    pub(crate) fn new(parent: &'p mut dyn Parent<'json>, remaining: &'json str) -> Self {
        Self { parent, remaining }
    }

    /// Try to parse the literal.
    ///
    /// # Errors
    /// If parsing the literal fails, this will return a [`ParseLiteralError`].
    pub fn get(&mut self) -> Result<ParsedLiteral, ParseLiteralError> {
        let mut machine = Machine::Start;

        for (i, c) in self.remaining.char_indices() {
            machine = machine.apply(c)?;

            if let Machine::End(value) = machine {
                let next_i = i + c.len_utf8();
                let remaining = &self.remaining[next_i..];
                self.parent.set_remaining(remaining);
                return Ok(value);
            }
        }

        Err(ParseLiteralError::UnexpectedEnd)
    }

    #[inline]
    /// Finish parsing the literal so that the parent can continue.
    ///
    /// If [`Self::get`] has been called, this is not needed.
    ///
    /// # Errors
    /// If parsing fails in this literal, the error is returned as a [`ParseLiteralError`].
    pub fn finish(&mut self) -> Result<(), ParseLiteralError> {
        self.get().map(drop)
    }
}

debug_impl!("Literal", Literal<'json, 'p>);