yuml-rs 0.1.6

Rust based yUML parser
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

use crate::model::shared::{ElementDetails, LabeledElement};

use super::*;

pub struct Uids<'a, T: LabeledElement> {
    uids: HashMap<&'a str, (usize, &'a T)>,
    uid: usize,
}

impl<'a, T: LabeledElement> Default for Uids<'a, T> {
    fn default() -> Self {
        Self {
            uids: Default::default(),
            uid: Default::default(),
        }
    }
}

impl<'a, T: LabeledElement> Uids<'a, T> {
    pub fn insert_uid(&mut self, label: &'a str, e: &'a T) -> usize {
        self.uid += 1;
        self.uids.insert(label, (self.uid, e));
        self.uid
    }

    pub fn contains_key(&self, key: &str) -> bool {
        self.uids.contains_key(key)
    }

    pub fn get(&'a self, key: &str) -> Option<&'a (usize, &'a T)> {
        self.uids.get(key)
    }
}

pub fn populate_uids<T: LabeledElement>(elements: &[T]) -> (Uids<T>, Vec<ElementDetails<T>>) {
    let mut uids = Uids::default();

    // we must collect to borrow uids in subsequent iterator
    let element_details: Vec<ElementDetails<T>> = elements
        .iter()
        .filter_map(|e| {
            if e.is_connection() {
                // ignore arrows for now
                None
            } else {
                let lbl = e.label();
                if uids.contains_key(lbl) {
                    None
                } else {
                    let id = uids.insert_uid(lbl, e);
                    Some((id, e))
                }
            }
        })
        .map(|(id, element)| ElementDetails {
            id: Some(id),
            element,
            relation: None,
        })
        .collect();

    (uids, element_details)
}