hgame 0.26.4

CG production management structs, e.g. of assets, personnels, progress, etc.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use super::*;
#[cfg(feature = "gui")]
use mkentity::ProjectSource;

// ----------------------------------------------------------------------------
#[derive(Debug, Clone, Default)]
/// Collection of [`Staff`]s, grouped by [`ProductionRole`].
pub struct RoleMap(pub HashMap<ProductionRole, HashSet<Staff>>);

impl RoleMap {
    pub fn all(&self) -> HashSet<Staff> {
        let mut staff = HashSet::new();
        for s in self.0.values() {
            staff = staff.union(&s).map(|s| s.to_owned()).collect();
        }
        staff
    }

    pub fn supervisors(&self, includes_directors: bool) -> HashSet<Staff> {
        let mut staff = HashSet::new();
        for s in self.team_leads_or_empty().drain() {
            staff.insert(s);
        }
        for s in self.art_producers_or_empty().drain() {
            staff.insert(s);
        }
        if includes_directors {
            for s in self.art_directors_or_empty().drain() {
                staff.insert(s);
            }
        };
        staff
    }

    pub fn supervisors_and_watchers(&self, includes_directors: bool) -> HashSet<Staff> {
        self.supervisors(includes_directors)
            .union(&self.watchers_or_empty())
            .map(|s| s.to_owned())
            .collect()
    }

    pub fn assignees_and_supervisors(
        &self,
        assignees: &HashSet<Staff>,
        includes_directors: bool,
        includes_watchers: bool,
    ) -> HashSet<Staff> {
        if includes_watchers {
            self.supervisors_and_watchers(includes_directors)
                .union(assignees)
                .map(|s| s.to_owned())
                .collect()
        } else {
            self.supervisors(includes_directors)
                .union(assignees)
                .map(|s| s.to_owned())
                .collect()
        }
    }

    pub fn assignnees_supervisors_no_producers(
        &self,
        assignees: &HashSet<Staff>,
    ) -> HashSet<Staff> {
        let mut staff = HashSet::new();
        for s in self.team_leads_or_empty().drain() {
            staff.insert(s);
        }
        for s in self.art_directors_or_empty().drain() {
            staff.insert(s);
        }
        staff.union(assignees).map(|s| s.to_owned()).collect()
    }

    pub fn assignees_and_team_leads(&self, assignees: &HashSet<Staff>) -> HashSet<Staff> {
        self.team_leads_or_empty()
            .union(assignees)
            .map(|s| s.to_owned())
            .collect()
    }

    pub fn art_directors_or_empty(&self) -> HashSet<Staff> {
        self.0
            .get(&ProductionRole::ArtDirector)
            .map(|s| s.to_owned())
            .unwrap_or(HashSet::new())
    }

    pub fn art_producers_or_empty(&self) -> HashSet<Staff> {
        self.0
            .get(&ProductionRole::ArtProducer)
            .map(|s| s.to_owned())
            .unwrap_or(HashSet::new())
    }

    pub fn team_leads_or_empty(&self) -> HashSet<Staff> {
        self.0
            .get(&ProductionRole::TeamLead)
            .map(|s| s.to_owned())
            .unwrap_or(HashSet::new())
    }

    pub fn watchers_or_empty(&self) -> HashSet<Staff> {
        self.0
            .get(&ProductionRole::Watcher)
            .map(|s| s.to_owned())
            .unwrap_or(HashSet::new())
    }

    #[cfg(feature = "gui")]
    pub fn into_trees(self, typ: &ProjectSource) -> Vec<MkTree<Staff>> {
        let mut trees: Vec<MkTree<Staff>> = self
            .0
            .into_iter()
            .map(|(role, users)| {
                // converts to `Vec`
                let mut users: Vec<Staff> = users.into_iter().collect();
                // and sorts alphabetically
                users.sort();

                MkTree::leaf_group(role.as_ref(), users, typ)
            })
            .collect();

        trees.sort_by_key(|t| t.node_name());
        trees
    }

    #[cfg(feature = "gui")]
    pub fn into_trees_cb(self, typ: &ProjectSource) -> Vec<MkTreeCb<Staff>> {
        let mut trees: Vec<MkTreeCb<Staff>> = self
            .0
            .into_iter()
            .map(|(role, users)| {
                // converts to `Vec`
                let mut users: Vec<Staff> = users.into_iter().collect();
                // and sorts alphabetically
                users.sort();

                MkTreeCb::leaf_group(role.as_ref(), users, typ)
            })
            .collect();

        trees.sort_by_key(|t| t.node_name());
        trees
    }
}