Struct DynDynFat

pub struct DynDynFat<B: ?Sized + DynDynBase, P> { /* private fields */ }

A fat pointer to an object that can be downcast via the base trait object B.

Such a pointer will only perform a call to retrieve the DynDynTable of the referenced object once when created. Thereafter, the cached table will be used for trait object metadata lookups. This effectively avoids the overhead of the repeated indirect calls to retrieve the table at the cost of increasing the size of the pointer to the object.

Implementations

impl<B: ?Sized + DynDynBase, P: GetDynDynTable<B>> DynDynFat<B, P>

pub unsafe fn new_unchecked(ptr: P, table: DynDynTable) -> Self

Creates a new fat pointer with the provided pointer and DynDynTable.

Safety

table must refer to the same table as a table that would be returned by calling GetDynDynTable::get_dyn_dyn_table on ptr at the time that this function is called.

pub fn new(ptr: P) -> Self

Creates a new fat pointer wrapping the provided pointer. This will immediately get the pointer’s DynDynTable by calling GetDynDynTable<B>::get_dyn_dyn_table and cache it for future use.

pub fn get_dyn_dyn_table(ptr: &Self) -> DynDynTable

Gets the DynDynTable of the object referenced by a fat pointer without dereferencing it.

pub fn unwrap(ptr: Self) -> P

Unwraps a fat pointer, returning the pointer originally used to construct it.

impl<B: ?Sized + DynDynBase, P: Deref> DynDynFat<B, P>

where P::Target: Unsize<B>,

pub fn deref_fat(ptr: &Self) -> DynDynFat<B, &P::Target>

Dereferences a fat pointer to produce a fat pointer with a reference.

impl<B: ?Sized + DynDynBase, P: DerefMut> DynDynFat<B, P>

where P::Target: Unsize<B>,

pub fn deref_mut_fat(ptr: &mut Self) -> DynDynFat<B, &mut P::Target>

Dereferences a fat pointer to produce a fat pointer with a mutable reference.

impl<B: ?Sized + DynDynBase, P: Clone> DynDynFat<B, P>

pub unsafe fn clone_unchecked(ptr: &Self) -> Self

Clones a fat pointer without verifying that the DynDynTable held by the new fat pointer is applicable to the cloned pointer.

Safety

The caller must guarantee that the result of calling ptr.clone() will dereference to an object having the same concrete type as that pointed to by ptr.

Trait Implementations

impl<B: ?Sized + DynDynBase, P: Deref> AsRef<P> for DynDynFat<B, P>

fn as_ref(&self) -> &P

Converts this type into a shared reference of the (usually inferred) input type.

impl<B: ?Sized + DynDynBase, P: Deref + Clone + GetDynDynTable<B>> Clone for DynDynFat<B, P>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug + ?Sized + DynDynBase, P: Debug> Debug for DynDynFat<B, P>

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

Formats the value using the given formatter.

impl<B: ?Sized + DynDynBase, P: GetDynDynTable<B> + Default> Default for DynDynFat<B, P>

fn default() -> Self

Returns the “default value” for a type.

impl<B: ?Sized + DynDynBase, P: Deref> Deref for DynDynFat<B, P>

type Target = <P as Deref>::Target

The resulting type after dereferencing.

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

Dereferences the value.

impl<B: ?Sized + DynDynBase, P: DerefMut> DerefMut for DynDynFat<B, P>

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

Mutably dereferences the value.

impl<B: ?Sized + DynDynBase, P: Display> Display for DynDynFat<B, P>

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

Formats the value using the given formatter.

impl<'a, B: ?Sized + DynDynBase, P: DowncastUnchecked<'a> + 'a> DowncastUnchecked<'a> for DynDynFat<B, P>

type DowncastResult<D: ?Sized + 'a> = <P as DowncastUnchecked<'a>>::DowncastResult<D>

The result of downcasting this pointer to point to the type D. Note that this type need not have the same outer wrapper as the type implementing DowncastUnchecked, since the result of the downcast may involve coercions and dereferences.

unsafe fn downcast_unchecked<D: ?Sized + Pointee>( self, metadata: <D as Pointee>::Metadata, ) -> Self::DowncastResult<D>

Downcasts this pointer into a new pointer pointing to the same object, but having type D.

impl<B: ?Sized + DynDynBase, P: GetDynDynTable<B>> From<P> for DynDynFat<B, P>

fn from(ptr: P) -> Self

Converts to this type from the input type.

impl<B: ?Sized + DynDynBase, P: GetDynDynTable<B>> GetDynDynTable<B> for DynDynFat<B, P>

type DynTarget = <P as GetDynDynTable<B>>::DynTarget

The actual type that this pointer currently points to. This type is used to allow propagation of auto trait bounds such as Send and Sync in the dyn_dyn_cast! macro.

fn get_dyn_dyn_table(&self) -> DynDynTable

Gets the DynDynTable for the object that this pointer points to.

impl<B: ?Sized + DynDynBase, P: Deref> Hash for DynDynFat<B, P>

where P::Target: Unsize<B> + Hash,

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<B: ?Sized + DynDynBase, P: Deref> Ord for DynDynFat<B, P>

where P::Target: Unsize<B> + Ord,

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<B1: ?Sized + DynDynBase, B2: ?Sized + DynDynBase, P1: Deref, P2: Deref> PartialEq<DynDynFat<B2, P2>> for DynDynFat<B1, P1>

where P1::Target: Unsize<B1> + PartialEq<P2::Target>, P2::Target: Unsize<B2>,

fn eq(&self, other: &DynDynFat<B2, P2>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<B1: ?Sized + DynDynBase, B2: ?Sized + DynDynBase, P1: Deref, P2: Deref> PartialOrd<DynDynFat<B2, P2>> for DynDynFat<B1, P1>

where P1::Target: Unsize<B1> + PartialOrd<P2::Target>, P2::Target: Unsize<B2>,

fn partial_cmp(&self, other: &DynDynFat<B2, P2>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<B: ?Sized + DynDynBase, P: Pointer> Pointer for DynDynFat<B, P>

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

Formats the value using the given formatter.

impl<B: ?Sized + DynDynBase, P: CloneStableDeref + GetDynDynTable<B>> CloneStableDeref for DynDynFat<B, P>

impl<B: ?Sized + DynDynBase, P1: Deref + CoerceUnsized<P2>, P2: Deref> CoerceUnsized<DynDynFat<B, P2>> for DynDynFat<B, P1>

where P1::Target: Unsize<B>, P2::Target: Unsize<B>,

impl<B: ?Sized + DynDynBase, P: Deref + Copy + GetDynDynTable<B>> Copy for DynDynFat<B, P>

where P::Target: Unsize<B>,

impl<B: ?Sized + DynDynBase, P: Deref> Eq for DynDynFat<B, P>

where P::Target: Unsize<B> + Eq,

impl<B: ?Sized + DynDynBase, P: StableDeref> StableDeref for DynDynFat<B, P>