wamp_core/messages/subscribed.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/// # Subscribed - [wamp-proto](https://wamp-proto.org/wamp_latest_ietf.html#name-subscribed-2)
10/// Represents an subscribed message in the WAMP protocol.
11/// ## Examples
12/// ```
13/// use wamp_core::messages::Subscribed;
14/// use wamp_core::subscribed;
15/// use serde_json::json;
16///
17/// # let mut subscribed_message2 = subscribed!(1, 2);
18///
19/// let subscribed_message = Subscribed {
20/// request_id: 1,
21/// subscription: 2
22/// };
23///
24/// # assert_eq!(subscribed_message, subscribed_message2);
25/// ```
26/// ### Serializer
27/// Implements serde Serialize trait for subscribed
28/// ```
29/// use wamp_core::messages::Subscribed;
30/// use serde_json::{json, to_string};
31///
32/// // Create an subscribed message
33/// let subscribed = Subscribed {
34/// request_id: 1,
35/// subscription: 2
36/// };
37///
38/// // Establish raw json data string
39/// let data = r#"[33,1,2]"#;
40///
41/// // Here we convert it from an `Subscribed` frame, to a string representation.
42/// let subscribed = to_string(&subscribed).unwrap();
43///
44/// // Confirm that our Subscribed frame strings are equal to each other
45/// assert_eq!(subscribed, data);
46/// ```
47/// ### Deserializer
48/// Implements serde Deserialize trait for Subscribed
49/// ```
50/// use wamp_core::messages::Subscribed;
51/// use serde_json::from_str;
52///
53/// // Here is our raw json data string
54/// let data = r#"[33,1,2]"#;
55///
56/// // Here we convert it to an `subscribed` frame
57/// let subscribed = from_str::<Subscribed>(data).unwrap();
58///
59/// // Confirm that our request_id and subscription deserialized
60/// assert_eq!(subscribed.request_id, 1);
61/// assert_eq!(subscribed.subscription, 2);
62/// ```
63pub struct Subscribed {
64 pub request_id: u64,
65 pub subscription: u64,
66}
67
68#[macro_export]
69/// # Subscribed Macro - [wamp-proto](https://wamp-proto.org/wamp_latest_ietf.html#name-subscribed-2)
70/// Macro that allows for creating subscribed wamp message.
71/// ## Examples
72/// ```
73/// use wamp_core::messages::{self, Subscribed};
74/// use wamp_core::subscribed;
75/// use serde_json::json;
76///
77/// let mut subscribed_message = subscribed!(1, 2);
78/// let subscribed_message2 = subscribed!(1, 3);
79///
80/// assert_ne!(subscribed_message, subscribed_message2);
81///
82/// // These macro invocations are the same as the following:
83/// let subscribed_message3 = Subscribed {
84/// request_id: 1,
85/// subscription: 2
86/// };
87///
88/// assert_eq!(subscribed_message, subscribed_message3);
89/// assert_ne!(subscribed_message2, subscribed_message3);
90/// ```
91macro_rules! subscribed {
92 ($request_id:expr, $subscription:expr) => {
93 Subscribed {
94 request_id: $request_id,
95 subscription: $subscription,
96 }
97 };
98}
99
100impl WampMessage for Subscribed {
101 const ID: u64 = 33;
102
103 fn direction(role: Roles) -> &'static MessageDirection {
104 match role {
105 Roles::Callee => &MessageDirection {
106 receives: &false,
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: &true,
119 sends: &false,
120 },
121 Roles::Dealer => &MessageDirection {
122 receives: &false,
123 sends: &false,
124 },
125 Roles::Broker => &MessageDirection {
126 receives: &false,
127 sends: &true,
128 },
129 }
130 }
131}
132
133impl Serialize for Subscribed {
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.subscription).serialize(serializer)
139 }
140}
141
142impl<'de> Deserialize<'de> for Subscribed {
143 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
144 where
145 D: Deserializer<'de>,
146 {
147 struct SubscribedVisitor(PhantomData<u64>, PhantomData<u64>, PhantomData<u64>);
148
149 impl<'vi> Visitor<'vi> for SubscribedVisitor {
150 type Value = Subscribed;
151 fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
152 formatter.write_str("A sequence of Subscribed 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::<Subscribed, A, _>(&message_id, "Subscribed")?;
164 let request_id: u64 = helpers::deser_seq_element(
165 &mut seq,
166 "request_id must be present and type u64.",
167 )?;
168 let subscription: u64 = helpers::deser_seq_element(
169 &mut seq,
170 "subscription must be present and object like.",
171 )?;
172 Ok(Subscribed {
173 request_id,
174 subscription,
175 })
176 }
177 }
178
179 deserializer.deserialize_struct(
180 "Subscribed",
181 &["request_id", "subscription"],
182 SubscribedVisitor(PhantomData, PhantomData, PhantomData),
183 )
184 }
185}