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 Enum7 { 31 A = 0x1, 32 B = 0x2, 33 } 34 impl TryFrom<u8> for Enum7 { 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 0x1 => Ok(Enum7::A), 39 0x2 => Ok(Enum7::B), 40 _ => Err(value), 41 } 42 } 43 } 44 impl From<&Enum7> for u8 { from(value: &Enum7) -> Self45 fn from(value: &Enum7) -> Self { 46 match value { 47 Enum7::A => 0x1, 48 Enum7::B => 0x2, 49 } 50 } 51 } 52 impl From<Enum7> for u8 { from(value: Enum7) -> Self53 fn from(value: Enum7) -> Self { 54 (&value).into() 55 } 56 } 57 impl From<Enum7> for i8 { from(value: Enum7) -> Self58 fn from(value: Enum7) -> Self { 59 u8::from(value) as Self 60 } 61 } 62 impl From<Enum7> for i16 { from(value: Enum7) -> Self63 fn from(value: Enum7) -> Self { 64 u8::from(value) as Self 65 } 66 } 67 impl From<Enum7> for i32 { from(value: Enum7) -> Self68 fn from(value: Enum7) -> Self { 69 u8::from(value) as Self 70 } 71 } 72 impl From<Enum7> for i64 { from(value: Enum7) -> Self73 fn from(value: Enum7) -> Self { 74 u8::from(value) as Self 75 } 76 } 77 impl From<Enum7> for u16 { from(value: Enum7) -> Self78 fn from(value: Enum7) -> Self { 79 u8::from(value) as Self 80 } 81 } 82 impl From<Enum7> for u32 { from(value: Enum7) -> Self83 fn from(value: Enum7) -> Self { 84 u8::from(value) as Self 85 } 86 } 87 impl From<Enum7> for u64 { from(value: Enum7) -> Self88 fn from(value: Enum7) -> Self { 89 u8::from(value) as Self 90 } 91 } 92 #[derive(Debug, Clone, PartialEq, Eq)] 93 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] 94 pub struct FooData { 95 b: u64, 96 } 97 #[derive(Debug, Clone, PartialEq, Eq)] 98 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] 99 pub struct Foo { 100 #[cfg_attr(feature = "serde", serde(flatten))] 101 foo: FooData, 102 } 103 #[derive(Debug)] 104 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] 105 pub struct FooBuilder { 106 pub b: u64, 107 } 108 impl FooData { conforms(bytes: &[u8]) -> bool109 fn conforms(bytes: &[u8]) -> bool { 110 bytes.len() >= 8 111 } parse(bytes: &[u8]) -> Result<Self, DecodeError>112 fn parse(bytes: &[u8]) -> Result<Self, DecodeError> { 113 let mut cell = Cell::new(bytes); 114 let packet = Self::parse_inner(&mut cell)?; 115 Ok(packet) 116 } parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>117 fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> { 118 if bytes.get().remaining() < 8 { 119 return Err(DecodeError::InvalidLengthError { 120 obj: "Foo", 121 wanted: 8, 122 got: bytes.get().remaining(), 123 }); 124 } 125 let chunk = bytes.get_mut().get_u64(); 126 let fixed_value = (chunk & 0x7f) as u8; 127 if fixed_value != u8::from(Enum7::A) { 128 return Err(DecodeError::InvalidFixedValue { 129 expected: u8::from(Enum7::A) as u64, 130 actual: fixed_value as u64, 131 }); 132 } 133 let b = ((chunk >> 7) & 0x1ff_ffff_ffff_ffff_u64); 134 Ok(Self { b }) 135 } write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>136 fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> { 137 if self.b > 0x1ff_ffff_ffff_ffff_u64 { 138 return Err(EncodeError::InvalidScalarValue { 139 packet: "Foo", 140 field: "b", 141 value: self.b as u64, 142 maximum_value: 0x1ff_ffff_ffff_ffff_u64, 143 }); 144 } 145 let value = (u8::from(Enum7::A) as u64) | (self.b << 7); 146 buffer.put_u64(value); 147 Ok(()) 148 } get_total_size(&self) -> usize149 fn get_total_size(&self) -> usize { 150 self.get_size() 151 } get_size(&self) -> usize152 fn get_size(&self) -> usize { 153 8 154 } 155 } 156 impl Packet for Foo { encoded_len(&self) -> usize157 fn encoded_len(&self) -> usize { 158 self.get_size() 159 } encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>160 fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> { 161 self.foo.write_to(buf) 162 } decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>163 fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> { 164 unimplemented!("Rust legacy does not implement full packet trait") 165 } 166 } 167 impl TryFrom<Foo> for Bytes { 168 type Error = EncodeError; try_from(packet: Foo) -> Result<Self, Self::Error>169 fn try_from(packet: Foo) -> Result<Self, Self::Error> { 170 packet.encode_to_bytes() 171 } 172 } 173 impl TryFrom<Foo> for Vec<u8> { 174 type Error = EncodeError; try_from(packet: Foo) -> Result<Self, Self::Error>175 fn try_from(packet: Foo) -> Result<Self, Self::Error> { 176 packet.encode_to_vec() 177 } 178 } 179 impl Foo { parse(bytes: &[u8]) -> Result<Self, DecodeError>180 pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> { 181 let mut cell = Cell::new(bytes); 182 let packet = Self::parse_inner(&mut cell)?; 183 Ok(packet) 184 } parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>185 fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> { 186 let data = FooData::parse_inner(&mut bytes)?; 187 Self::new(data) 188 } new(foo: FooData) -> Result<Self, DecodeError>189 fn new(foo: FooData) -> Result<Self, DecodeError> { 190 Ok(Self { foo }) 191 } get_b(&self) -> u64192 pub fn get_b(&self) -> u64 { 193 self.foo.b 194 } write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>195 fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> { 196 self.foo.write_to(buffer) 197 } get_size(&self) -> usize198 pub fn get_size(&self) -> usize { 199 self.foo.get_size() 200 } 201 } 202 impl FooBuilder { build(self) -> Foo203 pub fn build(self) -> Foo { 204 let foo = FooData { b: self.b }; 205 Foo::new(foo).unwrap() 206 } 207 } 208 impl From<FooBuilder> for Foo { from(builder: FooBuilder) -> Foo209 fn from(builder: FooBuilder) -> Foo { 210 builder.build().into() 211 } 212 } 213