eventson 0.1.0

An event based JSON parser with competitive performance
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

use std::fmt::Display;

pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug)]
pub enum Error {
    Io(std::io::Error),
    TokenTooLarge,
    InvalidInput { position: u64, input: InvalidInput },
    MaximumDepthExceeded,
}

impl std::error::Error for Error {}

impl Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

// TODO: Split into a lex and parse error?
#[derive(Debug, PartialEq)]
pub enum InvalidInput {
    InvalidEscape(u8),
    InvalidHighSurrogate(u32),
    InvalidLowSurrogate(u32),
    MissingLowSurrogate(u32),
    InvalidEscapeSequence(u8, u8, u8, u8),
    // TODO: Should we mask this inner type?
    InvalidNumber(Option<lexical::Error>),
    InvalidTokenStart(u8),
    ControlCharacterInString(u8),
    UnescapedString,
    UnterminatedString,
    InvalidLiteral,
    WrongTokenForContext,
    EmptyStack,
    UnexpectedEof,
}

impl InvalidInput {
    pub fn err(self, pos: u64) -> Error {
        Error::InvalidInput {
            position: pos,
            input: self,
        }
    }

    pub fn res<T>(self, pos: u64) -> Result<T> {
        Err(Error::InvalidInput {
            position: pos,
            input: self,
        })
    }
}

impl From<lexical::Error> for Error {
    fn from(err: lexical::Error) -> Self {
        Error::InvalidInput {
            position: 0, // Position is not available in lexical::Error
            input: InvalidInput::InvalidNumber(Some(err)),
        }
    }
}

impl From<std::io::Error> for Error {
    fn from(err: std::io::Error) -> Self {
        Error::Io(err)
    }
}