cpm_rs/
customtask.rs

1
2/// Represents a task a.k.a. a node in a batch graph.
3#[derive(Clone, Debug)]
4pub struct CustomTask<T>
5where T: From<i8>
6	+ std::clone::Clone
7	+ std::marker::Copy
8	+ std::ops::Sub::<Output = T>
9	+ std::ops::Add<Output = T>
10	+ std::fmt::Display
11	+ std::fmt::Debug
12	+ std::cmp::PartialOrd
13	+ std::ops::AddAssign
14{
15	/// Identifier of a task. Should be unique.
16	id: String,
17	/// Duration of a task.
18	duration: T,
19	/// Earlyiest possible start for the task. (Calculated)
20	early_start: Option<T>,
21	/// Earlyiest possible finish for the task. (Calculated)
22	early_finish: Option<T>,
23	/// Latest possible start for the task. (Calculated)
24	late_start: Option<T>,
25	/// Latest possible finish for the task. (Calculated)
26	late_finish: Option<T>,
27	/// Task dependency IDs.
28	dependencies: Vec<String>,
29}
30
31impl <T> CustomTask<T>
32where T: From<i8>
33	+ std::clone::Clone
34	+ std::marker::Copy
35	+ std::ops::Sub::<Output = T>
36	+ std::ops::Add<Output = T>
37	+ std::fmt::Display
38	+ std::fmt::Debug
39	+ std::cmp::PartialOrd
40	+ std::ops::AddAssign
41{
42	pub fn new(_id: String, _duration: T, _dependencies: Vec<String>) -> Self {
43		CustomTask {
44			id: _id,
45			duration: _duration,
46			dependencies: _dependencies,
47			early_start: None,
48			early_finish: None,
49			late_start: None,
50			late_finish: None,
51		}
52	}
53
54	pub fn get_id(&self) -> String {
55		self.id.clone()
56	}
57
58	pub fn get_duration(&self) -> T {
59		self.duration
60	}
61
62	pub fn set_duration(&mut self, dur: T) {
63		self.duration = dur;
64	}
65
66	pub fn get_dependencies(&self) -> Vec<String> {
67		self.dependencies.clone()
68	}
69
70	pub fn add_dependency(&mut self, _dependency: String) {
71		self.dependencies.push(_dependency);
72	}
73
74	pub fn add_dependencies(&mut self, _dependencies: &mut Vec<String>) {
75		self.dependencies.append(_dependencies);
76	}
77
78	pub fn set_dependencies(&mut self, _dependencies: Vec<String>) {
79		self.dependencies = _dependencies;
80	}
81
82	pub fn get_early_start(&self) -> Option<T> {
83		self.early_start
84	}
85
86	pub fn set_early_start(&mut self, es: T) -> Result<(), String> {
87		if es >= 0.into() {
88			self.early_start = Some(es);
89		} else {
90			return Err(
91				format!("Early start have to be greater or equal 0! ES: {:?}", es)
92			);
93		}
94		Ok(())
95	}
96
97	pub fn get_early_finish(&self) -> Option<T> {
98		self.early_finish
99	}
100
101	pub fn set_early_finish(&mut self, ef: T) -> Result<(), String> {
102		if ef >= 0.into() {
103			self.early_finish = Some(ef);
104		} else {
105			return Err(
106				format!("Early finish have to be greater or equal 0! EF: {:?}", ef)
107			);
108		}
109		Ok(())
110	}
111
112	pub fn get_late_start(&self) -> Option<T> {
113		self.late_start
114	}
115
116	pub fn set_late_start(&mut self, ls: T) -> Result<(), String> {
117		if ls >= 0.into() {
118			self.late_start = Some(ls);
119		} else {
120			return Err(
121				format!("Late start have to be greater or equal 0! LS: {:?}", ls)
122			);
123		}
124		Ok(())
125	}
126
127	pub fn get_late_finish(&self) -> Option<T> {
128		self.late_finish
129	}
130
131	pub fn set_late_finish(&mut self, lf: T) -> Result<(), String> {
132		if lf >= 0.into() {
133			self.late_finish = Some(lf);
134		} else {
135			return Err(
136				format!("Late finish have to be greater or equal 0! LF: {:?}", lf)
137			);
138		}
139		Ok(())
140	}
141
142	pub fn get_total_float(&self) -> Result<T, String> {
143		let (lf, ef);
144		match self.late_finish {
145			None => {
146				return Err(
147					format!("Late finish has not been calculated in task: {}", self.id)
148				);
149			},
150			Some(_lf) => {lf = _lf},
151		};
152		match self.early_finish {
153			None => {
154				return Err(
155					format!("Early finish has not been calculated in task: {}", self.id)
156				);
157			},
158			Some(_ef) => {ef = _ef},
159		};
160		let tf = lf - ef;
161		if tf < 0.into() {
162			return Err(format!("Total float is under 0 in task: {}", self.id));
163		}
164		Ok(tf)
165	}
166
167}