Struct more_sync::Carrier

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

A Carrier that manages the lifetime of an instance of type T.

The carrier owns the instance (the target). References to the target can be obtained by calling the create_ref method. The references returned by the method will be valid as long as the reference is alive.

The carrier can be closed, after which no new references can be obtained. The carrier can also wait for all references it gave out to be dropped. The ownership of target will be returned to the caller after the wait is complete. The caller can then carry out clean-ups or any other type of work that requires an owned instance of type T.

use more_sync::Carrier;

// Create a carrier that holds a mutex.
let carrier = Carrier::new(std::sync::Mutex::new(7usize));

// Ask for a reference to the value held by the carrier.
let ref_one = carrier.create_ref().unwrap();
assert_eq!(*ref_one.lock().unwrap(), 7);

// Reference returned by Carrier can be sent to another thread.
std::thread::spawn(move || *ref_one.lock().unwrap() = 8usize);

// Close the carrier, no new references can be created.
carrier.close();
assert!(carrier.create_ref().is_none());

// Shutdown the carrier and wait for all references to be dropped.
// The value held by carrier is returned.
let mutex_value = carrier.wait();
// Destroy the mutex.
assert!(matches!(mutex_value.into_inner(), Ok(8usize)));

Implementations

impl<T> Carrier<T>

pub fn new(target: T) -> Self

pub fn ref_count(&self) -> usize

pub fn create_ref(&self) -> Option<CarrierRef<T>>

pub fn close(&self)

pub fn wait(self) -> T

pub fn wait_timeout(self, timeout: Duration) -> Result<T, Self>

pub fn shutdown(self) -> T

pub fn shutdown_timeout(self, timeout: Duration) -> Result<T, Self>