Merge branch 'simplify'

Author: Byron

CHANGELOG.md

@@ -5,19 +5,62 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+This release is all about making `dyn` possible both for nested progress, as well as for 'simple' one (previously known as `RawProgress`).
+Switching to this release naturally makes it possible for users of `Progress` to also use `dyn Progress`, as this trait is now object safe (formerly `RawProgress`).
+If there are compile errors, the code now needs `NestedProgress`, instead of `Progress`, and possibly the import of the `Count` trait.
+Finally, it's recommended to review all usages of `Progress` as they can possibly be replaced with `Count` which provides the guarantee that only counting happens,
+and no change of the progress information itself.
+
+### New Features (BREAKING)
+
+ - <csr-id-6aba6e34f3e39bba5e609a0bc780c758cb43c821/> 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.
+
+### Commit Statistics
+
+<csr-read-only-do-not-edit/>
+
+ - 5 commits contributed to the release.
+ - 13 days passed between releases.
+ - 1 commit was understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' were seen in commit messages
+
+### Commit Details
+
+<csr-read-only-do-not-edit/>
+
+<details><summary>view details</summary>
+
+ * **Uncategorized**
+    - Fixup nested dyn-traits ([`5e76abf`](https://github.com/byron/prodash/commit/5e76abfbf8dc18afddea68873c50cce677450a54))
+    - Merge branch 'feat/dyn-progress' into simplify ([`c1590e4`](https://github.com/byron/prodash/commit/c1590e4650a9ffcf96a216f6a9fe82a1cf7cc10e))
+    - Split `Progress` into various super-traits to allow most of them to be dyn-safe. ([`6aba6e3`](https://github.com/byron/prodash/commit/6aba6e34f3e39bba5e609a0bc780c758cb43c821))
+    - Add benchmarks for dyn-traits ([`9d03124`](https://github.com/byron/prodash/commit/9d03124667935314a9d4c8e52886b994967f2671))
+    - Refactor ([`54094b6`](https://github.com/byron/prodash/commit/54094b63289446f0582c6b49a666b5d993625dff))
+</details>
+
 ## 25.0.2 (2023-08-22)
 
+<csr-id-05741765491984487beea7326eff9863b669ab51/>
+
 ### Chore
 
  - <csr-id-05741765491984487beea7326eff9863b669ab51/> Adjusting changelogs prior to release of prodash v25.0.2
 
+### New Features
+
+ - <csr-id-24d0b2aaa58978990fea90c2f3b387e238acf966/> Add new trait `DynProgress` & type `BoxedDynProgress`
+
 ### Commit Statistics
 
 <csr-read-only-do-not-edit/>
 
- - 2 commits contributed to the release.
+ - 4 commits contributed to the release over the course of 2 calendar days.
  - 37 days passed between releases.
- - 1 commit was understood as [conventional](https://www.conventionalcommits.org).
+ - 2 commits were understood as [conventional](https://www.conventionalcommits.org).
  - 0 issues like '(#ID)' were seen in commit messages
 
 ### Commit Details
@@ -27,8 +70,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <details><summary>view details</summary>
 
  * **Uncategorized**
+    - Release prodash v25.0.2 ([`abcc61b`](https://github.com/byron/prodash/commit/abcc61b456e75d4f700f3c476849d7c36c3ece15))
     - Adjusting changelogs prior to release of prodash v25.0.2 ([`0574176`](https://github.com/byron/prodash/commit/05741765491984487beea7326eff9863b669ab51))
     - Remove `atty` in favor of `is-terminal` ([`2bfe9ad`](https://github.com/byron/prodash/commit/2bfe9adca357cf48d7310036684eeb85efa5ef46))
+    - Add new trait `DynProgress` & type `BoxedDynProgress` ([`24d0b2a`](https://github.com/byron/prodash/commit/24d0b2aaa58978990fea90c2f3b387e238acf966))
 </details>
 
 ## 25.0.1 (2023-07-16)

benches/usage.rs

@@ -2,7 +2,9 @@ use criterion::*;
 use prodash::{
     messages::MessageLevel,
     tree::{root::Options as TreeOptions, Root as Tree},
+    BoxedDynNestedProgress, Count,
 };
+use std::sync::atomic::Ordering;
 
 fn usage(c: &mut Criterion) {
     fn small_tree() -> std::sync::Arc<Tree> {
@@ -13,38 +15,106 @@ fn usage(c: &mut Criterion) {
         .create()
         .into()
     }
-    c.benchmark_group("Tree::add_child")
-        .throughput(Throughput::Elements(4))
-        .bench_function("add children to build a tree of tasks and clear them (in drop)", |b| {
+    c.benchmark_group("Shared Counter")
+        .throughput(Throughput::Elements(5))
+        .bench_function("inc counter 5 times", |b| {
             let root = small_tree();
+            let progress = root.add_child("the one");
+            progress.init(Some(20), Some("element".into()));
+            let counter = progress.counter();
             b.iter(|| {
-                let mut c = root.add_child("1");
-                let _one = c.add_child("1");
-                let _two = c.add_child("2");
-                let _three = c.add_child("3");
+                counter.fetch_add(1, Ordering::Relaxed);
+                counter.fetch_add(1, Ordering::Relaxed);
+                counter.fetch_add(1, Ordering::Relaxed);
+                counter.fetch_add(1, Ordering::Relaxed);
+                counter.fetch_add(1, Ordering::Relaxed);
+            });
+        })
+        .bench_function("set counter 5 times", |b| {
+            let root = small_tree();
+            let progress = root.add_child("the one");
+            progress.init(Some(20), Some("element".into()));
+            let counter = progress.counter();
+            b.iter(|| {
+                counter.store(1, Ordering::SeqCst);
+                counter.store(2, Ordering::SeqCst);
+                counter.store(3, Ordering::SeqCst);
+                counter.store(4, Ordering::SeqCst);
+                counter.store(5, Ordering::SeqCst);
             });
         });
-    c.benchmark_group("tree::Item::set")
+    c.benchmark_group("BoxedDynProgress")
         .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()));
+            let progress = BoxedDynNestedProgress::new(progress);
             b.iter(|| {
                 progress.set(1);
                 progress.set(2);
                 progress.set(3);
                 progress.set(4);
                 progress.set(5);
             });
+        })
+        .bench_function("inc tree 5 times", |b| {
+            let root = small_tree();
+            let progress = root.add_child("the one");
+            progress.init(Some(20), Some("element".into()));
+            let progress = BoxedDynNestedProgress::new(progress);
+            b.iter(|| {
+                progress.inc();
+                progress.inc();
+                progress.inc();
+                progress.inc();
+                progress.inc();
+            });
+        });
+    c.benchmark_group("tree::Item")
+        .throughput(Throughput::Elements(5))
+        .bench_function("set tree 5 times", |b| {
+            let root = small_tree();
+            let progress = root.add_child("the one");
+            progress.init(Some(20), Some("element".into()));
+            b.iter(|| {
+                progress.set(1);
+                progress.set(2);
+                progress.set(3);
+                progress.set(4);
+                progress.set(5);
+            });
+        })
+        .bench_function("inc tree 5 times", |b| {
+            let root = small_tree();
+            let progress = root.add_child("the one");
+            progress.init(Some(20), Some("element".into()));
+            b.iter(|| {
+                progress.inc();
+                progress.inc();
+                progress.inc();
+                progress.inc();
+                progress.inc();
+            });
+        });
+    c.benchmark_group("Tree::add_child")
+        .throughput(Throughput::Elements(4))
+        .bench_function("add children to build a tree of tasks and clear them (in drop)", |b| {
+            let root = small_tree();
+            b.iter(|| {
+                let mut c = root.add_child("1");
+                let _one = c.add_child("1");
+                let _two = c.add_child("2");
+                let _three = c.add_child("3");
+            });
         });
     c.benchmark_group("tree::Item::message")
         .throughput(Throughput::Elements(1))
         .bench_function(
             "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,10 @@ pub mod messages;
 pub mod progress;
 
 mod traits;
-pub use traits::{Progress, RawProgress, Root, WeakRoot};
+pub use traits::{
+    BoxedDynNestedProgress, Count, DynNestedProgress, DynNestedProgressToNestedProgress, NestedProgress, Progress,
+    Root, WeakRoot,
+};
 
 mod throughput;
 pub use crate::throughput::Throughput;