Lines Matching defs:upgrade
3309 assert!(a.upgrade().is_none());
3313 assert!(a.upgrade().is_none());
3326 assert!(a.upgrade().is_some());
3337 assert!(a.upgrade().is_some());
3341 assert!(b.upgrade().is_none());
3344 assert!(b.upgrade().is_none());
9066 assert!(a.upgrade().is_none());
9070 assert!(a.upgrade().is_none());
9083 assert!(a.upgrade().is_some());
9094 assert!(a.upgrade().is_some());
9098 assert!(b.upgrade().is_none());
9101 assert!(b.upgrade().is_none());
15704 let y_up = Weak::upgrade(&y).unwrap();
15788 assert!(75 == *cow1_weak.upgrade().unwrap());
15793 assert!(cow1_weak.upgrade().is_none());
15800 assert!(y.upgrade().is_some());
15808 assert!(y.upgrade().is_none());
15849 let b = w.upgrade().expect("");
15904 assert!(y.upgrade().is_none());
15918 assert!(y.upgrade().is_none());
15934 assert!(foo.upgrade().is_none());
16113 assert!(inner.upgrade().is_none());
16130 assert!(inner.upgrade().is_none());
16137 let one_ref2 = Weak::upgrade(&one_ref.inner).unwrap();
16152 assert!(inner.upgrade().is_none());
16163 let two_refs1 = Weak::upgrade(&two_refs.inner1).unwrap();
16166 let two_refs2 = Weak::upgrade(&two_refs.inner2).unwrap();
19519 //! [`Weak`] pointer. A [`Weak`] pointer can be [`upgrade`][upgrade]d
19710 //! // `upgrade`, which returns an `Option<Rc<Gadget>>`.
19716 //! let gadget = gadget_weak.upgrade().unwrap();
19734 //! [upgrade]: Weak::upgrade
19848 /// to upgrade the weak reference before this function returns will result
20613 /// assert!(75 == *weak.upgrade().unwrap());
20618 /// assert!(weak.upgrade().is_none());
21423 /// managed allocation. The allocation is accessed by calling [`upgrade`] on the `Weak`
21429 /// when [`upgrade`]d. Note however that a `Weak` reference *does* prevent the allocation
21441 /// [`upgrade`]: Weak::upgrade
21466 /// Calling [`upgrade`] on the return value always gives [`None`].
21468 /// [`upgrade`]: Weak::upgrade
21476 /// assert!(empty.upgrade().is_none());
21574 /// This can be used to safely get a strong reference (by calling [`upgrade`]
21602 /// assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap());
21608 /// assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none());
21612 /// [`upgrade`]: Weak::upgrade
21634 /// Attempts to upgrade the `Weak` pointer to an [`Rc`], delaying
21648 /// let strong_five: Option<Rc<_>> = weak_five.upgrade();
21655 /// assert!(weak_five.upgrade().is_none());
21658 pub fn upgrade(&self) -> Option<Rc<T>> {
21781 /// assert!(other_weak_foo.upgrade().is_none());
21829 /// Calling [`upgrade`] on the return value always gives [`None`].
21832 /// [`upgrade`]: Weak::upgrade
21840 /// assert!(empty.upgrade().is_none());
23374 /// [`Weak`] pointer. A [`Weak`] pointer can be [`upgrade`][upgrade]d
23439 /// [upgrade]: Weak::upgrade
23522 /// managed allocation. The allocation is accessed by calling [`upgrade`] on the `Weak`
23528 /// when [`upgrade`]d. Note however that a `Weak` reference *does* prevent the allocation
23540 /// [`upgrade`]: Weak::upgrade
23577 // ability to upgrade weak pointers or downgrade strong ones; this is used
23611 /// to upgrade the weak reference before this function returns will result
23661 // in order to synchronize with the `compare_exchange_weak` in `Weak::upgrade`.
24754 // writes to `strong` (in particular in `Weak::upgrade`) prior to decrements
24883 /// Calling [`upgrade`] on the return value always gives [`None`].
24885 /// [`upgrade`]: Weak::upgrade
24893 /// assert!(empty.upgrade().is_none());
24986 /// This can be used to safely get a strong reference (by calling [`upgrade`]
25013 /// assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap());
25019 /// assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none());
25024 /// [`upgrade`]: Weak::upgrade
25048 /// Attempts to upgrade the `Weak` pointer to an [`Arc`], delaying
25062 /// let strong_five: Option<Arc<_>> = weak_five.upgrade();
25069 /// assert!(weak_five.upgrade().is_none());
25072 pub fn upgrade(&self) -> Option<Arc<T>> {
25247 /// Calling [`upgrade`] on the return value always
25250 /// [`upgrade`]: Weak::upgrade
25258 /// assert!(empty.upgrade().is_none());
25289 /// assert!(other_weak_foo.upgrade().is_none());
26426 assert!(y.upgrade().is_some());
26434 assert!(y.upgrade().is_none());
26470 let b = w.upgrade().expect("upgrade of live rc failed");
26586 let y_up = Weak::upgrade(&y).unwrap();
26684 assert!(75 == *cow1_weak.upgrade().unwrap());
26689 assert!(cow1_weak.upgrade().is_none());
26715 assert!(y.upgrade().is_none());
26731 assert!(foo.upgrade().is_none());
26888 assert!(inner.upgrade().is_none());
26906 assert!(inner.upgrade().is_none());
26913 let one_ref2 = Weak::upgrade(&one_ref.inner).unwrap();
26929 assert!(inner.upgrade().is_none());
26936 let two_ref3 = Weak::upgrade(&two_refs.inner).unwrap();
26939 let two_ref2 = Weak::upgrade(&two_refs.inner1).unwrap();