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
|
use std::collections::{HashMap, HashSet};
use std::fmt;
use crate::types::*;
#[derive(Debug)]
pub enum Error {
TaskNotFound(TaskRef),
DependencyCycle(TaskRef),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Error::TaskNotFound(id) => write!(f, "Task not found: {}", id),
Error::DependencyCycle(id) => write!(f, "DependencyCycle: {}", id),
}
}
}
impl std::error::Error for Error {}
pub type Result<T> = std::result::Result<T, Error>;
#[derive(PartialEq)]
enum ResolveState {
Resolving,
Resolved,
}
pub struct Resolver<'a> {
tasks: &'a TaskMap,
resolve_state: HashMap<TaskRef, ResolveState>,
}
impl<'a> Resolver<'a> {
pub fn new(tasks: &'a TaskMap) -> Self {
Resolver {
tasks: tasks,
resolve_state: HashMap::new(),
}
}
pub fn add_goal(&mut self, task: &TaskRef) -> Result<()> {
match self.resolve_state.get(task) {
Some(ResolveState::Resolving) => return Err(Error::DependencyCycle(task.clone())),
Some(ResolveState::Resolved) => return Ok(()),
None => (),
}
let task_def = match self.tasks.get(task) {
None => return Err(Error::TaskNotFound(task.clone())),
Some(task_def) => task_def,
};
self.resolve_state
.insert(task.clone(), ResolveState::Resolving);
for dep in &task_def.depends {
let res = self.add_goal(dep);
if res.is_err() {
self.resolve_state.remove(task);
return res;
}
}
*self
.resolve_state
.get_mut(task)
.expect("Missing resolve_state") = ResolveState::Resolved;
Ok(())
}
pub fn to_taskset(self) -> HashSet<TaskRef> {
fn tasks_resolved(this: &Resolver) -> bool {
for (_, resolved) in &this.resolve_state {
if *resolved != ResolveState::Resolved {
return false;
}
}
true
}
debug_assert!(tasks_resolved(&self));
self.resolve_state
.into_iter()
.map(|entry| entry.0)
.collect()
}
}
|
