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
use crate::engine::d2::{platform::Dynamic, Disposer};
use super::Promise;
/// Multiplexes a list of promises into a single promise. When all promises have been fulfilled, the
/// success signal will be emitted with an array containing their respective results. Progress and
/// error signals are also aggregated.
pub struct MultiPromise {
pub inner: Promise<Vec<Dynamic>>,
promises: Vec<Promise<Dynamic>>,
success_count: usize,
disposer: Disposer,
}
impl MultiPromise {
pub fn new(promises: Vec<Promise<Dynamic>>) -> Self {
let mut instance = Self {
inner: Promise::new(),
promises,
success_count: 0,
disposer: Disposer::new(),
};
instance.on_progress_changed();
// let disposer = &mut instance.disposer;
// for promise in instance.promises.iter() {
// disposer
// .connect1(promise.error.clone(), Box::new(|msg| instance.on_error(*msg)));
// disposer
// .connect0(promise.progress_changed.clone(), Box::new(|| instance.on_progress_changed()));
// // let pending = promise.get(Box::new(|v| instance.on_success(v)));
// // if let Some(paending) = pending {
// // // instance.disposer.add(Box::new(pending));
// // // todo!("should deal with it");
// // }
// // // todo!("should deal with it");
// }
instance
}
pub fn on_success(&mut self, v: &Dynamic) {
if self.promises.is_empty() {
return;
}
self.success_count += 1;
if self.success_count >= self.promises.len() {
let mut results = Vec::new();
for promise in self.promises.iter() {
results.push(promise.result());
}
self.finalize();
todo!("should deal with it");
// self.inner.set_result(Some(results));
}
}
pub fn on_error(&mut self, message: String) {
if self.promises.is_empty() {
return;
}
self.finalize();
self.inner.error.emit(message);
}
pub fn on_progress_changed(&mut self) {
if self.promises.is_empty() {
return;
}
self.inner.progress = 0.0;
self.inner.total = 0.0;
for promise in self.promises.iter() {
self.inner.progress += promise.progress();
self.inner.total += promise.total();
}
self.inner.progress_changed.emit();
}
fn finalize(&mut self) {
self.disposer.dispose();
self.promises.clear(); // Marks that all promises are fulfilled, or there was an error
}
}
impl AsRef<Promise<Vec<Dynamic>>> for MultiPromise {
fn as_ref(&self) -> &Promise<Vec<Dynamic>> {
&self.inner
}
}