rgraph 0.2.2

A task graph library.
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#[macro_export]
macro_rules! asset_str(
    ($node:ident, $asset:ident) => {
        concat!(stringify!($node), "::", stringify!($asset))
    };
    ($node:expr, $asset:ident) => {
        concat!($node, "::", stringify!($asset))
    };
    ($node:expr, $asset:expr) => {
        concat!($node, "::", $asset)
    };
);

#[macro_export]
macro_rules! asset_string(
    (as_str, $node:expr, $asset:ident) => {
        [$node.as_str(), stringify!($asset)].join("::")
    };
);

/// Macro to generate a Node (Task).
/// It requires:
///   a name (as used in the solver to execute it),
///   a set of inputs,
///   a set of outputs, and
///   a set of statements which are the body of the task
#[macro_export]
macro_rules! create_node(

    // name as expression allows to generate function names programatically
    ( name: $name:expr,
      ( $( $in:ident : $it:ty ),* ) ->
      ( $( $out:ident : $ot:ty ),* ) $( $body:stmt )+ ) => {
        {
            let tmp = $name.clone();
            Node::new($name.clone(),
               move | solver : &mut GraphSolver  |
               {
                    // get inputs
                    $(
                        let $in : $it = solver.get_value::<$it>(
                                            solver.get_binding(&asset_string!(as_str, tmp, $in))?
                                    )?;
                    )*

                    // if any of the inputs is new (or there are no imputs)
                    let eq = [ $( solver.input_is_new(&$in, &asset_string!(as_str, tmp, $in)) ),* ];
                    if !eq.iter().fold(false, |acum, b| acum || *b){
                        let tmp = tmp.clone();
                        let outs = vec!( $( asset_string!(as_str, tmp, $out) ),* );
                        if solver.use_old_ouput(&outs){
                            return Ok(SolverStatus::Cached);
                        }
                    }

                    // exec body (declare out vars, uninitalized)
                    $( let $out : $ot; )*
                    $( $body )+

                    // save outputs (re assign, this guarantees output type)
                    $( let $out : $ot = $out; )*
                    $( solver.save_value(&asset_string!(as_str, tmp, $out), $out); )*

                    // set the status to executed
                    Ok(SolverStatus::Executed)
               },
               vec!( $( asset_string!(as_str, $name.clone(), $in) ),* ),
               vec!( $( asset_string!(as_str, $name.clone(), $out) ),* ),
           )
        }
    };

    // no quotes in name, more function like
    ( $name:ident
      ( $( $in:ident : $it:ty ),* ) ->
      ( $( $out:ident : $ot:ty ),* ) $( $body:stmt )+ ) => {
        Node::new(stringify!($name).to_string(),
           move | solver : &mut GraphSolver  |
           {
                // get inputs
                $(
                    let $in : $it = solver.get_value::<$it>(
                                        solver.get_binding(asset_str!($name,$in))?
                                )?;
                )*

                // if any of the inputs is new (or there are no imputs)
                let eq = [ $( solver.input_is_new_str(&$in, asset_str!($name,$in)) ),* ];
                if !eq.iter().fold(false, |acum, b| acum || *b){
                    let outs : Vec<&'static str> = vec!( $( asset_str!($name,$out) ),* );
                    if solver.use_old_ouput(&outs){
                        return Ok(SolverStatus::Cached);
                    }
                }

                // exec body (declare out vars, uninitalized)
                $( let $out : $ot; )*
                $( $body )+

                // save outputs (re assign, this guarantees output type)
                $( let $out : $ot = $out; )*
                $( solver.save_value_str(asset_str!($name,$out), $out); )*

                // set the status to executed
                Ok(SolverStatus::Executed)
           },
           vec!( $( asset_str!($name, $in).to_string() ),* ),
           vec!( $( asset_str!($name, $out).to_string() ),* ),
       )
    };
);

#[cfg(test)]
mod tests {

    #[test]
    fn names() {
        assert!(asset_str!(one, two) == "one::two");
        assert!(asset_str!("one", two) == "one::two");
        assert!(asset_str!("one", "two") == "one::two");
    }
}