Struct abi_stable::std_types::RBoxError_

#[repr(C)]
pub struct RBoxError_<M = SyncSend> { /* fields omitted */ }

Ffi-safe version of Box<dyn std::error::Error + 'static> whose Send + Syncness is determined by the M type parameter.

Examples

Converting from and into Box<dyn Error + ...>

use std::{convert::TryFrom, error::Error as ErrorTrait};

use abi_stable::std_types::{RBox, RBoxError, SendRBoxError, UnsyncRBoxError};

{
    let from: Box<dyn ErrorTrait> = "hello, error".into();
    let rbox = UnsyncRBoxError::from_box(from);
    let _: Box<dyn ErrorTrait> = rbox.into_box();
}

{
    let arr_err = <[(); 0]>::try_from(&[()][..]).unwrap_err();
    let from: Box<dyn ErrorTrait + Send> = Box::new(arr_err);
    let rbox = SendRBoxError::from_box(from);
    let _: Box<dyn ErrorTrait + Send> = rbox.into_box();
}

{
    let arr_err = <[(); 0]>::try_from(&[()][..]).unwrap_err();
    let from: Box<dyn ErrorTrait + Send + Sync> = Box::new(arr_err);
    let rbox = RBoxError::from_box(from);
    let _: Box<dyn ErrorTrait + Send + Sync> = rbox.into_box();
}

Downcasting by value

use std::num::{ParseFloatError, ParseIntError};

use abi_stable::std_types::{RBox, RBoxError};

// Constructing a `RBoxError` from a `Box<dyn Error>`, then downcasting to a `ParseIntError`.
{
    let parse_err = "".parse::<u64>().unwrap_err();
    let dyn_err: Box<std::error::Error + Send + Sync + 'static> =
        Box::new(parse_err.clone());
    let err = RBoxError::from_box(dyn_err);

    assert_eq!(
        err.downcast::<ParseIntError>().unwrap(),
        RBox::new(parse_err)
    );
}

// Constructing a `RBoxError` from a `ParseFloatError`, then downcasting back to it.
{
    let parse_err = "".parse::<f32>().unwrap_err();
    let err = RBoxError::new(parse_err.clone());

    assert_eq!(
        err.downcast::<ParseFloatError>().unwrap(),
        RBox::new(parse_err)
    );
}

// Constructing a `RBoxError` from a `ParseFloatError`,
// then attempting to downcasting it to a `ParseIntError`.
{
    let parse_err = "".parse::<f32>().unwrap_err();
    let err = RBoxError::new(parse_err);

    assert!(err.downcast::<ParseIntError>().is_err());
}

Downcasting by reference

use std::{convert::TryFrom, num::TryFromIntError, str::Utf8Error};

use abi_stable::std_types::{RBox, UnsyncRBoxError};

// Constructing a `UnsyncRBoxError` from a `Box<dyn Error>`,
// then downcasting to a `TryFromIntError`.
{
    let int_err = u32::try_from(-1_i32).unwrap_err();
    let dyn_err: Box<std::error::Error + 'static> = Box::new(int_err.clone());
    let err = UnsyncRBoxError::from_box(dyn_err);

    assert_eq!(err.downcast_ref::<TryFromIntError>().unwrap(), &int_err);
}

// Constructing a `UnsyncRBoxError` from a `Utf8Error`, then downcasting back to it.
{
    let utf8_err = std::str::from_utf8(&[255]).unwrap_err();
    let err = UnsyncRBoxError::new(utf8_err.clone());

    assert_eq!(err.downcast_ref::<Utf8Error>().unwrap(), &utf8_err);
}

// Constructing a `UnsyncRBoxError` from a `Utf8Error`,
// then attempting to downcasting it to a `TryFromIntError`.
{
    let utf8_err = std::str::from_utf8(&[255]).unwrap_err();
    let err = UnsyncRBoxError::new(utf8_err);

    assert!(err.downcast_ref::<TryFromIntError>().is_none());
}

Downcasting by mutable reference

use std::string::{FromUtf16Error, FromUtf8Error};

use abi_stable::std_types::{RBox, SendRBoxError};

