Struct Ref 

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

A shared reference to a tinydyn trait object.

Ref<dyn Trait> can call the &self methods of Trait through its Deref impl. It can also be freely cloned and copied like a &dyn Trait.

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

• that would create a double pointer.

Implementations

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

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

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

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

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

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

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

Removes the Send bound from Trait, if any.

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

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

Removes the Sync bound from Trait, if any.

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, Trait: ?Sized + DynTrait + 'a> Deref for Ref<'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> 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: ?Sized + DynTrait + 'a> Copy for Ref<'a, Trait>

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

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

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

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