Replace Listener with Option<sys::Listener>

Author: notgull

src/lib.rs

@@ -179,7 +179,7 @@ impl Event {
         // Register the listener.
         let mut listener = EventListener(Listener {
             event: unsafe { Arc::clone(&ManuallyDrop::new(Arc::from_raw(inner))) },
-            listener: sys::Listener::Discarded,
+            listener: None,
         });
 
         listener.0.event.insert(&mut listener.0.listener);
@@ -510,10 +510,10 @@ impl EventListener {
     /// use event_listener::Event;
     ///
     /// let event = Event::new();
-    /// let mut listener = event.listen();
+    /// let listener = event.listen();
     ///
     /// // There are no notification so this times out.
-    /// assert!(!listener.as_mut().wait_deadline(Instant::now() + Duration::from_secs(1)));
+    /// assert!(!listener.wait_deadline(Instant::now() + Duration::from_secs(1)));
     /// ```
     #[cfg(feature = "std")]
     pub fn wait_deadline(self, deadline: Instant) -> bool {
@@ -601,7 +601,7 @@ struct Listener<B: Borrow<Inner> + Unpin> {
     event: B,
 
     /// The inner state of the listener.
-    listener: sys::Listener,
+    listener: Option<sys::Listener>,
 }
 
 unsafe impl<B: Borrow<Inner> + Unpin + Send> Send for Listener<B> {}

src/no_std.rs

@@ -33,43 +33,43 @@ impl crate::Inner {
     /// Add a new listener to the list.
     ///
     /// Does nothing if the list is already registered.
-    pub(crate) fn insert(&self, listener: &mut Listener) {
-        if let Listener::HasNode(_) | Listener::Queued(_) = *listener {
+    pub(crate) fn insert(&self, listener: &mut Option<Listener>) {
+        if listener.is_some() {
             // Already inserted.
             return;
         }
 
         match self.try_lock() {
             Some(mut lock) => {
                 let key = lock.insert(State::Created);
-                *listener = Listener::HasNode(key);
+                *listener = Some(Listener::HasNode(key));
             }
 
             None => {
                 // Push it to the queue.
                 let (node, task_waiting) = Node::listener();
                 self.list.queue.push(node);
-                *listener = Listener::Queued(task_waiting);
+                *listener = Some(Listener::Queued(task_waiting));
             }
         }
     }
 
     /// Remove a listener from the list.
-    pub(crate) fn remove(&self, listener: &mut Listener, propogate: bool) -> Option<State> {
-        let state = match mem::replace(listener, Listener::Discarded) {
-            Listener::HasNode(key) => {
+    pub(crate) fn remove(&self, listener: &mut Option<Listener>, propogate: bool) -> Option<State> {
+        let state = match listener.take() {
+            Some(Listener::HasNode(key)) => {
                 match self.try_lock() {
                     Some(mut list) => {
                         // Fast path removal.
-                        list.remove(Listener::HasNode(key), propogate)
+                        list.remove(key, propogate)
                     }
 
                     None => {
                         // Slow path removal.
                         // This is why intrusive lists don't work on no_std.
                         let node = Node::RemoveListener {
+                            key,
                             propagate: propogate,
-                            listener: Listener::HasNode(key),
                         };
 
                         self.list.queue.push(node);
@@ -79,12 +79,12 @@ impl crate::Inner {
                 }
             }
 
-            Listener::Queued(_) => {
+            Some(Listener::Queued(_)) => {
                 // This won't be added after we drop the lock.
                 None
             }
 
-            _ => None,
+            None => None,
         };
 
         state
@@ -115,11 +115,15 @@ impl crate::Inner {
     ///
     /// Returns `true` if the listener was already notified, and `false` otherwise. If the listener
     /// isn't inserted, returns `None`.
-    pub(crate) fn register(&self, listener: &mut Listener, task: TaskRef<'_>) -> Option<bool> {
+    pub(crate) fn register(
+        &self,
+        listener: &mut Option<Listener>,
+        task: TaskRef<'_>,
+    ) -> Option<bool> {
         loop {
-            match mem::replace(listener, Listener::Discarded) {
-                Listener::HasNode(key) => {
-                    *listener = Listener::HasNode(key);
+            match listener.take() {
+                Some(Listener::HasNode(key)) => {
+                    *listener = Some(Listener::HasNode(key));
                     match self.try_lock() {
                         Some(mut guard) => {
                             // Fast path registration.
@@ -135,18 +139,18 @@ impl crate::Inner {
                     }
                 }
 
-                Listener::Queued(task_waiting) => {
+                Some(Listener::Queued(task_waiting)) => {
                     // Are we done yet?
                     match task_waiting.status() {
                         Some(key) => {
                             // We're inserted now, adjust state.
-                            *listener = Listener::HasNode(key);
+                            *listener = Some(Listener::HasNode(key));
                         }
 
                         None => {
                             // We're still queued, so register the task.
                             task_waiting.register(task.into_task());
-                            *listener = Listener::Queued(task_waiting);
+                            *listener = Some(Listener::Queued(task_waiting));
                             return None;
                         }
                     }
@@ -476,12 +480,7 @@ impl ListenerSlab {
     }
 
     /// Removes an entry from the list and returns its state.
-    pub(crate) fn remove(&mut self, listener: Listener, propogate: bool) -> Option<State> {
-        let key = match listener {
-            Listener::HasNode(key) => key,
-            _ => return None,
-        };
-
+    pub(crate) fn remove(&mut self, key: NonZeroUsize, propogate: bool) -> Option<State> {
         let entry = &self.listeners[key.get()];
         let prev = entry.prev().get();
         let next = entry.next().get();
@@ -569,9 +568,13 @@ impl ListenerSlab {
     ///
     /// Returns `true` if the listener was already notified, and `false` otherwise. If the listener
     /// isn't inserted, returns `None`.
-    pub(crate) fn register(&mut self, listener: &mut Listener, task: TaskRef<'_>) -> Option<bool> {
+    pub(crate) fn register(
+        &mut self,
+        listener: &mut Option<Listener>,
+        task: TaskRef<'_>,
+    ) -> Option<bool> {
         let key = match *listener {
-            Listener::HasNode(key) => key,
+            Some(Listener::HasNode(key)) => key,
             _ => return None,
         };
 
@@ -581,7 +584,8 @@ impl ListenerSlab {
         match entry.state().replace(State::NotifiedTaken) {
             State::Notified(_) | State::NotifiedTaken => {
                 // The listener was already notified, so we don't need to do anything.
-                self.remove(mem::replace(listener, Listener::Discarded), false)?;
+                self.remove(key, false)?;
+                *listener = None;
                 Some(true)
             }
 
@@ -609,9 +613,6 @@ pub(crate) enum Listener {
     /// The listener has a node inside of the linked list.
     HasNode(NonZeroUsize),
 
-    /// The listener has already been notified and has discarded its entry.
-    Discarded,
-
     /// The listener has an entry in the queue that may or may not have a task waiting.
     Queued(Arc<TaskWaiting>),
 }

src/no_std/node.rs

@@ -1,6 +1,6 @@
 //! The node that makes up queues.
 
-use super::{Listener, ListenerSlab};
+use super::ListenerSlab;
 use crate::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
 use crate::sync::Arc;
 use crate::{State, Task};
@@ -32,7 +32,7 @@ pub(crate) enum Node {
     /// This node is removing a listener.
     RemoveListener {
         /// The ID of the listener to remove.
-        listener: Listener,
+        key: NonZeroUsize,
 
         /// Whether to propagate notifications to the next listener.
         propagate: bool,
@@ -83,12 +83,9 @@ impl Node {
                 // Notify the listener.
                 list.notify(count, additional);
             }
-            Node::RemoveListener {
-                listener,
-                propagate,
-            } => {
+            Node::RemoveListener { key, propagate } => {
                 // Remove the listener from the list.
-                list.remove(listener, propagate);
+                list.remove(key, propagate);
             }
             Node::Waiting(task) => {
                 return Some(task);