Struct abi_stable::sabi_types::RMut

source ·
pub struct RMut<'a, T> { /* private fields */ }
Expand description

Equivalent to &'a mut T, which allows a few more operations without causing Undefined Behavior.

Purpose

This type is used as the &mut self parameter in abi_stable trait objects because it can be soundly transmuted to point to other smaller but compatible types, then back to the original type.

This crate is tested with miri to detect bugs in unsafe code, which implements the Stacked Borrows model. Because that model forbids &mut T to &mut () to &mut T transmutes (when T isn’t zero-sized), it required defining RMut to allow a mutable-reference-like type that can be transmuted.

Example

This example demonstrates how a simple &mut dyn Any-like type can be implemented.

use abi_stable::{marker_type::ErasedObject, std_types::UTypeId, RMut};

fn main() {
    let mut value = WithTypeId::new(5u32);
    let mut clone = value.clone();
    let mut erased = value.erase();

    assert_eq!(WithTypeId::downcast::<i32>(erased.reborrow()), None);
    assert_eq!(WithTypeId::downcast::<bool>(erased.reborrow()), None);
    assert_eq!(
        WithTypeId::downcast::<u32>(erased.reborrow()),
        Some(&mut clone)
    );
}

// `#[repr(C))]` with a trailing `T` field is required for soundly transmuting from
// `RMut<'a, WithTypeId<T>>` to `RMut<'a, WithTypeId<ErasedObject>>`.
#[repr(C)]
#[derive(Debug, PartialEq, Clone)]
struct WithTypeId<T> {
    type_id: UTypeId,
    value: T,
}

impl<T> WithTypeId<T> {
    pub fn new(value: T) -> Self
    where
        T: 'static,
    {
        Self {
            type_id: UTypeId::new::<T>(),
            value,
        }
    }

    pub fn erase(&mut self) -> RMut<'_, WithTypeId<ErasedObject>> {
        unsafe { RMut::new(self).transmute::<WithTypeId<ErasedObject>>() }
    }
}

impl WithTypeId<ErasedObject> {
    pub fn downcast<T>(this: RMut<'_, Self>) -> Option<&mut WithTypeId<T>>
    where
        T: 'static,
    {
        if this.get().type_id == UTypeId::new::<T>() {
            // safety: we checked that type parameter was `T`
            unsafe { Some(this.transmute_into_mut::<WithTypeId<T>>()) }
        } else {
            None
        }
    }
}

Type Prefix

A type parameter U is considered a prefix of T in all of these cases:

  • U is a zero-sized type with an alignment equal or lower than T

  • U is a #[repr(transparent)] wrapper over T

  • U and T are both #[repr(C)] structs, in which T starts with the fields of U in the same order, and U has an alignment equal to or lower than T.

Please note that it can be unsound to transmute a non-local type if it has private fields, since it may assume it was constructed in a particular way.

Implementations§

source§

impl<'a, T> RMut<'a, T>

source

pub fn new(ref_: &'a mut T) -> Self

Constructs this RMut from a mutable reference

Example
use abi_stable::RMut;

let mut foo = 3;
let mut rmut = RMut::new(&mut foo);
*rmut.get_mut() += 10;

assert_eq!(*rmut.get(), 13);
assert_eq!(foo, 13);
source

pub const unsafe fn from_raw(ref_: *mut T) -> Self
where T: 'a,

Constructs this RMut from a raw pointer.

Safety

You must ensure that the raw pointer is valid for the 'a lifetime, points to a fully initialized and aligned T, and that this is the only active pointer to that value.

Example
use abi_stable::RMut;

let mut foo = 3u32;
// safety:
// `&mut foo` is casted to a pointer to a compatible type (`u32` to `i32`),
// `rmut` is only used for the lifetime of foo,
// and is the only active pointer to `foo` while it's used.
let mut rmut = unsafe { RMut::from_raw((&mut foo) as *mut u32 as *mut i32) };
*rmut.get_mut() -= 4;

assert_eq!(*rmut.get(), -1);
assert_eq!(foo, !0);
source

pub fn reborrow(&mut self) -> RMut<'_, T>

Reborrows this RMut, with a shorter lifetime.

This allows passing an RMut to functions multiple times, but with a shorter lifetime argument.

Example
use abi_stable::RMut;

let mut foo = 3;
let mut rmut = RMut::new(&mut foo);

assert_eq!(mutate(rmut.reborrow()), 6);
assert_eq!(mutate(rmut.reborrow()), 12);
assert_eq!(mutate(rmut.reborrow()), 24);

// last use of rmut, so it can be moved instead of being reborrowed.
assert_eq!(mutate(rmut), 48);

fn mutate(mut rmut: RMut<'_, u32>) -> u32 {
    *rmut.get_mut() *= 2;
    rmut.get_copy()
}
source

pub const fn get(&self) -> &T

Reborrows this RMut into a shared reference.

Note that because the reference reborrows this RMut<'a, T> its lifetime argument is strictly smaller. To turn an RMut<'a, T> into a &'a T (with the same lifetime argument) you can use into_ref.

Example
use abi_stable::RMut;

let mut val = 89;
let rmut = RMut::new(&mut val);

assert_eq!(rmut.get(), &89);
Lifetimes

This demonstrates when into_ref works, but get doesn’t.

fn stuff<'a>(x: RMut<'a, i32>) -> &'a i32 {
    x.into_ref()
}

