Vendor things

third-party/vendor/calloop/src/macros.rs

@@ -0,0 +1,223 @@
+//! Macros for helping with common operations in Calloop.
+
+/// Register a set of event sources. Effectively calls
+/// [`EventSource::register()`] for all the sources provided.
+///
+/// Usage:
+///
+/// ```none,actually-rust-but-see-https://github.com/rust-lang/rust/issues/63193
+/// calloop::batch_register!(
+///     poll, token_factory,
+///     self.source_one,
+///     self.source_two,
+///     self.source_three,
+///     self.source_four,
+/// )
+/// ```
+///
+/// Note that there is no scope for customisation; if you need to do special
+/// things with a particular source, you'll need to leave it off the list. Also
+/// note that this only does try-or-early-return error handling in the order
+/// that you list the sources; if you need anything else, don't use this macro.
+///
+/// [`EventSource::register()`]: crate::EventSource::register()
+#[macro_export]
+macro_rules! batch_register {
+    ($poll:ident, $token_fac:ident, $( $source:expr ),* $(,)?) => {
+        {
+            $(
+                $source.register($poll, $token_fac)?;
+            )*
+                $crate::Result::<_>::Ok(())
+        }
+    };
+}
+
+/// Reregister a set of event sources. Effectively calls
+/// [`EventSource::reregister()`] for all the sources provided.
+///
+/// Usage:
+///
+/// ```none,actually-rust-but-see-https://github.com/rust-lang/rust/issues/63193
+/// calloop::batch_reregister!(
+///     poll, token_factory,
+///     self.source_one,
+///     self.source_two,
+///     self.source_three,
+///     self.source_four,
+/// )
+/// ```
+///
+/// Note that there is no scope for customisation; if you need to do special
+/// things with a particular source, you'll need to leave it off the list. Also
+/// note that this only does try-or-early-return error handling in the order
+/// that you list the sources; if you need anything else, don't use this macro.
+///
+/// [`EventSource::reregister()`]: crate::EventSource::reregister()
+#[macro_export]
+macro_rules! batch_reregister {
+    ($poll:ident, $token_fac:ident, $( $source:expr ),* $(,)?) => {
+        {
+            $(
+                $source.reregister($poll, $token_fac)?;
+            )*
+                $crate::Result::<_>::Ok(())
+        }
+    };
+}
+
+/// Unregister a set of event sources. Effectively calls
+/// [`EventSource::unregister()`] for all the sources provided.
+///
+/// Usage:
+///
+/// ```none,actually-rust-but-see-https://github.com/rust-lang/rust/issues/63193
+/// calloop::batch_unregister!(
+///     poll,
+///     self.source_one,
+///     self.source_two,
+///     self.source_three,
+///     self.source_four,
+/// )
+/// ```
+///
+/// Note that there is no scope for customisation; if you need to do special
+/// things with a particular source, you'll need to leave it off the list. Also
+/// note that this only does try-or-early-return error handling in the order
+/// that you list the sources; if you need anything else, don't use this macro.
+///
+/// [`EventSource::unregister()`]: crate::EventSource::unregister()
+#[macro_export]
+macro_rules! batch_unregister {
+    ($poll:ident, $( $source:expr ),* $(,)?) => {
+        {
+            $(
+                $source.unregister($poll)?;
+            )*
+                $crate::Result::<_>::Ok(())
+        }
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use crate::{
+        ping::{make_ping, PingSource},
+        EventSource, PostAction,
+    };
+
+    struct BatchSource {
+        ping0: PingSource,
+        ping1: PingSource,
+        ping2: PingSource,
+    }
+
+    impl EventSource for BatchSource {
+        type Event = usize;
+        type Metadata = ();
+        type Ret = ();
+        type Error = Box<dyn std::error::Error + Sync + Send>;
+
+        fn process_events<F>(
+            &mut self,
+            readiness: crate::Readiness,
+            token: crate::Token,
+            mut callback: F,
+        ) -> Result<crate::PostAction, Self::Error>
+        where
+            F: FnMut(Self::Event, &mut Self::Metadata) -> Self::Ret,
+        {
+            self.ping0
+                .process_events(readiness, token, |_, m| callback(0, m))?;
+            self.ping1
+                .process_events(readiness, token, |_, m| callback(1, m))?;
+            self.ping2
+                .process_events(readiness, token, |_, m| callback(2, m))?;
+            Ok(PostAction::Continue)
+        }
+
+        fn register(
+            &mut self,
+            poll: &mut crate::Poll,
+            token_factory: &mut crate::TokenFactory,
+        ) -> crate::Result<()> {
+            crate::batch_register!(poll, token_factory, self.ping0, self.ping1, self.ping2)
+        }
+
+        fn reregister(
+            &mut self,
+            poll: &mut crate::Poll,
+            token_factory: &mut crate::TokenFactory,
+        ) -> crate::Result<()> {
+            crate::batch_reregister!(poll, token_factory, self.ping0, self.ping1, self.ping2)
+        }
+
+        fn unregister(&mut self, poll: &mut crate::Poll) -> crate::Result<()> {
+            crate::batch_unregister!(poll, self.ping0, self.ping1, self.ping2)
+        }
+    }
+
+    #[test]
+    fn test_batch_operations() {
+        let mut fired = [false; 3];
+
+        let (send0, ping0) = make_ping().unwrap();
+        let (send1, ping1) = make_ping().unwrap();
+        let (send2, ping2) = make_ping().unwrap();
+
+        let top = BatchSource {
+            ping0,
+            ping1,
+            ping2,
+        };
+
+        let mut event_loop = crate::EventLoop::<[bool; 3]>::try_new().unwrap();
+        let handle = event_loop.handle();
+
+        let token = handle
+            .insert_source(top, |idx, _, fired| {
+                fired[idx] = true;
+            })
+            .unwrap();
+
+        send0.ping();
+        send1.ping();
+        send2.ping();
+
+        event_loop
+            .dispatch(Duration::new(0, 0), &mut fired)
+            .unwrap();
+
+        assert_eq!(fired, [true; 3]);
+
+        fired = [false; 3];
+
+        handle.update(&token).unwrap();
+
+        send0.ping();
+        send1.ping();
+        send2.ping();
+
+        event_loop
+            .dispatch(Duration::new(0, 0), &mut fired)
+            .unwrap();
+
+        assert_eq!(fired, [true; 3]);
+
+        fired = [false; 3];
+
+        handle.remove(token);
+
+        send0.ping();
+        send1.ping();
+        send2.ping();
+
+        event_loop
+            .dispatch(Duration::new(0, 0), &mut fired)
+            .unwrap();
+
+        assert_eq!(fired, [false; 3]);
+    }
+}