Struct refptr::WeakPtr

pub struct WeakPtr<T: ?Sized> where
    T: Refcounted,
    T::Rc: WeakRefcount,  { /* fields omitted */ }

Weak reference to a Refcounted object.

Weak pointers can only be used on objects which have refcounts supporting weak references.

Example

#[refcounted(atomic, weak)]
struct HeapInt { i: i32 }

let here = make_refptr!(HeapInt { i: 10 });
let weak = WeakPtr::new(&*here);
assert_eq!(weak.upgrade().unwrap().i, 10);
drop(here);
assert!(weak.upgrade().is_none());

Implementations

impl<T: ?Sized> WeakPtr<T> where
    T: Refcounted,
    T::Rc: WeakRefcount, 

pub fn new(val: &T) -> WeakPtr<T>

Obtain a new weak reference to a refcounted object.

pub fn upgrade(&self) -> Option<RefPtr<T>>

Attempt to upgrade this weak reference into a strong reference, returning it.

pub fn strong_count(&self) -> usize

Gets the number of strong references to this allocation.

pub fn weak_count(&self) -> usize

Gets the number of weak references to this allocation.

If there are no remaining strong references, this will return 0.

Trait Implementations

impl<T: ?Sized> Clone for WeakPtr<T> where
    T: Refcounted,
    T::Rc: WeakRefcount, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: ?Sized> Debug for WeakPtr<T> where
    T: Refcounted,
    T::Rc: WeakRefcount, 

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

Formats the value using the given formatter.

impl<T: ?Sized> Drop for WeakPtr<T> where
    T: Refcounted,
    T::Rc: WeakRefcount, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ?Sized> Send for WeakPtr<T> where
    T: Refcounted + Send + Sync,
    T::Rc: WeakRefcount, 

impl<T: ?Sized> Sync for WeakPtr<T> where
    T: Refcounted + Send + Sync,
    T::Rc: WeakRefcount,