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,UnsyncRBoxError,SendRBoxError};

{
    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::{FromUtf8Error,FromUtf16Error};
    
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: ?Sized>(value: &T) -> Self where
    T: Display + Debug, 

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: ?Sized>(value: &T) -> Self where
    T: Debug, 

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>

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

Formats the value using the given formatter.

impl<M> Display for RBoxError_<M>

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

Formats the value using the given formatter.

impl<M> Error for RBoxError_<M>

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

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

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

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

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

pub fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

pub 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 + Send, Global>> for RBoxError_<UnsyncSend>

pub 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 + 'static + Sync + Send, Global>> for RBoxError_<SyncSend>

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

pub 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<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.

pub const LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

pub const ABI_CONSTS: AbiConsts

const-equivalents of the associated types.