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 #[derive(Debug, Clone, PartialEq, Eq)]
27 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28 pub struct TestData {
29     r#type: u8,
30 }
31 #[derive(Debug, Clone, PartialEq, Eq)]
32 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33 pub struct Test {
34     #[cfg_attr(feature = "serde", serde(flatten))]
35     test: TestData,
36 }
37 #[derive(Debug)]
38 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
39 pub struct TestBuilder {
40     pub r#type: u8,
41 }
42 impl TestData {
conforms(bytes: &[u8]) -> bool43     fn conforms(bytes: &[u8]) -> bool {
44         bytes.len() >= 1
45     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>46     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
47         let mut cell = Cell::new(bytes);
48         let packet = Self::parse_inner(&mut cell)?;
49         Ok(packet)
50     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>51     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
52         if bytes.get().remaining() < 1 {
53             return Err(DecodeError::InvalidLengthError {
54                 obj: "Test",
55                 wanted: 1,
56                 got: bytes.get().remaining(),
57             });
58         }
59         let r#type = bytes.get_mut().get_u8();
60         Ok(Self { r#type })
61     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>62     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
63         buffer.put_u8(self.r#type);
64         Ok(())
65     }
get_total_size(&self) -> usize66     fn get_total_size(&self) -> usize {
67         self.get_size()
68     }
get_size(&self) -> usize69     fn get_size(&self) -> usize {
70         1
71     }
72 }
73 impl Packet for Test {
encoded_len(&self) -> usize74     fn encoded_len(&self) -> usize {
75         self.get_size()
76     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>77     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
78         self.test.write_to(buf)
79     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>80     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
81         unimplemented!("Rust legacy does not implement full packet trait")
82     }
83 }
84 impl TryFrom<Test> for Bytes {
85     type Error = EncodeError;
try_from(packet: Test) -> Result<Self, Self::Error>86     fn try_from(packet: Test) -> Result<Self, Self::Error> {
87         packet.encode_to_bytes()
88     }
89 }
90 impl TryFrom<Test> for Vec<u8> {
91     type Error = EncodeError;
try_from(packet: Test) -> Result<Self, Self::Error>92     fn try_from(packet: Test) -> Result<Self, Self::Error> {
93         packet.encode_to_vec()
94     }
95 }
96 impl Test {
parse(bytes: &[u8]) -> Result<Self, DecodeError>97     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
98         let mut cell = Cell::new(bytes);
99         let packet = Self::parse_inner(&mut cell)?;
100         Ok(packet)
101     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>102     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
103         let data = TestData::parse_inner(&mut bytes)?;
104         Self::new(data)
105     }
new(test: TestData) -> Result<Self, DecodeError>106     fn new(test: TestData) -> Result<Self, DecodeError> {
107         Ok(Self { test })
108     }
get_type(&self) -> u8109     pub fn get_type(&self) -> u8 {
110         self.test.r#type
111     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>112     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
113         self.test.write_to(buffer)
114     }
get_size(&self) -> usize115     pub fn get_size(&self) -> usize {
116         self.test.get_size()
117     }
118 }
119 impl TestBuilder {
build(self) -> Test120     pub fn build(self) -> Test {
121         let test = TestData { r#type: self.r#type };
122         Test::new(test).unwrap()
123     }
124 }
125 impl From<TestBuilder> for Test {
from(builder: TestBuilder) -> Test126     fn from(builder: TestBuilder) -> Test {
127         builder.build().into()
128     }
129 }
130