Asynchron

Asynchronize blocking operation.

Example

```rust use asynchron::{Futurize, Futurized, ITaskHandle, Progress}; use std::{ io::Error, time::{Duration, Instant}, };

fn main() { let instant: Instant = Instant::now(); let task: Futurized = Futurize::task( 0, move |task: ITaskHandle| -> Progress { // // Panic if need to. // // will return Error with a message: // // "the task with id: (specific task id) panicked!" // std::panic::panicany("loudness"); let sleepdur = Duration::frommillis(10); std::thread::sleep(sleepdur); let result = Ok::( format!("The task with id: {} wake up from sleep", _task.id()).into(), ); match result { Ok(value) => { // Send current task progress. _task.send(value) } Err(e) => { // Return error immediately if something not right, for example: return Progress::Error(e.tostring().into()); } }

        if _task.should_cancel() {
            _task.send("Canceling the task".into());
            return Progress::Canceled;
        }
        Progress::Completed(instant.elapsed().subsec_millis())
    },
);

// Try do the task now.
task.try_do();

let mut exit = false;
loop {
    task.try_resolve(|progress, done| {
        match progress {
            Progress::Current(task_receiver) => {
                if let Some(value) = task_receiver {
                    println!("{}\n", value)
                }
                // // Cancel if need to.
                // task.cancel()
            }
            Progress::Canceled => {
                println!("The task was canceled\n")
            }
            Progress::Completed(elapsed) => {
                println!("The task finished in: {:?} milliseconds\n", elapsed)
            }
            Progress::Error(e) => {
                println!("{}\n", e)
            }
        }

        if done {
            // This scope act like "finally block", do final things here.
            exit = true
        }
    });

    if exit {
        break;
    }
}

} ```

More Example

Mixing sync and async with tokio, reqwest and fltk-rs can be found here.