Struct UniquePtr 

pub struct UniquePtr<T>
where
    T: Recyclable,
{ /* private fields */ }

UniquePtr<T> holds a unique pointer to an object of type T and deletes the object when the UniquePtr goes out of scope.

T must implement the Recyclable trait to define how the object is destroyed. This allows UniquePtr to manage both Rust-allocated objects and C++-allocated objects.

Implementations

impl<T: Recyclable> UniquePtr<T>

pub unsafe fn from_raw(ptr: *mut T) -> Self

Constructs a UniquePtr from a raw pointer.

Safety

• ptr must be valid and the sole owning reference to the object pointed to by ptr.
• ptr must have been allocated in such a way that calling T::recycle(ptr) is a correct way to deallocate the pointer.

pub fn try_new(value: T) -> Result<UniquePtr<T>, AllocError>

Helper function that allocates a new instance of T using T::allocate and returns a UniquePtr wrapping it.

For Rust-allocated objects where T derives Recyclable, this will use Box::try_new.

pub fn as_ptr(this: &Self) -> *const T

Returns the raw pointer to the object.

pub fn as_mut_ptr(this: &mut Self) -> *mut T

Returns a mutable raw pointer to the object.

pub fn into_raw(this: Self) -> *mut T

Consume the UniquePtr and return the raw pointer without destroying the object.

The caller is responsible for managing the object’s lifetime after this call.

Trait Implementations

impl<T: Recyclable> Deref for UniquePtr<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Recyclable> DerefMut for UniquePtr<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Recyclable> Drop for UniquePtr<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T: Recyclable> PtrTraits for UniquePtr<T>

const IS_MANAGED: bool = true

Whether the pointer type is managed (e.g., UniquePtr or RefPtr).

type Target = T

The type pointed to by this pointer.

fn into_raw(self) -> *mut T

Consumes the pointer and returns a raw pointer to the target.

unsafe fn from_raw(raw: *mut T) -> Self

Creates an instance of Self from a raw pointer.

fn get_ref(&self) -> &T

Returns a reference to the target.

impl<T: Recyclable> ManagedPtr for UniquePtr<T>

impl<T: Recyclable + Send> Send for UniquePtr<T>

impl<T: Recyclable + Sync> Sync for UniquePtr<T>