Struct PtrUninit 

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

A type-erased, wide pointer to an uninitialized value.

This can be useful for working with dynamically sized types, like slices or trait objects, where both a pointer and metadata (such as length or vtable) need to be stored.

The lifetime 'mem represents the borrow of the underlying uninitialized memory.

Implementations

impl<'mem> PtrUninit<'mem>

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

Create a new opaque pointer from a mutable pointer

pub const unsafe fn copy_from<'src>( self, src: PtrConst<'src>, shape: &'static Shape, ) -> Result<PtrMut<'mem>, UnsizedError>

Copies memory from a source pointer into this location and returns PtrMut

Safety

• The source pointer must be valid for reads of len bytes
• This pointer must be valid for writes of len bytes and properly aligned
• The regions may not overlap

pub const fn from_maybe_uninit<T>(borrow: &'mem mut MaybeUninit<T>) -> Self

Creates a new opaque pointer from a reference to a core::mem::MaybeUninit

The pointer will point to the potentially uninitialized contents

pub const unsafe fn assume_init(self) -> PtrMut<'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 put<T>(self, value: T) -> PtrMut<'mem>

Write a value to this location and convert to an initialized pointer

Safety

The pointer must be properly aligned for T and point to allocated memory that can be safely written to.

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

Returns the underlying raw pointer as a byte pointer

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

Returns the underlying raw pointer as a const byte pointer

pub const unsafe fn field_uninit_at(self, offset: usize) -> PtrUninit<'mem>

Returns a pointer with the given offset added

Safety

Offset is within the bounds of the allocated memory

pub const unsafe fn field_init_at(self, offset: usize) -> PtrMut<'mem>

Returns a pointer with the given offset added, assuming it’s initialized

Safety

The pointer plus offset must be:

• Within bounds of the allocated object
• Properly aligned for the type being pointed to
• Point to initialized data of the correct type

Trait Implementations

impl<'mem> Clone for PtrUninit<'mem>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PtrUninit<'_>

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

Formats the value using the given formatter.

impl<'mem, T: ?Sized> From<TypedPtrUninit<'mem, T>> for PtrUninit<'mem>

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

Converts to this type from the input type.

impl<'mem> PartialEq for PtrUninit<'mem>

fn eq(&self, other: &PtrUninit<'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 PtrUninit<'mem>

impl<'mem> Eq for PtrUninit<'mem>

impl<'mem> StructuralPartialEq for PtrUninit<'mem>