Struct Error 

pub struct Error { /* private fields */ }

🔬This is a nightly-only experimental API. (alloc_io)

The error type for I/O operations of the Read, Write, Seek, and associated traits.

Errors mostly originate from the underlying OS, but custom instances of Error can be created with crafted error messages and a particular value of ErrorKind.

Implementations

impl Error

pub fn raw_os_error(&self) -> Option<i32>

Returns the OS error that this error represents (if any).

If this Error was constructed via last_os_error or from_raw_os_error, then this function will return Some, otherwise it will return None.

Examples

use std::io::{Error, ErrorKind};

fn print_os_error(err: &Error) {
    if let Some(raw_os_err) = err.raw_os_error() {
        println!("raw OS error: {raw_os_err:?}");
    } else {
        println!("Not an OS error");
    }
}

fn main() {
    // Will print "raw OS error: ...".
    print_os_error(&Error::last_os_error());
    // Will print "Not an OS error".
    print_os_error(&Error::new(ErrorKind::Other, "oh no!"));
}

pub fn get_ref(&self) -> Option<&(dyn Error + Sync + Send + 'static)>

Returns a reference to the inner error wrapped by this error (if any).

If this Error was constructed via new then this function will return Some, otherwise it will return None.

Examples

use std::io::{Error, ErrorKind};

fn print_error(err: &Error) {
    if let Some(inner_err) = err.get_ref() {
        println!("Inner error: {inner_err:?}");
    } else {
        println!("No inner error");
    }
}

fn main() {
    // Will print "No inner error".
    print_error(&Error::last_os_error());
    // Will print "Inner error: ...".
    print_error(&Error::new(ErrorKind::Other, "oh no!"));
}

pub fn get_mut(&mut self) -> Option<&mut (dyn Error + Sync + Send + 'static)>

Returns a mutable reference to the inner error wrapped by this error (if any).

If this Error was constructed via new then this function will return Some, otherwise it will return None.

Examples

use std::io::{Error, ErrorKind};
use std::{error, fmt};
use std::fmt::Display;

#[derive(Debug)]
struct MyError {
    v: String,
}

impl MyError {
    fn new() -> MyError {
        MyError {
            v: "oh no!".to_string()
        }
    }

    fn change_message(&mut self, new_message: &str) {
        self.v = new_message.to_string();
    }
}

impl error::Error for MyError {}

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

fn change_error(mut err: Error) -> Error {
    if let Some(inner_err) = err.get_mut() {
        inner_err.downcast_mut::<MyError>().unwrap().change_message("I've been changed!");
    }
    err
}

fn print_error(err: &Error) {
    if let Some(inner_err) = err.get_ref() {
        println!("Inner error: {inner_err}");
    } else {
        println!("No inner error");
    }
}

fn main() {
    // Will print "No inner error".
    print_error(&change_error(Error::last_os_error()));
    // Will print "Inner error: ...".
    print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));
}

pub fn kind(&self) -> ErrorKind

Returns the corresponding ErrorKind for this error.

This may be a value set by Rust code constructing custom io::Errors, or if this io::Error was sourced from the operating system, it will be a value inferred from the system’s error encoding. See last_os_error for more details.

Examples

use std::io::{Error, ErrorKind};

fn print_error(err: Error) {
    println!("{:?}", err.kind());
}

fn main() {
    // As no error has (visibly) occurred, this may print anything!
    // It likely prints a placeholder for unidentified (non-)errors.
    print_error(Error::last_os_error());
    // Will print "AddrInUse".
    print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));
}

impl Error

pub fn last_os_error() -> Error

Returns an error representing the last OS error which occurred.

This function reads the value of errno for the target platform (e.g. GetLastError on Windows) and will return a corresponding instance of Error for the error code.

This should be called immediately after a call to a platform function, otherwise the state of the error value is indeterminate. In particular, other standard library functions may call platform functions that may (or may not) reset the error value even if they succeed.

Examples

use std::io::Error;

let os_error = Error::last_os_error();
println!("last OS error: {os_error:?}");

pub fn from_raw_os_error(code: i32) -> Error

Creates a new instance of an Error from a particular OS error code.

