Use std IoVec on AsyncRead/AsyncWrite

taiki-e · taiki-e · commit dfbd3c93651f · 2019-04-25T20:59:14.000+09:00
Also, this renames `poll_vectored_*` to `poll_*_vectored` to make it in
the same order as std.
diff --git a/futures-io/Cargo.toml b/futures-io/Cargo.toml
@@ -15,12 +15,11 @@ The `AsyncRead` and `AsyncWrite` traits for the futures-rs library.
 name = "futures_io"
 
 [features]
-std = ["futures-core-preview/std", "iovec"]
+std = ["futures-core-preview/std"]
 default = ["std"]
 
 [dependencies]
 futures-core-preview = { path = "../futures-core", version = "=0.3.0-alpha.14", default-features = false }
-iovec = { version = "0.1", optional = true }
 
 [dev-dependencies]
 futures-preview = { path = "../futures", version = "=0.3.0-alpha.14" }
diff --git a/futures-io/src/lib.rs b/futures-io/src/lib.rs
@@ -20,14 +20,12 @@ mod if_std {
     use std::pin::Pin;
     use std::ptr;
 
-    // Re-export IoVec for convenience
-    pub use iovec::IoVec;
-
-    // Re-export io::Error so that users don't have to deal
+    // Re-export some `std::io` items so that users don't have to deal
     // with conflicts when `use`ing `futures::io` and `std::io`.
     pub use self::StdIo::Error as Error;
     pub use self::StdIo::ErrorKind as ErrorKind;
     pub use self::StdIo::Result as Result;
+    pub use self::StdIo::{IoVec as IoVec, IoVecMut as IoVecMut};
 
     /// A type used to conditionally initialize buffers passed to `AsyncRead`
     /// methods, modeled after `std`.
@@ -133,7 +131,7 @@ mod if_std {
         /// `Interrupted`.  Implementations must convert `WouldBlock` into
         /// `Poll::Pending` and either internally retry or convert
         /// `Interrupted` into another error kind.
-        fn poll_vectored_read(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [&mut IoVec])
+        fn poll_read_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [IoVecMut<'_>])
             -> Poll<Result<usize>>
         {
             if let Some(ref mut first_iovec) = vec.get_mut(0) {
@@ -194,7 +192,7 @@ mod if_std {
         /// `Interrupted`.  Implementations must convert `WouldBlock` into
         /// `Poll::Pending` and either internally retry or convert
         /// `Interrupted` into another error kind.
-        fn poll_vectored_write(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[&IoVec])
+        fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[IoVec<'_>])
             -> Poll<Result<usize>>
         {
             if let Some(ref first_iovec) = vec.get(0) {
@@ -253,10 +251,10 @@ mod if_std {
                 Pin::new(&mut **self).poll_read(cx, buf)
             }
 
-            fn poll_vectored_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [&mut IoVec])
+            fn poll_read_vectored(mut self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [IoVecMut<'_>])
                 -> Poll<Result<usize>>
             {
-                Pin::new(&mut **self).poll_vectored_read(cx, vec)
+                Pin::new(&mut **self).poll_read_vectored(cx, vec)
             }
         }
     }
@@ -284,10 +282,10 @@ mod if_std {
             Pin::get_mut(self).as_mut().poll_read(cx, buf)
         }
 
-        fn poll_vectored_read(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [&mut IoVec])
+        fn poll_read_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [IoVecMut<'_>])
             -> Poll<Result<usize>>
         {
-            Pin::get_mut(self).as_mut().poll_vectored_read(cx, vec)
+            Pin::get_mut(self).as_mut().poll_read_vectored(cx, vec)
         }
     }
 
@@ -304,6 +302,12 @@ mod if_std {
             {
                 Poll::Ready(StdIo::Read::read(&mut *self, buf))
             }
+
+            fn poll_read_vectored(mut self: Pin<&mut Self>, _: &mut Context<'_>, vec: &mut [IoVecMut<'_>])
+                -> Poll<Result<usize>>
+            {
+                Poll::Ready(StdIo::Read::read_vectored(&mut *self, vec))
+            }
         }
     }
 
@@ -327,10 +331,10 @@ mod if_std {
                 Pin::new(&mut **self).poll_write(cx, buf)
             }
 
-            fn poll_vectored_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[&IoVec])
+            fn poll_write_vectored(mut self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[IoVec<'_>])
                 -> Poll<Result<usize>>
             {
-                Pin::new(&mut **self).poll_vectored_write(cx, vec)
+                Pin::new(&mut **self).poll_write_vectored(cx, vec)
             }
 
             fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
@@ -362,10 +366,10 @@ mod if_std {
             Pin::get_mut(self).as_mut().poll_write(cx, buf)
         }
 
-        fn poll_vectored_write(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[&IoVec])
+        fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[IoVec<'_>])
             -> Poll<Result<usize>>
         {
-            Pin::get_mut(self).as_mut().poll_vectored_write(cx, vec)
+            Pin::get_mut(self).as_mut().poll_write_vectored(cx, vec)
         }
 
         fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
@@ -385,6 +389,12 @@ mod if_std {
                 Poll::Ready(StdIo::Write::write(&mut *self, buf))
             }
 
+            fn poll_write_vectored(mut self: Pin<&mut Self>, _: &mut Context<'_>, vec: &[IoVec<'_>])
+                -> Poll<Result<usize>>
+            {
+                Poll::Ready(StdIo::Write::write_vectored(&mut *self, vec))
+            }
+
             fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<()>> {
                 Poll::Ready(StdIo::Write::flush(&mut *self))
             }
@@ -413,6 +423,12 @@ mod if_std {
             Poll::Ready(result)
         }
 
+        fn poll_write_vectored(self: Pin<&mut Self>, _: &mut Context<'_>, vec: &[IoVec<'_>])
+            -> Poll<Result<usize>>
+        {
+            Poll::Ready(StdIo::Write::write_vectored(&mut self.get_mut().get_mut().as_mut(), vec))
+        }
+
         fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<()>> {
             Poll::Ready(StdIo::Write::flush(&mut self.get_mut().get_mut().as_mut()))
         }
diff --git a/futures-util/src/io/allow_std.rs b/futures-util/src/io/allow_std.rs
@@ -64,6 +64,9 @@ impl<T> io::Write for AllowStdIo<T> where T: io::Write {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.0.write(buf)
     }
+    fn write_vectored(&mut self, bufs: &[IoVec<'_>]) -> io::Result<usize> {
+        self.0.write_vectored(bufs)
+    }
     fn flush(&mut self) -> io::Result<()> {
         self.0.flush()
     }
@@ -82,6 +85,12 @@ impl<T> AsyncWrite for AllowStdIo<T> where T: io::Write {
         Poll::Ready(Ok(try_with_interrupt!(self.0.write(buf))))
     }
 
+    fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoVec<'_>])
+        -> Poll<Result<usize>>
+    {
+        Poll::Ready(Ok(try_with_interrupt!(self.0.write_vectored(bufs))))
+    }
+
     fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
         try_with_interrupt!(self.0.flush());
         Poll::Ready(Ok(()))
@@ -96,6 +105,9 @@ impl<T> io::Read for AllowStdIo<T> where T: io::Read {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.0.read(buf)
     }
+    fn read_vectored(&mut self, bufs: &mut [IoVecMut<'_>]) -> io::Result<usize> {
+        self.0.read_vectored(bufs)
+    }
     // TODO: implement the `initializer` fn when it stabilizes.
     // See rust-lang/rust #42788
     fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
@@ -115,4 +127,10 @@ impl<T> AsyncRead for AllowStdIo<T> where T: io::Read {
     {
         Poll::Ready(Ok(try_with_interrupt!(self.0.read(buf))))
     }
+
+    fn poll_read_vectored(mut self: Pin<&mut Self>, _: &mut Context<'_>, bufs: &mut [IoVecMut<'_>])
+        -> Poll<Result<usize>>
+    {
+        Poll::Ready(Ok(try_with_interrupt!(self.0.read_vectored(bufs))))
+    }
 }
diff --git a/futures-util/src/io/mod.rs b/futures-util/src/io/mod.rs
@@ -7,7 +7,7 @@
 
 use std::vec::Vec;
 
-pub use futures_io::{AsyncRead, AsyncWrite, IoVec};
+pub use futures_io::{AsyncRead, AsyncWrite, IoVec, IoVecMut};
 
 #[cfg(feature = "io-compat")] use crate::compat::Compat;
 
diff --git a/futures-util/src/io/split.rs b/futures-util/src/io/split.rs
@@ -1,6 +1,6 @@
 use crate::lock::BiLock;
 use futures_core::task::{Context, Poll};
-use futures_io::{AsyncRead, AsyncWrite, IoVec};
+use futures_io::{AsyncRead, AsyncWrite, IoVec, IoVecMut};
 use std::io;
 use std::pin::Pin;
 
@@ -43,10 +43,10 @@ impl<R: AsyncRead> AsyncRead for ReadHalf<R> {
         lock_and_then(&self.handle, cx, |l, cx| l.poll_read(cx, buf))
     }
 
-    fn poll_vectored_read(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [&mut IoVec])
+    fn poll_read_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [IoVecMut<'_>])
         -> Poll<io::Result<usize>>
     {
-        lock_and_then(&self.handle, cx, |l, cx| l.poll_vectored_read(cx, vec))
+        lock_and_then(&self.handle, cx, |l, cx| l.poll_read_vectored(cx, vec))
     }
 }
 
@@ -57,10 +57,10 @@ impl<W: AsyncWrite> AsyncWrite for WriteHalf<W> {
         lock_and_then(&self.handle, cx, |l, cx| l.poll_write(cx, buf))
     }
 
-    fn poll_vectored_write(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[&IoVec])
+    fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[IoVec<'_>])
         -> Poll<io::Result<usize>>
     {
-        lock_and_then(&self.handle, cx, |l, cx| l.poll_vectored_write(cx, vec))
+        lock_and_then(&self.handle, cx, |l, cx| l.poll_write_vectored(cx, vec))
     }
 
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
diff --git a/futures/src/lib.rs b/futures/src/lib.rs
@@ -268,8 +268,9 @@ pub mod io {
     //! sinks.
 
     pub use futures_io::{
-        Error, Initializer, IoVec, ErrorKind, AsyncRead, AsyncWrite, Result
+        Error, Initializer, IoVec, IoVecMut, ErrorKind, AsyncRead, AsyncWrite, Result,
     };
+
     pub use futures_util::io::{
         AsyncReadExt, AsyncWriteExt, AllowStdIo, Close, CopyInto, Flush,
         Read, ReadExact, ReadHalf, ReadToEnd, Window, WriteAll, WriteHalf,

Original file line number	Diff line number	Diff line change
`@@ -20,14 +20,12 @@ mod if_std {`
`20`	`20`	`use std::pin::Pin;`
`21`	`21`	`use std::ptr;`
`22`	`22`
`23`		`- // Re-export IoVec for convenience`
`24`		`- pub use iovec::IoVec;`
`25`		`-`
`26`		`- // Re-export io::Error so that users don't have to deal`
	`23`	+ // Re-export some `std::io` items so that users don't have to deal
`27`	`24`	// with conflicts when `use`ing `futures::io` and `std::io`.
`28`	`25`	`pub use self::StdIo::Error as Error;`
`29`	`26`	`pub use self::StdIo::ErrorKind as ErrorKind;`
`30`	`27`	`pub use self::StdIo::Result as Result;`
	`28`	`+ pub use self::StdIo::{IoVec as IoVec, IoVecMut as IoVecMut};`
`31`	`29`
`32`	`30`	/// A type used to conditionally initialize buffers passed to `AsyncRead`
`33`	`31`	/// methods, modeled after `std`.
`@@ -133,7 +131,7 @@ mod if_std {`
`133`	`131`	/// `Interrupted`. Implementations must convert `WouldBlock` into
`134`	`132`	/// `Poll::Pending` and either internally retry or convert
`135`	`133`	/// `Interrupted` into another error kind.
`136`		`- fn poll_vectored_read(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [&mut IoVec])`
	`134`	`+ fn poll_read_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [IoVecMut<'_>])`
`137`	`135`	`-> Poll<Result<usize>>`
`138`	`136`	`{`
`139`	`137`	`if let Some(ref mut first_iovec) = vec.get_mut(0) {`
`@@ -194,7 +192,7 @@ mod if_std {`
`194`	`192`	/// `Interrupted`. Implementations must convert `WouldBlock` into
`195`	`193`	/// `Poll::Pending` and either internally retry or convert
`196`	`194`	/// `Interrupted` into another error kind.
`197`		`- fn poll_vectored_write(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[&IoVec])`
	`195`	`+ fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[IoVec<'_>])`
`198`	`196`	`-> Poll<Result<usize>>`
`199`	`197`	`{`
`200`	`198`	`if let Some(ref first_iovec) = vec.get(0) {`
`@@ -253,10 +251,10 @@ mod if_std {`
`253`	`251`	`Pin::new(&mut **self).poll_read(cx, buf)`
`254`	`252`	`}`
`255`	`253`
`256`		`- fn poll_vectored_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [&mut IoVec])`
	`254`	`+ fn poll_read_vectored(mut self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [IoVecMut<'_>])`
`257`	`255`	`-> Poll<Result<usize>>`
`258`	`256`	`{`
`259`		`- Pin::new(&mut **self).poll_vectored_read(cx, vec)`
	`257`	`+ Pin::new(&mut **self).poll_read_vectored(cx, vec)`
`260`	`258`	`}`
`261`	`259`	`}`
`262`	`260`	`}`
`@@ -284,10 +282,10 @@ mod if_std {`
`284`	`282`	`Pin::get_mut(self).as_mut().poll_read(cx, buf)`
`285`	`283`	`}`
`286`	`284`
`287`		`- fn poll_vectored_read(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [&mut IoVec])`
	`285`	`+ fn poll_read_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [IoVecMut<'_>])`
`288`	`286`	`-> Poll<Result<usize>>`
`289`	`287`	`{`
`290`		`- Pin::get_mut(self).as_mut().poll_vectored_read(cx, vec)`
	`288`	`+ Pin::get_mut(self).as_mut().poll_read_vectored(cx, vec)`
`291`	`289`	`}`
`292`	`290`	`}`
`293`	`291`
`@@ -304,6 +302,12 @@ mod if_std {`
`304`	`302`	`{`
`305`	`303`	`Poll::Ready(StdIo::Read::read(&mut *self, buf))`
`306`	`304`	`}`
	`305`	`+`
	`306`	`+ fn poll_read_vectored(mut self: Pin<&mut Self>, _: &mut Context<'_>, vec: &mut [IoVecMut<'_>])`
	`307`	`+ -> Poll<Result<usize>>`
	`308`	`+ {`
	`309`	`+ Poll::Ready(StdIo::Read::read_vectored(&mut *self, vec))`
	`310`	`+ }`
`307`	`311`	`}`
`308`	`312`	`}`
`309`	`313`
`@@ -327,10 +331,10 @@ mod if_std {`
`327`	`331`	`Pin::new(&mut **self).poll_write(cx, buf)`
`328`	`332`	`}`
`329`	`333`
`330`		`- fn poll_vectored_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[&IoVec])`
	`334`	`+ fn poll_write_vectored(mut self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[IoVec<'_>])`
`331`	`335`	`-> Poll<Result<usize>>`
`332`	`336`	`{`
`333`		`- Pin::new(&mut **self).poll_vectored_write(cx, vec)`
	`337`	`+ Pin::new(&mut **self).poll_write_vectored(cx, vec)`
`334`	`338`	`}`
`335`	`339`
`336`	`340`	`fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {`
`@@ -362,10 +366,10 @@ mod if_std {`
`362`	`366`	`Pin::get_mut(self).as_mut().poll_write(cx, buf)`
`363`	`367`	`}`
`364`	`368`
`365`		`- fn poll_vectored_write(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[&IoVec])`
	`369`	`+ fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[IoVec<'_>])`
`366`	`370`	`-> Poll<Result<usize>>`
`367`	`371`	`{`
`368`		`- Pin::get_mut(self).as_mut().poll_vectored_write(cx, vec)`
	`372`	`+ Pin::get_mut(self).as_mut().poll_write_vectored(cx, vec)`
`369`	`373`	`}`
`370`	`374`
`371`	`375`	`fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {`
`@@ -385,6 +389,12 @@ mod if_std {`
`385`	`389`	`Poll::Ready(StdIo::Write::write(&mut *self, buf))`
`386`	`390`	`}`
`387`	`391`
	`392`	`+ fn poll_write_vectored(mut self: Pin<&mut Self>, _: &mut Context<'_>, vec: &[IoVec<'_>])`
	`393`	`+ -> Poll<Result<usize>>`
	`394`	`+ {`
	`395`	`+ Poll::Ready(StdIo::Write::write_vectored(&mut *self, vec))`
	`396`	`+ }`
	`397`	`+`
`388`	`398`	`fn poll_flush(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<()>> {`
`389`	`399`	`Poll::Ready(StdIo::Write::flush(&mut *self))`
`390`	`400`	`}`
`@@ -413,6 +423,12 @@ mod if_std {`
`413`	`423`	`Poll::Ready(result)`
`414`	`424`	`}`
`415`	`425`
	`426`	`+ fn poll_write_vectored(self: Pin<&mut Self>, _: &mut Context<'_>, vec: &[IoVec<'_>])`
	`427`	`+ -> Poll<Result<usize>>`
	`428`	`+ {`
	`429`	`+ Poll::Ready(StdIo::Write::write_vectored(&mut self.get_mut().get_mut().as_mut(), vec))`
	`430`	`+ }`
	`431`	`+`
`416`	`432`	`fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<()>> {`
`417`	`433`	`Poll::Ready(StdIo::Write::flush(&mut self.get_mut().get_mut().as_mut()))`
`418`	`434`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`use crate::lock::BiLock;`
`2`	`2`	`use futures_core::task::{Context, Poll};`
`3`		`-use futures_io::{AsyncRead, AsyncWrite, IoVec};`
	`3`	`+use futures_io::{AsyncRead, AsyncWrite, IoVec, IoVecMut};`
`4`	`4`	`use std::io;`
`5`	`5`	`use std::pin::Pin;`
`6`	`6`
`@@ -43,10 +43,10 @@ impl<R: AsyncRead> AsyncRead for ReadHalf<R> {`
`43`	`43`	`lock_and_then(&self.handle, cx, \|l, cx\| l.poll_read(cx, buf))`
`44`	`44`	`}`
`45`	`45`
`46`		`- fn poll_vectored_read(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [&mut IoVec])`
	`46`	`+ fn poll_read_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &mut [IoVecMut<'_>])`
`47`	`47`	`-> Poll<io::Result<usize>>`
`48`	`48`	`{`
`49`		`- lock_and_then(&self.handle, cx, \|l, cx\| l.poll_vectored_read(cx, vec))`
	`49`	`+ lock_and_then(&self.handle, cx, \|l, cx\| l.poll_read_vectored(cx, vec))`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`@@ -57,10 +57,10 @@ impl<W: AsyncWrite> AsyncWrite for WriteHalf<W> {`
`57`	`57`	`lock_and_then(&self.handle, cx, \|l, cx\| l.poll_write(cx, buf))`
`58`	`58`	`}`
`59`	`59`
`60`		`- fn poll_vectored_write(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[&IoVec])`
	`60`	`+ fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, vec: &[IoVec<'_>])`
`61`	`61`	`-> Poll<io::Result<usize>>`
`62`	`62`	`{`
`63`		`- lock_and_then(&self.handle, cx, \|l, cx\| l.poll_vectored_write(cx, vec))`
	`63`	`+ lock_and_then(&self.handle, cx, \|l, cx\| l.poll_write_vectored(cx, vec))`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {`