1
2#[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 id: String,
17 duration: T,
19 early_start: Option<T>,
21 early_finish: Option<T>,
23 late_start: Option<T>,
25 late_finish: Option<T>,
27 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}