This doesn’t compile, because get reborrows foo.

fn stuff<'a>(foo: RMut<'a, i32>) -> &'a i32 {
    foo.get()
}
source

pub const fn get_copy(&self) -> T
where T: Copy,

Copies the value that this RMut points to.

Example
use abi_stable::RMut;

let mut val = "hello";
let mut rmut = RMut::new(&mut val);

*rmut.get_mut() = "world";

assert_eq!(rmut.get_copy(), "world");
source

pub const fn into_ref(self) -> &'a T

Converts this RMut<'a, T> into a &'a T

Example
use abi_stable::RMut;

let mut val = 89;

assert_eq!(mutate(RMut::new(&mut val)), &44);

fn mutate(mut rmut: RMut<'_, u32>) -> &u32 {
    *rmut.get_mut() /= 2;
    rmut.into_ref()
}
source

pub fn get_mut(&mut self) -> &mut T

Reborrows this RMut into a mutable reference.

Note that because the mutable reference reborrows this RMut<'a, T> its lifetime argument is strictly smaller. To turn an RMut<'a, T> into a &'a mut T (with the same lifetime argument) you can use into_mut.

Example
use abi_stable::RMut;

let mut val = 89;
let mut rmut = RMut::new(&mut val);

assert_eq!(rmut.get_mut(), &mut 89);

*rmut.get_mut() += 10;

assert_eq!(rmut.get_mut(), &mut 99);
Lifetimes

This demonstrates when into_mut works, but get_mut doesn’t.

fn stuff<'a>(x: RMut<'a, i32>) -> &'a mut i32 {
    x.into_mut()
}

This doesn’t compile, because get_mut reborrows foo.

fn stuff<'a>(mut foo: RMut<'a, i32>) -> &'a mut i32 {
    foo.get_mut()
}
source

pub fn into_mut(self) -> &'a mut T

Converts this RMut<'a, T> into a &'a mut T

Example
use abi_stable::RMut;

let mut val = 13;

let rmut = RMut::new(&mut val);

assert_eq!(rmut.get(), &13);

*rmut.into_mut() += 8;

assert_eq!(val, 21);
source

pub const fn as_ptr(&self) -> *const T

Reborrows this RMut as a const raw pointer.

Example
use abi_stable::RMut;

let mut val = 34;
let rmut = RMut::new(&mut val);

unsafe {
    assert_eq!(*rmut.as_ptr(), 34);
}
source

pub fn as_mut_ptr(&mut self) -> *mut T

Reborrows this RMut as a mutable raw pointer.

Example
use abi_stable::RMut;

let mut val = 34;
let mut rmut = RMut::new(&mut val);

unsafe {
    rmut.as_mut_ptr().write(7);

    *rmut.as_mut_ptr() *= 2;

    assert_eq!(val, 14);
}
source

pub const fn into_raw(self) -> *mut T

Converts this RMut<'a, T> into a *mut T

Example
use abi_stable::RMut;

let mut val = 89;
let rmut = RMut::new(&mut val);

unsafe {
    let ptr = rmut.into_raw();

    ptr.write(27);

    *ptr += 2;

    assert_eq!(val, 29);
}
source

