Struct bevy_ptr::OwningPtr

pub struct OwningPtr<'a>(_, _);

Type-erased Box-like pointer to some unknown type chosen when constructing this type. Conceptually represents ownership of whatever data is being pointed to and so is responsible for calling its Drop impl. This pointer is not responsible for freeing the memory pointed to by this pointer as it may be pointing to an element in a Vec or to a local in a function etc.

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

• Pointer should be considered exclusive and mutable. It cannot be cloned as this would lead to aliased mutability and potentially use after free bugs.
• 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.

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

Implementations

impl OwningPtr<'_>

pub unsafe fn byte_offset(self, count: isize) -> Self

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.

pub unsafe fn byte_add(self, count: usize) -> Self

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.

pub unsafe fn new(inner: NonNull<u8>) -> Self

Creates a new instance from a raw pointer.

Safety

The lifetime for the returned item must not exceed the lifetime inner is valid for

impl<'a> OwningPtr<'a>

pub fn make<T, F: FnOnce(OwningPtr<'_>) -> R, R>(val: T, f: F) -> R

Consumes a value and creates an OwningPtr to it while ensuring a double drop does not happen.

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

Consumes the OwningPtr to obtain ownership of the underlying data of type T.

Safety

Must point to a valid T.

pub unsafe fn drop_as<T>(self)

Consumes the OwningPtr to drop the underlying data of type T.

Safety

Must point to a valid T.

pub fn as_ptr(&self) -> *mut u8

Gets the underlying pointer, erasing the associated lifetime.

If possible, it is strongly encouraged to use the other more type-safe functions over this function.