Asynchron

Asynchronize blocking operation.

Example

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

fn main() { let instant: Instant = Instant::now(); let task: Futurized = Futurize::task( 0, move |task: ITaskHandle| -> Progress { let sleepdur = Duration::frommillis(10); std::thread::sleep(sleepdur); let value = format!("The task wake up from sleep"); // Send current task progress. // let _ = task.send(value); (to ignore sender error in some specific cases if needed). if let Err(e) = _task.send(value) { // Return error immediately // !WARNING! // if always ignoring error, // Undefined Behavior there's always a chance to occur and hard to debug, // always return error for safety in many cases (recommended), rather than unwrapping. return Progress::Error(format!( "Progress error while sending state: {}", e.tostring(), )); }

        if _task.is_canceled() {
            let _ = _task.send("Canceling the task".into());
            Progress::Canceled
        } else {
            Progress::Completed(instant.elapsed().subsec_millis())
        }
    },
);

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

loop {
    if task.is_in_progress() {
        match task.try_get() {
            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 task.is_done() {
            break;
        }
    }
}

} ```

More Example

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