Struct abi_stable::std_types::RIoError

#[repr(C)]
pub struct RIoError { /* private fields */ }

Ffi safe equivalent to std::io::Error.

Example

Defining an extern function to write a slice into a writer twice.

use abi_stable::{
    erased_types::interfaces::IoWriteInterface,
    rtry, sabi_extern_fn,
    std_types::{RIoError, ROk, RResult},
    traits::IntoReprC,
    DynTrait, RMut,
};

use std::io::Write;

#[sabi_extern_fn]
pub fn write_slice_twice(
    mut write: DynTrait<RMut<'_, ()>, IoWriteInterface>,
    slice: &[u8],
) -> RResult<(), RIoError> {
    rtry!(write.write_all(slice).into_c());
    rtry!(write.write_all(slice).into_c());
    ROk(())
}

Implementations

impl RIoError

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

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

Constructs an RIoError from an error and a std::io::ErrorKind.

Example

use abi_stable::std_types::RIoError;
use std::io::ErrorKind;

let err = RIoError::new(ErrorKind::Other, "".parse::<u64>().unwrap_err());

pub fn new_<E>(kind: ErrorKind, error: E) -> Self

where E: Into<Box<dyn ErrorTrait + Send + Sync + 'static>>,

Constructs an RIoError from a type convertible into a Box<dyn std::error::Error + Send + Sync + 'static>, and a std::io::ErrorKind.

Example

use abi_stable::std_types::RIoError;
use std::io::ErrorKind;

let str_err = "Timeout receiving the response from server.";

let err = RIoError::new_(ErrorKind::TimedOut, str_err);

pub fn from_kind(kind: ErrorKind) -> Self

Constructs an RIoError from a std::io::ErrorKind.

Example

use abi_stable::std_types::RIoError;
use std::io::ErrorKind;

let err = RIoError::from_kind(ErrorKind::AlreadyExists);

pub fn with_box( kind: ErrorKind, error: Box<dyn ErrorTrait + Send + Sync + 'static> ) -> Self

Constructs an RIoError from a Box<dyn std::error::Error + Send + Sync + 'static> and a std::io::ErrorKind.

Example

use abi_stable::std_types::RIoError;
use std::io::ErrorKind;

let str_err = "Could not create file \"memes.txt\" because it already exists.";

let err = RIoError::with_box(ErrorKind::AlreadyExists, str_err.into());

pub fn with_rboxerror(kind: ErrorKind, error: RBoxError) -> Self

Constructs an RIoError from an RBoxError and a std::io::ErrorKind.

Example

use abi_stable::std_types::RIoError;
use std::io::ErrorKind;

type DynErr = Box<dyn std::error::Error + Send + Sync>;

let str_err: DynErr = "IP address `256.256.256.256` is already in use.".into();

let err = RIoError::with_rboxerror(ErrorKind::AddrInUse, str_err.into());

pub fn kind(&self) -> RIoErrorKind

Retrieves the kind of io error.

Example

use abi_stable::std_types::{RIoError, RIoErrorKind};
use std::io::ErrorKind;

let err = RIoError::from_kind(ErrorKind::AlreadyExists);

assert_eq!(err.kind(), RIoErrorKind::AlreadyExists);

pub fn get_ref(&self) -> Option<&RBoxError>

Gets the internal error, returning None if this was constructed with RIoError::from_kind.

Example

use abi_stable::std_types::{RBoxError, RIoError, RIoErrorKind};
use std::io::ErrorKind;

{
    let err = RIoError::from_kind(ErrorKind::AlreadyExists);
    assert_eq!(err.get_ref().map(|_| ()), None);
}
{
    let msg = "Cannot access directory at \"/home/Steve/memes/\".";
    let err = RIoError::new_(ErrorKind::PermissionDenied, msg);

    assert!(err.get_ref().is_some());
}

pub fn get_mut(&mut self) -> Option<&mut RBoxError>

Gets the internal error, returning None if this was constructed with RIoError::from_kind.

Example

use abi_stable::std_types::{RBoxError, RIoError, RIoErrorKind};
use std::io::ErrorKind;

{
    let mut err = RIoError::from_kind(ErrorKind::AlreadyExists);
    assert_eq!(err.get_mut().map(|_| ()), None);
}
{
    let mut msg = "Cannot access directory at \"/home/Patrick/373.15K takes/\".";
    let mut err = RIoError::new_(ErrorKind::PermissionDenied, msg);
    assert!(err.get_mut().is_some());
}

pub fn into_inner(self) -> Option<RBoxError>

Converts this into the internal error, returning None if this was constructed with RIoError::from_kind.

Example

use abi_stable::std_types::RIoError;
use std::io::ErrorKind;

{
    let err = RIoError::from_kind(ErrorKind::AlreadyExists);
    assert_eq!(err.into_inner().map(|_| ()), None);
}
{
    let mut msg = "Cannot access directory at \"/home/wo_boat/blog/\".";
    let err = RIoError::new_(ErrorKind::PermissionDenied, msg);
    assert!(err.into_inner().is_some());
}

Trait Implementations

impl Debug for RIoError

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

Formats the value using the given formatter.

impl Display for RIoError

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

Formats the value using the given formatter.

impl Error for RIoError

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

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 cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

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 From<Error> for RIoError

fn from(this: ioError) -> RIoError

Converts to this type from the input type.

impl From<ErrorKind> for RIoError

fn from(kind: ErrorKind) -> Self

Converts to this type from the input type.

impl From<RIoError> for Error

fn from(this: RIoError) -> ioError

Converts to this type from the input type.

impl From<RIoErrorKind> for RIoError

fn from(kind: RIoErrorKind) -> Self

Converts to this type from the input type.

impl GetStaticEquivalent_ for RIoError

type StaticEquivalent = _static_RIoError

The 'static equivalent of Self

impl IntoReprRust for RIoError

type ReprRust = Error

The #[repr(Rust)] equivalent.

fn into_rust(self) -> Self::ReprRust

Performs the conversion

impl StableAbi for RIoError

type IsNonZeroType = False

Whether this type has a single invalid bit-pattern.

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.