aldrin_core/message/
subscribe_event.rs

1use super::message_ops::Sealed;
2use super::{
3    Message, MessageDeserializeError, MessageKind, MessageOps, MessageSerializeError,
4    MessageSerializer, MessageWithoutValueDeserializer, OptionKind,
5};
6use crate::{SerializedValue, SerializedValueSlice, ServiceCookie};
7use bytes::BytesMut;
8
9#[derive(Debug, Copy, Clone, PartialEq, Eq)]
10#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
11pub struct SubscribeEvent {
12    pub serial: Option<u32>,
13    pub service_cookie: ServiceCookie,
14    pub event: u32,
15}
16
17impl MessageOps for SubscribeEvent {
18    fn kind(&self) -> MessageKind {
19        MessageKind::SubscribeEvent
20    }
21
22    fn serialize_message(self) -> Result<BytesMut, MessageSerializeError> {
23        let mut serializer = MessageSerializer::without_value(MessageKind::SubscribeEvent);
24
25        match self.serial {
26            None => {
27                serializer.put_discriminant_u8(OptionKind::None);
28            }
29
30            Some(serial) => {
31                serializer.put_discriminant_u8(OptionKind::Some);
32                serializer.put_varint_u32_le(serial);
33            }
34        }
35
36        serializer.put_uuid(self.service_cookie.0);
37        serializer.put_varint_u32_le(self.event);
38
39        serializer.finish()
40    }
41
42    fn deserialize_message(buf: BytesMut) -> Result<Self, MessageDeserializeError> {
43        let mut deserializer =
44            MessageWithoutValueDeserializer::new(buf, MessageKind::SubscribeEvent)?;
45
46        let serial = match deserializer.try_get_discriminant_u8()? {
47            OptionKind::None => None,
48            OptionKind::Some => deserializer.try_get_varint_u32_le().map(Some)?,
49        };
50
51        let service_cookie = deserializer.try_get_uuid().map(ServiceCookie)?;
52        let event = deserializer.try_get_varint_u32_le()?;
53
54        deserializer.finish()?;
55        Ok(Self {
56            serial,
57            service_cookie,
58            event,
59        })
60    }
61
62    fn value(&self) -> Option<&SerializedValueSlice> {
63        None
64    }
65
66    fn value_mut(&mut self) -> Option<&mut SerializedValue> {
67        None
68    }
69}
70
71impl Sealed for SubscribeEvent {}
72
73impl From<SubscribeEvent> for Message {
74    fn from(msg: SubscribeEvent) -> Self {
75        Self::SubscribeEvent(msg)
76    }
77}
78
79#[cfg(test)]
80mod test {
81    use super::super::test::{assert_deserialize_eq, assert_serialize_eq};
82    use super::super::Message;
83    use super::SubscribeEvent;
84    use crate::ServiceCookie;
85    use uuid::uuid;
86
87    #[test]
88    fn no_serial() {
89        let serialized = [
90            23, 0, 0, 0, 13, 0, 0x94, 0x5f, 0xc6, 0xe4, 0xe8, 0x9c, 0x49, 0x61, 0xb7, 0xbc, 0x4e,
91            0x0e, 0x84, 0x80, 0xdf, 0xad, 1,
92        ];
93
94        let msg = SubscribeEvent {
95            serial: None,
96            service_cookie: ServiceCookie(uuid!("945fc6e4-e89c-4961-b7bc-4e0e8480dfad")),
97            event: 1,
98        };
99        assert_serialize_eq(&msg, serialized);
100        assert_deserialize_eq(&msg, serialized);
101
102        let msg = Message::SubscribeEvent(msg);
103        assert_serialize_eq(&msg, serialized);
104        assert_deserialize_eq(&msg, serialized);
105    }
106
107    #[test]
108    fn serial() {
109        let serialized = [
110            24, 0, 0, 0, 13, 1, 2, 0x94, 0x5f, 0xc6, 0xe4, 0xe8, 0x9c, 0x49, 0x61, 0xb7, 0xbc,
111            0x4e, 0x0e, 0x84, 0x80, 0xdf, 0xad, 3,
112        ];
113
114        let msg = SubscribeEvent {
115            serial: Some(2),
116            service_cookie: ServiceCookie(uuid!("945fc6e4-e89c-4961-b7bc-4e0e8480dfad")),
117            event: 3,
118        };
119        assert_serialize_eq(&msg, serialized);
120        assert_deserialize_eq(&msg, serialized);
121
122        let msg = Message::SubscribeEvent(msg);
123        assert_serialize_eq(&msg, serialized);
124        assert_deserialize_eq(&msg, serialized);
125    }
126}