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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
use std::time::Instant;
use crate::{messages::MessageLevel, progress, progress::Id, Unit};
/// A trait for describing hierarchical process.
pub trait Progress: Send {
/// The type of progress returned by [`add_child()`][Progress::add_child()].
type SubProgress: Progress;
/// Adds a new child, whose parent is this instance, with the given `name`.
///
/// This will make the child progress to appear contained in the parent progress.
/// Note that such progress does not have a stable identifier, which can be added
/// with [`add_child_with_id()`][Progress::add_child_with_id()] if desired.
fn add_child(&mut self, name: impl Into<String>) -> Self::SubProgress;
/// Adds a new child, whose parent is this instance, with the given `name` and `id`.
///
/// This will make the child progress to appear contained in the parent progress, and it can be identified
/// using `id`.
fn add_child_with_id(&mut self, name: impl Into<String>, id: Id) -> Self::SubProgress;
/// Initialize the Item for receiving progress information.
///
/// If `max` is `Some(…)`, it will be treated as upper bound. When progress is [set(…)](./struct.Item.html#method.set)
/// it should not exceed the given maximum.
/// If `max` is `None`, the progress is unbounded. Use this if the amount of work cannot accurately
/// be determined in advance.
///
/// If `unit` is `Some(…)`, it is used for display purposes only. See `prodash::Unit` for more information.
///
/// If both `unit` and `max` are `None`, the item will be reset to be equivalent to 'uninitialized'.
///
/// If this method is never called, this `Progress` instance will serve as organizational unit, useful to add more structure
/// to the progress tree (e.g. a headline).
///
/// **Note** that this method can be called multiple times, changing the bounded-ness and unit at will.
fn init(&mut self, max: Option<progress::Step>, unit: Option<Unit>);
/// Set the current progress to the given `step`. The cost of this call is negligible,
/// making manual throttling *not* necessary.
///
/// **Note**: that this call has no effect unless `init(…)` was called before.
fn set(&mut self, step: progress::Step);
/// Returns the (cloned) unit associated with this Progress
fn unit(&self) -> Option<Unit> {
None
}
/// Returns the maximum about of items we expect, as provided with the `init(…)` call
fn max(&self) -> Option<progress::Step> {
None
}
/// Set the maximum value to `max` and return the old maximum value.
fn set_max(&mut self, _max: Option<progress::Step>) -> Option<progress::Step> {
None
}
/// Returns the current step, as controlled by `inc*(…)` calls
fn step(&self) -> progress::Step;
/// Increment the current progress to the given `step`.
/// The cost of this call is negligible, making manual throttling *not* necessary.
fn inc_by(&mut self, step: progress::Step);
/// Increment the current progress to the given 1. The cost of this call is negligible,
/// making manual throttling *not* necessary.
fn inc(&mut self) {
self.inc_by(1)
}
/// Set the name of the instance, altering the value given when crating it with `add_child(…)`
/// The progress is allowed to discard it.
fn set_name(&mut self, name: impl Into<String>);
/// Get the name of the instance as given when creating it with `add_child(…)`
/// The progress is allowed to not be named, thus there is no guarantee that a previously set names 'sticks'.
fn name(&self) -> Option<String>;
/// Get a stable identifier for the progress instance.
/// Note that it could be [unknown][crate::progress::UNKNOWN].
fn id(&self) -> Id;
/// Create a `message` of the given `level` and store it with the progress tree.
///
/// Use this to provide additional,human-readable information about the progress
/// made, including indicating success or failure.
fn message(&mut self, level: MessageLevel, message: impl Into<String>);
/// If available, return an atomic counter for direct access to the underlying state.
///
/// This is useful if multiple threads want to access the same progress, without the need
/// for provide each their own progress and aggregating the result.
fn counter(&self) -> Option<StepShared> {
None
}
/// Create a message providing additional information about the progress thus far.
fn info(&mut self, message: impl Into<String>) {
self.message(MessageLevel::Info, message)
}
/// Create a message indicating the task is done successfully
fn done(&mut self, message: impl Into<String>) {
self.message(MessageLevel::Success, message)
}
/// Create a message indicating the task failed
fn fail(&mut self, message: impl Into<String>) {
self.message(MessageLevel::Failure, message)
}
/// A shorthand to print throughput information
fn show_throughput(&mut self, start: Instant) {
let step = self.step();
match self.unit() {
Some(unit) => self.show_throughput_with(start, step, unit, MessageLevel::Info),
None => {
let elapsed = start.elapsed().as_secs_f32();
let steps_per_second = (step as f32 / elapsed) as progress::Step;
self.info(format!(
"done {} items in {:.02}s ({} items/s)",
step, elapsed, steps_per_second
))
}
};
}
/// A shorthand to print throughput information, with the given step and unit, and message level.
fn show_throughput_with(&mut self, start: Instant, step: progress::Step, unit: Unit, level: MessageLevel) {
use std::fmt::Write;
let elapsed = start.elapsed().as_secs_f32();
let steps_per_second = (step as f32 / elapsed) as progress::Step;
let mut buf = String::with_capacity(128);
let unit = unit.as_display_value();
let push_unit = |buf: &mut String| {
buf.push(' ');
let len_before_unit = buf.len();
unit.display_unit(buf, step).ok();
if buf.len() == len_before_unit {
buf.pop();
}
};
buf.push_str("done ");
unit.display_current_value(&mut buf, step, None).ok();
push_unit(&mut buf);
buf.write_fmt(format_args!(" in {:.02}s (", elapsed)).ok();
unit.display_current_value(&mut buf, steps_per_second, None).ok();
push_unit(&mut buf);
buf.push_str("/s)");
self.message(level, buf);
}
}
use crate::{
messages::{Message, MessageCopyState},
progress::StepShared,
};
/// The top-level root as weak handle, which needs an upgrade to become a usable root.
///
/// If the underlying reference isn't present anymore, such upgrade will fail permanently.
pub trait WeakRoot {
/// The type implementing the `Root` trait
type Root: Root;
/// Equivalent to `std::sync::Weak::upgrade()`.
fn upgrade(&self) -> Option<Self::Root>;
}
/// The top level of a progress task hierarchy, with `progress::Task`s identified with `progress::Key`s
pub trait Root {
/// The type implementing the `WeakRoot` trait
type WeakRoot: WeakRoot;
/// Returns the maximum amount of messages we can keep before overwriting older ones.
fn messages_capacity(&self) -> usize;
/// Returns the current amount of tasks underneath the root, transitively.
/// **Note** that this is at most a guess as tasks can be added and removed in parallel.
fn num_tasks(&self) -> usize;
/// Copy the entire progress tree into the given `out` vector, so that
/// it can be traversed from beginning to end in order of hierarchy.
/// The `out` vec will be cleared automatically.
fn sorted_snapshot(&self, out: &mut Vec<(progress::Key, progress::Task)>);
/// Copy all messages from the internal ring buffer into the given `out`
/// vector. Messages are ordered from oldest to newest.
fn copy_messages(&self, out: &mut Vec<Message>);
/// Copy only new messages from the internal ring buffer into the given `out`
/// vector. Messages are ordered from oldest to newest.
fn copy_new_messages(&self, out: &mut Vec<Message>, prev: Option<MessageCopyState>) -> MessageCopyState;
/// Similar to `Arc::downgrade()`
fn downgrade(&self) -> Self::WeakRoot;
}
mod impls {
use std::{
ops::{Deref, DerefMut},
time::Instant,
};
use crate::{
messages::MessageLevel,
progress::{Id, Step, StepShared},
Progress, Unit,
};
impl<'a, T> Progress for &'a mut T
where
T: Progress,
{
type SubProgress = <T as Progress>::SubProgress;
fn add_child(&mut self, name: impl Into<String>) -> Self::SubProgress {
self.deref_mut().add_child(name)
}
fn add_child_with_id(&mut self, name: impl Into<String>, id: Id) -> Self::SubProgress {
self.deref_mut().add_child_with_id(name, id)
}
fn init(&mut self, max: Option<Step>, unit: Option<Unit>) {
self.deref_mut().init(max, unit)
}
fn set(&mut self, step: Step) {
self.deref_mut().set(step)
}
fn unit(&self) -> Option<Unit> {
self.deref().unit()
}
fn max(&self) -> Option<Step> {
self.deref().max()
}
fn set_max(&mut self, max: Option<Step>) -> Option<Step> {
self.deref_mut().set_max(max)
}
fn step(&self) -> Step {
self.deref().step()
}
fn inc_by(&mut self, step: Step) {
self.deref_mut().inc_by(step)
}
fn inc(&mut self) {
self.deref_mut().inc()
}
fn set_name(&mut self, name: impl Into<String>) {
self.deref_mut().set_name(name)
}
fn name(&self) -> Option<String> {
self.deref().name()
}
fn id(&self) -> Id {
todo!()
}
fn message(&mut self, level: MessageLevel, message: impl Into<String>) {
self.deref_mut().message(level, message)
}
fn counter(&self) -> Option<StepShared> {
self.deref().counter()
}
fn info(&mut self, message: impl Into<String>) {
self.deref_mut().info(message)
}
fn done(&mut self, message: impl Into<String>) {
self.deref_mut().done(message)
}
fn fail(&mut self, message: impl Into<String>) {
self.deref_mut().fail(message)
}
fn show_throughput(&mut self, start: Instant) {
self.deref_mut().show_throughput(start)
}
fn show_throughput_with(&mut self, start: Instant, step: Step, unit: Unit, level: MessageLevel) {
self.deref_mut().show_throughput_with(start, step, unit, level)
}
}
}