Struct RefMut 

pub struct RefMut<'a, Trait: ?Sized + DynTrait> { /* private fields */ }

A mutable reference to a tinydyn trait object.

RefMut<dyn Trait> can call the &self and &mut self methods of Trait through its Deref impl.

Like &mut dyn Trait, this cannot be cloned or copied. It can, however, be reborrowed.

Prefer passing this around rather than calling deref_mut and passing around that reference

• that would create a double pointer.

Implementations

impl<'a, Trait: ?Sized + DynTrait> RefMut<'a, Trait>

pub fn new<U>(r: &'a mut U) -> Self

where <<Trait as DynTrait>::Plain as PlainDyn>::LocalNewtype<U>: Implements<Trait>,

Upcasts this &mut U into a RefMut<dyn Trait> so long as U: Trait.

This builds a tinydyn vtable and references it in the returned RefMut.

impl<'a, Trait: ?Sized + DynTrait + 'a> RefMut<'a, Trait>

pub fn as_ref<'b>(&'b self) -> Ref<'b, Trait>

Reborrow as a shared Ref with a smaller lifetime.

Since a RefMut isn’t Copy, this is needed to pass to a function expecting a Ref and regain access to the underlying RefMut after it’s done.

pub fn as_mut<'b>(&'b mut self) -> RefMut<'b, Trait>

where 'a: 'b,

Reborrow as a RefMut with a smaller lifetime.

Since a RefMut isn’t Copy, this is needed to pass to a function expecting a RefMut and regain access to the underlying RefMut after it’s done.

pub fn as_downcast_ptr<T>(&mut self) -> NonNull<T>

Downcasts this RefMut into a raw pointer of concrete type.

The pointer can accessed soundly for the lifetime of &mut self so long as self was constructed from a &mut T.

pub fn metadata(&self) -> <Trait::Plain as PlainDyn>::Metadata

Gets the pointer metadata for this trait object.

impl<'a, Trait: ?Sized + DynTrait + Send + 'a> RefMut<'a, Trait>

pub fn remove_send(self) -> RefMut<'a, Trait::RemoveSend>

Removes the Send bound from Trait, if any.

impl<'a, Trait: ?Sized + DynTrait + Sync + 'a> RefMut<'a, Trait>

pub fn remove_sync(self) -> RefMut<'a, Trait::RemoveSync>

Removes the Sync bound from Trait, if any.

Trait Implementations

impl<'a, Trait: ?Sized + DynTrait + 'a> Deref for RefMut<'a, Trait>

fn deref(&self) -> &Self::Target

It’s not recommended to hold onto the result of this deref, as it creates a double reference.

type Target = DynTarget<Trait>

The resulting type after dereferencing.

impl<'a, Trait: ?Sized + DynTrait + 'a> DerefMut for RefMut<'a, Trait>

fn deref_mut(&mut self) -> &mut Self::Target

It’s not recommended to hold onto the result of this deref, as it creates a double reference.

impl<'a, Trait: ?Sized + DynTrait> From<RefMut<'a, Trait>> for Ref<'a, Trait>

fn from(value: RefMut<'a, Trait>) -> Self

Converts to this type from the input type.

impl<'a, Trait> Send for RefMut<'a, Trait>

where Trait: ?Sized + DynTrait, &'a mut Trait: Send,

impl<'a, Trait> Sync for RefMut<'a, Trait>

where Trait: ?Sized + DynTrait, &'a mut Trait: Sync,