Update fmt::Debug to produce new info

src/lib.rs

@@ -171,7 +171,29 @@ impl<T> core::panic::RefUnwindSafe for Event<T> {}
 
 impl<T> fmt::Debug for Event<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("Event { .. }")
+        match self.try_inner() {
+            Some(inner) => {
+                let notified_count = inner.notified.load(Ordering::Relaxed);
+                let total_count = match inner.list.total_listeners() {
+                    Ok(total_count) => total_count,
+                    Err(_) => {
+                        return f
+                            .debug_tuple("Event")
+                            .field(&format_args!("<locked>"))
+                            .finish()
+                    }
+                };
+
+                f.debug_struct("Event")
+                    .field("listeners_notified", &notified_count)
+                    .field("listeners_total", &total_count)
+                    .finish()
+            }
+            None => f
+                .debug_tuple("Event")
+                .field(&format_args!("<uninitialized>"))
+                .finish(),
+        }
     }
 }
 
@@ -650,7 +672,9 @@ unsafe impl<T: Send> Sync for EventListener<T> {}
 
 impl<T> fmt::Debug for EventListener<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("EventListener { .. }")
+        f.debug_struct("EventListener")
+            .field("listening", &self.is_listening())
+            .finish()
     }
 }
 

src/no_std.rs

@@ -240,6 +240,12 @@ impl<T> List<T> {
             queue: concurrent_queue::ConcurrentQueue::unbounded(),
         }
     }
+    pub fn total_listeners(&self) -> Result<usize, &str> {
+        self.inner
+            .try_lock()
+            .map(|lock| Ok(lock.listeners.len()))
+            .unwrap_or(Err("<locked>"))
+    }
 }
 
 /// The guard returned by [`Inner::lock`].

src/std.rs

@@ -44,6 +44,16 @@ impl<T> List<T> {
             notified: 0,
         }))
     }
+    // Accessor method because fields are private, not sure how to go around it
+    pub fn total_listeners(&self) -> Result<usize, &str> {
+        match self.0.try_lock() {
+            Ok(mutex) => {
+                let len = mutex.len;
+                Ok(len)
+            }
+            Err(_) => Err("<locked>"),
+        }
+    }
 }
 
 impl<T> crate::Inner<T> {