aldrin_core/message/
abort_function_call.rs

1use super::message_ops::Sealed;
2use super::{
3    Message, MessageDeserializeError, MessageKind, MessageOps, MessageSerializeError,
4    MessageSerializer, MessageWithoutValueDeserializer,
5};
6use crate::{SerializedValue, SerializedValueSlice};
7use bytes::BytesMut;
8
9#[derive(Debug, Copy, Clone, PartialEq, Eq)]
10#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
11pub struct AbortFunctionCall {
12    pub serial: u32,
13}
14
15impl MessageOps for AbortFunctionCall {
16    fn kind(&self) -> MessageKind {
17        MessageKind::AbortFunctionCall
18    }
19
20    fn serialize_message(self) -> Result<BytesMut, MessageSerializeError> {
21        let mut serializer = MessageSerializer::without_value(MessageKind::AbortFunctionCall);
22
23        serializer.put_varint_u32_le(self.serial);
24
25        serializer.finish()
26    }
27
28    fn deserialize_message(buf: BytesMut) -> Result<Self, MessageDeserializeError> {
29        let mut deserializer =
30            MessageWithoutValueDeserializer::new(buf, MessageKind::AbortFunctionCall)?;
31
32        let serial = deserializer.try_get_varint_u32_le()?;
33
34        deserializer.finish()?;
35        Ok(Self { serial })
36    }
37
38    fn value(&self) -> Option<&SerializedValueSlice> {
39        None
40    }
41
42    fn value_mut(&mut self) -> Option<&mut SerializedValue> {
43        None
44    }
45}
46
47impl Sealed for AbortFunctionCall {}
48
49impl From<AbortFunctionCall> for Message {
50    fn from(msg: AbortFunctionCall) -> Self {
51        Self::AbortFunctionCall(msg)
52    }
53}
54
55#[cfg(test)]
56mod test {
57    use super::super::test::{assert_deserialize_eq, assert_serialize_eq};
58    use super::super::Message;
59    use super::AbortFunctionCall;
60
61    #[test]
62    fn sync() {
63        let serialized = [6, 0, 0, 0, 48, 1];
64
65        let msg = AbortFunctionCall { serial: 1 };
66        assert_serialize_eq(&msg, serialized);
67        assert_deserialize_eq(&msg, serialized);
68
69        let msg = Message::AbortFunctionCall(msg);
70        assert_serialize_eq(&msg, serialized);
71        assert_deserialize_eq(&msg, serialized);
72    }
73}