feat!: split Progress into various super-traits to allow most of them to be dyn-safe.

`Progress` is now `NestedProgress`, `RawProgress` is now `Progress`, and there is
a new `Count` trait for solely counting things.

Author: Byron

benches/usage.rs

@@ -28,7 +28,7 @@ fn usage(c: &mut Criterion) {
         .throughput(Throughput::Elements(5))
         .bench_function("set tree 5 times", |b| {
             let root = small_tree();
-            let mut progress = root.add_child("the one");
+            let progress = root.add_child("the one");
             progress.init(Some(20), Some("element".into()));
             b.iter(|| {
                 progress.set(1);
@@ -44,7 +44,7 @@ fn usage(c: &mut Criterion) {
             "send one message with a full message buffer (worst case performance)",
             |b| {
                 let root = small_tree();
-                let mut progress = root.add_child("the one");
+                let progress = root.add_child("the one");
                 progress.init(Some(20), Some("element".into()));
                 b.iter(|| {
                     progress.message(MessageLevel::Success, "for testing");

examples/units.rs

@@ -31,15 +31,15 @@ fn main() -> Result {
 }
 
 fn work_for_a_long_time_blocking(root: Arc<Tree>) {
-    let mut bytes = root.add_child_with_id("download unknown", *b"DLUK");
+    let bytes = root.add_child_with_id("download unknown", *b"DLUK");
     bytes.init(
         None,
         Some(unit::dynamic_and_mode(
             unit::Bytes,
             unit::display::Mode::with_throughput(),
         )),
     );
-    let mut bytes_max = root.add_child_with_id("download", *b"DLKN");
+    let bytes_max = root.add_child_with_id("download", *b"DLKN");
     bytes_max.init(
         Some(100_000_000),
         Some(unit::dynamic_and_mode(
@@ -48,9 +48,9 @@ fn work_for_a_long_time_blocking(root: Arc<Tree>) {
         )),
     );
 
-    let mut duration = root.add_child_with_id("duration unknown", *b"DRUK");
+    let duration = root.add_child_with_id("duration unknown", *b"DRUK");
     duration.init(None, Some(unit::dynamic(unit::Duration)));
-    let mut duration_max = root.add_child_with_id("duration", *b"DRKN");
+    let duration_max = root.add_child_with_id("duration", *b"DRKN");
     duration_max.init(
         Some(60 * 60 * 24),
         Some(unit::dynamic_and_mode(
@@ -64,15 +64,15 @@ fn work_for_a_long_time_blocking(root: Arc<Tree>) {
         f.with_decimals(decimals);
         f
     }
-    let mut human_count = root.add_child_with_id("item count unknown", *b"ITUK");
+    let human_count = root.add_child_with_id("item count unknown", *b"ITUK");
     human_count.init(
         None,
         Some(unit::dynamic_and_mode(
             unit::Human::new(formatter(0), "items"),
             unit::display::Mode::with_throughput(),
         )),
     );
-    let mut human_count_max = root.add_child_with_id("item count", *b"ITKN");
+    let human_count_max = root.add_child_with_id("item count", *b"ITKN");
     human_count_max.init(
         Some(7_542_241),
         Some(unit::dynamic_and_mode(
@@ -81,15 +81,15 @@ fn work_for_a_long_time_blocking(root: Arc<Tree>) {
         )),
     );
 
-    let mut steps = root.add_child_with_id("steps to take unknown", *b"STUK");
+    let steps = root.add_child_with_id("steps to take unknown", *b"STUK");
     steps.init(
         None,
         Some(unit::dynamic_and_mode(
             unit::Range::new("steps"),
             unit::display::Mode::with_throughput(),
         )),
     );
-    let mut steps_max = root.add_child_with_id("steps to take", *b"STKN");
+    let steps_max = root.add_child_with_id("steps to take", *b"STKN");
     steps_max.init(
         Some(100),
         Some(unit::dynamic_and_mode(

src/lib.rs

@@ -64,7 +64,7 @@ pub mod messages;
 pub mod progress;
 
 mod traits;
-pub use traits::{Progress, RawProgress, Root, WeakRoot};
+pub use traits::{Count, NestedProgress, Progress, Root, WeakRoot};
 
 mod throughput;
 pub use crate::throughput::Throughput;

src/progress/log.rs

@@ -9,10 +9,10 @@ use std::{
 use crate::{
     messages::MessageLevel,
     progress::{Id, Step, StepShared},
-    Progress, Unit,
+    Count, NestedProgress, Progress, Unit,
 };
 
-/// A [`Progress`] implementation which displays progress as it happens without the use of a renderer.
+/// A [`NestedProgress`] implementation which displays progress as it happens without the use of a renderer.
 ///
 /// Note that this incurs considerable performance cost as each progress calls ends up getting the system time
 /// to see if progress information should actually be emitted.
@@ -73,36 +73,31 @@ impl Log {
     }
 }
 
-impl Progress for Log {
-    type SubProgress = Log;
+impl Count for Log {
+    fn set(&self, step: Step) {
+        self.step.store(step, Ordering::SeqCst);
+        self.maybe_log()
+    }
 
-    fn add_child(&mut self, name: impl Into<String>) -> Self::SubProgress {
-        self.add_child_with_id(name, crate::progress::UNKNOWN)
+    fn step(&self) -> usize {
+        self.step.load(Ordering::Relaxed)
     }
 
-    fn add_child_with_id(&mut self, name: impl Into<String>, id: Id) -> Self::SubProgress {
-        Log {
-            name: format!("{}{}{}", self.name, SEP, Into::<String>::into(name)),
-            id,
-            current_level: self.current_level + 1,
-            max_level: self.max_level,
-            step: Default::default(),
-            max: None,
-            unit: None,
-            trigger: Arc::clone(&self.trigger),
-        }
+    fn inc_by(&self, step: Step) {
+        self.step.fetch_add(step, Ordering::SeqCst);
+        self.maybe_log()
     }
 
+    fn counter(&self) -> Option<StepShared> {
+        Some(self.step.clone())
+    }
+}
+
+impl Progress for Log {
     fn init(&mut self, max: Option<Step>, unit: Option<Unit>) {
         self.max = max;
         self.unit = unit;
     }
-
-    fn set(&mut self, step: Step) {
-        self.step.store(step, Ordering::SeqCst);
-        self.maybe_log()
-    }
-
     fn unit(&self) -> Option<Unit> {
         self.unit.clone()
     }
@@ -117,17 +112,7 @@ impl Progress for Log {
         prev
     }
 
-    fn step(&self) -> usize {
-        self.step.load(Ordering::Relaxed)
-    }
-
-    fn inc_by(&mut self, step: Step) {
-        self.step.fetch_add(step, Ordering::SeqCst);
-        self.maybe_log()
-    }
-
-    fn set_name(&mut self, name: impl Into<String>) {
-        let name = name.into();
+    fn set_name(&mut self, name: String) {
         self.name = self
             .name
             .split("::")
@@ -144,16 +129,32 @@ impl Progress for Log {
         self.id
     }
 
-    fn message(&self, level: MessageLevel, message: impl Into<String>) {
-        let message: String = message.into();
+    fn message(&self, level: MessageLevel, message: String) {
         match level {
             MessageLevel::Info => log::info!("ℹ{} → {}", self.name, message),
             MessageLevel::Failure => log::error!("𐄂{} → {}", self.name, message),
             MessageLevel::Success => log::info!("✓{} → {}", self.name, message),
         }
     }
+}
 
-    fn counter(&self) -> Option<StepShared> {
-        Some(self.step.clone())
+impl NestedProgress for Log {
+    type SubProgress = Log;
+
+    fn add_child(&mut self, name: impl Into<String>) -> Self::SubProgress {
+        self.add_child_with_id(name, crate::progress::UNKNOWN)
+    }
+
+    fn add_child_with_id(&mut self, name: impl Into<String>, id: Id) -> Self::SubProgress {
+        Log {
+            name: format!("{}{}{}", self.name, SEP, Into::<String>::into(name)),
+            id,
+            current_level: self.current_level + 1,
+            max_level: self.max_level,
+            step: Default::default(),
+            max: None,
+            unit: None,
+            trigger: Arc::clone(&self.trigger),
+        }
     }
 }