pub const fn transmute_into_raw<U>(self) -> *mut U

Transmutes this RMut<'a, T> to a *mut U.

Example
use abi_stable::RMut;

let mut val = Direction::Up;
let rmut = RMut::new(&mut val);

assert_eq!(rmut.get(), &Direction::Up);

let ptr = rmut.transmute_into_raw::<u8>();

unsafe {
    assert_eq!(*ptr, 2);
    *ptr = 3;
}

assert_eq!(val, Direction::Down);

#[repr(u8)]
#[derive(Debug, PartialEq)]
enum Direction {
    Left = 0,
    Right = 1,
    Up = 2,
    Down = 3,
}
source

pub unsafe fn transmute_into_mut<U>(self) -> &'a mut U
where U: 'a,

Transmutes this RMut<'a, T> to a &'a mut U.

Safety

Either of these must be the case:

Example
use abi_stable::RMut;

let mut val = 13u8;
let rmut = RMut::new(&mut val);

assert_eq!(rmut.get(), &13);

unsafe {
    *rmut.transmute_into_mut::<i8>() = -1;
}

assert_eq!(val, 255);
source

pub const unsafe fn transmute<U>(self) -> RMut<'a, U>
where U: 'a,

Transmutes this RMut<'a, T> to a RMut<'a,U>.

Safety

Either of these must be the case:

Example
use abi_stable::RMut;

let mut val: [u32; 3] = [2, 3, 0];
let mut rmut = RMut::new(&mut val);

unsafe {
    // safety:
    // it's sound to transmute mutable references of arrays into shorter arrays.
    //
    // The `.reborrow()` prevents the `rmut` from being consumed.
    compute_next(rmut.reborrow().transmute::<[u32; 2]>());
    assert_eq!(rmut.get_copy(), [3, 5, 0]);

    compute_next(rmut.reborrow().transmute::<[u32; 2]>());
    assert_eq!(rmut.get_copy(), [5, 8, 0]);

    // last use of `rmut`, so no need to reborrow
    compute_next(rmut.transmute::<[u32; 2]>());
}

assert_eq!(val, [8, 13, 0]);

fn compute_next(rmut: RMut<'_, [u32; 2]>) {
    let [v0, v1] = rmut.into_mut();
    let next = *v0 + *v1;
    *v0 = std::mem::replace(v1, next);
}
source

pub const fn as_rref<'r>(&'r self) -> RRef<'r, T>

Reborrows this RMut<'a, T> into an RRef<'_, T>

Example
use abi_stable::{RMut, RRef};

let mut val = 77;
let rmut = RMut::new(&mut val);

for _ in 0..10 {
    assertion(rmut.as_rref());
}

fn assertion(rref: RRef<'_, u32>) {
    assert_eq!(rref.get_copy(), 77);
}
source

pub const fn into_rref(self) -> RRef<'a, T>

Converts this RMut<'a, T> to an RRef<'_, T>

Example
use abi_stable::{RMut, RRef};

let mut val = 0;
let rmut = RMut::new(&mut val);

assertion(rmut.into_rref());

fn assertion(rref: RRef<'_, u32>) {
    assert_eq!(rref.get_copy(), 0);
}

Trait Implementations§

source§

impl<'a, T> AsMutPtr for RMut<'a, T>

source§

fn as_mut_ptr(&mut self) -> *mut T

Gets a mutable raw pointer to the value that this points to.
source§

fn as_rmut(&mut self) -> RMut<'_, T>

Converts this pointer to an RRef.
source§

impl<'a, T> AsPtr for RMut<'a, T>

source§

fn as_ptr(&self) -> *const T

Gets a const raw pointer to the value that this points to.
source§

fn as_rref(&self) -> RRef<'_, T>

Converts this pointer to an RRef.
source§

impl<'a, T, U> CanTransmuteElement<U> for RMut<'a, T>
where U: 'a,

§

type TransmutedPtr = RMut<'a, U>

The type of the pointer after it’s element type has been changed.
source§

unsafe fn transmute_element_(self) -> Self::TransmutedPtr

Transmutes the element type of this pointer.. Read more
source§

impl<'a, T> Debug for RMut<'a, T>
where T: Debug,

source§

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

