Skip to main content

moq_transport/message/
group_order.rs

1use crate::coding::{Decode, DecodeError, Encode, EncodeError};
2
3/// Group Order
4#[derive(Clone, Copy, Debug, Eq, PartialEq)]
5pub enum GroupOrder {
6    Publisher = 0x0,
7    Ascending = 0x1,
8    Descending = 0x2,
9}
10
11impl Encode for GroupOrder {
12    fn encode<W: bytes::BufMut>(&self, w: &mut W) -> Result<(), EncodeError> {
13        let val = *self as u8;
14        val.encode(w)?;
15        Ok(())
16    }
17}
18
19impl Decode for GroupOrder {
20    fn decode<R: bytes::Buf>(r: &mut R) -> Result<Self, DecodeError> {
21        match u8::decode(r)? {
22            0x0 => Ok(Self::Publisher),
23            0x1 => Ok(Self::Ascending),
24            0x2 => Ok(Self::Descending),
25            _ => Err(DecodeError::InvalidGroupOrder),
26        }
27    }
28}
29
30#[cfg(test)]
31mod tests {
32    use super::*;
33    use bytes::Bytes;
34    use bytes::BytesMut;
35
36    #[test]
37    fn encode_decode() {
38        let mut buf = BytesMut::new();
39
40        let go = GroupOrder::Publisher;
41        go.encode(&mut buf).unwrap();
42        assert_eq!(buf.to_vec(), vec![0x00]);
43        let decoded = GroupOrder::decode(&mut buf).unwrap();
44        assert_eq!(decoded, go);
45
46        let go = GroupOrder::Ascending;
47        go.encode(&mut buf).unwrap();
48        assert_eq!(buf.to_vec(), vec![0x01]);
49        let decoded = GroupOrder::decode(&mut buf).unwrap();
50        assert_eq!(decoded, go);
51
52        let go = GroupOrder::Descending;
53        go.encode(&mut buf).unwrap();
54        assert_eq!(buf.to_vec(), vec![0x02]);
55        let decoded = GroupOrder::decode(&mut buf).unwrap();
56        assert_eq!(decoded, go);
57    }
58
59    #[test]
60    fn decode_bad_value() {
61        let data: Vec<u8> = vec![0x03]; // Invalid filter type
62        let mut buf: Bytes = data.into();
63        let result = GroupOrder::decode(&mut buf);
64        assert!(matches!(result, Err(DecodeError::InvalidGroupOrder)));
65    }
66}