impl Error

fn line(self: &Self) -> usize

One-based line number at which the error was detected.

Characters in the first line of the input (before the first newline character) are in line 1.

fn column(self: &Self) -> usize

One-based column number at which the error was detected.

The first character in the input and any characters immediately following a newline character are in column 1.

Note that errors may occur in column 0, for example if a read from an I/O stream fails immediately following a previously read newline character.

fn classify(self: &Self) -> Category

Categorizes the cause of this error.

• Category::Io - failure to read or write bytes on an I/O stream
• Category::Syntax - input that is not syntactically valid JSON
• Category::Data - input data that is semantically incorrect
• Category::Eof - unexpected end of the input data

fn is_io(self: &Self) -> bool

Returns true if this error was caused by a failure to read or write bytes on an I/O stream.

fn is_syntax(self: &Self) -> bool

Returns true if this error was caused by input that was not syntactically valid JSON.

fn is_data(self: &Self) -> bool

Returns true if this error was caused by input data that was semantically incorrect.

For example, JSON containing a number is semantically incorrect when the type being deserialized into holds a String.

fn is_eof(self: &Self) -> bool

Returns true if this error was caused by prematurely reaching the end of the input data.

Callers that process streaming input may be interested in retrying the deserialization once more data is available.

fn io_error_kind(self: &Self) -> Option<ErrorKind>

The kind reported by the underlying standard library I/O error, if this error was caused by a failure to read or write bytes on an I/O stream.

Example

use serde_json::Value;
use std::io::{self, ErrorKind, Read};
use std::process;

struct ReaderThatWillTimeOut<'a>(&'a [u8]);

impl<'a> Read for ReaderThatWillTimeOut<'a> {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        if self.0.is_empty() {
            Err(io::Error::new(ErrorKind::TimedOut, "timed out"))
        } else {
            self.0.read(buf)
        }
    }
}

fn main() {
    let reader = ReaderThatWillTimeOut(br#" {"k": "#);

    let _: Value = match serde_json::from_reader(reader) {
        Ok(value) => value,
        Err(error) => {
            if error.io_error_kind() == Some(ErrorKind::TimedOut) {
                // Maybe this application needs to retry certain kinds of errors.

                # return;
            } else {
                eprintln!("error: {}", error);
                process::exit(1);
            }
        }
    };
}

impl Debug for Error

fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result

impl Display for Error

fn fmt(self: &Self, f: &mut fmt::Formatter<'_>) -> fmt::Result

impl Error for Error

fn source(self: &Self) -> Option<&dyn error::Error + 'static>

impl Error for Error

fn custom<T: Display>(msg: T) -> Error

fn invalid_type(unexp: de::Unexpected<'_>, exp: &dyn de::Expected) -> Self

fn invalid_value(unexp: de::Unexpected<'_>, exp: &dyn de::Expected) -> Self

impl Error for Error

fn custom<T: Display>(msg: T) -> Error

impl Freeze for Error

impl RefUnwindSafe for Error

impl Send for Error

impl Sync for Error

impl Unpin for Error

impl UnwindSafe for Error

impl<T> Any for Error

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Error

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Error

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> From for Error

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToString for Error

fn to_string(self: &Self) -> String

impl<T, U> Into for Error

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Error

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Error

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>