add a new Payload struct to allow for one-copy writes and cargo fmt

wisp/src/fastwebsockets.rs

@@ -3,93 +3,100 @@ use std::ops::Deref;
 use async_trait::async_trait;
 use bytes::BytesMut;
 use fastwebsockets::{
-    CloseCode, FragmentCollectorRead, Frame, OpCode, Payload, WebSocketError, WebSocketWrite,
+	CloseCode, FragmentCollectorRead, Frame, OpCode, Payload, WebSocketError, WebSocketWrite,
 };
 use tokio::io::{AsyncRead, AsyncWrite};
 
 use crate::{ws::LockedWebSocketWrite, WispError};
 
-fn match_payload(payload: Payload) -> BytesMut {
+fn match_payload<'a>(payload: Payload<'a>) -> crate::ws::Payload<'a> {
 	match payload {
-		Payload::Bytes(x) => x,
-		Payload::Owned(x) => BytesMut::from(x.deref()),
-		Payload::BorrowedMut(x) => BytesMut::from(x.deref()),
-		Payload::Borrowed(x) => BytesMut::from(x),
+		Payload::Bytes(x) => crate::ws::Payload::Bytes(x),
+		Payload::Owned(x) => crate::ws::Payload::Bytes(BytesMut::from(x.deref())),
+		Payload::BorrowedMut(x) => crate::ws::Payload::Borrowed(&*x),
+		Payload::Borrowed(x) => crate::ws::Payload::Borrowed(x),
+	}
+}
+
+fn match_payload_reverse<'a>(payload: crate::ws::Payload<'a>) -> Payload<'a> {
+	match payload {
+		crate::ws::Payload::Bytes(x) => Payload::Bytes(x),
+		crate::ws::Payload::Borrowed(x) => Payload::Borrowed(x),
 	}
 }
 
 impl From<OpCode> for crate::ws::OpCode {
-    fn from(opcode: OpCode) -> Self {
-        use OpCode::*;
-        match opcode {
-            Continuation => {
-                unreachable!("continuation should never be recieved when using a fragmentcollector")
-            }
-            Text => Self::Text,
-            Binary => Self::Binary,
-            Close => Self::Close,
-            Ping => Self::Ping,
-            Pong => Self::Pong,
-        }
-    }
+	fn from(opcode: OpCode) -> Self {
+		use OpCode::*;
+		match opcode {
+			Continuation => {
+				unreachable!("continuation should never be recieved when using a fragmentcollector")
+			}
+			Text => Self::Text,
+			Binary => Self::Binary,
+			Close => Self::Close,
+			Ping => Self::Ping,
+			Pong => Self::Pong,
+		}
+	}
 }
 
-impl From<Frame<'_>> for crate::ws::Frame {
-    fn from(frame: Frame) -> Self {
-        Self {
-            finished: frame.fin,
-            opcode: frame.opcode.into(),
-            payload: match_payload(frame.payload),
-        }
-    }
+impl<'a> From<Frame<'a>> for crate::ws::Frame<'a> {
+	fn from(frame: Frame<'a>) -> Self {
+		Self {
+			finished: frame.fin,
+			opcode: frame.opcode.into(),
+			payload: match_payload(frame.payload),
+		}
+	}
 }
 
-impl<'a> From<crate::ws::Frame> for Frame<'a> {
-    fn from(frame: crate::ws::Frame) -> Self {
-        use crate::ws::OpCode::*;
-        let payload = Payload::Bytes(frame.payload);
-        match frame.opcode {
-            Text => Self::text(payload),
-            Binary => Self::binary(payload),
-            Close => Self::close_raw(payload),
-            Ping => Self::new(true, OpCode::Ping, None, payload),
-            Pong => Self::pong(payload),
-        }
-    }
+impl<'a> From<crate::ws::Frame<'a>> for Frame<'a> {
+	fn from(frame: crate::ws::Frame<'a>) -> Self {
+		use crate::ws::OpCode::*;
+		let payload = match_payload_reverse(frame.payload);
+		match frame.opcode {
+			Text => Self::text(payload),
+			Binary => Self::binary(payload),
+			Close => Self::close_raw(payload),
+			Ping => Self::new(true, OpCode::Ping, None, payload),
+			Pong => Self::pong(payload),
+		}
+	}
 }
 
 impl From<WebSocketError> for crate::WispError {
-    fn from(err: WebSocketError) -> Self {
-        if let WebSocketError::ConnectionClosed = err {
-            Self::WsImplSocketClosed
-        } else {
-            Self::WsImplError(Box::new(err))
-        }
-    }
+	fn from(err: WebSocketError) -> Self {
+		if let WebSocketError::ConnectionClosed = err {
+			Self::WsImplSocketClosed
+		} else {
+			Self::WsImplError(Box::new(err))
+		}
+	}
 }
 
 #[async_trait]
 impl<S: AsyncRead + Unpin + Send> crate::ws::WebSocketRead for FragmentCollectorRead<S> {
-    async fn wisp_read_frame(
-        &mut self,
-        tx: &LockedWebSocketWrite,
-    ) -> Result<crate::ws::Frame, WispError> {
-        Ok(self
-            .read_frame(&mut |frame| async { tx.write_frame(frame.into()).await })
-            .await?
-            .into())
-    }
+	async fn wisp_read_frame(
+		&mut self,
+		tx: &LockedWebSocketWrite,
+	) -> Result<crate::ws::Frame<'static>, WispError> {
+		Ok(self
+			.read_frame(&mut |frame| async { tx.write_frame(frame.into()).await })
+			.await?
+			.into())
+	}
 }
 
 #[async_trait]
 impl<S: AsyncWrite + Unpin + Send> crate::ws::WebSocketWrite for WebSocketWrite<S> {
-    async fn wisp_write_frame(&mut self, frame: crate::ws::Frame) -> Result<(), WispError> {
-        self.write_frame(frame.into()).await.map_err(|e| e.into())
-    }
+	async fn wisp_write_frame(&mut self, frame: crate::ws::Frame<'_>) -> Result<(), WispError> {
+		self.write_frame(frame.into()).await.map_err(|e| e.into())
+	}
 
-    async fn wisp_close(&mut self) -> Result<(), WispError> {
-        self.write_frame(Frame::close(CloseCode::Normal.into(), b""))
-            .await
-            .map_err(|e| e.into())
-    }
+	async fn wisp_close(&mut self) -> Result<(), WispError> {
+		self.write_frame(Frame::close(CloseCode::Normal.into(), b""))
+			.await
+			.map_err(|e| e.into())
+	}
 }