// Constructing a `SendRBoxError` from a `Box<dyn Error>`,
// then downcasting to a `FromUtf8Error`.
{
    let str_err = || String::from_utf8(vec![255]).unwrap_err();
    let dyn_err: Box<std::error::Error + Send + 'static> = Box::new(str_err());
    let mut err = SendRBoxError::from_box(dyn_err);

    assert!(err.downcast_ref::<FromUtf8Error>().is_some(), "part A");
}

// Constructing a `SendRBoxError` from a `FromUtf8Error`, then downcasting back to it.
{
    let str_err = || String::from_utf8(vec![255]).unwrap_err();
    let mut err = SendRBoxError::new(str_err());

    assert!(err.downcast_ref::<FromUtf8Error>().is_some(), "part B");
}

// Constructing a `SendRBoxError` from a `FromUtf16Error`,
// then attempting to downcasting it to a `FromUtf8Error`.
{
    let str_err = || String::from_utf16(&[0xD834]).unwrap_err();
    let mut err = SendRBoxError::new(str_err());

    assert!(err.downcast_ref::<FromUtf8Error>().is_none(), "part C");
}

Implementations

impl RBoxError_<SyncSend>

pub fn new<T>(value: T) -> Self where
    T: ErrorTrait + Send + Sync + 'static, 

Constructs a Send + Sync RBoxError_ from an error.

Example

use abi_stable::std_types::RBoxError;

let str_err = String::from_utf8(vec![255]).unwrap_err();

let err = RBoxError::new(str_err);

impl RBoxError_<UnsyncSend>

pub fn new<T>(value: T) -> Self where
    T: ErrorTrait + Send + 'static, 

Constructs a Send + !Sync RBoxError_ from an error.

Example

use abi_stable::std_types::SendRBoxError;

let str_err = String::from_utf16(&[0xD834]).unwrap_err() ;

let err = SendRBoxError::new(str_err);

impl RBoxError_<UnsyncUnsend>

pub fn new<T>(value: T) -> Self where
    T: ErrorTrait + 'static, 

Constructs a !Send + !Sync RBoxError_ from an error.

Example

use abi_stable::std_types::UnsyncRBoxError;

let str_err = std::str::from_utf8(&[255]).unwrap_err() ;

let err = UnsyncRBoxError::new(str_err);

impl<M> RBoxError_<M>

pub fn from_fmt<T>(value: &T) -> Self where
    T: Display + Debug + ?Sized, 

Constructs an RBoxError from an error, storing the Debug and Display messages without storing the error value.

Example

use abi_stable::std_types::RBoxError;

let int_error = "".parse::<u32>().unwrap_err();

let display_fmt = int_error.to_string();
let debug_fmt = format!("{:#?}", int_error);

let err = RBoxError::from_fmt(&int_error);

assert_eq!(display_fmt, err.to_string());
assert_eq!(debug_fmt, format!("{:?}", err));

pub fn from_debug<T>(value: &T) -> Self where
    T: Debug + ?Sized, 

Constructs an RBoxError from a type that only implements Debug, storing the Debug message without storing the error value.

Example

use abi_stable::std_types::RBoxError;

let int_error = "".parse::<u32>().unwrap_err();

let debug_fmt = format!("{:#?}", int_error);
let err = RBoxError::from_debug(&int_error);

assert_eq!(debug_fmt, format!("{}", err));
assert_eq!(debug_fmt, format!("{:#?}", err));

impl<M> RBoxError_<M>

pub fn to_formatted_error<N>(&self) -> RBoxError_<N>

Converts this error to a formatted error

This is used to decouple an RBoxError from the dynamic library that produced it, in order to unload the dynamic library.

impl<M> RBoxError_<M>

pub fn type_id(&self) -> UTypeId

Returns the UTypeId of the error this wraps.

pub fn heap_address(&self) -> usize

The address of the Box<_> this wraps

pub fn as_unsync(&self) -> &UnsyncRBoxError

Casts this &RBoxError_<_> to &UnsyncRBoxError.

Example

use abi_stable::std_types::{RBoxError, UnsyncRBoxError};
use std::convert::TryFrom;

