Struct stabby::DynRef

#[repr(C)]
pub struct DynRef<'a, Vt>
where
    Vt: 'static,
{ /* private fields */ }

A stable &'a dyn Traits

Implementations

impl<'a, Vt> DynRef<'a, Vt>

where Vt: 'static,

pub const fn has_optimal_layout() -> bool

Returns true if the layout for DynRef is smaller or equal to that Rust would have generated for it.

impl<'a, Vt> DynRef<'a, Vt>

where Vt: Copy + 'a,

pub const fn ptr(&self) -> &()

Access the data pointer.

pub const fn vtable(&self) -> &Vt

Access the vtable.

pub fn into_super<Super>(self) -> Super

where DynRef<'a, Vt>: IntoSuperTrait<Super>,

Allows casting a dyn A + B into dyn A.

Note that you can only remove the outermost (rightmost in dyn syntax) trait at a time, except Send and Sync that may both be kept, or both be removed.

pub unsafe fn downcast<T>(&self) -> Option<&T>

where Vt: PartialEq + IConstConstructor<'a, T>,

Downcasts the reference based on vtable equality.

This implies that this downcast will always yield None when attempting to downcast values constructed accross an FFI.

Safety

This may have false positives if all of the following applies:

• self was built from &U, within the same FFI-boundary,
• T and U have identical implementations for all methods of the vtable,
• the compiler chose to merge these implementations, making T and U share their function pointers.

While all of these factors aligning is unlikely, you should be aware of this if you plan on using methods of T that wouldn’t be valid for U.

pub fn stable_downcast<T, Path>(&self) -> Option<&T>

where T: IStable, Vt: TransitiveDeref<StabbyVtableAny, Path>,

Downcasts the reference based on its reflection report.

Trait Implementations

impl<StabbyVtProvider, StabbyTransitiveDerefN> AnyDyn<StabbyTransitiveDerefN> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableAny, StabbyTransitiveDerefN> + Copy,

extern "C" fn report(&self) -> &'static TypeReport

An stabby-generated item for Any

extern "C" fn id(&self) -> u64

An stabby-generated item for Any

impl<StabbyVtProvider, StabbyTransitiveDerefN, O> Call0Dyn<StabbyTransitiveDerefN, O> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCall0<O>, StabbyTransitiveDerefN> + Copy,

extern "C" fn call(&self) -> O

An stabby-generated item for Call0

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0> Call1Dyn<StabbyTransitiveDerefN, O, I0> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCall1<O, I0>, StabbyTransitiveDerefN> + Copy,

extern "C" fn call(&self, _0: I0) -> O

An stabby-generated item for Call1

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1> Call2Dyn<StabbyTransitiveDerefN, O, I0, I1> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCall2<O, I0, I1>, StabbyTransitiveDerefN> + Copy,

extern "C" fn call(&self, _0: I0, _1: I1) -> O

An stabby-generated item for Call2

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2> Call3Dyn<StabbyTransitiveDerefN, O, I0, I1, I2> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCall3<O, I0, I1, I2>, StabbyTransitiveDerefN> + Copy,

extern "C" fn call(&self, _0: I0, _1: I1, _2: I2) -> O

An stabby-generated item for Call3

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3> Call4Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCall4<O, I0, I1, I2, I3>, StabbyTransitiveDerefN> + Copy,

extern "C" fn call(&self, _0: I0, _1: I1, _2: I2, _3: I3) -> O

An stabby-generated item for Call4

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4> Call5Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCall5<O, I0, I1, I2, I3, I4>, StabbyTransitiveDerefN> + Copy,

extern "C" fn call(&self, _0: I0, _1: I1, _2: I2, _3: I3, _4: I4) -> O

An stabby-generated item for Call5

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5> Call6Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCall6<O, I0, I1, I2, I3, I4, I5>, StabbyTransitiveDerefN> + Copy,

extern "C" fn call( &self, _0: I0, _1: I1, _2: I2, _3: I3, _4: I4, _5: I5 ) -> O

An stabby-generated item for Call6

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6> Call7Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCall7<O, I0, I1, I2, I3, I4, I5, I6>, StabbyTransitiveDerefN> + Copy,

