Struct PtrMut 

pub struct PtrMut<'mem> { /* private fields */ }

A type-erased, mutable wide pointer to an initialized value.

Like PtrMut, but for unsized types where metadata is needed. Provides mutable access to the underlying object, whose borrow is tracked by lifetime 'mem.

Implementations

impl<'mem> PtrMut<'mem>

pub const fn new<T: ?Sized>(ptr: NonNull<T>) -> Self

Creates a new mutable wide pointer from a raw pointer to a (potentially unsized) object.

Arguments

• ptr - Raw mutable pointer to the object. Can be a pointer to a DST (e.g., slice, trait object).

Panics

Panics if a thin pointer is provided where a wide pointer is expected.

pub const fn as_byte_ptr(self) -> *const u8

Gets the underlying raw pointer

pub const fn as_mut_byte_ptr(self) -> *mut u8

Gets the underlying raw pointer as mutable

pub const fn as_uninit(self) -> PtrUninit<'mem>

Assumes the pointer is initialized and returns an Opaque pointer

Safety

The pointer must actually be pointing to initialized memory of the correct type.

pub const unsafe fn as_ptr<T: ?Sized>(self) -> *const T

Gets the underlying raw pointer as a pointer of type T

Safety

Must be called with the original type T that was used to create this pointer

pub const unsafe fn as_mut<'borrow: 'mem, T: ?Sized>(self) -> &'borrow mut T

Gets the underlying raw pointer as a mutable pointer of type T

Safety

T must be the actual underlying type. You’re downcasting with no guardrails.

pub const unsafe fn get<'borrow: 'mem, T>(self) -> &'borrow T

Gets the underlying raw pointer as a const pointer of type T

Safety

T must be the actual underlying type. You’re downcasting with no guardrails. You must respect AXM (aliasing xor mutability). Holding onto the borrow while calling as_mut is UB.

Basically this is UB land. Careful.

pub const fn as_const<'borrow: 'mem>(self) -> PtrConst<'borrow>

Make a const ptr out of this mut ptr

pub const unsafe fn read<T>(self) -> T

Exposes core::ptr::read

Safety

T must be the actual underlying type of the pointed-to memory. The memory must be properly initialized and aligned for type T.

pub unsafe fn drop_in_place<T: ?Sized>(self) -> PtrUninit<'mem>

Exposes core::ptr::drop_in_place

Safety

T must be the actual underlying type of the pointed-to memory. The memory must be properly initialized and aligned for type T. After calling this function, the memory should not be accessed again until it is properly reinitialized.

pub unsafe fn replace<T>(self, value: T) -> Self

Write a value to this location after dropping the existing value

Safety

• The pointer must be properly aligned for T and point to allocated memory that can be safely written to.
• T must be the actual type of the object being pointed to
• The memory must already be initialized to a valid T value

Trait Implementations

impl<'mem> Clone for PtrMut<'mem>

fn clone(&self) -> PtrMut<'mem>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PtrMut<'_>

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

Formats the value using the given formatter.

impl<'mem, T: ?Sized> From<TypedPtrMut<'mem, T>> for PtrMut<'mem>

fn from(ptr: TypedPtrMut<'mem, T>) -> Self

Converts to this type from the input type.

impl<'mem> PartialEq for PtrMut<'mem>

fn eq(&self, other: &PtrMut<'mem>) -> 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<'mem> Copy for PtrMut<'mem>

impl<'mem> Eq for PtrMut<'mem>

impl<'mem> StructuralPartialEq for PtrMut<'mem>