Examples

On Linux:

use std::io;

let error = io::Error::from_raw_os_error(22);
assert_eq!(error.kind(), io::ErrorKind::InvalidInput);

On Windows:

use std::io;

let error = io::Error::from_raw_os_error(10022);
assert_eq!(error.kind(), io::ErrorKind::InvalidInput);

impl Error

pub fn new<E>(kind: ErrorKind, error: E) -> Error

where E: Into<Box<dyn Error + Sync + Send>>,

Creates a new I/O error from a known kind of error as well as an arbitrary error payload.

This function is used to generically create I/O errors which do not originate from the OS itself. The error argument is an arbitrary payload which will be contained in this Error.

Note that this function allocates memory on the heap. If no extra payload is required, use the From conversion from ErrorKind.

Examples

use std::io::{Error, ErrorKind};

// errors can be created from strings
let custom_error = Error::new(ErrorKind::Other, "oh no!");

// errors can also be created from other errors
let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);

// creating an error without payload (and without memory allocation)
let eof_error = Error::from(ErrorKind::UnexpectedEof);

pub fn other<E>(error: E) -> Error

where E: Into<Box<dyn Error + Sync + Send>>,

Creates a new I/O error from an arbitrary error payload.

This function is used to generically create I/O errors which do not originate from the OS itself. It is a shortcut for Error::new with ErrorKind::Other.

Examples

use std::io::Error;

// errors can be created from strings
let custom_error = Error::other("oh no!");

// errors can also be created from other errors
let custom_error2 = Error::other(custom_error);

pub fn into_inner(self) -> Option<Box<dyn Error + Sync + Send>>

Consumes the Error, returning its inner error (if any).

If this Error was constructed via new or other, then this function will return Some, otherwise it will return None.

Examples

use std::io::{Error, ErrorKind};

fn print_error(err: Error) {
    if let Some(inner_err) = err.into_inner() {
        println!("Inner error: {inner_err}");
    } else {
        println!("No inner error");
    }
}

fn main() {
    // Will print "No inner error".
    print_error(Error::last_os_error());
    // Will print "Inner error: ...".
    print_error(Error::new(ErrorKind::Other, "oh no!"));
}

pub fn downcast<E>(self) -> Result<E, Error>

where E: Error + Send + Sync + 'static,

Attempts to downcast the custom boxed error to E.

If this Error contains a custom boxed error, then it would attempt downcasting on the boxed error, otherwise it will return Err.

If the custom boxed error has the same type as E, it will return Ok, otherwise it will also return Err.

This method is meant to be a convenience routine for calling Box<dyn Error + Sync + Send>::downcast on the custom boxed error, returned by Error::into_inner.

Examples

use std::fmt;
use std::io;
use std::error::Error;

#[derive(Debug)]
enum E {
    Io(io::Error),
    SomeOtherVariant,
}

impl fmt::Display for E {
   // ...
}
impl Error for E {}

impl From<io::Error> for E {
    fn from(err: io::Error) -> E {
        err.downcast::<E>()
            .unwrap_or_else(E::Io)
    }
}

impl From<E> for io::Error {
    fn from(err: E) -> io::Error {
        match err {
            E::Io(io_error) => io_error,
            e => io::Error::new(io::ErrorKind::Other, e),
        }
    }
}

let e = E::SomeOtherVariant;
// Convert it to an io::Error
let io_error = io::Error::from(e);
// Cast it back to the original variant
let e = E::from(io_error);
assert!(matches!(e, E::SomeOtherVariant));

let io_error = io::Error::from(io::ErrorKind::AlreadyExists);
// Convert it to E
let e = E::from(io_error);
// Cast it back to the original variant
let io_error = io::Error::from(e);
assert_eq!(io_error.kind(), io::ErrorKind::AlreadyExists);
assert!(io_error.get_ref().is_none());
assert!(io_error.raw_os_error().is_none());

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

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

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<T> From<AsyncFdTryNewError<T>> for Error

fn from(value: AsyncFdTryNewError<T>) -> Error

Converts to this type from the input type.

impl<S, E> From<ConversionError<S, E>> for Error

where E: Display,

