yao 0.1.4

a fast, tiny, extensiable workflow engine
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
123
124
125
126
127
128
129

macro_rules! impl_act_state {
    ($type: tt) => {
        impl $type {
            pub(crate) fn set_state(&self, state: &TaskState) {
                let state = state.clone();
                let time: chrono::DateTime<chrono::Utc> = chrono::Utc::now();
                let time_millis = time.timestamp_millis();
                if state == TaskState::Running || state == TaskState::WaitingEvent {
                    *self.start_time.write().unwrap() = time_millis;
                } else {
                    if state != TaskState::None && state != TaskState::Pending {
                        *self.end_time.write().unwrap() = time_millis;
                    }
                }

                *self.state.write().unwrap() = state;
            }

            #[allow(unused)]
            pub(crate) fn pending(&self) -> bool {
                let state = self.state();
                state == TaskState::Pending
            }

            #[allow(unused)]
            pub(crate) fn waiting(&self) -> bool {
                let state = self.state();
                state == TaskState::WaitingEvent
            }

            #[allow(unused)]
            pub(crate) fn failed(&self) -> bool {
                let state = self.state();
                match state {
                    TaskState::Abort(..) | TaskState::Fail(..) => true,
                    _ => false,
                }
            }

            #[allow(unused)]
            pub(crate) fn finished(&self) -> bool {
                let state = self.state();
                match state {
                    TaskState::None
                    | TaskState::Running
                    | TaskState::Pending
                    | TaskState::WaitingEvent => false,
                    _ => true,
                }
            }

            pub fn state(&self) -> TaskState {
                let state = &*self.state.read().unwrap();
                state.clone()
            }
        }
    };
}

macro_rules! impl_act_time {
    ($type: tt) => {
        impl $type {
            pub fn start_time(&self) -> i64 {
                *self.start_time.read().unwrap()
            }
            pub fn end_time(&self) -> i64 {
                *self.end_time.read().unwrap()
            }

            pub(crate) fn set_start_time(&self, time: i64) {
                *self.start_time.write().unwrap() = time;
            }
            pub(crate) fn set_end_time(&self, time: i64) {
                *self.end_time.write().unwrap() = time;
            }
        }
    };
}

macro_rules! impl_act_id {
    ($type: tt) => {
        impl $type {
            pub fn id(&self) -> String {
                self.id.clone()
            }
            pub fn set_id(&mut self, id: &str) {
                self.id = id.to_string();
            }
        }
    };
}

macro_rules! impl_act_acts {
    ($type: tt) => {
        impl $type {
            pub fn ord(&self) -> usize {
                *self.act_ord.read().unwrap()
            }
            pub(in crate::sch) fn set_ord(&self, ord: usize) {
                *self.act_ord.write().unwrap() = ord;
            }

            pub fn acts(&self) -> Vec<Act> {
                self.acts.read().unwrap().clone()
            }

            pub(in crate::sch) fn push_act(&self, act: &Act) {
                debug!("push_act: {}", act.id);
                self.acts.write().unwrap().push(act.clone());
            }

            pub fn candidates(&self) -> Vec<Act> {
                self.act_candidates.read().unwrap().clone()
            }

            pub(in crate::sch) fn set_candidates(&self, acts: &Vec<Act>) {
                *self.act_candidates.write().unwrap() = acts.clone();
            }

            pub fn matcher(&self) -> Matcher {
                self.act_matcher.read().unwrap().clone()
            }

            pub(in crate::sch) fn set_matcher(&self, matcher: &Matcher) {
                *self.act_matcher.write().unwrap() = matcher.clone();
            }
        }
    };
}