let int_err = u32::try_from(-1_i32).unwrap_err();

let err: RBoxError = RBoxError::new(int_err);

let unsync_err: &UnsyncRBoxError = err.as_unsync();

pub fn into_unsync(self) -> UnsyncRBoxError

Converts this RBoxError_<_> to UnsyncRBoxError.

Example

use abi_stable::std_types::{RBoxError, UnsyncRBoxError};
use std::convert::TryFrom;

let int_err = u64::try_from(-1338_i32).unwrap_err();

let err: RBoxError = RBoxError::new(int_err);

let unsync_err: UnsyncRBoxError = err.into_unsync();

impl RBoxError_<SyncSend>

pub fn as_send(&self) -> &SendRBoxError

Casts this &RBoxError_<_> to &SendRBoxError.

Example

use abi_stable::std_types::{RBoxError, SendRBoxError};
use std::convert::TryFrom;

let slice: &mut [u32] = &mut [];
let arr_err=<&mut [u32;10]>::try_from(slice).unwrap_err();

let err: RBoxError = RBoxError::new(arr_err);

let unsync_err: &SendRBoxError = err.as_send();

pub fn into_send(self) -> SendRBoxError

Converts this RBoxError_<_> to SendRBoxError.

Example

use abi_stable::std_types::{RBoxError, SendRBoxError};
use std::convert::TryFrom;

let slice: &[u32] = &[];
let arr_err=<&[u32;10]>::try_from(slice).unwrap_err();

let err: RBoxError = RBoxError::new(arr_err);

let unsync_err: SendRBoxError = err.into_send();

impl RBoxError_<SyncSend>

