refactor: encode/decode

Author: upupnoah

dump.rdb

@@ -56,8 +56,9 @@ impl TryFrom<RespArray> for Set {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use crate::RespDecode;
+
+    use super::*;
     use anyhow::Result;
     use bytes::BytesMut;
 

src/cmd/map.rs

@@ -0,0 +1,143 @@
+use std::ops::Deref;
+
+use bytes::{Buf, BytesMut};
+
+use super::{
+    calc_total_length, extract_fixed_data, parse_length, RespDecode, RespEncode, RespError,
+    RespFrame, BUF_CAP, CRLF_LEN,
+};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct RespArray(pub(crate) Vec<RespFrame>);
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RespNullArray;
+
+impl RespArray {
+    pub fn new(s: impl Into<Vec<RespFrame>>) -> Self {
+        RespArray(s.into())
+    }
+}
+
+// - array: "*<number-of-elements>\r\n<element-1>...<element-n>"
+impl RespEncode for RespArray {
+    fn encode(self) -> Vec<u8> {
+        let mut buf = Vec::with_capacity(BUF_CAP);
+        buf.extend_from_slice(&format!("*{}\r\n", self.len()).into_bytes());
+        for frame in self.0 {
+            buf.extend_from_slice(&frame.encode());
+        }
+        buf
+    }
+}
+
+// - array: "*<number-of-elements>\r\n<element-1>...<element-n>"
+impl RespDecode for RespArray {
+    const PREFIX: &'static str = "*";
+    fn decode(buf: &mut BytesMut) -> Result<Self, RespError> {
+        let (end, len) = parse_length(buf, Self::PREFIX)?;
+        let total_len = calc_total_length(buf, end, len, Self::PREFIX)?;
+
+        if buf.len() < total_len {
+            return Err(RespError::NotComplete);
+        }
+
+        buf.advance(end + CRLF_LEN);
+
+        let mut frames = Vec::with_capacity(len);
+        for _ in 0..len {
+            frames.push(RespFrame::decode(buf)?);
+        }
+
+        Ok(RespArray::new(frames))
+    }
+
+    fn expect_length(buf: &[u8]) -> Result<usize, RespError> {
+        let (end, len) = parse_length(buf, Self::PREFIX)?;
+        calc_total_length(buf, end, len, Self::PREFIX)
+    }
+}
+
+// - null array: "*-1\r\n"
+impl RespEncode for RespNullArray {
+    fn encode(self) -> Vec<u8> {
+        b"*-1\r\n".to_vec()
+    }
+}
+
+impl RespDecode for RespNullArray {
+    const PREFIX: &'static str = "*";
+    fn decode(buf: &mut BytesMut) -> Result<Self, RespError> {
+        extract_fixed_data(buf, "*-1\r\n", "NullArray")?;
+        Ok(RespNullArray)
+    }
+
+    fn expect_length(_buf: &[u8]) -> Result<usize, RespError> {
+        Ok(4)
+    }
+}
+
+impl Deref for RespArray {
+    type Target = Vec<RespFrame>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::BulkString;
+    use anyhow::Result;
+
+    #[test]
+    fn test_array_encode() {
+        let frame: RespFrame = RespArray::new(vec![
+            BulkString::new("set".to_string()).into(),
+            BulkString::new("hello".to_string()).into(),
+            BulkString::new("world".to_string()).into(),
+        ])
+        .into();
+        assert_eq!(
+            &frame.encode(),
+            b"*3\r\n$3\r\nset\r\n$5\r\nhello\r\n$5\r\nworld\r\n"
+        );
+    }
+
+    #[test]
+    fn test_null_array_encode() {
+        let frame: RespFrame = RespNullArray.into();
+        assert_eq!(frame.encode(), b"*-1\r\n");
+    }
+
+    #[test]
+    fn test_null_array_decode() -> Result<()> {
+        let mut buf = BytesMut::new();
+        buf.extend_from_slice(b"*-1\r\n");
+
+        let frame = RespNullArray::decode(&mut buf)?;
+        assert_eq!(frame, RespNullArray);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_array_decode() -> Result<()> {
+        let mut buf = BytesMut::new();
+        buf.extend_from_slice(b"*2\r\n$3\r\nset\r\n$5\r\nhello\r\n");
+
+        let frame = RespArray::decode(&mut buf)?;
+        assert_eq!(frame, RespArray::new([b"set".into(), b"hello".into()]));
+
+        buf.extend_from_slice(b"*2\r\n$3\r\nset\r\n");
+        let ret = RespArray::decode(&mut buf);
+        assert_eq!(ret.unwrap_err(), RespError::NotComplete);
+
+        buf.extend_from_slice(b"$5\r\nhello\r\n");
+        let frame = RespArray::decode(&mut buf)?;
+        assert_eq!(frame, RespArray::new([b"set".into(), b"hello".into()]));
+
+        Ok(())
+    }
+}

src/resp/array.rs

@@ -0,0 +1,76 @@
+use bytes::BytesMut;
+
+use super::{extract_fixed_data, RespDecode, RespEncode, RespError};
+
+// - boolean: "#<t|f>\r\n"
+impl RespEncode for bool {
+    fn encode(self) -> Vec<u8> {
+        // if self {
+        //     b"#t\r\n".to_vec()
+        // } else {
+        //     b"#f\r\n".to_vec()
+        // }
+        format!("#{}\r\n", if self { "t" } else { "f" }).into_bytes()
+    }
+}
+
+// - boolean: "#<t|f>\r\n"
+impl RespDecode for bool {
+    const PREFIX: &'static str = "#";
+    fn decode(buf: &mut BytesMut) -> Result<Self, RespError> {
+        match extract_fixed_data(buf, "#t\r\n", "Bool") {
+            Ok(_) => Ok(true),
+            Err(RespError::NotComplete) => Err(RespError::NotComplete),
+            Err(_) => match extract_fixed_data(buf, "#f\r\n", "Bool") {
+                Ok(_) => Ok(false),
+                Err(e) => Err(e),
+            },
+        }
+    }
+
+    fn expect_length(_buf: &[u8]) -> Result<usize, RespError> {
+        Ok(4)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::RespFrame;
+
+    use super::*;
+    use anyhow::Result;
+    use bytes::BufMut;
+
+    #[test]
+    fn test_boolean_encode() {
+        let frame: RespFrame = true.into();
+        assert_eq!(frame.encode(), b"#t\r\n");
+
+        let frame: RespFrame = false.into();
+        assert_eq!(frame.encode(), b"#f\r\n");
+    }
+
+    #[test]
+    fn test_boolean_decode() -> Result<()> {
+        let mut buf = BytesMut::new();
+        buf.extend_from_slice(b"#t\r\n");
+
+        let frame = bool::decode(&mut buf)?;
+        assert!(frame);
+
+        buf.extend_from_slice(b"#f\r\n");
+
+        let frame = bool::decode(&mut buf)?;
+        assert!(!frame);
+
+        buf.extend_from_slice(b"#f\r");
+        let ret = bool::decode(&mut buf);
+        assert_eq!(ret.unwrap_err(), RespError::NotComplete);
+
+        buf.put_u8(b'\n');
+        let frame = bool::decode(&mut buf)?;
+        assert!(!frame);
+
+        Ok(())
+    }
+}

src/resp/bool.rs

@@ -0,0 +1,156 @@
+use std::ops::Deref;
+
+use bytes::{Buf, BytesMut};
+
+use super::{extract_fixed_data, parse_length, RespDecode, RespEncode, RespError, CRLF_LEN};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BulkString(pub(crate) Vec<u8>); // 单个二进制字符串, 用于存储二进制数据(最大512MB)
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RespNullBulkString;
+
+impl BulkString {
+    pub fn new(s: impl Into<Vec<u8>>) -> Self {
+        BulkString(s.into())
+    }
+}
+
+// - bulk string: "$<length>\r\n<data>\r\n"
+impl RespEncode for BulkString {
+    fn encode(self) -> Vec<u8> {
+        let mut buf = Vec::with_capacity(self.len() + 16);
+        buf.extend_from_slice(&format!("${}\r\n", self.len()).into_bytes());
+        buf.extend_from_slice(&self);
+        buf.extend_from_slice(b"\r\n");
+        buf
+    }
+}
+// - bulk string: "$<length>\r\n<data>\r\n"
+impl RespDecode for BulkString {
+    const PREFIX: &'static str = "$";
+    fn decode(buf: &mut BytesMut) -> Result<Self, RespError> {
+        let (end, len) = parse_length(buf, Self::PREFIX)?;
+        let remained = &buf[end + CRLF_LEN..];
+        if remained.len() < len + CRLF_LEN {
+            return Err(RespError::NotComplete);
+        }
+
+        buf.advance(end + CRLF_LEN);
+
+        let data = buf.split_to(len + CRLF_LEN);
+        Ok(BulkString::new(data[..len].to_vec()))
+    }
+
+    fn expect_length(buf: &[u8]) -> Result<usize, RespError> {
+        let (end, len) = parse_length(buf, Self::PREFIX)?;
+        Ok(end + CRLF_LEN + len + CRLF_LEN)
+    }
+}
+
+// - null bulk string: "$-1\r\n"
+impl RespEncode for RespNullBulkString {
+    fn encode(self) -> Vec<u8> {
+        b"$-1\r\n".to_vec()
+    }
+}
+
+impl RespDecode for RespNullBulkString {
+    const PREFIX: &'static str = "$";
+    fn decode(buf: &mut BytesMut) -> Result<Self, RespError> {
+        extract_fixed_data(buf, "$-1\r\n", "NullBulkString")?;
+        Ok(RespNullBulkString)
+    }
+
+    fn expect_length(_buf: &[u8]) -> Result<usize, RespError> {
+        Ok(5)
+    }
+}
+
+impl Deref for BulkString {
+    type Target = Vec<u8>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<[u8]> for BulkString {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl From<&str> for BulkString {
+    fn from(s: &str) -> Self {
+        BulkString(s.as_bytes().to_vec())
+    }
+}
+
+impl From<String> for BulkString {
+    fn from(s: String) -> Self {
+        BulkString(s.into_bytes())
+    }
+}
+
+impl From<&[u8]> for BulkString {
+    fn from(s: &[u8]) -> Self {
+        BulkString(s.to_vec())
+    }
+}
+
+impl<const N: usize> From<&[u8; N]> for BulkString {
+    fn from(s: &[u8; N]) -> Self {
+        BulkString(s.to_vec())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::RespFrame;
+
+    use super::*;
+    use anyhow::Result;
+
+    #[test]
+    fn test_bulk_string_encode() {
+        let frame: RespFrame = BulkString::new(b"hello".to_vec()).into();
+        assert_eq!(frame.encode(), b"$5\r\nhello\r\n");
+    }
+
+    #[test]
+    fn test_null_bulk_string_encode() {
+        let frame: RespFrame = RespNullBulkString.into();
+        assert_eq!(frame.encode(), b"$-1\r\n");
+    }
+
+    #[test]
+    fn test_bulk_string_decode() -> Result<()> {
+        let mut buf = BytesMut::new();
+        buf.extend_from_slice(b"$5\r\nhello\r\n");
+
+        let frame = BulkString::decode(&mut buf)?;
+        assert_eq!(frame, BulkString::new(b"hello"));
+
+        buf.extend_from_slice(b"$5\r\nhello");
+        let ret = BulkString::decode(&mut buf);
+        assert_eq!(ret.unwrap_err(), RespError::NotComplete);
+
+        buf.extend_from_slice(b"\r\n");
+        let frame = BulkString::decode(&mut buf)?;
+        assert_eq!(frame, BulkString::new(b"hello"));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_null_bulk_string_decode() -> Result<()> {
+        let mut buf = BytesMut::new();
+        buf.extend_from_slice(b"$-1\r\n");
+
+        let frame = RespNullBulkString::decode(&mut buf)?;
+        assert_eq!(frame, RespNullBulkString);
+
+        Ok(())
+    }
+}