[−][src]Struct abi_stable::std_types::RBoxError_
Ffi-safe version of Box<dyn std::error::Error + 'static>
whose Send + Sync
ness 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>
[src]
pub fn new<T>(value: T) -> Self where
T: ErrorTrait + Send + Sync + 'static,
[src]
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>
[src]
pub fn new<T>(value: T) -> Self where
T: ErrorTrait + Send + 'static,
[src]
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>
[src]
pub fn new<T>(value: T) -> Self where
T: ErrorTrait + 'static,
[src]
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>
[src]
pub fn from_fmt<T: ?Sized>(value: &T) -> Self where
T: Display + Debug,
[src]
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,
[src]
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>
[src]
pub fn to_formatted_error<N>(&self) -> RBoxError_<N>
[src]
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>
[src]
pub fn type_id(&self) -> UTypeId
[src]
Returns the UTypeId
of the error this wraps.
pub fn heap_address(&self) -> usize
[src]
The address of the Box<_>
this wraps
pub fn as_unsync(&self) -> &UnsyncRBoxError
[src]
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
[src]
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>
[src]
pub fn as_send(&self) -> &SendRBoxError
[src]
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
[src]
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>
[src]
pub fn from_box(this: Box<dyn ErrorTrait + Send + Sync + 'static>) -> Self
[src]
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>
[src]
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,
[src]
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 thanT
.
Example
Look at the type level documentation for the example.
pub fn downcast_ref<T>(&self) -> Option<&T> where
T: ErrorTrait + 'static,
[src]
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 thanT
.
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,
[src]
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 thanT
.
Example
Look at the type level documentation for the example. the example.
impl RBoxError_<UnsyncSend>
[src]
pub fn from_box(this: Box<dyn ErrorTrait + Send + 'static>) -> Self
[src]
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>
[src]
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,
[src]
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 thanT
.
Example
Look at the type level documentation for the example.
pub fn downcast_ref<T>(&self) -> Option<&T> where
T: ErrorTrait + 'static,
[src]
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 thanT
.
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,
[src]
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 thanT
.
Example
Look at the type level documentation for the example. the example.
impl RBoxError_<UnsyncUnsend>
[src]
pub fn from_box(this: Box<dyn ErrorTrait + 'static>) -> Self
[src]
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>
[src]
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,
[src]
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 thanT
.
Example
Look at the type level documentation for the example.
pub fn downcast_ref<T>(&self) -> Option<&T> where
T: ErrorTrait + 'static,
[src]
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 thanT
.
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,
[src]
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 thanT
.
Example
Look at the type level documentation for the example. the example.
Trait Implementations
impl<M> Debug for RBoxError_<M>
[src]
impl<M> Display for RBoxError_<M>
[src]
impl<M> Error for RBoxError_<M>
[src]
pub fn source(&self) -> Option<&(dyn Error + 'static)>
1.30.0[src]
pub fn backtrace(&self) -> Option<&Backtrace>
[src]
pub fn description(&self) -> &str
1.0.0[src]
pub fn cause(&self) -> Option<&dyn Error>
1.0.0[src]
impl From<Box<dyn Error + 'static + Send + Sync, Global>> for RBoxError_<SyncSend>
[src]
pub fn from(
this: Box<dyn ErrorTrait + Send + Sync + 'static>
) -> RBoxError_<SyncSend>
[src]
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 + Send, Global>> for RBoxError_<UnsyncSend>
[src]
pub fn from(
this: Box<dyn ErrorTrait + Send + 'static>
) -> RBoxError_<UnsyncSend>
[src]
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, Global>> for RBoxError_<UnsyncUnsend>
[src]
pub fn from(this: Box<dyn ErrorTrait + 'static>) -> RBoxError_<UnsyncUnsend>
[src]
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,
[src]
M: __StableAbi,
type StaticEquivalent = _static_RBoxError_<__GetStaticEquivalent<M>>
impl<M> StableAbi for RBoxError_<M> where
M: __StableAbi,
[src]
M: __StableAbi,
type IsNonZeroType = False
Whether this type has a single invalid bit-pattern. Read more
pub const LAYOUT: &'static TypeLayout
[src]
pub const ABI_CONSTS: AbiConsts
[src]
Auto Trait Implementations
impl<M> RefUnwindSafe for RBoxError_<M> where
M: RefUnwindSafe,
M: RefUnwindSafe,
impl<M> Send for RBoxError_<M> where
M: Send,
M: Send,
impl<M> Sync for RBoxError_<M> where
M: Sync,
M: Sync,
impl<M> Unpin for RBoxError_<M> where
M: Unpin,
M: Unpin,
impl<M> UnwindSafe for RBoxError_<M> where
M: UnwindSafe,
M: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T> GetWithMetadata for T
[src]
type ForSelf = WithMetadata_<T, T>
This is always WithMetadata_<Self, Self>
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> SelfOps for T where
T: ?Sized,
[src]
T: ?Sized,
pub const T: PhantomData<fn() -> Self>
[src]
pub const T_D: PhantomData<Self>
[src]
pub fn assert_ty(self, _other: PhantomData<fn() -> Self>) -> Self
[src]
pub fn assert_ty_ref(&self, _other: PhantomData<fn() -> Self>) -> &Self
[src]
pub fn assert_ty_mut(&mut self, _other: PhantomData<fn() -> Self>) -> &mut Self
[src]
pub fn ty_(&self) -> PhantomData<fn() -> Self>
[src]
pub fn ty_d(&self) -> PhantomData<Self>
[src]
pub fn ty_inv(&self) -> PhantomData<fn(Self) -> Self>
[src]
pub fn ty_inv_ref(&self) -> PhantomData<Cell<&Self>>
[src]
pub fn eq_id(&self, other: &Self) -> bool
[src]
pub fn piped<F, U>(self, f: F) -> U where
F: FnOnce(Self) -> U,
[src]
F: FnOnce(Self) -> U,
pub fn piped_ref<'a, F, U>(&'a self, f: F) -> U where
F: FnOnce(&'a Self) -> U,
[src]
F: FnOnce(&'a Self) -> U,
pub fn piped_mut<'a, F, U>(&'a mut self, f: F) -> U where
F: FnOnce(&'a mut Self) -> U,
[src]
F: FnOnce(&'a mut Self) -> U,
pub fn mutated<F>(self, f: F) -> Self where
F: FnOnce(&mut Self),
[src]
F: FnOnce(&mut Self),
pub fn observe<F>(self, f: F) -> Self where
F: FnOnce(&Self),
[src]
F: FnOnce(&Self),
pub fn into_<T>(self, PhantomData<fn() -> T>) -> T where
Self: Into<T>,
[src]
Self: Into<T>,
pub fn as_ref_<T>(&self) -> &T where
Self: AsRef<T>,
T: ?Sized,
[src]
Self: AsRef<T>,
T: ?Sized,
pub fn as_mut_<T>(&mut self) -> &mut T where
Self: AsMut<T>,
T: ?Sized,
[src]
Self: AsMut<T>,
T: ?Sized,
pub fn drop_(self)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<This> TransmuteElement for This where
This: ?Sized,
[src]
This: ?Sized,
pub unsafe fn transmute_element<T>(self) -> Self::TransmutedPtr where
Self: CanTransmuteElement<T>,
Self::Target: Sized,
[src]
Self: CanTransmuteElement<T>,
Self::Target: Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The error type returned when the conversion fails.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> TypeIdentity for T where
T: ?Sized,
[src]
T: ?Sized,
type Type = T
The same type as Self. Read more
pub fn into_type_val(self) -> Self::Type where
Self::Type: Sized,
[src]
Self::Type: Sized,
pub fn into_type_ref(&self) -> &Self::Type
[src]
pub fn into_type_mut(&mut self) -> &mut Self::Type
[src]
pub fn into_type_box(self: Box<Self, Global>) -> Box<Self::Type, Global>
[src]
pub fn into_type_arc(this: Arc<Self>) -> Arc<Self::Type>
[src]
pub fn into_type_rc(this: Rc<Self>) -> Rc<Self::Type>
[src]
pub fn from_type_val(this: Self::Type) -> Self where
Self::Type: Sized,
[src]
Self::Type: Sized,