Refactor parse_header to return structured type and update to Rust 2024

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "meta-memcache-socket"
 version = "0.1.6"
-edition = "2021"
+edition = "2024"
 
 [lib]
 name = "meta_memcache_socket"

src/impl_build_cmd.rs

@@ -1,4 +1,4 @@
-use base64::{engine::general_purpose, Engine as _};
+use base64::{Engine as _, engine::general_purpose};
 
 use crate::RequestFlags;
 

src/impl_parse_header.rs

@@ -1,12 +1,18 @@
 use memchr::memmem;
 
-use crate::{constants::*, ResponseFlags};
+use crate::constants::*;
+use crate::response_flags::ResponseFlags;
 
-pub fn impl_parse_header(
-    data: &[u8],
-    start: usize,
-    end: usize,
-) -> Option<(usize, Option<u8>, Option<u32>, Option<ResponseFlags>)> {
+/// Result of parsing a memcache meta-protocol response header.
+#[derive(Debug)]
+pub struct ParsedHeader {
+    pub end_pos: usize,
+    pub response_type: Option<u8>,
+    pub size: Option<u32>,
+    pub flags: Option<ResponseFlags>,
+}
+
+pub fn impl_parse_header(data: &[u8], start: usize, end: usize) -> Option<ParsedHeader> {
     if end - start < 4 {
         return None;
     }
@@ -15,28 +21,60 @@ pub fn impl_parse_header(
     if search_start >= end {
         return None;
     }
-    // Use memmem SIMD-accelerated search for \r\n
-    if let Some(pos) = memmem::find(&data[search_start..end], b"\r\n") {
-        let n = search_start + pos;
-        let endl_pos = n + 2;
-        match &data[start..start + 2] {
-            b"VA" => match ResponseFlags::from_value_header(&data[start..n]) {
-                Some((size, flags)) => {
-                    Some((endl_pos, Some(RESPONSE_VALUE), Some(size), Some(flags)))
-                }
-                None => Some((endl_pos, None, None, None)),
-            },
-            b"HD" | b"OK" => {
-                let flags = ResponseFlags::from_success_header(&data[start..n]);
-                Some((endl_pos, Some(RESPONSE_SUCCESS), None, Some(flags)))
-            }
-            b"NS" => Some((endl_pos, Some(RESPONSE_NOT_STORED), None, None)),
-            b"EX" => Some((endl_pos, Some(RESPONSE_CONFLICT), None, None)),
-            b"EN" | b"NF" => Some((endl_pos, Some(RESPONSE_MISS), None, None)),
-            b"MN" => Some((endl_pos, Some(RESPONSE_NOOP), None, None)),
-            _ => Some((endl_pos, None, None, None)),
-        }
-    } else {
-        None
+    // SIMD-accelerated search for \r\n
+    let pos = memmem::find(&data[search_start..end], b"\r\n")?;
+    let n = search_start + pos;
+    let end_pos = n + 2;
+    match &data[start..start + 2] {
+        b"VA" => match ResponseFlags::from_value_header(&data[start..n]) {
+            Some((size, flags)) => Some(ParsedHeader {
+                end_pos,
+                response_type: Some(RESPONSE_VALUE),
+                size: Some(size),
+                flags: Some(flags),
+            }),
+            None => Some(ParsedHeader {
+                end_pos,
+                response_type: None,
+                size: None,
+                flags: None,
+            }),
+        },
+        b"HD" | b"OK" => Some(ParsedHeader {
+            end_pos,
+            response_type: Some(RESPONSE_SUCCESS),
+            size: None,
+            flags: Some(ResponseFlags::from_success_header(&data[start..n])),
+        }),
+        b"NS" => Some(ParsedHeader {
+            end_pos,
+            response_type: Some(RESPONSE_NOT_STORED),
+            size: None,
+            flags: None,
+        }),
+        b"EX" => Some(ParsedHeader {
+            end_pos,
+            response_type: Some(RESPONSE_CONFLICT),
+            size: None,
+            flags: None,
+        }),
+        b"EN" | b"NF" => Some(ParsedHeader {
+            end_pos,
+            response_type: Some(RESPONSE_MISS),
+            size: None,
+            flags: None,
+        }),
+        b"MN" => Some(ParsedHeader {
+            end_pos,
+            response_type: Some(RESPONSE_NOOP),
+            size: None,
+            flags: None,
+        }),
+        _ => Some(ParsedHeader {
+            end_pos,
+            response_type: None,
+            size: None,
+            flags: None,
+        }),
     }
 }