Struct stabby :: Dyn Copy item path

impl<'a, Vt, Alloc> Dyn<'a, Weak<(), Alloc>, Vt>
where Vt: HasDropVt + IStable, Alloc: IAlloc,

pub fn upgrade(self) -> Option<Dyn<'a, Arc<(), Alloc>, Vt>>

Attempts to upgrade a weak trait object to a strong one.

impl<'a, P, Vt> Dyn<'a, P, Vt>
where P: IPtrOwned + 'a, Vt: HasDropVt + 'static,

pub const fn has_optimal_layout() -> bool

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

impl<'a, P, Vt> Dyn<'a, P, Vt>
where P: IPtrOwned + IPtr, Vt: HasDropVt + 'a,

pub fn ptr(&self) -> &P

Access the data pointer immutably.

pub fn ptr_mut(&mut self) -> &mut P

Access the data pointer mutably.

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

Access the vtable.

pub fn as_ref(&self) -> DynRef<'_, Vt>

Borrow into an ABI-stable &dyn Traits

pub fn as_mut(&mut self) -> Dyn<'_, &mut (), Vt>
where P: IPtrMut,

Borrow into an ABI-stable &mut dyn Traits

pub fn try_as_mut(&mut self) -> Option<Dyn<'_, &mut (), Vt>>
where P: IPtrTryAsMut,

Attempt to borrow into an ABI-stable &mut dyn Traits

pub fn into_super<Super>(self) -> Super
where Dyn<'a, P, 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_ref<T>(&self) -> Option<&T>
where Vt: PartialEq + Copy + 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.

Note that the compiler may chose to have multiple copies of the vtable, notably in optimized builds. This means that even within a same compile unit, this function may fail to downcast a value even if the type should have matched.

In general, you should prefer Self::stable_downcast_ref

§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_ref<T, Path>(&self) -> Option<&T>
where T: IStable, Vt: TransitiveDeref<StabbyVtableAny, Path> + IConstConstructor<'a, T>,

Downcasts the reference based on its reflection report.

pub unsafe fn downcast_mut<T>(&mut self) -> Option<&mut T>
where Vt: PartialEq + Copy + IConstConstructor<'a, T>, P: IPtrMut,

Downcasts the mutable reference based on vtable equality.

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

Note that the compiler may chose to have multiple copies of the vtable, notably in optimized builds. This means that even within a same compile unit, this function may fail to downcast a value even if the type should have matched.

In general, you should prefer Self::stable_downcast_mut

§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_mut<T, Path>(&mut self) -> Option<&mut T>
where T: IStable, Vt: TransitiveDeref<StabbyVtableAny, Path> + IConstConstructor<'a, T>, P: IPtrMut,

Downcasts the mutable reference based on its reflection report.

Trait Implementations§

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN> AnyDyn<StabbyTransitiveDerefN> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableAny, StabbyTransitiveDerefN>,

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<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O> Call0Dyn<StabbyTransitiveDerefN, O> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCall0<O>, StabbyTransitiveDerefN>,

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

An stabby-generated item for Call0

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0> Call1Dyn<StabbyTransitiveDerefN, O, I0> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCall1<O, I0>, StabbyTransitiveDerefN>,

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

An stabby-generated item for Call1

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1> Call2Dyn<StabbyTransitiveDerefN, O, I0, I1> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCall2<O, I0, I1>, StabbyTransitiveDerefN>,

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

An stabby-generated item for Call2

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2> Call3Dyn<StabbyTransitiveDerefN, O, I0, I1, I2> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCall3<O, I0, I1, I2>, StabbyTransitiveDerefN>,

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

An stabby-generated item for Call3

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3> Call4Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCall4<O, I0, I1, I2, I3>, StabbyTransitiveDerefN>,

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

An stabby-generated item for Call4

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4> Call5Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCall5<O, I0, I1, I2, I3, I4>, StabbyTransitiveDerefN>,

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

An stabby-generated item for Call5

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5> Call6Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCall6<O, I0, I1, I2, I3, I4, I5>, StabbyTransitiveDerefN>,

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<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6> Call7Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCall7<O, I0, I1, I2, I3, I4, I5, I6>, StabbyTransitiveDerefN>,

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<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7> Call8Dyn<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCall8<O, I0, I1, I2, I3, I4, I5, I6, I7>, StabbyTransitiveDerefN>,

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<StabbyPtrProvider, 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 Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCall9<O, I0, I1, I2, I3, I4, I5, I6, I7, I8>, StabbyTransitiveDerefN>,

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<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O> CallMut0DynMut<StabbyTransitiveDerefN, O> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCallMut0<O>, StabbyTransitiveDerefN>,

extern "C" fn call_mut(&mut self) -> O

