ebi_bpmn 0.0.29

A BPMN parser, writer and executor
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

use crate::{
    BusinessProcessModelAndNotation,
    element::BPMNElement,
    semantics::BPMNSubMarking,
    sequence_flow::BPMNSequenceFlow,
    traits::{objectable::BPMNObject, startable::InitiationMode},
};
use anyhow::{Result, anyhow};
use std::fmt::Debug;

/// a trait with methods for container elements
pub trait Processable: BPMNObject + Debug {
    /// return the elements of this process, but do not recurse
    fn elements_non_recursive(&self) -> &Vec<BPMNElement>;

    /// return the sequence flows of this process, but do not recurse
    fn sequence_flows_non_recursive(&self) -> &Vec<BPMNSequenceFlow>;

    /// return a initial marking
    fn to_sub_marking(&self, initiation_mode: &InitiationMode) -> Result<BPMNSubMarking>;

    /// return whether this is a sub-process, i.e. not a pool or a root of the model
    fn is_sub_process(&self) -> bool;

    /// return the element that is the target of the given sequence flow
    fn sequence_flow_index_2_source(&self, sequence_flow_index: usize) -> Result<&BPMNElement> {
        let sequence_flow = self
            .sequence_flows_non_recursive()
            .get(sequence_flow_index)
            .ok_or_else(|| anyhow!("sequence flow of index {} not found", sequence_flow_index))?;
        self.elements_non_recursive()
            .get(sequence_flow.source_local_index)
            .ok_or_else(|| {
                anyhow!(
                    "the target of sequence flow `{}` was not found",
                    sequence_flow.id
                )
            })
    }

    /// return the element that is the target of the given sequence flow
    fn sequence_flow_index_2_target(&self, sequence_flow_index: usize) -> Result<&BPMNElement> {
        let sequence_flow = self
            .sequence_flows_non_recursive()
            .get(sequence_flow_index)
            .ok_or_else(|| anyhow!("sequence flow of index {} not found", sequence_flow_index))?;
        self.elements_non_recursive()
            .get(sequence_flow.target_local_index)
            .ok_or_else(|| {
                anyhow!(
                    "the target of sequence flow `{}` was not found",
                    sequence_flow.id
                )
            })
    }
}

static EMPTY_FLOWS: Vec<BPMNSequenceFlow> = vec![];

impl Processable for BusinessProcessModelAndNotation {
    fn elements_non_recursive(&self) -> &Vec<BPMNElement> {
        &self.elements
    }

    fn sequence_flows_non_recursive(&self) -> &Vec<BPMNSequenceFlow> {
        &EMPTY_FLOWS
    }

    fn to_sub_marking(&self, _initiation_mode: &InitiationMode) -> Result<BPMNSubMarking> {
        Err(anyhow!("call the dedicated function"))
    }

    fn is_sub_process(&self) -> bool {
        false
    }
}