Source code
Revision control
Copy as Markdown
Other Tools
use std::fmt;
use std::mem;
use std::ops::Deref;
use runtime::{Object, self};
use super::WeakPtr;
/// A pointer that strongly references an object, ensuring it won't be deallocated.
pub struct StrongPtr(*mut Object);
impl StrongPtr {
/// Constructs a `StrongPtr` to a newly created object that already has a
/// +1 retain count. This will not retain the object.
/// When dropped, the object will be released.
/// Unsafe because the caller must ensure the given object pointer is valid.
pub unsafe fn new(ptr: *mut Object) -> Self {
StrongPtr(ptr)
}
/// Retains the given object and constructs a `StrongPtr` to it.
/// When dropped, the object will be released.
/// Unsafe because the caller must ensure the given object pointer is valid.
pub unsafe fn retain(ptr: *mut Object) -> Self {
StrongPtr(runtime::objc_retain(ptr))
}
/// Autoreleases self, meaning that the object is not immediately released,
/// but will be when the autorelease pool is drained. A pointer to the
/// object is returned, but its validity is no longer ensured.
pub fn autorelease(self) -> *mut Object {
let ptr = self.0;
mem::forget(self);
unsafe {
runtime::objc_autorelease(ptr);
}
ptr
}
/// Returns a `WeakPtr` to self.
pub fn weak(&self) -> WeakPtr {
unsafe { WeakPtr::new(self.0) }
}
}
impl Drop for StrongPtr {
fn drop(&mut self) {
unsafe {
runtime::objc_release(self.0);
}
}
}
impl Clone for StrongPtr {
fn clone(&self) -> StrongPtr {
unsafe {
StrongPtr::retain(self.0)
}
}
}
impl Deref for StrongPtr {
type Target = *mut Object;
fn deref(&self) -> &*mut Object {
&self.0
}
}
impl fmt::Pointer for StrongPtr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Pointer::fmt(&self.0, f)
}
}