Pass through AsyncRead and AsyncWrite

Author: link2xt

src/tokio/bufread/generic/decoder.rs

@@ -2,12 +2,12 @@ use core::{
     pin::Pin,
     task::{Context, Poll},
 };
-use std::io::Result;
+use std::io::{IoSlice, Result};
 
 use crate::{codec::Decode, util::PartialBuffer};
 use futures_core::ready;
 use pin_project_lite::pin_project;
-use tokio::io::{AsyncBufRead, AsyncRead, ReadBuf};
+use tokio::io::{AsyncBufRead, AsyncRead, AsyncWrite, ReadBuf};
 
 #[derive(Debug)]
 enum State {
@@ -162,3 +162,33 @@ impl<R: AsyncBufRead, D: Decode> AsyncRead for Decoder<R, D> {
         }
     }
 }
+
+impl<R: AsyncBufRead + AsyncWrite, D: Decode> AsyncWrite for Decoder<R, D> {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize>> {
+        self.get_pin_mut().poll_write(cx, buf)
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        mut bufs: &[IoSlice<'_>],
+    ) -> Poll<Result<usize>> {
+        self.get_pin_mut().poll_write_vectored(cx, bufs)
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        self.get_ref().is_write_vectored()
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
+        self.get_pin_mut().poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
+        self.get_pin_mut().poll_shutdown(cx)
+    }
+}

src/tokio/bufread/macros/decoder.rs

@@ -72,6 +72,30 @@ macro_rules! decoder {
             }
         }
 
+        impl<$inner: tokio::io::AsyncBufRead + tokio::io::AsyncWrite> tokio::io::AsyncWrite for $name<$inner> {
+            fn poll_write(
+                self: std::pin::Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+                buf: &[u8],
+            ) -> std::task::Poll<std::io::Result<usize>> {
+                self.project().inner.poll_write(cx, buf)
+            }
+
+            fn poll_flush(
+                self: std::pin::Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+            ) -> std::task::Poll<std::io::Result<()>> {
+                self.project().inner.poll_flush(cx)
+            }
+
+            fn poll_shutdown(
+                self: std::pin::Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+            ) -> std::task::Poll<std::io::Result<()>> {
+                self.project().inner.poll_shutdown(cx)
+            }
+        }
+
         const _: () = {
             fn _assert() {
                 use crate::util::{_assert_send, _assert_sync};

src/tokio/write/generic/encoder.rs

@@ -11,7 +11,7 @@ use crate::{
 };
 use futures_core::ready;
 use pin_project_lite::pin_project;
-use tokio::io::AsyncWrite;
+use tokio::io::{AsyncWrite, AsyncRead, ReadBuf};
 
 #[derive(Debug)]
 enum State {
@@ -179,3 +179,13 @@ impl<W: AsyncWrite, E: Encode> AsyncWrite for Encoder<W, E> {
         Poll::Ready(Ok(()))
     }
 }
+
+impl<W: AsyncWrite + AsyncRead, E: Encode> AsyncRead for Encoder<W, E> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        self.get_pin_mut().poll_read(cx, buf)
+    }
+}

src/tokio/write/macros/encoder.rs

@@ -76,6 +76,16 @@ macro_rules! encoder {
             }
         }
 
+        impl<$inner: tokio::io::AsyncWrite + tokio::io::AsyncRead> tokio::io::AsyncRead for $name<$inner> {
+            fn poll_read(
+                self: std::pin::Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+                buf: &mut tokio::io::ReadBuf<'_>,
+            ) -> std::task::Poll<std::io::Result<()>> {
+                self.project().inner.poll_read(cx, buf)
+            }
+        }
+
         const _: () = {
             fn _assert() {
                 use crate::util::{_assert_send, _assert_sync};