snurr 0.10.3

Read BPMN 2.0 files and run the process flow
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

use super::handler::HandlerMap;
use crate::model::{ActivityType, Bpmn, Gateway, GatewayType};
use std::collections::{HashMap, HashSet};

#[derive(Debug)]
pub(super) struct Diagram {
    data: Vec<Vec<Bpmn>>,
    boundaries: HashMap<String, Vec<usize>>,
    catch_event_links: HashMap<String, HashMap<String, usize>>,
}

impl Diagram {
    pub(super) fn new(
        data: Vec<Vec<Bpmn>>,
        boundaries: HashMap<String, Vec<usize>>,
        catch_event_links: HashMap<String, HashMap<String, usize>>,
    ) -> Self {
        Self {
            data,
            boundaries,
            catch_event_links,
        }
    }
    // All top level processes defined in Definitions.
    // Always last in the Vec as it is a top level construct in the XML.
    pub(super) fn get_processes(&self) -> Option<&Vec<Bpmn>> {
        self.data.last()
    }

    // Can be a process or sub process
    pub(super) fn get_process(&self, process_id: usize) -> Option<&Vec<Bpmn>> {
        self.data.get(process_id)
    }

    pub(super) fn data(&self) -> &[Vec<Bpmn>] {
        self.data.as_slice()
    }

    pub(super) fn boundaries(&self) -> &HashMap<String, Vec<usize>> {
        &self.boundaries
    }

    pub(super) fn catch_event_links(&self) -> &HashMap<String, HashMap<String, usize>> {
        &self.catch_event_links
    }

    pub(super) fn install_and_check(&mut self, handler_map: HandlerMap) -> HashSet<String> {
        let mut missing = HashSet::new();
        for bpmn in self.data.iter_mut().flatten() {
            match bpmn {
                Bpmn::Activity {
                    id,
                    name,
                    func_idx,
                    activity:
                        activity @ (ActivityType::Task
                        | ActivityType::ScriptTask
                        | ActivityType::UserTask
                        | ActivityType::ServiceTask
                        | ActivityType::CallActivity
                        | ActivityType::ReceiveTask
                        | ActivityType::SendTask
                        | ActivityType::ManualTask
                        | ActivityType::BusinessRuleTask),
                    ..
                } => {
                    let name_or_id: &str = name.as_deref().unwrap_or(id.bpmn());
                    if let Some(id) = handler_map.task().get(name_or_id) {
                        func_idx.replace(*id);
                    } else {
                        missing.insert(format!("{}: {}", activity, name_or_id));
                    }
                }
                Bpmn::Gateway(Gateway {
                    gateway:
                        gateway @ (GatewayType::EventBased
                        | GatewayType::Exclusive
                        | GatewayType::Inclusive),
                    name,
                    id,
                    func_idx,
                    outputs,
                    ..
                }) if outputs.len() > 1 => {
                    let map = match gateway {
                        GatewayType::Exclusive => handler_map.exclusive(),
                        GatewayType::Inclusive => handler_map.inclusive(),
                        GatewayType::EventBased => handler_map.event_based(),
                        _ => continue,
                    };

                    let name_or_id: &str = name.as_deref().unwrap_or(id.bpmn());
                    if let Some(id) = map.get(name_or_id) {
                        func_idx.replace(*id);
                    } else {
                        missing.insert(format!("{}: {}", gateway, name_or_id));
                    }
                }
                _ => {}
            }
        }
        missing
    }
}