impl<T> SyncWrapper<T>

const fn new(value: T) -> Self

Creates a new static mutex containing the given value.

Examples

use sync_wrapper::SyncWrapper;

let mutex = SyncWrapper::new(42);

fn get_mut(&mut self) -> &mut T

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

fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T>

Acquires a pinned reference to the protected value.

See Self::get_mut for why this method is safe.

Examples

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

use pin_project_lite::pin_project;
use sync_wrapper::SyncWrapper;

pin_project! {
    struct FutureWrapper<F> {
        #[pin]
        inner: SyncWrapper<F>,
    }
}

impl<F: Future> Future for FutureWrapper<F> {
    type Output = F::Output;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        self.project().inner.get_pin_mut().poll(cx)
    }
}

fn into_inner(self) -> T

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