Struct bevy::ptr::Ptr

pub struct Ptr<'a, A = Aligned>(/* private fields */)
where
    A: IsAligned;

Type-erased borrow of some unknown type chosen when constructing this type.

This type tries to act “borrow-like” which means that:

• It should be considered immutable: its target must not be changed while this pointer is alive.
• It must always points to a valid value of whatever the pointee type is.
• The lifetime 'a accurately represents how long the pointer is valid for.
• Must be sufficiently aligned for the unknown pointee type.

It may be helpful to think of this type as similar to &'a dyn Any but without the metadata and able to point to data that does not correspond to a Rust type.

Implementations

impl<'a> Ptr<'a>

pub fn to_unaligned(self) -> Ptr<'a, Unaligned>

Removes the alignment requirement of this pointer

impl<A> Ptr<'_, A>

where A: IsAligned,

pub unsafe fn byte_offset(self, count: isize) -> Ptr<'_, A>

Calculates the offset from a pointer. As the pointer is type-erased, there is no size information available. The provided count parameter is in raw bytes.

See also: ptr::offset

Safety

• The offset cannot make the existing ptr null, or take it out of bounds for its allocation.
• If the A type parameter is Aligned then the offset must not make the resulting pointer be unaligned for the pointee type.

pub unsafe fn byte_add(self, count: usize) -> Ptr<'_, A>

Calculates the offset from a pointer (convenience for .offset(count as isize)). As the pointer is type-erased, there is no size information available. The provided count parameter is in raw bytes.

See also: ptr::add

Safety

• The offset cannot make the existing ptr null, or take it out of bounds for its allocation.
• If the A type parameter is Aligned then the offset must not make the resulting pointer be unaligned for the pointee type.

impl<'a, A> Ptr<'a, A>

where A: IsAligned,

pub unsafe fn new(inner: NonNull<u8>) -> Ptr<'a, A>

Creates a new instance from a raw pointer.

Safety

• inner must point to valid value of whatever the pointee type is.
• If the A type parameter is Aligned then inner must be sufficiently aligned for the pointee type.
• inner must have correct provenance to allow reads of the pointee type.
• The lifetime 'a must be constrained such that this Ptr will stay valid and nothing can mutate the pointee while this Ptr is live except through an UnsafeCell.

pub unsafe fn assert_unique(self) -> PtrMut<'a, A>

Transforms this Ptr into an PtrMut

Safety

Another PtrMut for the same Ptr must not be created until the first is dropped.

pub unsafe fn deref<T>(self) -> &'a T

Transforms this Ptr<T> into a &T with the same lifetime

Safety

• T must be the erased pointee type for this Ptr.
• If the type parameter A is Unaligned then this pointer must be sufficiently aligned for the pointee type T.

pub fn as_ptr(self) -> *mut u8

Gets the underlying pointer, erasing the associated lifetime.

If possible, it is strongly encouraged to use deref over this function, as it retains the lifetime.

Trait Implementations

impl<'a, A> Clone for Ptr<'a, A>

where A: Clone + IsAligned,

fn clone(&self) -> Ptr<'a, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T> From<&'a T> for Ptr<'a>

fn from(val: &'a T) -> Ptr<'a>

Converts to this type from the input type.

impl<'a, A> From<Ptr<'a, A>> for NonNull<u8>

where A: IsAligned,

fn from(ptr: Ptr<'a, A>) -> NonNull<u8>

Converts to this type from the input type.

impl<A> Pointer for Ptr<'_, A>

where A: IsAligned,

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

Formats the value using the given formatter.

impl<'a, A> Copy for Ptr<'a, A>

where A: Copy + IsAligned,