chore: Fix up some minor bits before release

Signed-off-by: John Nunley <dev@notgull.net>

src/lib.rs

@@ -174,9 +174,9 @@ impl<T> fmt::Debug for Event<T> {
  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(_) => {
+ let total_count = match inner.list.try_total_listeners() {
+ Some(total_count) => total_count,
+ None => {
  return f
  .debug_tuple("Event")
  .field(&format_args!("<locked>"))
@@ -480,12 +480,20 @@ impl<T> Event<T> {
  inner
  }
 
- /// Return the listener count by acquiring a lock.
+ /// Get the number of listeners currently listening to this [`Event`].
  ///
- /// This is just a snapshot of the number of listeners at this point in time.
- /// It is possible for the actual number to change at any point.
- /// The number should only ever be used as a hint.
- /// This is only available when `std` feature is enabled.
+ /// This call returns the number of [`EventListener`]s that are currently listening to
+ /// this event. It does this by acquiring the internal event lock and reading the listener
+ /// count. Therefore it is only available for `std`-enabled platforms.
+ ///
+ /// # Caveats
+ ///
+ /// This function returns just a snapshot of the number of listeners at this point in time.
+ /// Due to the nature of multi-threaded CPUs, it is possible that this number will be
+ /// inaccurate by the time that this function returns.
+ ///
+ /// It is possible for the actual number to change at any point. Therefore, the number should
+ /// only ever be used as a hint.
  ///
  /// # Examples
  ///
@@ -510,7 +518,7 @@ impl<T> Event<T> {
  #[inline]
  pub fn total_listeners(&self) -> usize {
  if let Some(inner) = self.try_inner() {
- inner.list.total_listeners_wait()
+ inner.list.total_listeners()
  } else {
  0
  }

src/no_std.rs

@@ -240,11 +240,10 @@ 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>"))
+
+ /// Try to get the total number of listeners without blocking.
+ pub(super) fn try_total_listeners(&self) -> Option<usize> {
+ self.inner.try_lock().map(|lock| lock.listeners.len())
  }
 }
 

src/std.rs

@@ -44,23 +44,15 @@ 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>"),
- }
+
+ /// Get the total number of listeners without blocking.
+ pub(crate) fn try_total_listeners(&self) -> Option<usize> {
+ self.0.try_lock().ok().map(|list| list.len)
  }
 
- // Get the listener count by blocking.
- pub(crate) fn total_listeners_wait(&self) -> usize {
- match self.0.lock() {
- Ok(mutex) => mutex.len,
- Err(err) => panic!("{err}"),
- }
+ /// Get the total number of listeners with blocking.
+ pub(crate) fn total_listeners(&self) -> usize {
+ self.0.lock().unwrap_or_else(|e| e.into_inner()).len
  }
 }