Struct PtrMut

pub struct PtrMut<'mem>(/* private fields */);

A type-erased pointer to an initialized value

Implementations

impl<'mem> PtrMut<'mem>

pub const fn new<T>(ptr: *mut T) -> PtrMut<'mem>

Create a new opaque pointer from a raw pointer

Safety

The pointer must be valid, aligned, and point to initialized memory of the correct type, and be valid for lifetime 'mem.

It’s encouraged to take the address of something with &raw mut x, rather than &x

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 unsafe fn as_ptr<T>(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, T>(self) -> &'borrow mut T

where 'borrow: 'mem,

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, T>(self) -> &'borrow T

where 'borrow: 'mem,

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>(self) -> PtrConst<'borrow>

where 'borrow: 'mem,

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>(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) -> PtrMut<'mem>

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 copy of the value.

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

Performs copy-assignment from source.

impl<'mem> Copy for PtrMut<'mem>