flowync 5.1.0

A simple utility for multithreading a/synchronization
Documentation 
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

// [dependencies]
// # Make sure to enable tokio "full" features (multithreaded support) like so:
// tokio = { version = "1", features = ["full"] }

use flowync::{error::Cause, Flower};
use std::{io::Error, time::Instant};

type TestTokioFlower = Flower<String, u32>;

#[tokio::main]
async fn main() {
    let instant: Instant = Instant::now();
    let flower: TestTokioFlower = Flower::new(1);
    tokio::spawn({
        let this = flower.handle();
        // Activate
        this.activate();
        async move {
            let id = this.id();
            let result =
                Ok::<String, Error>(format!("the flower with id: {} is flowing", id).into());

            match result {
                Ok(value) => {
                    // Send current flower progress.
                    this.send_async(value).await;
                }
                Err(e) => {
                    // Return error immediately if something not right, for example:
                    return this.error_verbose(e.into());
                }
            }

            // Explicit Cancelation example:
            // Check if the current flower should be canceled
            if this.should_cancel() {
                let value = format!("canceling the flower with id: {}", id);
                this.send_async(value).await;
                return this.error(format!("the flower with id: {} canceled", id));
            }

            // Finalizing
            // either `return this.success(instant.elapsed().subsec_micros());` or
            this.success(instant.elapsed().subsec_micros());
            // both are ok
        }
    });

    let mut done = false;

    loop {
        if flower.is_active() {
            flower
                .extract(|value| println!("{}", value))
                .finalize(|result| {
                    match result {
                        Ok(elapsed) => println!(
                            "the flower with id: {} finished in: {:?} microseconds \n",
                            flower.id(),
                            elapsed
                        ),
                        Err(Cause::Suppose(msg)) => {
                            println!("{}", msg)
                        }
                        Err(Cause::Panicked(msg)) => {
                            println!("{}", msg)
                        }
                    }
                    done = true;
                });
        }

        // Cancel if need to
        // flower.cancel();

        if done {
            break;
        }
    }
}