Bump async dependencies

Bump tokio to version 1.x, mio to 0.7.x and futures to 0.3.
Also set edition to 2018.

Author: oll3

Cargo.toml

@@ -11,13 +11,14 @@ homepage = "https://github.com/rust-embedded/rust-sysfs-gpio"
 documentation = "https://docs.rs/sysfs_gpio/"
 description = "Provides access to GPIOs using the Linux sysfs interface."
 readme = "README.md"
+edition = "2018"
 
 [features]
 mio-evented = ["mio"]
 async-tokio = ["futures", "tokio", "mio-evented"]
 
 [dependencies]
-futures = { version = "0.1", optional = true }
+futures = { version = "0.3", optional = true }
 nix = "0.22"
-mio = { version = "0.6", optional = true }
-tokio = { version = "0.1", optional = true }
+mio = { version = "0.7", optional = true, features = ["os-ext"]}
+tokio = { version = "1", optional = true, features = ["net"] }

src/lib.rs

@@ -53,28 +53,29 @@ extern crate nix;
 #[cfg(feature = "async-tokio")]
 extern crate tokio;
 
-use std::fs;
-use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 #[cfg(any(target_os = "linux", target_os = "android", feature = "async-tokio"))]
 use std::io::SeekFrom;
 #[cfg(not(target_os = "wasi"))]
 use std::os::unix::prelude::*;
 use std::path::Path;
+use std::{fs, fs::File};
 
 #[cfg(feature = "async-tokio")]
-use futures::{Async, Poll, Stream};
+use futures::{ready, Stream};
 #[cfg(feature = "mio-evented")]
-use mio::unix::EventedFd;
+use mio::event::Source;
 #[cfg(feature = "mio-evented")]
-use mio::Evented;
+use mio::unix::SourceFd;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use nix::sys::epoll::*;
 #[cfg(not(target_os = "wasi"))]
 use nix::unistd::close;
 #[cfg(feature = "async-tokio")]
-use tokio::reactor::{Handle, PollEvented};
+use std::task::Poll;
+#[cfg(feature = "async-tokio")]
+use tokio::io::unix::AsyncFd;
 
 pub use error::Error;
 
@@ -472,17 +473,6 @@ impl Pin {
         AsyncPinPoller::new(self.pin_num)
     }
 
-    /// Get a Stream of pin interrupts for this pin
-    ///
-    /// The PinStream object can be used with the `tokio` crate. You should probably call
-    /// `set_edge()` before using this.
-    ///
-    /// This method is only available when the `async-tokio` crate feature is enabled.
-    #[cfg(feature = "async-tokio")]
-    pub fn get_stream_with_handle(&self, handle: &Handle) -> Result<PinStream> {
-        PinStream::init_with_handle(*self, handle)
-    }
-
     /// Get a Stream of pin interrupts for this pin
     ///
     /// The PinStream object can be used with the `tokio` crate. You should probably call
@@ -494,22 +484,6 @@ impl Pin {
         PinStream::init(*self)
     }
 
-    /// Get a Stream of pin values for this pin
-    ///
-    /// The PinStream object can be used with the `tokio` crate. You should probably call
-    /// `set_edge(Edge::BothEdges)` before using this.
-    ///
-    /// Note that the values produced are the value of the pin as soon as we get to handling the
-    /// interrupt in userspace.  Each time this stream produces a value, a change has occurred, but
-    /// it could end up producing the same value multiple times if the value has changed back
-    /// between when the interrupt occurred and when the value was read.
-    ///
-    /// This method is only available when the `async-tokio` crate feature is enabled.
-    #[cfg(feature = "async-tokio")]
-    pub fn get_value_stream_with_handle(&self, handle: &Handle) -> Result<PinValueStream> {
-        Ok(PinValueStream(PinStream::init_with_handle(*self, handle)?))
-    }
-
     /// Get a Stream of pin values for this pin
     ///
     /// The PinStream object can be used with the `tokio` crate. You should probably call
@@ -536,9 +510,9 @@ fn extract_pin_fom_path_test() {
     let tok3 = Pin::extract_pin_from_path(&"../../devices/soc0/gpiochip3/gpio/gpio124");
     assert_eq!(124, tok3.unwrap());
     let err1 = Pin::extract_pin_from_path(&"/sys/CLASS/gpio/gpio");
-    assert_eq!(true, err1.is_err());
+    assert!(err1.is_err());
     let err2 = Pin::extract_pin_from_path(&"/sys/class/gpio/gpioSDS");
-    assert_eq!(true, err2.is_err());
+    assert!(err2.is_err());
 }
 #[cfg(not(target_os = "wasi"))]
 #[derive(Debug)]
