remove async framework dependencies, add example compat converter to each async example

Author: stevefan1999-personal

Cargo.toml

@@ -11,20 +11,16 @@ categories = ["embedded", "no-std", "network-programming"]
 readme = "README.md"
 
 [dependencies]
-async-std = { version = "1.12.0", optional = true }
 async-trait = { version = "0.1.56", optional = true }
 base64 = { version = "0.13.0", default-features = false }
 base64-simd = { version = "0.5.0", default-features = false, optional = true }
 byteorder = { version = "1.4.3", default-features = false }
 cfg-if = "1.0.0"
 core2 = "0.4.0"
-futures = { version = "0.3.21", optional = true }
 heapless = "0.7.14"
 httparse = { version = "1.7.1", default-features = false }
 rand_core = "0.6.3"
 sha1 = "0.10.1"
-smol = { version = "1.2.5", optional = true }
-tokio = { version = "1.19.2", features = ["io-util"], optional = true }
 
 [dev-dependencies]
 async-std = { version = "1.12.0", features = ["attributes"] }
@@ -44,37 +40,36 @@ default = ["std"]
 # default = []
 std = []
 async = ["std", "async-trait"]
-tokio = ["dep:tokio", "async"]
-futures = ["dep:futures", "async"]
-smol = ["dep:smol", "async"]
-async-std = ["dep:async-std", "async"]
+example-tokio = ["async"]
+example-smol = ["async"]
+example-async-std = ["async"]
 
 [[example]]
 name = "server_tokio"
 path = "examples/server_async/main.rs"
-required-features = ["tokio"]
+required-features = ["example-tokio"]
 
 [[example]]
 name = "server_smol"
 path = "examples/server_async/main.rs"
-required-features = ["smol"]
+required-features = ["example-smol"]
 
 [[example]]
 name = "server_async_std"
 path = "examples/server_async/main.rs"
-required-features = ["async-std"]
+required-features = ["example-async-std"]
 
 [[example]]
 name = "client_tokio"
 path = "examples/client_async/main.rs"
-required-features = ["tokio"]
+required-features = ["example-tokio"]
 
 [[example]]
 name = "client_smol"
 path = "examples/client_async/main.rs"
-required-features = ["smol"]
+required-features = ["example-smol"]
 
 [[example]]
 name = "client_async_std"
 path = "examples/client_async/main.rs"
-required-features = ["async-std"]
+required-features = ["example-async-std"]

examples/client_async/compat.rs

