resp-rs 0.1.8

Zero-copy RESP2 and RESP3 protocol parser and serializer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

//! Basic parsing and serialization demo.
//!
//! Run with: `cargo run --example parse`

use bytes::Bytes;

fn main() {
    // --- RESP2 ---
    println!("=== RESP2 ===\n");

    // Parse a simple string
    let data = Bytes::from("+OK\r\n");
    let (frame, _) = resp_rs::resp2::parse_frame(data).unwrap();
    println!("Simple string: {frame:?}");

    // Parse an array (a SET command)
    let data = Bytes::from("*3\r\n$3\r\nSET\r\n$5\r\nmykey\r\n$7\r\nmyvalue\r\n");
    let (frame, _) = resp_rs::resp2::parse_frame(data).unwrap();
    println!("SET command:   {frame:?}");

    // Serialize a frame back to wire format
    let frame = resp_rs::resp2::Frame::Array(Some(vec![
        resp_rs::resp2::Frame::BulkString(Some(Bytes::from("GET"))),
        resp_rs::resp2::Frame::BulkString(Some(Bytes::from("mykey"))),
    ]));
    let wire = resp_rs::resp2::frame_to_bytes(&frame);
    println!("Serialized:    {:?}", String::from_utf8_lossy(&wire));

    // --- RESP3 ---
    println!("\n=== RESP3 ===\n");

    // Parse RESP3-specific types
    let cases: &[(&str, &[u8])] = &[
        ("Null", b"_\r\n"),
        ("Boolean", b"#t\r\n"),
        ("Double", b",3.14159\r\n"),
        (
            "Big number",
            b"(3492890328409238509324850943850943825024385\r\n",
        ),
        ("Verbatim", b"=15\r\ntxt:hello world\r\n"),
    ];
    for (label, raw) in cases {
        let (frame, _) = resp_rs::resp3::parse_frame(Bytes::from(*raw)).unwrap();
        println!("{label:12}:  {frame:?}");
    }

    // Parse a map
    let data = Bytes::from("%2\r\n+name\r\n$5\r\nAlice\r\n+age\r\n:30\r\n");
    let (frame, _) = resp_rs::resp3::parse_frame(data).unwrap();
    println!("{:12}:  {frame:?}", "Map");

    // --- Streaming parser ---
    println!("\n=== Streaming parser ===\n");

    let mut parser = resp_rs::resp2::Parser::new();

    // Feed partial data
    parser.feed(Bytes::from("*2\r\n$4\r\nPIN"));
    println!(
        "Fed partial data, buffered {} bytes",
        parser.buffered_bytes()
    );
    println!("Next frame: {:?}", parser.next_frame().unwrap());

    // Feed the rest
    parser.feed(Bytes::from("G\r\n$0\r\n\r\n"));
    println!("Fed remaining data");
    let frame = parser.next_frame().unwrap().unwrap();
    println!("Got frame:  {frame:?}");
}