feat!: Make messaging functions thread-safe by taking shared borrow and requring Sync.

That way it's possible to share the `RawProgress` object across threads and emit messages,
much like a logging system that's more integrated with rendering.

Author: Byron

src/progress/log.rs

@@ -136,7 +136,7 @@ impl Progress for Log {
         self.id
     }
 
-    fn message(&mut self, level: MessageLevel, message: impl Into<String>) {
+    fn message(&self, level: MessageLevel, message: impl Into<String>) {
         let message: String = message.into();
         match level {
             MessageLevel::Info => log::info!("ℹ{} → {}", self.name, message),

src/progress/utils.rs

@@ -38,7 +38,7 @@ impl Progress for Discard {
         crate::progress::UNKNOWN
     }
 
-    fn message(&mut self, _level: MessageLevel, _message: impl Into<String>) {}
+    fn message(&self, _level: MessageLevel, _message: impl Into<String>) {}
 
     fn counter(&self) -> Option<StepShared> {
         None
@@ -144,7 +144,7 @@ where
         todo!()
     }
 
-    fn message(&mut self, level: MessageLevel, message: impl Into<String>) {
+    fn message(&self, level: MessageLevel, message: impl Into<String>) {
         match self {
             Either::Left(l) => l.message(level, message),
             Either::Right(r) => r.message(level, message),
@@ -247,7 +247,7 @@ where
         self.0.id()
     }
 
-    fn message(&mut self, level: MessageLevel, message: impl Into<String>) {
+    fn message(&self, level: MessageLevel, message: impl Into<String>) {
         self.0.message(level, message)
     }
 
@@ -321,7 +321,7 @@ impl<T: Progress> Progress for ThroughputOnDrop<T> {
         self.0.id()
     }
 
-    fn message(&mut self, level: MessageLevel, message: impl Into<String>) {
+    fn message(&self, level: MessageLevel, message: impl Into<String>) {
         self.0.message(level, message)
     }
 

src/traits.rs

@@ -3,7 +3,7 @@ use std::time::Instant;
 use crate::{messages::MessageLevel, progress, progress::Id, Unit};
 
 /// A trait for describing hierarchical progress.
-pub trait Progress: Send {
+pub trait Progress: Send + Sync {
     /// The type of progress returned by [`add_child()`][Progress::add_child()].
     type SubProgress: Progress;
 
@@ -87,7 +87,7 @@ pub trait Progress: Send {
     ///
     /// 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>);
+    fn message(&self, level: MessageLevel, message: impl Into<String>);
 
     /// If available, return an atomic counter for direct access to the underlying state.
     ///
@@ -98,19 +98,19 @@ pub trait Progress: Send {
     }
 
     /// Create a message providing additional information about the progress thus far.
-    fn info(&mut self, message: impl Into<String>) {
+    fn info(&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>) {
+    fn done(&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>) {
+    fn fail(&self, message: impl Into<String>) {
         self.message(MessageLevel::Failure, message)
     }
     /// A shorthand to print throughput information
-    fn show_throughput(&mut self, start: Instant) {
+    fn show_throughput(&self, start: Instant) {
         let step = self.step();
         match self.unit() {
             Some(unit) => self.show_throughput_with(start, step, unit, MessageLevel::Info),
@@ -126,7 +126,7 @@ pub trait Progress: Send {
     }
 
     /// 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) {
+    fn show_throughput_with(&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;
@@ -159,7 +159,7 @@ pub trait Progress: Send {
 /// It differs by not being able to add child progress dynamically, but in turn is object safe. It's recommended to
 /// use this trait whenever there is no need to add child progress, at the leaf of a computation.
 // NOTE: keep this in-sync with `Progress`.
-pub trait RawProgress: Send {
+pub trait RawProgress: Send + Sync {
     /// 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)
@@ -227,7 +227,7 @@ pub trait RawProgress: Send {
     ///
     /// Use this to provide additional,human-readable information about the progress
     /// made, including indicating success or failure.
-    fn message(&mut self, level: MessageLevel, message: String);
+    fn message(&self, level: MessageLevel, message: String);
 
     /// If available, return an atomic counter for direct access to the underlying state.
     ///
@@ -238,19 +238,19 @@ pub trait RawProgress: Send {
     }
 
     /// Create a message providing additional information about the progress thus far.
-    fn info(&mut self, message: String) {
+    fn info(&self, message: String) {
         self.message(MessageLevel::Info, message)
     }
     /// Create a message indicating the task is done successfully
-    fn done(&mut self, message: String) {
+    fn done(&self, message: String) {
         self.message(MessageLevel::Success, message)
     }
     /// Create a message indicating the task failed
-    fn fail(&mut self, message: String) {
+    fn fail(&self, message: String) {
         self.message(MessageLevel::Failure, message)
     }
     /// A shorthand to print throughput information
-    fn show_throughput(&mut self, start: Instant) {
+    fn show_throughput(&self, start: Instant) {
         let step = self.step();
         match self.unit() {
             Some(unit) => self.show_throughput_with(start, step, unit, MessageLevel::Info),
@@ -266,7 +266,7 @@ pub trait RawProgress: Send {
     }
 
     /// 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) {
+    fn show_throughput_with(&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;
@@ -400,31 +400,31 @@ mod impls {
             <T as Progress>::id(self)
         }
 
-        fn message(&mut self, level: MessageLevel, message: String) {
+        fn message(&self, level: MessageLevel, message: String) {
             <T as Progress>::message(self, level, message)
         }
 
         fn counter(&self) -> Option<StepShared> {
             <T as Progress>::counter(self)
         }
 
-        fn info(&mut self, message: String) {
+        fn info(&self, message: String) {
             <T as Progress>::info(self, message)
         }
 
-        fn done(&mut self, message: String) {
+        fn done(&self, message: String) {
             <T as Progress>::done(self, message)
         }
 
-        fn fail(&mut self, message: String) {
+        fn fail(&self, message: String) {
             <T as Progress>::fail(self, message)
         }
 
-        fn show_throughput(&mut self, start: Instant) {
+        fn show_throughput(&self, start: Instant) {
             <T as Progress>::show_throughput(self, start)
         }
 
-        fn show_throughput_with(&mut self, start: Instant, step: Step, unit: Unit, level: MessageLevel) {
+        fn show_throughput_with(&self, start: Instant, step: Step, unit: Unit, level: MessageLevel) {
             <T as Progress>::show_throughput_with(self, start, step, unit, level)
         }
     }
@@ -487,32 +487,32 @@ mod impls {
             self.deref().id()
         }
 
-        fn message(&mut self, level: MessageLevel, message: impl Into<String>) {
-            self.deref_mut().message(level, message)
+        fn message(&self, level: MessageLevel, message: impl Into<String>) {
+            self.deref().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 info(&self, message: impl Into<String>) {
+            self.deref().info(message)
         }
 
-        fn done(&mut self, message: impl Into<String>) {
-            self.deref_mut().done(message)
+        fn done(&self, message: impl Into<String>) {
+            self.deref().done(message)
         }
 
-        fn fail(&mut self, message: impl Into<String>) {
-            self.deref_mut().fail(message)
+        fn fail(&self, message: impl Into<String>) {
+            self.deref().fail(message)
         }
 
-        fn show_throughput(&mut self, start: Instant) {
-            self.deref_mut().show_throughput(start)
+        fn show_throughput(&self, start: Instant) {
+            self.deref().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)
+        fn show_throughput_with(&self, start: Instant, step: Step, unit: Unit, level: MessageLevel) {
+            self.deref().show_throughput_with(start, step, unit, level)
         }
     }
 }

src/tree/item.rs

@@ -292,7 +292,7 @@ impl Item {
     ///
     /// Use this to provide additional,human-readable information about the progress
     /// made, including indicating success or failure.
-    pub fn message(&mut self, level: MessageLevel, message: impl Into<String>) {
+    pub fn message(&self, level: MessageLevel, message: impl Into<String>) {
         let message: String = message.into();
         self.messages.lock().push_overwrite(
             level,
@@ -396,7 +396,7 @@ impl crate::Progress for Item {
         Item::id(self)
     }
 
-    fn message(&mut self, level: MessageLevel, message: impl Into<String>) {
+    fn message(&self, level: MessageLevel, message: impl Into<String>) {
         Item::message(self, level, message)
     }
 

tests/raw_progress/mod.rs

@@ -9,3 +9,13 @@ fn dyn_safe() {
     let mut child_of_child = child.add_child("there");
     needs_dyn(&mut child_of_child);
 }
+
+#[test]
+fn thread_safe() {
+    fn needs_send<'a, T: Send + 'a>(_p: T) {}
+    let root = prodash::tree::Root::new();
+    let mut child = root.add_child("hello");
+    needs_send(&child);
+    let child_of_child = child.add_child("there");
+    needs_send(&child_of_child);
+}