reddb_server/storage/primitives/
serializer.rs

1// Binary serializer - compact and fast
2use std::io::{self, Write};
3
4#[derive(Debug, Clone)]
5pub struct Record {
6    pub key: Vec<u8>,
7    pub value: Vec<u8>,
8}
9
10pub struct Serializer;
11
12impl Serializer {
13    /// Serialize record to binary format
14    /// Format: [total_len: u32][key_len: u32][key][value]
15    pub fn serialize(record: &Record) -> io::Result<Vec<u8>> {
16        let key_len = record.key.len() as u32;
17        let value_len = record.value.len() as u32;
18        let total_len = 4 + key_len + value_len; // 4 bytes for key_len
19
20        let mut buf = Vec::with_capacity(4 + total_len as usize);
21
22        // Total length (excluding this field)
23        buf.write_all(&total_len.to_le_bytes())?;
24
25        // Key length
26        buf.write_all(&key_len.to_le_bytes())?;
27
28        // Key
29        buf.write_all(&record.key)?;
30
31        // Value
32        buf.write_all(&record.value)?;
33
34        Ok(buf)
35    }
36
37    /// Deserialize record from binary format
38    pub fn deserialize(buf: &[u8]) -> io::Result<Record> {
39        if buf.len() < 4 {
40            return Err(io::Error::new(
41                io::ErrorKind::InvalidData,
42                "Buffer too small for key length",
43            ));
44        }
45
46        let key_len = u32::from_le_bytes([buf[0], buf[1], buf[2], buf[3]]) as usize;
47
48        if buf.len() < 4 + key_len {
49            return Err(io::Error::new(
50                io::ErrorKind::InvalidData,
51                "Buffer too small for key",
52            ));
53        }
54
55        let key = buf[4..4 + key_len].to_vec();
56        let value = buf[4 + key_len..].to_vec();
57
58        Ok(Record { key, value })
59    }
60
61    /// Serialize a string efficiently
62    pub fn serialize_string(s: &str) -> Vec<u8> {
63        s.as_bytes().to_vec()
64    }
65
66    /// Deserialize a string
67    pub fn deserialize_string(buf: &[u8]) -> io::Result<String> {
68        String::from_utf8(buf.to_vec())
69            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))
70    }
71
72    /// Serialize u64 as little-endian bytes
73    pub fn serialize_u64(n: u64) -> Vec<u8> {
74        n.to_le_bytes().to_vec()
75    }
76
77    /// Deserialize u64 from little-endian bytes
78    pub fn deserialize_u64(buf: &[u8]) -> io::Result<u64> {
79        if buf.len() != 8 {
80            return Err(io::Error::new(
81                io::ErrorKind::InvalidData,
82                "Invalid u64 buffer size",
83            ));
84        }
85        Ok(u64::from_le_bytes([
86            buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
87        ]))
88    }
89}
90
91#[cfg(test)]
92mod tests {
93    use super::*;
94
95    #[test]
96    fn test_serialize_deserialize() {
97        let record = Record {
98            key: b"domain:example.com".to_vec(),
99            value: b"192.168.1.1".to_vec(),
100        };
101
102        let serialized = Serializer::serialize(&record).unwrap();
103        let deserialized = Serializer::deserialize(&serialized[4..]).unwrap();
104
105        assert_eq!(record.key, deserialized.key);
106        assert_eq!(record.value, deserialized.value);
107    }
108
109    #[test]
110    fn test_string_serialization() {
111        let s = "example.com";
112        let serialized = Serializer::serialize_string(s);
113        let deserialized = Serializer::deserialize_string(&serialized).unwrap();
114        assert_eq!(s, deserialized);
115    }
116
117    #[test]
118    fn test_u64_serialization() {
119        let n = 1234567890u64;
120        let serialized = Serializer::serialize_u64(n);
121        let deserialized = Serializer::deserialize_u64(&serialized).unwrap();
122        assert_eq!(n, deserialized);
123    }
124}
reddb_server/storage/primitives/serializer.rs

reddb_server/storage/primitives/
serializer.rs
