1 #![rustfmt::skip]
2 /// @generated rust packets from test.
3 use bytes::{Buf, BufMut, Bytes, BytesMut};
4 use std::convert::{TryFrom, TryInto};
5 use std::cell::Cell;
6 use std::fmt;
7 use std::result::Result;
8 use pdl_runtime::{DecodeError, EncodeError, Packet};
9 /// Private prevents users from creating arbitrary scalar values
10 /// in situations where the value needs to be validated.
11 /// Users can freely deref the value, but only the backend
12 /// may create it.
13 #[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
14 pub struct Private<T>(T);
15 impl<T> std::ops::Deref for Private<T> {
16     type Target = T;
deref(&self) -> &Self::Target17     fn deref(&self) -> &Self::Target {
18         &self.0
19     }
20 }
21 impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result22     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
23         T::fmt(&self.0, f)
24     }
25 }
26 #[repr(u64)]
27 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
28 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
30 pub enum IncompleteTruncatedClosed {
31     A = 0x0,
32     B = 0x1,
33 }
34 impl TryFrom<u8> for IncompleteTruncatedClosed {
35     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>36     fn try_from(value: u8) -> Result<Self, Self::Error> {
37         match value {
38             0x0 => Ok(IncompleteTruncatedClosed::A),
39             0x1 => Ok(IncompleteTruncatedClosed::B),
40             _ => Err(value),
41         }
42     }
43 }
44 impl From<&IncompleteTruncatedClosed> for u8 {
from(value: &IncompleteTruncatedClosed) -> Self45     fn from(value: &IncompleteTruncatedClosed) -> Self {
46         match value {
47             IncompleteTruncatedClosed::A => 0x0,
48             IncompleteTruncatedClosed::B => 0x1,
49         }
50     }
51 }
52 impl From<IncompleteTruncatedClosed> for u8 {
from(value: IncompleteTruncatedClosed) -> Self53     fn from(value: IncompleteTruncatedClosed) -> Self {
54         (&value).into()
55     }
56 }
57 impl From<IncompleteTruncatedClosed> for i8 {
from(value: IncompleteTruncatedClosed) -> Self58     fn from(value: IncompleteTruncatedClosed) -> Self {
59         u8::from(value) as Self
60     }
61 }
62 impl From<IncompleteTruncatedClosed> for i16 {
from(value: IncompleteTruncatedClosed) -> Self63     fn from(value: IncompleteTruncatedClosed) -> Self {
64         u8::from(value) as Self
65     }
66 }
67 impl From<IncompleteTruncatedClosed> for i32 {
from(value: IncompleteTruncatedClosed) -> Self68     fn from(value: IncompleteTruncatedClosed) -> Self {
69         u8::from(value) as Self
70     }
71 }
72 impl From<IncompleteTruncatedClosed> for i64 {
from(value: IncompleteTruncatedClosed) -> Self73     fn from(value: IncompleteTruncatedClosed) -> Self {
74         u8::from(value) as Self
75     }
76 }
77 impl From<IncompleteTruncatedClosed> for u16 {
from(value: IncompleteTruncatedClosed) -> Self78     fn from(value: IncompleteTruncatedClosed) -> Self {
79         u8::from(value) as Self
80     }
81 }
82 impl From<IncompleteTruncatedClosed> for u32 {
from(value: IncompleteTruncatedClosed) -> Self83     fn from(value: IncompleteTruncatedClosed) -> Self {
84         u8::from(value) as Self
85     }
86 }
87 impl From<IncompleteTruncatedClosed> for u64 {
from(value: IncompleteTruncatedClosed) -> Self88     fn from(value: IncompleteTruncatedClosed) -> Self {
89         u8::from(value) as Self
90     }
91 }
92 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
93 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
94 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
95 pub enum IncompleteTruncatedOpen {
96     A,
97     B,
98     Unknown(Private<u8>),
99 }
100 impl TryFrom<u8> for IncompleteTruncatedOpen {
101     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>102     fn try_from(value: u8) -> Result<Self, Self::Error> {
103         match value {
104             0x0 => Ok(IncompleteTruncatedOpen::A),
105             0x1 => Ok(IncompleteTruncatedOpen::B),
106             0..=0x7 => Ok(IncompleteTruncatedOpen::Unknown(Private(value))),
107             _ => Err(value),
108         }
109     }
110 }
111 impl From<&IncompleteTruncatedOpen> for u8 {
from(value: &IncompleteTruncatedOpen) -> Self112     fn from(value: &IncompleteTruncatedOpen) -> Self {
113         match value {
114             IncompleteTruncatedOpen::A => 0x0,
115             IncompleteTruncatedOpen::B => 0x1,
116             IncompleteTruncatedOpen::Unknown(Private(value)) => *value,
117         }
118     }
119 }
120 impl From<IncompleteTruncatedOpen> for u8 {
from(value: IncompleteTruncatedOpen) -> Self121     fn from(value: IncompleteTruncatedOpen) -> Self {
122         (&value).into()
123     }
124 }
125 impl From<IncompleteTruncatedOpen> for i8 {
from(value: IncompleteTruncatedOpen) -> Self126     fn from(value: IncompleteTruncatedOpen) -> Self {
127         u8::from(value) as Self
128     }
129 }
130 impl From<IncompleteTruncatedOpen> for i16 {
from(value: IncompleteTruncatedOpen) -> Self131     fn from(value: IncompleteTruncatedOpen) -> Self {
132         u8::from(value) as Self
133     }
134 }
135 impl From<IncompleteTruncatedOpen> for i32 {
from(value: IncompleteTruncatedOpen) -> Self136     fn from(value: IncompleteTruncatedOpen) -> Self {
137         u8::from(value) as Self
138     }
139 }
140 impl From<IncompleteTruncatedOpen> for i64 {
from(value: IncompleteTruncatedOpen) -> Self141     fn from(value: IncompleteTruncatedOpen) -> Self {
142         u8::from(value) as Self
143     }
144 }
145 impl From<IncompleteTruncatedOpen> for u16 {
from(value: IncompleteTruncatedOpen) -> Self146     fn from(value: IncompleteTruncatedOpen) -> Self {
147         u8::from(value) as Self
148     }
149 }
150 impl From<IncompleteTruncatedOpen> for u32 {
from(value: IncompleteTruncatedOpen) -> Self151     fn from(value: IncompleteTruncatedOpen) -> Self {
152         u8::from(value) as Self
153     }
154 }
155 impl From<IncompleteTruncatedOpen> for u64 {
from(value: IncompleteTruncatedOpen) -> Self156     fn from(value: IncompleteTruncatedOpen) -> Self {
157         u8::from(value) as Self
158     }
159 }
160 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
161 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
162 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
163 pub enum IncompleteTruncatedClosedWithRange {
164     A,
165     X,
166     Y,
167     B(Private<u8>),
168 }
169 impl TryFrom<u8> for IncompleteTruncatedClosedWithRange {
170     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>171     fn try_from(value: u8) -> Result<Self, Self::Error> {
172         match value {
173             0x0 => Ok(IncompleteTruncatedClosedWithRange::A),
174             0x1 => Ok(IncompleteTruncatedClosedWithRange::X),
175             0x2 => Ok(IncompleteTruncatedClosedWithRange::Y),
176             0x1..=0x6 => Ok(IncompleteTruncatedClosedWithRange::B(Private(value))),
177             _ => Err(value),
178         }
179     }
180 }
181 impl From<&IncompleteTruncatedClosedWithRange> for u8 {
from(value: &IncompleteTruncatedClosedWithRange) -> Self182     fn from(value: &IncompleteTruncatedClosedWithRange) -> Self {
183         match value {
184             IncompleteTruncatedClosedWithRange::A => 0x0,
185             IncompleteTruncatedClosedWithRange::X => 0x1,
186             IncompleteTruncatedClosedWithRange::Y => 0x2,
187             IncompleteTruncatedClosedWithRange::B(Private(value)) => *value,
188         }
189     }
190 }
191 impl From<IncompleteTruncatedClosedWithRange> for u8 {
from(value: IncompleteTruncatedClosedWithRange) -> Self192     fn from(value: IncompleteTruncatedClosedWithRange) -> Self {
193         (&value).into()
194     }
195 }
196 impl From<IncompleteTruncatedClosedWithRange> for i8 {
from(value: IncompleteTruncatedClosedWithRange) -> Self197     fn from(value: IncompleteTruncatedClosedWithRange) -> Self {
198         u8::from(value) as Self
199     }
200 }
201 impl From<IncompleteTruncatedClosedWithRange> for i16 {
from(value: IncompleteTruncatedClosedWithRange) -> Self202     fn from(value: IncompleteTruncatedClosedWithRange) -> Self {
203         u8::from(value) as Self
204     }
205 }
206 impl From<IncompleteTruncatedClosedWithRange> for i32 {
from(value: IncompleteTruncatedClosedWithRange) -> Self207     fn from(value: IncompleteTruncatedClosedWithRange) -> Self {
208         u8::from(value) as Self
209     }
210 }
211 impl From<IncompleteTruncatedClosedWithRange> for i64 {
from(value: IncompleteTruncatedClosedWithRange) -> Self212     fn from(value: IncompleteTruncatedClosedWithRange) -> Self {
213         u8::from(value) as Self
214     }
215 }
216 impl From<IncompleteTruncatedClosedWithRange> for u16 {
from(value: IncompleteTruncatedClosedWithRange) -> Self217     fn from(value: IncompleteTruncatedClosedWithRange) -> Self {
218         u8::from(value) as Self
219     }
220 }
221 impl From<IncompleteTruncatedClosedWithRange> for u32 {
from(value: IncompleteTruncatedClosedWithRange) -> Self222     fn from(value: IncompleteTruncatedClosedWithRange) -> Self {
223         u8::from(value) as Self
224     }
225 }
226 impl From<IncompleteTruncatedClosedWithRange> for u64 {
from(value: IncompleteTruncatedClosedWithRange) -> Self227     fn from(value: IncompleteTruncatedClosedWithRange) -> Self {
228         u8::from(value) as Self
229     }
230 }
231 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
232 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
233 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
234 pub enum IncompleteTruncatedOpenWithRange {
235     A,
236     X,
237     Y,
238     B(Private<u8>),
239     Unknown(Private<u8>),
240 }
241 impl TryFrom<u8> for IncompleteTruncatedOpenWithRange {
242     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>243     fn try_from(value: u8) -> Result<Self, Self::Error> {
244         match value {
245             0x0 => Ok(IncompleteTruncatedOpenWithRange::A),
246             0x1 => Ok(IncompleteTruncatedOpenWithRange::X),
247             0x2 => Ok(IncompleteTruncatedOpenWithRange::Y),
248             0x1..=0x6 => Ok(IncompleteTruncatedOpenWithRange::B(Private(value))),
249             0..=0x7 => Ok(IncompleteTruncatedOpenWithRange::Unknown(Private(value))),
250             _ => Err(value),
251         }
252     }
253 }
254 impl From<&IncompleteTruncatedOpenWithRange> for u8 {
from(value: &IncompleteTruncatedOpenWithRange) -> Self255     fn from(value: &IncompleteTruncatedOpenWithRange) -> Self {
256         match value {
257             IncompleteTruncatedOpenWithRange::A => 0x0,
258             IncompleteTruncatedOpenWithRange::X => 0x1,
259             IncompleteTruncatedOpenWithRange::Y => 0x2,
260             IncompleteTruncatedOpenWithRange::B(Private(value)) => *value,
261             IncompleteTruncatedOpenWithRange::Unknown(Private(value)) => *value,
262         }
263     }
264 }
265 impl From<IncompleteTruncatedOpenWithRange> for u8 {
from(value: IncompleteTruncatedOpenWithRange) -> Self266     fn from(value: IncompleteTruncatedOpenWithRange) -> Self {
267         (&value).into()
268     }
269 }
270 impl From<IncompleteTruncatedOpenWithRange> for i8 {
from(value: IncompleteTruncatedOpenWithRange) -> Self271     fn from(value: IncompleteTruncatedOpenWithRange) -> Self {
272         u8::from(value) as Self
273     }
274 }
275 impl From<IncompleteTruncatedOpenWithRange> for i16 {
from(value: IncompleteTruncatedOpenWithRange) -> Self276     fn from(value: IncompleteTruncatedOpenWithRange) -> Self {
277         u8::from(value) as Self
278     }
279 }
280 impl From<IncompleteTruncatedOpenWithRange> for i32 {
from(value: IncompleteTruncatedOpenWithRange) -> Self281     fn from(value: IncompleteTruncatedOpenWithRange) -> Self {
282         u8::from(value) as Self
283     }
284 }
285 impl From<IncompleteTruncatedOpenWithRange> for i64 {
from(value: IncompleteTruncatedOpenWithRange) -> Self286     fn from(value: IncompleteTruncatedOpenWithRange) -> Self {
287         u8::from(value) as Self
288     }
289 }
290 impl From<IncompleteTruncatedOpenWithRange> for u16 {
from(value: IncompleteTruncatedOpenWithRange) -> Self291     fn from(value: IncompleteTruncatedOpenWithRange) -> Self {
292         u8::from(value) as Self
293     }
294 }
295 impl From<IncompleteTruncatedOpenWithRange> for u32 {
from(value: IncompleteTruncatedOpenWithRange) -> Self296     fn from(value: IncompleteTruncatedOpenWithRange) -> Self {
297         u8::from(value) as Self
298     }
299 }
300 impl From<IncompleteTruncatedOpenWithRange> for u64 {
from(value: IncompleteTruncatedOpenWithRange) -> Self301     fn from(value: IncompleteTruncatedOpenWithRange) -> Self {
302         u8::from(value) as Self
303     }
304 }
305 #[repr(u64)]
306 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
307 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
308 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
309 pub enum CompleteTruncated {
310     A = 0x0,
311     B = 0x1,
312     C = 0x2,
313     D = 0x3,
314     E = 0x4,
315     F = 0x5,
316     G = 0x6,
317     H = 0x7,
318 }
319 impl TryFrom<u8> for CompleteTruncated {
320     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>321     fn try_from(value: u8) -> Result<Self, Self::Error> {
322         match value {
323             0x0 => Ok(CompleteTruncated::A),
324             0x1 => Ok(CompleteTruncated::B),
325             0x2 => Ok(CompleteTruncated::C),
326             0x3 => Ok(CompleteTruncated::D),
327             0x4 => Ok(CompleteTruncated::E),
328             0x5 => Ok(CompleteTruncated::F),
329             0x6 => Ok(CompleteTruncated::G),
330             0x7 => Ok(CompleteTruncated::H),
331             _ => Err(value),
332         }
333     }
334 }
335 impl From<&CompleteTruncated> for u8 {
from(value: &CompleteTruncated) -> Self336     fn from(value: &CompleteTruncated) -> Self {
337         match value {
338             CompleteTruncated::A => 0x0,
339             CompleteTruncated::B => 0x1,
340             CompleteTruncated::C => 0x2,
341             CompleteTruncated::D => 0x3,
342             CompleteTruncated::E => 0x4,
343             CompleteTruncated::F => 0x5,
344             CompleteTruncated::G => 0x6,
345             CompleteTruncated::H => 0x7,
346         }
347     }
348 }
349 impl From<CompleteTruncated> for u8 {
from(value: CompleteTruncated) -> Self350     fn from(value: CompleteTruncated) -> Self {
351         (&value).into()
352     }
353 }
354 impl From<CompleteTruncated> for i8 {
from(value: CompleteTruncated) -> Self355     fn from(value: CompleteTruncated) -> Self {
356         u8::from(value) as Self
357     }
358 }
359 impl From<CompleteTruncated> for i16 {
from(value: CompleteTruncated) -> Self360     fn from(value: CompleteTruncated) -> Self {
361         u8::from(value) as Self
362     }
363 }
364 impl From<CompleteTruncated> for i32 {
from(value: CompleteTruncated) -> Self365     fn from(value: CompleteTruncated) -> Self {
366         u8::from(value) as Self
367     }
368 }
369 impl From<CompleteTruncated> for i64 {
from(value: CompleteTruncated) -> Self370     fn from(value: CompleteTruncated) -> Self {
371         u8::from(value) as Self
372     }
373 }
374 impl From<CompleteTruncated> for u16 {
from(value: CompleteTruncated) -> Self375     fn from(value: CompleteTruncated) -> Self {
376         u8::from(value) as Self
377     }
378 }
379 impl From<CompleteTruncated> for u32 {
from(value: CompleteTruncated) -> Self380     fn from(value: CompleteTruncated) -> Self {
381         u8::from(value) as Self
382     }
383 }
384 impl From<CompleteTruncated> for u64 {
from(value: CompleteTruncated) -> Self385     fn from(value: CompleteTruncated) -> Self {
386         u8::from(value) as Self
387     }
388 }
389 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
390 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
391 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
392 pub enum CompleteTruncatedWithRange {
393     A,
394     X,
395     Y,
396     B(Private<u8>),
397 }
398 impl TryFrom<u8> for CompleteTruncatedWithRange {
399     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>400     fn try_from(value: u8) -> Result<Self, Self::Error> {
401         match value {
402             0x0 => Ok(CompleteTruncatedWithRange::A),
403             0x1 => Ok(CompleteTruncatedWithRange::X),
404             0x2 => Ok(CompleteTruncatedWithRange::Y),
405             0x1..=0x7 => Ok(CompleteTruncatedWithRange::B(Private(value))),
406             _ => Err(value),
407         }
408     }
409 }
410 impl From<&CompleteTruncatedWithRange> for u8 {
from(value: &CompleteTruncatedWithRange) -> Self411     fn from(value: &CompleteTruncatedWithRange) -> Self {
412         match value {
413             CompleteTruncatedWithRange::A => 0x0,
414             CompleteTruncatedWithRange::X => 0x1,
415             CompleteTruncatedWithRange::Y => 0x2,
416             CompleteTruncatedWithRange::B(Private(value)) => *value,
417         }
418     }
419 }
420 impl From<CompleteTruncatedWithRange> for u8 {
from(value: CompleteTruncatedWithRange) -> Self421     fn from(value: CompleteTruncatedWithRange) -> Self {
422         (&value).into()
423     }
424 }
425 impl From<CompleteTruncatedWithRange> for i8 {
from(value: CompleteTruncatedWithRange) -> Self426     fn from(value: CompleteTruncatedWithRange) -> Self {
427         u8::from(value) as Self
428     }
429 }
430 impl From<CompleteTruncatedWithRange> for i16 {
from(value: CompleteTruncatedWithRange) -> Self431     fn from(value: CompleteTruncatedWithRange) -> Self {
432         u8::from(value) as Self
433     }
434 }
435 impl From<CompleteTruncatedWithRange> for i32 {
from(value: CompleteTruncatedWithRange) -> Self436     fn from(value: CompleteTruncatedWithRange) -> Self {
437         u8::from(value) as Self
438     }
439 }
440 impl From<CompleteTruncatedWithRange> for i64 {
from(value: CompleteTruncatedWithRange) -> Self441     fn from(value: CompleteTruncatedWithRange) -> Self {
442         u8::from(value) as Self
443     }
444 }
445 impl From<CompleteTruncatedWithRange> for u16 {
from(value: CompleteTruncatedWithRange) -> Self446     fn from(value: CompleteTruncatedWithRange) -> Self {
447         u8::from(value) as Self
448     }
449 }
450 impl From<CompleteTruncatedWithRange> for u32 {
from(value: CompleteTruncatedWithRange) -> Self451     fn from(value: CompleteTruncatedWithRange) -> Self {
452         u8::from(value) as Self
453     }
454 }
455 impl From<CompleteTruncatedWithRange> for u64 {
from(value: CompleteTruncatedWithRange) -> Self456     fn from(value: CompleteTruncatedWithRange) -> Self {
457         u8::from(value) as Self
458     }
459 }
460 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
461 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
462 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
463 pub enum CompleteWithRange {
464     A,
465     B,
466     C(Private<u8>),
467 }
468 impl TryFrom<u8> for CompleteWithRange {
469     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>470     fn try_from(value: u8) -> Result<Self, Self::Error> {
471         match value {
472             0x0 => Ok(CompleteWithRange::A),
473             0x1 => Ok(CompleteWithRange::B),
474             0x2..=0xff => Ok(CompleteWithRange::C(Private(value))),
475         }
476     }
477 }
478 impl From<&CompleteWithRange> for u8 {
from(value: &CompleteWithRange) -> Self479     fn from(value: &CompleteWithRange) -> Self {
480         match value {
481             CompleteWithRange::A => 0x0,
482             CompleteWithRange::B => 0x1,
483             CompleteWithRange::C(Private(value)) => *value,
484         }
485     }
486 }
487 impl From<CompleteWithRange> for u8 {
from(value: CompleteWithRange) -> Self488     fn from(value: CompleteWithRange) -> Self {
489         (&value).into()
490     }
491 }
492 impl From<CompleteWithRange> for i16 {
from(value: CompleteWithRange) -> Self493     fn from(value: CompleteWithRange) -> Self {
494         u8::from(value) as Self
495     }
496 }
497 impl From<CompleteWithRange> for i32 {
from(value: CompleteWithRange) -> Self498     fn from(value: CompleteWithRange) -> Self {
499         u8::from(value) as Self
500     }
501 }
502 impl From<CompleteWithRange> for i64 {
from(value: CompleteWithRange) -> Self503     fn from(value: CompleteWithRange) -> Self {
504         u8::from(value) as Self
505     }
506 }
507 impl From<CompleteWithRange> for u16 {
from(value: CompleteWithRange) -> Self508     fn from(value: CompleteWithRange) -> Self {
509         u8::from(value) as Self
510     }
511 }
512 impl From<CompleteWithRange> for u32 {
from(value: CompleteWithRange) -> Self513     fn from(value: CompleteWithRange) -> Self {
514         u8::from(value) as Self
515     }
516 }
517 impl From<CompleteWithRange> for u64 {
from(value: CompleteWithRange) -> Self518     fn from(value: CompleteWithRange) -> Self {
519         u8::from(value) as Self
520     }
521 }
522