@@ -0,0 +1,110 @@
+#![allow(dead_code)]
+
+// This is an example implementation of compatibility extension, gladly stolen from futures_lite
+// As this is far from being any useful, please do extend this on your own
+pub trait CompatExt {
+    fn compat(self) -> Compat<Self>
+    where
+        Self: Sized;
+    fn compat_ref(&self) -> Compat<&Self>;
+    fn compat_mut(&mut self) -> Compat<&mut Self>;
+}
+
+impl<T> CompatExt for T {
+    fn compat(self) -> Compat<Self>
+    where
+        Self: Sized,
+    {
+        Compat(self)
+    }
+
+    fn compat_ref(&self) -> Compat<&Self> {
+        Compat(self)
+    }
+
+    fn compat_mut(&mut self) -> Compat<&mut Self> {
+        Compat(self)
+    }
+}
+
+pub struct Compat<T>(T);
+
+impl<T> Compat<T> {
+    pub fn get_ref(&self) -> &T {
+        &self.0
+    }
+
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+#[cfg(feature = "example-tokio")]
+pub mod tokio_compat {
+    use super::Compat;
+    use async_trait::async_trait;
+    use embedded_websocket::compat::{AsyncRead, AsyncWrite};
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    #[async_trait]
+    impl<T: tokio::io::AsyncRead + Unpin + Send + Sync> AsyncRead<std::io::Error> for Compat<T> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
+            AsyncReadExt::read(self.get_mut(), buf).await
+        }
+    }
+
+    #[async_trait]
+    impl<T: tokio::io::AsyncWrite + Unpin + Send + Sync> AsyncWrite<std::io::Error> for Compat<T> {
+        async fn write_all(&mut self, buf: &[u8]) -> Result<(), std::io::Error> {
+            AsyncWriteExt::write_all(self.get_mut(), buf).await
+        }
+    }
+}
+
+#[cfg(feature = "example-smol")]
+pub mod smol_compat {
+    use super::Compat;
+    use async_trait::async_trait;
+    use embedded_websocket::compat::{AsyncRead, AsyncWrite};
+    use smol::io::{AsyncReadExt, AsyncWriteExt};
+
+    #[async_trait]
+    impl<T: smol::io::AsyncRead + Unpin + Send + Sync> AsyncRead<std::io::Error> for Compat<T> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
+            AsyncReadExt::read(self.get_mut(), buf).await
+        }
+    }
+
+    #[async_trait]
+    impl<T: smol::io::AsyncWrite + Unpin + Send + Sync> AsyncWrite<std::io::Error> for Compat<T> {
+        async fn write_all(&mut self, buf: &[u8]) -> Result<(), std::io::Error> {
+            AsyncWriteExt::write_all(self.get_mut(), buf).await
+        }
+    }
+}
+
+#[cfg(feature = "example-async-std")]
+pub mod async_std_compat {
+    use super::Compat;
+    use async_std::io::{ReadExt, WriteExt};
+    use async_trait::async_trait;
+    use embedded_websocket::compat::{AsyncRead, AsyncWrite};
+
+    #[async_trait]
+    impl<T: async_std::io::Read + Unpin + Send + Sync> AsyncRead<std::io::Error> for Compat<T> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
+            ReadExt::read(self.get_mut(), buf).await
+        }
+    }
+
+    #[async_trait]
+    impl<T: async_std::io::Write + Unpin + Send + Sync> AsyncWrite<std::io::Error> for Compat<T> {
+        async fn write_all(&mut self, buf: &[u8]) -> Result<(), std::io::Error> {
+            WriteExt::write_all(self.get_mut(), buf).await
+        }
+    }
+}

examples/client_async/main.rs

@@ -9,25 +9,28 @@
 // Note that we are using the standard library in the demo and making use of the framer helper module
 // but the websocket library remains no_std (see client_full for an example without the framer helper module)
 
+mod compat;
+
+use crate::compat::CompatExt;
 use embedded_websocket::{
     framer::{Framer, FramerError, ReadResult},
     WebSocketClient, WebSocketCloseStatusCode, WebSocketOptions, WebSocketSendMessageType,
 };
 use std::error::Error;
 
 cfg_if::cfg_if! {
-    if #[cfg(feature = "tokio")] {
+    if #[cfg(feature = "example-tokio")] {
         use tokio::net::TcpStream;
-    } else if #[cfg(feature = "smol")] {
+    } else if #[cfg(feature = "example-smol")] {
         use smol::net::TcpStream;
-    } else if #[cfg(feature = "async-std")] {
+    } else if #[cfg(feature = "example-async-std")] {
         use async_std::net::TcpStream;
     }
 }
 
