Struct SharedPtr 

pub struct SharedPtr<T> { /* private fields */ }

A smart pointer that automatically manages the reference count of an Objective-C object.

C++ equivalent: NS::SharedPtr<_Class>

Ownership

SharedPtr owns a reference to the underlying Objective-C object. When the SharedPtr is dropped, it will release the reference. When cloned, it will retain a new reference.

Implementations

impl<T> SharedPtr<T>

pub fn null() -> Option<Self>

Create a null SharedPtr.

Note: Unlike C++, Rust’s NonNull cannot be null, so this returns an Option. For null representation, use Option<SharedPtr<T>>.

C++ equivalent: SharedPtr()

pub unsafe fn from_raw(ptr: *mut c_void) -> Option<Self>

Create a SharedPtr from a raw pointer, taking ownership.

Safety

• The pointer must be a valid Objective-C object.
• The caller must ensure the object has a retain count of at least 1.
• Ownership is transferred to the SharedPtr (no additional retain).

C++ equivalent: Used internally by TransferPtr

pub fn get(&self) -> *mut c_void

Get the raw pointer to the Objective-C object.

C++ equivalent: _Class* get() const

pub fn as_ptr(&self) -> *const c_void

Get the raw pointer (const version for API compatibility).

pub fn reset(&mut self)

Reset this SharedPtr to null, releasing the reference.

C++ equivalent: void reset()

pub fn detach(self) -> *mut c_void

Detach the SharedPtr from the pointee without releasing.

Returns the raw pointer and prevents the destructor from releasing.

C++ equivalent: void detach()

pub unsafe fn cast<U>(self) -> SharedPtr<U>

Convert to a pointer to a different type.

Safety

The types must be compatible.

Trait Implementations

impl<T> Clone for SharedPtr<T>

fn clone(&self) -> Self

Clone this SharedPtr, retaining the object.

C++ equivalent: SharedPtr(const SharedPtr<_Class>& other)

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

Performs copy-assignment from source.

impl<T> Debug for SharedPtr<T>

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

Formats the value using the given formatter.

impl<T> Deref for SharedPtr<T>

type Target = *mut c_void

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> Drop for SharedPtr<T>

fn drop(&mut self)

Release the reference when dropped.

C++ equivalent: ~SharedPtr()

impl<T> PartialEq for SharedPtr<T>

fn eq(&self, other: &Self) -> 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<T> Eq for SharedPtr<T>

impl<T: Send> Send for SharedPtr<T>

impl<T: Sync> Sync for SharedPtr<T>