1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
//! `coachman` is a rust asynchronous task manager built on top of tokio framework.
//!
//! ## Features
//!
//! * **Task count control:**
//! `coachman` allows you to control task count preventing your application from uncontrolled task count explosion.
//! * **Task cancellation:**
//! The main feature of `coachman` is task cancellation. It provides a simple api for making your task cancelable.
//!
//! # Basic example
//!
//! The main feature of coachman is making asynchronous tasks cancelable.
//! Look at the following example:
//!
//! ```
//! use coachman as cm;
//! use coachman::{try_await, Canceled, Completed, TaskError};
//!
//! async fn inner_func(i: usize, duration: u64) {
//! match try_await!(tokio::time::sleep(std::time::Duration::from_secs(duration))) {
//! Canceled => println!("task#{} inner canceled", i),
//! Completed(_) => println!("task#{} inner completed", i),
//! }
//! }
//!
//! async fn outer_func(i: usize, duration: u64) {
//! match try_await!(inner_func(i, duration)) {
//! Canceled => println!("task#{} outer canceled", i),
//! Completed(_) => println!("task#{} outer completed", i),
//! }
//! }
//!
//! #[tokio::main(flavor = "current_thread")]
//! async fn main() {
//! let mut task_handles = Vec::new();
//! for i in 0..5 {
//! let duration = i as u64;
//! task_handles.push(cm::spawn(outer_func(i, duration)));
//! }
//!
//! let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
//! for (i, mut handle) in task_handles.into_iter().enumerate() {
//! if tokio::time::timeout_at(deadline, &mut handle).await.is_ok() {
//! println!("task-{} completed", i);
//! } else {
//! handle.cancel();
//! match handle.await {
//! Result::Err(TaskError::Canceled) => println!("task-{} canceled", i),
//! Result::Err(TaskError::Aborted) => println!("task-{} aborted", i),
//! Result::Err(TaskError::Panicked(_)) => println!("task-{} panicked", i),
//! Result::Ok(_) => unreachable!(),
//! }
//! }
//! }
//! }
//! ```
pub use ;
pub use ;
pub use ;