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
72
73
74
75
76
77
78
79
80
81

use crate::{ByteEncode, BorrowByteEncode};


macro_rules! encode_bytes {
    ($value:expr, $input:expr, $fattr:expr) => {
        // key and split
        if let Some(fattr) = $fattr {
            if let Some(key) = &fattr.key { $input.extend(key); }
            if let Some(splits) = &fattr.split && let Some(split) = splits.first() {
                $input.extend(split);
            }
        }

        $input.extend($value.to_vec());

        if let Some(fattr) = $fattr && let Some(linend_value_list) = &fattr.linend_value && let Some(linend_value) = linend_value_list.first() {
            if !$value.to_vec().ends_with(linend_value) {
                $input.extend(linend_value)
            }
        }
    };
}


impl ByteEncode for &[u8] {
    fn encode(&self, input: &mut Vec<u8>, _cattr: Option<&crate::ContainerAttrModifiers>, fattr: Option<&crate::FieldAttrModifiers>)
        where 
            Self: Sized
    {
        encode_bytes!(self , input, fattr);
    }
}


impl<'de> BorrowByteEncode for &'de [u8] {
    fn encode(&self, input: &mut Vec<u8>, _cattr: Option<&crate::ContainerAttrModifiers>, fattr: Option<&crate::FieldAttrModifiers>)
        where 
            Self: Sized
    {
        encode_bytes!(self, input, fattr);
    }
}


#[cfg(test)]
mod tests {
    use crate::encode::BorrowByteEncode;
    use crate::FieldAttrModifiers;

    #[test]
    fn test_encode_bytes() {
        let mut buf = vec![];
        let value = &[b'a', b'b', b'c'][..];
        value.encode(&mut buf, None, None);
        assert_eq!(buf, b"abc");

        let fattr = FieldAttrModifiers { linend_value: Some(vec!["\r\n".as_bytes().to_vec()]), ..Default::default() };
        let mut buf = vec![];
        let value = &[b'a', b'b', b'c'][..];
        value.encode(&mut buf, None, Some(&fattr));
        assert_eq!(buf, b"abc\r\n");

        let fattr = FieldAttrModifiers { linend_value: Some(vec!["abc".as_bytes().to_vec()]), ..Default::default() };
        let mut buf = vec![];
        let value = &[b'a', b'b', b'c'][..];
        value.encode(&mut buf, None, Some(&fattr));
        assert_eq!(buf, b"abc");

        let fattr = FieldAttrModifiers { linend_value: Some(vec!["123".as_bytes().to_vec()]), ..Default::default() };
        let mut buf = vec![];
        let value = &[b'a', b'b', b'c'][..];
        value.encode(&mut buf, None, Some(&fattr));
        assert_eq!(buf, b"abc123");

        let fattr = FieldAttrModifiers { key: Some(b"Host: ".to_vec()), linend_value: Some(vec![b"\r\n".to_vec()]), ..Default::default() };
        let mut buf = vec![];
        let value = &b"abc"[..];
        value.encode(&mut buf, None, Some(&fattr));
        assert_eq!(buf, b"Host: abc\r\n");
    }
}