Formats the value using the given formatter. Read more
source§

impl<'a, T> Display for RMut<'a, T>
where T: Display,

source§

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

Formats the value using the given formatter. Read more
source§

impl<'a, T> GetPointerKind for RMut<'a, T>

§

type Kind = PK_MutReference

The kind of the pointer. Read more
§

type PtrTarget = T

What this pointer points to. Read more
source§

const KIND: PointerKind = <Self::Kind as PointerKindVariant>::VALUE

The value-level version of the Kind associated type. Read more
source§

impl<'a, T> GetStaticEquivalent_ for RMut<'a, T>
where T: __StableAbi + 'a,

§

type StaticEquivalent = _static_RMut<'static, <T as GetStaticEquivalent_>::StaticEquivalent>

The 'static equivalent of Self
source§

impl<'a, T> Hash for RMut<'a, T>
where T: Hash,

source§

fn hash<H>(&self, state: &mut H)
where H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl<'a, T> Ord for RMut<'a, T>
where T: Ord,

source§

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl<'a, T> PartialEq for RMut<'a, T>
where T: PartialEq,

source§

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a, T> PartialOrd for RMut<'a, T>
where T: PartialOrd,

source§

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl<'a, T> StableAbi for RMut<'a, T>
where T: __StableAbi + 'a,

§

type IsNonZeroType = <NonNull<T> as StableAbi>::IsNonZeroType

Whether this type has a single invalid bit-pattern. Read more
source§

const LAYOUT: &'static TypeLayout = _

The layout of the type provided by implementors.
source§

const ABI_CONSTS: AbiConsts = _

const-equivalents of the associated types.
source§

impl<'a, T> Eq for RMut<'a, T>
where T: Eq,

source§

impl<'a, T> Send for RMut<'a, T>
where &'a T: Send,

source§

impl<'a, T> Sync for RMut<'a, T>
where &'a T: Sync,

Auto Trait Implementations§

§

impl<'a, T> RefUnwindSafe for RMut<'a, T>
where T: RefUnwindSafe,

§

impl<'a, T> Unpin for RMut<'a, T>

§

impl<'a, T> !UnwindSafe for RMut<'a, T>

Blanket Implementations§

source§

impl<T> AlignerFor<1> for T

§

type Aligner = AlignTo1<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<1024> for T

§

type Aligner = AlignTo1024<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<128> for T

§

type Aligner = AlignTo128<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<16> for T

§

type Aligner = AlignTo16<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<16384> for T

§

type Aligner = AlignTo16384<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<2> for T

§

type Aligner = AlignTo2<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<2048> for T

§

type Aligner = AlignTo2048<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<256> for T

§

type Aligner = AlignTo256<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<32> for T

§

type Aligner = AlignTo32<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<32768> for T

§

type Aligner = AlignTo32768<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<4> for T

§

type Aligner = AlignTo4<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<4096> for T

§

type Aligner = AlignTo4096<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<512> for T

§

type Aligner = AlignTo512<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<64> for T

§

type Aligner = AlignTo64<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<8> for T

§

type Aligner = AlignTo8<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> AlignerFor<8192> for T

§

type Aligner = AlignTo8192<T>

The AlignTo* type which aligns Self to ALIGNMENT.
source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<S> ROExtAcc for S

source§

fn f_get<F>(&self, offset: FieldOffset<S, F, Aligned>) -> &F

Gets a reference to a field, determined by offset. Read more
source§

fn f_get_mut<F>(&mut self, offset: FieldOffset<S, F, Aligned>) -> &mut F

Gets a muatble reference to a field, determined by offset. Read more
source§

fn f_get_ptr<F, A>(&self, offset: FieldOffset<S, F, A>) -> *const F

Gets a const pointer to a field, the field is determined by offset. Read more
source§

fn f_get_mut_ptr<F, A>(&mut self, offset: FieldOffset<S, F, A>) -> *mut F

Gets a mutable pointer to a field, determined by offset. Read more
source§

impl<S> ROExtOps<Aligned> for S

source§

fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Aligned>, value: F) -> F

Replaces a field (determined by offset) with value, returning the previous value of the field. Read more
source§

fn f_swap<F>(&mut self, offset: FieldOffset<S, F, Aligned>, right: &mut S)

