Struct asynchron::SyncState

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

Tricky oneshot thread safe state management

WARNING! (if not sure how to use it, don’t use it)

using std::sync::Arc, std::sync::Mutex and core::option::Option 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();
    
    // The state will be empty if it successfully loaded.
    match state.load() {
        Some(value) => {
            println!("initial value: {:?}", value)
        }
        _ => (),
    }
    
    assert_eq!(true, state.is_empty());

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

    if state.is_full() {
        match state.load() {
            Some(value) => {
                assert_eq!(value, 20);
                println!("latest value {:?}", value)
            }
            _ => {
                let e = std::io::Error::new(std::io::ErrorKind::Other, "State not restore.");
                return Err(Box::new(e));
            }
        }
    }
    
    assert_eq!(true, state.is_empty());
    
    Ok(())
}

Implementations

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

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

Create new state.

pub fn load(&self) -> Option<T>

Load new value from the state.

pub fn store(&self, t: T)

Store new value to the state

pub fn is_empty(&self) -> bool

Check if the state isn’t full (if it isn’t full, just store it).

pub fn is_full(&self) -> bool

Check if the state isn’t empty (if it isn’t empty, just load it).

Trait Implementations

impl<T> Clone for SyncState<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.