plyne 0.2.0

Based pipeline of async task system
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

pub mod function;
pub mod pipeline;

pub use function::*;
pub use pipeline::*;

pub use magic_params;
pub use paste;

// Pipeline
pub type Input<T> = tokio::sync::mpsc::UnboundedSender<T>;
pub type Output<T> = tokio::sync::mpsc::UnboundedReceiver<T>;

#[macro_export]
macro_rules! define_tasks {
    (
        $tasks_name: ident
        pipelines {
            $($name: ident: $ty: ty),* $(,)?
        }
        vars {
            $($var: ident: $vty: ty),* $(,)?
        }
        tasks {
            $($task: ident),* $(,)?
        }
    ) => {
        $crate::paste::paste! {
            // Context
            $crate::magic_params::define_context!([< $tasks_name Context >] {
                $( $name: $crate::Pipeline<$ty>,)*
                $( $var: $vty,)*
            });

            // Pipelines
            $(
                impl [< From $tasks_name Context >]<'_> for $crate::Input<$ty> {
                    fn from_context(ctx: &[< $tasks_name Context >]) -> Self { ctx.$name.input().unwrap() }
                }

                impl [< From $tasks_name Context >]<'_> for $crate::Output<$ty> {
                    fn from_context(ctx: &[< $tasks_name Context >]) -> Self { ctx.$name.output().unwrap() }
                }
            )*

            $crate::magic_params::context_as_params!([< $tasks_name Context >], 12);

            // System
            struct $tasks_name([< $tasks_name Context >]);

            impl $tasks_name {
                #[must_use]
                #[allow(dead_code)]
                pub fn new($($var: $vty),*) -> Self {
                    Self([< $tasks_name Context >] {
                        $( $name: $crate::Pipeline::new(false), )*
                        $( $var, )*
                    })
                }

                #[allow(dead_code)]
                pub async fn execute(self) -> [< $tasks_name Context >] {
                    futures::join!( $( $task.call(&self.0), )* );
                    self.0
                }
            }
        }
    };
}