rename methods again

Author: yoshuawuyts

src/chunked/encoder.rs

@@ -72,20 +72,20 @@ impl ChunkedEncoder {
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
         self.bytes_written = 0;
-        let res = self.dispatch(res, cx, buf);
+        let res = self.run(res, cx, buf);
         log::trace!("ChunkedEncoder {} bytes written", self.bytes_written);
         res
     }
 
     /// Execute the right method for the current state.
-    fn dispatch(
+    fn run(
         &mut self,
         res: &mut Response,
         cx: &mut Context<'_>,
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
         match self.state {
-            State::Start => self.set_state(State::EncodeChunks, res, cx, buf),
+            State::Start => self.dispatch(State::EncodeChunks, res, cx, buf),
             State::EncodeChunks => self.encode_chunks(res, cx, buf),
             State::EndOfChunks => self.encode_chunks_eos(res, cx, buf),
             State::ReceiveTrailers => self.receive_trailers(res, cx, buf),
@@ -96,7 +96,7 @@ impl ChunkedEncoder {
     }
 
     /// Switch the internal state to a new state.
-    fn set_state(
+    fn dispatch(
         &mut self,
         state: State,
         res: &mut Response,
@@ -118,7 +118,7 @@ impl ChunkedEncoder {
         }
 
         self.state = state;
-        self.dispatch(res, cx, buf)
+        self.run(res, cx, buf)
     }
 
     /// Stream out data using chunked encoding.
@@ -142,7 +142,7 @@ impl ChunkedEncoder {
         // If the stream doesn't have any more bytes left to read we're done
         // sending chunks and it's time to move on.
         if src.len() == 0 {
-            return self.set_state(State::EndOfChunks, res, cx, buf);
+            return self.dispatch(State::EndOfChunks, res, cx, buf);
         }
 
         // Each chunk is prefixed with the length of the data in hex, then a
@@ -209,7 +209,7 @@ impl ChunkedEncoder {
         buf[idx + 2] = LF;
         self.bytes_written += 1 + CRLF_LEN;
 
-        self.set_state(State::ReceiveTrailers, res, cx, buf)
+        self.dispatch(State::ReceiveTrailers, res, cx, buf)
     }
 
     /// Receive trailers sent to the response, and store them in an internal
@@ -221,7 +221,7 @@ impl ChunkedEncoder {
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
         // TODO: actually wait for trailers to be received.
-        self.set_state(State::EncodeTrailers, res, cx, buf)
+        self.dispatch(State::EncodeTrailers, res, cx, buf)
     }
 
     /// Send trailers to the buffer.
@@ -232,7 +232,7 @@ impl ChunkedEncoder {
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
         // TODO: actually encode trailers here.
-        self.set_state(State::EndOfStream, res, cx, buf)
+        self.dispatch(State::EndOfStream, res, cx, buf)
     }
 
     /// Encode the end of the stream.
@@ -247,6 +247,6 @@ impl ChunkedEncoder {
         buf[idx] = CR;
         buf[idx + 1] = LF;
         self.bytes_written += CRLF_LEN;
-        self.set_state(State::End, res, cx, buf)
+        self.dispatch(State::End, res, cx, buf)
     }
 }

src/server/encode.rs

@@ -60,7 +60,7 @@ impl Read for Encoder {
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
         self.bytes_written = 0;
-        let res = self.dispatch(cx, buf);
+        let res = self.run(cx, buf);
         log::trace!("ServerEncoder {} bytes written", self.bytes_written);
         res
     }
@@ -83,7 +83,7 @@ impl Encoder {
     }
 
     /// Switch the internal state to a new state.
-    fn set_state(
+    fn dispatch(
         &mut self,
         state: State,
         cx: &mut Context<'_>,
@@ -103,13 +103,13 @@ impl Encoder {
         }
 
         self.state = state;
-        self.dispatch(cx, buf)
+        self.run(cx, buf)
     }
 
     /// Execute the right method for the current state.
-    fn dispatch(&mut self, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
+    fn run(&mut self, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<io::Result<usize>> {
         match self.state {
-            State::Start => self.set_state(State::ComputeHead, cx, buf),
+            State::Start => self.dispatch(State::ComputeHead, cx, buf),
             State::ComputeHead => self.compute_head(cx, buf),
             State::EncodeHead => self.encode_head(cx, buf),
             State::EncodeFixedBody => self.encode_fixed_body(cx, buf),
@@ -152,7 +152,7 @@ impl Encoder {
 
         std::io::Write::write_fmt(&mut self.head, format_args!("\r\n"))?;
 
-        self.set_state(State::EncodeHead, cx, buf)
+        self.dispatch(State::EncodeHead, cx, buf)
     }
 
     /// Encode the status code + headers.
@@ -173,9 +173,9 @@ impl Encoder {
             match self.res.len() {
                 Some(body_len) => {
                     self.body_len = body_len;
-                    self.set_state(State::EncodeFixedBody, cx, buf)
+                    self.dispatch(State::EncodeFixedBody, cx, buf)
                 }
-                None => self.set_state(State::EncodeChunkedBody, cx, buf),
+                None => self.dispatch(State::EncodeChunkedBody, cx, buf),
             }
         } else {
             // If we haven't read the entire header it means `buf` isn't
@@ -227,11 +227,11 @@ impl Encoder {
 
         if self.body_len == self.body_bytes_written {
             // If we've read the `len` number of bytes, end
-            self.set_state(State::End, cx, buf)
+            self.dispatch(State::End, cx, buf)
         } else if new_body_bytes_written == 0 {
             // If we've reached unexpected EOF, end anyway
             // TODO: do something?
-            self.set_state(State::End, cx, buf)
+            self.dispatch(State::End, cx, buf)
         } else {
             // Else continue encoding
             self.encode_fixed_body(cx, buf)
@@ -250,7 +250,7 @@ impl Encoder {
             Poll::Ready(Ok(read)) => {
                 self.bytes_written += read;
                 match self.bytes_written {
-                    0 => self.set_state(State::End, cx, buf),
+                    0 => self.dispatch(State::End, cx, buf),
                     _ => Poll::Ready(Ok(self.bytes_written)),
                 }
             }