An stabby-generated item for CallMut0

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0> CallMut1DynMut<StabbyTransitiveDerefN, O, I0> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCallMut1<O, I0>, StabbyTransitiveDerefN>,

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

An stabby-generated item for CallMut1

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1> CallMut2DynMut<StabbyTransitiveDerefN, O, I0, I1> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCallMut2<O, I0, I1>, StabbyTransitiveDerefN>,

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

An stabby-generated item for CallMut2

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2> CallMut3DynMut<StabbyTransitiveDerefN, O, I0, I1, I2> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCallMut3<O, I0, I1, I2>, StabbyTransitiveDerefN>,

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

An stabby-generated item for CallMut3

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3> CallMut4DynMut<StabbyTransitiveDerefN, O, I0, I1, I2, I3> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCallMut4<O, I0, I1, I2, I3>, StabbyTransitiveDerefN>,

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

An stabby-generated item for CallMut4

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4> CallMut5DynMut<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCallMut5<O, I0, I1, I2, I3, I4>, StabbyTransitiveDerefN>,

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

An stabby-generated item for CallMut5

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5> CallMut6DynMut<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCallMut6<O, I0, I1, I2, I3, I4, I5>, StabbyTransitiveDerefN>,

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

An stabby-generated item for CallMut6

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6> CallMut7DynMut<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCallMut7<O, I0, I1, I2, I3, I4, I5, I6>, StabbyTransitiveDerefN>,

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

An stabby-generated item for CallMut7

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7> CallMut8DynMut<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCallMut8<O, I0, I1, I2, I3, I4, I5, I6, I7>, StabbyTransitiveDerefN>,

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

An stabby-generated item for CallMut8

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7, I8> CallMut9DynMut<StabbyTransitiveDerefN, O, I0, I1, I2, I3, I4, I5, I6, I7, I8> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableCallMut9<O, I0, I1, I2, I3, I4, I5, I6, I7, I8>, StabbyTransitiveDerefN>,

