aldrin_core/message/
connect2.rs

1use super::message_ops::Sealed;
2use super::{Message, MessageKind, MessageOps};
3use crate::error::{DeserializeError, SerializeError};
4use crate::message_deserializer::{MessageDeserializeError, MessageWithValueDeserializer};
5use crate::message_serializer::{MessageSerializeError, MessageSerializer};
6use crate::serialized_value::{SerializedValue, SerializedValueSlice};
7use crate::value_deserializer::{Deserialize, Deserializer};
8use crate::value_serializer::{Serialize, Serializer};
9use bytes::BytesMut;
10
11#[derive(Debug, Clone, PartialEq, Eq, Default)]
12#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
13pub struct ConnectData {
14    pub user: Option<SerializedValue>,
15}
16
17impl ConnectData {
18    pub fn new() -> Self {
19        Self::default()
20    }
21
22    pub fn serialize_user<T: Serialize + ?Sized>(
23        &mut self,
24        user: &T,
25    ) -> Result<&mut Self, SerializeError> {
26        self.user = SerializedValue::serialize(user).map(Some)?;
27        Ok(self)
28    }
29
30    pub fn deserialize_user<T: Deserialize>(&self) -> Option<Result<T, DeserializeError>> {
31        self.user.as_deref().map(SerializedValueSlice::deserialize)
32    }
33}
34
35impl Serialize for ConnectData {
36    fn serialize(&self, serializer: Serializer) -> Result<(), SerializeError> {
37        let mut serializer = serializer.serialize_struct(1)?;
38        serializer.serialize_field(0, &self.user)?;
39        serializer.finish()
40    }
41}
42
43impl Deserialize for ConnectData {
44    fn deserialize(deserializer: Deserializer) -> Result<Self, DeserializeError> {
45        let mut deserializer = deserializer.deserialize_struct()?;
46
47        let mut user = None;
48
49        while deserializer.has_more_fields() {
50            let deserializer = deserializer.deserialize_field()?;
51
52            match deserializer.id() {
53                0 => user = deserializer.deserialize()?,
54                _ => deserializer.skip()?,
55            }
56        }
57
58        Ok(Self { user })
59    }
60}
61
62#[derive(Debug, Clone, PartialEq, Eq)]
63#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
64pub struct Connect2 {
65    pub major_version: u32,
66    pub minor_version: u32,
67    pub value: SerializedValue,
68}
69
70impl Connect2 {
71    pub fn with_serialize_data(
72        major_version: u32,
73        minor_version: u32,
74        data: &ConnectData,
75    ) -> Result<Self, SerializeError> {
76        let value = SerializedValue::serialize(data)?;
77
78        Ok(Self {
79            major_version,
80            minor_version,
81            value,
82        })
83    }
84
85    pub fn deserialize_connect_data(&self) -> Result<ConnectData, DeserializeError> {
86        self.value.deserialize()
87    }
88}
89
90impl MessageOps for Connect2 {
91    fn kind(&self) -> MessageKind {
92        MessageKind::Connect2
93    }
94
95    fn serialize_message(self) -> Result<BytesMut, MessageSerializeError> {
96        let mut serializer = MessageSerializer::with_value(self.value, MessageKind::Connect2)?;
97
98        serializer.put_varint_u32_le(self.major_version);
99        serializer.put_varint_u32_le(self.minor_version);
100
101        serializer.finish()
102    }
103
104    fn deserialize_message(buf: BytesMut) -> Result<Self, MessageDeserializeError> {
105        let mut deserializer = MessageWithValueDeserializer::new(buf, MessageKind::Connect2)?;
106
107        let major_version = deserializer.try_get_varint_u32_le()?;
108        let minor_version = deserializer.try_get_varint_u32_le()?;
109        let value = deserializer.finish()?;
110
111        Ok(Self {
112            major_version,
113            minor_version,
114            value,
115        })
116    }
117
118    fn value(&self) -> Option<&SerializedValueSlice> {
119        Some(&self.value)
120    }
121}
122
123impl Sealed for Connect2 {}
124
125impl From<Connect2> for Message {
126    fn from(msg: Connect2) -> Self {
127        Self::Connect2(msg)
128    }
129}
130
131#[cfg(test)]
132mod test {
133    use super::super::test::{assert_deserialize_eq_with_value, assert_serialize_eq};
134    use super::super::Message;
135    use super::{Connect2, ConnectData};
136
137    #[test]
138    fn connect() {
139        let serialized = [15, 0, 0, 0, 46, 4, 0, 0, 0, 39, 1, 0, 0, 1, 2];
140        let value = ConnectData::new();
141
142        let msg = Connect2::with_serialize_data(1, 2, &value).unwrap();
143        assert_serialize_eq(&msg, serialized);
144        assert_deserialize_eq_with_value(&msg, serialized, &value);
145
146        let msg = Message::Connect2(msg);
147        assert_serialize_eq(&msg, serialized);
148        assert_deserialize_eq_with_value(&msg, serialized, &value);
149    }
150}
aldrin_core/message/connect2.rs

aldrin_core/message/
connect2.rs
