rs-netty 0.2.2

A Tokio-native typed TCP/UDP pipeline framework inspired by Netty.
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

use bytes::{Bytes, BytesMut};

use crate::{
    codec::{Decoder, Encoder},
    Result,
};

/// Byte stream drain codec.
///
/// Decoding returns all bytes currently buffered as one [`Bytes`] value. This
/// is useful for protocols that already have an external message boundary or
/// for tests; it is not a framing codec for arbitrary TCP streams.
pub struct ByteArrayDecoder;

impl Decoder for ByteArrayDecoder {
    type Item = Bytes;

    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>> {
        if src.is_empty() {
            return Ok(None);
        }

        Ok(Some(src.split().freeze()))
    }
}

impl Encoder<Bytes> for ByteArrayDecoder {
    fn encode(&mut self, item: Bytes, dst: &mut BytesMut) -> Result<()> {
        dst.extend_from_slice(&item);
        Ok(())
    }
}

/// Pass-through byte encoder.
pub struct ByteArrayEncoder;

impl Encoder<Bytes> for ByteArrayEncoder {
    fn encode(&mut self, item: Bytes, dst: &mut BytesMut) -> Result<()> {
        dst.extend_from_slice(&item);
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn drains_available_bytes() {
        let mut codec = ByteArrayDecoder;
        let mut buf = BytesMut::from(&b"abc"[..]);

        assert_eq!(
            codec.decode(&mut buf).expect("decode"),
            Some(Bytes::from_static(b"abc"))
        );
        assert!(buf.is_empty());
    }
}