Struct enso_flexer::prelude::Weak 1.4.0[−][src]
pub struct Weak<T> where
T: ?Sized, { /* fields omitted */ }
Expand description
Weak
is a version of Rc
that holds a non-owning reference to the
managed allocation. The allocation is accessed by calling upgrade
on the Weak
pointer, which returns an Option
<
Rc
<T>>
.
Since a Weak
reference does not count towards ownership, it will not
prevent the value stored in the allocation from being dropped, and Weak
itself makes no
guarantees about the value still being present. Thus it may return None
when upgrade
d. Note however that a Weak
reference does prevent the allocation
itself (the backing store) from being deallocated.
A Weak
pointer is useful for keeping a temporary reference to the allocation
managed by Rc
without preventing its inner value from being dropped. 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 Weak
pointers from children back to their parents.
The typical way to obtain a Weak
pointer is to call Rc::downgrade
.
Implementations
impl<T> Weak<T> where
T: ?Sized,
[src]
impl<T> Weak<T> where
T: ?Sized,
[src]pub fn as_ptr(&self) -> *const T
1.45.0[src]
pub fn as_ptr(&self) -> *const T
1.45.0[src]Returns a raw pointer to the object T
pointed to by this Weak<T>
.
The pointer is valid only if there are some strong references. The pointer may be dangling,
unaligned or even null
otherwise.
Examples
use std::rc::Rc; use std::ptr; let strong = Rc::new("hello".to_owned()); let weak = Rc::downgrade(&strong); // Both point to the same object assert!(ptr::eq(&*strong, weak.as_ptr())); // The strong here keeps it alive, so we can still access the object. assert_eq!("hello", unsafe { &*weak.as_ptr() }); drop(strong); // But not any more. We can do weak.as_ptr(), but accessing the pointer would lead to // undefined behaviour. // assert_eq!("hello", unsafe { &*weak.as_ptr() });
pub fn into_raw(self) -> *const T
1.45.0[src]
pub fn into_raw(self) -> *const T
1.45.0[src]Consumes the Weak<T>
and turns it into a raw pointer.
This converts the weak pointer into a raw pointer, while still preserving the ownership of
one weak reference (the weak count is not modified by this operation). It can be turned
back into the Weak<T>
with from_raw
.
The same restrictions of accessing the target of the pointer as with
as_ptr
apply.
Examples
use std::rc::{Rc, Weak}; let strong = Rc::new("hello".to_owned()); let weak = Rc::downgrade(&strong); let raw = weak.into_raw(); assert_eq!(1, Rc::weak_count(&strong)); assert_eq!("hello", unsafe { &*raw }); drop(unsafe { Weak::from_raw(raw) }); assert_eq!(0, Rc::weak_count(&strong));
pub unsafe fn from_raw(ptr: *const T) -> Weak<T>
1.45.0[src]
pub unsafe fn from_raw(ptr: *const T) -> Weak<T>
1.45.0[src]Converts a raw pointer previously created by into_raw
back into Weak<T>
.
This can be used to safely get a strong reference (by calling upgrade
later) or to deallocate the weak count by dropping the Weak<T>
.
It takes ownership of one weak reference (with the exception of pointers created by new
,
as these don’t own anything; the method still works on them).
Safety
The pointer must have originated from the into_raw
and must still own its potential
weak reference.
It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this
takes ownership of one weak reference currently represented as a raw pointer (the weak
count is not modified by this operation) and therefore it must be paired with a previous
call to into_raw
.
Examples
use std::rc::{Rc, Weak}; let strong = Rc::new("hello".to_owned()); let raw_1 = Rc::downgrade(&strong).into_raw(); let raw_2 = Rc::downgrade(&strong).into_raw(); assert_eq!(2, Rc::weak_count(&strong)); assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap()); assert_eq!(1, Rc::weak_count(&strong)); drop(strong); // Decrement the last weak count. assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none());
pub fn upgrade(&self) -> Option<Rc<T>>
[src]
pub fn upgrade(&self) -> Option<Rc<T>>
[src]Attempts to upgrade the Weak
pointer to an Rc
, delaying
dropping of the inner value if successful.
Returns None
if the inner value has since been dropped.
Examples
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()); // Destroy all strong pointers. drop(strong_five); drop(five); assert!(weak_five.upgrade().is_none());
pub fn strong_count(&self) -> usize
1.41.0[src]
pub fn strong_count(&self) -> usize
1.41.0[src]Gets the number of strong (Rc
) pointers pointing to this allocation.
If self
was created using Weak::new
, this will return 0.
pub fn weak_count(&self) -> usize
1.41.0[src]
pub fn weak_count(&self) -> usize
1.41.0[src]Gets the number of Weak
pointers pointing to this allocation.
If no strong pointers remain, this will return zero.
pub fn ptr_eq(&self, other: &Weak<T>) -> bool
1.39.0[src]
pub fn ptr_eq(&self, other: &Weak<T>) -> bool
1.39.0[src]Returns true
if the two Weak
s point to the same allocation (similar to
ptr::eq
), or if both don’t point to any allocation
(because they were created with Weak::new()
).
Notes
Since this compares pointers it means that Weak::new()
will equal each
other, even though they don’t point to any allocation.
Examples
use std::rc::Rc; let first_rc = Rc::new(5); let first = Rc::downgrade(&first_rc); let second = Rc::downgrade(&first_rc); assert!(first.ptr_eq(&second)); let third_rc = Rc::new(5); let third = Rc::downgrade(&third_rc); assert!(!first.ptr_eq(&third));
Comparing Weak::new
.
use std::rc::{Rc, Weak}; let first = Weak::new(); let second = Weak::new(); assert!(first.ptr_eq(&second)); let third_rc = Rc::new(()); let third = Rc::downgrade(&third_rc); assert!(!first.ptr_eq(&third));
Trait Implementations
impl<T> Clone for Weak<T> where
T: ?Sized,
[src]
impl<T> Clone for Weak<T> where
T: ?Sized,
[src]pub fn clone(&self) -> Weak<T>
[src]
pub fn clone(&self) -> Weak<T>
[src]Makes a clone of the Weak
pointer that points to the same allocation.
Examples
use std::rc::{Rc, Weak}; let weak_five = Rc::downgrade(&Rc::new(5)); let _ = Weak::clone(&weak_five);
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]Performs copy-assignment from source
. Read more
impl<T> Drop for Weak<T> where
T: ?Sized,
[src]
impl<T> Drop for Weak<T> where
T: ?Sized,
[src]pub fn drop(&mut self)
[src]
pub fn drop(&mut self)
[src]Drops the Weak
pointer.
Examples
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); // Doesn't print anything drop(foo); // Prints "dropped!" assert!(other_weak_foo.upgrade().is_none());
impl<T> WeakElement for Weak<T> where
T: ?Sized,
[src]
impl<T> WeakElement for Weak<T> where
T: ?Sized,
[src]pub fn new(view: &<Weak<T> as WeakElement>::Strong) -> Weak<T>
[src]
pub fn new(view: &<Weak<T> as WeakElement>::Strong) -> Weak<T>
[src]Constructs a weak pointer from a strong pointer. Read more
pub fn view(&self) -> Option<<Weak<T> as WeakElement>::Strong>
[src]
pub fn view(&self) -> Option<<Weak<T> as WeakElement>::Strong>
[src]Acquires a strong pointer from a weak pointer. Read more
pub fn clone(
view: &<Weak<T> as WeakElement>::Strong
) -> <Weak<T> as WeakElement>::Strong
[src]
pub fn clone(
view: &<Weak<T> as WeakElement>::Strong
) -> <Weak<T> as WeakElement>::Strong
[src]Clones a strong pointer. Read more
fn is_expired(&self) -> bool
[src]
fn is_expired(&self) -> bool
[src]Is the given weak element expired? Read more
impl<T, U> CoerceUnsized<Weak<U>> for Weak<T> where
T: Unsize<U> + ?Sized,
U: ?Sized,
[src]
T: Unsize<U> + ?Sized,
U: ?Sized,
impl<T, U> DispatchFromDyn<Weak<U>> for Weak<T> where
T: Unsize<U> + ?Sized,
U: ?Sized,
[src]
T: Unsize<U> + ?Sized,
U: ?Sized,
impl<T> !Send for Weak<T> where
T: ?Sized,
[src]
T: ?Sized,
impl<T> !Sync for Weak<T> where
T: ?Sized,
[src]
T: ?Sized,
Auto Trait Implementations
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> HasRefValue for T where
T: ?Sized,
[src]
impl<T> HasRefValue for T where
T: ?Sized,
[src]type RefValue = T
impl<T> PhantomConversions for T
[src]
impl<T> PhantomConversions for T
[src]fn phantom_into<P>() -> P where
Self: PhantomInto<P>,
[src]
Self: PhantomInto<P>,
fn phantom_from<P>() -> Self where
P: PhantomInto<Self>,
[src]
P: PhantomInto<Self>,
impl<T> Same<T> for T
impl<T> Same<T> for T
type Output = T
type Output = T
Should always be Self
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
pub fn to_subset(&self) -> Option<SS>
pub fn to_subset(&self) -> Option<SS>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
pub fn is_in_subset(&self) -> bool
pub fn is_in_subset(&self) -> bool
Checks if self
is actually part of its subset T
(and can be converted to it).
pub fn to_subset_unchecked(&self) -> SS
pub fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset
but without any property checks. Always succeeds.
pub fn from_subset(element: &SS) -> SP
pub fn from_subset(element: &SS) -> SP
The inclusion map: converts self
to the equivalent element of its superset.
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
impl<T> TypeDisplay for T
[src]
impl<T> TypeDisplay for T
[src]pub default fn type_display() -> String
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
pub fn vzip(self) -> V
impl<T> Writer for T
[src]
impl<T> Writer for T
[src]pub default fn write_by_level(&self, message: &Array)
[src]
pub default fn write_by_level(&self, message: &Array)
[src]Write message using the appropriate console method.