pmrs 0.0.2

Rust support to process mining functions. Includes a library and a small cli-interface.
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


use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename="gexf")]
pub struct Gexf {
    xmlns: String,
    #[serde(alias="xmlns:xsi", rename(serialize="xmlns:xsi"))]
    xmlnsxsi: String,
    #[serde(alias="xsi:schemaLocation", rename(serialize="xsi:schemaLocation"))]
    schemaloc: String,
    version: String,
    pub meta: Meta,
    pub graph: GraphGexf
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Meta {
    #[serde(rename = "$unflatten=creator")]
    pub creator: String,
    #[serde(rename = "$unflatten=description")]
    pub description: String
}


#[derive(Serialize, Deserialize, Debug)]
pub struct GraphGexf {
    defaultedgetype: String,
    pub attributes: Vec<AttributesGexf>,
    pub nodes: NodesGexf,
    pub edges: EdgesGexf
}

#[derive(Serialize, Deserialize, Debug)]
pub struct AttributesGexf {
    pub class: String,
    #[serde(rename="attribute", default)]
    pub attributes: Vec<AttributeGexf>
}

#[derive(Serialize, Deserialize, Debug)]
pub struct AttributeGexf {
    pub id: String,
    pub title: String,
    #[serde(rename="type")]
    pub attr_type: String
}

#[derive(Serialize, Deserialize, Debug)]
pub struct NodesGexf {
    #[serde(rename="node")]
    pub nodes: Vec<NodeGexf>
}

#[derive(Serialize, Deserialize, Debug)]
pub struct NodeGexf {
    pub id: String,
    pub label: String,
    pub attvalues: AttValuesGexf
}

#[derive(Serialize, Deserialize, Debug)]
pub struct AttValuesGexf {
    #[serde(rename="attvalue")]
    pub attvalues: Vec<AttValueGexf>
}

#[derive(Serialize, Deserialize, Debug)]
pub struct AttValueGexf {
    #[serde(alias="for", rename(serialize="for"))]
    pub attr: String,
    pub value: String

}

#[derive(Serialize, Deserialize, Debug)]
pub struct EdgesGexf {
    #[serde(rename="edge")]
    pub edges: Vec<EdgeGexf>
}


#[derive(Serialize, Deserialize, Debug)]
pub struct EdgeGexf {
    pub source: String, 
    pub target: String,
    pub attvalues: AttValuesGexf
}
impl Gexf {
    pub(crate) fn new() -> Self {
        Self { xmlns: "http://gexf.net/1.3".to_owned(), 
               xmlnsxsi: "http://www.w3.org/2001/XMLSchema-instance".to_owned(), 
               schemaloc: "http://gexf.net/1.3 http://gexf.net/1.3/gexf.xsd".to_owned(), 
               version: "1.3".to_owned(), 
               meta: Meta::default(), 
               graph: GraphGexf::default() }
    }
}

impl Default for GraphGexf {
    fn default() -> Self {
        Self { defaultedgetype: "directed".to_owned(), 
               attributes: vec![], 
               nodes: NodesGexf { nodes: vec![] }, 
               edges: EdgesGexf { edges: vec![] } }
    }
}

impl Default for Meta {
    fn default() -> Self {
        Self { creator: format!("Made with {} version {} by {}.",env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"), env!("CARGO_PKG_AUTHORS")), description: "Object-Centric Directed Graph".to_owned() }
    }
}