Struct SyncWrapper 

#[non_exhaustive]
pub struct SyncWrapper<T> { /* private fields */ }

Implementations

impl<T> SyncWrapper<T>

where T: Clone,

pub fn new(data: T) -> Self

 use std::sync::Arc;
 use wrapit::SyncWrapper;
 let wrapper = SyncWrapper::new("java");
 assert_eq!(wrapper.get(), SyncWrapper::new("java").get());

pub fn reset(&self, ndata: T) -> &Self

 use wrapit::SyncWrapper;
 let wrapper = SyncWrapper::new("java");
 let res = wrapper.reset("clojure");
 let got = SyncWrapper::new("clojure");
 assert_eq!(*got.lock(), res.get());

pub fn get(&self) -> T

 use wrapit::SyncWrapper;
 use std::sync::Arc;
 let wrapper = SyncWrapper::new("java");
 assert_eq!(wrapper.get(), "java");

pub fn lock(&self) -> MutexGuard<'_, T>

Acquire a lock on the underlying data.

Returns a MutexGuard, allowing mutable access.

Panics

Panics if the mutex is poisoned (another thread panicked while holding the lock).

Examples

use wrapit::SyncWrapper;
let w = SyncWrapper::new(vec![1, 2, 3]);
{
    let mut guard = w.lock();
    guard.push(4);
} // lock released here
assert_eq!(w.get(), vec![1, 2, 3, 4]);

pub fn map<F, U>(&self, f: F) -> U

where F: FnOnce(&T) -> U,

Apply a function to the locked value without exposing the guard.

The lock is automatically released when the function returns.

Panics

Panics if the mutex is poisoned.

Examples

use wrapit::SyncWrapper;
let w = SyncWrapper::new(10i32);
let doubled = w.map(|x| x * 2);
assert_eq!(doubled, 20);
assert_eq!(w.get(), 10); // original unchanged

Trait Implementations

impl<T: Clone> Clone for SyncWrapper<T>

fn clone(&self) -> SyncWrapper<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for SyncWrapper<T>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for SyncWrapper<T>

fn default() -> SyncWrapper<T>

Returns the “default value” for a type.