Struct asynchron::SyncState

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

Simple helper thread safe state management,

using std::sync::Arc and std::sync::Mutex under the hood.

Example:

use asynchron::SyncState;

fn main() -> core::result::Result<(), Box<dyn std::error::Error>> {
    let state: SyncState<i32> = SyncState::new(0);
    let _state = state.clone();

    if let Err(_) = std::thread::spawn(move||{
        _state.set(20);
    })
     .join()
    {
        let e = std::io::Error::new(std::io::ErrorKind::Other, "Unable to join thread.");
        return Err(Box::new(e));
    }

    if let Ok(value) = state.get() {
       println!("{:?}", *value);
    } else {
       let e = std::io::Error::new(std::io::ErrorKind::Other, "Mutex poisonous!");
       return Err(Box::new(e));
    }
    Ok(())
}

Implementations

impl<T: Clone + Send + Sync + ?Sized> SyncState<T>

pub fn new(t: T) -> SyncState<T>

Create new state.

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

Get state.

pub fn set(&self, t: T)

Set state.

Trait Implementations

impl<T: Clone> Clone for SyncState<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.