Struct basedrop::SharedCell

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

A thread-safe shared mutable memory location that holds a Shared<T>.

SharedCell is designed to be low-overhead for readers at the expense of somewhat higher overhead for writers.

Implementations

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

pub fn new(value: Shared<T>) -> SharedCell<T>

Constructs a new SharedCell containing value.

Examples

use basedrop::{Collector, Shared, SharedCell};

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

impl<T> SharedCell<T>

pub fn get(&self) -> Shared<T>

Gets a copy of the contained Shared<T>, incrementing its reference count in the process.

Examples

use basedrop::{Collector, Shared, SharedCell};

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

let y = cell.get();

pub fn set(&self, value: Shared<T>)

Replaces the contained Shared<T>, decrementing its reference count in the process.

Examples

use basedrop::{Collector, Shared, SharedCell};

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

let y = Shared::new(&collector.handle(), 4);
cell.set(y);

pub fn replace(&self, value: Shared<T>) -> Shared<T>

Replaces the contained Shared<T> and returns it.

Examples

use basedrop::{Collector, Shared, SharedCell};

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

let y = Shared::new(&collector.handle(), 4);
let x = cell.replace(y);

pub fn into_inner(self) -> Shared<T>

Consumes the SharedCell and returns the contained Shared<T>. This is safe because we are guaranteed to be the only holder of the SharedCell.

Examples

use basedrop::{Collector, Shared, SharedCell};

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

let x = cell.into_inner();

Trait Implementations

impl<T> Drop for SharedCell<T>

fn drop(&mut self)

Executes the destructor for this type.

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

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