@@ -643,76 +617,70 @@ impl AsyncPinPoller {
 }
 
 #[cfg(feature = "mio-evented")]
-impl Evented for AsyncPinPoller {
+impl Source for AsyncPinPoller {
     fn register(
-        &self,
-        poll: &mio::Poll,
+        &mut self,
+        poll: &mio::Registry,
         token: mio::Token,
-        interest: mio::Ready,
-        opts: mio::PollOpt,
+        interest: mio::Interest,
     ) -> io::Result<()> {
-        EventedFd(&self.devfile.as_raw_fd()).register(poll, token, interest, opts)
+        SourceFd(&self.as_raw_fd()).register(poll, token, interest)
     }
 
     fn reregister(
-        &self,
-        poll: &mio::Poll,
+        &mut self,
+        poll: &mio::Registry,
         token: mio::Token,
-        interest: mio::Ready,
-        opts: mio::PollOpt,
+        interest: mio::Interest,
     ) -> io::Result<()> {
-        EventedFd(&self.devfile.as_raw_fd()).reregister(poll, token, interest, opts)
+        SourceFd(&self.as_raw_fd()).reregister(poll, token, interest)
     }
 
-    fn deregister(&self, poll: &mio::Poll) -> io::Result<()> {
-        EventedFd(&self.devfile.as_raw_fd()).deregister(poll)
+    fn deregister(&mut self, poll: &mio::Registry) -> io::Result<()> {
+        SourceFd(&self.as_raw_fd()).deregister(poll)
     }
 }
 
-#[cfg(feature = "async-tokio")]
-pub struct PinStream {
-    evented: PollEvented<AsyncPinPoller>,
-    skipped_first_event: bool,
+#[cfg(any(feature = "async-tokio", feature = "mio-evented"))]
+impl AsRawFd for AsyncPinPoller {
+    fn as_raw_fd(&self) -> RawFd {
+        self.devfile.as_raw_fd()
+    }
 }
 
 #[cfg(feature = "async-tokio")]
-impl PinStream {
-    pub fn init_with_handle(pin: Pin, handle: &Handle) -> Result<Self> {
-        Ok(PinStream {
-            evented: PollEvented::new(pin.get_async_poller()?, handle)?,
-            skipped_first_event: false,
-        })
-    }
+pub struct PinStream {
+    evented: AsyncFd<AsyncPinPoller>,
+    skipped_first_event: bool,
 }
 
 #[cfg(feature = "async-tokio")]
 impl PinStream {
     pub fn init(pin: Pin) -> Result<Self> {
         Ok(PinStream {
-            evented: PollEvented::new(pin.get_async_poller()?, &Handle::default())?,
+            evented: AsyncFd::new(pin.get_async_poller()?)?,
             skipped_first_event: false,
         })
     }
 }
 
 #[cfg(feature = "async-tokio")]
 impl Stream for PinStream {
-    type Item = ();
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        Ok(match self.evented.poll_read() {
-            Async::Ready(()) => {
-                self.evented.need_read()?;
-                if self.skipped_first_event {
-                    Async::Ready(Some(()))
-                } else {
-                    self.skipped_first_event = true;
-                    Async::NotReady
-                }
+    type Item = Result<()>;
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        loop {
+            let mut guard = ready!(self.evented.poll_read_ready(cx))?;
+            guard.clear_ready();
+            if self.skipped_first_event {
+                return Poll::Ready(Some(Ok(())));
+            } else {
+                self.skipped_first_event = true;
             }
-            Async::NotReady => Async::NotReady,
-        })
+        }
     }
 }
 
@@ -729,18 +697,13 @@ impl PinValueStream {
 
 #[cfg(feature = "async-tokio")]
 impl Stream for PinValueStream {
-    type Item = u8;
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        match self.0.poll() {
-            Ok(Async::Ready(Some(()))) => {
-                let value = self.get_value()?;
-                Ok(Async::Ready(Some(value)))
-            }
-            Ok(Async::Ready(None)) => Ok(Async::Ready(None)),
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(e) => Err(e),
-        }
+    type Item = Result<u8>;
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        ready!(std::pin::Pin::new(&mut self.0).poll_next(cx));
+        Poll::Ready(Some(Ok(self.get_value()?)))
     }
 }