Enum kg_tree::serial::json::JsonParseErrDetail

pub enum JsonParseErrDetail {
    InvalidEscape {
        from: Position,
        to: Position,
    },
    InvalidChar {
        input: char,
        from: Position,
        to: Position,
    },
    InvalidCharOne {
        input: char,
        from: Position,
        to: Position,
        expected: char,
    },
    InvalidCharMany {
        input: char,
        from: Position,
        to: Position,
        expected: Vec<char>,
    },
    InvalidControlUTF8Char {
        input: char,
        from: Position,
        to: Position,
    },
    InvalidIntegerLiteral {
        err: ParseIntError,
        from: Position,
        to: Position,
    },
    InvalidFloatLiteral {
        err: ParseFloatError,
        from: Position,
        to: Position,
    },
    UnexpectedEoi {
        pos: Position,
    },
    UnexpectedEoiOne {
        pos: Position,
        expected: char,
    },
    UnexpectedEoiMany {
        pos: Position,
        expected: Vec<char>,
    },
    UnexpectedEoiOneString {
        pos: Position,
        expected: String,
    },
    UnexpectedToken {
        token: LexToken<Terminal>,
    },
    UnexpectedTokenOne {
        token: LexToken<Terminal>,
        expected: Terminal,
    },
    UnexpectedTokenMany {
        token: LexToken<Terminal>,
        expected: Vec<Terminal>,
    },
    UnclosedGroup(Terminal),
    RedefinedKey {
        key: String,
    },
}

Variants

InvalidEscape

Fields of InvalidEscape

from: Positionto: Position

InvalidChar

Fields of InvalidChar

input: charfrom: Positionto: Position

InvalidCharOne

Fields of InvalidCharOne

input: charfrom: Positionto: Positionexpected: char

InvalidCharMany

Fields of InvalidCharMany

input: charfrom: Positionto: Positionexpected: Vec<char>

InvalidControlUTF8Char

Fields of InvalidControlUTF8Char

input: charfrom: Positionto: Position

InvalidIntegerLiteral

Fields of InvalidIntegerLiteral

err: ParseIntErrorfrom: Positionto: Position

InvalidFloatLiteral

Fields of InvalidFloatLiteral

err: ParseFloatErrorfrom: Positionto: Position

UnexpectedEoi

Fields of UnexpectedEoi

pos: Position

UnexpectedEoiOne

Fields of UnexpectedEoiOne

pos: Positionexpected: char

UnexpectedEoiMany

Fields of UnexpectedEoiMany

pos: Positionexpected: Vec<char>

UnexpectedEoiOneString

Fields of UnexpectedEoiOneString

pos: Positionexpected: String

UnexpectedToken

Fields of UnexpectedToken

token: LexToken<Terminal>

UnexpectedTokenOne

Fields of UnexpectedTokenOne

token: LexToken<Terminal>expected: Terminal

UnexpectedTokenMany

Fields of UnexpectedTokenMany

token: LexToken<Terminal>expected: Vec<Terminal>

UnclosedGroup(Terminal)RedefinedKey

Fields of RedefinedKey

key: String

Methods

impl ParseErr

pub fn invalid_escape<T>(r: &mut dyn CharReader) -> Result<T, ParseDiag>

pub fn invalid_input<T>(r: &mut dyn CharReader) -> Result<T, ParseDiag>

pub fn invalid_input_one<T>(
    r: &mut dyn CharReader,
    expected: char
) -> Result<T, ParseDiag>

pub fn invalid_input_many<T>(
    r: &mut dyn CharReader,
    expected: Vec<char>
) -> Result<T, ParseDiag>

pub fn invalid_control_utf8_input<T>(
    r: &mut dyn CharReader
) -> Result<T, ParseDiag>

pub fn unexpected_eoi_str<T>(
    r: &mut dyn CharReader,
    expected: String
) -> Result<T, ParseDiag>

pub fn unexpected_token<T>(
    token: LexToken<Terminal>,
    r: &mut dyn CharReader
) -> Result<T, ParseDiag>

pub fn unexpected_token_one<T>(
    token: LexToken<Terminal>,
    expected: Terminal,
    r: &mut dyn CharReader
) -> Result<T, ParseDiag>

pub fn unexpected_token_many<T>(
    token: LexToken<Terminal>,
    expected: Vec<Terminal>,
    r: &mut dyn CharReader
) -> Result<T, ParseDiag>

pub fn key_redefined<T>(
    r: &mut dyn CharReader,
    redefined: Span,
    prev: Span,
    key: &str
) -> Result<T, ParseDiag>

pub fn key_redefined_node<T>(
    r: &mut dyn CharReader,
    redefined: Span,
    prev_defined: &NodeRef,
    key: &str
) -> Result<T, ParseDiag>

Trait Implementations

impl Display for ParseErr

fn fmt(&self, f__: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Debug for ParseErr

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Detail for ParseErr

fn severity(&self) -> Severity

fn code(&self) -> u32

fn type_id(&self) -> TypeId

fn as_fmt_debug(&self) -> &dyn Debug

fn as_fmt_display(&self) -> &dyn Display