Swaps a field (determined by offset) with the same field in right. Read more
source§

fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Aligned>) -> F
where F: Copy,

Gets a copy of a field (determined by offset). The field is determined by offset. Read more
source§

impl<S> ROExtOps<Unaligned> for S

source§

fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, value: F) -> F

Replaces a field (determined by offset) with value, returning the previous value of the field. Read more
source§

fn f_swap<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, right: &mut S)

Swaps a field (determined by offset) with the same field in right. Read more
source§

fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Unaligned>) -> F
where F: Copy,

Gets a copy of a field (determined by offset). The field is determined by offset. Read more
source§

impl<T> SelfOps for T
where T: ?Sized,

source§

fn eq_id(&self, other: &Self) -> bool

Compares the address of self with the address of other. Read more
source§

fn piped<F, U>(self, f: F) -> U
where F: FnOnce(Self) -> U, Self: Sized,

Emulates the pipeline operator, allowing method syntax in more places. Read more
source§

fn piped_ref<'a, F, U>(&'a self, f: F) -> U
where F: FnOnce(&'a Self) -> U,

The same as piped except that the function takes &Self Useful for functions that take &Self instead of Self. Read more
source§

fn piped_mut<'a, F, U>(&'a mut self, f: F) -> U
where F: FnOnce(&'a mut Self) -> U,

The same as piped, except that the function takes &mut Self. Useful for functions that take &mut Self instead of Self.
source§

fn mutated<F>(self, f: F) -> Self
where F: FnOnce(&mut Self), Self: Sized,

Mutates self using a closure taking self by mutable reference, passing it along the method chain. Read more
source§

fn observe<F>(self, f: F) -> Self
where F: FnOnce(&Self), Self: Sized,

Observes the value of self, passing it along unmodified. Useful in long method chains. Read more
source§

fn into_<T>(self) -> T
where Self: Into<T>,

Performs a conversion with Into. using the turbofish .into_::<_>() syntax. Read more
source§

fn as_ref_<T>(&self) -> &T
where Self: AsRef<T>, T: ?Sized,

Performs a reference to reference conversion with AsRef, using the turbofish .as_ref_::<_>() syntax. Read more
source§

fn as_mut_<T>(&mut self) -> &mut T
where Self: AsMut<T>, T: ?Sized,

Performs a mutable reference to mutable reference conversion with AsMut, using the turbofish .as_mut_::<_>() syntax. Read more
source§

fn drop_(self)
where Self: Sized,

Drops self using method notation. Alternative to std::mem::drop. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<This> TransmuteElement for This
where This: ?Sized,

source§

unsafe fn transmute_element<T>( self ) -> <Self as CanTransmuteElement<T>>::TransmutedPtr
where Self: CanTransmuteElement<T>,

Transmutes the element type of this pointer.. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> TypeIdentity for T
where T: ?Sized,

§

type Type = T

This is always Self.
source§

fn into_type(self) -> Self::Type
where Self: Sized, Self::Type: Sized,

Converts a value back to the original type.
source§

fn as_type(&self) -> &Self::Type

Converts a reference back to the original type.
source§

fn as_type_mut(&mut self) -> &mut Self::Type

Converts a mutable reference back to the original type.
source§

fn into_type_box(self: Box<Self>) -> Box<Self::Type>

Converts a box back to the original type.
source§

fn into_type_arc(this: Arc<Self>) -> Arc<Self::Type>

Converts an Arc back to the original type. Read more
source§

fn into_type_rc(this: Rc<Self>) -> Rc<Self::Type>

Converts an Rc back to the original type. Read more
source§

fn from_type(this: Self::Type) -> Self
where Self: Sized, Self::Type: Sized,

Converts a value back to the original type.
source§

fn from_type_ref(this: &Self::Type) -> &Self

Converts a reference back to the original type.
source§

fn from_type_mut(this: &mut Self::Type) -> &mut Self

Converts a mutable reference back to the original type.
source§

fn from_type_box(this: Box<Self::Type>) -> Box<Self>

Converts a box back to the original type.
source§

fn from_type_arc(this: Arc<Self::Type>) -> Arc<Self>

Converts an Arc back to the original type.
source§

fn from_type_rc(this: Rc<Self::Type>) -> Rc<Self>

Converts an Rc back to the original type.