Struct system_error::Error

pub struct Error(_);

An error type for cross platform system-level errors.

This type captures the behavior and error message for errno on unix platforms, GetLastError() on Windows, and kern_return_t on macOS and iOS.

Implementations

impl Error

pub fn last_os_error() -> Self

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.

Examples

use system_error::Error;

println!("last OS error: {:?}", Error::last_os_error());

pub fn from_raw_os_error(code: OsCode) -> Self

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

Examples

On Linux:

use system_error::Error;
use std::io;

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

On Windows:

use system_error::Error;
use std::io;

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

pub fn from_raw_kernel_error(code: KernelCode) -> Self

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

Examples

On macOS:

use system_error::Error;
use std::io;

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

On Linux:

use system_error::Error;
use std::io;

let error = Error::from_raw_kernel_error(4);
assert_eq!(error.kind(), io::ErrorKind::Other);

pub fn kind(&self) -> ErrorKind

Returns the corresponding ErrorKind for this error.

Examples

use system_error::Error;
use std::io;

assert_eq!(Error::last_os_error().kind(), io::ErrorKind::Other);
assert_eq!(Error::from_raw_os_error(1).kind(), io::ErrorKind::PermissionDenied);

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 system_error::Error;

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

let os_err = Error::last_os_error();
let kern_err = Error::from_raw_kernel_error(8);

// Will print "raw OS error: ...".
print_os_error(&os_err);
// Will print "Not an OS error".
print_os_error(&kern_err);

assert!(os_err.raw_os_error().is_some());
assert_eq!(kern_err.raw_os_error(), None);

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

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

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

Examples

use system_error::Error;

fn print_kernel_error(err: &Error) {
    if let Some(raw_kernel_err) = err.raw_kernel_error() {
        println!("raw kernel error: {:?}", raw_kernel_err);
    } else {
        println!("Not an kernel error");
    }
}

let kern_err = Error::from_raw_kernel_error(8);
let os_err = Error::last_os_error();

// Will print "raw kernel error: 8".
print_kernel_error(&kern_err);
// Will print "Not an kernel error".
print_kernel_error(&os_err);

assert_eq!(kern_err.raw_kernel_error(), Some(8));
assert_eq!(os_err.raw_kernel_error(), None);

Trait Implementations

impl Debug for Error

fn fmt(&self, fmt: &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 source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn backtrace(&self) -> Option<&Backtrace>

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

Returns a stack backtrace, if available, of where this error occurred.

fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

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

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

impl Into<Error> for Error

fn into(self) -> Error

Performs the conversion.

impl TryFrom<Error> for Error

type Error = Error

The type returned in the event of a conversion error.

fn try_from(io: Error) -> Result<Self, Error>

Performs the conversion.