std::rc::Weak - Rust (original) (raw)
Struct std::rc::Weak1.4.0 [−] [src]
pub struct Weak where
T: ?Sized, { /* fields omitted */ }
Weak is a version of Rc that holds a non-owning reference to the managed value. The value is accessed by calling upgrade on the Weakpointer, which returns an Option<Rc<T>>.
Since a Weak reference does not count towards ownership, it will not prevent the inner value from being dropped, and Weak itself makes no guarantees about the value still being present and may return Nonewhen upgraded.
A Weak pointer is useful for keeping a temporary reference to the value within Rc without extending its lifetime. It is also used to prevent circular references between Rc pointers, since mutual owning references would never allow either Rc to be dropped. For example, a tree could have strong Rc pointers from parent nodes to children, and Weakpointers from children back to their parents.
The typical way to obtain a Weak pointer is to call Rc::downgrade.
impl<T> [Weak](../../std/rc/struct.Weak.html "struct std::rc::Weak")<T>[src]
pub fn [new](#method.new)() -> [Weak](../../std/rc/struct.Weak.html "struct std::rc::Weak")<T>
1.10.0
Constructs a new Weak<T>, allocating memory for T without initializing it. Calling upgrade on the return value always gives None.
use std::rc::Weak;
let empty: Weak = Weak::new(); assert!(empty.upgrade().is_none());Run
`impl Weak where
pub fn [upgrade](#method.upgrade)(&self) -> [Option](../../std/option/enum.Option.html "enum std::option::Option")<[Rc](../../std/rc/struct.Rc.html "struct std::rc::Rc")<T>>[src]
Attempts to upgrade the Weak pointer to an Rc, extending the lifetime of the value if successful.
Returns None if the value has since been dropped.
use std::rc::Rc;
let five = Rc::new(5);
let weak_five = Rc::downgrade(&five);
let strong_five: Option<Rc<_>> = weak_five.upgrade(); assert!(strong_five.is_some());
drop(strong_five); drop(five);
assert!(weak_five.upgrade().is_none());Run
`impl<T, U> CoerceUnsized<Weak> for Weak where
T: Unsize + ?Sized,
U: ?Sized, `[src]
`impl 
for Weak where
`impl Clone for Weak where
fn [clone](../../std/clone/trait.Clone.html#tymethod.clone)(&self) -> [Weak](../../std/rc/struct.Weak.html "struct std::rc::Weak")<T>[src]
Makes a clone of the Weak pointer that points to the same value.
use std::rc::{Rc, Weak};
let weak_five = Rc::downgrade(&Rc::new(5));
Weak::clone(&weak_five);Run
fn [clone_from](../../std/clone/trait.Clone.html#method.clone%5Ffrom)(&mut self, source: [&](../primitive.reference.html)Self)
1.0.0
Performs copy-assignment from source. Read more
impl<T> [Default](../../std/default/trait.Default.html "trait std::default::Default") for [Weak](../../std/rc/struct.Weak.html "struct std::rc::Weak")<T>
1.10.0
fn [default](../../std/default/trait.Default.html#tymethod.default)() -> [Weak](../../std/rc/struct.Weak.html "struct std::rc::Weak")<T>[src]
Constructs a new Weak<T>, allocating memory for T without initializing it. Calling upgrade on the return value always gives None.
use std::rc::Weak;
let empty: Weak = Default::default(); assert!(empty.upgrade().is_none());Run
`impl Debug for Weak where
`impl Drop for Weak where
fn [drop](../../std/ops/trait.Drop.html#tymethod.drop)(&mut self)[src]
Drops the Weak pointer.
use std::rc::{Rc, Weak};
struct Foo;
impl Drop for Foo { fn drop(&mut self) { println!("dropped!"); } }
let foo = Rc::new(Foo); let weak_foo = Rc::downgrade(&foo); let other_weak_foo = Weak::clone(&weak_foo);
drop(weak_foo);
drop(foo);
assert!(other_weak_foo.upgrade().is_none());Run