-#[cfg_attr(feature = "async-std", async_std::main)]
-#[cfg_attr(feature = "tokio", tokio::main)]
-#[cfg_attr(feature = "smol", smol_potat::main)]
+#[cfg_attr(feature = "example-async-std", async_std::main)]
+#[cfg_attr(feature = "example-tokio", tokio::main)]
+#[cfg_attr(feature = "example-smol", smol_potat::main)]
 async fn main() -> Result<(), FramerError<impl Error>> {
     // open a TCP stream to localhost port 1337
     let address = "127.0.0.1:1337";
@@ -56,6 +59,8 @@ async fn main() -> Result<(), FramerError<impl Error>> {
         &mut write_buf,
         &mut websocket,
     );
+    let mut stream = stream.compat_mut();
+
     framer
         .connect_async(&mut stream, &websocket_options)
         .await?;

examples/server_async/compat.rs

@@ -0,0 +1,110 @@
+#![allow(dead_code)]
+
+// This is an example implementation of compatibility extension, gladly stolen from futures_lite
+// As this is far from being any useful, please do extend this on your own
+pub trait CompatExt {
+    fn compat(self) -> Compat<Self>
+        where
+            Self: Sized;
+    fn compat_ref(&self) -> Compat<&Self>;
+    fn compat_mut(&mut self) -> Compat<&mut Self>;
+}
+
+impl<T> CompatExt for T {
+    fn compat(self) -> Compat<Self>
+        where
+            Self: Sized,
+    {
+        Compat(self)
+    }
+
+    fn compat_ref(&self) -> Compat<&Self> {
+        Compat(self)
+    }
+
+    fn compat_mut(&mut self) -> Compat<&mut Self> {
+        Compat(self)
+    }
+}
+
+pub struct Compat<T>(T);
+
+impl<T> Compat<T> {
+    pub fn get_ref(&self) -> &T {
+        &self.0
+    }
+
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+#[cfg(feature = "example-tokio")]
+pub mod tokio_compat {
+    use super::Compat;
+    use async_trait::async_trait;
+    use embedded_websocket::compat::{AsyncRead, AsyncWrite};
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    #[async_trait]
+    impl<T: tokio::io::AsyncRead + Unpin + Send + Sync> AsyncRead<std::io::Error> for Compat<T> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
+            AsyncReadExt::read(self.get_mut(), buf).await
+        }
+    }
+
+    #[async_trait]
+    impl<T: tokio::io::AsyncWrite + Unpin + Send + Sync> AsyncWrite<std::io::Error> for Compat<T> {
+        async fn write_all(&mut self, buf: &[u8]) -> Result<(), std::io::Error> {
+            AsyncWriteExt::write_all(self.get_mut(), buf).await
+        }
+    }
+}
+
+#[cfg(feature = "example-smol")]
+pub mod smol_compat {
+    use super::Compat;
+    use async_trait::async_trait;
+    use embedded_websocket::compat::{AsyncRead, AsyncWrite};
+    use smol::io::{AsyncReadExt, AsyncWriteExt};
+
+    #[async_trait]
+    impl<T: smol::io::AsyncRead + Unpin + Send + Sync> AsyncRead<std::io::Error> for Compat<T> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
+            AsyncReadExt::read(self.get_mut(), buf).await
+        }
+    }
+
+    #[async_trait]
+    impl<T: smol::io::AsyncWrite + Unpin + Send + Sync> AsyncWrite<std::io::Error> for Compat<T> {
+        async fn write_all(&mut self, buf: &[u8]) -> Result<(), std::io::Error> {
+            AsyncWriteExt::write_all(self.get_mut(), buf).await
+        }
+    }
+}
+
+#[cfg(feature = "example-async-std")]
+pub mod async_std_compat {
+    use super::Compat;
+    use async_std::io::{ReadExt, WriteExt};
+    use async_trait::async_trait;
+    use embedded_websocket::compat::{AsyncRead, AsyncWrite};
+
+    #[async_trait]
+    impl<T: async_std::io::Read + Unpin + Send + Sync> AsyncRead<std::io::Error> for Compat<T> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
+            ReadExt::read(self.get_mut(), buf).await
+        }
+    }
+
+    #[async_trait]
+    impl<T: async_std::io::Write + Unpin + Send + Sync> AsyncWrite<std::io::Error> for Compat<T> {
+        async fn write_all(&mut self, buf: &[u8]) -> Result<(), std::io::Error> {
+            WriteExt::write_all(self.get_mut(), buf).await
+        }
+    }
+}