extern "C" fn call_mut( &mut 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 CallMut9

impl<'a, P, Vt> Clone for Dyn<'a, P, Vt>
where P: IPtrOwned + IPtrClone, Vt: HasDropVt + 'a,

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

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl<'a, P, Vt> Drop for Dyn<'a, P, Vt>
where P: IPtrOwned, Vt: HasDropVt,

fn drop(&mut self)

Executes the destructor for this type. Read more

impl<'a, Vt, Alloc> From<&'a Dyn<'a, Arc<(), Alloc>, Vt>> for Dyn<'a, Weak<(), Alloc>, Vt>
where Vt: HasDropVt, Alloc: IAlloc,

fn from(value: &'a Dyn<'a, Arc<(), Alloc>, Vt>) -> Dyn<'a, Weak<(), Alloc>, Vt>

Converts to this type from the input type.

impl<'a, Vt, P> From for Dyn<'a, ::Anonymized, Vt>
where Vt: HasDropVt + Copy + IConstConstructor<'static, ::Target> + 'static, P: IntoDyn + 'a, ::Anonymized: IPtrOwned,

fn from(value: P) -> Dyn<'a, ::Anonymized, Vt>

Converts to this type from the input type.

impl<'a, Vt, P, Output> Future for Dyn<'a, P, VTable<StabbyVtableFuture<Output>, Vt>>
where Vt: HasDropVt, P: IPtrOwned + IPtrMut, Output: IDeterminantProvider<()>,

type Output = Output

The type of value produced on completion.

fn poll( self: Pin<&mut Dyn<'a, P, VTable<StabbyVtableFuture<Output>, Vt>>>, cx: &mut Context<'_> ) -> Poll<<Dyn<'a, P, VTable<StabbyVtableFuture<Output>, Vt>> as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

impl<'a, Vt, P, Output> Future for Dyn<'a, P, VtSend<VTable<StabbyVtableFuture<Output>, Vt>>>
where Vt: HasDropVt, P: IPtrOwned + IPtrMut, Output: IDeterminantProvider<()>,

type Output = Output

The type of value produced on completion.

fn poll( self: Pin<&mut Dyn<'a, P, VtSend<VTable<StabbyVtableFuture<Output>, Vt>>>>, cx: &mut Context<'_> ) -> Poll<<Dyn<'a, P, VtSend<VTable<StabbyVtableFuture<Output>, Vt>>> as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

impl<'a, Vt, P, Output> Future for Dyn<'a, P, VtSend<VtSync<VTable<StabbyVtableFuture<Output>, Vt>>>>
where Vt: HasDropVt, P: IPtrOwned + IPtrMut, Output: IDeterminantProvider<()>,

type Output = Output

The type of value produced on completion.

fn poll( self: Pin<&mut Dyn<'a, P, VtSend<VtSync<VTable<StabbyVtableFuture<Output>, Vt>>>>>, cx: &mut Context<'_> ) -> Poll<<Dyn<'a, P, VtSend<VtSync<VTable<StabbyVtableFuture<Output>, Vt>>>> as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

impl<'a, Vt, P, Output> Future for Dyn<'a, P, VtSync<VTable<StabbyVtableFuture<Output>, Vt>>>
where Vt: HasDropVt, P: IPtrOwned + IPtrMut, Output: IDeterminantProvider<()>,

type Output = Output

The type of value produced on completion.

fn poll( self: Pin<&mut Dyn<'a, P, VtSync<VTable<StabbyVtableFuture<Output>, Vt>>>>, cx: &mut Context<'_> ) -> Poll<<Dyn<'a, P, VtSync<VTable<StabbyVtableFuture<Output>, Vt>>> as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

impl<'a, Vt, P, Output> Future for Dyn<'a, P, VtSync<VtSend<VTable<StabbyVtableFuture<Output>, Vt>>>>
where Vt: HasDropVt, P: IPtrOwned + IPtrMut, Output: IDeterminantProvider<()>,

type Output = Output

The type of value produced on completion.

fn poll( self: Pin<&mut Dyn<'a, P, VtSync<VtSend<VTable<StabbyVtableFuture<Output>, Vt>>>>>, cx: &mut Context<'_> ) -> Poll<<Dyn<'a, P, VtSync<VtSend<VTable<StabbyVtableFuture<Output>, Vt>>>> as Future>::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, _stabby_unselfed_0> FutureDyn<StabbyTransitiveDerefN, _stabby_unselfed_0> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtr, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableFuture<_stabby_unselfed_0>, StabbyTransitiveDerefN>, _stabby_unselfed_0: IDeterminantProvider<()>,

type Output = _stabby_unselfed_0

An stabby-generated item for Future

impl<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN, _stabby_unselfed_0> FutureDynMut<StabbyTransitiveDerefN, _stabby_unselfed_0> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableFuture<_stabby_unselfed_0>, StabbyTransitiveDerefN>, _stabby_unselfed_0: IDeterminantProvider<()>,

extern "C" fn poll<'a>( &'a mut self, _0: StableWaker<'a> ) -> Option<<Dyn<'_, StabbyPtrProvider, StabbyVtProvider> as FutureDyn<StabbyTransitiveDerefN, _stabby_unselfed_0>>::Output>

An stabby-generated item for Future

impl<'a, P, Vt> IStable for Dyn<'a, P, Vt>
where P: IPtrOwned + 'a, Vt: HasDropVt + 'static, Struct<FieldPair<FieldPair<ManuallyDrop, &'static Vt>, PhantomData<&'a P>>>: IStable, ManuallyDrop: IStable, &'static Vt: IStable, PhantomData<&'a P>: IStable,

type ForbiddenValues = <Struct<FieldPair<FieldPair<ManuallyDrop, &'static Vt>, PhantomData<&'a P>>> as IStable>::ForbiddenValues

The values that the annotated type cannot occupy.

type UnusedBits = <Struct<FieldPair<FieldPair<ManuallyDrop, &'static Vt>, PhantomData<&'a P>>> as IStable>::UnusedBits

The padding bits in the annotated types

type Size = <Struct<FieldPair<FieldPair<ManuallyDrop, &'static Vt>, PhantomData<&'a P>>> as IStable>::Size

The size of the annotated type in bytes.

type Align = <Struct<FieldPair<FieldPair<ManuallyDrop, &'static Vt>, PhantomData<&'a P>>> as IStable>::Align

The alignment of the annotated type in bytes.

type HasExactlyOneNiche = <Struct<FieldPair<FieldPair<ManuallyDrop, &'static Vt>, PhantomData<&'a P>>> as IStable>::HasExactlyOneNiche

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

type ContainsIndirections = <Struct<FieldPair<FieldPair<ManuallyDrop, &'static Vt>, PhantomData<&'a P>>> 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<StabbyPtrProvider, StabbyVtProvider, StabbyTransitiveDerefN> IStableAllocDynMut<StabbyTransitiveDerefN> for Dyn<'_, StabbyPtrProvider, StabbyVtProvider>
where StabbyPtrProvider: IPtrOwned + IPtrMut, StabbyVtProvider: HasDropVt + Copy + TransitiveDeref<StabbyVtableIStableAlloc, StabbyTransitiveDerefN>,

extern "C" fn alloc(&mut self, _0: Layout) -> *mut ()

An stabby-generated item for IStableAlloc

extern "C" fn free(&mut self, _0: *mut ())

An stabby-generated item for IStableAlloc

extern "C" fn realloc(&mut self, _0: mut (), _1: Layout) -> mut ()

An stabby-generated item for IStableAlloc