wasm4pm 26.7.1

High-performance process mining algorithms in WebAssembly for JavaScript/TypeScript
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

//! Process tree data model for POWL → ProcessTree conversion.

use serde::{Deserialize, Serialize};

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum PtOperator {
    Sequence,
    Xor,
    Parallel,
    Loop,
}

impl PtOperator {
    pub fn as_str(self) -> &'static str {
        match self {
            PtOperator::Sequence => "->",
            PtOperator::Xor => "X",
            PtOperator::Parallel => "+",
            PtOperator::Loop => "*",
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ProcessTree {
    pub label: Option<String>,
    pub operator: Option<PtOperator>,
    #[serde(default)]
    pub children: Vec<ProcessTree>,
}

impl ProcessTree {
    pub fn leaf(label: Option<String>) -> Self {
        ProcessTree {
            label,
            operator: None,
            children: Vec::new(),
        }
    }

    pub fn internal(operator: PtOperator, children: Vec<ProcessTree>) -> Self {
        ProcessTree {
            label: None,
            operator: Some(operator),
            children,
        }
    }

    pub fn to_repr(&self) -> String {
        match (&self.operator, &self.label) {
            (None, None) => "tau".to_string(),
            (None, Some(l)) => l.clone(),
            (Some(op), _) => {
                let children: Vec<String> = self.children.iter().map(|c| c.to_repr()).collect();
                format!("{} ( {} )", op.as_str(), children.join(", "))
            }
        }
    }
}