extern "C" fn call( &self, _0: I0, _1: I1, _2: I2, _3: I3, _4: I4, _5: I5, _6: I6 ) -> O

An stabby-generated item for Call7

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7> Call8Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCall8<O, I0, I1, I2, I3, I4, I5, I6, I7>, StabbyTransitiveDerefN> + Copy,

extern "C" fn call( &self, _0: I0, _1: I1, _2: I2, _3: I3, _4: I4, _5: I5, _6: I6, _7: I7 ) -> O

An stabby-generated item for Call8

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7, I8> Call9Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7, I8> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCall9<O, I0, I1, I2, I3, I4, I5, I6, I7, I8>, StabbyTransitiveDerefN> + Copy,

extern "C" fn call( &self, _0: I0, _1: I1, _2: I2, _3: I3, _4: I4, _5: I5, _6: I6, _7: I7, _8: I8 ) -> O

An stabby-generated item for Call9

impl<'a, Vt> Clone for DynRef<'a, Vt>

where Vt: Clone + 'static,

fn clone(&self) -> DynRef<'a, Vt>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T, Vt> From<&'a T> for DynRef<'a, Vt>

where Vt: Copy + IConstConstructor<'a, T>,

fn from(value: &'a T) -> DynRef<'a, Vt>

Converts to this type from the input type.

impl<StabbyVtProvider, StabbyTransitiveDerefN, _stabby_unselfed_0> FutureDyn<StabbyTransitiveDerefN, _stabby_unselfed_0> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableFuture<_stabby_unselfed_0>, StabbyTransitiveDerefN> + Copy, _stabby_unselfed_0: IDeterminantProvider<()>,

type Output = _stabby_unselfed_0

An stabby-generated item for Future

impl<'a, Vt> IStable for DynRef<'a, Vt>

where Vt: 'static, Struct<FieldPair<FieldPair<&'a (), &'a Vt>, PhantomData<*mut ()>>>: IStable, &'a (): IStable, &'a Vt: IStable, PhantomData<*mut ()>: IStable,

type ForbiddenValues = <Struct<FieldPair<FieldPair<&'a (), &'a Vt>, PhantomData<*mut ()>>> as IStable>::ForbiddenValues

The values that the annotated type cannot occupy.

type UnusedBits = <Struct<FieldPair<FieldPair<&'a (), &'a Vt>, PhantomData<*mut ()>>> as IStable>::UnusedBits

The padding bits in the annotated types

type Size = <Struct<FieldPair<FieldPair<&'a (), &'a Vt>, PhantomData<*mut ()>>> as IStable>::Size

The size of the annotated type in bytes.

type Align = <Struct<FieldPair<FieldPair<&'a (), &'a Vt>, PhantomData<*mut ()>>> as IStable>::Align

The alignment of the annotated type in bytes.

type HasExactlyOneNiche = <Struct<FieldPair<FieldPair<&'a (), &'a Vt>, PhantomData<*mut ()>>> as IStable>::HasExactlyOneNiche

Allows the detection of whether or not core::option::Options are stable:

type ContainsIndirections = <Struct<FieldPair<FieldPair<&'a (), &'a Vt>, PhantomData<*mut ()>>> as IStable>::ContainsIndirections

Whether or not the type contains indirections (pointers, indices in independent data-structures…)

const REPORT: &'static TypeReport = _

A compile-time generated report of the fields of the type, allowing for compatibility inspection.

const ID: u64 = _

A stable (and ideally unique) identifier for the type. Often generated using crate::report::gen_id, but can be manually set.

fn size() -> usize

Returns the size of the type.

fn align() -> usize

Returns the alignment of the type.

impl<'a, Head, Tail> IntoSuperTrait<DynRef<'a, Tail>> for DynRef<'a, VTable<Head, Tail>>

where Tail: HasDropVt + 'static,

fn into_super(this: DynRef<'a, VTable<Head, Tail>>) -> DynRef<'a, Tail>

Cast dyn A + B into dyn A.

impl<'a, Head, Tail> IntoSuperTrait<DynRef<'a, Tail>> for DynRef<'a, VtSend<VTable<Head, Tail>>>

where Tail: HasDropVt + 'static,

fn into_super(this: DynRef<'a, VtSend<VTable<Head, Tail>>>) -> DynRef<'a, Tail>

Cast dyn A + B into dyn A.

impl<'a, Head, Tail> IntoSuperTrait<DynRef<'a, Tail>> for DynRef<'a, VtSend<VtSync<VTable<Head, Tail>>>>

where Tail: HasDropVt + 'static,

fn into_super( this: DynRef<'a, VtSend<VtSync<VTable<Head, Tail>>>> ) -> DynRef<'a, Tail>

Cast dyn A + B into dyn A.

impl<'a, Head, Tail> IntoSuperTrait<DynRef<'a, Tail>> for DynRef<'a, VtSync<VTable<Head, Tail>>>

where Tail: HasDropVt + 'static,

fn into_super(this: DynRef<'a, VtSync<VTable<Head, Tail>>>) -> DynRef<'a, Tail>

Cast dyn A + B into dyn A.

impl<'a, Head, Tail> IntoSuperTrait<DynRef<'a, Tail>> for DynRef<'a, VtSync<VtSend<VTable<Head, Tail>>>>

where Tail: HasDropVt + 'static,

fn into_super( this: DynRef<'a, VtSync<VtSend<VTable<Head, Tail>>>> ) -> DynRef<'a, Tail>

Cast dyn A + B into dyn A.

impl<'a, Vt> IntoSuperTrait<DynRef<'a, Vt>> for DynRef<'a, VtSend<Vt>>

where Vt: HasDropVt + 'static,

fn into_super(this: DynRef<'a, VtSend<Vt>>) -> DynRef<'a, Vt>

Cast dyn A + B into dyn A.

impl<'a, Vt> IntoSuperTrait<DynRef<'a, Vt>> for DynRef<'a, VtSend<VtSync<Vt>>>

where Vt: HasDropVt + 'static,

fn into_super(this: DynRef<'a, VtSend<VtSync<Vt>>>) -> DynRef<'a, Vt>

Cast dyn A + B into dyn A.

impl<'a, Vt> IntoSuperTrait<DynRef<'a, Vt>> for DynRef<'a, VtSync<Vt>>

where Vt: HasDropVt + 'static,

fn into_super(this: DynRef<'a, VtSync<Vt>>) -> DynRef<'a, Vt>

Cast dyn A + B into dyn A.

impl<'a, Vt> IntoSuperTrait<DynRef<'a, Vt>> for DynRef<'a, VtSync<VtSend<Vt>>>

where Vt: HasDropVt + 'static,

fn into_super(this: DynRef<'a, VtSync<VtSend<Vt>>>) -> DynRef<'a, Vt>

Cast dyn A + B into dyn A.

impl<'a, Head, Tail> IntoSuperTrait<DynRef<'a, VtSend<Tail>>> for DynRef<'a, VtSend<VTable<Head, Tail>>>

where Tail: HasDropVt + 'static,

fn into_super( this: DynRef<'a, VtSend<VTable<Head, Tail>>> ) -> DynRef<'a, VtSend<Tail>>

Cast dyn A + B into dyn A.

impl<'a, Vt> IntoSuperTrait<DynRef<'a, VtSend<Vt>>> for DynRef<'a, VtSend<VtSync<Vt>>>

where Vt: HasDropVt + 'static,

fn into_super(this: DynRef<'a, VtSend<VtSync<Vt>>>) -> DynRef<'a, VtSend<Vt>>

Cast dyn A + B into dyn A.

impl<'a, Head, Tail> IntoSuperTrait<DynRef<'a, VtSend<VtSync<Tail>>>> for DynRef<'a, VtSend<VtSync<VTable<Head, Tail>>>>

where Tail: HasDropVt + 'static,

fn into_super( this: DynRef<'a, VtSend<VtSync<VTable<Head, Tail>>>> ) -> DynRef<'a, VtSend<VtSync<Tail>>>

Cast dyn A + B into dyn A.

impl<'a, Head, Tail> IntoSuperTrait<DynRef<'a, VtSync<Tail>>> for DynRef<'a, VtSync<VTable<Head, Tail>>>

where Tail: HasDropVt + 'static,

fn into_super( this: DynRef<'a, VtSync<VTable<Head, Tail>>> ) -> DynRef<'a, VtSync<Tail>>

Cast dyn A + B into dyn A.

impl<'a, Vt> IntoSuperTrait<DynRef<'a, VtSync<Vt>>> for DynRef<'a, VtSync<VtSend<Vt>>>

where Vt: HasDropVt + 'static,

fn into_super(this: DynRef<'a, VtSync<VtSend<Vt>>>) -> DynRef<'a, VtSync<Vt>>

Cast dyn A + B into dyn A.

impl<'a, Head, Tail> IntoSuperTrait<DynRef<'a, VtSync<VtSend<Tail>>>> for DynRef<'a, VtSync<VtSend<VTable<Head, Tail>>>>

where Tail: HasDropVt + 'static,

fn into_super( this: DynRef<'a, VtSync<VtSend<VTable<Head, Tail>>>> ) -> DynRef<'a, VtSync<VtSend<Tail>>>

Cast dyn A + B into dyn A.

impl<StabbyVtProvider, StabbyTransitiveDerefN, _stabby_unselfed_0> IteratorDyn<StabbyTransitiveDerefN, _stabby_unselfed_0> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableIterator<_stabby_unselfed_0>, StabbyTransitiveDerefN> + Copy, _stabby_unselfed_0: IDeterminantProvider<()>,

type Item = _stabby_unselfed_0

An stabby-generated item for Iterator

extern "C" fn size_hint(&self) -> Tuple<usize, Option<usize>>

An stabby-generated item for Iterator

impl<StabbyVtProvider, StabbyTransitiveDerefN, O> CallMut0Dyn<StabbyTransitiveDerefN, O> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCallMut0<O>, StabbyTransitiveDerefN> + Copy,

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0> CallMut1Dyn<StabbyTransitiveDerefN, O, I0> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCallMut1<O, I0>, StabbyTransitiveDerefN> + Copy,

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1> CallMut2Dyn<StabbyTransitiveDerefN, O, I0, I1> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCallMut2<O, I0, I1>, StabbyTransitiveDerefN> + Copy,

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2> CallMut3Dyn<StabbyTransitiveDerefN, O, I0, I1, I2> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCallMut3<O, I0, I1, I2>, StabbyTransitiveDerefN> + Copy,

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3> CallMut4Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCallMut4<O, I0, I1, I2, I3>, StabbyTransitiveDerefN> + Copy,

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4> CallMut5Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCallMut5<O, I0, I1, I2, I3, I4>, StabbyTransitiveDerefN> + Copy,

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5> CallMut6Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCallMut6<O, I0, I1, I2, I3, I4, I5>, StabbyTransitiveDerefN> + Copy,

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6> CallMut7Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCallMut7<O, I0, I1, I2, I3, I4, I5, I6>, StabbyTransitiveDerefN> + Copy,

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7> CallMut8Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCallMut8<O, I0, I1, I2, I3, I4, I5, I6, I7>, StabbyTransitiveDerefN> + Copy,

impl<StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7, I8> CallMut9Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7, I8> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableCallMut9<O, I0, I1, I2, I3, I4, I5, I6, I7, I8>, StabbyTransitiveDerefN> + Copy,

impl<'a, Vt> Copy for DynRef<'a, Vt>

where Vt: Copy + 'static,

impl<StabbyVtProvider, StabbyTransitiveDerefN> IStableAllocDyn<StabbyTransitiveDerefN> for DynRef<'_, StabbyVtProvider>

where StabbyVtProvider: TransitiveDeref<StabbyVtableIStableAlloc, StabbyTransitiveDerefN> + Copy,

impl<'a, Vt> Send for DynRef<'a, Vt>

where Vt: HasSendVt,

impl<'a, Vt> Sync for DynRef<'a, Vt>

where Vt: HasSyncVt,