Split the EventListener struct into a sub-listener structure

First part of EventListener reworks. The idea here is that, in the
future, we can add an "EventListenerRef" structure that just takes
an "&'a Inner" rather than an "Arc<Inner>". This way, you don't
need to do an atomic clone for listening.

src/lib.rs

@@ -73,6 +73,7 @@ mod sys;
 
 use alloc::sync::Arc;
 
+use core::borrow::Borrow;
 use core::fmt;
 use core::future::Future;
 use core::mem::ManuallyDrop;
@@ -176,12 +177,12 @@ impl Event {
  let inner = self.inner();
 
  // Register the listener.
- let mut listener = EventListener {
- inner: unsafe { Arc::clone(&ManuallyDrop::new(Arc::from_raw(inner))) },
- state: sys::Listener::Discarded,
- };
+ let mut listener = EventListener(Listener {
+ event: unsafe { Arc::clone(&ManuallyDrop::new(Arc::from_raw(inner))) },
+ listener: sys::Listener::Discarded,
+ });
 
- listener.inner.insert(&mut listener.state);
+ listener.0.event.insert(&mut listener.0.listener);
 
  // Make sure the listener is registered before whatever happens next.
  full_fence();
@@ -443,12 +444,12 @@ impl Default for Event {
 /// If a notified listener is dropped without receiving a notification, dropping will notify
 /// another active listener. Whether one *additional* listener will be notified depends on what
 /// kind of notification was delivered.
-pub struct EventListener {
- /// A reference to [`Event`]'s inner state.
- inner: Arc<Inner>,
+pub struct EventListener(Listener<Arc<Inner>>);
 
- /// The current state of the listener.
- state: sys::Listener,
+impl fmt::Debug for EventListener {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str("EventListener { .. }")
+ }
 }
 
 #[cfg(feature = "std")]
@@ -475,7 +476,7 @@ impl EventListener {
  /// listener.wait();
  /// ```
  pub fn wait(self) {
- self.wait_internal(None);
+ self.0.wait_internal(None);
  }
 
  /// Blocks until a notification is received or a timeout is reached.
@@ -495,7 +496,7 @@ impl EventListener {
  /// assert!(!listener.wait_timeout(Duration::from_secs(1)));
  /// ```
  pub fn wait_timeout(self, timeout: Duration) -> bool {
- self.wait_internal(Some(Instant::now() + timeout))
+ self.0.wait_internal(Instant::now().checked_add(timeout))
  }
 
  /// Blocks until a notification is received or a deadline is reached.
@@ -509,69 +510,14 @@ impl EventListener {
  /// use event_listener::Event;
  ///
  /// let event = Event::new();
- /// let listener = event.listen();
+ /// let mut listener = event.listen();
  ///
  /// // There are no notification so this times out.
- /// assert!(!listener.wait_deadline(Instant::now() + Duration::from_secs(1)));
+ /// assert!(!listener.as_mut().wait_deadline(Instant::now() + Duration::from_secs(1)));
  /// ```
+ #[cfg(feature = "std")]
  pub fn wait_deadline(self, deadline: Instant) -> bool {
- self.wait_internal(Some(deadline))
- }
-
- fn wait_internal(mut self, deadline: Option<Instant>) -> bool {
- let (parker, unparker) = parking::pair();
-
- // Set the listener's state to `Task`.
- match self
- .inner
- .register(&mut self.state, TaskRef::Unparker(&unparker))
- {
- Some(true) => {
- // We were already notified, so we don't need to park.
- return true;
- }
-
- Some(false) => {
- // We're now waiting for a notification.
- }
-
- None => {
- // We were never inserted into the list.
- panic!("listener was never inserted into the list");
- }
- }
-
- // Wait until a notification is received or the timeout is reached.
- loop {
- match deadline {
- None => parker.park(),
-
- Some(deadline) => {
- // Check for timeout.
- let now = Instant::now();
- if now >= deadline {
- // Remove our entry and check if we were notified.
- return self
- .inner
- .remove(&mut self.state, false)
- .expect("We never removed ourself from the list")
- .is_notified();
- }
-
- // Park until the deadline.
- parker.park_timeout(deadline - now);
- }
- }
-
- // See if we were notified.
- if self
- .inner
- .register(&mut self.state, TaskRef::Unparker(&unparker))
- .expect("We never removed ourself from the list")
- {
- return true;
- }
- }
+ self.0.wait_internal(Some(deadline))
  }
 }
 
@@ -595,10 +541,8 @@ impl EventListener {
  /// assert!(listener1.discard());
  /// assert!(!listener2.discard());
  /// ```
- pub fn discard(mut self) -> bool {
- self.inner
- .remove(&mut self.state, false)
- .map_or(false, |state| state.is_notified())
+ pub fn discard(self) -> bool {
+ self.0.discard()
  }
 
  /// Returns `true` if this listener listens to the given `Event`.
@@ -615,7 +559,7 @@ impl EventListener {
  /// ```
  #[inline]
  pub fn listens_to(&self, event: &Event) -> bool {
- ptr::eq::<Inner>(&*self.inner, event.inner.load(Ordering::Acquire))
+ ptr::eq::<Inner>(&**self.inner(), event.inner.load(Ordering::Acquire))
  }
 
  /// Returns `true` if both listeners listen to the same `Event`.
@@ -632,27 +576,112 @@ impl EventListener {
  /// assert!(listener1.same_event(&listener2));
  /// ```
  pub fn same_event(&self, other: &EventListener) -> bool {
- ptr::eq::<Inner>(&*self.inner, &*other.inner)
+ ptr::eq::<Inner>(&**self.inner(), &**other.inner())
  }
-}
 
-impl fmt::Debug for EventListener {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.pad("EventListener { .. }")
+ fn listener(&mut self) -> &mut Listener<Arc<Inner>> {
+ &mut self.0
+ }
+
+ fn inner(&self) -> &Arc<Inner> {
+ &self.0.event
  }
 }
 
 impl Future for EventListener {
  type Output = ();
 
- #[allow(unreachable_patterns)]
- fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
- let this = self.get_mut();
+ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+ self.listener().poll_internal(cx)
+ }
+}
+
+struct Listener<B: Borrow<Inner> + Unpin> {
+ /// The reference to the original event.
+ event: B,
+
+ /// The inner state of the listener.
+ listener: sys::Listener,
+}
+
+unsafe impl<B: Borrow<Inner> + Unpin + Send> Send for Listener<B> {}
+unsafe impl<B: Borrow<Inner> + Unpin + Sync> Sync for Listener<B> {}
+
+impl<B: Borrow<Inner> + Unpin> Listener<B> {
+ /// Wait until the provided deadline.
+ #[cfg(feature = "std")]
+ fn wait_internal(mut self, deadline: Option<Instant>) -> bool {
+ let (parker, unparker) = parking::pair();
+
+ // Set the listener's state to `Task`.
+ match self
+ .event
+ .borrow()
+ .register(&mut self.listener, TaskRef::Unparker(&unparker))
+ {
+ Some(true) => {
+ // We were already notified, so we don't need to park.
+ return true;
+ }
+
+ Some(false) => {
+ // We're now waiting for a notification.
+ }
 
+ None => {
+ // We were never inserted into the list.
+ panic!("listener was never inserted into the list");
+ }
+ }
+
+ // Wait until a notification is received or the timeout is reached.
+ loop {
+ match deadline {
+ None => parker.park(),
+
+ Some(deadline) => {
+ // Make sure we're not timed out already.
+ let now = Instant::now();
+ if now >= deadline {
+ // Remove our entry and check if we were notified.
+ return self
+ .event
+ .borrow()
+ .remove(&mut self.listener, false)
+ .expect("We never removed ourself from the list")
+ .is_notified();
+ }
+ }
+ }
+
+ // See if we were notified.
+ if self
+ .event
+ .borrow()
+ .register(&mut self.listener, TaskRef::Unparker(&unparker))
+ .expect("We never removed ourself from the list")
+ {
+ return true;
+ }
+ }
+ }
+
+ /// Drops this listener and discards its notification (if any) without notifying another
+ /// active listener.
+ fn discard(mut self) -> bool {
+ self.event
+ .borrow()
+ .remove(&mut self.listener, false)
+ .map_or(false, |state| state.is_notified())
+ }
+
+ /// Poll this listener for a notification.
+ fn poll_internal(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  // Try to register the listener.
- match this
- .inner
- .register(&mut this.state, TaskRef::Waker(cx.waker()))
+ match self
+ .event
+ .borrow()
+ .register(&mut self.listener, TaskRef::Waker(cx.waker()))
  {
  Some(true) => {
  // We were already notified, so we don't need to park.
@@ -672,9 +701,10 @@ impl Future for EventListener {
  }
 }
 
-impl Drop for EventListener {
+impl<B: Borrow<Inner> + Unpin> Drop for Listener<B> {
  fn drop(&mut self) {
- self.inner.remove(&mut self.state, true);
+ // If we're being dropped, we need to remove ourself from the list.
+ self.event.borrow().remove(&mut self.listener, true);
  }
 }