Implement Read, Write, and Seek for &File, &TcpSocket, etc.

`std` provides these impls, so `cap_std` should too.

Author: sunfishcode

cap-async-std/src/fs/file.rs

@@ -198,6 +198,30 @@ impl Read for File {
     // async_std doesn't have `initializer`.
 }
 
+impl Read for &File {
+    #[inline]
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        Read::poll_read(Pin::new(&mut &self.std), cx, buf)
+    }
+
+    #[inline]
+    fn poll_read_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        bufs: &mut [IoSliceMut],
+    ) -> Poll<io::Result<usize>> {
+        Read::poll_read_vectored(Pin::new(&mut &self.std), cx, bufs)
+    }
+
+    // async_std doesn't have `is_read_vectored`.
+
+    // async_std doesn't have `initializer`.
+}
+
 impl Write for File {
     #[inline]
     fn poll_write(
@@ -232,6 +256,36 @@ impl Write for File {
     // async_std doesn't have `write_all_vectored`.
 }
 
+impl Write for &File {
+    #[inline]
+    fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<io::Result<usize>> {
+        Write::poll_write(Pin::new(&mut &self.std), cx, buf)
+    }
+
+    #[inline]
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        Write::poll_flush(Pin::new(&mut &self.std), cx)
+    }
+
+    #[inline]
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        Write::poll_close(Pin::new(&mut &self.std), cx)
+    }
+
+    #[inline]
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        bufs: &[IoSlice],
+    ) -> Poll<io::Result<usize>> {
+        Write::poll_write_vectored(Pin::new(&mut &self.std), cx, bufs)
+    }
+
+    // async_std doesn't have `is_write_vectored`.
+
+    // async_std doesn't have `write_all_vectored`.
+}
+
 impl Seek for File {
     #[inline]
     fn poll_seek(
@@ -247,6 +301,17 @@ impl Seek for File {
     // async_std doesn't have `seek_convenience`.
 }
 
+impl Seek for &File {
+    #[inline]
+    fn poll_seek(self: Pin<&mut Self>, cx: &mut Context, pos: SeekFrom) -> Poll<io::Result<u64>> {
+        Seek::poll_seek(Pin::new(&mut &self.std), cx, pos)
+    }
+
+    // async_std doesn't have `stream_len`.
+
+    // async_std doesn't have `seek_convenience`.
+}
+
 // TODO: Can async_std implement `From<File>` for `process::Stdio`?
 
 // async_std doesn't have `FileExt`.

cap-async-std/src/fs_utf8/file.rs

@@ -170,6 +170,30 @@ impl Read for File {
     // async_std doesn't have `initializer`.
 }
 
+impl Read for &File {
+    #[inline]
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        Read::poll_read(Pin::new(&mut &self.cap_std), cx, buf)
+    }
+
+    #[inline]
+    fn poll_read_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        bufs: &mut [IoSliceMut],
+    ) -> Poll<io::Result<usize>> {
+        Read::poll_read_vectored(Pin::new(&mut &self.cap_std), cx, bufs)
+    }
+
+    // async_std doesn't have `is_read_vectored`.
+
+    // async_std doesn't have `initializer`.
+}
+
 impl Write for File {
     #[inline]
     fn poll_write(
@@ -204,6 +228,36 @@ impl Write for File {
     // async_std doesn't have `write_all_vectored`.
 }
 
+impl Write for &File {
+    #[inline]
+    fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<io::Result<usize>> {
+        Write::poll_write(Pin::new(&mut &self.cap_std), cx, buf)
+    }
+
+    #[inline]
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        Write::poll_flush(Pin::new(&mut &self.cap_std), cx)
+    }
+
+    #[inline]
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        Write::poll_close(Pin::new(&mut &self.cap_std), cx)
+    }
+
+    #[inline]
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        bufs: &[IoSlice],
+    ) -> Poll<io::Result<usize>> {
+        Write::poll_write_vectored(Pin::new(&mut &self.cap_std), cx, bufs)
+    }
+
+    // async_std doesn't have `can_vector`.
+
+    // async_std doesn't have `write_all_vectored`.
+}
+
 impl Seek for File {
     #[inline]
     fn poll_seek(
@@ -219,6 +273,17 @@ impl Seek for File {
     // async_std doesn't have `stream_position`.
 }
 
+impl Seek for &File {
+    #[inline]
+    fn poll_seek(self: Pin<&mut Self>, cx: &mut Context, pos: SeekFrom) -> Poll<io::Result<u64>> {
+        Seek::poll_seek(Pin::new(&mut &self.cap_std), cx, pos)
+    }
+
+    // async_std doesn't have `stream_len`.
+
+    // async_std doesn't have `stream_position`.
+}
+
 // TODO: Can async_std implement `From<File>` for `process::Stdio`?
 
 // async_std doesn't have `FileExt`.

cap-async-std/src/net/tcp_stream.rs

@@ -190,6 +190,30 @@ impl Read for TcpStream {
     // async_std doesn't have `initializer`.
 }
 
+impl Read for &TcpStream {
+    #[inline]
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        Read::poll_read(Pin::new(&mut &self.std), cx, buf)
+    }
+
+    #[inline]
+    fn poll_read_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        bufs: &mut [IoSliceMut],
+    ) -> Poll<io::Result<usize>> {
+        Read::poll_read_vectored(Pin::new(&mut &self.std), cx, bufs)
+    }
+
+    // async_std doesn't have `is_read_vectored`.
+
+    // async_std doesn't have `initializer`.
+}
+
 impl Write for TcpStream {
     #[inline]
     fn poll_write(
@@ -224,4 +248,34 @@ impl Write for TcpStream {
     // async_std doesn't have `write_all_vectored`.
 }
 
+impl Write for &TcpStream {
+    #[inline]
+    fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<io::Result<usize>> {
+        Write::poll_write(Pin::new(&mut &self.std), cx, buf)
+    }
+
+    #[inline]
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        Write::poll_flush(Pin::new(&mut &self.std), cx)
+    }
+
+    #[inline]
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        Write::poll_close(Pin::new(&mut &self.std), cx)
+    }
+
+    #[inline]
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        bufs: &[IoSlice],
+    ) -> Poll<io::Result<usize>> {
+        Write::poll_write_vectored(Pin::new(&mut &self.std), cx, bufs)
+    }
+
+    // async_std doesn't have `is_write_vectored`.
+
+    // async_std doesn't have `write_all_vectored`.
+}
+
 // TODO: impl Debug for TcpStream

