[−][src]Struct sync_wrapper::SyncWrapper
A mutual exclusion primitive that relies on static type information only
In some cases synchronization can be proven statically: whenever you hold an exclusive &mut
reference, the Rust type system ensures that no other part of the program can hold another
reference to the data. Therefore it is safe to access it even if the current thread obtained
this reference via a channel. Whenever this is the case, the overhead of allocating and locking
a Mutex
can be avoided by using this static version.
One example where this is often applicable is Future
, which requires an exclusive reference
for its poll
method: While a given Future
implementation may not be safe to access by
multiple threads concurrently, the executor can only run the Future
on one thread at any
given time, making it Sync
in practice as long as the implementation is Send
. You can
therefore use the static mutex to prove that your data structure is Sync
even though it
contains such a Future
.
Example
use sync_wrapper::SyncWrapper; use std::future::Future; struct MyThing { future: SyncWrapper<Box<dyn Future<Output = String> + Send>>, } impl MyThing { // all accesses to `self.future` now require an exclusive reference or ownership } fn assert_sync<T: Sync>() {} assert_sync::<MyThing>();
Implementations
impl<T> SyncWrapper<T>
[src]
pub fn new(value: T) -> Self
[src]
Creates a new static mutex containing the given value.
Examples
use sync_wrapper::SyncWrapper; let mutex = SyncWrapper::new(42);
pub fn get_mut(&mut self) -> &mut T
[src]
Acquires a reference to the protected value.
This is safe because it requires an exclusive reference to the mutex. Therefore this method
neither panics nor does it return an error. This is in contrast to Mutex::get_mut
which
returns an error if another thread panicked while holding the lock. It is not recommended
to send an exclusive reference to a potentially damaged value to another thread for further
processing.
Examples
use sync_wrapper::SyncWrapper; let mut mutex = SyncWrapper::new(42); let value = mutex.get_mut(); *value = 0; assert_eq!(*mutex.get_mut(), 0);
pub fn into_inner(self) -> T
[src]
Consumes this mutex, returning the underlying data.
This is safe because it requires ownership of the mutex, therefore this method will neither
panic nor does it return an error. This is in contrast to Mutex::into_inner
which
returns an error if another thread panicked while holding the lock. It is not recommended
to send an exclusive reference to a potentially damaged value to another thread for further
processing.
Examples
use sync_wrapper::SyncWrapper; let mut mutex = SyncWrapper::new(42); assert_eq!(mutex.into_inner(), 42);
Trait Implementations
impl<T: Send> Sync for SyncWrapper<T>
[src]
Auto Trait Implementations
impl<T> RefUnwindSafe for SyncWrapper<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for SyncWrapper<T> where
T: Send,
T: Send,
impl<T> Unpin for SyncWrapper<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for SyncWrapper<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,