wamp_core/messages/registered.rs
1use super::{helpers, MessageDirection, WampMessage};
2use crate::roles::Roles;
3use serde::de::{SeqAccess, Visitor};
4use serde::{Deserialize, Deserializer, Serialize};
5use std::fmt::Formatter;
6use std::marker::PhantomData;
7
8#[derive(Debug, Clone, PartialEq, Eq)]
9/// # Registered - [wamp-proto](https://wamp-proto.org/wamp_latest_ietf.html#name-registered-2)
10/// Represents an Registered message in the WAMP protocol.
11/// ## Examples
12/// ```
13/// use wamp_core::messages::Registered;
14/// use wamp_core::registered;
15/// use serde_json::json;
16///
17/// # let mut registered_message2 = registered!(1, 2);
18///
19/// let registered_message = Registered {
20/// request_id: 1,
21/// registration: 2
22/// };
23///
24/// # assert_eq!(registered_message, registered_message2);
25/// ```
26/// ### Serializer
27/// Implements serde Serialize trait for registered
28/// ```
29/// use wamp_core::messages::Registered;
30/// use serde_json::{json, to_string};
31///
32/// // Create an registered message
33/// let registered = Registered {
34/// request_id: 1,
35/// registration: 2
36/// };
37///
38/// // Establish raw json data string
39/// let data = r#"[65,1,2]"#;
40///
41/// // Here we convert it from an `registered` frame, to a string representation.
42/// let registered = to_string(®istered).unwrap();
43///
44/// // Confirm that our registered frame strings are equal to each other
45/// assert_eq!(registered, data);
46/// ```
47/// ### Deserializer
48/// Implements serde Deserialize trait for registered
49/// ```
50/// use wamp_core::messages::Registered;
51/// use serde_json::from_str;
52///
53/// // Here is our raw json data string
54/// let data = r#"[65,1,2]"#;
55///
56/// // Here we convert it to an `Registered` frame
57/// let registered = from_str::<Registered>(data).unwrap();
58///
59/// // Confirm that our request_id and registration deserialized
60/// assert_eq!(registered.request_id, 1);
61/// assert_eq!(registered.registration, 2);
62/// ```
63pub struct Registered {
64 pub request_id: u64,
65 pub registration: u64,
66}
67
68#[macro_export]
69/// # Registered Macro - [wamp-proto](https://wamp-proto.org/wamp_latest_ietf.html#name-registered-2)
70/// Macro that allows for creating Registered wamp message.
71/// ## Examples
72/// ```
73/// use wamp_core::messages::{self, Registered};
74/// use wamp_core::registered;
75/// use serde_json::json;
76///
77/// let mut registered_message = registered!(1, 2);
78/// let registered_message2 = registered!(1, 3);
79///
80/// assert_ne!(registered_message, registered_message2);
81///
82/// // These macro invocations are the same as the following:
83/// let registered_message3 = Registered {
84/// request_id: 1,
85/// registration: 2
86/// };
87///
88/// assert_eq!(registered_message, registered_message3);
89/// assert_ne!(registered_message2, registered_message3);
90/// ```
91macro_rules! registered {
92 ($request_id:expr, $registration:expr) => {
93 Registered {
94 request_id: $request_id,
95 registration: $registration,
96 }
97 };
98}
99
100impl WampMessage for Registered {
101 const ID: u64 = 65;
102
103 fn direction(role: Roles) -> &'static MessageDirection {
104 match role {
105 Roles::Callee => &MessageDirection {
106 receives: &true,
107 sends: &false,
108 },
109 Roles::Caller => &MessageDirection {
110 receives: &false,
111 sends: &false,
112 },
113 Roles::Publisher => &MessageDirection {
114 receives: &false,
115 sends: &false,
116 },
117 Roles::Subscriber => &MessageDirection {
118 receives: &false,
119 sends: &false,
120 },
121 Roles::Dealer => &MessageDirection {
122 receives: &false,
123 sends: &true,
124 },
125 Roles::Broker => &MessageDirection {
126 receives: &false,
127 sends: &false,
128 },
129 }
130 }
131}
132
133impl Serialize for Registered {
134 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
135 where
136 S: serde::Serializer,
137 {
138 (Self::ID, &self.request_id, &self.registration).serialize(serializer)
139 }
140}
141
142impl<'de> Deserialize<'de> for Registered {
143 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
144 where
145 D: Deserializer<'de>,
146 {
147 struct RegisteredVisitor(PhantomData<u64>, PhantomData<u64>, PhantomData<u64>);
148
149 impl<'vi> Visitor<'vi> for RegisteredVisitor {
150 type Value = Registered;
151 fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
152 formatter.write_str("A sequence of Registered components.")
153 }
154
155 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
156 where
157 A: SeqAccess<'vi>,
158 {
159 let message_id: u64 = helpers::deser_seq_element(
160 &mut seq,
161 "Message ID must be present and type u8.",
162 )?;
163 helpers::validate_id::<Registered, A, _>(&message_id, "Registered")?;
164 let request_id: u64 = helpers::deser_seq_element(
165 &mut seq,
166 "request_id must be present and type u64.",
167 )?;
168 let registration: u64 = helpers::deser_seq_element(
169 &mut seq,
170 "registration must be present and object like.",
171 )?;
172 Ok(Registered {
173 request_id,
174 registration,
175 })
176 }
177 }
178
179 deserializer.deserialize_struct(
180 "Registered",
181 &["request_id", "registration"],
182 RegisteredVisitor(PhantomData, PhantomData, PhantomData),
183 )
184 }
185}
186
187#[cfg(test)]
188mod tests {
189 use serde_json::{from_str, to_string};
190
191 use super::Registered;
192
193 #[test]
194 fn test() {
195 let d1 = r#"[65,25349185,2103333224]"#;
196 let p1 = Registered {
197 request_id: 25349185,
198 registration: 2103333224,
199 };
200 assert_eq!(d1, to_string(&p1).unwrap());
201 assert_eq!(from_str::<Registered>(d1).unwrap(), p1);
202 }
203}