cap-async-std/src/os/unix/net/unix_stream.rs

@@ -133,6 +133,30 @@ impl Read for UnixStream {
     // async_std doesn't have `initializer`.
 }
 
+impl Read for &UnixStream {
+    #[inline]
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        Read::poll_read(Pin::new(&mut &self.std), cx, buf)
+    }
+
+    #[inline]
+    fn poll_read_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        bufs: &mut [IoSliceMut],
+    ) -> Poll<io::Result<usize>> {
+        Read::poll_read_vectored(Pin::new(&mut &self.std), cx, bufs)
+    }
+
+    // async_std doesn't have `is_read_vectored`.
+
+    // async_std doesn't have `initializer`.
+}
+
 impl Write for UnixStream {
     #[inline]
     fn poll_write(
@@ -167,4 +191,34 @@ impl Write for UnixStream {
     // async_std doesn't have `write_all_vectored`.
 }
 
+impl Write for &UnixStream {
+    #[inline]
+    fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<io::Result<usize>> {
+        Write::poll_write(Pin::new(&mut &self.std), cx, buf)
+    }
+
+    #[inline]
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        Write::poll_flush(Pin::new(&mut &self.std), cx)
+    }
+
+    #[inline]
+    fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
+        Write::poll_close(Pin::new(&mut &self.std), cx)
+    }
+
+    #[inline]
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+        bufs: &[IoSlice],
+    ) -> Poll<io::Result<usize>> {
+        Write::poll_write_vectored(Pin::new(&mut &self.std), cx, bufs)
+    }
+
+    // async_std doesn't have `is_write_vectored`.
+
+    // async_std doesn't have `write_all_vectored`.
+}
+
 // TODO: impl Debug for UnixStream