acts 0.19.0

a fast, lightweight, 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

mod act_executor;
mod event_executor;
mod message_executor;
mod model_executor;
mod package_executor;
mod process_executor;
mod task_executor;

use crate::scheduler::Runtime;
use std::sync::Arc;

#[derive(Clone)]
pub struct Executor {
    msg: message_executor::MessageExecutor,
    act: act_executor::ActExecutor,
    model: model_executor::ModelExecutor,
    proc: process_executor::ProcessExecutor,
    task: task_executor::TaskExecutor,
    pack: package_executor::PackageExecutor,
    evt: event_executor::EventExecutor,
}

impl Executor {
    pub(crate) fn new(rt: &Arc<Runtime>) -> Self {
        Self {
            msg: message_executor::MessageExecutor::new(rt),
            act: act_executor::ActExecutor::new(rt),
            model: model_executor::ModelExecutor::new(rt),
            proc: process_executor::ProcessExecutor::new(rt),
            task: task_executor::TaskExecutor::new(rt),
            pack: package_executor::PackageExecutor::new(rt),
            evt: event_executor::EventExecutor::new(rt),
        }
    }

    /// executor for related message functions
    pub fn msg(&self) -> &message_executor::MessageExecutor {
        &self.msg
    }

    /// executor for related act operations
    /// such as 'complete', 'back', 'cancel' ..
    pub fn act(&self) -> &act_executor::ActExecutor {
        &self.act
    }

    /// executor for related model functions
    pub fn model(&self) -> &model_executor::ModelExecutor {
        &self.model
    }

    /// executor for related process functions
    pub fn proc(&self) -> &process_executor::ProcessExecutor {
        &self.proc
    }

    /// executor for related task functions
    pub fn task(&self) -> &task_executor::TaskExecutor {
        &self.task
    }

    /// executor for related package functions
    pub fn pack(&self) -> &package_executor::PackageExecutor {
        &self.pack
    }

    /// executor for related event functions
    pub fn evt(&self) -> &event_executor::EventExecutor {
        &self.evt
    }
}