1//! Serialization for client-server communication.
2
3use std::any::Any;
4use std::io::Write;
5use std::num::NonZero;
6
7pub(super) type Writer = super::buffer::Buffer;
8
9pub(super) trait Encode<S>: Sized {
10 fn encode(self, w: &mut Writer, s: &mut S);
11}
12
13pub(super) type Reader<'a> = &'a [u8];
14
15pub(super) trait Decode<'a, 's, S>: Sized {
16 fn decode(r: &mut Reader<'a>, s: &'s mut S) -> Self;
17}
18
19macro_rules! rpc_encode_decode {
20 (le $ty:ty) => {
21 impl<S> Encode<S> for $ty {
22 fn encode(self, w: &mut Writer, _: &mut S) {
23 w.extend_from_array(&self.to_le_bytes());
24 }
25 }
26
27 impl<S> Decode<'_, '_, S> for $ty {
28 fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {
29 const N: usize = size_of::<$ty>();
30
31 let mut bytes = [0; N];
32 bytes.copy_from_slice(&r[..N]);
33 *r = &r[N..];
34
35 Self::from_le_bytes(bytes)
36 }
37 }
38 };
39 (struct $name:ident $(<$($T:ident),+>)? { $($field:ident),* $(,)? }) => {
40 impl<S, $($($T: Encode<S>),+)?> Encode<S> for $name $(<$($T),+>)? {
41 fn encode(self, w: &mut Writer, s: &mut S) {
42 $(self.$field.encode(w, s);)*
43 }
44 }
45
46 impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>
47 for $name $(<$($T),+>)?
48 {
49 fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
50 $name {
51 $($field: Decode::decode(r, s)),*
52 }
53 }
54 }
55 };
56 (enum $name:ident $(<$($T:ident),+>)? { $($variant:ident $(($field:ident))*),* $(,)? }) => {
57 impl<S, $($($T: Encode<S>),+)?> Encode<S> for $name $(<$($T),+>)? {
58 fn encode(self, w: &mut Writer, s: &mut S) {
59 // HACK(eddyb): `Tag` enum duplicated between the
60 // two impls as there's no other place to stash it.
61 #[repr(u8)] enum Tag { $($variant),* }
62
63 match self {
64 $($name::$variant $(($field))* => {
65 (Tag::$variant as u8).encode(w, s);
66 $($field.encode(w, s);)*
67 })*
68 }
69 }
70 }
71
72 impl<'a, S, $($($T: for<'s> Decode<'a, 's, S>),+)?> Decode<'a, '_, S>
73 for $name $(<$($T),+>)?
74 {
75 fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
76 // HACK(eddyb): `Tag` enum duplicated between the
77 // two impls as there's no other place to stash it.
78 #[allow(non_upper_case_globals)]
79 mod tag {
80 #[repr(u8)] enum Tag { $($variant),* }
81
82 $(pub(crate) const $variant: u8 = Tag::$variant as u8;)*
83 }
84
85 match u8::decode(r, s) {
86 $(tag::$variant => {
87 $(let $field = Decode::decode(r, s);)*
88 $name::$variant $(($field))*
89 })*
90 _ => unreachable!(),
91 }
92 }
93 }
94 }
95}
96
97impl<S> Encode<S> for () {
98 fn encode(self, _: &mut Writer, _: &mut S) {}
99}
100
101impl<S> Decode<'_, '_, S> for () {
102 fn decode(_: &mut Reader<'_>, _: &mut S) -> Self {}
103}
104
105impl<S> Encode<S> for u8 {
106 fn encode(self, w: &mut Writer, _: &mut S) {
107 w.push(self);
108 }
109}
110
111impl<S> Decode<'_, '_, S> for u8 {
112 fn decode(r: &mut Reader<'_>, _: &mut S) -> Self {
113 let x: u8 = r[0];
114 *r = &r[1..];
115 x
116 }
117}
118
119rpc_encode_decode!(le u32);
120rpc_encode_decode!(le usize);
121
122impl<S> Encode<S> for bool {
123 fn encode(self, w: &mut Writer, s: &mut S) {
124 (self as u8).encode(w, s);
125 }
126}
127
128impl<S> Decode<'_, '_, S> for bool {
129 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
130 match u8::decode(r, s) {
131 0 => false,
132 1 => true,
133 _ => unreachable!(),
134 }
135 }
136}
137
138impl<S> Encode<S> for char {
139 fn encode(self, w: &mut Writer, s: &mut S) {
140 (self as u32).encode(w, s);
141 }
142}
143
144impl<S> Decode<'_, '_, S> for char {
145 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
146 char::from_u32(u32::decode(r, s)).unwrap()
147 }
148}
149
150impl<S> Encode<S> for NonZero<u32> {
151 fn encode(self, w: &mut Writer, s: &mut S) {
152 self.get().encode(w, s);
153 }
154}
155
156impl<S> Decode<'_, '_, S> for NonZero<u32> {
157 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
158 Self::new(u32::decode(r, s)).unwrap()
159 }
160}
161
162impl<S, A: Encode<S>, B: Encode<S>> Encode<S> for (A, B) {
163 fn encode(self, w: &mut Writer, s: &mut S) {
164 self.0.encode(w, s);
165 self.1.encode(w, s);
166 }
167}
168
169impl<'a, S, A: for<'s> Decode<'a, 's, S>, B: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S>
170 for (A, B)
171{
172 fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
173 (Decode::decode(r, s), Decode::decode(r, s))
174 }
175}
176
177impl<S> Encode<S> for &[u8] {
178 fn encode(self, w: &mut Writer, s: &mut S) {
179 self.len().encode(w, s);
180 w.write_all(self).unwrap();
181 }
182}
183
184impl<'a, S> Decode<'a, '_, S> for &'a [u8] {
185 fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
186 let len: usize = usize::decode(r, s);
187 let xs: &[u8] = &r[..len];
188 *r = &r[len..];
189 xs
190 }
191}
192
193impl<S> Encode<S> for &str {
194 fn encode(self, w: &mut Writer, s: &mut S) {
195 self.as_bytes().encode(w, s);
196 }
197}
198
199impl<'a, S> Decode<'a, '_, S> for &'a str {
200 fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
201 str::from_utf8(<&[u8]>::decode(r, s)).unwrap()
202 }
203}
204
205impl<S> Encode<S> for String {
206 fn encode(self, w: &mut Writer, s: &mut S) {
207 self[..].encode(w, s);
208 }
209}
210
211impl<S> Decode<'_, '_, S> for String {
212 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
213 <&str>::decode(r, s).to_string()
214 }
215}
216
217impl<S, T: Encode<S>> Encode<S> for Vec<T> {
218 fn encode(self, w: &mut Writer, s: &mut S) {
219 self.len().encode(w, s);
220 for x: T in self {
221 x.encode(w, s);
222 }
223 }
224}
225
226impl<'a, S, T: for<'s> Decode<'a, 's, S>> Decode<'a, '_, S> for Vec<T> {
227 fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
228 let len: usize = usize::decode(r, s);
229 let mut vec: Vec = Vec::with_capacity(len);
230 for _ in 0..len {
231 vec.push(T::decode(r, s));
232 }
233 vec
234 }
235}
236
237/// Simplified version of panic payloads, ignoring
238/// types other than `&'static str` and `String`.
239pub enum PanicMessage {
240 StaticStr(&'static str),
241 String(String),
242 Unknown,
243}
244
245impl From<Box<dyn Any + Send>> for PanicMessage {
246 fn from(payload: Box<dyn Any + Send + 'static>) -> Self {
247 if let Some(s: &&str) = payload.downcast_ref::<&'static str>() {
248 return PanicMessage::StaticStr(s);
249 }
250 if let Ok(s: Box) = payload.downcast::<String>() {
251 return PanicMessage::String(*s);
252 }
253 PanicMessage::Unknown
254 }
255}
256
257impl From<PanicMessage> for Box<dyn Any + Send> {
258 fn from(val: PanicMessage) -> Self {
259 match val {
260 PanicMessage::StaticStr(s: &'static str) => Box::new(s),
261 PanicMessage::String(s: String) => Box::new(s),
262 PanicMessage::Unknown => {
263 struct UnknownPanicMessage;
264 Box::new(UnknownPanicMessage)
265 }
266 }
267 }
268}
269
270impl PanicMessage {
271 pub fn as_str(&self) -> Option<&str> {
272 match self {
273 PanicMessage::StaticStr(s: &&'static str) => Some(s),
274 PanicMessage::String(s: &String) => Some(s),
275 PanicMessage::Unknown => None,
276 }
277 }
278}
279
280impl<S> Encode<S> for PanicMessage {
281 fn encode(self, w: &mut Writer, s: &mut S) {
282 self.as_str().encode(w, s);
283 }
284}
285
286impl<S> Decode<'_, '_, S> for PanicMessage {
287 fn decode(r: &mut Reader<'_>, s: &mut S) -> Self {
288 match Option::<String>::decode(r, s) {
289 Some(s: String) => PanicMessage::String(s),
290 None => PanicMessage::Unknown,
291 }
292 }
293}
294