Struct Error 

pub struct Error {
    repr: Repr,
}

🔬This is a nightly-only experimental API. (core_io #154046)

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.

Fields

repr: Repr

🔬This is a nightly-only experimental API. (core_io #154046)

Implementations

impl Error

Common errors constants for use in std

#[doc(hidden)]

pub const INVALID_UTF8: Self

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

#[doc(hidden)]

pub const READ_EXACT_EOF: Self

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

#[doc(hidden)]

pub const UNKNOWN_THREAD_COUNT: Self

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

#[doc(hidden)]

pub const UNSUPPORTED_PLATFORM: Self

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

#[doc(hidden)]

pub const WRITE_ALL_EOF: Self

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

#[doc(hidden)]

pub const ZERO_TIMEOUT: Self

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

#[doc(hidden)]

pub const NO_ADDRESSES: Self

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

impl Error

#[doc(hidden)]

pub unsafe fn from_custom_owner(custom: CustomOwner) -> Error

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

Safety

The provided CustomOwner must have been constructed from a Box from the alloc crate.

#[doc(hidden)]

pub fn into_custom_owner(self) -> Result<CustomOwner, Self>

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

#[doc(hidden)]

pub const fn from_static_message(msg: &'static SimpleMessage) -> Error

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

Creates a new I/O error from a known kind of error as well as a constant message.

This function does not allocate.

You should not use this directly, and instead use the const_error! macro: io::const_error!(ErrorKind::Something, "some_message").

This function should maybe change to from_static_message<const MSG: &'static str>(kind: ErrorKind) in the future, when const generics allow that.

#[doc(hidden)]

pub unsafe fn from_raw_os_error_with_functions( code: RawOsError, functions: &'static OsFunctions, ) -> Error

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

Safety

functions must point to data that is entirely constant; it must not be created during runtime.

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

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 + Send + Sync + '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 + Send + Sync + '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!"));
}

#[doc(hidden)]

pub fn is_interrupted(&self) -> bool

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

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

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.

#[doc(hidden)]

fn type_id(&self, _: Internal) -> TypeId

where Self: 'static,

🔬This is a nightly-only experimental API. (error_type_id #60784)

Gets the TypeId of self.

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 #99301)

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

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}"));