Let receive be a method, rather than a constructor function

ivmarkov · Oct 10, 2024 · 8079ce4 · 8079ce4
1 parent d42c63f
commit 8079ce4
Show file tree

Hide file tree

Showing 4 changed files with 47 additions and 33 deletions.
diff --git a/edge-http/src/io.rs b/edge-http/src/io.rs
@@ -100,10 +100,11 @@ impl<E> std::error::Error for Error<E> where E: std::error::Error {}
 impl<'b, const N: usize> RequestHeaders<'b, N> {
     /// Parse the headers from the input stream
     pub async fn receive<R>(
+        &mut self,
         buf: &'b mut [u8],
         mut input: R,
         exact: bool,
-    ) -> Result<(Self, &'b mut [u8], usize), Error<R::Error>>
+    ) -> Result<(&'b mut [u8], usize), Error<R::Error>>
     where
         R: Read,
     {
@@ -113,8 +114,7 @@ impl<'b, const N: usize> RequestHeaders<'b, N> {
                 Err(e) => return Err(e),
             };
 
-        let mut headers = Headers::<'b, N>::new();
-        let mut parser = httparse::Request::new(&mut headers.0);
+        let mut parser = httparse::Request::new(&mut self.headers.0);
 
         let (headers_buf, body_buf) = buf.split_at_mut(headers_len);
 
@@ -128,26 +128,19 @@ impl<'b, const N: usize> RequestHeaders<'b, N> {
                 unreachable!("Should not happen. HTTP header parsing is indeterminate.")
             }
 
-            let http11 = match parser.version {
+            self.http11 = match parser.version {
                 Some(0) => false,
                 Some(1) => true,
                 _ => Err(Error::InvalidHeaders)?,
             };
 
             let method_str = parser.method.ok_or(Error::InvalidHeaders)?;
-            let method = Method::new(method_str).ok_or(Error::InvalidHeaders)?;
-            let path = parser.path.ok_or(Error::InvalidHeaders)?;
-
-            let result = Self {
-                http11,
-                method,
-                path,
-                headers,
-            };
+            self.method = Method::new(method_str).ok_or(Error::InvalidHeaders)?;
+            self.path = parser.path.ok_or(Error::InvalidHeaders)?;
 
-            trace!("Received:\n{}", result);
+            trace!("Received:\n{}", self);
 
-            Ok((result, body_buf, read_len - headers_len))
+            Ok((body_buf, read_len - headers_len))
         } else {
             unreachable!("Secondary parse of already loaded buffer failed.")
         }
@@ -178,18 +171,18 @@ impl<'b, const N: usize> RequestHeaders<'b, N> {
 impl<'b, const N: usize> ResponseHeaders<'b, N> {
     /// Parse the headers from the input stream
     pub async fn receive<R>(
+        &mut self,
         buf: &'b mut [u8],
         mut input: R,
         exact: bool,
-    ) -> Result<(Self, &'b mut [u8], usize), Error<R::Error>>
+    ) -> Result<(&'b mut [u8], usize), Error<R::Error>>
     where
         R: Read,
     {
         let (read_len, headers_len) =
             raw::read_reply_buf::<N, _>(&mut input, buf, false, exact).await?;
 
-        let mut headers = Headers::<'b, N>::new();
-        let mut parser = httparse::Response::new(&mut headers.0);
+        let mut parser = httparse::Response::new(&mut self.headers.0);
 
         let (headers_buf, body_buf) = buf.split_at_mut(headers_len);
 
@@ -200,25 +193,18 @@ impl<'b, const N: usize> ResponseHeaders<'b, N> {
                 unreachable!("Should not happen. HTTP header parsing is indeterminate.")
             }
 
-            let http11 = match parser.version {
+            self.http11 = match parser.version {
                 Some(0) => false,
                 Some(1) => true,
                 _ => Err(Error::InvalidHeaders)?,
             };
 
-            let code = parser.code.ok_or(Error::InvalidHeaders)?;
-            let reason = parser.reason;
-
-            let result = Self {
-                http11,
-                code,
-                reason,
-                headers,
-            };
+            self.code = parser.code.ok_or(Error::InvalidHeaders)?;
+            self.reason = parser.reason;
 
-            trace!("Received:\n{}", result);
+            trace!("Received:\n{}", self);
 
-            Ok((result, body_buf, read_len - headers_len))
+            Ok((body_buf, read_len - headers_len))
         } else {
             unreachable!("Secondary parse of already loaded buffer failed.")
         }

diff --git a/edge-http/src/io/client.rs b/edge-http/src/io/client.rs
@@ -262,9 +262,13 @@ where
 
         let mut state = self.unbind();
         let buf_ptr: *mut [u8] = state.buf;
+        let mut response = ResponseHeaders::default();
 
-        match ResponseHeaders::receive(state.buf, &mut state.io.as_mut().unwrap(), true).await {
-            Ok((response, buf, read_len)) => {
+        match response
+            .receive(state.buf, &mut state.io.as_mut().unwrap(), true)
+            .await
+        {
+            Ok((buf, read_len)) => {
                 let (connection_type, body_type) =
                     response.resolve::<T::Error>(request_connection_type)?;
 

diff --git a/edge-http/src/io/server.rs b/edge-http/src/io/server.rs
@@ -52,7 +52,9 @@ where
         buf: &'b mut [u8],
         mut io: T,
     ) -> Result<Connection<'b, T, N>, Error<T::Error>> {
-        let (request, buf, read_len) = RequestHeaders::receive(buf, &mut io, true).await?;
+        let mut request = RequestHeaders::default();
+
+        let (buf, read_len) = request.receive(buf, &mut io, true).await?;
 
         let (connection_type, body_type) = request.resolve::<T::Error>()?;
 

diff --git a/edge-http/src/lib.rs b/edge-http/src/lib.rs
@@ -723,6 +723,17 @@ impl<const N: usize> RequestHeaders<'_, N> {
     }
 }
 
+impl<'b, const N: usize> Default for RequestHeaders<'b, N> {
+    fn default() -> Self {
+        Self {
+            http11: true,
+            method: Method::Get,
+            path: "/",
+            headers: Headers::new(),
+        }
+    }
+}
+
 impl<const N: usize> Display for RequestHeaders<'_, N> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{} ", if self.http11 { "HTTP/1.1" } else { "HTTP/1.0" })?;
@@ -766,6 +777,17 @@ impl<const N: usize> ResponseHeaders<'_, N> {
     }
 }
 
+impl<'b, const N: usize> Default for ResponseHeaders<'b, N> {
+    fn default() -> Self {
+        Self {
+            http11: true,
+            code: 200,
+            reason: None,
+            headers: Headers::new(),
+        }
+    }
+}
+
 impl<const N: usize> Display for ResponseHeaders<'_, N> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{} ", if self.http11 { "HTTP/1.1 " } else { "HTTP/1.0" })?;