pub fn from_box(this: Box<dyn ErrorTrait + Send + Sync + 'static>) -> Self

Converts a Box<dyn Error + Send + Sync> to a Send + Sync RBoxError_.

RBoxError::from_box( RBoxError::into_box( err ) ) is a no-op with respect to the heap address of the RBoxError_<_>.

Behavior

If the contents of the Box<_> is an erased RBoxError_<_> it will be returned directly, otherwise the Box<_> will be converted into an RBoxError_<_> using RBoxError_::new.

Example

For an example of converting back and forth to a Box<dyn Error> here is the example.

pub fn into_box(self) -> Box<dyn ErrorTrait + Send + Sync + 'static>

Converts an RBoxError_<_> to a Box<dyn Error>.

RBoxError::from_box( RBoxError::into_box( err ) ) is a no-op with respect to the heap address of the RBoxError_<_>.

Behavior

If the contents of the RBoxError_<_> is an erased Box<dyn Error + ... > it will be returned directly, otherwise the RBoxError_<_> will be converted into an Box<dyn Error + ... > using Box::new.

Example

For an example of converting back and forth to a Box<dyn Error> here is the example.

pub fn downcast<T>(self) -> Result<RBox<T>, Self> where
    T: ErrorTrait + 'static, 

Converts this RBoxError_<_> to an RBox<T>.

If was constructed from a Box<dyn Error + ... >, and this is being casted to another type, it’ll first downcast to Box<dyn Error + ... >, then it’ll downcast the Box<dyn Error + ... > into RBox<T>.

Errors

This returns Err(self) in any of these cases:

• The RBoxError_ wasn’t constructed in the current dynamic library.

• The RBoxError_ was constructed with a different type than T.

Example

Look at the type level documentation for the example.

pub fn downcast_ref<T>(&self) -> Option<&T> where
    T: ErrorTrait + 'static, 

Converts this &RBoxError_<_> to a &T.

If was constructed from a Box<dyn Error + ... >, and this is being casted to another type, it’ll first downcast to &dyn Error + ... , then it’ll downcast the &dyn Error + ... into &T.

Errors

This returns None in any of these cases:

• The RBoxError_ wasn’t constructed in the current dynamic library.

• The RBoxError_ was constructed with a different type than T.

Example

Look at the type level documentation for the example. the example.

pub fn downcast_mut<T>(&mut self) -> Option<&mut T> where
    T: ErrorTrait + 'static, 

Converts this &mut RBoxError_<_> to a &mut T.

If was constructed from a Box<dyn Error + ... >, and this is being casted to another type, it’ll first downcast to &mut dyn Error + ... , then it’ll downcast the &mut dyn Error + ... into &mut T.

Errors

This returns None in any of these cases:

• The RBoxError_ wasn’t constructed in the current dynamic library.

• The RBoxError_ was constructed with a different type than T.

Example

Look at the type level documentation for the example. the example.

impl RBoxError_<UnsyncSend>

pub fn from_box(this: Box<dyn ErrorTrait + Send + 'static>) -> Self

Converts a Box<dyn Error + Send> to a Send + !Sync RBoxError_.

RBoxError::from_box( RBoxError::into_box( err ) ) is a no-op with respect to the heap address of the RBoxError_<_>.

Behavior

If the contents of the Box<_> is an erased RBoxError_<_> it will be returned directly, otherwise the Box<_> will be converted into an RBoxError_<_> using RBoxError_::new.

Example

For an example of converting back and forth to a Box<dyn Error> here is the example.

pub fn into_box(self) -> Box<dyn ErrorTrait + Send + 'static>

Converts an RBoxError_<_> to a Box<dyn Error>.

RBoxError::from_box( RBoxError::into_box( err ) ) is a no-op with respect to the heap address of the RBoxError_<_>.

Behavior

If the contents of the RBoxError_<_> is an erased Box<dyn Error + ... > it will be returned directly, otherwise the RBoxError_<_> will be converted into an Box<dyn Error + ... > using Box::new.

Example

For an example of converting back and forth to a Box<dyn Error> here is the example.

pub fn downcast<T>(self) -> Result<RBox<T>, Self> where
    T: ErrorTrait + 'static, 

Converts this RBoxError_<_> to an RBox<T>.

If was constructed from a Box<dyn Error + ... >, and this is being casted to another type, it’ll first downcast to Box<dyn Error + ... >, then it’ll downcast the Box<dyn Error + ... > into RBox<T>.

Errors

This returns Err(self) in any of these cases:

• The RBoxError_ wasn’t constructed in the current dynamic library.

• The RBoxError_ was constructed with a different type than T.

Example

Look at the type level documentation for the example.

pub fn downcast_ref<T>(&self) -> Option<&T> where
    T: ErrorTrait + 'static, 

Converts this &RBoxError_<_> to a &T.

If was constructed from a Box<dyn Error + ... >, and this is being casted to another type, it’ll first downcast to &dyn Error + ... , then it’ll downcast the &dyn Error + ... into &T.

Errors

This returns None in any of these cases:

• The RBoxError_ wasn’t constructed in the current dynamic library.

• The RBoxError_ was constructed with a different type than T.

Example

Look at the type level documentation for the example. the example.

pub fn downcast_mut<T>(&mut self) -> Option<&mut T> where
    T: ErrorTrait + 'static, 

Converts this &mut RBoxError_<_> to a &mut T.

If was constructed from a Box<dyn Error + ... >, and this is being casted to another type, it’ll first downcast to &mut dyn Error + ... , then it’ll downcast the &mut dyn Error + ... into &mut T.

Errors

This returns None in any of these cases:

• The RBoxError_ wasn’t constructed in the current dynamic library.

• The RBoxError_ was constructed with a different type than T.

Example

Look at the type level documentation for the example. the example.

impl RBoxError_<UnsyncUnsend>

pub fn from_box(this: Box<dyn ErrorTrait + 'static>) -> Self

Converts a Box<dyn Error> to a !Send + !Sync RBoxError_.

RBoxError::from_box( RBoxError::into_box( err ) ) is a no-op with respect to the heap address of the RBoxError_<_>.

Behavior

If the contents of the Box<_> is an erased RBoxError_<_> it will be returned directly, otherwise the Box<_> will be converted into an RBoxError_<_> using RBoxError_::new.

Example

For an example of converting back and forth to a Box<dyn Error> here is the example.

pub fn into_box(self) -> Box<dyn ErrorTrait + 'static>

Converts an RBoxError_<_> to a Box<dyn Error>.

RBoxError::from_box( RBoxError::into_box( err ) ) is a no-op with respect to the heap address of the RBoxError_<_>.

Behavior

If the contents of the RBoxError_<_> is an erased Box<dyn Error + ... > it will be returned directly, otherwise the RBoxError_<_> will be converted into an Box<dyn Error + ... > using Box::new.

Example

For an example of converting back and forth to a Box<dyn Error> here is the example.

pub fn downcast<T>(self) -> Result<RBox<T>, Self> where
    T: ErrorTrait + 'static, 

Converts this RBoxError_<_> to an RBox<T>.

If was constructed from a Box<dyn Error + ... >, and this is being casted to another type, it’ll first downcast to Box<dyn Error + ... >, then it’ll downcast the Box<dyn Error + ... > into RBox<T>.

Errors

This returns Err(self) in any of these cases:

• The RBoxError_ wasn’t constructed in the current dynamic library.

• The RBoxError_ was constructed with a different type than T.

Example

Look at the type level documentation for the example.

pub fn downcast_ref<T>(&self) -> Option<&T> where
    T: ErrorTrait + 'static, 

Converts this &RBoxError_<_> to a &T.

If was constructed from a Box<dyn Error + ... >, and this is being casted to another type, it’ll first downcast to &dyn Error + ... , then it’ll downcast the &dyn Error + ... into &T.

Errors

This returns None in any of these cases:

• The RBoxError_ wasn’t constructed in the current dynamic library.

• The RBoxError_ was constructed with a different type than T.

Example

Look at the type level documentation for the example. the example.

pub fn downcast_mut<T>(&mut self) -> Option<&mut T> where
    T: ErrorTrait + 'static, 

Converts this &mut RBoxError_<_> to a &mut T.

If was constructed from a Box<dyn Error + ... >, and this is being casted to another type, it’ll first downcast to &mut dyn Error + ... , then it’ll downcast the &mut dyn Error + ... into &mut T.

Errors

This returns None in any of these cases:

• The RBoxError_ wasn’t constructed in the current dynamic library.

• The RBoxError_ was constructed with a different type than T.

Example

Look at the type level documentation for the example. the example.

Trait Implementations

impl<M> Debug for RBoxError_<M>

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

Formats the value using the given formatter.

impl<M> Display for RBoxError_<M>

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

Formats the value using the given formatter.

impl<M> Error for RBoxError_<M>

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 From<Box<dyn Error + 'static, Global>> for RBoxError_<UnsyncUnsend>

fn from(this: Box<dyn ErrorTrait + 'static>) -> RBoxError_<UnsyncUnsend>

Converts a Box<dyn Error> to a !Send + !Sync RBoxError_.

Behavior

If the contents of the Box<_> is an erased RBoxError_<_> it will be returned directly, otherwise the Box<_> will be converted into an RBoxError_<_> using RBoxError_::new.

impl From<Box<dyn Error + Send + 'static, Global>> for RBoxError_<UnsyncSend>

fn from(this: Box<dyn ErrorTrait + Send + 'static>) -> RBoxError_<UnsyncSend>

Converts a Box<dyn Error + Send> to a Send + !Sync RBoxError_.

Behavior

If the contents of the Box<_> is an erased RBoxError_<_> it will be returned directly, otherwise the Box<_> will be converted into an RBoxError_<_> using RBoxError_::new.

impl From<Box<dyn Error + Send + Sync + 'static, Global>> for RBoxError_<SyncSend>

fn from(
    this: Box<dyn ErrorTrait + Send + Sync + 'static>
) -> RBoxError_<SyncSend>

Converts a Box<dyn Error + Send + Sync> to a Send + Sync RBoxError_.

Behavior

If the contents of the Box<_> is an erased RBoxError_<_> it will be returned directly, otherwise the Box<_> will be converted into an RBoxError_<_> using RBoxError_::new.

impl<M> GetStaticEquivalent_ for RBoxError_<M> where
    M: __StableAbi, 

type StaticEquivalent = _static_RBoxError_<__GetStaticEquivalent<M>>

impl<M> StableAbi for RBoxError_<M> where
    M: __StableAbi, 

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.