jsn 0.14.0

A library for querying streaming JSON tokens
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 std::default::Default;
use std::fmt::Display;
use std::io;

/// Current position in the input JSON input
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Position {
    /// Byte offset from start of the input
    pub offset: usize,
    /// Column number. First column is 1
    pub col: usize,
    /// Line number. First line is 1
    pub line: usize,
}

impl Default for Position {
    fn default() -> Self {
        Self {
            offset: 0,
            line: 1,
            col: 0,
        }
    }
}

impl Display for Position {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "offset:{} line:{} col:{}",
            self.offset, self.line, self.col
        )
    }
}

/// All the possible reasons parsing json might fail
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum Reason {
    /// Failed to parse what looked like a number
    ExpectedNumber,

    /// Failed to parse what looked like a string
    ExpectedString,

    /// Failed to parse what looked like a boolean
    ExpectedBool,

    /// Failed to parse what looked like a null
    ExpectedNull,

    /// Unexpected control character in string
    UnexpectedCtrlChar,

    /// Encountered an invalid unicode/utf8 sequence while parsing a string
    InvalidUtf8,

    /// Invalid escape escape code in string
    InvalidEscapeCode,

    /// Unexpectedly reached end of file. Json is malformed
    UnexpectedEof,

    /// A character was not recognized as being part of a valid json construct
    UnexpectedChar,

    /// The read implementation was non-blocking, which is not supported
    NonBlockingRead,

    /// Failed to rewind a `Seek`able input.
    CouldNotRewindInput(io::ErrorKind),

    /// An unrecognized io-related error occured
    UnrecognizedIoError(io::ErrorKind),
}

/// Bundles the reason & location of a parsing error
#[derive(Debug, Copy, Clone, thiserror::Error, PartialEq, Eq)]
#[error("malformed json at position {position}")]
pub struct JsonError {
    /// The reason parsing failed
    pub reason: Reason,
    /// Position in the input at which parsing failed
    pub position: Position,
}

impl From<io::ErrorKind> for Reason {
    fn from(value: io::ErrorKind) -> Self {
        match value {
            io::ErrorKind::UnexpectedEof => Reason::UnexpectedEof,
            io::ErrorKind::WouldBlock => Reason::NonBlockingRead,
            _ => Reason::UnrecognizedIoError(value),
        }
    }
}