Struct MutHandle 

pub struct MutHandle<'a, T: ?Sized> {
    ptr: NonNull<T>,
    _lt: PhantomData<&'a mut T>,
}

Fields

ptr: NonNull<T>

_lt: PhantomData<&'a mut T>

Implementations

impl<'a, T: ?Sized> MutHandle<'a, T>

pub unsafe fn from_raw(ptr: *mut T) -> Self

Trait Implementations

impl<'a, 'b, T> BorrowPlace<&'b mut T> for MutHandle<'a, T>

where 'a: 'b,

const ACCESS: AccessKind = AccessKind::Exclusive

The access permissions to the place required by Self::borrow.

const SAFE: bool = true

Whether Self::borrow is safe when Self::ACCESS is honored for Self::Timing.

type Timing = Lifetime<'b>

The timing of the access permissions of Self::borrow.

unsafe fn borrow(self) -> &'b mut T

Borrow the place using Output.

impl<T: ?Sized> Clone for MutHandle<'_, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ?Sized> Copy for MutHandle<'_, T>

impl<'a, ProxyTiming, P> DerefPlace<ProxyTiming, Instant> for MutHandle<'a, P>

where P: CreateHandle<ProxyTiming> + ?Sized, ProxyTiming: Timing,

const POINTEE_ACCESS: AccessKind = P::ACCESS

The access permissions to the contents of the place handled by Self required by Self::deref_place.

const POINTER_ACCESS: AccessKind = AccessKind::Shared

The access permissions to the place handled by Self required by Self::deref_place.

const SAFE: bool = true

Whether Self::deref_place is safe when Self::POINTEE_ACCESS and Self::POINTER_ACCESS are honored for PointeeTiming and PointerTiming respectively.

unsafe fn deref_place( self, ) -> <Self::Target as CreateHandle<ProxyTiming>>::Handle

impl<T> DropPlace for MutHandle<'_, T>

unsafe fn drop_place(self)

impl<'a, T: ?Sized> PlaceHandle for MutHandle<'a, T>

type Target = T

The type that’s stored in the place.

impl<'a, S: Subplace<Target: 'a>> ProjectPlace<S> for MutHandle<'a, S::Source>

type Projected = MutHandle<'a, <S as Subplace>::Target>

unsafe fn project_place(self, subplace: S) -> Self::Projected

impl<T> ReadPlace for MutHandle<'_, T>

const ACCESS: AccessKind = AccessKind::Exclusive

The access permissions to the place required by Self::read_place.

const SAFE: bool = true

Whether Self::read_place is safe when Self::ACCESS is honored.

unsafe fn read_place(self) -> Self::Target

Read from the place.

impl<T> WritePlace for MutHandle<'_, T>

const ACCESS: AccessKind = AccessKind::Exclusive

The access permissions to the place required by Self::write_place.

const SAFE: bool = true

Whether Self::write_place is safe when Self::ACCESS is honored.

unsafe fn write_place(self, value: Self::Target)

Write to the place.