acts 0.17.2

a fast, lightweight, extensiable workflow engine
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use super::Node;
use crate::NodeKind;
use std::collections::HashMap;
use std::ops::Deref;
use std::sync::Arc;

#[derive(Clone)]
pub struct VisitRoot {
    visits: HashMap<String, usize>,
}

impl VisitRoot {
    pub fn walk<F: Fn(&Visitor) + Clone>(node: &Arc<Node>, f: &F) {
        let root = Box::new(VisitRoot {
            visits: HashMap::new(),
        });
        let mut root = Visitor::new(&root, node, 0, 0, true, &HashMap::new());
        root.walk(f);
    }

    pub fn visit_count(&self, id: &str) -> usize {
        self.visits.get(id).copied().unwrap_or(0)
    }
}

#[derive(Clone)]
pub struct Visitor {
    root: Box<VisitRoot>,
    pub level: usize,
    pub is_last: bool,
    pub index: usize,
    node: Arc<Node>,
    pub path: HashMap<usize, bool>,
}

impl Deref for Visitor {
    type Target = Arc<Node>;
    fn deref(&self) -> &Self::Target {
        &self.node
    }
}

#[allow(clippy::borrowed_box)]
impl Visitor {
    pub fn new(
        root: &Box<VisitRoot>,
        node: &Arc<Node>,
        level: usize,
        index: usize,
        is_last: bool,
        path: &HashMap<usize, bool>,
        // next_sibling: bool,
    ) -> Box<Self> {
        let mut path = path.clone();
        path.entry(node.level)
            .and_modify(|v| *v = !is_last)
            .or_insert(!is_last);
        Box::new(Self {
            root: root.clone(),
            node: node.clone(),
            level,
            index,
            is_last,
            path,
        })
    }

    #[allow(clippy::vec_box)]
    pub fn children_visits(&self) -> Vec<Box<Self>> {
        let len = self.node.children().len();
        self.node
            .children()
            .iter()
            .enumerate()
            .map(|(i, iter)| {
                let mut is_last = i == len - 1;
                if iter.kind() == NodeKind::Step {
                    if let Some(next) = iter.next().upgrade() {
                        if self.root.visit_count(next.id()) == 0 {
                            is_last = false;
                        }
                    }
                }
                Visitor::new(&self.root, iter, iter.level, i, is_last, &self.path)
            })
            .collect::<Vec<_>>()
    }

    pub fn next_visit(&self) -> Option<Box<Self>> {
        if let Some(next) = self.node.next().upgrade() {
            if self.root.visit_count(next.id()) == 0 {
                let node = Visitor::new(
                    &self.root,
                    &next,
                    next.level,
                    self.index + 1,
                    next.next().upgrade().is_none(),
                    &self.path,
                );
                return Some(node);
            }
        }

        None
    }

    pub fn visit(&mut self) {
        self.root
            .visits
            .entry(self.node.id().to_string())
            .and_modify(|v| *v += 1)
            .or_insert(1);
    }

    pub fn walk<F: Fn(&Visitor) + Clone>(&mut self, f: &F) {
        f(self);
        self.visit();

        for node in self.children_visits().iter_mut() {
            node.walk(f);
        }

        if let Some(mut next) = self.next_visit() {
            next.walk(f);
        }
    }
}