Boxes the error into an io::Error, dropping the retained file descriptor in the process.

fn from(e: ConversionError<S, E>) -> Error

Converts to this type from the input type.

impl From<DecodeError> for Error

Available on crate feature std only.

fn from(error: DecodeError) -> Error

Converts to this type from the input type.

impl From<Elapsed> for Error

fn from(_err: Elapsed) -> Error

Converts to this type from the input type.

impl From<Elapsed> for Error

fn from(_err: Elapsed) -> Error

Converts to this type from the input type.

impl From<EncodeError> for Error

Available on crate feature std only.

fn from(error: EncodeError) -> Error

Converts to this type from the input type.

impl From<Errno> for Error

Available on crate feature std only.

fn from(errno: Errno) -> Error

Converts to this type from the input type.

impl From<Errno> for Error

fn from(err: Errno) -> Error

Converts to this type from the input type.

impl From<Errno> for Error

Available on crate feature std only.

fn from(err: Errno) -> Error

Converts to this type from the input type.

impl From<Error> for Error

fn from(walk_err: Error) -> Error

Convert the Error to an io::Error, preserving the original Error as the “inner error”. Note that this also makes the display of the error include the context.

This is different from into_io_error which returns the original io::Error.

impl From<Error> for Error

fn from(error: Error) -> Error

Converts to this type from the input type.

impl From<Error> for Error

fn from(e: Error) -> Error

Converts to this type from the input type.

impl From<Error> for Error

Available on crate feature std only.

fn from(error: Error) -> Error

Converts to this type from the input type.

impl From<Error> for Error

fn from(err: Error) -> Error

Converts to this type from the input type.

impl From<Error> for Error

Available on crate feature std only.

fn from(j: Error) -> Error

Convert a serde_json::Error into an io::Error.

JSON syntax and data errors are turned into InvalidData I/O errors. EOF errors are turned into UnexpectedEof I/O errors.

use std::io;

enum MyError {
    Io(io::Error),
    Json(serde_json::Error),
}

impl From<serde_json::Error> for MyError {
    fn from(err: serde_json::Error) -> MyError {
        use serde_json::error::Category;
        match err.classify() {
            Category::Io => {
                MyError::Io(err.into())
            }
            Category::Syntax | Category::Data | Category::Eof => {
                MyError::Json(err)
            }
        }
    }
}

impl From<ErrorKind> for Error

Intended for use for errors not exposed to the user, where allocating onto the heap (for normal construction via Error::new) is too costly.

fn from(kind: ErrorKind) -> Error

Converts an ErrorKind into an Error.

This conversion creates a new error with a simple representation of error kind.

Examples

use std::io::{Error, ErrorKind};

let not_found = ErrorKind::NotFound;
let error = Error::from(not_found);
assert_eq!("entity not found", format!("{error}"));

impl From<FormError> for Error

fn from(e: FormError) -> Error

Converts to this type from the input type.

impl<W> From<IntoInnerError<W>> for Error

fn from(iie: IntoInnerError<W>) -> Error

Converts to this type from the input type.

impl From<JoinError> for Error

fn from(src: JoinError) -> Error

Converts to this type from the input type.

impl From<MultiError> for Error

fn from(e: MultiError) -> Error

Converts to this type from the input type.

impl From<NulError> for Error

Available on non-no_global_oom_handling and non-no_rc and non-no_sync only.

fn from(_: NulError) -> Error

Converts a crate::ffi::NulError into a Error.

impl From<ShareError> for Error

fn from(e: ShareError) -> Error

Converts to this type from the input type.

impl From<SpawnError> for Error

fn from(e: SpawnError) -> Error

Converts to this type from the input type.

impl From<TryGetError> for Error

Available on crate feature std only.

fn from(error: TryGetError) -> Error

Converts to this type from the input type.

impl From<TryLockError> for Error

fn from(err: TryLockError) -> Error

Converts to this type from the input type.

impl From<TryReserveError> for Error

fn from(_: TryReserveError) -> Error

Converts TryReserveError to an error with ErrorKind::OutOfMemory.

TryReserveError won’t be available as the error source(), but this may change in the future.