Update fmt::Debug to produce new info

src/lib.rs

@@ -116,14 +116,14 @@ struct Inner<T> {
     /// The number of notified entries, or `usize::MAX` if all of them have been notified.
     ///
     /// If there are no entries, this value is set to `usize::MAX`.
-    notified: AtomicUsize,
+    pub notified: AtomicUsize,
 
     /// Inner queue of event listeners.
     ///
     /// On `std` platforms, this is an intrusive linked list. On `no_std` platforms, this is a
     /// more traditional `Vec` of listeners, with an atomic queue used as a backup for high
     /// contention.
-    list: sys::List<T>,
+    pub list: sys::List<T>,
 }
 
 impl<T> Inner<T> {
@@ -171,7 +171,15 @@ 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 { .. }")
+        let inner = self.inner();
+        let notified_count = unsafe { (*inner).notified.load(Ordering::Relaxed) };
+        let total_count = unsafe { (*inner).list.total_listeners() };
+
+        write!(
+            f,
+            "Event {{\n  Number of notified listeners: {:?}\n  Total number of listeners: {:?}\n}}",
+            notified_count, total_count
+        )
     }
 }
 
@@ -202,7 +210,6 @@ impl<T> Event<T> {
             inner: AtomicPtr::new(ptr::null_mut()),
         }
     }
-
     /// Tell whether any listeners are currently notified.
     ///
     /// # Examples
@@ -456,7 +463,6 @@ impl Event<()> {
             inner: AtomicPtr::new(ptr::null_mut()),
         }
     }
-
     /// Notifies a number of active listeners without emitting a `SeqCst` fence.
     ///
     /// The number is allowed to be zero or exceed the current number of listeners.
@@ -650,7 +656,15 @@ 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 { .. }")
+        let mut ds = f.debug_struct("EventListener");
+
+        if self.is_listening() {
+            ds.field("Listening", &"Yes");
+        } else {
+            ds.field("Listening", &"No");
+        }
+
+        ds.finish()
     }
 }
 

src/no_std.rs

@@ -240,6 +240,14 @@ impl<T> List<T> {
             queue: concurrent_queue::ConcurrentQueue::unbounded(),
         }
     }
+    pub fn total_listeners(&self) -> usize {
+        self.inner
+            .try_lock()
+            .as_ref()
+            .map(|lock| &**lock)
+            .map(|listener_slab| listener_slab.listeners.len())
+            .unwrap_or(0)
+    }
 }
 
 /// The guard returned by [`Inner::lock`].

src/std.rs

@@ -44,6 +44,10 @@ 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> {
+        self.0.lock().map(|mutex| mutex.len).map_err(|_| "<locked>")
+    }
 }
 
 impl<T> crate::Inner<T> {