Impl std Read, Write for tcpstream

examples/echo.rs

@@ -61,7 +61,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
                 if readiness.is_read() {
                     while let Some(buf) = ring_buf.for_reading() {
-                        match polldance::io::try_read(stream.as_ref(), buf)? {
+                        match stream.try_read(buf)? {
                             Nonblocking::Ready(ReadBytes::Read(n)) => {
                                 let n: usize = n.into();
                                 let should_break = n < buf.len();
@@ -83,7 +83,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
                 if readiness.is_write() {
                     while let Some(buf) = ring_buf.for_writing() {
-                        match polldance::io::try_write(stream.as_ref(), buf)? {
+                        match stream.try_write(buf)? {
                             Nonblocking::Ready(n) => {
                                 ring_buf.advance_write(n);
                                 if ring_buf.is_empty() {

src/net.rs

@@ -1,4 +1,6 @@
-use crate::io::{in_progress, nonblocking, InProgress, Nonblocking};
+use crate::io::{
+    in_progress, nonblocking, try_read, try_write, InProgress, Nonblocking, ReadBytes,
+};
 use rustix::{
     fd::AsFd,
     io::OwnedFd,
@@ -78,6 +80,14 @@ impl TcpStream {
             inner: sock,
         })
     }
+
+    pub fn try_write(&self, buf: &[u8]) -> crate::io::Result<Nonblocking<usize>> {
+        try_write(self, buf)
+    }
+
+    pub fn try_read(&self, buf: &mut [u8]) -> crate::io::Result<Nonblocking<ReadBytes>> {
+        try_read(self, buf)
+    }
 }
 
 impl TcpListenerBuilder {
@@ -111,6 +121,30 @@ impl TcpStreamBuilder {
     }
 }
 
+impl std::io::Read for TcpStream {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        match self.try_read(buf) {
+            Ok(Nonblocking::Ready(size)) => Ok(size.into()),
+            Ok(Nonblocking::WouldBlock) => Err(std::io::ErrorKind::WouldBlock.into()),
+            Err(e) => Err(e.into()),
+        }
+    }
+}
+
+impl std::io::Write for TcpStream {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        match self.try_write(buf) {
+            Ok(Nonblocking::Ready(size)) => Ok(size),
+            Ok(Nonblocking::WouldBlock) => Err(std::io::ErrorKind::WouldBlock.into()),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}
+
 impl AsFd for TcpStream {
     fn as_fd(&self) -> rustix::fd::BorrowedFd<'_> {
         self.inner.as_fd()