Struct Weak

pub struct Weak<T, A = Global>
where
    A: Allocator,
    T: ?Sized,
{ /* private fields */ }

Available on crate feature dep_bumpalo only.

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 upgraded. 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>

pub const fn new() -> Weak<T>

Available on crate feature alloc only.

Constructs a new Weak<T>, without allocating any memory. Calling upgrade on the return value always gives None.

Examples

use std::rc::Weak;

let empty: Weak<i64> = Weak::new();
assert!(empty.upgrade().is_none());

impl<T, A> Weak<T, A>

where A: Allocator,

pub fn new_in(alloc: A) -> Weak<T, A>

🔬This is a nightly-only experimental API. (allocator_api)

Available on crate feature alloc only.

Constructs a new Weak<T>, without allocating any memory, technically in the provided allocator. Calling upgrade on the return value always gives None.

Examples

use std::rc::Weak;

let empty: Weak<i64> = Weak::new();
assert!(empty.upgrade().is_none());

impl<T> Weak<T>

where T: ?Sized,

pub unsafe fn from_raw(ptr: *const T) -> Weak<T>

Available on crate feature alloc only.

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, and ptr must point to a block of memory allocated by the global allocator.

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());

impl<T, A> Weak<T, A>

where A: Allocator, T: ?Sized,

pub fn allocator(&self) -> &A

🔬This is a nightly-only experimental API. (allocator_api)

Available on crate feature alloc only.

Returns a reference to the underlying allocator.

pub fn as_ptr(&self) -> *const T

Available on crate feature alloc only.

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 behavior.
// assert_eq!("hello", unsafe { &*weak.as_ptr() });

pub fn into_raw(self) -> *const T

Available on crate feature alloc only.

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 fn into_raw_with_allocator(self) -> (*const T, A)

🔬This is a nightly-only experimental API. (allocator_api)

Available on crate feature alloc only.

Consumes the Weak<T>, returning the wrapped pointer and allocator.

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_in.

The same restrictions of accessing the target of the pointer as with as_ptr apply.

Examples

#![feature(allocator_api)]
use std::rc::{Rc, Weak};
use std::alloc::System;

let strong = Rc::new_in("hello".to_owned(), System);
let weak = Rc::downgrade(&strong);
let (raw, alloc) = weak.into_raw_with_allocator();

assert_eq!(1, Rc::weak_count(&strong));
assert_eq!("hello", unsafe { &*raw });

drop(unsafe { Weak::from_raw_in(raw, alloc) });
assert_eq!(0, Rc::weak_count(&strong));

pub unsafe fn from_raw_in(ptr: *const T, alloc: A) -> Weak<T, A>

🔬This is a nightly-only experimental API. (allocator_api)

Available on crate feature alloc only.

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, and ptr must point to a block of memory allocated by alloc.

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, A>>

where A: Clone,

Available on crate feature alloc only.

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

Available on crate feature alloc only.

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

Available on crate feature alloc only.

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, A>) -> bool

Available on crate feature alloc only.

Returns true if the two Weaks 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()). However, this function ignores the metadata of dyn Trait pointers.

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> Archive for Weak<T>

where T: ArchiveUnsized + ?Sized,

type Archived = ArchivedRcWeak<<T as ArchiveUnsized>::Archived, RcFlavor>

The archived representation of this type.

type Resolver = RcWeakResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <Weak<T> as Archive>::Resolver, out: Place<<Weak<T> as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<T, A> Clone for Weak<T, A>

where A: Allocator + Clone, T: ?Sized,

fn clone(&self) -> Weak<T, A>

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)

Performs copy-assignment from source.

impl<T: ConstDefault> ConstDefault for RcWeak<T>

const DEFAULT: Self

Returns the compile-time “default value” for a type.

impl<T, A> Debug for Weak<T, A>

where A: Allocator, T: ?Sized,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for Weak<T>

fn default() -> Weak<T>

Constructs a new Weak<T>, without allocating any memory. Calling upgrade on the return value always gives None.

Examples

use std::rc::Weak;

let empty: Weak<i64> = Default::default();
assert!(empty.upgrade().is_none());

impl<T, D> Deserialize<Weak<T>, D> for ArchivedRcWeak<<T as ArchiveUnsized>::Archived, RcFlavor>

where T: ArchiveUnsized + LayoutRaw + Pointee + 'static, <T as ArchiveUnsized>::Archived: DeserializeUnsized<T, D>, <T as Pointee>::Metadata: Into<Metadata>, Metadata: Into<<T as Pointee>::Metadata>, D: Fallible + Pooling + ?Sized, <D as Fallible>::Error: Source,

fn deserialize( &self, deserializer: &mut D, ) -> Result<Weak<T>, <D as Fallible>::Error>

Deserializes using the given deserializer

impl<T, A> Drop for Weak<T, A>

where A: Allocator, T: ?Sized,

fn drop(&mut self)

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, S> Serialize<S> for Weak<T>

where T: SerializeUnsized<S> + 'static + ?Sized, S: Fallible + Writer + Sharing + ?Sized, <S as Fallible>::Error: Source,

fn serialize( &self, serializer: &mut S, ) -> Result<<Weak<T> as Archive>::Resolver, <S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<T, U, A> CoerceUnsized<Weak<U, A>> for Weak<T, A>

where T: Unsize<U> + ?Sized, A: Allocator, U: ?Sized,

impl<T, U> DispatchFromDyn<Weak<U>> for Weak<T>

where T: Unsize<U> + ?Sized, U: ?Sized,

impl<T, A> PinCoerceUnsized for Weak<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> !Send for Weak<T, A>

where A: Allocator, T: ?Sized,

impl<T, A> !Sync for Weak<T, A>

where A: Allocator, T: ?Sized,