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