aldrin_core/message/
call_function.rs

1use super::message_ops::Sealed;
2use super::{
3    Message, MessageDeserializeError, MessageKind, MessageOps, MessageSerializeError,
4    MessageSerializer, MessageWithValueDeserializer,
5};
6use crate::{SerializedValue, SerializedValueSlice, ServiceCookie};
7use bytes::BytesMut;
8
9#[derive(Debug, Clone, PartialEq, Eq)]
10#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
11pub struct CallFunction {
12    pub serial: u32,
13    pub service_cookie: ServiceCookie,
14    pub function: u32,
15    pub value: SerializedValue,
16}
17
18impl MessageOps for CallFunction {
19    fn kind(&self) -> MessageKind {
20        MessageKind::CallFunction
21    }
22
23    fn serialize_message(self) -> Result<BytesMut, MessageSerializeError> {
24        let mut serializer = MessageSerializer::with_value(self.value, MessageKind::CallFunction)?;
25
26        serializer.put_varint_u32_le(self.serial);
27        serializer.put_uuid(self.service_cookie.0);
28        serializer.put_varint_u32_le(self.function);
29
30        serializer.finish()
31    }
32
33    fn deserialize_message(buf: BytesMut) -> Result<Self, MessageDeserializeError> {
34        let mut deserializer = MessageWithValueDeserializer::new(buf, MessageKind::CallFunction)?;
35
36        let serial = deserializer.try_get_varint_u32_le()?;
37        let service_cookie = deserializer.try_get_uuid().map(ServiceCookie)?;
38        let function = deserializer.try_get_varint_u32_le()?;
39        let value = deserializer.finish()?;
40
41        Ok(Self {
42            serial,
43            service_cookie,
44            function,
45            value,
46        })
47    }
48
49    fn value(&self) -> Option<&SerializedValueSlice> {
50        Some(&self.value)
51    }
52
53    fn value_mut(&mut self) -> Option<&mut SerializedValue> {
54        Some(&mut self.value)
55    }
56}
57
58impl Sealed for CallFunction {}
59
60impl From<CallFunction> for Message {
61    fn from(msg: CallFunction) -> Self {
62        Self::CallFunction(msg)
63    }
64}
65
66#[cfg(test)]
67mod test {
68    use super::super::test::{assert_deserialize_eq_with_value, assert_serialize_eq};
69    use super::super::Message;
70    use super::CallFunction;
71    use crate::{tags, SerializedValue, ServiceCookie};
72    use uuid::uuid;
73
74    #[test]
75    fn call_function() {
76        let serialized = [
77            29, 0, 0, 0, 11, 2, 0, 0, 0, 3, 4, 1, 0x02, 0x6c, 0x31, 0x42, 0x53, 0x0b, 0x4d, 0x65,
78            0x85, 0x0d, 0xa2, 0x97, 0xdc, 0xc2, 0xfe, 0xcb, 2,
79        ];
80        let value = 4u8;
81
82        let msg = CallFunction {
83            serial: 1,
84            service_cookie: ServiceCookie(uuid!("026c3142-530b-4d65-850d-a297dcc2fecb")),
85            function: 2,
86            value: SerializedValue::serialize(value).unwrap(),
87        };
88
89        assert_serialize_eq(&msg, serialized);
90        assert_deserialize_eq_with_value::<_, _, tags::U8, _>(&msg, serialized, &value);
91
92        let msg = Message::CallFunction(msg);
93        assert_serialize_eq(&msg, serialized);
94        assert_deserialize_eq_with_value::<_, _, tags::U8, _>(&msg, serialized, &value);
95    }
96}