Struct basedrop::Shared

pub struct Shared<T> { /* fields omitted */ }

A reference-counted smart pointer with deferred collection, analogous to Arc.

When a Shared<T>’s reference count goes to zero, its contents are added to the drop queue of the Collector whose Handle it was originally allocated with. As the collector may be on another thread, contents are required to be Send + 'static.

Implementations

impl<T: Send + 'static> Shared<T>

pub fn new(handle: &Handle, data: T) -> Shared<T>

Constructs a new Shared<T>.

Examples

use basedrop::{Collector, Shared};

let collector = Collector::new();
let three = Shared::new(&collector.handle(), 3);

impl<T> Shared<T>

pub fn get_mut(this: &mut Self) -> Option<&mut T>

Returns a mutable reference to the contained value if there are no other extant Shared pointers to the same allocation; otherwise returns None.

Examples

use basedrop::{Collector, Shared};

let collector = Collector::new();
let mut x = Shared::new(&collector.handle(), 3);

*Shared::get_mut(&mut x).unwrap() = 4;
assert_eq!(*x, 4);

let _y = Shared::clone(&x);
assert!(Shared::get_mut(&mut x).is_none());

Trait Implementations

impl<T> Clone for Shared<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Deref for Shared<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> Drop for Shared<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Send + Sync> Send for Shared<T>

impl<T: Send + Sync> Sync for Shared<T>