1 /// @generated rust packets from uci_packets.pdl.
2 use bytes::{Buf, BufMut, Bytes, BytesMut};
3 use std::convert::{TryFrom, TryInto};
4 use std::cell::Cell;
5 use std::fmt;
6 use std::result::Result;
7 use pdl_runtime::{DecodeError, EncodeError, Packet};
8 /// Private prevents users from creating arbitrary scalar values
9 /// in situations where the value needs to be validated.
10 /// Users can freely deref the value, but only the backend
11 /// may create it.
12 #[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
13 pub struct Private<T>(T);
14 impl<T> std::ops::Deref for Private<T> {
15     type Target = T;
deref(&self) -> &Self::Target16     fn deref(&self) -> &Self::Target {
17         &self.0
18     }
19 }
20 impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result21     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
22         T::fmt(&self.0, f)
23     }
24 }
25 #[repr(u64)]
26 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
27 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
29 pub enum PacketBoundaryFlag {
30     Complete = 0x0,
31     NotComplete = 0x1,
32 }
33 impl TryFrom<u8> for PacketBoundaryFlag {
34     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>35     fn try_from(value: u8) -> Result<Self, Self::Error> {
36         match value {
37             0x0 => Ok(PacketBoundaryFlag::Complete),
38             0x1 => Ok(PacketBoundaryFlag::NotComplete),
39             _ => Err(value),
40         }
41     }
42 }
43 impl From<&PacketBoundaryFlag> for u8 {
from(value: &PacketBoundaryFlag) -> Self44     fn from(value: &PacketBoundaryFlag) -> Self {
45         match value {
46             PacketBoundaryFlag::Complete => 0x0,
47             PacketBoundaryFlag::NotComplete => 0x1,
48         }
49     }
50 }
51 impl From<PacketBoundaryFlag> for u8 {
from(value: PacketBoundaryFlag) -> Self52     fn from(value: PacketBoundaryFlag) -> Self {
53         (&value).into()
54     }
55 }
56 impl From<PacketBoundaryFlag> for i8 {
from(value: PacketBoundaryFlag) -> Self57     fn from(value: PacketBoundaryFlag) -> Self {
58         u8::from(value) as Self
59     }
60 }
61 impl From<PacketBoundaryFlag> for i16 {
from(value: PacketBoundaryFlag) -> Self62     fn from(value: PacketBoundaryFlag) -> Self {
63         u8::from(value) as Self
64     }
65 }
66 impl From<PacketBoundaryFlag> for i32 {
from(value: PacketBoundaryFlag) -> Self67     fn from(value: PacketBoundaryFlag) -> Self {
68         u8::from(value) as Self
69     }
70 }
71 impl From<PacketBoundaryFlag> for i64 {
from(value: PacketBoundaryFlag) -> Self72     fn from(value: PacketBoundaryFlag) -> Self {
73         u8::from(value) as Self
74     }
75 }
76 impl From<PacketBoundaryFlag> for u16 {
from(value: PacketBoundaryFlag) -> Self77     fn from(value: PacketBoundaryFlag) -> Self {
78         u8::from(value) as Self
79     }
80 }
81 impl From<PacketBoundaryFlag> for u32 {
from(value: PacketBoundaryFlag) -> Self82     fn from(value: PacketBoundaryFlag) -> Self {
83         u8::from(value) as Self
84     }
85 }
86 impl From<PacketBoundaryFlag> for u64 {
from(value: PacketBoundaryFlag) -> Self87     fn from(value: PacketBoundaryFlag) -> Self {
88         u8::from(value) as Self
89     }
90 }
91 #[repr(u64)]
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 GroupId {
96     Core = 0x0,
97     SessionConfig = 0x1,
98     SessionControl = 0x2,
99     DataControl = 0x3,
100     Test = 0xd,
101     VendorReserved9 = 0x9,
102     VendorReservedA = 0xa,
103     VendorReservedB = 0xb,
104     VendorAndroid = 0xc,
105     VendorReservedE = 0xe,
106     VendorReservedF = 0xf,
107 }
108 impl TryFrom<u8> for GroupId {
109     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>110     fn try_from(value: u8) -> Result<Self, Self::Error> {
111         match value {
112             0x0 => Ok(GroupId::Core),
113             0x1 => Ok(GroupId::SessionConfig),
114             0x2 => Ok(GroupId::SessionControl),
115             0x3 => Ok(GroupId::DataControl),
116             0xd => Ok(GroupId::Test),
117             0x9 => Ok(GroupId::VendorReserved9),
118             0xa => Ok(GroupId::VendorReservedA),
119             0xb => Ok(GroupId::VendorReservedB),
120             0xc => Ok(GroupId::VendorAndroid),
121             0xe => Ok(GroupId::VendorReservedE),
122             0xf => Ok(GroupId::VendorReservedF),
123             _ => Err(value),
124         }
125     }
126 }
127 impl From<&GroupId> for u8 {
from(value: &GroupId) -> Self128     fn from(value: &GroupId) -> Self {
129         match value {
130             GroupId::Core => 0x0,
131             GroupId::SessionConfig => 0x1,
132             GroupId::SessionControl => 0x2,
133             GroupId::DataControl => 0x3,
134             GroupId::Test => 0xd,
135             GroupId::VendorReserved9 => 0x9,
136             GroupId::VendorReservedA => 0xa,
137             GroupId::VendorReservedB => 0xb,
138             GroupId::VendorAndroid => 0xc,
139             GroupId::VendorReservedE => 0xe,
140             GroupId::VendorReservedF => 0xf,
141         }
142     }
143 }
144 impl From<GroupId> for u8 {
from(value: GroupId) -> Self145     fn from(value: GroupId) -> Self {
146         (&value).into()
147     }
148 }
149 impl From<GroupId> for i8 {
from(value: GroupId) -> Self150     fn from(value: GroupId) -> Self {
151         u8::from(value) as Self
152     }
153 }
154 impl From<GroupId> for i16 {
from(value: GroupId) -> Self155     fn from(value: GroupId) -> Self {
156         u8::from(value) as Self
157     }
158 }
159 impl From<GroupId> for i32 {
from(value: GroupId) -> Self160     fn from(value: GroupId) -> Self {
161         u8::from(value) as Self
162     }
163 }
164 impl From<GroupId> for i64 {
from(value: GroupId) -> Self165     fn from(value: GroupId) -> Self {
166         u8::from(value) as Self
167     }
168 }
169 impl From<GroupId> for u16 {
from(value: GroupId) -> Self170     fn from(value: GroupId) -> Self {
171         u8::from(value) as Self
172     }
173 }
174 impl From<GroupId> for u32 {
from(value: GroupId) -> Self175     fn from(value: GroupId) -> Self {
176         u8::from(value) as Self
177     }
178 }
179 impl From<GroupId> for u64 {
from(value: GroupId) -> Self180     fn from(value: GroupId) -> Self {
181         u8::from(value) as Self
182     }
183 }
184 #[repr(u64)]
185 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
186 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
187 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
188 pub enum DataPacketFormat {
189     DataSnd = 0x1,
190     DataRcv = 0x2,
191     RadarDataMessage = 0xf,
192 }
193 impl TryFrom<u8> for DataPacketFormat {
194     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>195     fn try_from(value: u8) -> Result<Self, Self::Error> {
196         match value {
197             0x1 => Ok(DataPacketFormat::DataSnd),
198             0x2 => Ok(DataPacketFormat::DataRcv),
199             0xf => Ok(DataPacketFormat::RadarDataMessage),
200             _ => Err(value),
201         }
202     }
203 }
204 impl From<&DataPacketFormat> for u8 {
from(value: &DataPacketFormat) -> Self205     fn from(value: &DataPacketFormat) -> Self {
206         match value {
207             DataPacketFormat::DataSnd => 0x1,
208             DataPacketFormat::DataRcv => 0x2,
209             DataPacketFormat::RadarDataMessage => 0xf,
210         }
211     }
212 }
213 impl From<DataPacketFormat> for u8 {
from(value: DataPacketFormat) -> Self214     fn from(value: DataPacketFormat) -> Self {
215         (&value).into()
216     }
217 }
218 impl From<DataPacketFormat> for i8 {
from(value: DataPacketFormat) -> Self219     fn from(value: DataPacketFormat) -> Self {
220         u8::from(value) as Self
221     }
222 }
223 impl From<DataPacketFormat> for i16 {
from(value: DataPacketFormat) -> Self224     fn from(value: DataPacketFormat) -> Self {
225         u8::from(value) as Self
226     }
227 }
228 impl From<DataPacketFormat> for i32 {
from(value: DataPacketFormat) -> Self229     fn from(value: DataPacketFormat) -> Self {
230         u8::from(value) as Self
231     }
232 }
233 impl From<DataPacketFormat> for i64 {
from(value: DataPacketFormat) -> Self234     fn from(value: DataPacketFormat) -> Self {
235         u8::from(value) as Self
236     }
237 }
238 impl From<DataPacketFormat> for u16 {
from(value: DataPacketFormat) -> Self239     fn from(value: DataPacketFormat) -> Self {
240         u8::from(value) as Self
241     }
242 }
243 impl From<DataPacketFormat> for u32 {
from(value: DataPacketFormat) -> Self244     fn from(value: DataPacketFormat) -> Self {
245         u8::from(value) as Self
246     }
247 }
248 impl From<DataPacketFormat> for u64 {
from(value: DataPacketFormat) -> Self249     fn from(value: DataPacketFormat) -> Self {
250         u8::from(value) as Self
251     }
252 }
253 #[repr(u64)]
254 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
255 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
256 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
257 pub enum GroupIdOrDataPacketFormat {
258     Core = 0x0,
259     SessionConfigOrDataSnd = 0x1,
260     SessionControlOrDataRcv = 0x2,
261     DataControl = 0x3,
262     Test = 0xd,
263     VendorReserved9 = 0x9,
264     VendorReservedA = 0xa,
265     VendorReservedB = 0xb,
266     VendorAndroid = 0xc,
267     VendorReservedE = 0xe,
268     VendorReservedF = 0xf,
269 }
270 impl TryFrom<u8> for GroupIdOrDataPacketFormat {
271     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>272     fn try_from(value: u8) -> Result<Self, Self::Error> {
273         match value {
274             0x0 => Ok(GroupIdOrDataPacketFormat::Core),
275             0x1 => Ok(GroupIdOrDataPacketFormat::SessionConfigOrDataSnd),
276             0x2 => Ok(GroupIdOrDataPacketFormat::SessionControlOrDataRcv),
277             0x3 => Ok(GroupIdOrDataPacketFormat::DataControl),
278             0xd => Ok(GroupIdOrDataPacketFormat::Test),
279             0x9 => Ok(GroupIdOrDataPacketFormat::VendorReserved9),
280             0xa => Ok(GroupIdOrDataPacketFormat::VendorReservedA),
281             0xb => Ok(GroupIdOrDataPacketFormat::VendorReservedB),
282             0xc => Ok(GroupIdOrDataPacketFormat::VendorAndroid),
283             0xe => Ok(GroupIdOrDataPacketFormat::VendorReservedE),
284             0xf => Ok(GroupIdOrDataPacketFormat::VendorReservedF),
285             _ => Err(value),
286         }
287     }
288 }
289 impl From<&GroupIdOrDataPacketFormat> for u8 {
from(value: &GroupIdOrDataPacketFormat) -> Self290     fn from(value: &GroupIdOrDataPacketFormat) -> Self {
291         match value {
292             GroupIdOrDataPacketFormat::Core => 0x0,
293             GroupIdOrDataPacketFormat::SessionConfigOrDataSnd => 0x1,
294             GroupIdOrDataPacketFormat::SessionControlOrDataRcv => 0x2,
295             GroupIdOrDataPacketFormat::DataControl => 0x3,
296             GroupIdOrDataPacketFormat::Test => 0xd,
297             GroupIdOrDataPacketFormat::VendorReserved9 => 0x9,
298             GroupIdOrDataPacketFormat::VendorReservedA => 0xa,
299             GroupIdOrDataPacketFormat::VendorReservedB => 0xb,
300             GroupIdOrDataPacketFormat::VendorAndroid => 0xc,
301             GroupIdOrDataPacketFormat::VendorReservedE => 0xe,
302             GroupIdOrDataPacketFormat::VendorReservedF => 0xf,
303         }
304     }
305 }
306 impl From<GroupIdOrDataPacketFormat> for u8 {
from(value: GroupIdOrDataPacketFormat) -> Self307     fn from(value: GroupIdOrDataPacketFormat) -> Self {
308         (&value).into()
309     }
310 }
311 impl From<GroupIdOrDataPacketFormat> for i8 {
from(value: GroupIdOrDataPacketFormat) -> Self312     fn from(value: GroupIdOrDataPacketFormat) -> Self {
313         u8::from(value) as Self
314     }
315 }
316 impl From<GroupIdOrDataPacketFormat> for i16 {
from(value: GroupIdOrDataPacketFormat) -> Self317     fn from(value: GroupIdOrDataPacketFormat) -> Self {
318         u8::from(value) as Self
319     }
320 }
321 impl From<GroupIdOrDataPacketFormat> for i32 {
from(value: GroupIdOrDataPacketFormat) -> Self322     fn from(value: GroupIdOrDataPacketFormat) -> Self {
323         u8::from(value) as Self
324     }
325 }
326 impl From<GroupIdOrDataPacketFormat> for i64 {
from(value: GroupIdOrDataPacketFormat) -> Self327     fn from(value: GroupIdOrDataPacketFormat) -> Self {
328         u8::from(value) as Self
329     }
330 }
331 impl From<GroupIdOrDataPacketFormat> for u16 {
from(value: GroupIdOrDataPacketFormat) -> Self332     fn from(value: GroupIdOrDataPacketFormat) -> Self {
333         u8::from(value) as Self
334     }
335 }
336 impl From<GroupIdOrDataPacketFormat> for u32 {
from(value: GroupIdOrDataPacketFormat) -> Self337     fn from(value: GroupIdOrDataPacketFormat) -> Self {
338         u8::from(value) as Self
339     }
340 }
341 impl From<GroupIdOrDataPacketFormat> for u64 {
from(value: GroupIdOrDataPacketFormat) -> Self342     fn from(value: GroupIdOrDataPacketFormat) -> Self {
343         u8::from(value) as Self
344     }
345 }
346 #[repr(u64)]
347 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
348 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
349 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
350 pub enum CoreOpCode {
351     CoreDeviceReset = 0x0,
352     CoreDeviceStatusNtf = 0x1,
353     CoreDeviceInfo = 0x2,
354     CoreGetCapsInfo = 0x3,
355     CoreSetConfig = 0x4,
356     CoreGetConfig = 0x5,
357     CoreDeviceSuspend = 0x6,
358     CoreGenericErrorNtf = 0x7,
359     CoreQueryUwbsTimestamp = 0x8,
360 }
361 impl TryFrom<u8> for CoreOpCode {
362     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>363     fn try_from(value: u8) -> Result<Self, Self::Error> {
364         match value {
365             0x0 => Ok(CoreOpCode::CoreDeviceReset),
366             0x1 => Ok(CoreOpCode::CoreDeviceStatusNtf),
367             0x2 => Ok(CoreOpCode::CoreDeviceInfo),
368             0x3 => Ok(CoreOpCode::CoreGetCapsInfo),
369             0x4 => Ok(CoreOpCode::CoreSetConfig),
370             0x5 => Ok(CoreOpCode::CoreGetConfig),
371             0x6 => Ok(CoreOpCode::CoreDeviceSuspend),
372             0x7 => Ok(CoreOpCode::CoreGenericErrorNtf),
373             0x8 => Ok(CoreOpCode::CoreQueryUwbsTimestamp),
374             _ => Err(value),
375         }
376     }
377 }
378 impl From<&CoreOpCode> for u8 {
from(value: &CoreOpCode) -> Self379     fn from(value: &CoreOpCode) -> Self {
380         match value {
381             CoreOpCode::CoreDeviceReset => 0x0,
382             CoreOpCode::CoreDeviceStatusNtf => 0x1,
383             CoreOpCode::CoreDeviceInfo => 0x2,
384             CoreOpCode::CoreGetCapsInfo => 0x3,
385             CoreOpCode::CoreSetConfig => 0x4,
386             CoreOpCode::CoreGetConfig => 0x5,
387             CoreOpCode::CoreDeviceSuspend => 0x6,
388             CoreOpCode::CoreGenericErrorNtf => 0x7,
389             CoreOpCode::CoreQueryUwbsTimestamp => 0x8,
390         }
391     }
392 }
393 impl From<CoreOpCode> for u8 {
from(value: CoreOpCode) -> Self394     fn from(value: CoreOpCode) -> Self {
395         (&value).into()
396     }
397 }
398 impl From<CoreOpCode> for i8 {
from(value: CoreOpCode) -> Self399     fn from(value: CoreOpCode) -> Self {
400         u8::from(value) as Self
401     }
402 }
403 impl From<CoreOpCode> for i16 {
from(value: CoreOpCode) -> Self404     fn from(value: CoreOpCode) -> Self {
405         u8::from(value) as Self
406     }
407 }
408 impl From<CoreOpCode> for i32 {
from(value: CoreOpCode) -> Self409     fn from(value: CoreOpCode) -> Self {
410         u8::from(value) as Self
411     }
412 }
413 impl From<CoreOpCode> for i64 {
from(value: CoreOpCode) -> Self414     fn from(value: CoreOpCode) -> Self {
415         u8::from(value) as Self
416     }
417 }
418 impl From<CoreOpCode> for u16 {
from(value: CoreOpCode) -> Self419     fn from(value: CoreOpCode) -> Self {
420         u8::from(value) as Self
421     }
422 }
423 impl From<CoreOpCode> for u32 {
from(value: CoreOpCode) -> Self424     fn from(value: CoreOpCode) -> Self {
425         u8::from(value) as Self
426     }
427 }
428 impl From<CoreOpCode> for u64 {
from(value: CoreOpCode) -> Self429     fn from(value: CoreOpCode) -> Self {
430         u8::from(value) as Self
431     }
432 }
433 #[repr(u64)]
434 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
435 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
436 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
437 pub enum SessionConfigOpCode {
438     SessionInit = 0x0,
439     SessionDeinit = 0x1,
440     SessionStatusNtf = 0x2,
441     SessionSetAppConfig = 0x3,
442     SessionGetAppConfig = 0x4,
443     SessionGetCount = 0x5,
444     SessionGetState = 0x6,
445     SessionUpdateControllerMulticastList = 0x7,
446     SessionUpdateActiveRoundsAnchor = 0x8,
447     SessionUpdateActiveRoundsDtTag = 0x9,
448     SessionSetInitiatorDtAnchorRrRdmList = 0xa,
449     SessionQueryDataSizeInRanging = 0xb,
450     SessionSetHusControllerConfig = 0xc,
451     SessionSetHusControleeConfig = 0xd,
452     SessionDataTransferPhaseConfiguration = 0xe,
453 }
454 impl TryFrom<u8> for SessionConfigOpCode {
455     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>456     fn try_from(value: u8) -> Result<Self, Self::Error> {
457         match value {
458             0x0 => Ok(SessionConfigOpCode::SessionInit),
459             0x1 => Ok(SessionConfigOpCode::SessionDeinit),
460             0x2 => Ok(SessionConfigOpCode::SessionStatusNtf),
461             0x3 => Ok(SessionConfigOpCode::SessionSetAppConfig),
462             0x4 => Ok(SessionConfigOpCode::SessionGetAppConfig),
463             0x5 => Ok(SessionConfigOpCode::SessionGetCount),
464             0x6 => Ok(SessionConfigOpCode::SessionGetState),
465             0x7 => Ok(SessionConfigOpCode::SessionUpdateControllerMulticastList),
466             0x8 => Ok(SessionConfigOpCode::SessionUpdateActiveRoundsAnchor),
467             0x9 => Ok(SessionConfigOpCode::SessionUpdateActiveRoundsDtTag),
468             0xa => Ok(SessionConfigOpCode::SessionSetInitiatorDtAnchorRrRdmList),
469             0xb => Ok(SessionConfigOpCode::SessionQueryDataSizeInRanging),
470             0xc => Ok(SessionConfigOpCode::SessionSetHusControllerConfig),
471             0xd => Ok(SessionConfigOpCode::SessionSetHusControleeConfig),
472             0xe => Ok(SessionConfigOpCode::SessionDataTransferPhaseConfiguration),
473             _ => Err(value),
474         }
475     }
476 }
477 impl From<&SessionConfigOpCode> for u8 {
from(value: &SessionConfigOpCode) -> Self478     fn from(value: &SessionConfigOpCode) -> Self {
479         match value {
480             SessionConfigOpCode::SessionInit => 0x0,
481             SessionConfigOpCode::SessionDeinit => 0x1,
482             SessionConfigOpCode::SessionStatusNtf => 0x2,
483             SessionConfigOpCode::SessionSetAppConfig => 0x3,
484             SessionConfigOpCode::SessionGetAppConfig => 0x4,
485             SessionConfigOpCode::SessionGetCount => 0x5,
486             SessionConfigOpCode::SessionGetState => 0x6,
487             SessionConfigOpCode::SessionUpdateControllerMulticastList => 0x7,
488             SessionConfigOpCode::SessionUpdateActiveRoundsAnchor => 0x8,
489             SessionConfigOpCode::SessionUpdateActiveRoundsDtTag => 0x9,
490             SessionConfigOpCode::SessionSetInitiatorDtAnchorRrRdmList => 0xa,
491             SessionConfigOpCode::SessionQueryDataSizeInRanging => 0xb,
492             SessionConfigOpCode::SessionSetHusControllerConfig => 0xc,
493             SessionConfigOpCode::SessionSetHusControleeConfig => 0xd,
494             SessionConfigOpCode::SessionDataTransferPhaseConfiguration => 0xe,
495         }
496     }
497 }
498 impl From<SessionConfigOpCode> for u8 {
from(value: SessionConfigOpCode) -> Self499     fn from(value: SessionConfigOpCode) -> Self {
500         (&value).into()
501     }
502 }
503 impl From<SessionConfigOpCode> for i8 {
from(value: SessionConfigOpCode) -> Self504     fn from(value: SessionConfigOpCode) -> Self {
505         u8::from(value) as Self
506     }
507 }
508 impl From<SessionConfigOpCode> for i16 {
from(value: SessionConfigOpCode) -> Self509     fn from(value: SessionConfigOpCode) -> Self {
510         u8::from(value) as Self
511     }
512 }
513 impl From<SessionConfigOpCode> for i32 {
from(value: SessionConfigOpCode) -> Self514     fn from(value: SessionConfigOpCode) -> Self {
515         u8::from(value) as Self
516     }
517 }
518 impl From<SessionConfigOpCode> for i64 {
from(value: SessionConfigOpCode) -> Self519     fn from(value: SessionConfigOpCode) -> Self {
520         u8::from(value) as Self
521     }
522 }
523 impl From<SessionConfigOpCode> for u16 {
from(value: SessionConfigOpCode) -> Self524     fn from(value: SessionConfigOpCode) -> Self {
525         u8::from(value) as Self
526     }
527 }
528 impl From<SessionConfigOpCode> for u32 {
from(value: SessionConfigOpCode) -> Self529     fn from(value: SessionConfigOpCode) -> Self {
530         u8::from(value) as Self
531     }
532 }
533 impl From<SessionConfigOpCode> for u64 {
from(value: SessionConfigOpCode) -> Self534     fn from(value: SessionConfigOpCode) -> Self {
535         u8::from(value) as Self
536     }
537 }
538 #[repr(u64)]
539 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
540 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
541 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
542 pub enum SessionControlOpCode {
543     SessionStart = 0x0,
544     SessionStop = 0x1,
545     SessionReserved = 0x2,
546     SessionGetRangingCount = 0x3,
547     SessionDataCreditNtf = 0x4,
548     SessionDataTransferStatusNtf = 0x5,
549 }
550 impl TryFrom<u8> for SessionControlOpCode {
551     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>552     fn try_from(value: u8) -> Result<Self, Self::Error> {
553         match value {
554             0x0 => Ok(SessionControlOpCode::SessionStart),
555             0x1 => Ok(SessionControlOpCode::SessionStop),
556             0x2 => Ok(SessionControlOpCode::SessionReserved),
557             0x3 => Ok(SessionControlOpCode::SessionGetRangingCount),
558             0x4 => Ok(SessionControlOpCode::SessionDataCreditNtf),
559             0x5 => Ok(SessionControlOpCode::SessionDataTransferStatusNtf),
560             _ => Err(value),
561         }
562     }
563 }
564 impl From<&SessionControlOpCode> for u8 {
from(value: &SessionControlOpCode) -> Self565     fn from(value: &SessionControlOpCode) -> Self {
566         match value {
567             SessionControlOpCode::SessionStart => 0x0,
568             SessionControlOpCode::SessionStop => 0x1,
569             SessionControlOpCode::SessionReserved => 0x2,
570             SessionControlOpCode::SessionGetRangingCount => 0x3,
571             SessionControlOpCode::SessionDataCreditNtf => 0x4,
572             SessionControlOpCode::SessionDataTransferStatusNtf => 0x5,
573         }
574     }
575 }
576 impl From<SessionControlOpCode> for u8 {
from(value: SessionControlOpCode) -> Self577     fn from(value: SessionControlOpCode) -> Self {
578         (&value).into()
579     }
580 }
581 impl From<SessionControlOpCode> for i8 {
from(value: SessionControlOpCode) -> Self582     fn from(value: SessionControlOpCode) -> Self {
583         u8::from(value) as Self
584     }
585 }
586 impl From<SessionControlOpCode> for i16 {
from(value: SessionControlOpCode) -> Self587     fn from(value: SessionControlOpCode) -> Self {
588         u8::from(value) as Self
589     }
590 }
591 impl From<SessionControlOpCode> for i32 {
from(value: SessionControlOpCode) -> Self592     fn from(value: SessionControlOpCode) -> Self {
593         u8::from(value) as Self
594     }
595 }
596 impl From<SessionControlOpCode> for i64 {
from(value: SessionControlOpCode) -> Self597     fn from(value: SessionControlOpCode) -> Self {
598         u8::from(value) as Self
599     }
600 }
601 impl From<SessionControlOpCode> for u16 {
from(value: SessionControlOpCode) -> Self602     fn from(value: SessionControlOpCode) -> Self {
603         u8::from(value) as Self
604     }
605 }
606 impl From<SessionControlOpCode> for u32 {
from(value: SessionControlOpCode) -> Self607     fn from(value: SessionControlOpCode) -> Self {
608         u8::from(value) as Self
609     }
610 }
611 impl From<SessionControlOpCode> for u64 {
from(value: SessionControlOpCode) -> Self612     fn from(value: SessionControlOpCode) -> Self {
613         u8::from(value) as Self
614     }
615 }
616 #[repr(u64)]
617 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
618 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
619 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
620 pub enum AppDataOpCode {
621     AppDataTx = 0x0,
622     AppDataRx = 0x1,
623 }
624 impl TryFrom<u8> for AppDataOpCode {
625     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>626     fn try_from(value: u8) -> Result<Self, Self::Error> {
627         match value {
628             0x0 => Ok(AppDataOpCode::AppDataTx),
629             0x1 => Ok(AppDataOpCode::AppDataRx),
630             _ => Err(value),
631         }
632     }
633 }
634 impl From<&AppDataOpCode> for u8 {
from(value: &AppDataOpCode) -> Self635     fn from(value: &AppDataOpCode) -> Self {
636         match value {
637             AppDataOpCode::AppDataTx => 0x0,
638             AppDataOpCode::AppDataRx => 0x1,
639         }
640     }
641 }
642 impl From<AppDataOpCode> for u8 {
from(value: AppDataOpCode) -> Self643     fn from(value: AppDataOpCode) -> Self {
644         (&value).into()
645     }
646 }
647 impl From<AppDataOpCode> for i8 {
from(value: AppDataOpCode) -> Self648     fn from(value: AppDataOpCode) -> Self {
649         u8::from(value) as Self
650     }
651 }
652 impl From<AppDataOpCode> for i16 {
from(value: AppDataOpCode) -> Self653     fn from(value: AppDataOpCode) -> Self {
654         u8::from(value) as Self
655     }
656 }
657 impl From<AppDataOpCode> for i32 {
from(value: AppDataOpCode) -> Self658     fn from(value: AppDataOpCode) -> Self {
659         u8::from(value) as Self
660     }
661 }
662 impl From<AppDataOpCode> for i64 {
from(value: AppDataOpCode) -> Self663     fn from(value: AppDataOpCode) -> Self {
664         u8::from(value) as Self
665     }
666 }
667 impl From<AppDataOpCode> for u16 {
from(value: AppDataOpCode) -> Self668     fn from(value: AppDataOpCode) -> Self {
669         u8::from(value) as Self
670     }
671 }
672 impl From<AppDataOpCode> for u32 {
from(value: AppDataOpCode) -> Self673     fn from(value: AppDataOpCode) -> Self {
674         u8::from(value) as Self
675     }
676 }
677 impl From<AppDataOpCode> for u64 {
from(value: AppDataOpCode) -> Self678     fn from(value: AppDataOpCode) -> Self {
679         u8::from(value) as Self
680     }
681 }
682 #[repr(u64)]
683 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
684 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
685 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
686 pub enum AndroidOpCode {
687     AndroidGetPowerStats = 0x0,
688     AndroidSetCountryCode = 0x1,
689     AndroidFiraRangeDiagnostics = 0x2,
690     AndroidRadarSetAppConfig = 0x11,
691     AndroidRadarGetAppConfig = 0x12,
692 }
693 impl TryFrom<u8> for AndroidOpCode {
694     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>695     fn try_from(value: u8) -> Result<Self, Self::Error> {
696         match value {
697             0x0 => Ok(AndroidOpCode::AndroidGetPowerStats),
698             0x1 => Ok(AndroidOpCode::AndroidSetCountryCode),
699             0x2 => Ok(AndroidOpCode::AndroidFiraRangeDiagnostics),
700             0x11 => Ok(AndroidOpCode::AndroidRadarSetAppConfig),
701             0x12 => Ok(AndroidOpCode::AndroidRadarGetAppConfig),
702             _ => Err(value),
703         }
704     }
705 }
706 impl From<&AndroidOpCode> for u8 {
from(value: &AndroidOpCode) -> Self707     fn from(value: &AndroidOpCode) -> Self {
708         match value {
709             AndroidOpCode::AndroidGetPowerStats => 0x0,
710             AndroidOpCode::AndroidSetCountryCode => 0x1,
711             AndroidOpCode::AndroidFiraRangeDiagnostics => 0x2,
712             AndroidOpCode::AndroidRadarSetAppConfig => 0x11,
713             AndroidOpCode::AndroidRadarGetAppConfig => 0x12,
714         }
715     }
716 }
717 impl From<AndroidOpCode> for u8 {
from(value: AndroidOpCode) -> Self718     fn from(value: AndroidOpCode) -> Self {
719         (&value).into()
720     }
721 }
722 impl From<AndroidOpCode> for i8 {
from(value: AndroidOpCode) -> Self723     fn from(value: AndroidOpCode) -> Self {
724         u8::from(value) as Self
725     }
726 }
727 impl From<AndroidOpCode> for i16 {
from(value: AndroidOpCode) -> Self728     fn from(value: AndroidOpCode) -> Self {
729         u8::from(value) as Self
730     }
731 }
732 impl From<AndroidOpCode> for i32 {
from(value: AndroidOpCode) -> Self733     fn from(value: AndroidOpCode) -> Self {
734         u8::from(value) as Self
735     }
736 }
737 impl From<AndroidOpCode> for i64 {
from(value: AndroidOpCode) -> Self738     fn from(value: AndroidOpCode) -> Self {
739         u8::from(value) as Self
740     }
741 }
742 impl From<AndroidOpCode> for u16 {
from(value: AndroidOpCode) -> Self743     fn from(value: AndroidOpCode) -> Self {
744         u8::from(value) as Self
745     }
746 }
747 impl From<AndroidOpCode> for u32 {
from(value: AndroidOpCode) -> Self748     fn from(value: AndroidOpCode) -> Self {
749         u8::from(value) as Self
750     }
751 }
752 impl From<AndroidOpCode> for u64 {
from(value: AndroidOpCode) -> Self753     fn from(value: AndroidOpCode) -> Self {
754         u8::from(value) as Self
755     }
756 }
757 #[repr(u64)]
758 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
759 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
760 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
761 pub enum TestOpCode {
762     RfTestConfigSetCommand = 0x0,
763     RfTestConfigGetCommand = 0x1,
764     RfTestPeriodicTxCmd = 0x2,
765 }
766 impl TryFrom<u8> for TestOpCode {
767     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>768     fn try_from(value: u8) -> Result<Self, Self::Error> {
769         match value {
770             0x0 => Ok(TestOpCode::RfTestConfigSetCommand),
771             0x1 => Ok(TestOpCode::RfTestConfigGetCommand),
772             0x2 => Ok(TestOpCode::RfTestPeriodicTxCmd),
773             _ => Err(value),
774         }
775     }
776 }
777 impl From<&TestOpCode> for u8 {
from(value: &TestOpCode) -> Self778     fn from(value: &TestOpCode) -> Self {
779         match value {
780             TestOpCode::RfTestConfigSetCommand => 0x0,
781             TestOpCode::RfTestConfigGetCommand => 0x1,
782             TestOpCode::RfTestPeriodicTxCmd => 0x2,
783         }
784     }
785 }
786 impl From<TestOpCode> for u8 {
from(value: TestOpCode) -> Self787     fn from(value: TestOpCode) -> Self {
788         (&value).into()
789     }
790 }
791 impl From<TestOpCode> for i8 {
from(value: TestOpCode) -> Self792     fn from(value: TestOpCode) -> Self {
793         u8::from(value) as Self
794     }
795 }
796 impl From<TestOpCode> for i16 {
from(value: TestOpCode) -> Self797     fn from(value: TestOpCode) -> Self {
798         u8::from(value) as Self
799     }
800 }
801 impl From<TestOpCode> for i32 {
from(value: TestOpCode) -> Self802     fn from(value: TestOpCode) -> Self {
803         u8::from(value) as Self
804     }
805 }
806 impl From<TestOpCode> for i64 {
from(value: TestOpCode) -> Self807     fn from(value: TestOpCode) -> Self {
808         u8::from(value) as Self
809     }
810 }
811 impl From<TestOpCode> for u16 {
from(value: TestOpCode) -> Self812     fn from(value: TestOpCode) -> Self {
813         u8::from(value) as Self
814     }
815 }
816 impl From<TestOpCode> for u32 {
from(value: TestOpCode) -> Self817     fn from(value: TestOpCode) -> Self {
818         u8::from(value) as Self
819     }
820 }
821 impl From<TestOpCode> for u64 {
from(value: TestOpCode) -> Self822     fn from(value: TestOpCode) -> Self {
823         u8::from(value) as Self
824     }
825 }
826 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
827 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
828 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
829 pub enum StatusCode {
830     UciStatusOk,
831     UciStatusRejected,
832     UciStatusFailed,
833     UciStatusSyntaxError,
834     UciStatusInvalidParam,
835     UciStatusInvalidRange,
836     UciStatusInvalidMsgSize,
837     UciStatusUnknownGid,
838     UciStatusUnknownOid,
839     UciStatusReadOnly,
840     UciStatusCommandRetry,
841     UciStatusUnknown,
842     UciStatusNotApplicable,
843     RfuStatusCodeRange1(Private<u8>),
844     UciStatusSessionNotExist,
845     UciStatusSessionDuplicate,
846     UciStatusSessionActive,
847     UciStatusMaxSessionsExceeded,
848     UciStatusSessionNotConfigured,
849     UciStatusActiveSessionsOngoing,
850     UciStatusMulticastListFull,
851     UciStatusAddressNotFound,
852     UciStatusAddressAlreadyPresent,
853     UciStatusErrorUwbInitiationTimeTooOld,
854     UciStatusOkNegativeDistanceReport,
855     RfuStatusCodeRange2(Private<u8>),
856     UciStatusRangingTxFailed,
857     UciStatusRangingRxTimeout,
858     UciStatusRangingRxPhyDecFailed,
859     UciStatusRangingRxPhyToaFailed,
860     UciStatusRangingRxPhyStsFailed,
861     UciStatusRangingRxMacDecFailed,
862     UciStatusRangingRxMacIeDecFailed,
863     UciStatusRangingRxMacIeMissing,
864     UciStatusErrorRoundIndexNotActivated,
865     UciStatusErrorNumberOfActiveRangingRoundsExceeded,
866     UciStatusErrorDlTdoaDeviceAddressNotMatchingInReplyTimeList,
867     RfuStatusCodeRange3(Private<u8>),
868     UciStatusDataMaxTxPsduSizeExceeded,
869     UciStatusDataRxCrcError,
870     RfuStatusCodeRange4(Private<u8>),
871     UciStatusErrorCccSeBusy,
872     UciStatusErrorCccLifecycle,
873     UciStatusErrorStoppedDueToOtherSessionConflict,
874     UciStatusRegulationUwbOff,
875     VendorSpecificStatusCodeRange1(Private<u8>),
876     VendorSpecificStatusCode2,
877 }
878 impl TryFrom<u8> for StatusCode {
879     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>880     fn try_from(value: u8) -> Result<Self, Self::Error> {
881         match value {
882             0x0 => Ok(StatusCode::UciStatusOk),
883             0x1 => Ok(StatusCode::UciStatusRejected),
884             0x2 => Ok(StatusCode::UciStatusFailed),
885             0x3 => Ok(StatusCode::UciStatusSyntaxError),
886             0x4 => Ok(StatusCode::UciStatusInvalidParam),
887             0x5 => Ok(StatusCode::UciStatusInvalidRange),
888             0x6 => Ok(StatusCode::UciStatusInvalidMsgSize),
889             0x7 => Ok(StatusCode::UciStatusUnknownGid),
890             0x8 => Ok(StatusCode::UciStatusUnknownOid),
891             0x9 => Ok(StatusCode::UciStatusReadOnly),
892             0xa => Ok(StatusCode::UciStatusCommandRetry),
893             0xb => Ok(StatusCode::UciStatusUnknown),
894             0xc => Ok(StatusCode::UciStatusNotApplicable),
895             0xd..=0x10 => Ok(StatusCode::RfuStatusCodeRange1(Private(value))),
896             0x11 => Ok(StatusCode::UciStatusSessionNotExist),
897             0x12 => Ok(StatusCode::UciStatusSessionDuplicate),
898             0x13 => Ok(StatusCode::UciStatusSessionActive),
899             0x14 => Ok(StatusCode::UciStatusMaxSessionsExceeded),
900             0x15 => Ok(StatusCode::UciStatusSessionNotConfigured),
901             0x16 => Ok(StatusCode::UciStatusActiveSessionsOngoing),
902             0x17 => Ok(StatusCode::UciStatusMulticastListFull),
903             0x18 => Ok(StatusCode::UciStatusAddressNotFound),
904             0x19 => Ok(StatusCode::UciStatusAddressAlreadyPresent),
905             0x1a => Ok(StatusCode::UciStatusErrorUwbInitiationTimeTooOld),
906             0x1b => Ok(StatusCode::UciStatusOkNegativeDistanceReport),
907             0x1c..=0x1f => Ok(StatusCode::RfuStatusCodeRange2(Private(value))),
908             0x20 => Ok(StatusCode::UciStatusRangingTxFailed),
909             0x21 => Ok(StatusCode::UciStatusRangingRxTimeout),
910             0x22 => Ok(StatusCode::UciStatusRangingRxPhyDecFailed),
911             0x23 => Ok(StatusCode::UciStatusRangingRxPhyToaFailed),
912             0x24 => Ok(StatusCode::UciStatusRangingRxPhyStsFailed),
913             0x25 => Ok(StatusCode::UciStatusRangingRxMacDecFailed),
914             0x26 => Ok(StatusCode::UciStatusRangingRxMacIeDecFailed),
915             0x27 => Ok(StatusCode::UciStatusRangingRxMacIeMissing),
916             0x28 => Ok(StatusCode::UciStatusErrorRoundIndexNotActivated),
917             0x29 => Ok(StatusCode::UciStatusErrorNumberOfActiveRangingRoundsExceeded),
918             0x2a => {
919                 Ok(
920                     StatusCode::UciStatusErrorDlTdoaDeviceAddressNotMatchingInReplyTimeList,
921                 )
922             }
923             0x2b..=0x2f => Ok(StatusCode::RfuStatusCodeRange3(Private(value))),
924             0x30 => Ok(StatusCode::UciStatusDataMaxTxPsduSizeExceeded),
925             0x31 => Ok(StatusCode::UciStatusDataRxCrcError),
926             0x32..=0x4f => Ok(StatusCode::RfuStatusCodeRange4(Private(value))),
927             0x50 => Ok(StatusCode::UciStatusErrorCccSeBusy),
928             0x51 => Ok(StatusCode::UciStatusErrorCccLifecycle),
929             0x52 => Ok(StatusCode::UciStatusErrorStoppedDueToOtherSessionConflict),
930             0x53 => Ok(StatusCode::UciStatusRegulationUwbOff),
931             0x50..=0xfe => Ok(StatusCode::VendorSpecificStatusCodeRange1(Private(value))),
932             0xff => Ok(StatusCode::VendorSpecificStatusCode2),
933         }
934     }
935 }
936 impl From<&StatusCode> for u8 {
from(value: &StatusCode) -> Self937     fn from(value: &StatusCode) -> Self {
938         match value {
939             StatusCode::UciStatusOk => 0x0,
940             StatusCode::UciStatusRejected => 0x1,
941             StatusCode::UciStatusFailed => 0x2,
942             StatusCode::UciStatusSyntaxError => 0x3,
943             StatusCode::UciStatusInvalidParam => 0x4,
944             StatusCode::UciStatusInvalidRange => 0x5,
945             StatusCode::UciStatusInvalidMsgSize => 0x6,
946             StatusCode::UciStatusUnknownGid => 0x7,
947             StatusCode::UciStatusUnknownOid => 0x8,
948             StatusCode::UciStatusReadOnly => 0x9,
949             StatusCode::UciStatusCommandRetry => 0xa,
950             StatusCode::UciStatusUnknown => 0xb,
951             StatusCode::UciStatusNotApplicable => 0xc,
952             StatusCode::RfuStatusCodeRange1(Private(value)) => *value,
953             StatusCode::UciStatusSessionNotExist => 0x11,
954             StatusCode::UciStatusSessionDuplicate => 0x12,
955             StatusCode::UciStatusSessionActive => 0x13,
956             StatusCode::UciStatusMaxSessionsExceeded => 0x14,
957             StatusCode::UciStatusSessionNotConfigured => 0x15,
958             StatusCode::UciStatusActiveSessionsOngoing => 0x16,
959             StatusCode::UciStatusMulticastListFull => 0x17,
960             StatusCode::UciStatusAddressNotFound => 0x18,
961             StatusCode::UciStatusAddressAlreadyPresent => 0x19,
962             StatusCode::UciStatusErrorUwbInitiationTimeTooOld => 0x1a,
963             StatusCode::UciStatusOkNegativeDistanceReport => 0x1b,
964             StatusCode::RfuStatusCodeRange2(Private(value)) => *value,
965             StatusCode::UciStatusRangingTxFailed => 0x20,
966             StatusCode::UciStatusRangingRxTimeout => 0x21,
967             StatusCode::UciStatusRangingRxPhyDecFailed => 0x22,
968             StatusCode::UciStatusRangingRxPhyToaFailed => 0x23,
969             StatusCode::UciStatusRangingRxPhyStsFailed => 0x24,
970             StatusCode::UciStatusRangingRxMacDecFailed => 0x25,
971             StatusCode::UciStatusRangingRxMacIeDecFailed => 0x26,
972             StatusCode::UciStatusRangingRxMacIeMissing => 0x27,
973             StatusCode::UciStatusErrorRoundIndexNotActivated => 0x28,
974             StatusCode::UciStatusErrorNumberOfActiveRangingRoundsExceeded => 0x29,
975             StatusCode::UciStatusErrorDlTdoaDeviceAddressNotMatchingInReplyTimeList => {
976                 0x2a
977             }
978             StatusCode::RfuStatusCodeRange3(Private(value)) => *value,
979             StatusCode::UciStatusDataMaxTxPsduSizeExceeded => 0x30,
980             StatusCode::UciStatusDataRxCrcError => 0x31,
981             StatusCode::RfuStatusCodeRange4(Private(value)) => *value,
982             StatusCode::UciStatusErrorCccSeBusy => 0x50,
983             StatusCode::UciStatusErrorCccLifecycle => 0x51,
984             StatusCode::UciStatusErrorStoppedDueToOtherSessionConflict => 0x52,
985             StatusCode::UciStatusRegulationUwbOff => 0x53,
986             StatusCode::VendorSpecificStatusCodeRange1(Private(value)) => *value,
987             StatusCode::VendorSpecificStatusCode2 => 0xff,
988         }
989     }
990 }
991 impl From<StatusCode> for u8 {
from(value: StatusCode) -> Self992     fn from(value: StatusCode) -> Self {
993         (&value).into()
994     }
995 }
996 impl From<StatusCode> for i16 {
from(value: StatusCode) -> Self997     fn from(value: StatusCode) -> Self {
998         u8::from(value) as Self
999     }
1000 }
1001 impl From<StatusCode> for i32 {
from(value: StatusCode) -> Self1002     fn from(value: StatusCode) -> Self {
1003         u8::from(value) as Self
1004     }
1005 }
1006 impl From<StatusCode> for i64 {
from(value: StatusCode) -> Self1007     fn from(value: StatusCode) -> Self {
1008         u8::from(value) as Self
1009     }
1010 }
1011 impl From<StatusCode> for u16 {
from(value: StatusCode) -> Self1012     fn from(value: StatusCode) -> Self {
1013         u8::from(value) as Self
1014     }
1015 }
1016 impl From<StatusCode> for u32 {
from(value: StatusCode) -> Self1017     fn from(value: StatusCode) -> Self {
1018         u8::from(value) as Self
1019     }
1020 }
1021 impl From<StatusCode> for u64 {
from(value: StatusCode) -> Self1022     fn from(value: StatusCode) -> Self {
1023         u8::from(value) as Self
1024     }
1025 }
1026 #[repr(u64)]
1027 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
1028 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1029 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
1030 pub enum DataRcvStatusCode {
1031     UciStatusSuccess = 0x0,
1032     UciStatusError = 0x1,
1033     UciStatusUnknown = 0x2,
1034 }
1035 impl TryFrom<u8> for DataRcvStatusCode {
1036     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>1037     fn try_from(value: u8) -> Result<Self, Self::Error> {
1038         match value {
1039             0x0 => Ok(DataRcvStatusCode::UciStatusSuccess),
1040             0x1 => Ok(DataRcvStatusCode::UciStatusError),
1041             0x2 => Ok(DataRcvStatusCode::UciStatusUnknown),
1042             _ => Err(value),
1043         }
1044     }
1045 }
1046 impl From<&DataRcvStatusCode> for u8 {
from(value: &DataRcvStatusCode) -> Self1047     fn from(value: &DataRcvStatusCode) -> Self {
1048         match value {
1049             DataRcvStatusCode::UciStatusSuccess => 0x0,
1050             DataRcvStatusCode::UciStatusError => 0x1,
1051             DataRcvStatusCode::UciStatusUnknown => 0x2,
1052         }
1053     }
1054 }
1055 impl From<DataRcvStatusCode> for u8 {
from(value: DataRcvStatusCode) -> Self1056     fn from(value: DataRcvStatusCode) -> Self {
1057         (&value).into()
1058     }
1059 }
1060 impl From<DataRcvStatusCode> for i16 {
from(value: DataRcvStatusCode) -> Self1061     fn from(value: DataRcvStatusCode) -> Self {
1062         u8::from(value) as Self
1063     }
1064 }
1065 impl From<DataRcvStatusCode> for i32 {
from(value: DataRcvStatusCode) -> Self1066     fn from(value: DataRcvStatusCode) -> Self {
1067         u8::from(value) as Self
1068     }
1069 }
1070 impl From<DataRcvStatusCode> for i64 {
from(value: DataRcvStatusCode) -> Self1071     fn from(value: DataRcvStatusCode) -> Self {
1072         u8::from(value) as Self
1073     }
1074 }
1075 impl From<DataRcvStatusCode> for u16 {
from(value: DataRcvStatusCode) -> Self1076     fn from(value: DataRcvStatusCode) -> Self {
1077         u8::from(value) as Self
1078     }
1079 }
1080 impl From<DataRcvStatusCode> for u32 {
from(value: DataRcvStatusCode) -> Self1081     fn from(value: DataRcvStatusCode) -> Self {
1082         u8::from(value) as Self
1083     }
1084 }
1085 impl From<DataRcvStatusCode> for u64 {
from(value: DataRcvStatusCode) -> Self1086     fn from(value: DataRcvStatusCode) -> Self {
1087         u8::from(value) as Self
1088     }
1089 }
1090 #[repr(u64)]
1091 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
1092 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1093 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
1094 pub enum CreditAvailability {
1095     CreditNotAvailable = 0x0,
1096     CreditAvailable = 0x1,
1097 }
1098 impl TryFrom<u8> for CreditAvailability {
1099     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>1100     fn try_from(value: u8) -> Result<Self, Self::Error> {
1101         match value {
1102             0x0 => Ok(CreditAvailability::CreditNotAvailable),
1103             0x1 => Ok(CreditAvailability::CreditAvailable),
1104             _ => Err(value),
1105         }
1106     }
1107 }
1108 impl From<&CreditAvailability> for u8 {
from(value: &CreditAvailability) -> Self1109     fn from(value: &CreditAvailability) -> Self {
1110         match value {
1111             CreditAvailability::CreditNotAvailable => 0x0,
1112             CreditAvailability::CreditAvailable => 0x1,
1113         }
1114     }
1115 }
1116 impl From<CreditAvailability> for u8 {
from(value: CreditAvailability) -> Self1117     fn from(value: CreditAvailability) -> Self {
1118         (&value).into()
1119     }
1120 }
1121 impl From<CreditAvailability> for i16 {
from(value: CreditAvailability) -> Self1122     fn from(value: CreditAvailability) -> Self {
1123         u8::from(value) as Self
1124     }
1125 }
1126 impl From<CreditAvailability> for i32 {
from(value: CreditAvailability) -> Self1127     fn from(value: CreditAvailability) -> Self {
1128         u8::from(value) as Self
1129     }
1130 }
1131 impl From<CreditAvailability> for i64 {
from(value: CreditAvailability) -> Self1132     fn from(value: CreditAvailability) -> Self {
1133         u8::from(value) as Self
1134     }
1135 }
1136 impl From<CreditAvailability> for u16 {
from(value: CreditAvailability) -> Self1137     fn from(value: CreditAvailability) -> Self {
1138         u8::from(value) as Self
1139     }
1140 }
1141 impl From<CreditAvailability> for u32 {
from(value: CreditAvailability) -> Self1142     fn from(value: CreditAvailability) -> Self {
1143         u8::from(value) as Self
1144     }
1145 }
1146 impl From<CreditAvailability> for u64 {
from(value: CreditAvailability) -> Self1147     fn from(value: CreditAvailability) -> Self {
1148         u8::from(value) as Self
1149     }
1150 }
1151 #[repr(u64)]
1152 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
1153 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1154 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
1155 pub enum DataTransferNtfStatusCode {
1156     UciDataTransferStatusRepetitionOk = 0x0,
1157     UciDataTransferStatusOk = 0x1,
1158     UciDataTransferStatusErrorDataTransfer = 0x2,
1159     UciDataTransferStatusErrorNoCreditAvailable = 0x3,
1160     UciDataTransferStatusErrorRejected = 0x4,
1161     UciDataTransferStatusSessionTypeNotSupported = 0x5,
1162     UciDataTransferStatusErrorDataTransferIsOngoing = 0x6,
1163     UciDataTransferStatusInvalidFormat = 0x7,
1164 }
1165 impl TryFrom<u8> for DataTransferNtfStatusCode {
1166     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>1167     fn try_from(value: u8) -> Result<Self, Self::Error> {
1168         match value {
1169             0x0 => Ok(DataTransferNtfStatusCode::UciDataTransferStatusRepetitionOk),
1170             0x1 => Ok(DataTransferNtfStatusCode::UciDataTransferStatusOk),
1171             0x2 => Ok(DataTransferNtfStatusCode::UciDataTransferStatusErrorDataTransfer),
1172             0x3 => {
1173                 Ok(
1174                     DataTransferNtfStatusCode::UciDataTransferStatusErrorNoCreditAvailable,
1175                 )
1176             }
1177             0x4 => Ok(DataTransferNtfStatusCode::UciDataTransferStatusErrorRejected),
1178             0x5 => {
1179                 Ok(
1180                     DataTransferNtfStatusCode::UciDataTransferStatusSessionTypeNotSupported,
1181                 )
1182             }
1183             0x6 => {
1184                 Ok(
1185                     DataTransferNtfStatusCode::UciDataTransferStatusErrorDataTransferIsOngoing,
1186                 )
1187             }
1188             0x7 => Ok(DataTransferNtfStatusCode::UciDataTransferStatusInvalidFormat),
1189             _ => Err(value),
1190         }
1191     }
1192 }
1193 impl From<&DataTransferNtfStatusCode> for u8 {
from(value: &DataTransferNtfStatusCode) -> Self1194     fn from(value: &DataTransferNtfStatusCode) -> Self {
1195         match value {
1196             DataTransferNtfStatusCode::UciDataTransferStatusRepetitionOk => 0x0,
1197             DataTransferNtfStatusCode::UciDataTransferStatusOk => 0x1,
1198             DataTransferNtfStatusCode::UciDataTransferStatusErrorDataTransfer => 0x2,
1199             DataTransferNtfStatusCode::UciDataTransferStatusErrorNoCreditAvailable => 0x3,
1200             DataTransferNtfStatusCode::UciDataTransferStatusErrorRejected => 0x4,
1201             DataTransferNtfStatusCode::UciDataTransferStatusSessionTypeNotSupported => {
1202                 0x5
1203             }
1204             DataTransferNtfStatusCode::UciDataTransferStatusErrorDataTransferIsOngoing => {
1205                 0x6
1206             }
1207             DataTransferNtfStatusCode::UciDataTransferStatusInvalidFormat => 0x7,
1208         }
1209     }
1210 }
1211 impl From<DataTransferNtfStatusCode> for u8 {
from(value: DataTransferNtfStatusCode) -> Self1212     fn from(value: DataTransferNtfStatusCode) -> Self {
1213         (&value).into()
1214     }
1215 }
1216 impl From<DataTransferNtfStatusCode> for i16 {
from(value: DataTransferNtfStatusCode) -> Self1217     fn from(value: DataTransferNtfStatusCode) -> Self {
1218         u8::from(value) as Self
1219     }
1220 }
1221 impl From<DataTransferNtfStatusCode> for i32 {
from(value: DataTransferNtfStatusCode) -> Self1222     fn from(value: DataTransferNtfStatusCode) -> Self {
1223         u8::from(value) as Self
1224     }
1225 }
1226 impl From<DataTransferNtfStatusCode> for i64 {
from(value: DataTransferNtfStatusCode) -> Self1227     fn from(value: DataTransferNtfStatusCode) -> Self {
1228         u8::from(value) as Self
1229     }
1230 }
1231 impl From<DataTransferNtfStatusCode> for u16 {
from(value: DataTransferNtfStatusCode) -> Self1232     fn from(value: DataTransferNtfStatusCode) -> Self {
1233         u8::from(value) as Self
1234     }
1235 }
1236 impl From<DataTransferNtfStatusCode> for u32 {
from(value: DataTransferNtfStatusCode) -> Self1237     fn from(value: DataTransferNtfStatusCode) -> Self {
1238         u8::from(value) as Self
1239     }
1240 }
1241 impl From<DataTransferNtfStatusCode> for u64 {
from(value: DataTransferNtfStatusCode) -> Self1242     fn from(value: DataTransferNtfStatusCode) -> Self {
1243         u8::from(value) as Self
1244     }
1245 }
1246 #[repr(u64)]
1247 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
1248 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1249 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
1250 pub enum DataTransferPhaseConfigUpdateStatusCode {
1251     UciDtpcmConfigSuccessStatusOk = 0x0,
1252     UciDtpcmStatusErrorDuplicateSlotAssigment = 0x1,
1253 }
1254 impl TryFrom<u8> for DataTransferPhaseConfigUpdateStatusCode {
1255     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>1256     fn try_from(value: u8) -> Result<Self, Self::Error> {
1257         match value {
1258             0x0 => {
1259                 Ok(
1260                     DataTransferPhaseConfigUpdateStatusCode::UciDtpcmConfigSuccessStatusOk,
1261                 )
1262             }
1263             0x1 => {
1264                 Ok(
1265                     DataTransferPhaseConfigUpdateStatusCode::UciDtpcmStatusErrorDuplicateSlotAssigment,
1266                 )
1267             }
1268             _ => Err(value),
1269         }
1270     }
1271 }
1272 impl From<&DataTransferPhaseConfigUpdateStatusCode> for u8 {
from(value: &DataTransferPhaseConfigUpdateStatusCode) -> Self1273     fn from(value: &DataTransferPhaseConfigUpdateStatusCode) -> Self {
1274         match value {
1275             DataTransferPhaseConfigUpdateStatusCode::UciDtpcmConfigSuccessStatusOk => 0x0,
1276             DataTransferPhaseConfigUpdateStatusCode::UciDtpcmStatusErrorDuplicateSlotAssigment => {
1277                 0x1
1278             }
1279         }
1280     }
1281 }
1282 impl From<DataTransferPhaseConfigUpdateStatusCode> for u8 {
from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self1283     fn from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self {
1284         (&value).into()
1285     }
1286 }
1287 impl From<DataTransferPhaseConfigUpdateStatusCode> for i16 {
from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self1288     fn from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self {
1289         u8::from(value) as Self
1290     }
1291 }
1292 impl From<DataTransferPhaseConfigUpdateStatusCode> for i32 {
from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self1293     fn from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self {
1294         u8::from(value) as Self
1295     }
1296 }
1297 impl From<DataTransferPhaseConfigUpdateStatusCode> for i64 {
from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self1298     fn from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self {
1299         u8::from(value) as Self
1300     }
1301 }
1302 impl From<DataTransferPhaseConfigUpdateStatusCode> for u16 {
from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self1303     fn from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self {
1304         u8::from(value) as Self
1305     }
1306 }
1307 impl From<DataTransferPhaseConfigUpdateStatusCode> for u32 {
from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self1308     fn from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self {
1309         u8::from(value) as Self
1310     }
1311 }
1312 impl From<DataTransferPhaseConfigUpdateStatusCode> for u64 {
from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self1313     fn from(value: DataTransferPhaseConfigUpdateStatusCode) -> Self {
1314         u8::from(value) as Self
1315     }
1316 }
1317 #[repr(u64)]
1318 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
1319 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1320 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
1321 pub enum ResetConfig {
1322     UwbsReset = 0x0,
1323 }
1324 impl TryFrom<u8> for ResetConfig {
1325     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>1326     fn try_from(value: u8) -> Result<Self, Self::Error> {
1327         match value {
1328             0x0 => Ok(ResetConfig::UwbsReset),
1329             _ => Err(value),
1330         }
1331     }
1332 }
1333 impl From<&ResetConfig> for u8 {
from(value: &ResetConfig) -> Self1334     fn from(value: &ResetConfig) -> Self {
1335         match value {
1336             ResetConfig::UwbsReset => 0x0,
1337         }
1338     }
1339 }
1340 impl From<ResetConfig> for u8 {
from(value: ResetConfig) -> Self1341     fn from(value: ResetConfig) -> Self {
1342         (&value).into()
1343     }
1344 }
1345 impl From<ResetConfig> for i16 {
from(value: ResetConfig) -> Self1346     fn from(value: ResetConfig) -> Self {
1347         u8::from(value) as Self
1348     }
1349 }
1350 impl From<ResetConfig> for i32 {
from(value: ResetConfig) -> Self1351     fn from(value: ResetConfig) -> Self {
1352         u8::from(value) as Self
1353     }
1354 }
1355 impl From<ResetConfig> for i64 {
from(value: ResetConfig) -> Self1356     fn from(value: ResetConfig) -> Self {
1357         u8::from(value) as Self
1358     }
1359 }
1360 impl From<ResetConfig> for u16 {
from(value: ResetConfig) -> Self1361     fn from(value: ResetConfig) -> Self {
1362         u8::from(value) as Self
1363     }
1364 }
1365 impl From<ResetConfig> for u32 {
from(value: ResetConfig) -> Self1366     fn from(value: ResetConfig) -> Self {
1367         u8::from(value) as Self
1368     }
1369 }
1370 impl From<ResetConfig> for u64 {
from(value: ResetConfig) -> Self1371     fn from(value: ResetConfig) -> Self {
1372         u8::from(value) as Self
1373     }
1374 }
1375 #[repr(u64)]
1376 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
1377 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1378 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
1379 pub enum DeviceConfigId {
1380     DeviceState = 0x0,
1381     LowPowerMode = 0x1,
1382 }
1383 impl TryFrom<u8> for DeviceConfigId {
1384     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>1385     fn try_from(value: u8) -> Result<Self, Self::Error> {
1386         match value {
1387             0x0 => Ok(DeviceConfigId::DeviceState),
1388             0x1 => Ok(DeviceConfigId::LowPowerMode),
1389             _ => Err(value),
1390         }
1391     }
1392 }
1393 impl From<&DeviceConfigId> for u8 {
from(value: &DeviceConfigId) -> Self1394     fn from(value: &DeviceConfigId) -> Self {
1395         match value {
1396             DeviceConfigId::DeviceState => 0x0,
1397             DeviceConfigId::LowPowerMode => 0x1,
1398         }
1399     }
1400 }
1401 impl From<DeviceConfigId> for u8 {
from(value: DeviceConfigId) -> Self1402     fn from(value: DeviceConfigId) -> Self {
1403         (&value).into()
1404     }
1405 }
1406 impl From<DeviceConfigId> for i16 {
from(value: DeviceConfigId) -> Self1407     fn from(value: DeviceConfigId) -> Self {
1408         u8::from(value) as Self
1409     }
1410 }
1411 impl From<DeviceConfigId> for i32 {
from(value: DeviceConfigId) -> Self1412     fn from(value: DeviceConfigId) -> Self {
1413         u8::from(value) as Self
1414     }
1415 }
1416 impl From<DeviceConfigId> for i64 {
from(value: DeviceConfigId) -> Self1417     fn from(value: DeviceConfigId) -> Self {
1418         u8::from(value) as Self
1419     }
1420 }
1421 impl From<DeviceConfigId> for u16 {
from(value: DeviceConfigId) -> Self1422     fn from(value: DeviceConfigId) -> Self {
1423         u8::from(value) as Self
1424     }
1425 }
1426 impl From<DeviceConfigId> for u32 {
from(value: DeviceConfigId) -> Self1427     fn from(value: DeviceConfigId) -> Self {
1428         u8::from(value) as Self
1429     }
1430 }
1431 impl From<DeviceConfigId> for u64 {
from(value: DeviceConfigId) -> Self1432     fn from(value: DeviceConfigId) -> Self {
1433         u8::from(value) as Self
1434     }
1435 }
1436 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
1437 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1438 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
1439 pub enum AppConfigTlvType {
1440     DeviceType,
1441     RangingRoundUsage,
1442     StsConfig,
1443     MultiNodeMode,
1444     ChannelNumber,
1445     NoOfControlee,
1446     DeviceMacAddress,
1447     DstMacAddress,
1448     SlotDuration,
1449     RangingDuration,
1450     StsIndex,
1451     MacFcsType,
1452     RangingRoundControl,
1453     AoaResultReq,
1454     RngDataNtf,
1455     RngDataNtfProximityNear,
1456     RngDataNtfProximityFar,
1457     DeviceRole,
1458     RframeConfig,
1459     RssiReporting,
1460     PreambleCodeIndex,
1461     SfdId,
1462     PsduDataRate,
1463     PreambleDuration,
1464     LinkLayerMode,
1465     DataRepetitionCount,
1466     RangingTimeStruct,
1467     SlotsPerRr,
1468     TxAdaptivePayloadPower,
1469     RngDataNtfAoaBound,
1470     ResponderSlotIndex,
1471     PrfMode,
1472     CapSizeRange,
1473     TxJitterWindowSize,
1474     ScheduledMode,
1475     KeyRotation,
1476     KeyRotationRate,
1477     SessionPriority,
1478     MacAddressMode,
1479     VendorId,
1480     StaticStsIv,
1481     NumberOfStsSegments,
1482     MaxRrRetry,
1483     UwbInitiationTime,
1484     HoppingMode,
1485     BlockStrideLength,
1486     ResultReportConfig,
1487     InBandTerminationAttemptCount,
1488     SubSessionId,
1489     BprfPhrDataRate,
1490     MaxNumberOfMeasurements,
1491     UlTdoaTxInterval,
1492     UlTdoaRandomWindow,
1493     StsLength,
1494     SuspendRangingRounds,
1495     UlTdoaNtfReportConfig,
1496     UlTdoaDeviceId,
1497     UlTdoaTxTimestamp,
1498     MinFramesPerRr,
1499     MtuSize,
1500     InterFrameInterval,
1501     DlTdoaRangingMethod,
1502     DlTdoaTxTimestampConf,
1503     DlTdoaHopCount,
1504     DlTdoaAnchorCfo,
1505     DlTdoaAnchorLocation,
1506     DlTdoaTxActiveRangingRounds,
1507     DlTdoaBlockStriding,
1508     DlTdoaTimeReferenceAnchor,
1509     SessionKey,
1510     SubsessionKey,
1511     SessionDataTransferStatusNtfConfig,
1512     SessionTimeBase,
1513     DlTdoaResponderTof,
1514     SecureRangingNefaLevel,
1515     SecureRangingCswLength,
1516     ApplicationDataEndpoint,
1517     OwrAoaMeasurementNtfPeriod,
1518     RfuAppCfgTlvTypeRange(Private<u8>),
1519     CccHopModeKey,
1520     CccUwbTime0,
1521     CccRangingProtocolVer,
1522     CccUwbConfigId,
1523     CccPulseshapeCombo,
1524     CccUrskTtl,
1525     CccLastIndexUsed,
1526     AliroMacMode,
1527     VendorSpecificAppCfgTlvTypeRange1(Private<u8>),
1528     RfuAppCfgTlvTypeRange4(Private<u8>),
1529     NbOfRangeMeasurements,
1530     NbOfAzimuthMeasurements,
1531     NbOfElevationMeasurements,
1532     EnableDiagnostics,
1533     DiagramsFrameReportsFields,
1534     AntennaMode,
1535     VendorSpecificAppCfgTlvTypeRange2(Private<u8>),
1536 }
1537 impl TryFrom<u8> for AppConfigTlvType {
1538     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>1539     fn try_from(value: u8) -> Result<Self, Self::Error> {
1540         match value {
1541             0x0 => Ok(AppConfigTlvType::DeviceType),
1542             0x1 => Ok(AppConfigTlvType::RangingRoundUsage),
1543             0x2 => Ok(AppConfigTlvType::StsConfig),
1544             0x3 => Ok(AppConfigTlvType::MultiNodeMode),
1545             0x4 => Ok(AppConfigTlvType::ChannelNumber),
1546             0x5 => Ok(AppConfigTlvType::NoOfControlee),
1547             0x6 => Ok(AppConfigTlvType::DeviceMacAddress),
1548             0x7 => Ok(AppConfigTlvType::DstMacAddress),
1549             0x8 => Ok(AppConfigTlvType::SlotDuration),
1550             0x9 => Ok(AppConfigTlvType::RangingDuration),
1551             0xa => Ok(AppConfigTlvType::StsIndex),
1552             0xb => Ok(AppConfigTlvType::MacFcsType),
1553             0xc => Ok(AppConfigTlvType::RangingRoundControl),
1554             0xd => Ok(AppConfigTlvType::AoaResultReq),
1555             0xe => Ok(AppConfigTlvType::RngDataNtf),
1556             0xf => Ok(AppConfigTlvType::RngDataNtfProximityNear),
1557             0x10 => Ok(AppConfigTlvType::RngDataNtfProximityFar),
1558             0x11 => Ok(AppConfigTlvType::DeviceRole),
1559             0x12 => Ok(AppConfigTlvType::RframeConfig),
1560             0x13 => Ok(AppConfigTlvType::RssiReporting),
1561             0x14 => Ok(AppConfigTlvType::PreambleCodeIndex),
1562             0x15 => Ok(AppConfigTlvType::SfdId),
1563             0x16 => Ok(AppConfigTlvType::PsduDataRate),
1564             0x17 => Ok(AppConfigTlvType::PreambleDuration),
1565             0x18 => Ok(AppConfigTlvType::LinkLayerMode),
1566             0x19 => Ok(AppConfigTlvType::DataRepetitionCount),
1567             0x1a => Ok(AppConfigTlvType::RangingTimeStruct),
1568             0x1b => Ok(AppConfigTlvType::SlotsPerRr),
1569             0x1c => Ok(AppConfigTlvType::TxAdaptivePayloadPower),
1570             0x1d => Ok(AppConfigTlvType::RngDataNtfAoaBound),
1571             0x1e => Ok(AppConfigTlvType::ResponderSlotIndex),
1572             0x1f => Ok(AppConfigTlvType::PrfMode),
1573             0x20 => Ok(AppConfigTlvType::CapSizeRange),
1574             0x21 => Ok(AppConfigTlvType::TxJitterWindowSize),
1575             0x22 => Ok(AppConfigTlvType::ScheduledMode),
1576             0x23 => Ok(AppConfigTlvType::KeyRotation),
1577             0x24 => Ok(AppConfigTlvType::KeyRotationRate),
1578             0x25 => Ok(AppConfigTlvType::SessionPriority),
1579             0x26 => Ok(AppConfigTlvType::MacAddressMode),
1580             0x27 => Ok(AppConfigTlvType::VendorId),
1581             0x28 => Ok(AppConfigTlvType::StaticStsIv),
1582             0x29 => Ok(AppConfigTlvType::NumberOfStsSegments),
1583             0x2a => Ok(AppConfigTlvType::MaxRrRetry),
1584             0x2b => Ok(AppConfigTlvType::UwbInitiationTime),
1585             0x2c => Ok(AppConfigTlvType::HoppingMode),
1586             0x2d => Ok(AppConfigTlvType::BlockStrideLength),
1587             0x2e => Ok(AppConfigTlvType::ResultReportConfig),
1588             0x2f => Ok(AppConfigTlvType::InBandTerminationAttemptCount),
1589             0x30 => Ok(AppConfigTlvType::SubSessionId),
1590             0x31 => Ok(AppConfigTlvType::BprfPhrDataRate),
1591             0x32 => Ok(AppConfigTlvType::MaxNumberOfMeasurements),
1592             0x33 => Ok(AppConfigTlvType::UlTdoaTxInterval),
1593             0x34 => Ok(AppConfigTlvType::UlTdoaRandomWindow),
1594             0x35 => Ok(AppConfigTlvType::StsLength),
1595             0x36 => Ok(AppConfigTlvType::SuspendRangingRounds),
1596             0x37 => Ok(AppConfigTlvType::UlTdoaNtfReportConfig),
1597             0x38 => Ok(AppConfigTlvType::UlTdoaDeviceId),
1598             0x39 => Ok(AppConfigTlvType::UlTdoaTxTimestamp),
1599             0x3a => Ok(AppConfigTlvType::MinFramesPerRr),
1600             0x3b => Ok(AppConfigTlvType::MtuSize),
1601             0x3c => Ok(AppConfigTlvType::InterFrameInterval),
1602             0x3d => Ok(AppConfigTlvType::DlTdoaRangingMethod),
1603             0x3e => Ok(AppConfigTlvType::DlTdoaTxTimestampConf),
1604             0x3f => Ok(AppConfigTlvType::DlTdoaHopCount),
1605             0x40 => Ok(AppConfigTlvType::DlTdoaAnchorCfo),
1606             0x41 => Ok(AppConfigTlvType::DlTdoaAnchorLocation),
1607             0x42 => Ok(AppConfigTlvType::DlTdoaTxActiveRangingRounds),
1608             0x43 => Ok(AppConfigTlvType::DlTdoaBlockStriding),
1609             0x44 => Ok(AppConfigTlvType::DlTdoaTimeReferenceAnchor),
1610             0x45 => Ok(AppConfigTlvType::SessionKey),
1611             0x46 => Ok(AppConfigTlvType::SubsessionKey),
1612             0x47 => Ok(AppConfigTlvType::SessionDataTransferStatusNtfConfig),
1613             0x48 => Ok(AppConfigTlvType::SessionTimeBase),
1614             0x49 => Ok(AppConfigTlvType::DlTdoaResponderTof),
1615             0x4a => Ok(AppConfigTlvType::SecureRangingNefaLevel),
1616             0x4b => Ok(AppConfigTlvType::SecureRangingCswLength),
1617             0x4c => Ok(AppConfigTlvType::ApplicationDataEndpoint),
1618             0x4d => Ok(AppConfigTlvType::OwrAoaMeasurementNtfPeriod),
1619             0x4e..=0x9f => Ok(AppConfigTlvType::RfuAppCfgTlvTypeRange(Private(value))),
1620             0xa0 => Ok(AppConfigTlvType::CccHopModeKey),
1621             0xa1 => Ok(AppConfigTlvType::CccUwbTime0),
1622             0xa3 => Ok(AppConfigTlvType::CccRangingProtocolVer),
1623             0xa4 => Ok(AppConfigTlvType::CccUwbConfigId),
1624             0xa5 => Ok(AppConfigTlvType::CccPulseshapeCombo),
1625             0xa6 => Ok(AppConfigTlvType::CccUrskTtl),
1626             0xa8 => Ok(AppConfigTlvType::CccLastIndexUsed),
1627             0xa9 => Ok(AppConfigTlvType::AliroMacMode),
1628             0xa0..=0xdf => {
1629                 Ok(AppConfigTlvType::VendorSpecificAppCfgTlvTypeRange1(Private(value)))
1630             }
1631             0xe0..=0xe2 => Ok(AppConfigTlvType::RfuAppCfgTlvTypeRange4(Private(value))),
1632             0xe3 => Ok(AppConfigTlvType::NbOfRangeMeasurements),
1633             0xe4 => Ok(AppConfigTlvType::NbOfAzimuthMeasurements),
1634             0xe5 => Ok(AppConfigTlvType::NbOfElevationMeasurements),
1635             0xe8 => Ok(AppConfigTlvType::EnableDiagnostics),
1636             0xe9 => Ok(AppConfigTlvType::DiagramsFrameReportsFields),
1637             0xea => Ok(AppConfigTlvType::AntennaMode),
1638             0xe3..=0xff => {
1639                 Ok(AppConfigTlvType::VendorSpecificAppCfgTlvTypeRange2(Private(value)))
1640             }
1641         }
1642     }
1643 }
1644 impl From<&AppConfigTlvType> for u8 {
from(value: &AppConfigTlvType) -> Self1645     fn from(value: &AppConfigTlvType) -> Self {
1646         match value {
1647             AppConfigTlvType::DeviceType => 0x0,
1648             AppConfigTlvType::RangingRoundUsage => 0x1,
1649             AppConfigTlvType::StsConfig => 0x2,
1650             AppConfigTlvType::MultiNodeMode => 0x3,
1651             AppConfigTlvType::ChannelNumber => 0x4,
1652             AppConfigTlvType::NoOfControlee => 0x5,
1653             AppConfigTlvType::DeviceMacAddress => 0x6,
1654             AppConfigTlvType::DstMacAddress => 0x7,
1655             AppConfigTlvType::SlotDuration => 0x8,
1656             AppConfigTlvType::RangingDuration => 0x9,
1657             AppConfigTlvType::StsIndex => 0xa,
1658             AppConfigTlvType::MacFcsType => 0xb,
1659             AppConfigTlvType::RangingRoundControl => 0xc,
1660             AppConfigTlvType::AoaResultReq => 0xd,
1661             AppConfigTlvType::RngDataNtf => 0xe,
1662             AppConfigTlvType::RngDataNtfProximityNear => 0xf,
1663             AppConfigTlvType::RngDataNtfProximityFar => 0x10,
1664             AppConfigTlvType::DeviceRole => 0x11,
1665             AppConfigTlvType::RframeConfig => 0x12,
1666             AppConfigTlvType::RssiReporting => 0x13,
1667             AppConfigTlvType::PreambleCodeIndex => 0x14,
1668             AppConfigTlvType::SfdId => 0x15,
1669             AppConfigTlvType::PsduDataRate => 0x16,
1670             AppConfigTlvType::PreambleDuration => 0x17,
1671             AppConfigTlvType::LinkLayerMode => 0x18,
1672             AppConfigTlvType::DataRepetitionCount => 0x19,
1673             AppConfigTlvType::RangingTimeStruct => 0x1a,
1674             AppConfigTlvType::SlotsPerRr => 0x1b,
1675             AppConfigTlvType::TxAdaptivePayloadPower => 0x1c,
1676             AppConfigTlvType::RngDataNtfAoaBound => 0x1d,
1677             AppConfigTlvType::ResponderSlotIndex => 0x1e,
1678             AppConfigTlvType::PrfMode => 0x1f,
1679             AppConfigTlvType::CapSizeRange => 0x20,
1680             AppConfigTlvType::TxJitterWindowSize => 0x21,
1681             AppConfigTlvType::ScheduledMode => 0x22,
1682             AppConfigTlvType::KeyRotation => 0x23,
1683             AppConfigTlvType::KeyRotationRate => 0x24,
1684             AppConfigTlvType::SessionPriority => 0x25,
1685             AppConfigTlvType::MacAddressMode => 0x26,
1686             AppConfigTlvType::VendorId => 0x27,
1687             AppConfigTlvType::StaticStsIv => 0x28,
1688             AppConfigTlvType::NumberOfStsSegments => 0x29,
1689             AppConfigTlvType::MaxRrRetry => 0x2a,
1690             AppConfigTlvType::UwbInitiationTime => 0x2b,
1691             AppConfigTlvType::HoppingMode => 0x2c,
1692             AppConfigTlvType::BlockStrideLength => 0x2d,
1693             AppConfigTlvType::ResultReportConfig => 0x2e,
1694             AppConfigTlvType::InBandTerminationAttemptCount => 0x2f,
1695             AppConfigTlvType::SubSessionId => 0x30,
1696             AppConfigTlvType::BprfPhrDataRate => 0x31,
1697             AppConfigTlvType::MaxNumberOfMeasurements => 0x32,
1698             AppConfigTlvType::UlTdoaTxInterval => 0x33,
1699             AppConfigTlvType::UlTdoaRandomWindow => 0x34,
1700             AppConfigTlvType::StsLength => 0x35,
1701             AppConfigTlvType::SuspendRangingRounds => 0x36,
1702             AppConfigTlvType::UlTdoaNtfReportConfig => 0x37,
1703             AppConfigTlvType::UlTdoaDeviceId => 0x38,
1704             AppConfigTlvType::UlTdoaTxTimestamp => 0x39,
1705             AppConfigTlvType::MinFramesPerRr => 0x3a,
1706             AppConfigTlvType::MtuSize => 0x3b,
1707             AppConfigTlvType::InterFrameInterval => 0x3c,
1708             AppConfigTlvType::DlTdoaRangingMethod => 0x3d,
1709             AppConfigTlvType::DlTdoaTxTimestampConf => 0x3e,
1710             AppConfigTlvType::DlTdoaHopCount => 0x3f,
1711             AppConfigTlvType::DlTdoaAnchorCfo => 0x40,
1712             AppConfigTlvType::DlTdoaAnchorLocation => 0x41,
1713             AppConfigTlvType::DlTdoaTxActiveRangingRounds => 0x42,
1714             AppConfigTlvType::DlTdoaBlockStriding => 0x43,
1715             AppConfigTlvType::DlTdoaTimeReferenceAnchor => 0x44,
1716             AppConfigTlvType::SessionKey => 0x45,
1717             AppConfigTlvType::SubsessionKey => 0x46,
1718             AppConfigTlvType::SessionDataTransferStatusNtfConfig => 0x47,
1719             AppConfigTlvType::SessionTimeBase => 0x48,
1720             AppConfigTlvType::DlTdoaResponderTof => 0x49,
1721             AppConfigTlvType::SecureRangingNefaLevel => 0x4a,
1722             AppConfigTlvType::SecureRangingCswLength => 0x4b,
1723             AppConfigTlvType::ApplicationDataEndpoint => 0x4c,
1724             AppConfigTlvType::OwrAoaMeasurementNtfPeriod => 0x4d,
1725             AppConfigTlvType::RfuAppCfgTlvTypeRange(Private(value)) => *value,
1726             AppConfigTlvType::CccHopModeKey => 0xa0,
1727             AppConfigTlvType::CccUwbTime0 => 0xa1,
1728             AppConfigTlvType::CccRangingProtocolVer => 0xa3,
1729             AppConfigTlvType::CccUwbConfigId => 0xa4,
1730             AppConfigTlvType::CccPulseshapeCombo => 0xa5,
1731             AppConfigTlvType::CccUrskTtl => 0xa6,
1732             AppConfigTlvType::CccLastIndexUsed => 0xa8,
1733             AppConfigTlvType::AliroMacMode => 0xa9,
1734             AppConfigTlvType::VendorSpecificAppCfgTlvTypeRange1(Private(value)) => *value,
1735             AppConfigTlvType::RfuAppCfgTlvTypeRange4(Private(value)) => *value,
1736             AppConfigTlvType::NbOfRangeMeasurements => 0xe3,
1737             AppConfigTlvType::NbOfAzimuthMeasurements => 0xe4,
1738             AppConfigTlvType::NbOfElevationMeasurements => 0xe5,
1739             AppConfigTlvType::EnableDiagnostics => 0xe8,
1740             AppConfigTlvType::DiagramsFrameReportsFields => 0xe9,
1741             AppConfigTlvType::AntennaMode => 0xea,
1742             AppConfigTlvType::VendorSpecificAppCfgTlvTypeRange2(Private(value)) => *value,
1743         }
1744     }
1745 }
1746 impl From<AppConfigTlvType> for u8 {
from(value: AppConfigTlvType) -> Self1747     fn from(value: AppConfigTlvType) -> Self {
1748         (&value).into()
1749     }
1750 }
1751 impl From<AppConfigTlvType> for i16 {
from(value: AppConfigTlvType) -> Self1752     fn from(value: AppConfigTlvType) -> Self {
1753         u8::from(value) as Self
1754     }
1755 }
1756 impl From<AppConfigTlvType> for i32 {
from(value: AppConfigTlvType) -> Self1757     fn from(value: AppConfigTlvType) -> Self {
1758         u8::from(value) as Self
1759     }
1760 }
1761 impl From<AppConfigTlvType> for i64 {
from(value: AppConfigTlvType) -> Self1762     fn from(value: AppConfigTlvType) -> Self {
1763         u8::from(value) as Self
1764     }
1765 }
1766 impl From<AppConfigTlvType> for u16 {
from(value: AppConfigTlvType) -> Self1767     fn from(value: AppConfigTlvType) -> Self {
1768         u8::from(value) as Self
1769     }
1770 }
1771 impl From<AppConfigTlvType> for u32 {
from(value: AppConfigTlvType) -> Self1772     fn from(value: AppConfigTlvType) -> Self {
1773         u8::from(value) as Self
1774     }
1775 }
1776 impl From<AppConfigTlvType> for u64 {
from(value: AppConfigTlvType) -> Self1777     fn from(value: AppConfigTlvType) -> Self {
1778         u8::from(value) as Self
1779     }
1780 }
1781 #[repr(u64)]
1782 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
1783 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1784 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
1785 pub enum FrameReportTlvType {
1786     Rssi = 0x0,
1787     Aoa = 0x1,
1788     Cir = 0x2,
1789     SegmentMetrics = 0x6,
1790 }
1791 impl TryFrom<u8> for FrameReportTlvType {
1792     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>1793     fn try_from(value: u8) -> Result<Self, Self::Error> {
1794         match value {
1795             0x0 => Ok(FrameReportTlvType::Rssi),
1796             0x1 => Ok(FrameReportTlvType::Aoa),
1797             0x2 => Ok(FrameReportTlvType::Cir),
1798             0x6 => Ok(FrameReportTlvType::SegmentMetrics),
1799             _ => Err(value),
1800         }
1801     }
1802 }
1803 impl From<&FrameReportTlvType> for u8 {
from(value: &FrameReportTlvType) -> Self1804     fn from(value: &FrameReportTlvType) -> Self {
1805         match value {
1806             FrameReportTlvType::Rssi => 0x0,
1807             FrameReportTlvType::Aoa => 0x1,
1808             FrameReportTlvType::Cir => 0x2,
1809             FrameReportTlvType::SegmentMetrics => 0x6,
1810         }
1811     }
1812 }
1813 impl From<FrameReportTlvType> for u8 {
from(value: FrameReportTlvType) -> Self1814     fn from(value: FrameReportTlvType) -> Self {
1815         (&value).into()
1816     }
1817 }
1818 impl From<FrameReportTlvType> for i16 {
from(value: FrameReportTlvType) -> Self1819     fn from(value: FrameReportTlvType) -> Self {
1820         u8::from(value) as Self
1821     }
1822 }
1823 impl From<FrameReportTlvType> for i32 {
from(value: FrameReportTlvType) -> Self1824     fn from(value: FrameReportTlvType) -> Self {
1825         u8::from(value) as Self
1826     }
1827 }
1828 impl From<FrameReportTlvType> for i64 {
from(value: FrameReportTlvType) -> Self1829     fn from(value: FrameReportTlvType) -> Self {
1830         u8::from(value) as Self
1831     }
1832 }
1833 impl From<FrameReportTlvType> for u16 {
from(value: FrameReportTlvType) -> Self1834     fn from(value: FrameReportTlvType) -> Self {
1835         u8::from(value) as Self
1836     }
1837 }
1838 impl From<FrameReportTlvType> for u32 {
from(value: FrameReportTlvType) -> Self1839     fn from(value: FrameReportTlvType) -> Self {
1840         u8::from(value) as Self
1841     }
1842 }
1843 impl From<FrameReportTlvType> for u64 {
from(value: FrameReportTlvType) -> Self1844     fn from(value: FrameReportTlvType) -> Self {
1845         u8::from(value) as Self
1846     }
1847 }
1848 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
1849 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1850 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
1851 pub enum CapTlvType {
1852     SupportedV1FiraPhyVersionRangeV2MaxMessageSize,
1853     SupportedV1FiraMacVersionRangeV2MaxDataPayloadSize,
1854     SupportedV1DeviceRolesV2FiraPhyVersionRange,
1855     SupportedV1RangingMethodV2FiraMacVersionRange,
1856     SupportedV1StsConfigV2DeviceType,
1857     SupportedV1MultiNodeModesV2DeviceRoles,
1858     SupportedV1RangingTimeStructV2RangingMethod,
1859     SupportedV1ScheduledModeV2StsConfig,
1860     SupportedV1HoppingModeV2MultiNodeMode,
1861     SupportedV1BlockStridingV2RangingTimeStruct,
1862     SupportedV1UwbInitiationTimeV2ScheduleMode,
1863     SupportedV1ChannelsV2HoppingMode,
1864     SupportedV1RframeConfigV2BlockStriding,
1865     SupportedV1CcConstraintLengthV2UwbInitiationTime,
1866     SupportedV1BprfParameterSetsV2Channels,
1867     SupportedV1HprfParameterSetsV2RframeConfig,
1868     SupportedV1AoaV2CcConstraintLength,
1869     SupportedV1ExtendedMacAddressV2BprfParameterSets,
1870     SupportedV1MaxMessageSizeV2HprfParameterSets,
1871     SupportedV1MaxDataPacketPayloadSizeV2AoaSupport,
1872     SupportedV2ExtendedMacAddress,
1873     SupportedV2Assigned,
1874     SupportedV2SessionKeyLength,
1875     SupportedV2DtAnchorMaxActiveRr,
1876     SupportedV2DtTagMaxActiveRr,
1877     SupportedV2DtTagBlockShipping,
1878     SupportedV2PsduLengthSupport,
1879     RfuCapTlvTypeRange1(Private<u8>),
1880     CccSupportedChapsPerSlot,
1881     CccSupportedSyncCodes,
1882     CccSupportedHoppingConfigModesAndSequences,
1883     CccSupportedChannels,
1884     CccSupportedVersions,
1885     CccSupportedUwbConfigs,
1886     CccSupportedPulseShapeCombos,
1887     CccSupportedRanMultiplier,
1888     CccSupportedMaxRangingSessionNumber,
1889     CccSupportedMinUwbInitiationTimeMs,
1890     CccPrioritizedChannelList,
1891     CccSupportedUwbsMaxPpm,
1892     AliroSupportedMacModes,
1893     RadarSupport,
1894     VendorSpecificCapTlvTypeRange1(Private<u8>),
1895     SupportedPowerStats,
1896     VendorSpecificCapTlvTypeRange2(Private<u8>),
1897     RfuCapTlvTypeRange2(Private<u8>),
1898     SupportedAoaResultReqAntennaInterleaving,
1899     SupportedMinRangingIntervalMs,
1900     SupportedRangeDataNtfConfig,
1901     SupportedRssiReporting,
1902     SupportedDiagnostics,
1903     SupportedMinSlotDurationRstu,
1904     SupportedMaxRangingSessionNumber,
1905     VendorSpecificCapTlvTypeRange3(Private<u8>),
1906 }
1907 impl TryFrom<u8> for CapTlvType {
1908     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>1909     fn try_from(value: u8) -> Result<Self, Self::Error> {
1910         match value {
1911             0x0 => Ok(CapTlvType::SupportedV1FiraPhyVersionRangeV2MaxMessageSize),
1912             0x1 => Ok(CapTlvType::SupportedV1FiraMacVersionRangeV2MaxDataPayloadSize),
1913             0x2 => Ok(CapTlvType::SupportedV1DeviceRolesV2FiraPhyVersionRange),
1914             0x3 => Ok(CapTlvType::SupportedV1RangingMethodV2FiraMacVersionRange),
1915             0x4 => Ok(CapTlvType::SupportedV1StsConfigV2DeviceType),
1916             0x5 => Ok(CapTlvType::SupportedV1MultiNodeModesV2DeviceRoles),
1917             0x6 => Ok(CapTlvType::SupportedV1RangingTimeStructV2RangingMethod),
1918             0x7 => Ok(CapTlvType::SupportedV1ScheduledModeV2StsConfig),
1919             0x8 => Ok(CapTlvType::SupportedV1HoppingModeV2MultiNodeMode),
1920             0x9 => Ok(CapTlvType::SupportedV1BlockStridingV2RangingTimeStruct),
1921             0xa => Ok(CapTlvType::SupportedV1UwbInitiationTimeV2ScheduleMode),
1922             0xb => Ok(CapTlvType::SupportedV1ChannelsV2HoppingMode),
1923             0xc => Ok(CapTlvType::SupportedV1RframeConfigV2BlockStriding),
1924             0xd => Ok(CapTlvType::SupportedV1CcConstraintLengthV2UwbInitiationTime),
1925             0xe => Ok(CapTlvType::SupportedV1BprfParameterSetsV2Channels),
1926             0xf => Ok(CapTlvType::SupportedV1HprfParameterSetsV2RframeConfig),
1927             0x10 => Ok(CapTlvType::SupportedV1AoaV2CcConstraintLength),
1928             0x11 => Ok(CapTlvType::SupportedV1ExtendedMacAddressV2BprfParameterSets),
1929             0x12 => Ok(CapTlvType::SupportedV1MaxMessageSizeV2HprfParameterSets),
1930             0x13 => Ok(CapTlvType::SupportedV1MaxDataPacketPayloadSizeV2AoaSupport),
1931             0x14 => Ok(CapTlvType::SupportedV2ExtendedMacAddress),
1932             0x15 => Ok(CapTlvType::SupportedV2Assigned),
1933             0x16 => Ok(CapTlvType::SupportedV2SessionKeyLength),
1934             0x17 => Ok(CapTlvType::SupportedV2DtAnchorMaxActiveRr),
1935             0x18 => Ok(CapTlvType::SupportedV2DtTagMaxActiveRr),
1936             0x19 => Ok(CapTlvType::SupportedV2DtTagBlockShipping),
1937             0x1a => Ok(CapTlvType::SupportedV2PsduLengthSupport),
1938             0x1b..=0x9f => Ok(CapTlvType::RfuCapTlvTypeRange1(Private(value))),
1939             0xa0 => Ok(CapTlvType::CccSupportedChapsPerSlot),
1940             0xa1 => Ok(CapTlvType::CccSupportedSyncCodes),
1941             0xa2 => Ok(CapTlvType::CccSupportedHoppingConfigModesAndSequences),
1942             0xa3 => Ok(CapTlvType::CccSupportedChannels),
1943             0xa4 => Ok(CapTlvType::CccSupportedVersions),
1944             0xa5 => Ok(CapTlvType::CccSupportedUwbConfigs),
1945             0xa6 => Ok(CapTlvType::CccSupportedPulseShapeCombos),
1946             0xa7 => Ok(CapTlvType::CccSupportedRanMultiplier),
1947             0xa8 => Ok(CapTlvType::CccSupportedMaxRangingSessionNumber),
1948             0xa9 => Ok(CapTlvType::CccSupportedMinUwbInitiationTimeMs),
1949             0xaa => Ok(CapTlvType::CccPrioritizedChannelList),
1950             0xab => Ok(CapTlvType::CccSupportedUwbsMaxPpm),
1951             0xac => Ok(CapTlvType::AliroSupportedMacModes),
1952             0xb0 => Ok(CapTlvType::RadarSupport),
1953             0xa0..=0xbf => Ok(CapTlvType::VendorSpecificCapTlvTypeRange1(Private(value))),
1954             0xc0 => Ok(CapTlvType::SupportedPowerStats),
1955             0xc1..=0xdf => Ok(CapTlvType::VendorSpecificCapTlvTypeRange2(Private(value))),
1956             0xe0..=0xe2 => Ok(CapTlvType::RfuCapTlvTypeRange2(Private(value))),
1957             0xe3 => Ok(CapTlvType::SupportedAoaResultReqAntennaInterleaving),
1958             0xe4 => Ok(CapTlvType::SupportedMinRangingIntervalMs),
1959             0xe5 => Ok(CapTlvType::SupportedRangeDataNtfConfig),
1960             0xe6 => Ok(CapTlvType::SupportedRssiReporting),
1961             0xe7 => Ok(CapTlvType::SupportedDiagnostics),
1962             0xe8 => Ok(CapTlvType::SupportedMinSlotDurationRstu),
1963             0xe9 => Ok(CapTlvType::SupportedMaxRangingSessionNumber),
1964             0xe3..=0xff => Ok(CapTlvType::VendorSpecificCapTlvTypeRange3(Private(value))),
1965         }
1966     }
1967 }
1968 impl From<&CapTlvType> for u8 {
from(value: &CapTlvType) -> Self1969     fn from(value: &CapTlvType) -> Self {
1970         match value {
1971             CapTlvType::SupportedV1FiraPhyVersionRangeV2MaxMessageSize => 0x0,
1972             CapTlvType::SupportedV1FiraMacVersionRangeV2MaxDataPayloadSize => 0x1,
1973             CapTlvType::SupportedV1DeviceRolesV2FiraPhyVersionRange => 0x2,
1974             CapTlvType::SupportedV1RangingMethodV2FiraMacVersionRange => 0x3,
1975             CapTlvType::SupportedV1StsConfigV2DeviceType => 0x4,
1976             CapTlvType::SupportedV1MultiNodeModesV2DeviceRoles => 0x5,
1977             CapTlvType::SupportedV1RangingTimeStructV2RangingMethod => 0x6,
1978             CapTlvType::SupportedV1ScheduledModeV2StsConfig => 0x7,
1979             CapTlvType::SupportedV1HoppingModeV2MultiNodeMode => 0x8,
1980             CapTlvType::SupportedV1BlockStridingV2RangingTimeStruct => 0x9,
1981             CapTlvType::SupportedV1UwbInitiationTimeV2ScheduleMode => 0xa,
1982             CapTlvType::SupportedV1ChannelsV2HoppingMode => 0xb,
1983             CapTlvType::SupportedV1RframeConfigV2BlockStriding => 0xc,
1984             CapTlvType::SupportedV1CcConstraintLengthV2UwbInitiationTime => 0xd,
1985             CapTlvType::SupportedV1BprfParameterSetsV2Channels => 0xe,
1986             CapTlvType::SupportedV1HprfParameterSetsV2RframeConfig => 0xf,
1987             CapTlvType::SupportedV1AoaV2CcConstraintLength => 0x10,
1988             CapTlvType::SupportedV1ExtendedMacAddressV2BprfParameterSets => 0x11,
1989             CapTlvType::SupportedV1MaxMessageSizeV2HprfParameterSets => 0x12,
1990             CapTlvType::SupportedV1MaxDataPacketPayloadSizeV2AoaSupport => 0x13,
1991             CapTlvType::SupportedV2ExtendedMacAddress => 0x14,
1992             CapTlvType::SupportedV2Assigned => 0x15,
1993             CapTlvType::SupportedV2SessionKeyLength => 0x16,
1994             CapTlvType::SupportedV2DtAnchorMaxActiveRr => 0x17,
1995             CapTlvType::SupportedV2DtTagMaxActiveRr => 0x18,
1996             CapTlvType::SupportedV2DtTagBlockShipping => 0x19,
1997             CapTlvType::SupportedV2PsduLengthSupport => 0x1a,
1998             CapTlvType::RfuCapTlvTypeRange1(Private(value)) => *value,
1999             CapTlvType::CccSupportedChapsPerSlot => 0xa0,
2000             CapTlvType::CccSupportedSyncCodes => 0xa1,
2001             CapTlvType::CccSupportedHoppingConfigModesAndSequences => 0xa2,
2002             CapTlvType::CccSupportedChannels => 0xa3,
2003             CapTlvType::CccSupportedVersions => 0xa4,
2004             CapTlvType::CccSupportedUwbConfigs => 0xa5,
2005             CapTlvType::CccSupportedPulseShapeCombos => 0xa6,
2006             CapTlvType::CccSupportedRanMultiplier => 0xa7,
2007             CapTlvType::CccSupportedMaxRangingSessionNumber => 0xa8,
2008             CapTlvType::CccSupportedMinUwbInitiationTimeMs => 0xa9,
2009             CapTlvType::CccPrioritizedChannelList => 0xaa,
2010             CapTlvType::CccSupportedUwbsMaxPpm => 0xab,
2011             CapTlvType::AliroSupportedMacModes => 0xac,
2012             CapTlvType::RadarSupport => 0xb0,
2013             CapTlvType::VendorSpecificCapTlvTypeRange1(Private(value)) => *value,
2014             CapTlvType::SupportedPowerStats => 0xc0,
2015             CapTlvType::VendorSpecificCapTlvTypeRange2(Private(value)) => *value,
2016             CapTlvType::RfuCapTlvTypeRange2(Private(value)) => *value,
2017             CapTlvType::SupportedAoaResultReqAntennaInterleaving => 0xe3,
2018             CapTlvType::SupportedMinRangingIntervalMs => 0xe4,
2019             CapTlvType::SupportedRangeDataNtfConfig => 0xe5,
2020             CapTlvType::SupportedRssiReporting => 0xe6,
2021             CapTlvType::SupportedDiagnostics => 0xe7,
2022             CapTlvType::SupportedMinSlotDurationRstu => 0xe8,
2023             CapTlvType::SupportedMaxRangingSessionNumber => 0xe9,
2024             CapTlvType::VendorSpecificCapTlvTypeRange3(Private(value)) => *value,
2025         }
2026     }
2027 }
2028 impl From<CapTlvType> for u8 {
from(value: CapTlvType) -> Self2029     fn from(value: CapTlvType) -> Self {
2030         (&value).into()
2031     }
2032 }
2033 impl From<CapTlvType> for i16 {
from(value: CapTlvType) -> Self2034     fn from(value: CapTlvType) -> Self {
2035         u8::from(value) as Self
2036     }
2037 }
2038 impl From<CapTlvType> for i32 {
from(value: CapTlvType) -> Self2039     fn from(value: CapTlvType) -> Self {
2040         u8::from(value) as Self
2041     }
2042 }
2043 impl From<CapTlvType> for i64 {
from(value: CapTlvType) -> Self2044     fn from(value: CapTlvType) -> Self {
2045         u8::from(value) as Self
2046     }
2047 }
2048 impl From<CapTlvType> for u16 {
from(value: CapTlvType) -> Self2049     fn from(value: CapTlvType) -> Self {
2050         u8::from(value) as Self
2051     }
2052 }
2053 impl From<CapTlvType> for u32 {
from(value: CapTlvType) -> Self2054     fn from(value: CapTlvType) -> Self {
2055         u8::from(value) as Self
2056     }
2057 }
2058 impl From<CapTlvType> for u64 {
from(value: CapTlvType) -> Self2059     fn from(value: CapTlvType) -> Self {
2060         u8::from(value) as Self
2061     }
2062 }
2063 #[repr(u64)]
2064 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
2065 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2066 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
2067 pub enum AoaResultReqType {
2068     AoaDisable = 0x0,
2069     AoaEnable = 0x1,
2070     AoaEnableAzimuth = 0x2,
2071     AoaEnableElevation = 0x3,
2072     AoaEnableInterleaved = 0xf0,
2073 }
2074 impl TryFrom<u8> for AoaResultReqType {
2075     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>2076     fn try_from(value: u8) -> Result<Self, Self::Error> {
2077         match value {
2078             0x0 => Ok(AoaResultReqType::AoaDisable),
2079             0x1 => Ok(AoaResultReqType::AoaEnable),
2080             0x2 => Ok(AoaResultReqType::AoaEnableAzimuth),
2081             0x3 => Ok(AoaResultReqType::AoaEnableElevation),
2082             0xf0 => Ok(AoaResultReqType::AoaEnableInterleaved),
2083             _ => Err(value),
2084         }
2085     }
2086 }
2087 impl From<&AoaResultReqType> for u8 {
from(value: &AoaResultReqType) -> Self2088     fn from(value: &AoaResultReqType) -> Self {
2089         match value {
2090             AoaResultReqType::AoaDisable => 0x0,
2091             AoaResultReqType::AoaEnable => 0x1,
2092             AoaResultReqType::AoaEnableAzimuth => 0x2,
2093             AoaResultReqType::AoaEnableElevation => 0x3,
2094             AoaResultReqType::AoaEnableInterleaved => 0xf0,
2095         }
2096     }
2097 }
2098 impl From<AoaResultReqType> for u8 {
from(value: AoaResultReqType) -> Self2099     fn from(value: AoaResultReqType) -> Self {
2100         (&value).into()
2101     }
2102 }
2103 impl From<AoaResultReqType> for i16 {
from(value: AoaResultReqType) -> Self2104     fn from(value: AoaResultReqType) -> Self {
2105         u8::from(value) as Self
2106     }
2107 }
2108 impl From<AoaResultReqType> for i32 {
from(value: AoaResultReqType) -> Self2109     fn from(value: AoaResultReqType) -> Self {
2110         u8::from(value) as Self
2111     }
2112 }
2113 impl From<AoaResultReqType> for i64 {
from(value: AoaResultReqType) -> Self2114     fn from(value: AoaResultReqType) -> Self {
2115         u8::from(value) as Self
2116     }
2117 }
2118 impl From<AoaResultReqType> for u16 {
from(value: AoaResultReqType) -> Self2119     fn from(value: AoaResultReqType) -> Self {
2120         u8::from(value) as Self
2121     }
2122 }
2123 impl From<AoaResultReqType> for u32 {
from(value: AoaResultReqType) -> Self2124     fn from(value: AoaResultReqType) -> Self {
2125         u8::from(value) as Self
2126     }
2127 }
2128 impl From<AoaResultReqType> for u64 {
from(value: AoaResultReqType) -> Self2129     fn from(value: AoaResultReqType) -> Self {
2130         u8::from(value) as Self
2131     }
2132 }
2133 #[repr(u64)]
2134 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
2135 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2136 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
2137 pub enum DeviceState {
2138     DeviceStateReady = 0x1,
2139     DeviceStateActive = 0x2,
2140     DeviceStateError = 0xff,
2141 }
2142 impl TryFrom<u8> for DeviceState {
2143     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>2144     fn try_from(value: u8) -> Result<Self, Self::Error> {
2145         match value {
2146             0x1 => Ok(DeviceState::DeviceStateReady),
2147             0x2 => Ok(DeviceState::DeviceStateActive),
2148             0xff => Ok(DeviceState::DeviceStateError),
2149             _ => Err(value),
2150         }
2151     }
2152 }
2153 impl From<&DeviceState> for u8 {
from(value: &DeviceState) -> Self2154     fn from(value: &DeviceState) -> Self {
2155         match value {
2156             DeviceState::DeviceStateReady => 0x1,
2157             DeviceState::DeviceStateActive => 0x2,
2158             DeviceState::DeviceStateError => 0xff,
2159         }
2160     }
2161 }
2162 impl From<DeviceState> for u8 {
from(value: DeviceState) -> Self2163     fn from(value: DeviceState) -> Self {
2164         (&value).into()
2165     }
2166 }
2167 impl From<DeviceState> for i16 {
from(value: DeviceState) -> Self2168     fn from(value: DeviceState) -> Self {
2169         u8::from(value) as Self
2170     }
2171 }
2172 impl From<DeviceState> for i32 {
from(value: DeviceState) -> Self2173     fn from(value: DeviceState) -> Self {
2174         u8::from(value) as Self
2175     }
2176 }
2177 impl From<DeviceState> for i64 {
from(value: DeviceState) -> Self2178     fn from(value: DeviceState) -> Self {
2179         u8::from(value) as Self
2180     }
2181 }
2182 impl From<DeviceState> for u16 {
from(value: DeviceState) -> Self2183     fn from(value: DeviceState) -> Self {
2184         u8::from(value) as Self
2185     }
2186 }
2187 impl From<DeviceState> for u32 {
from(value: DeviceState) -> Self2188     fn from(value: DeviceState) -> Self {
2189         u8::from(value) as Self
2190     }
2191 }
2192 impl From<DeviceState> for u64 {
from(value: DeviceState) -> Self2193     fn from(value: DeviceState) -> Self {
2194         u8::from(value) as Self
2195     }
2196 }
2197 #[repr(u64)]
2198 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
2199 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2200 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
2201 pub enum SessionState {
2202     SessionStateInit = 0x0,
2203     SessionStateDeinit = 0x1,
2204     SessionStateActive = 0x2,
2205     SessionStateIdle = 0x3,
2206 }
2207 impl TryFrom<u8> for SessionState {
2208     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>2209     fn try_from(value: u8) -> Result<Self, Self::Error> {
2210         match value {
2211             0x0 => Ok(SessionState::SessionStateInit),
2212             0x1 => Ok(SessionState::SessionStateDeinit),
2213             0x2 => Ok(SessionState::SessionStateActive),
2214             0x3 => Ok(SessionState::SessionStateIdle),
2215             _ => Err(value),
2216         }
2217     }
2218 }
2219 impl From<&SessionState> for u8 {
from(value: &SessionState) -> Self2220     fn from(value: &SessionState) -> Self {
2221         match value {
2222             SessionState::SessionStateInit => 0x0,
2223             SessionState::SessionStateDeinit => 0x1,
2224             SessionState::SessionStateActive => 0x2,
2225             SessionState::SessionStateIdle => 0x3,
2226         }
2227     }
2228 }
2229 impl From<SessionState> for u8 {
from(value: SessionState) -> Self2230     fn from(value: SessionState) -> Self {
2231         (&value).into()
2232     }
2233 }
2234 impl From<SessionState> for i16 {
from(value: SessionState) -> Self2235     fn from(value: SessionState) -> Self {
2236         u8::from(value) as Self
2237     }
2238 }
2239 impl From<SessionState> for i32 {
from(value: SessionState) -> Self2240     fn from(value: SessionState) -> Self {
2241         u8::from(value) as Self
2242     }
2243 }
2244 impl From<SessionState> for i64 {
from(value: SessionState) -> Self2245     fn from(value: SessionState) -> Self {
2246         u8::from(value) as Self
2247     }
2248 }
2249 impl From<SessionState> for u16 {
from(value: SessionState) -> Self2250     fn from(value: SessionState) -> Self {
2251         u8::from(value) as Self
2252     }
2253 }
2254 impl From<SessionState> for u32 {
from(value: SessionState) -> Self2255     fn from(value: SessionState) -> Self {
2256         u8::from(value) as Self
2257     }
2258 }
2259 impl From<SessionState> for u64 {
from(value: SessionState) -> Self2260     fn from(value: SessionState) -> Self {
2261         u8::from(value) as Self
2262     }
2263 }
2264 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
2265 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2266 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
2267 pub enum ReasonCode {
2268     StateChangeWithSessionManagementCommands,
2269     MaxRangingRoundRetryCountReached,
2270     MaxNumberOfMeasurementsReached,
2271     SessionSuspendedDueToInbandSignal,
2272     SessionResumedDueToInbandSignal,
2273     SessionStoppedDueToInbandSignal,
2274     RfuReasonCodeRange1(Private<u8>),
2275     ErrorInvalidUlTdoaRandomWindow,
2276     ErrorMinRframesPerRrNotSupported,
2277     ErrorInterFrameIntervalNotSupported,
2278     ErrorSlotLengthNotSupported,
2279     ErrorInsufficientSlotsPerRr,
2280     ErrorMacAddressModeNotSupported,
2281     ErrorInvalidRangingDuration,
2282     ErrorInvalidStsConfig,
2283     ErrorInvalidRframeConfig,
2284     ErrorHusNotEnoughSlots,
2285     ErrorHusCfpPhaseTooShort,
2286     ErrorHusCapPhaseTooShort,
2287     ErrorHusOthers,
2288     ErrorStatusSessionKeyNotFound,
2289     ErrorStatusSubSessionKeyNotFound,
2290     ErrorInvalidPreambleCodeIndex,
2291     ErrorInvalidSfdId,
2292     ErrorInvalidPsduDataRate,
2293     ErrorInvalidPhrDataRate,
2294     ErrorInvalidPreambleDuration,
2295     ErrorInvalidStsLength,
2296     ErrorInvalidNumOfStsSegments,
2297     ErrorInvalidNumOfControlees,
2298     ErrorMaxRangingReplyTimeExceeded,
2299     ErrorInvalidDstAddressList,
2300     ErrorInvalidOrNotFoundSubSessionId,
2301     ErrorInvalidResultReportConfig,
2302     ErrorInvalidRangingRoundControlConfig,
2303     ErrorInvalidRangingRoundUsage,
2304     ErrorInvalidMultiNodeMode,
2305     ErrorRdsFetchFailure,
2306     ErrorRefUwbSessionDoesNotExist,
2307     ErrorRefUwbSessionRangingDurationMismatch,
2308     ErrorRefUwbSessionInvalidOffsetTime,
2309     ErrorRefUwbSessionLost,
2310     ErrorDtAnchorRangingRoundsNotConfigured,
2311     ErrorDtTagRangingRoundsNotConfigured,
2312     RfuReasonCodeRange2(Private<u8>),
2313     ErrorInvalidChannelWithAoa,
2314     ErrorStoppedDueToOtherSessionConflict,
2315     VendorSpecificReasonCodeRange1(Private<u8>),
2316     SessionStoppedDueToMaxStsIndexValue,
2317     VendorSpecificReasonCodeRange2(Private<u8>),
2318     VendorSpecificReasonCode2,
2319 }
2320 impl TryFrom<u8> for ReasonCode {
2321     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>2322     fn try_from(value: u8) -> Result<Self, Self::Error> {
2323         match value {
2324             0x0 => Ok(ReasonCode::StateChangeWithSessionManagementCommands),
2325             0x1 => Ok(ReasonCode::MaxRangingRoundRetryCountReached),
2326             0x2 => Ok(ReasonCode::MaxNumberOfMeasurementsReached),
2327             0x3 => Ok(ReasonCode::SessionSuspendedDueToInbandSignal),
2328             0x4 => Ok(ReasonCode::SessionResumedDueToInbandSignal),
2329             0x5 => Ok(ReasonCode::SessionStoppedDueToInbandSignal),
2330             0x6..=0x1c => Ok(ReasonCode::RfuReasonCodeRange1(Private(value))),
2331             0x1d => Ok(ReasonCode::ErrorInvalidUlTdoaRandomWindow),
2332             0x1e => Ok(ReasonCode::ErrorMinRframesPerRrNotSupported),
2333             0x1f => Ok(ReasonCode::ErrorInterFrameIntervalNotSupported),
2334             0x20 => Ok(ReasonCode::ErrorSlotLengthNotSupported),
2335             0x21 => Ok(ReasonCode::ErrorInsufficientSlotsPerRr),
2336             0x22 => Ok(ReasonCode::ErrorMacAddressModeNotSupported),
2337             0x23 => Ok(ReasonCode::ErrorInvalidRangingDuration),
2338             0x24 => Ok(ReasonCode::ErrorInvalidStsConfig),
2339             0x25 => Ok(ReasonCode::ErrorInvalidRframeConfig),
2340             0x26 => Ok(ReasonCode::ErrorHusNotEnoughSlots),
2341             0x27 => Ok(ReasonCode::ErrorHusCfpPhaseTooShort),
2342             0x28 => Ok(ReasonCode::ErrorHusCapPhaseTooShort),
2343             0x29 => Ok(ReasonCode::ErrorHusOthers),
2344             0x2a => Ok(ReasonCode::ErrorStatusSessionKeyNotFound),
2345             0x2b => Ok(ReasonCode::ErrorStatusSubSessionKeyNotFound),
2346             0x2c => Ok(ReasonCode::ErrorInvalidPreambleCodeIndex),
2347             0x2d => Ok(ReasonCode::ErrorInvalidSfdId),
2348             0x2e => Ok(ReasonCode::ErrorInvalidPsduDataRate),
2349             0x2f => Ok(ReasonCode::ErrorInvalidPhrDataRate),
2350             0x30 => Ok(ReasonCode::ErrorInvalidPreambleDuration),
2351             0x31 => Ok(ReasonCode::ErrorInvalidStsLength),
2352             0x32 => Ok(ReasonCode::ErrorInvalidNumOfStsSegments),
2353             0x33 => Ok(ReasonCode::ErrorInvalidNumOfControlees),
2354             0x34 => Ok(ReasonCode::ErrorMaxRangingReplyTimeExceeded),
2355             0x35 => Ok(ReasonCode::ErrorInvalidDstAddressList),
2356             0x36 => Ok(ReasonCode::ErrorInvalidOrNotFoundSubSessionId),
2357             0x37 => Ok(ReasonCode::ErrorInvalidResultReportConfig),
2358             0x38 => Ok(ReasonCode::ErrorInvalidRangingRoundControlConfig),
2359             0x39 => Ok(ReasonCode::ErrorInvalidRangingRoundUsage),
2360             0x3a => Ok(ReasonCode::ErrorInvalidMultiNodeMode),
2361             0x3b => Ok(ReasonCode::ErrorRdsFetchFailure),
2362             0x3c => Ok(ReasonCode::ErrorRefUwbSessionDoesNotExist),
2363             0x3d => Ok(ReasonCode::ErrorRefUwbSessionRangingDurationMismatch),
2364             0x3e => Ok(ReasonCode::ErrorRefUwbSessionInvalidOffsetTime),
2365             0x3f => Ok(ReasonCode::ErrorRefUwbSessionLost),
2366             0x40 => Ok(ReasonCode::ErrorDtAnchorRangingRoundsNotConfigured),
2367             0x41 => Ok(ReasonCode::ErrorDtTagRangingRoundsNotConfigured),
2368             0x40..=0x7f => Ok(ReasonCode::RfuReasonCodeRange2(Private(value))),
2369             0x80 => Ok(ReasonCode::ErrorInvalidChannelWithAoa),
2370             0x81 => Ok(ReasonCode::ErrorStoppedDueToOtherSessionConflict),
2371             0x80..=0xa1 => Ok(ReasonCode::VendorSpecificReasonCodeRange1(Private(value))),
2372             0xa2 => Ok(ReasonCode::SessionStoppedDueToMaxStsIndexValue),
2373             0xa3..=0xfe => Ok(ReasonCode::VendorSpecificReasonCodeRange2(Private(value))),
2374             0xff => Ok(ReasonCode::VendorSpecificReasonCode2),
2375         }
2376     }
2377 }
2378 impl From<&ReasonCode> for u8 {
from(value: &ReasonCode) -> Self2379     fn from(value: &ReasonCode) -> Self {
2380         match value {
2381             ReasonCode::StateChangeWithSessionManagementCommands => 0x0,
2382             ReasonCode::MaxRangingRoundRetryCountReached => 0x1,
2383             ReasonCode::MaxNumberOfMeasurementsReached => 0x2,
2384             ReasonCode::SessionSuspendedDueToInbandSignal => 0x3,
2385             ReasonCode::SessionResumedDueToInbandSignal => 0x4,
2386             ReasonCode::SessionStoppedDueToInbandSignal => 0x5,
2387             ReasonCode::RfuReasonCodeRange1(Private(value)) => *value,
2388             ReasonCode::ErrorInvalidUlTdoaRandomWindow => 0x1d,
2389             ReasonCode::ErrorMinRframesPerRrNotSupported => 0x1e,
2390             ReasonCode::ErrorInterFrameIntervalNotSupported => 0x1f,
2391             ReasonCode::ErrorSlotLengthNotSupported => 0x20,
2392             ReasonCode::ErrorInsufficientSlotsPerRr => 0x21,
2393             ReasonCode::ErrorMacAddressModeNotSupported => 0x22,
2394             ReasonCode::ErrorInvalidRangingDuration => 0x23,
2395             ReasonCode::ErrorInvalidStsConfig => 0x24,
2396             ReasonCode::ErrorInvalidRframeConfig => 0x25,
2397             ReasonCode::ErrorHusNotEnoughSlots => 0x26,
2398             ReasonCode::ErrorHusCfpPhaseTooShort => 0x27,
2399             ReasonCode::ErrorHusCapPhaseTooShort => 0x28,
2400             ReasonCode::ErrorHusOthers => 0x29,
2401             ReasonCode::ErrorStatusSessionKeyNotFound => 0x2a,
2402             ReasonCode::ErrorStatusSubSessionKeyNotFound => 0x2b,
2403             ReasonCode::ErrorInvalidPreambleCodeIndex => 0x2c,
2404             ReasonCode::ErrorInvalidSfdId => 0x2d,
2405             ReasonCode::ErrorInvalidPsduDataRate => 0x2e,
2406             ReasonCode::ErrorInvalidPhrDataRate => 0x2f,
2407             ReasonCode::ErrorInvalidPreambleDuration => 0x30,
2408             ReasonCode::ErrorInvalidStsLength => 0x31,
2409             ReasonCode::ErrorInvalidNumOfStsSegments => 0x32,
2410             ReasonCode::ErrorInvalidNumOfControlees => 0x33,
2411             ReasonCode::ErrorMaxRangingReplyTimeExceeded => 0x34,
2412             ReasonCode::ErrorInvalidDstAddressList => 0x35,
2413             ReasonCode::ErrorInvalidOrNotFoundSubSessionId => 0x36,
2414             ReasonCode::ErrorInvalidResultReportConfig => 0x37,
2415             ReasonCode::ErrorInvalidRangingRoundControlConfig => 0x38,
2416             ReasonCode::ErrorInvalidRangingRoundUsage => 0x39,
2417             ReasonCode::ErrorInvalidMultiNodeMode => 0x3a,
2418             ReasonCode::ErrorRdsFetchFailure => 0x3b,
2419             ReasonCode::ErrorRefUwbSessionDoesNotExist => 0x3c,
2420             ReasonCode::ErrorRefUwbSessionRangingDurationMismatch => 0x3d,
2421             ReasonCode::ErrorRefUwbSessionInvalidOffsetTime => 0x3e,
2422             ReasonCode::ErrorRefUwbSessionLost => 0x3f,
2423             ReasonCode::ErrorDtAnchorRangingRoundsNotConfigured => 0x40,
2424             ReasonCode::ErrorDtTagRangingRoundsNotConfigured => 0x41,
2425             ReasonCode::RfuReasonCodeRange2(Private(value)) => *value,
2426             ReasonCode::ErrorInvalidChannelWithAoa => 0x80,
2427             ReasonCode::ErrorStoppedDueToOtherSessionConflict => 0x81,
2428             ReasonCode::VendorSpecificReasonCodeRange1(Private(value)) => *value,
2429             ReasonCode::SessionStoppedDueToMaxStsIndexValue => 0xa2,
2430             ReasonCode::VendorSpecificReasonCodeRange2(Private(value)) => *value,
2431             ReasonCode::VendorSpecificReasonCode2 => 0xff,
2432         }
2433     }
2434 }
2435 impl From<ReasonCode> for u8 {
from(value: ReasonCode) -> Self2436     fn from(value: ReasonCode) -> Self {
2437         (&value).into()
2438     }
2439 }
2440 impl From<ReasonCode> for i16 {
from(value: ReasonCode) -> Self2441     fn from(value: ReasonCode) -> Self {
2442         u8::from(value) as Self
2443     }
2444 }
2445 impl From<ReasonCode> for i32 {
from(value: ReasonCode) -> Self2446     fn from(value: ReasonCode) -> Self {
2447         u8::from(value) as Self
2448     }
2449 }
2450 impl From<ReasonCode> for i64 {
from(value: ReasonCode) -> Self2451     fn from(value: ReasonCode) -> Self {
2452         u8::from(value) as Self
2453     }
2454 }
2455 impl From<ReasonCode> for u16 {
from(value: ReasonCode) -> Self2456     fn from(value: ReasonCode) -> Self {
2457         u8::from(value) as Self
2458     }
2459 }
2460 impl From<ReasonCode> for u32 {
from(value: ReasonCode) -> Self2461     fn from(value: ReasonCode) -> Self {
2462         u8::from(value) as Self
2463     }
2464 }
2465 impl From<ReasonCode> for u64 {
from(value: ReasonCode) -> Self2466     fn from(value: ReasonCode) -> Self {
2467         u8::from(value) as Self
2468     }
2469 }
2470 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
2471 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2472 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
2473 pub enum MulticastUpdateStatusCode {
2474     StatusOkMulticastListUpdate,
2475     StatusErrorMulticastListFull,
2476     StatusErrorKeyFetchFail,
2477     StatusErrorSubSessionIdNotFound,
2478     StatusErrorSubSessionKeyNotFound,
2479     StatusErrorSubSessionKeyNotApplicable,
2480     StatusErrorSessionKeyNotFound,
2481     StatusErrorAddressNotFound,
2482     StatusErrorAddressAlreadyPresent,
2483     RfuStatusCodeRange1(Private<u8>),
2484 }
2485 impl TryFrom<u8> for MulticastUpdateStatusCode {
2486     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>2487     fn try_from(value: u8) -> Result<Self, Self::Error> {
2488         match value {
2489             0x0 => Ok(MulticastUpdateStatusCode::StatusOkMulticastListUpdate),
2490             0x1 => Ok(MulticastUpdateStatusCode::StatusErrorMulticastListFull),
2491             0x2 => Ok(MulticastUpdateStatusCode::StatusErrorKeyFetchFail),
2492             0x3 => Ok(MulticastUpdateStatusCode::StatusErrorSubSessionIdNotFound),
2493             0x4 => Ok(MulticastUpdateStatusCode::StatusErrorSubSessionKeyNotFound),
2494             0x5 => Ok(MulticastUpdateStatusCode::StatusErrorSubSessionKeyNotApplicable),
2495             0x6 => Ok(MulticastUpdateStatusCode::StatusErrorSessionKeyNotFound),
2496             0x7 => Ok(MulticastUpdateStatusCode::StatusErrorAddressNotFound),
2497             0x8 => Ok(MulticastUpdateStatusCode::StatusErrorAddressAlreadyPresent),
2498             0x9..=0xff => {
2499                 Ok(MulticastUpdateStatusCode::RfuStatusCodeRange1(Private(value)))
2500             }
2501         }
2502     }
2503 }
2504 impl From<&MulticastUpdateStatusCode> for u8 {
from(value: &MulticastUpdateStatusCode) -> Self2505     fn from(value: &MulticastUpdateStatusCode) -> Self {
2506         match value {
2507             MulticastUpdateStatusCode::StatusOkMulticastListUpdate => 0x0,
2508             MulticastUpdateStatusCode::StatusErrorMulticastListFull => 0x1,
2509             MulticastUpdateStatusCode::StatusErrorKeyFetchFail => 0x2,
2510             MulticastUpdateStatusCode::StatusErrorSubSessionIdNotFound => 0x3,
2511             MulticastUpdateStatusCode::StatusErrorSubSessionKeyNotFound => 0x4,
2512             MulticastUpdateStatusCode::StatusErrorSubSessionKeyNotApplicable => 0x5,
2513             MulticastUpdateStatusCode::StatusErrorSessionKeyNotFound => 0x6,
2514             MulticastUpdateStatusCode::StatusErrorAddressNotFound => 0x7,
2515             MulticastUpdateStatusCode::StatusErrorAddressAlreadyPresent => 0x8,
2516             MulticastUpdateStatusCode::RfuStatusCodeRange1(Private(value)) => *value,
2517         }
2518     }
2519 }
2520 impl From<MulticastUpdateStatusCode> for u8 {
from(value: MulticastUpdateStatusCode) -> Self2521     fn from(value: MulticastUpdateStatusCode) -> Self {
2522         (&value).into()
2523     }
2524 }
2525 impl From<MulticastUpdateStatusCode> for i16 {
from(value: MulticastUpdateStatusCode) -> Self2526     fn from(value: MulticastUpdateStatusCode) -> Self {
2527         u8::from(value) as Self
2528     }
2529 }
2530 impl From<MulticastUpdateStatusCode> for i32 {
from(value: MulticastUpdateStatusCode) -> Self2531     fn from(value: MulticastUpdateStatusCode) -> Self {
2532         u8::from(value) as Self
2533     }
2534 }
2535 impl From<MulticastUpdateStatusCode> for i64 {
from(value: MulticastUpdateStatusCode) -> Self2536     fn from(value: MulticastUpdateStatusCode) -> Self {
2537         u8::from(value) as Self
2538     }
2539 }
2540 impl From<MulticastUpdateStatusCode> for u16 {
from(value: MulticastUpdateStatusCode) -> Self2541     fn from(value: MulticastUpdateStatusCode) -> Self {
2542         u8::from(value) as Self
2543     }
2544 }
2545 impl From<MulticastUpdateStatusCode> for u32 {
from(value: MulticastUpdateStatusCode) -> Self2546     fn from(value: MulticastUpdateStatusCode) -> Self {
2547         u8::from(value) as Self
2548     }
2549 }
2550 impl From<MulticastUpdateStatusCode> for u64 {
from(value: MulticastUpdateStatusCode) -> Self2551     fn from(value: MulticastUpdateStatusCode) -> Self {
2552         u8::from(value) as Self
2553     }
2554 }
2555 #[repr(u64)]
2556 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
2557 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2558 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
2559 pub enum MacAddressIndicator {
2560     ShortAddress = 0x0,
2561     ExtendedAddress = 0x1,
2562 }
2563 impl TryFrom<u8> for MacAddressIndicator {
2564     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>2565     fn try_from(value: u8) -> Result<Self, Self::Error> {
2566         match value {
2567             0x0 => Ok(MacAddressIndicator::ShortAddress),
2568             0x1 => Ok(MacAddressIndicator::ExtendedAddress),
2569             _ => Err(value),
2570         }
2571     }
2572 }
2573 impl From<&MacAddressIndicator> for u8 {
from(value: &MacAddressIndicator) -> Self2574     fn from(value: &MacAddressIndicator) -> Self {
2575         match value {
2576             MacAddressIndicator::ShortAddress => 0x0,
2577             MacAddressIndicator::ExtendedAddress => 0x1,
2578         }
2579     }
2580 }
2581 impl From<MacAddressIndicator> for u8 {
from(value: MacAddressIndicator) -> Self2582     fn from(value: MacAddressIndicator) -> Self {
2583         (&value).into()
2584     }
2585 }
2586 impl From<MacAddressIndicator> for i16 {
from(value: MacAddressIndicator) -> Self2587     fn from(value: MacAddressIndicator) -> Self {
2588         u8::from(value) as Self
2589     }
2590 }
2591 impl From<MacAddressIndicator> for i32 {
from(value: MacAddressIndicator) -> Self2592     fn from(value: MacAddressIndicator) -> Self {
2593         u8::from(value) as Self
2594     }
2595 }
2596 impl From<MacAddressIndicator> for i64 {
from(value: MacAddressIndicator) -> Self2597     fn from(value: MacAddressIndicator) -> Self {
2598         u8::from(value) as Self
2599     }
2600 }
2601 impl From<MacAddressIndicator> for u16 {
from(value: MacAddressIndicator) -> Self2602     fn from(value: MacAddressIndicator) -> Self {
2603         u8::from(value) as Self
2604     }
2605 }
2606 impl From<MacAddressIndicator> for u32 {
from(value: MacAddressIndicator) -> Self2607     fn from(value: MacAddressIndicator) -> Self {
2608         u8::from(value) as Self
2609     }
2610 }
2611 impl From<MacAddressIndicator> for u64 {
from(value: MacAddressIndicator) -> Self2612     fn from(value: MacAddressIndicator) -> Self {
2613         u8::from(value) as Self
2614     }
2615 }
2616 #[repr(u64)]
2617 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
2618 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2619 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
2620 pub enum SessionType {
2621     FiraRangingSession = 0x0,
2622     FiraRangingAndInBandDataSession = 0x1,
2623     FiraDataTransferSession = 0x2,
2624     FiraRangingOnlyPhase = 0x3,
2625     FiraInBandDataPhase = 0x4,
2626     FiraRangingWithDataPhase = 0x5,
2627     Ccc = 0xa0,
2628     RadarSession = 0xa1,
2629     Aliro = 0xa2,
2630     DeviceTestMode = 0xd0,
2631 }
2632 impl TryFrom<u8> for SessionType {
2633     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>2634     fn try_from(value: u8) -> Result<Self, Self::Error> {
2635         match value {
2636             0x0 => Ok(SessionType::FiraRangingSession),
2637             0x1 => Ok(SessionType::FiraRangingAndInBandDataSession),
2638             0x2 => Ok(SessionType::FiraDataTransferSession),
2639             0x3 => Ok(SessionType::FiraRangingOnlyPhase),
2640             0x4 => Ok(SessionType::FiraInBandDataPhase),
2641             0x5 => Ok(SessionType::FiraRangingWithDataPhase),
2642             0xa0 => Ok(SessionType::Ccc),
2643             0xa1 => Ok(SessionType::RadarSession),
2644             0xa2 => Ok(SessionType::Aliro),
2645             0xd0 => Ok(SessionType::DeviceTestMode),
2646             _ => Err(value),
2647         }
2648     }
2649 }
2650 impl From<&SessionType> for u8 {
from(value: &SessionType) -> Self2651     fn from(value: &SessionType) -> Self {
2652         match value {
2653             SessionType::FiraRangingSession => 0x0,
2654             SessionType::FiraRangingAndInBandDataSession => 0x1,
2655             SessionType::FiraDataTransferSession => 0x2,
2656             SessionType::FiraRangingOnlyPhase => 0x3,
2657             SessionType::FiraInBandDataPhase => 0x4,
2658             SessionType::FiraRangingWithDataPhase => 0x5,
2659             SessionType::Ccc => 0xa0,
2660             SessionType::RadarSession => 0xa1,
2661             SessionType::Aliro => 0xa2,
2662             SessionType::DeviceTestMode => 0xd0,
2663         }
2664     }
2665 }
2666 impl From<SessionType> for u8 {
from(value: SessionType) -> Self2667     fn from(value: SessionType) -> Self {
2668         (&value).into()
2669     }
2670 }
2671 impl From<SessionType> for i16 {
from(value: SessionType) -> Self2672     fn from(value: SessionType) -> Self {
2673         u8::from(value) as Self
2674     }
2675 }
2676 impl From<SessionType> for i32 {
from(value: SessionType) -> Self2677     fn from(value: SessionType) -> Self {
2678         u8::from(value) as Self
2679     }
2680 }
2681 impl From<SessionType> for i64 {
from(value: SessionType) -> Self2682     fn from(value: SessionType) -> Self {
2683         u8::from(value) as Self
2684     }
2685 }
2686 impl From<SessionType> for u16 {
from(value: SessionType) -> Self2687     fn from(value: SessionType) -> Self {
2688         u8::from(value) as Self
2689     }
2690 }
2691 impl From<SessionType> for u32 {
from(value: SessionType) -> Self2692     fn from(value: SessionType) -> Self {
2693         u8::from(value) as Self
2694     }
2695 }
2696 impl From<SessionType> for u64 {
from(value: SessionType) -> Self2697     fn from(value: SessionType) -> Self {
2698         u8::from(value) as Self
2699     }
2700 }
2701 #[repr(u64)]
2702 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
2703 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2704 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
2705 pub enum MessageType {
2706     Data = 0x0,
2707     Command = 0x1,
2708     Response = 0x2,
2709     Notification = 0x3,
2710     ReservedForTesting1 = 0x4,
2711     ReservedForTesting2 = 0x5,
2712 }
2713 impl TryFrom<u8> for MessageType {
2714     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>2715     fn try_from(value: u8) -> Result<Self, Self::Error> {
2716         match value {
2717             0x0 => Ok(MessageType::Data),
2718             0x1 => Ok(MessageType::Command),
2719             0x2 => Ok(MessageType::Response),
2720             0x3 => Ok(MessageType::Notification),
2721             0x4 => Ok(MessageType::ReservedForTesting1),
2722             0x5 => Ok(MessageType::ReservedForTesting2),
2723             _ => Err(value),
2724         }
2725     }
2726 }
2727 impl From<&MessageType> for u8 {
from(value: &MessageType) -> Self2728     fn from(value: &MessageType) -> Self {
2729         match value {
2730             MessageType::Data => 0x0,
2731             MessageType::Command => 0x1,
2732             MessageType::Response => 0x2,
2733             MessageType::Notification => 0x3,
2734             MessageType::ReservedForTesting1 => 0x4,
2735             MessageType::ReservedForTesting2 => 0x5,
2736         }
2737     }
2738 }
2739 impl From<MessageType> for u8 {
from(value: MessageType) -> Self2740     fn from(value: MessageType) -> Self {
2741         (&value).into()
2742     }
2743 }
2744 impl From<MessageType> for i8 {
from(value: MessageType) -> Self2745     fn from(value: MessageType) -> Self {
2746         u8::from(value) as Self
2747     }
2748 }
2749 impl From<MessageType> for i16 {
from(value: MessageType) -> Self2750     fn from(value: MessageType) -> Self {
2751         u8::from(value) as Self
2752     }
2753 }
2754 impl From<MessageType> for i32 {
from(value: MessageType) -> Self2755     fn from(value: MessageType) -> Self {
2756         u8::from(value) as Self
2757     }
2758 }
2759 impl From<MessageType> for i64 {
from(value: MessageType) -> Self2760     fn from(value: MessageType) -> Self {
2761         u8::from(value) as Self
2762     }
2763 }
2764 impl From<MessageType> for u16 {
from(value: MessageType) -> Self2765     fn from(value: MessageType) -> Self {
2766         u8::from(value) as Self
2767     }
2768 }
2769 impl From<MessageType> for u32 {
from(value: MessageType) -> Self2770     fn from(value: MessageType) -> Self {
2771         u8::from(value) as Self
2772     }
2773 }
2774 impl From<MessageType> for u64 {
from(value: MessageType) -> Self2775     fn from(value: MessageType) -> Self {
2776         u8::from(value) as Self
2777     }
2778 }
2779 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
2780 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2781 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
2782 pub enum RfTestConfigTlvType {
2783     NumPackets,
2784     TGap,
2785     TStart,
2786     TWin,
2787     RandomizePsdu,
2788     PhrRangingBit,
2789     RmarkerTxStart,
2790     RmarkerRxStart,
2791     StsIndexAutoIncr,
2792     StsDetectBitmap,
2793     RfuTestAppCfgTlvTypeRange(Private<u8>),
2794 }
2795 impl TryFrom<u8> for RfTestConfigTlvType {
2796     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>2797     fn try_from(value: u8) -> Result<Self, Self::Error> {
2798         match value {
2799             0x0 => Ok(RfTestConfigTlvType::NumPackets),
2800             0x1 => Ok(RfTestConfigTlvType::TGap),
2801             0x2 => Ok(RfTestConfigTlvType::TStart),
2802             0x3 => Ok(RfTestConfigTlvType::TWin),
2803             0x4 => Ok(RfTestConfigTlvType::RandomizePsdu),
2804             0x5 => Ok(RfTestConfigTlvType::PhrRangingBit),
2805             0x6 => Ok(RfTestConfigTlvType::RmarkerTxStart),
2806             0x7 => Ok(RfTestConfigTlvType::RmarkerRxStart),
2807             0x8 => Ok(RfTestConfigTlvType::StsIndexAutoIncr),
2808             0x9 => Ok(RfTestConfigTlvType::StsDetectBitmap),
2809             0xa..=0xff => {
2810                 Ok(RfTestConfigTlvType::RfuTestAppCfgTlvTypeRange(Private(value)))
2811             }
2812         }
2813     }
2814 }
2815 impl From<&RfTestConfigTlvType> for u8 {
from(value: &RfTestConfigTlvType) -> Self2816     fn from(value: &RfTestConfigTlvType) -> Self {
2817         match value {
2818             RfTestConfigTlvType::NumPackets => 0x0,
2819             RfTestConfigTlvType::TGap => 0x1,
2820             RfTestConfigTlvType::TStart => 0x2,
2821             RfTestConfigTlvType::TWin => 0x3,
2822             RfTestConfigTlvType::RandomizePsdu => 0x4,
2823             RfTestConfigTlvType::PhrRangingBit => 0x5,
2824             RfTestConfigTlvType::RmarkerTxStart => 0x6,
2825             RfTestConfigTlvType::RmarkerRxStart => 0x7,
2826             RfTestConfigTlvType::StsIndexAutoIncr => 0x8,
2827             RfTestConfigTlvType::StsDetectBitmap => 0x9,
2828             RfTestConfigTlvType::RfuTestAppCfgTlvTypeRange(Private(value)) => *value,
2829         }
2830     }
2831 }
2832 impl From<RfTestConfigTlvType> for u8 {
from(value: RfTestConfigTlvType) -> Self2833     fn from(value: RfTestConfigTlvType) -> Self {
2834         (&value).into()
2835     }
2836 }
2837 impl From<RfTestConfigTlvType> for i16 {
from(value: RfTestConfigTlvType) -> Self2838     fn from(value: RfTestConfigTlvType) -> Self {
2839         u8::from(value) as Self
2840     }
2841 }
2842 impl From<RfTestConfigTlvType> for i32 {
from(value: RfTestConfigTlvType) -> Self2843     fn from(value: RfTestConfigTlvType) -> Self {
2844         u8::from(value) as Self
2845     }
2846 }
2847 impl From<RfTestConfigTlvType> for i64 {
from(value: RfTestConfigTlvType) -> Self2848     fn from(value: RfTestConfigTlvType) -> Self {
2849         u8::from(value) as Self
2850     }
2851 }
2852 impl From<RfTestConfigTlvType> for u16 {
from(value: RfTestConfigTlvType) -> Self2853     fn from(value: RfTestConfigTlvType) -> Self {
2854         u8::from(value) as Self
2855     }
2856 }
2857 impl From<RfTestConfigTlvType> for u32 {
from(value: RfTestConfigTlvType) -> Self2858     fn from(value: RfTestConfigTlvType) -> Self {
2859         u8::from(value) as Self
2860     }
2861 }
2862 impl From<RfTestConfigTlvType> for u64 {
from(value: RfTestConfigTlvType) -> Self2863     fn from(value: RfTestConfigTlvType) -> Self {
2864         u8::from(value) as Self
2865     }
2866 }
2867 #[derive(Debug, Clone, PartialEq, Eq)]
2868 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2869 pub enum UciPacketHalDataChild {
2870     UciDataPacketHal(UciDataPacketHalData),
2871     UciControlPacketHal(UciControlPacketHalData),
2872     Payload(Bytes),
2873     None,
2874 }
2875 impl UciPacketHalDataChild {
get_total_size(&self) -> usize2876     fn get_total_size(&self) -> usize {
2877         match self {
2878             UciPacketHalDataChild::UciDataPacketHal(value) => value.get_total_size(),
2879             UciPacketHalDataChild::UciControlPacketHal(value) => value.get_total_size(),
2880             UciPacketHalDataChild::Payload(bytes) => bytes.len(),
2881             UciPacketHalDataChild::None => 0,
2882         }
2883     }
2884 }
2885 #[derive(Debug, Clone, PartialEq, Eq)]
2886 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2887 pub enum UciPacketHalChild {
2888     UciDataPacketHal(UciDataPacketHal),
2889     UciControlPacketHal(UciControlPacketHal),
2890     Payload(Bytes),
2891     None,
2892 }
2893 #[derive(Debug, Clone, PartialEq, Eq)]
2894 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2895 pub struct UciPacketHalData {
2896     group_id_or_data_packet_format: GroupIdOrDataPacketFormat,
2897     packet_boundary_flag: PacketBoundaryFlag,
2898     message_type: MessageType,
2899     child: UciPacketHalDataChild,
2900 }
2901 #[derive(Debug, Clone, PartialEq, Eq)]
2902 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2903 pub struct UciPacketHal {
2904     #[cfg_attr(feature = "serde", serde(flatten))]
2905     ucipackethal: UciPacketHalData,
2906 }
2907 #[derive(Debug)]
2908 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2909 pub struct UciPacketHalBuilder {
2910     pub group_id_or_data_packet_format: GroupIdOrDataPacketFormat,
2911     pub message_type: MessageType,
2912     pub packet_boundary_flag: PacketBoundaryFlag,
2913     pub payload: Option<Bytes>,
2914 }
2915 impl UciPacketHalData {
conforms(bytes: &[u8]) -> bool2916     fn conforms(bytes: &[u8]) -> bool {
2917         bytes.len() >= 1
2918     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>2919     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
2920         let mut cell = Cell::new(bytes);
2921         let packet = Self::parse_inner(&mut cell)?;
2922         Ok(packet)
2923     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>2924     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
2925         if bytes.get().remaining() < 1 {
2926             return Err(DecodeError::InvalidLengthError {
2927                 obj: "UciPacketHal",
2928                 wanted: 1,
2929                 got: bytes.get().remaining(),
2930             });
2931         }
2932         let chunk = bytes.get_mut().get_u8();
2933         let group_id_or_data_packet_format = GroupIdOrDataPacketFormat::try_from(
2934                 (chunk & 0xf),
2935             )
2936             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
2937                 obj: "UciPacketHal",
2938                 field: "group_id_or_data_packet_format",
2939                 value: unknown_val as u64,
2940                 type_: "GroupIdOrDataPacketFormat",
2941             })?;
2942         let packet_boundary_flag = PacketBoundaryFlag::try_from(((chunk >> 4) & 0x1))
2943             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
2944                 obj: "UciPacketHal",
2945                 field: "packet_boundary_flag",
2946                 value: unknown_val as u64,
2947                 type_: "PacketBoundaryFlag",
2948             })?;
2949         let message_type = MessageType::try_from(((chunk >> 5) & 0x7))
2950             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
2951                 obj: "UciPacketHal",
2952                 field: "message_type",
2953                 value: unknown_val as u64,
2954                 type_: "MessageType",
2955             })?;
2956         let payload = bytes.get();
2957         bytes.get_mut().advance(payload.len());
2958         let child = match (message_type) {
2959             (MessageType::Data) if UciDataPacketHalData::conforms(&payload) => {
2960                 let mut cell = Cell::new(payload);
2961                 let child_data = UciDataPacketHalData::parse_inner(&mut cell)?;
2962                 UciPacketHalDataChild::UciDataPacketHal(child_data)
2963             }
2964             _ if !payload.is_empty() => {
2965                 UciPacketHalDataChild::Payload(Bytes::copy_from_slice(payload))
2966             }
2967             _ => UciPacketHalDataChild::None,
2968         };
2969         Ok(Self {
2970             group_id_or_data_packet_format,
2971             packet_boundary_flag,
2972             message_type,
2973             child,
2974         })
2975     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>2976     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
2977         let value = u8::from(self.group_id_or_data_packet_format)
2978             | (u8::from(self.packet_boundary_flag) << 4)
2979             | (u8::from(self.message_type) << 5);
2980         buffer.put_u8(value);
2981         match &self.child {
2982             UciPacketHalDataChild::UciDataPacketHal(child) => child.write_to(buffer)?,
2983             UciPacketHalDataChild::UciControlPacketHal(child) => child.write_to(buffer)?,
2984             UciPacketHalDataChild::Payload(payload) => buffer.put_slice(payload),
2985             UciPacketHalDataChild::None => {}
2986         }
2987         Ok(())
2988     }
get_total_size(&self) -> usize2989     fn get_total_size(&self) -> usize {
2990         self.get_size()
2991     }
get_size(&self) -> usize2992     fn get_size(&self) -> usize {
2993         1 + self.child.get_total_size()
2994     }
2995 }
2996 impl Packet for UciPacketHal {
encoded_len(&self) -> usize2997     fn encoded_len(&self) -> usize {
2998         self.get_size()
2999     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>3000     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
3001         self.ucipackethal.write_to(buf)
3002     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>3003     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
3004         unimplemented!("Rust legacy does not implement full packet trait")
3005     }
3006 }
3007 impl TryFrom<UciPacketHal> for Bytes {
3008     type Error = EncodeError;
try_from(packet: UciPacketHal) -> Result<Self, Self::Error>3009     fn try_from(packet: UciPacketHal) -> Result<Self, Self::Error> {
3010         packet.encode_to_bytes()
3011     }
3012 }
3013 impl TryFrom<UciPacketHal> for Vec<u8> {
3014     type Error = EncodeError;
try_from(packet: UciPacketHal) -> Result<Self, Self::Error>3015     fn try_from(packet: UciPacketHal) -> Result<Self, Self::Error> {
3016         packet.encode_to_vec()
3017     }
3018 }
3019 impl UciPacketHal {
parse(bytes: &[u8]) -> Result<Self, DecodeError>3020     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
3021         let mut cell = Cell::new(bytes);
3022         let packet = Self::parse_inner(&mut cell)?;
3023         Ok(packet)
3024     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>3025     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
3026         let data = UciPacketHalData::parse_inner(&mut bytes)?;
3027         Self::new(data)
3028     }
specialize(&self) -> UciPacketHalChild3029     pub fn specialize(&self) -> UciPacketHalChild {
3030         match &self.ucipackethal.child {
3031             UciPacketHalDataChild::UciDataPacketHal(_) => {
3032                 UciPacketHalChild::UciDataPacketHal(
3033                     UciDataPacketHal::new(self.ucipackethal.clone()).unwrap(),
3034                 )
3035             }
3036             UciPacketHalDataChild::UciControlPacketHal(_) => {
3037                 UciPacketHalChild::UciControlPacketHal(
3038                     UciControlPacketHal::new(self.ucipackethal.clone()).unwrap(),
3039                 )
3040             }
3041             UciPacketHalDataChild::Payload(payload) => {
3042                 UciPacketHalChild::Payload(payload.clone())
3043             }
3044             UciPacketHalDataChild::None => UciPacketHalChild::None,
3045         }
3046     }
new(ucipackethal: UciPacketHalData) -> Result<Self, DecodeError>3047     fn new(ucipackethal: UciPacketHalData) -> Result<Self, DecodeError> {
3048         Ok(Self { ucipackethal })
3049     }
get_group_id_or_data_packet_format(&self) -> GroupIdOrDataPacketFormat3050     pub fn get_group_id_or_data_packet_format(&self) -> GroupIdOrDataPacketFormat {
3051         self.ucipackethal.group_id_or_data_packet_format
3052     }
get_message_type(&self) -> MessageType3053     pub fn get_message_type(&self) -> MessageType {
3054         self.ucipackethal.message_type
3055     }
get_packet_boundary_flag(&self) -> PacketBoundaryFlag3056     pub fn get_packet_boundary_flag(&self) -> PacketBoundaryFlag {
3057         self.ucipackethal.packet_boundary_flag
3058     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>3059     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
3060         self.ucipackethal.write_to(buffer)
3061     }
get_size(&self) -> usize3062     pub fn get_size(&self) -> usize {
3063         self.ucipackethal.get_size()
3064     }
3065 }
3066 impl UciPacketHalBuilder {
build(self) -> UciPacketHal3067     pub fn build(self) -> UciPacketHal {
3068         let ucipackethal = UciPacketHalData {
3069             group_id_or_data_packet_format: self.group_id_or_data_packet_format,
3070             message_type: self.message_type,
3071             packet_boundary_flag: self.packet_boundary_flag,
3072             child: match self.payload {
3073                 None => UciPacketHalDataChild::None,
3074                 Some(bytes) => UciPacketHalDataChild::Payload(bytes),
3075             },
3076         };
3077         UciPacketHal::new(ucipackethal).unwrap()
3078     }
3079 }
3080 impl From<UciPacketHalBuilder> for UciPacketHal {
from(builder: UciPacketHalBuilder) -> UciPacketHal3081     fn from(builder: UciPacketHalBuilder) -> UciPacketHal {
3082         builder.build().into()
3083     }
3084 }
3085 #[derive(Debug, Clone, PartialEq, Eq)]
3086 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3087 pub enum UciDataPacketHalDataChild {
3088     Payload(Bytes),
3089     None,
3090 }
3091 impl UciDataPacketHalDataChild {
get_total_size(&self) -> usize3092     fn get_total_size(&self) -> usize {
3093         match self {
3094             UciDataPacketHalDataChild::Payload(bytes) => bytes.len(),
3095             UciDataPacketHalDataChild::None => 0,
3096         }
3097     }
3098 }
3099 #[derive(Debug, Clone, PartialEq, Eq)]
3100 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3101 pub enum UciDataPacketHalChild {
3102     Payload(Bytes),
3103     None,
3104 }
3105 #[derive(Debug, Clone, PartialEq, Eq)]
3106 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3107 pub struct UciDataPacketHalData {
3108     child: UciDataPacketHalDataChild,
3109 }
3110 #[derive(Debug, Clone, PartialEq, Eq)]
3111 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3112 pub struct UciDataPacketHal {
3113     #[cfg_attr(feature = "serde", serde(flatten))]
3114     ucipackethal: UciPacketHalData,
3115     #[cfg_attr(feature = "serde", serde(flatten))]
3116     ucidatapackethal: UciDataPacketHalData,
3117 }
3118 #[derive(Debug)]
3119 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3120 pub struct UciDataPacketHalBuilder {
3121     pub group_id_or_data_packet_format: GroupIdOrDataPacketFormat,
3122     pub packet_boundary_flag: PacketBoundaryFlag,
3123     pub payload: Option<Bytes>,
3124 }
3125 impl UciDataPacketHalData {
conforms(bytes: &[u8]) -> bool3126     fn conforms(bytes: &[u8]) -> bool {
3127         bytes.len() >= 3
3128     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>3129     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
3130         let mut cell = Cell::new(bytes);
3131         let packet = Self::parse_inner(&mut cell)?;
3132         Ok(packet)
3133     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>3134     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
3135         if bytes.get().remaining() < 1 {
3136             return Err(DecodeError::InvalidLengthError {
3137                 obj: "UciDataPacketHal",
3138                 wanted: 1,
3139                 got: bytes.get().remaining(),
3140             });
3141         }
3142         bytes.get_mut().advance(1);
3143         if bytes.get().remaining() < 2 {
3144             return Err(DecodeError::InvalidLengthError {
3145                 obj: "UciDataPacketHal",
3146                 wanted: 2,
3147                 got: bytes.get().remaining(),
3148             });
3149         }
3150         let payload_size = bytes.get_mut().get_u16_le() as usize;
3151         if bytes.get().remaining() < payload_size {
3152             return Err(DecodeError::InvalidLengthError {
3153                 obj: "UciDataPacketHal",
3154                 wanted: payload_size,
3155                 got: bytes.get().remaining(),
3156             });
3157         }
3158         let payload = &bytes.get()[..payload_size];
3159         bytes.get_mut().advance(payload_size);
3160         let child = match () {
3161             _ if !payload.is_empty() => {
3162                 UciDataPacketHalDataChild::Payload(Bytes::copy_from_slice(payload))
3163             }
3164             _ => UciDataPacketHalDataChild::None,
3165         };
3166         Ok(Self { child })
3167     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>3168     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
3169         buffer.put_bytes(0, 1);
3170         if self.child.get_total_size() > 0xffff {
3171             return Err(EncodeError::SizeOverflow {
3172                 packet: "UciDataPacketHal",
3173                 field: "_payload_",
3174                 size: self.child.get_total_size(),
3175                 maximum_size: 0xffff,
3176             });
3177         }
3178         buffer.put_u16_le(self.child.get_total_size() as u16);
3179         match &self.child {
3180             UciDataPacketHalDataChild::Payload(payload) => buffer.put_slice(payload),
3181             UciDataPacketHalDataChild::None => {}
3182         }
3183         Ok(())
3184     }
get_total_size(&self) -> usize3185     fn get_total_size(&self) -> usize {
3186         self.get_size()
3187     }
get_size(&self) -> usize3188     fn get_size(&self) -> usize {
3189         3 + self.child.get_total_size()
3190     }
3191 }
3192 impl Packet for UciDataPacketHal {
encoded_len(&self) -> usize3193     fn encoded_len(&self) -> usize {
3194         self.get_size()
3195     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>3196     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
3197         self.ucipackethal.write_to(buf)
3198     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>3199     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
3200         unimplemented!("Rust legacy does not implement full packet trait")
3201     }
3202 }
3203 impl TryFrom<UciDataPacketHal> for Bytes {
3204     type Error = EncodeError;
try_from(packet: UciDataPacketHal) -> Result<Self, Self::Error>3205     fn try_from(packet: UciDataPacketHal) -> Result<Self, Self::Error> {
3206         packet.encode_to_bytes()
3207     }
3208 }
3209 impl TryFrom<UciDataPacketHal> for Vec<u8> {
3210     type Error = EncodeError;
try_from(packet: UciDataPacketHal) -> Result<Self, Self::Error>3211     fn try_from(packet: UciDataPacketHal) -> Result<Self, Self::Error> {
3212         packet.encode_to_vec()
3213     }
3214 }
3215 impl From<UciDataPacketHal> for UciPacketHal {
from(packet: UciDataPacketHal) -> UciPacketHal3216     fn from(packet: UciDataPacketHal) -> UciPacketHal {
3217         UciPacketHal::new(packet.ucipackethal).unwrap()
3218     }
3219 }
3220 impl TryFrom<UciPacketHal> for UciDataPacketHal {
3221     type Error = DecodeError;
try_from(packet: UciPacketHal) -> Result<UciDataPacketHal, Self::Error>3222     fn try_from(packet: UciPacketHal) -> Result<UciDataPacketHal, Self::Error> {
3223         UciDataPacketHal::new(packet.ucipackethal)
3224     }
3225 }
3226 impl UciDataPacketHal {
parse(bytes: &[u8]) -> Result<Self, DecodeError>3227     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
3228         let mut cell = Cell::new(bytes);
3229         let packet = Self::parse_inner(&mut cell)?;
3230         Ok(packet)
3231     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>3232     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
3233         let data = UciPacketHalData::parse_inner(&mut bytes)?;
3234         Self::new(data)
3235     }
specialize(&self) -> UciDataPacketHalChild3236     pub fn specialize(&self) -> UciDataPacketHalChild {
3237         match &self.ucidatapackethal.child {
3238             UciDataPacketHalDataChild::Payload(payload) => {
3239                 UciDataPacketHalChild::Payload(payload.clone())
3240             }
3241             UciDataPacketHalDataChild::None => UciDataPacketHalChild::None,
3242         }
3243     }
new(ucipackethal: UciPacketHalData) -> Result<Self, DecodeError>3244     fn new(ucipackethal: UciPacketHalData) -> Result<Self, DecodeError> {
3245         let ucidatapackethal = match &ucipackethal.child {
3246             UciPacketHalDataChild::UciDataPacketHal(value) => value.clone(),
3247             _ => {
3248                 return Err(DecodeError::InvalidChildError {
3249                     expected: stringify!(UciPacketHalDataChild::UciDataPacketHal),
3250                     actual: format!("{:?}", & ucipackethal.child),
3251                 });
3252             }
3253         };
3254         Ok(Self {
3255             ucipackethal,
3256             ucidatapackethal,
3257         })
3258     }
get_group_id_or_data_packet_format(&self) -> GroupIdOrDataPacketFormat3259     pub fn get_group_id_or_data_packet_format(&self) -> GroupIdOrDataPacketFormat {
3260         self.ucipackethal.group_id_or_data_packet_format
3261     }
get_message_type(&self) -> MessageType3262     pub fn get_message_type(&self) -> MessageType {
3263         self.ucipackethal.message_type
3264     }
get_packet_boundary_flag(&self) -> PacketBoundaryFlag3265     pub fn get_packet_boundary_flag(&self) -> PacketBoundaryFlag {
3266         self.ucipackethal.packet_boundary_flag
3267     }
get_payload(&self) -> &[u8]3268     pub fn get_payload(&self) -> &[u8] {
3269         match &self.ucidatapackethal.child {
3270             UciDataPacketHalDataChild::Payload(bytes) => &bytes,
3271             UciDataPacketHalDataChild::None => &[],
3272         }
3273     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>3274     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
3275         self.ucidatapackethal.write_to(buffer)
3276     }
get_size(&self) -> usize3277     pub fn get_size(&self) -> usize {
3278         self.ucipackethal.get_size()
3279     }
3280 }
3281 impl UciDataPacketHalBuilder {
build(self) -> UciDataPacketHal3282     pub fn build(self) -> UciDataPacketHal {
3283         let ucidatapackethal = UciDataPacketHalData {
3284             child: match self.payload {
3285                 None => UciDataPacketHalDataChild::None,
3286                 Some(bytes) => UciDataPacketHalDataChild::Payload(bytes),
3287             },
3288         };
3289         let ucipackethal = UciPacketHalData {
3290             group_id_or_data_packet_format: self.group_id_or_data_packet_format,
3291             message_type: MessageType::Data,
3292             packet_boundary_flag: self.packet_boundary_flag,
3293             child: UciPacketHalDataChild::UciDataPacketHal(ucidatapackethal),
3294         };
3295         UciDataPacketHal::new(ucipackethal).unwrap()
3296     }
3297 }
3298 impl From<UciDataPacketHalBuilder> for UciPacketHal {
from(builder: UciDataPacketHalBuilder) -> UciPacketHal3299     fn from(builder: UciDataPacketHalBuilder) -> UciPacketHal {
3300         builder.build().into()
3301     }
3302 }
3303 impl From<UciDataPacketHalBuilder> for UciDataPacketHal {
from(builder: UciDataPacketHalBuilder) -> UciDataPacketHal3304     fn from(builder: UciDataPacketHalBuilder) -> UciDataPacketHal {
3305         builder.build().into()
3306     }
3307 }
3308 #[derive(Debug, Clone, PartialEq, Eq)]
3309 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3310 pub enum UciControlPacketHalDataChild {
3311     Payload(Bytes),
3312     None,
3313 }
3314 impl UciControlPacketHalDataChild {
get_total_size(&self) -> usize3315     fn get_total_size(&self) -> usize {
3316         match self {
3317             UciControlPacketHalDataChild::Payload(bytes) => bytes.len(),
3318             UciControlPacketHalDataChild::None => 0,
3319         }
3320     }
3321 }
3322 #[derive(Debug, Clone, PartialEq, Eq)]
3323 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3324 pub enum UciControlPacketHalChild {
3325     Payload(Bytes),
3326     None,
3327 }
3328 #[derive(Debug, Clone, PartialEq, Eq)]
3329 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3330 pub struct UciControlPacketHalData {
3331     opcode: u8,
3332     child: UciControlPacketHalDataChild,
3333 }
3334 #[derive(Debug, Clone, PartialEq, Eq)]
3335 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3336 pub struct UciControlPacketHal {
3337     #[cfg_attr(feature = "serde", serde(flatten))]
3338     ucipackethal: UciPacketHalData,
3339     #[cfg_attr(feature = "serde", serde(flatten))]
3340     ucicontrolpackethal: UciControlPacketHalData,
3341 }
3342 #[derive(Debug)]
3343 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3344 pub struct UciControlPacketHalBuilder {
3345     pub group_id_or_data_packet_format: GroupIdOrDataPacketFormat,
3346     pub message_type: MessageType,
3347     pub opcode: u8,
3348     pub packet_boundary_flag: PacketBoundaryFlag,
3349     pub payload: Option<Bytes>,
3350 }
3351 impl UciControlPacketHalData {
conforms(bytes: &[u8]) -> bool3352     fn conforms(bytes: &[u8]) -> bool {
3353         bytes.len() >= 3
3354     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>3355     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
3356         let mut cell = Cell::new(bytes);
3357         let packet = Self::parse_inner(&mut cell)?;
3358         Ok(packet)
3359     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>3360     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
3361         if bytes.get().remaining() < 1 {
3362             return Err(DecodeError::InvalidLengthError {
3363                 obj: "UciControlPacketHal",
3364                 wanted: 1,
3365                 got: bytes.get().remaining(),
3366             });
3367         }
3368         let chunk = bytes.get_mut().get_u8();
3369         let opcode = (chunk & 0x3f);
3370         if bytes.get().remaining() < 1 {
3371             return Err(DecodeError::InvalidLengthError {
3372                 obj: "UciControlPacketHal",
3373                 wanted: 1,
3374                 got: bytes.get().remaining(),
3375             });
3376         }
3377         bytes.get_mut().advance(1);
3378         if bytes.get().remaining() < 1 {
3379             return Err(DecodeError::InvalidLengthError {
3380                 obj: "UciControlPacketHal",
3381                 wanted: 1,
3382                 got: bytes.get().remaining(),
3383             });
3384         }
3385         let payload_size = bytes.get_mut().get_u8() as usize;
3386         if bytes.get().remaining() < payload_size {
3387             return Err(DecodeError::InvalidLengthError {
3388                 obj: "UciControlPacketHal",
3389                 wanted: payload_size,
3390                 got: bytes.get().remaining(),
3391             });
3392         }
3393         let payload = &bytes.get()[..payload_size];
3394         bytes.get_mut().advance(payload_size);
3395         let child = match () {
3396             _ if !payload.is_empty() => {
3397                 UciControlPacketHalDataChild::Payload(Bytes::copy_from_slice(payload))
3398             }
3399             _ => UciControlPacketHalDataChild::None,
3400         };
3401         Ok(Self { opcode, child })
3402     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>3403     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
3404         if self.opcode > 0x3f {
3405             return Err(EncodeError::InvalidScalarValue {
3406                 packet: "UciControlPacketHal",
3407                 field: "opcode",
3408                 value: self.opcode as u64,
3409                 maximum_value: 0x3f,
3410             });
3411         }
3412         buffer.put_u8(self.opcode);
3413         buffer.put_bytes(0, 1);
3414         if self.child.get_total_size() > 0xff {
3415             return Err(EncodeError::SizeOverflow {
3416                 packet: "UciControlPacketHal",
3417                 field: "_payload_",
3418                 size: self.child.get_total_size(),
3419                 maximum_size: 0xff,
3420             });
3421         }
3422         buffer.put_u8(self.child.get_total_size() as u8);
3423         match &self.child {
3424             UciControlPacketHalDataChild::Payload(payload) => buffer.put_slice(payload),
3425             UciControlPacketHalDataChild::None => {}
3426         }
3427         Ok(())
3428     }
get_total_size(&self) -> usize3429     fn get_total_size(&self) -> usize {
3430         self.get_size()
3431     }
get_size(&self) -> usize3432     fn get_size(&self) -> usize {
3433         3 + self.child.get_total_size()
3434     }
3435 }
3436 impl Packet for UciControlPacketHal {
encoded_len(&self) -> usize3437     fn encoded_len(&self) -> usize {
3438         self.get_size()
3439     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>3440     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
3441         self.ucipackethal.write_to(buf)
3442     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>3443     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
3444         unimplemented!("Rust legacy does not implement full packet trait")
3445     }
3446 }
3447 impl TryFrom<UciControlPacketHal> for Bytes {
3448     type Error = EncodeError;
try_from(packet: UciControlPacketHal) -> Result<Self, Self::Error>3449     fn try_from(packet: UciControlPacketHal) -> Result<Self, Self::Error> {
3450         packet.encode_to_bytes()
3451     }
3452 }
3453 impl TryFrom<UciControlPacketHal> for Vec<u8> {
3454     type Error = EncodeError;
try_from(packet: UciControlPacketHal) -> Result<Self, Self::Error>3455     fn try_from(packet: UciControlPacketHal) -> Result<Self, Self::Error> {
3456         packet.encode_to_vec()
3457     }
3458 }
3459 impl From<UciControlPacketHal> for UciPacketHal {
from(packet: UciControlPacketHal) -> UciPacketHal3460     fn from(packet: UciControlPacketHal) -> UciPacketHal {
3461         UciPacketHal::new(packet.ucipackethal).unwrap()
3462     }
3463 }
3464 impl TryFrom<UciPacketHal> for UciControlPacketHal {
3465     type Error = DecodeError;
try_from(packet: UciPacketHal) -> Result<UciControlPacketHal, Self::Error>3466     fn try_from(packet: UciPacketHal) -> Result<UciControlPacketHal, Self::Error> {
3467         UciControlPacketHal::new(packet.ucipackethal)
3468     }
3469 }
3470 impl UciControlPacketHal {
parse(bytes: &[u8]) -> Result<Self, DecodeError>3471     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
3472         let mut cell = Cell::new(bytes);
3473         let packet = Self::parse_inner(&mut cell)?;
3474         Ok(packet)
3475     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>3476     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
3477         let data = UciPacketHalData::parse_inner(&mut bytes)?;
3478         Self::new(data)
3479     }
specialize(&self) -> UciControlPacketHalChild3480     pub fn specialize(&self) -> UciControlPacketHalChild {
3481         match &self.ucicontrolpackethal.child {
3482             UciControlPacketHalDataChild::Payload(payload) => {
3483                 UciControlPacketHalChild::Payload(payload.clone())
3484             }
3485             UciControlPacketHalDataChild::None => UciControlPacketHalChild::None,
3486         }
3487     }
new(ucipackethal: UciPacketHalData) -> Result<Self, DecodeError>3488     fn new(ucipackethal: UciPacketHalData) -> Result<Self, DecodeError> {
3489         let ucicontrolpackethal = match &ucipackethal.child {
3490             UciPacketHalDataChild::UciControlPacketHal(value) => value.clone(),
3491             _ => {
3492                 return Err(DecodeError::InvalidChildError {
3493                     expected: stringify!(UciPacketHalDataChild::UciControlPacketHal),
3494                     actual: format!("{:?}", & ucipackethal.child),
3495                 });
3496             }
3497         };
3498         Ok(Self {
3499             ucipackethal,
3500             ucicontrolpackethal,
3501         })
3502     }
get_group_id_or_data_packet_format(&self) -> GroupIdOrDataPacketFormat3503     pub fn get_group_id_or_data_packet_format(&self) -> GroupIdOrDataPacketFormat {
3504         self.ucipackethal.group_id_or_data_packet_format
3505     }
get_message_type(&self) -> MessageType3506     pub fn get_message_type(&self) -> MessageType {
3507         self.ucipackethal.message_type
3508     }
get_opcode(&self) -> u83509     pub fn get_opcode(&self) -> u8 {
3510         self.ucicontrolpackethal.opcode
3511     }
get_packet_boundary_flag(&self) -> PacketBoundaryFlag3512     pub fn get_packet_boundary_flag(&self) -> PacketBoundaryFlag {
3513         self.ucipackethal.packet_boundary_flag
3514     }
get_payload(&self) -> &[u8]3515     pub fn get_payload(&self) -> &[u8] {
3516         match &self.ucicontrolpackethal.child {
3517             UciControlPacketHalDataChild::Payload(bytes) => &bytes,
3518             UciControlPacketHalDataChild::None => &[],
3519         }
3520     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>3521     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
3522         self.ucicontrolpackethal.write_to(buffer)
3523     }
get_size(&self) -> usize3524     pub fn get_size(&self) -> usize {
3525         self.ucipackethal.get_size()
3526     }
3527 }
3528 impl UciControlPacketHalBuilder {
build(self) -> UciControlPacketHal3529     pub fn build(self) -> UciControlPacketHal {
3530         let ucicontrolpackethal = UciControlPacketHalData {
3531             opcode: self.opcode,
3532             child: match self.payload {
3533                 None => UciControlPacketHalDataChild::None,
3534                 Some(bytes) => UciControlPacketHalDataChild::Payload(bytes),
3535             },
3536         };
3537         let ucipackethal = UciPacketHalData {
3538             group_id_or_data_packet_format: self.group_id_or_data_packet_format,
3539             message_type: self.message_type,
3540             packet_boundary_flag: self.packet_boundary_flag,
3541             child: UciPacketHalDataChild::UciControlPacketHal(ucicontrolpackethal),
3542         };
3543         UciControlPacketHal::new(ucipackethal).unwrap()
3544     }
3545 }
3546 impl From<UciControlPacketHalBuilder> for UciPacketHal {
from(builder: UciControlPacketHalBuilder) -> UciPacketHal3547     fn from(builder: UciControlPacketHalBuilder) -> UciPacketHal {
3548         builder.build().into()
3549     }
3550 }
3551 impl From<UciControlPacketHalBuilder> for UciControlPacketHal {
from(builder: UciControlPacketHalBuilder) -> UciControlPacketHal3552     fn from(builder: UciControlPacketHalBuilder) -> UciControlPacketHal {
3553         builder.build().into()
3554     }
3555 }
3556 #[derive(Debug, Clone, PartialEq, Eq)]
3557 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3558 pub enum UciControlPacketDataChild {
3559     UciCommand(UciCommandData),
3560     UciResponse(UciResponseData),
3561     UciNotification(UciNotificationData),
3562     Payload(Bytes),
3563     None,
3564 }
3565 impl UciControlPacketDataChild {
get_total_size(&self) -> usize3566     fn get_total_size(&self) -> usize {
3567         match self {
3568             UciControlPacketDataChild::UciCommand(value) => value.get_total_size(),
3569             UciControlPacketDataChild::UciResponse(value) => value.get_total_size(),
3570             UciControlPacketDataChild::UciNotification(value) => value.get_total_size(),
3571             UciControlPacketDataChild::Payload(bytes) => bytes.len(),
3572             UciControlPacketDataChild::None => 0,
3573         }
3574     }
3575 }
3576 #[derive(Debug, Clone, PartialEq, Eq)]
3577 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3578 pub enum UciControlPacketChild {
3579     UciCommand(UciCommand),
3580     UciResponse(UciResponse),
3581     UciNotification(UciNotification),
3582     Payload(Bytes),
3583     None,
3584 }
3585 #[derive(Debug, Clone, PartialEq, Eq)]
3586 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3587 pub struct UciControlPacketData {
3588     group_id: GroupId,
3589     message_type: MessageType,
3590     opcode: u8,
3591     child: UciControlPacketDataChild,
3592 }
3593 #[derive(Debug, Clone, PartialEq, Eq)]
3594 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3595 pub struct UciControlPacket {
3596     #[cfg_attr(feature = "serde", serde(flatten))]
3597     ucicontrolpacket: UciControlPacketData,
3598 }
3599 #[derive(Debug)]
3600 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3601 pub struct UciControlPacketBuilder {
3602     pub group_id: GroupId,
3603     pub message_type: MessageType,
3604     pub opcode: u8,
3605     pub payload: Option<Bytes>,
3606 }
3607 impl UciControlPacketData {
conforms(bytes: &[u8]) -> bool3608     fn conforms(bytes: &[u8]) -> bool {
3609         bytes.len() >= 7
3610     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>3611     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
3612         let mut cell = Cell::new(bytes);
3613         let packet = Self::parse_inner(&mut cell)?;
3614         Ok(packet)
3615     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>3616     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
3617         if bytes.get().remaining() < 1 {
3618             return Err(DecodeError::InvalidLengthError {
3619                 obj: "UciControlPacket",
3620                 wanted: 1,
3621                 got: bytes.get().remaining(),
3622             });
3623         }
3624         let chunk = bytes.get_mut().get_u8();
3625         let group_id = GroupId::try_from((chunk & 0xf))
3626             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
3627                 obj: "UciControlPacket",
3628                 field: "group_id",
3629                 value: unknown_val as u64,
3630                 type_: "GroupId",
3631             })?;
3632         let message_type = MessageType::try_from(((chunk >> 5) & 0x7))
3633             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
3634                 obj: "UciControlPacket",
3635                 field: "message_type",
3636                 value: unknown_val as u64,
3637                 type_: "MessageType",
3638             })?;
3639         if bytes.get().remaining() < 1 {
3640             return Err(DecodeError::InvalidLengthError {
3641                 obj: "UciControlPacket",
3642                 wanted: 1,
3643                 got: bytes.get().remaining(),
3644             });
3645         }
3646         let chunk = bytes.get_mut().get_u8();
3647         let opcode = (chunk & 0x3f);
3648         if bytes.get().remaining() < 1 {
3649             return Err(DecodeError::InvalidLengthError {
3650                 obj: "UciControlPacket",
3651                 wanted: 1,
3652                 got: bytes.get().remaining(),
3653             });
3654         }
3655         bytes.get_mut().advance(1);
3656         if bytes.get().remaining() < 4 {
3657             return Err(DecodeError::InvalidLengthError {
3658                 obj: "UciControlPacket",
3659                 wanted: 4,
3660                 got: bytes.get().remaining(),
3661             });
3662         }
3663         let payload_size = bytes.get_mut().get_u32_le() as usize;
3664         if bytes.get().remaining() < payload_size {
3665             return Err(DecodeError::InvalidLengthError {
3666                 obj: "UciControlPacket",
3667                 wanted: payload_size,
3668                 got: bytes.get().remaining(),
3669             });
3670         }
3671         let payload = &bytes.get()[..payload_size];
3672         bytes.get_mut().advance(payload_size);
3673         let child = match (message_type) {
3674             (MessageType::Command) if UciCommandData::conforms(&payload) => {
3675                 let mut cell = Cell::new(payload);
3676                 let child_data = UciCommandData::parse_inner(
3677                     &mut cell,
3678                     group_id,
3679                     opcode,
3680                 )?;
3681                 UciControlPacketDataChild::UciCommand(child_data)
3682             }
3683             (MessageType::Response) if UciResponseData::conforms(&payload) => {
3684                 let mut cell = Cell::new(payload);
3685                 let child_data = UciResponseData::parse_inner(
3686                     &mut cell,
3687                     group_id,
3688                     opcode,
3689                 )?;
3690                 UciControlPacketDataChild::UciResponse(child_data)
3691             }
3692             (MessageType::Notification) if UciNotificationData::conforms(&payload) => {
3693                 let mut cell = Cell::new(payload);
3694                 let child_data = UciNotificationData::parse_inner(
3695                     &mut cell,
3696                     group_id,
3697                     opcode,
3698                 )?;
3699                 UciControlPacketDataChild::UciNotification(child_data)
3700             }
3701             _ if !payload.is_empty() => {
3702                 UciControlPacketDataChild::Payload(Bytes::copy_from_slice(payload))
3703             }
3704             _ => UciControlPacketDataChild::None,
3705         };
3706         Ok(Self {
3707             group_id,
3708             message_type,
3709             opcode,
3710             child,
3711         })
3712     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>3713     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
3714         let value = u8::from(self.group_id) | (u8::from(self.message_type) << 5);
3715         buffer.put_u8(value);
3716         if self.opcode > 0x3f {
3717             return Err(EncodeError::InvalidScalarValue {
3718                 packet: "UciControlPacket",
3719                 field: "opcode",
3720                 value: self.opcode as u64,
3721                 maximum_value: 0x3f,
3722             });
3723         }
3724         buffer.put_u8(self.opcode);
3725         buffer.put_bytes(0, 1);
3726         if self.child.get_total_size() > 0xffff_ffff_usize {
3727             return Err(EncodeError::SizeOverflow {
3728                 packet: "UciControlPacket",
3729                 field: "_payload_",
3730                 size: self.child.get_total_size(),
3731                 maximum_size: 0xffff_ffff_usize,
3732             });
3733         }
3734         buffer.put_u32_le(self.child.get_total_size() as u32);
3735         match &self.child {
3736             UciControlPacketDataChild::UciCommand(child) => child.write_to(buffer)?,
3737             UciControlPacketDataChild::UciResponse(child) => child.write_to(buffer)?,
3738             UciControlPacketDataChild::UciNotification(child) => child.write_to(buffer)?,
3739             UciControlPacketDataChild::Payload(payload) => buffer.put_slice(payload),
3740             UciControlPacketDataChild::None => {}
3741         }
3742         Ok(())
3743     }
get_total_size(&self) -> usize3744     fn get_total_size(&self) -> usize {
3745         self.get_size()
3746     }
get_size(&self) -> usize3747     fn get_size(&self) -> usize {
3748         7 + self.child.get_total_size()
3749     }
3750 }
3751 impl Packet for UciControlPacket {
encoded_len(&self) -> usize3752     fn encoded_len(&self) -> usize {
3753         self.get_size()
3754     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>3755     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
3756         self.ucicontrolpacket.write_to(buf)
3757     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>3758     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
3759         unimplemented!("Rust legacy does not implement full packet trait")
3760     }
3761 }
3762 impl TryFrom<UciControlPacket> for Bytes {
3763     type Error = EncodeError;
try_from(packet: UciControlPacket) -> Result<Self, Self::Error>3764     fn try_from(packet: UciControlPacket) -> Result<Self, Self::Error> {
3765         packet.encode_to_bytes()
3766     }
3767 }
3768 impl TryFrom<UciControlPacket> for Vec<u8> {
3769     type Error = EncodeError;
try_from(packet: UciControlPacket) -> Result<Self, Self::Error>3770     fn try_from(packet: UciControlPacket) -> Result<Self, Self::Error> {
3771         packet.encode_to_vec()
3772     }
3773 }
3774 impl UciControlPacket {
parse(bytes: &[u8]) -> Result<Self, DecodeError>3775     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
3776         let mut cell = Cell::new(bytes);
3777         let packet = Self::parse_inner(&mut cell)?;
3778         Ok(packet)
3779     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>3780     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
3781         let data = UciControlPacketData::parse_inner(&mut bytes)?;
3782         Self::new(data)
3783     }
specialize(&self) -> UciControlPacketChild3784     pub fn specialize(&self) -> UciControlPacketChild {
3785         match &self.ucicontrolpacket.child {
3786             UciControlPacketDataChild::UciCommand(_) => {
3787                 UciControlPacketChild::UciCommand(
3788                     UciCommand::new(self.ucicontrolpacket.clone()).unwrap(),
3789                 )
3790             }
3791             UciControlPacketDataChild::UciResponse(_) => {
3792                 UciControlPacketChild::UciResponse(
3793                     UciResponse::new(self.ucicontrolpacket.clone()).unwrap(),
3794                 )
3795             }
3796             UciControlPacketDataChild::UciNotification(_) => {
3797                 UciControlPacketChild::UciNotification(
3798                     UciNotification::new(self.ucicontrolpacket.clone()).unwrap(),
3799                 )
3800             }
3801             UciControlPacketDataChild::Payload(payload) => {
3802                 UciControlPacketChild::Payload(payload.clone())
3803             }
3804             UciControlPacketDataChild::None => UciControlPacketChild::None,
3805         }
3806     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>3807     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
3808         Ok(Self { ucicontrolpacket })
3809     }
get_group_id(&self) -> GroupId3810     pub fn get_group_id(&self) -> GroupId {
3811         self.ucicontrolpacket.group_id
3812     }
get_message_type(&self) -> MessageType3813     pub fn get_message_type(&self) -> MessageType {
3814         self.ucicontrolpacket.message_type
3815     }
get_opcode(&self) -> u83816     pub fn get_opcode(&self) -> u8 {
3817         self.ucicontrolpacket.opcode
3818     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>3819     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
3820         self.ucicontrolpacket.write_to(buffer)
3821     }
get_size(&self) -> usize3822     pub fn get_size(&self) -> usize {
3823         self.ucicontrolpacket.get_size()
3824     }
3825 }
3826 impl UciControlPacketBuilder {
build(self) -> UciControlPacket3827     pub fn build(self) -> UciControlPacket {
3828         let ucicontrolpacket = UciControlPacketData {
3829             group_id: self.group_id,
3830             message_type: self.message_type,
3831             opcode: self.opcode,
3832             child: match self.payload {
3833                 None => UciControlPacketDataChild::None,
3834                 Some(bytes) => UciControlPacketDataChild::Payload(bytes),
3835             },
3836         };
3837         UciControlPacket::new(ucicontrolpacket).unwrap()
3838     }
3839 }
3840 impl From<UciControlPacketBuilder> for UciControlPacket {
from(builder: UciControlPacketBuilder) -> UciControlPacket3841     fn from(builder: UciControlPacketBuilder) -> UciControlPacket {
3842         builder.build().into()
3843     }
3844 }
3845 #[derive(Debug, Clone, PartialEq, Eq)]
3846 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3847 pub enum UciDataPacketDataChild {
3848     UciDataSnd(UciDataSndData),
3849     UciDataRcv(UciDataRcvData),
3850     RadarDataRcv(RadarDataRcvData),
3851     Payload(Bytes),
3852     None,
3853 }
3854 impl UciDataPacketDataChild {
get_total_size(&self) -> usize3855     fn get_total_size(&self) -> usize {
3856         match self {
3857             UciDataPacketDataChild::UciDataSnd(value) => value.get_total_size(),
3858             UciDataPacketDataChild::UciDataRcv(value) => value.get_total_size(),
3859             UciDataPacketDataChild::RadarDataRcv(value) => value.get_total_size(),
3860             UciDataPacketDataChild::Payload(bytes) => bytes.len(),
3861             UciDataPacketDataChild::None => 0,
3862         }
3863     }
3864 }
3865 #[derive(Debug, Clone, PartialEq, Eq)]
3866 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3867 pub enum UciDataPacketChild {
3868     UciDataSnd(UciDataSnd),
3869     UciDataRcv(UciDataRcv),
3870     RadarDataRcv(RadarDataRcv),
3871     Payload(Bytes),
3872     None,
3873 }
3874 #[derive(Debug, Clone, PartialEq, Eq)]
3875 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3876 pub struct UciDataPacketData {
3877     data_packet_format: DataPacketFormat,
3878     message_type: MessageType,
3879     child: UciDataPacketDataChild,
3880 }
3881 #[derive(Debug, Clone, PartialEq, Eq)]
3882 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3883 pub struct UciDataPacket {
3884     #[cfg_attr(feature = "serde", serde(flatten))]
3885     ucidatapacket: UciDataPacketData,
3886 }
3887 #[derive(Debug)]
3888 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
3889 pub struct UciDataPacketBuilder {
3890     pub data_packet_format: DataPacketFormat,
3891     pub message_type: MessageType,
3892     pub payload: Option<Bytes>,
3893 }
3894 impl UciDataPacketData {
conforms(bytes: &[u8]) -> bool3895     fn conforms(bytes: &[u8]) -> bool {
3896         bytes.len() >= 6
3897     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>3898     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
3899         let mut cell = Cell::new(bytes);
3900         let packet = Self::parse_inner(&mut cell)?;
3901         Ok(packet)
3902     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>3903     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
3904         if bytes.get().remaining() < 1 {
3905             return Err(DecodeError::InvalidLengthError {
3906                 obj: "UciDataPacket",
3907                 wanted: 1,
3908                 got: bytes.get().remaining(),
3909             });
3910         }
3911         let chunk = bytes.get_mut().get_u8();
3912         let data_packet_format = DataPacketFormat::try_from((chunk & 0xf))
3913             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
3914                 obj: "UciDataPacket",
3915                 field: "data_packet_format",
3916                 value: unknown_val as u64,
3917                 type_: "DataPacketFormat",
3918             })?;
3919         let message_type = MessageType::try_from(((chunk >> 5) & 0x7))
3920             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
3921                 obj: "UciDataPacket",
3922                 field: "message_type",
3923                 value: unknown_val as u64,
3924                 type_: "MessageType",
3925             })?;
3926         if bytes.get().remaining() < 1 {
3927             return Err(DecodeError::InvalidLengthError {
3928                 obj: "UciDataPacket",
3929                 wanted: 1,
3930                 got: bytes.get().remaining(),
3931             });
3932         }
3933         bytes.get_mut().advance(1);
3934         if bytes.get().remaining() < 4 {
3935             return Err(DecodeError::InvalidLengthError {
3936                 obj: "UciDataPacket",
3937                 wanted: 4,
3938                 got: bytes.get().remaining(),
3939             });
3940         }
3941         let payload_size = bytes.get_mut().get_u32_le() as usize;
3942         if bytes.get().remaining() < payload_size {
3943             return Err(DecodeError::InvalidLengthError {
3944                 obj: "UciDataPacket",
3945                 wanted: payload_size,
3946                 got: bytes.get().remaining(),
3947             });
3948         }
3949         let payload = &bytes.get()[..payload_size];
3950         bytes.get_mut().advance(payload_size);
3951         let child = match (data_packet_format, message_type) {
3952             (
3953                 DataPacketFormat::DataSnd,
3954                 MessageType::Data,
3955             ) if UciDataSndData::conforms(&payload) => {
3956                 let mut cell = Cell::new(payload);
3957                 let child_data = UciDataSndData::parse_inner(&mut cell)?;
3958                 UciDataPacketDataChild::UciDataSnd(child_data)
3959             }
3960             (
3961                 DataPacketFormat::DataRcv,
3962                 MessageType::Data,
3963             ) if UciDataRcvData::conforms(&payload) => {
3964                 let mut cell = Cell::new(payload);
3965                 let child_data = UciDataRcvData::parse_inner(&mut cell)?;
3966                 UciDataPacketDataChild::UciDataRcv(child_data)
3967             }
3968             (
3969                 DataPacketFormat::RadarDataMessage,
3970                 MessageType::Data,
3971             ) if RadarDataRcvData::conforms(&payload) => {
3972                 let mut cell = Cell::new(payload);
3973                 let child_data = RadarDataRcvData::parse_inner(&mut cell)?;
3974                 UciDataPacketDataChild::RadarDataRcv(child_data)
3975             }
3976             _ if !payload.is_empty() => {
3977                 UciDataPacketDataChild::Payload(Bytes::copy_from_slice(payload))
3978             }
3979             _ => UciDataPacketDataChild::None,
3980         };
3981         Ok(Self {
3982             data_packet_format,
3983             message_type,
3984             child,
3985         })
3986     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>3987     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
3988         let value = u8::from(self.data_packet_format)
3989             | (u8::from(self.message_type) << 5);
3990         buffer.put_u8(value);
3991         buffer.put_bytes(0, 1);
3992         if self.child.get_total_size() > 0xffff_ffff_usize {
3993             return Err(EncodeError::SizeOverflow {
3994                 packet: "UciDataPacket",
3995                 field: "_payload_",
3996                 size: self.child.get_total_size(),
3997                 maximum_size: 0xffff_ffff_usize,
3998             });
3999         }
4000         buffer.put_u32_le(self.child.get_total_size() as u32);
4001         match &self.child {
4002             UciDataPacketDataChild::UciDataSnd(child) => child.write_to(buffer)?,
4003             UciDataPacketDataChild::UciDataRcv(child) => child.write_to(buffer)?,
4004             UciDataPacketDataChild::RadarDataRcv(child) => child.write_to(buffer)?,
4005             UciDataPacketDataChild::Payload(payload) => buffer.put_slice(payload),
4006             UciDataPacketDataChild::None => {}
4007         }
4008         Ok(())
4009     }
get_total_size(&self) -> usize4010     fn get_total_size(&self) -> usize {
4011         self.get_size()
4012     }
get_size(&self) -> usize4013     fn get_size(&self) -> usize {
4014         6 + self.child.get_total_size()
4015     }
4016 }
4017 impl Packet for UciDataPacket {
encoded_len(&self) -> usize4018     fn encoded_len(&self) -> usize {
4019         self.get_size()
4020     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>4021     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
4022         self.ucidatapacket.write_to(buf)
4023     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>4024     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
4025         unimplemented!("Rust legacy does not implement full packet trait")
4026     }
4027 }
4028 impl TryFrom<UciDataPacket> for Bytes {
4029     type Error = EncodeError;
try_from(packet: UciDataPacket) -> Result<Self, Self::Error>4030     fn try_from(packet: UciDataPacket) -> Result<Self, Self::Error> {
4031         packet.encode_to_bytes()
4032     }
4033 }
4034 impl TryFrom<UciDataPacket> for Vec<u8> {
4035     type Error = EncodeError;
try_from(packet: UciDataPacket) -> Result<Self, Self::Error>4036     fn try_from(packet: UciDataPacket) -> Result<Self, Self::Error> {
4037         packet.encode_to_vec()
4038     }
4039 }
4040 impl UciDataPacket {
parse(bytes: &[u8]) -> Result<Self, DecodeError>4041     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
4042         let mut cell = Cell::new(bytes);
4043         let packet = Self::parse_inner(&mut cell)?;
4044         Ok(packet)
4045     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>4046     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
4047         let data = UciDataPacketData::parse_inner(&mut bytes)?;
4048         Self::new(data)
4049     }
specialize(&self) -> UciDataPacketChild4050     pub fn specialize(&self) -> UciDataPacketChild {
4051         match &self.ucidatapacket.child {
4052             UciDataPacketDataChild::UciDataSnd(_) => {
4053                 UciDataPacketChild::UciDataSnd(
4054                     UciDataSnd::new(self.ucidatapacket.clone()).unwrap(),
4055                 )
4056             }
4057             UciDataPacketDataChild::UciDataRcv(_) => {
4058                 UciDataPacketChild::UciDataRcv(
4059                     UciDataRcv::new(self.ucidatapacket.clone()).unwrap(),
4060                 )
4061             }
4062             UciDataPacketDataChild::RadarDataRcv(_) => {
4063                 UciDataPacketChild::RadarDataRcv(
4064                     RadarDataRcv::new(self.ucidatapacket.clone()).unwrap(),
4065                 )
4066             }
4067             UciDataPacketDataChild::Payload(payload) => {
4068                 UciDataPacketChild::Payload(payload.clone())
4069             }
4070             UciDataPacketDataChild::None => UciDataPacketChild::None,
4071         }
4072     }
new(ucidatapacket: UciDataPacketData) -> Result<Self, DecodeError>4073     fn new(ucidatapacket: UciDataPacketData) -> Result<Self, DecodeError> {
4074         Ok(Self { ucidatapacket })
4075     }
get_data_packet_format(&self) -> DataPacketFormat4076     pub fn get_data_packet_format(&self) -> DataPacketFormat {
4077         self.ucidatapacket.data_packet_format
4078     }
get_message_type(&self) -> MessageType4079     pub fn get_message_type(&self) -> MessageType {
4080         self.ucidatapacket.message_type
4081     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>4082     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
4083         self.ucidatapacket.write_to(buffer)
4084     }
get_size(&self) -> usize4085     pub fn get_size(&self) -> usize {
4086         self.ucidatapacket.get_size()
4087     }
4088 }
4089 impl UciDataPacketBuilder {
build(self) -> UciDataPacket4090     pub fn build(self) -> UciDataPacket {
4091         let ucidatapacket = UciDataPacketData {
4092             data_packet_format: self.data_packet_format,
4093             message_type: self.message_type,
4094             child: match self.payload {
4095                 None => UciDataPacketDataChild::None,
4096                 Some(bytes) => UciDataPacketDataChild::Payload(bytes),
4097             },
4098         };
4099         UciDataPacket::new(ucidatapacket).unwrap()
4100     }
4101 }
4102 impl From<UciDataPacketBuilder> for UciDataPacket {
from(builder: UciDataPacketBuilder) -> UciDataPacket4103     fn from(builder: UciDataPacketBuilder) -> UciDataPacket {
4104         builder.build().into()
4105     }
4106 }
4107 #[derive(Debug, Clone, PartialEq, Eq)]
4108 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4109 pub struct UciDataSndData {
4110     session_token: u32,
4111     dest_mac_address: u64,
4112     uci_sequence_number: u16,
4113     data: Vec<u8>,
4114 }
4115 #[derive(Debug, Clone, PartialEq, Eq)]
4116 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4117 pub struct UciDataSnd {
4118     #[cfg_attr(feature = "serde", serde(flatten))]
4119     ucidatapacket: UciDataPacketData,
4120     #[cfg_attr(feature = "serde", serde(flatten))]
4121     ucidatasnd: UciDataSndData,
4122 }
4123 #[derive(Debug)]
4124 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4125 pub struct UciDataSndBuilder {
4126     pub data: Vec<u8>,
4127     pub dest_mac_address: u64,
4128     pub session_token: u32,
4129     pub uci_sequence_number: u16,
4130 }
4131 impl UciDataSndData {
conforms(bytes: &[u8]) -> bool4132     fn conforms(bytes: &[u8]) -> bool {
4133         bytes.len() >= 16
4134     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>4135     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
4136         let mut cell = Cell::new(bytes);
4137         let packet = Self::parse_inner(&mut cell)?;
4138         Ok(packet)
4139     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>4140     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
4141         if bytes.get().remaining() < 4 {
4142             return Err(DecodeError::InvalidLengthError {
4143                 obj: "UciDataSnd",
4144                 wanted: 4,
4145                 got: bytes.get().remaining(),
4146             });
4147         }
4148         let session_token = bytes.get_mut().get_u32_le();
4149         if bytes.get().remaining() < 8 {
4150             return Err(DecodeError::InvalidLengthError {
4151                 obj: "UciDataSnd",
4152                 wanted: 8,
4153                 got: bytes.get().remaining(),
4154             });
4155         }
4156         let dest_mac_address = bytes.get_mut().get_u64_le();
4157         if bytes.get().remaining() < 2 {
4158             return Err(DecodeError::InvalidLengthError {
4159                 obj: "UciDataSnd",
4160                 wanted: 2,
4161                 got: bytes.get().remaining(),
4162             });
4163         }
4164         let uci_sequence_number = bytes.get_mut().get_u16_le();
4165         if bytes.get().remaining() < 2 {
4166             return Err(DecodeError::InvalidLengthError {
4167                 obj: "UciDataSnd",
4168                 wanted: 2,
4169                 got: bytes.get().remaining(),
4170             });
4171         }
4172         let data_size = bytes.get_mut().get_u16_le() as usize;
4173         if bytes.get().remaining() < data_size {
4174             return Err(DecodeError::InvalidLengthError {
4175                 obj: "UciDataSnd",
4176                 wanted: data_size,
4177                 got: bytes.get().remaining(),
4178             });
4179         }
4180         let mut data = Vec::with_capacity(data_size);
4181         for _ in 0..data_size {
4182             data.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
4183         }
4184         Ok(Self {
4185             session_token,
4186             dest_mac_address,
4187             uci_sequence_number,
4188             data,
4189         })
4190     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>4191     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
4192         buffer.put_u32_le(self.session_token);
4193         buffer.put_u64_le(self.dest_mac_address);
4194         buffer.put_u16_le(self.uci_sequence_number);
4195         if self.data.len() > 0xffff {
4196             return Err(EncodeError::SizeOverflow {
4197                 packet: "UciDataSnd",
4198                 field: "data",
4199                 size: self.data.len(),
4200                 maximum_size: 0xffff,
4201             });
4202         }
4203         buffer.put_u16_le(self.data.len() as u16);
4204         for elem in &self.data {
4205             buffer.put_u8(*elem);
4206         }
4207         Ok(())
4208     }
get_total_size(&self) -> usize4209     fn get_total_size(&self) -> usize {
4210         self.get_size()
4211     }
get_size(&self) -> usize4212     fn get_size(&self) -> usize {
4213         16 + self.data.len()
4214     }
4215 }
4216 impl Packet for UciDataSnd {
encoded_len(&self) -> usize4217     fn encoded_len(&self) -> usize {
4218         self.get_size()
4219     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>4220     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
4221         self.ucidatapacket.write_to(buf)
4222     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>4223     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
4224         unimplemented!("Rust legacy does not implement full packet trait")
4225     }
4226 }
4227 impl TryFrom<UciDataSnd> for Bytes {
4228     type Error = EncodeError;
try_from(packet: UciDataSnd) -> Result<Self, Self::Error>4229     fn try_from(packet: UciDataSnd) -> Result<Self, Self::Error> {
4230         packet.encode_to_bytes()
4231     }
4232 }
4233 impl TryFrom<UciDataSnd> for Vec<u8> {
4234     type Error = EncodeError;
try_from(packet: UciDataSnd) -> Result<Self, Self::Error>4235     fn try_from(packet: UciDataSnd) -> Result<Self, Self::Error> {
4236         packet.encode_to_vec()
4237     }
4238 }
4239 impl From<UciDataSnd> for UciDataPacket {
from(packet: UciDataSnd) -> UciDataPacket4240     fn from(packet: UciDataSnd) -> UciDataPacket {
4241         UciDataPacket::new(packet.ucidatapacket).unwrap()
4242     }
4243 }
4244 impl TryFrom<UciDataPacket> for UciDataSnd {
4245     type Error = DecodeError;
try_from(packet: UciDataPacket) -> Result<UciDataSnd, Self::Error>4246     fn try_from(packet: UciDataPacket) -> Result<UciDataSnd, Self::Error> {
4247         UciDataSnd::new(packet.ucidatapacket)
4248     }
4249 }
4250 impl UciDataSnd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>4251     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
4252         let mut cell = Cell::new(bytes);
4253         let packet = Self::parse_inner(&mut cell)?;
4254         Ok(packet)
4255     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>4256     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
4257         let data = UciDataPacketData::parse_inner(&mut bytes)?;
4258         Self::new(data)
4259     }
new(ucidatapacket: UciDataPacketData) -> Result<Self, DecodeError>4260     fn new(ucidatapacket: UciDataPacketData) -> Result<Self, DecodeError> {
4261         let ucidatasnd = match &ucidatapacket.child {
4262             UciDataPacketDataChild::UciDataSnd(value) => value.clone(),
4263             _ => {
4264                 return Err(DecodeError::InvalidChildError {
4265                     expected: stringify!(UciDataPacketDataChild::UciDataSnd),
4266                     actual: format!("{:?}", & ucidatapacket.child),
4267                 });
4268             }
4269         };
4270         Ok(Self { ucidatapacket, ucidatasnd })
4271     }
get_data(&self) -> &Vec<u8>4272     pub fn get_data(&self) -> &Vec<u8> {
4273         &self.ucidatasnd.data
4274     }
get_data_packet_format(&self) -> DataPacketFormat4275     pub fn get_data_packet_format(&self) -> DataPacketFormat {
4276         self.ucidatapacket.data_packet_format
4277     }
get_dest_mac_address(&self) -> u644278     pub fn get_dest_mac_address(&self) -> u64 {
4279         self.ucidatasnd.dest_mac_address
4280     }
get_message_type(&self) -> MessageType4281     pub fn get_message_type(&self) -> MessageType {
4282         self.ucidatapacket.message_type
4283     }
get_session_token(&self) -> u324284     pub fn get_session_token(&self) -> u32 {
4285         self.ucidatasnd.session_token
4286     }
get_uci_sequence_number(&self) -> u164287     pub fn get_uci_sequence_number(&self) -> u16 {
4288         self.ucidatasnd.uci_sequence_number
4289     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>4290     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
4291         self.ucidatasnd.write_to(buffer)
4292     }
get_size(&self) -> usize4293     pub fn get_size(&self) -> usize {
4294         self.ucidatapacket.get_size()
4295     }
4296 }
4297 impl UciDataSndBuilder {
build(self) -> UciDataSnd4298     pub fn build(self) -> UciDataSnd {
4299         let ucidatasnd = UciDataSndData {
4300             data: self.data,
4301             dest_mac_address: self.dest_mac_address,
4302             session_token: self.session_token,
4303             uci_sequence_number: self.uci_sequence_number,
4304         };
4305         let ucidatapacket = UciDataPacketData {
4306             data_packet_format: DataPacketFormat::DataSnd,
4307             message_type: MessageType::Data,
4308             child: UciDataPacketDataChild::UciDataSnd(ucidatasnd),
4309         };
4310         UciDataSnd::new(ucidatapacket).unwrap()
4311     }
4312 }
4313 impl From<UciDataSndBuilder> for UciDataPacket {
from(builder: UciDataSndBuilder) -> UciDataPacket4314     fn from(builder: UciDataSndBuilder) -> UciDataPacket {
4315         builder.build().into()
4316     }
4317 }
4318 impl From<UciDataSndBuilder> for UciDataSnd {
from(builder: UciDataSndBuilder) -> UciDataSnd4319     fn from(builder: UciDataSndBuilder) -> UciDataSnd {
4320         builder.build().into()
4321     }
4322 }
4323 #[derive(Debug, Clone, PartialEq, Eq)]
4324 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4325 pub struct UciDataRcvData {
4326     session_token: u32,
4327     status: StatusCode,
4328     source_mac_address: u64,
4329     uci_sequence_number: u16,
4330     data: Vec<u8>,
4331 }
4332 #[derive(Debug, Clone, PartialEq, Eq)]
4333 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4334 pub struct UciDataRcv {
4335     #[cfg_attr(feature = "serde", serde(flatten))]
4336     ucidatapacket: UciDataPacketData,
4337     #[cfg_attr(feature = "serde", serde(flatten))]
4338     ucidatarcv: UciDataRcvData,
4339 }
4340 #[derive(Debug)]
4341 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4342 pub struct UciDataRcvBuilder {
4343     pub data: Vec<u8>,
4344     pub session_token: u32,
4345     pub source_mac_address: u64,
4346     pub status: StatusCode,
4347     pub uci_sequence_number: u16,
4348 }
4349 impl UciDataRcvData {
conforms(bytes: &[u8]) -> bool4350     fn conforms(bytes: &[u8]) -> bool {
4351         bytes.len() >= 17
4352     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>4353     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
4354         let mut cell = Cell::new(bytes);
4355         let packet = Self::parse_inner(&mut cell)?;
4356         Ok(packet)
4357     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>4358     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
4359         if bytes.get().remaining() < 4 {
4360             return Err(DecodeError::InvalidLengthError {
4361                 obj: "UciDataRcv",
4362                 wanted: 4,
4363                 got: bytes.get().remaining(),
4364             });
4365         }
4366         let session_token = bytes.get_mut().get_u32_le();
4367         if bytes.get().remaining() < 1 {
4368             return Err(DecodeError::InvalidLengthError {
4369                 obj: "UciDataRcv",
4370                 wanted: 1,
4371                 got: bytes.get().remaining(),
4372             });
4373         }
4374         let status = StatusCode::try_from(bytes.get_mut().get_u8())
4375             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
4376                 obj: "UciDataRcv",
4377                 field: "status",
4378                 value: unknown_val as u64,
4379                 type_: "StatusCode",
4380             })?;
4381         if bytes.get().remaining() < 8 {
4382             return Err(DecodeError::InvalidLengthError {
4383                 obj: "UciDataRcv",
4384                 wanted: 8,
4385                 got: bytes.get().remaining(),
4386             });
4387         }
4388         let source_mac_address = bytes.get_mut().get_u64_le();
4389         if bytes.get().remaining() < 2 {
4390             return Err(DecodeError::InvalidLengthError {
4391                 obj: "UciDataRcv",
4392                 wanted: 2,
4393                 got: bytes.get().remaining(),
4394             });
4395         }
4396         let uci_sequence_number = bytes.get_mut().get_u16_le();
4397         if bytes.get().remaining() < 2 {
4398             return Err(DecodeError::InvalidLengthError {
4399                 obj: "UciDataRcv",
4400                 wanted: 2,
4401                 got: bytes.get().remaining(),
4402             });
4403         }
4404         let data_size = bytes.get_mut().get_u16_le() as usize;
4405         if bytes.get().remaining() < data_size {
4406             return Err(DecodeError::InvalidLengthError {
4407                 obj: "UciDataRcv",
4408                 wanted: data_size,
4409                 got: bytes.get().remaining(),
4410             });
4411         }
4412         let mut data = Vec::with_capacity(data_size);
4413         for _ in 0..data_size {
4414             data.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
4415         }
4416         Ok(Self {
4417             session_token,
4418             status,
4419             source_mac_address,
4420             uci_sequence_number,
4421             data,
4422         })
4423     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>4424     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
4425         buffer.put_u32_le(self.session_token);
4426         buffer.put_u8(u8::from(self.status));
4427         buffer.put_u64_le(self.source_mac_address);
4428         buffer.put_u16_le(self.uci_sequence_number);
4429         if self.data.len() > 0xffff {
4430             return Err(EncodeError::SizeOverflow {
4431                 packet: "UciDataRcv",
4432                 field: "data",
4433                 size: self.data.len(),
4434                 maximum_size: 0xffff,
4435             });
4436         }
4437         buffer.put_u16_le(self.data.len() as u16);
4438         for elem in &self.data {
4439             buffer.put_u8(*elem);
4440         }
4441         Ok(())
4442     }
get_total_size(&self) -> usize4443     fn get_total_size(&self) -> usize {
4444         self.get_size()
4445     }
get_size(&self) -> usize4446     fn get_size(&self) -> usize {
4447         17 + self.data.len()
4448     }
4449 }
4450 impl Packet for UciDataRcv {
encoded_len(&self) -> usize4451     fn encoded_len(&self) -> usize {
4452         self.get_size()
4453     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>4454     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
4455         self.ucidatapacket.write_to(buf)
4456     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>4457     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
4458         unimplemented!("Rust legacy does not implement full packet trait")
4459     }
4460 }
4461 impl TryFrom<UciDataRcv> for Bytes {
4462     type Error = EncodeError;
try_from(packet: UciDataRcv) -> Result<Self, Self::Error>4463     fn try_from(packet: UciDataRcv) -> Result<Self, Self::Error> {
4464         packet.encode_to_bytes()
4465     }
4466 }
4467 impl TryFrom<UciDataRcv> for Vec<u8> {
4468     type Error = EncodeError;
try_from(packet: UciDataRcv) -> Result<Self, Self::Error>4469     fn try_from(packet: UciDataRcv) -> Result<Self, Self::Error> {
4470         packet.encode_to_vec()
4471     }
4472 }
4473 impl From<UciDataRcv> for UciDataPacket {
from(packet: UciDataRcv) -> UciDataPacket4474     fn from(packet: UciDataRcv) -> UciDataPacket {
4475         UciDataPacket::new(packet.ucidatapacket).unwrap()
4476     }
4477 }
4478 impl TryFrom<UciDataPacket> for UciDataRcv {
4479     type Error = DecodeError;
try_from(packet: UciDataPacket) -> Result<UciDataRcv, Self::Error>4480     fn try_from(packet: UciDataPacket) -> Result<UciDataRcv, Self::Error> {
4481         UciDataRcv::new(packet.ucidatapacket)
4482     }
4483 }
4484 impl UciDataRcv {
parse(bytes: &[u8]) -> Result<Self, DecodeError>4485     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
4486         let mut cell = Cell::new(bytes);
4487         let packet = Self::parse_inner(&mut cell)?;
4488         Ok(packet)
4489     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>4490     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
4491         let data = UciDataPacketData::parse_inner(&mut bytes)?;
4492         Self::new(data)
4493     }
new(ucidatapacket: UciDataPacketData) -> Result<Self, DecodeError>4494     fn new(ucidatapacket: UciDataPacketData) -> Result<Self, DecodeError> {
4495         let ucidatarcv = match &ucidatapacket.child {
4496             UciDataPacketDataChild::UciDataRcv(value) => value.clone(),
4497             _ => {
4498                 return Err(DecodeError::InvalidChildError {
4499                     expected: stringify!(UciDataPacketDataChild::UciDataRcv),
4500                     actual: format!("{:?}", & ucidatapacket.child),
4501                 });
4502             }
4503         };
4504         Ok(Self { ucidatapacket, ucidatarcv })
4505     }
get_data(&self) -> &Vec<u8>4506     pub fn get_data(&self) -> &Vec<u8> {
4507         &self.ucidatarcv.data
4508     }
get_data_packet_format(&self) -> DataPacketFormat4509     pub fn get_data_packet_format(&self) -> DataPacketFormat {
4510         self.ucidatapacket.data_packet_format
4511     }
get_message_type(&self) -> MessageType4512     pub fn get_message_type(&self) -> MessageType {
4513         self.ucidatapacket.message_type
4514     }
get_session_token(&self) -> u324515     pub fn get_session_token(&self) -> u32 {
4516         self.ucidatarcv.session_token
4517     }
get_source_mac_address(&self) -> u644518     pub fn get_source_mac_address(&self) -> u64 {
4519         self.ucidatarcv.source_mac_address
4520     }
get_status(&self) -> StatusCode4521     pub fn get_status(&self) -> StatusCode {
4522         self.ucidatarcv.status
4523     }
get_uci_sequence_number(&self) -> u164524     pub fn get_uci_sequence_number(&self) -> u16 {
4525         self.ucidatarcv.uci_sequence_number
4526     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>4527     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
4528         self.ucidatarcv.write_to(buffer)
4529     }
get_size(&self) -> usize4530     pub fn get_size(&self) -> usize {
4531         self.ucidatapacket.get_size()
4532     }
4533 }
4534 impl UciDataRcvBuilder {
build(self) -> UciDataRcv4535     pub fn build(self) -> UciDataRcv {
4536         let ucidatarcv = UciDataRcvData {
4537             data: self.data,
4538             session_token: self.session_token,
4539             source_mac_address: self.source_mac_address,
4540             status: self.status,
4541             uci_sequence_number: self.uci_sequence_number,
4542         };
4543         let ucidatapacket = UciDataPacketData {
4544             data_packet_format: DataPacketFormat::DataRcv,
4545             message_type: MessageType::Data,
4546             child: UciDataPacketDataChild::UciDataRcv(ucidatarcv),
4547         };
4548         UciDataRcv::new(ucidatapacket).unwrap()
4549     }
4550 }
4551 impl From<UciDataRcvBuilder> for UciDataPacket {
from(builder: UciDataRcvBuilder) -> UciDataPacket4552     fn from(builder: UciDataRcvBuilder) -> UciDataPacket {
4553         builder.build().into()
4554     }
4555 }
4556 impl From<UciDataRcvBuilder> for UciDataRcv {
from(builder: UciDataRcvBuilder) -> UciDataRcv4557     fn from(builder: UciDataRcvBuilder) -> UciDataRcv {
4558         builder.build().into()
4559     }
4560 }
4561 #[derive(Debug, Clone, PartialEq, Eq)]
4562 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4563 pub enum UciCommandDataChild {
4564     CoreCommand(CoreCommandData),
4565     SessionConfigCommand(SessionConfigCommandData),
4566     SessionControlCommand(SessionControlCommandData),
4567     AndroidCommand(AndroidCommandData),
4568     TestCommand(TestCommandData),
4569     Payload(Bytes),
4570     None,
4571 }
4572 impl UciCommandDataChild {
get_total_size(&self) -> usize4573     fn get_total_size(&self) -> usize {
4574         match self {
4575             UciCommandDataChild::CoreCommand(value) => value.get_total_size(),
4576             UciCommandDataChild::SessionConfigCommand(value) => value.get_total_size(),
4577             UciCommandDataChild::SessionControlCommand(value) => value.get_total_size(),
4578             UciCommandDataChild::AndroidCommand(value) => value.get_total_size(),
4579             UciCommandDataChild::TestCommand(value) => value.get_total_size(),
4580             UciCommandDataChild::Payload(bytes) => bytes.len(),
4581             UciCommandDataChild::None => 0,
4582         }
4583     }
4584 }
4585 #[derive(Debug, Clone, PartialEq, Eq)]
4586 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4587 pub enum UciCommandChild {
4588     CoreCommand(CoreCommand),
4589     SessionConfigCommand(SessionConfigCommand),
4590     SessionControlCommand(SessionControlCommand),
4591     AndroidCommand(AndroidCommand),
4592     TestCommand(TestCommand),
4593     Payload(Bytes),
4594     None,
4595 }
4596 #[derive(Debug, Clone, PartialEq, Eq)]
4597 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4598 pub struct UciCommandData {
4599     child: UciCommandDataChild,
4600 }
4601 #[derive(Debug, Clone, PartialEq, Eq)]
4602 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4603 pub struct UciCommand {
4604     #[cfg_attr(feature = "serde", serde(flatten))]
4605     ucicontrolpacket: UciControlPacketData,
4606     #[cfg_attr(feature = "serde", serde(flatten))]
4607     ucicommand: UciCommandData,
4608 }
4609 #[derive(Debug)]
4610 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4611 pub struct UciCommandBuilder {
4612     pub group_id: GroupId,
4613     pub opcode: u8,
4614     pub payload: Option<Bytes>,
4615 }
4616 impl UciCommandData {
conforms(bytes: &[u8]) -> bool4617     fn conforms(bytes: &[u8]) -> bool {
4618         true
4619     }
parse(bytes: &[u8], group_id: GroupId, opcode: u8) -> Result<Self, DecodeError>4620     fn parse(bytes: &[u8], group_id: GroupId, opcode: u8) -> Result<Self, DecodeError> {
4621         let mut cell = Cell::new(bytes);
4622         let packet = Self::parse_inner(&mut cell, group_id, opcode)?;
4623         Ok(packet)
4624     }
parse_inner( mut bytes: &mut Cell<&[u8]>, group_id: GroupId, opcode: u8, ) -> Result<Self, DecodeError>4625     fn parse_inner(
4626         mut bytes: &mut Cell<&[u8]>,
4627         group_id: GroupId,
4628         opcode: u8,
4629     ) -> Result<Self, DecodeError> {
4630         let payload = bytes.get();
4631         bytes.get_mut().advance(payload.len());
4632         let child = match (group_id) {
4633             (GroupId::Core) if CoreCommandData::conforms(&payload) => {
4634                 let mut cell = Cell::new(payload);
4635                 let child_data = CoreCommandData::parse_inner(&mut cell, opcode)?;
4636                 UciCommandDataChild::CoreCommand(child_data)
4637             }
4638             (GroupId::SessionConfig) if SessionConfigCommandData::conforms(&payload) => {
4639                 let mut cell = Cell::new(payload);
4640                 let child_data = SessionConfigCommandData::parse_inner(
4641                     &mut cell,
4642                     opcode,
4643                 )?;
4644                 UciCommandDataChild::SessionConfigCommand(child_data)
4645             }
4646             (GroupId::SessionControl) if SessionControlCommandData::conforms(
4647                 &payload,
4648             ) => {
4649                 let mut cell = Cell::new(payload);
4650                 let child_data = SessionControlCommandData::parse_inner(
4651                     &mut cell,
4652                     opcode,
4653                 )?;
4654                 UciCommandDataChild::SessionControlCommand(child_data)
4655             }
4656             (GroupId::VendorAndroid) if AndroidCommandData::conforms(&payload) => {
4657                 let mut cell = Cell::new(payload);
4658                 let child_data = AndroidCommandData::parse_inner(&mut cell, opcode)?;
4659                 UciCommandDataChild::AndroidCommand(child_data)
4660             }
4661             (GroupId::Test) if TestCommandData::conforms(&payload) => {
4662                 let mut cell = Cell::new(payload);
4663                 let child_data = TestCommandData::parse_inner(&mut cell, opcode)?;
4664                 UciCommandDataChild::TestCommand(child_data)
4665             }
4666             _ if !payload.is_empty() => {
4667                 UciCommandDataChild::Payload(Bytes::copy_from_slice(payload))
4668             }
4669             _ => UciCommandDataChild::None,
4670         };
4671         Ok(Self { child })
4672     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>4673     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
4674         match &self.child {
4675             UciCommandDataChild::CoreCommand(child) => child.write_to(buffer)?,
4676             UciCommandDataChild::SessionConfigCommand(child) => child.write_to(buffer)?,
4677             UciCommandDataChild::SessionControlCommand(child) => child.write_to(buffer)?,
4678             UciCommandDataChild::AndroidCommand(child) => child.write_to(buffer)?,
4679             UciCommandDataChild::TestCommand(child) => child.write_to(buffer)?,
4680             UciCommandDataChild::Payload(payload) => buffer.put_slice(payload),
4681             UciCommandDataChild::None => {}
4682         }
4683         Ok(())
4684     }
get_total_size(&self) -> usize4685     fn get_total_size(&self) -> usize {
4686         self.get_size()
4687     }
get_size(&self) -> usize4688     fn get_size(&self) -> usize {
4689         self.child.get_total_size()
4690     }
4691 }
4692 impl Packet for UciCommand {
encoded_len(&self) -> usize4693     fn encoded_len(&self) -> usize {
4694         self.get_size()
4695     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>4696     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
4697         self.ucicontrolpacket.write_to(buf)
4698     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>4699     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
4700         unimplemented!("Rust legacy does not implement full packet trait")
4701     }
4702 }
4703 impl TryFrom<UciCommand> for Bytes {
4704     type Error = EncodeError;
try_from(packet: UciCommand) -> Result<Self, Self::Error>4705     fn try_from(packet: UciCommand) -> Result<Self, Self::Error> {
4706         packet.encode_to_bytes()
4707     }
4708 }
4709 impl TryFrom<UciCommand> for Vec<u8> {
4710     type Error = EncodeError;
try_from(packet: UciCommand) -> Result<Self, Self::Error>4711     fn try_from(packet: UciCommand) -> Result<Self, Self::Error> {
4712         packet.encode_to_vec()
4713     }
4714 }
4715 impl From<UciCommand> for UciControlPacket {
from(packet: UciCommand) -> UciControlPacket4716     fn from(packet: UciCommand) -> UciControlPacket {
4717         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
4718     }
4719 }
4720 impl TryFrom<UciControlPacket> for UciCommand {
4721     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<UciCommand, Self::Error>4722     fn try_from(packet: UciControlPacket) -> Result<UciCommand, Self::Error> {
4723         UciCommand::new(packet.ucicontrolpacket)
4724     }
4725 }
4726 impl UciCommand {
parse(bytes: &[u8]) -> Result<Self, DecodeError>4727     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
4728         let mut cell = Cell::new(bytes);
4729         let packet = Self::parse_inner(&mut cell)?;
4730         Ok(packet)
4731     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>4732     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
4733         let data = UciControlPacketData::parse_inner(&mut bytes)?;
4734         Self::new(data)
4735     }
specialize(&self) -> UciCommandChild4736     pub fn specialize(&self) -> UciCommandChild {
4737         match &self.ucicommand.child {
4738             UciCommandDataChild::CoreCommand(_) => {
4739                 UciCommandChild::CoreCommand(
4740                     CoreCommand::new(self.ucicontrolpacket.clone()).unwrap(),
4741                 )
4742             }
4743             UciCommandDataChild::SessionConfigCommand(_) => {
4744                 UciCommandChild::SessionConfigCommand(
4745                     SessionConfigCommand::new(self.ucicontrolpacket.clone()).unwrap(),
4746                 )
4747             }
4748             UciCommandDataChild::SessionControlCommand(_) => {
4749                 UciCommandChild::SessionControlCommand(
4750                     SessionControlCommand::new(self.ucicontrolpacket.clone()).unwrap(),
4751                 )
4752             }
4753             UciCommandDataChild::AndroidCommand(_) => {
4754                 UciCommandChild::AndroidCommand(
4755                     AndroidCommand::new(self.ucicontrolpacket.clone()).unwrap(),
4756                 )
4757             }
4758             UciCommandDataChild::TestCommand(_) => {
4759                 UciCommandChild::TestCommand(
4760                     TestCommand::new(self.ucicontrolpacket.clone()).unwrap(),
4761                 )
4762             }
4763             UciCommandDataChild::Payload(payload) => {
4764                 UciCommandChild::Payload(payload.clone())
4765             }
4766             UciCommandDataChild::None => UciCommandChild::None,
4767         }
4768     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>4769     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
4770         let ucicommand = match &ucicontrolpacket.child {
4771             UciControlPacketDataChild::UciCommand(value) => value.clone(),
4772             _ => {
4773                 return Err(DecodeError::InvalidChildError {
4774                     expected: stringify!(UciControlPacketDataChild::UciCommand),
4775                     actual: format!("{:?}", & ucicontrolpacket.child),
4776                 });
4777             }
4778         };
4779         Ok(Self {
4780             ucicontrolpacket,
4781             ucicommand,
4782         })
4783     }
get_group_id(&self) -> GroupId4784     pub fn get_group_id(&self) -> GroupId {
4785         self.ucicontrolpacket.group_id
4786     }
get_message_type(&self) -> MessageType4787     pub fn get_message_type(&self) -> MessageType {
4788         self.ucicontrolpacket.message_type
4789     }
get_opcode(&self) -> u84790     pub fn get_opcode(&self) -> u8 {
4791         self.ucicontrolpacket.opcode
4792     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>4793     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
4794         self.ucicommand.write_to(buffer)
4795     }
get_size(&self) -> usize4796     pub fn get_size(&self) -> usize {
4797         self.ucicontrolpacket.get_size()
4798     }
4799 }
4800 impl UciCommandBuilder {
build(self) -> UciCommand4801     pub fn build(self) -> UciCommand {
4802         let ucicommand = UciCommandData {
4803             child: match self.payload {
4804                 None => UciCommandDataChild::None,
4805                 Some(bytes) => UciCommandDataChild::Payload(bytes),
4806             },
4807         };
4808         let ucicontrolpacket = UciControlPacketData {
4809             group_id: self.group_id,
4810             message_type: MessageType::Command,
4811             opcode: self.opcode,
4812             child: UciControlPacketDataChild::UciCommand(ucicommand),
4813         };
4814         UciCommand::new(ucicontrolpacket).unwrap()
4815     }
4816 }
4817 impl From<UciCommandBuilder> for UciControlPacket {
from(builder: UciCommandBuilder) -> UciControlPacket4818     fn from(builder: UciCommandBuilder) -> UciControlPacket {
4819         builder.build().into()
4820     }
4821 }
4822 impl From<UciCommandBuilder> for UciCommand {
from(builder: UciCommandBuilder) -> UciCommand4823     fn from(builder: UciCommandBuilder) -> UciCommand {
4824         builder.build().into()
4825     }
4826 }
4827 #[derive(Debug, Clone, PartialEq, Eq)]
4828 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4829 pub enum UciResponseDataChild {
4830     CoreResponse(CoreResponseData),
4831     SessionConfigResponse(SessionConfigResponseData),
4832     SessionControlResponse(SessionControlResponseData),
4833     AndroidResponse(AndroidResponseData),
4834     TestResponse(TestResponseData),
4835     UciVendor_9_Response(UciVendor_9_ResponseData),
4836     UciVendor_A_Response(UciVendor_A_ResponseData),
4837     UciVendor_B_Response(UciVendor_B_ResponseData),
4838     UciVendor_E_Response(UciVendor_E_ResponseData),
4839     UciVendor_F_Response(UciVendor_F_ResponseData),
4840     Payload(Bytes),
4841     None,
4842 }
4843 impl UciResponseDataChild {
get_total_size(&self) -> usize4844     fn get_total_size(&self) -> usize {
4845         match self {
4846             UciResponseDataChild::CoreResponse(value) => value.get_total_size(),
4847             UciResponseDataChild::SessionConfigResponse(value) => value.get_total_size(),
4848             UciResponseDataChild::SessionControlResponse(value) => value.get_total_size(),
4849             UciResponseDataChild::AndroidResponse(value) => value.get_total_size(),
4850             UciResponseDataChild::TestResponse(value) => value.get_total_size(),
4851             UciResponseDataChild::UciVendor_9_Response(value) => value.get_total_size(),
4852             UciResponseDataChild::UciVendor_A_Response(value) => value.get_total_size(),
4853             UciResponseDataChild::UciVendor_B_Response(value) => value.get_total_size(),
4854             UciResponseDataChild::UciVendor_E_Response(value) => value.get_total_size(),
4855             UciResponseDataChild::UciVendor_F_Response(value) => value.get_total_size(),
4856             UciResponseDataChild::Payload(bytes) => bytes.len(),
4857             UciResponseDataChild::None => 0,
4858         }
4859     }
4860 }
4861 #[derive(Debug, Clone, PartialEq, Eq)]
4862 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4863 pub enum UciResponseChild {
4864     CoreResponse(CoreResponse),
4865     SessionConfigResponse(SessionConfigResponse),
4866     SessionControlResponse(SessionControlResponse),
4867     AndroidResponse(AndroidResponse),
4868     TestResponse(TestResponse),
4869     UciVendor_9_Response(UciVendor_9_Response),
4870     UciVendor_A_Response(UciVendor_A_Response),
4871     UciVendor_B_Response(UciVendor_B_Response),
4872     UciVendor_E_Response(UciVendor_E_Response),
4873     UciVendor_F_Response(UciVendor_F_Response),
4874     Payload(Bytes),
4875     None,
4876 }
4877 #[derive(Debug, Clone, PartialEq, Eq)]
4878 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4879 pub struct UciResponseData {
4880     child: UciResponseDataChild,
4881 }
4882 #[derive(Debug, Clone, PartialEq, Eq)]
4883 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4884 pub struct UciResponse {
4885     #[cfg_attr(feature = "serde", serde(flatten))]
4886     ucicontrolpacket: UciControlPacketData,
4887     #[cfg_attr(feature = "serde", serde(flatten))]
4888     uciresponse: UciResponseData,
4889 }
4890 #[derive(Debug)]
4891 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4892 pub struct UciResponseBuilder {
4893     pub group_id: GroupId,
4894     pub opcode: u8,
4895     pub payload: Option<Bytes>,
4896 }
4897 impl UciResponseData {
conforms(bytes: &[u8]) -> bool4898     fn conforms(bytes: &[u8]) -> bool {
4899         true
4900     }
parse(bytes: &[u8], group_id: GroupId, opcode: u8) -> Result<Self, DecodeError>4901     fn parse(bytes: &[u8], group_id: GroupId, opcode: u8) -> Result<Self, DecodeError> {
4902         let mut cell = Cell::new(bytes);
4903         let packet = Self::parse_inner(&mut cell, group_id, opcode)?;
4904         Ok(packet)
4905     }
parse_inner( mut bytes: &mut Cell<&[u8]>, group_id: GroupId, opcode: u8, ) -> Result<Self, DecodeError>4906     fn parse_inner(
4907         mut bytes: &mut Cell<&[u8]>,
4908         group_id: GroupId,
4909         opcode: u8,
4910     ) -> Result<Self, DecodeError> {
4911         let payload = bytes.get();
4912         bytes.get_mut().advance(payload.len());
4913         let child = match (group_id) {
4914             (GroupId::Core) if CoreResponseData::conforms(&payload) => {
4915                 let mut cell = Cell::new(payload);
4916                 let child_data = CoreResponseData::parse_inner(&mut cell, opcode)?;
4917                 UciResponseDataChild::CoreResponse(child_data)
4918             }
4919             (GroupId::SessionConfig) if SessionConfigResponseData::conforms(
4920                 &payload,
4921             ) => {
4922                 let mut cell = Cell::new(payload);
4923                 let child_data = SessionConfigResponseData::parse_inner(
4924                     &mut cell,
4925                     opcode,
4926                 )?;
4927                 UciResponseDataChild::SessionConfigResponse(child_data)
4928             }
4929             (GroupId::SessionControl) if SessionControlResponseData::conforms(
4930                 &payload,
4931             ) => {
4932                 let mut cell = Cell::new(payload);
4933                 let child_data = SessionControlResponseData::parse_inner(
4934                     &mut cell,
4935                     opcode,
4936                 )?;
4937                 UciResponseDataChild::SessionControlResponse(child_data)
4938             }
4939             (GroupId::VendorAndroid) if AndroidResponseData::conforms(&payload) => {
4940                 let mut cell = Cell::new(payload);
4941                 let child_data = AndroidResponseData::parse_inner(&mut cell, opcode)?;
4942                 UciResponseDataChild::AndroidResponse(child_data)
4943             }
4944             (GroupId::Test) if TestResponseData::conforms(&payload) => {
4945                 let mut cell = Cell::new(payload);
4946                 let child_data = TestResponseData::parse_inner(&mut cell, opcode)?;
4947                 UciResponseDataChild::TestResponse(child_data)
4948             }
4949             (GroupId::VendorReserved9) if UciVendor_9_ResponseData::conforms(
4950                 &payload,
4951             ) => {
4952                 let mut cell = Cell::new(payload);
4953                 let child_data = UciVendor_9_ResponseData::parse_inner(&mut cell)?;
4954                 UciResponseDataChild::UciVendor_9_Response(child_data)
4955             }
4956             (GroupId::VendorReservedA) if UciVendor_A_ResponseData::conforms(
4957                 &payload,
4958             ) => {
4959                 let mut cell = Cell::new(payload);
4960                 let child_data = UciVendor_A_ResponseData::parse_inner(&mut cell)?;
4961                 UciResponseDataChild::UciVendor_A_Response(child_data)
4962             }
4963             (GroupId::VendorReservedB) if UciVendor_B_ResponseData::conforms(
4964                 &payload,
4965             ) => {
4966                 let mut cell = Cell::new(payload);
4967                 let child_data = UciVendor_B_ResponseData::parse_inner(&mut cell)?;
4968                 UciResponseDataChild::UciVendor_B_Response(child_data)
4969             }
4970             (GroupId::VendorReservedE) if UciVendor_E_ResponseData::conforms(
4971                 &payload,
4972             ) => {
4973                 let mut cell = Cell::new(payload);
4974                 let child_data = UciVendor_E_ResponseData::parse_inner(&mut cell)?;
4975                 UciResponseDataChild::UciVendor_E_Response(child_data)
4976             }
4977             (GroupId::VendorReservedF) if UciVendor_F_ResponseData::conforms(
4978                 &payload,
4979             ) => {
4980                 let mut cell = Cell::new(payload);
4981                 let child_data = UciVendor_F_ResponseData::parse_inner(&mut cell)?;
4982                 UciResponseDataChild::UciVendor_F_Response(child_data)
4983             }
4984             _ if !payload.is_empty() => {
4985                 UciResponseDataChild::Payload(Bytes::copy_from_slice(payload))
4986             }
4987             _ => UciResponseDataChild::None,
4988         };
4989         Ok(Self { child })
4990     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>4991     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
4992         match &self.child {
4993             UciResponseDataChild::CoreResponse(child) => child.write_to(buffer)?,
4994             UciResponseDataChild::SessionConfigResponse(child) => child.write_to(buffer)?,
4995             UciResponseDataChild::SessionControlResponse(child) => {
4996                 child.write_to(buffer)?
4997             }
4998             UciResponseDataChild::AndroidResponse(child) => child.write_to(buffer)?,
4999             UciResponseDataChild::TestResponse(child) => child.write_to(buffer)?,
5000             UciResponseDataChild::UciVendor_9_Response(child) => child.write_to(buffer)?,
5001             UciResponseDataChild::UciVendor_A_Response(child) => child.write_to(buffer)?,
5002             UciResponseDataChild::UciVendor_B_Response(child) => child.write_to(buffer)?,
5003             UciResponseDataChild::UciVendor_E_Response(child) => child.write_to(buffer)?,
5004             UciResponseDataChild::UciVendor_F_Response(child) => child.write_to(buffer)?,
5005             UciResponseDataChild::Payload(payload) => buffer.put_slice(payload),
5006             UciResponseDataChild::None => {}
5007         }
5008         Ok(())
5009     }
get_total_size(&self) -> usize5010     fn get_total_size(&self) -> usize {
5011         self.get_size()
5012     }
get_size(&self) -> usize5013     fn get_size(&self) -> usize {
5014         self.child.get_total_size()
5015     }
5016 }
5017 impl Packet for UciResponse {
encoded_len(&self) -> usize5018     fn encoded_len(&self) -> usize {
5019         self.get_size()
5020     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>5021     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
5022         self.ucicontrolpacket.write_to(buf)
5023     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>5024     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
5025         unimplemented!("Rust legacy does not implement full packet trait")
5026     }
5027 }
5028 impl TryFrom<UciResponse> for Bytes {
5029     type Error = EncodeError;
try_from(packet: UciResponse) -> Result<Self, Self::Error>5030     fn try_from(packet: UciResponse) -> Result<Self, Self::Error> {
5031         packet.encode_to_bytes()
5032     }
5033 }
5034 impl TryFrom<UciResponse> for Vec<u8> {
5035     type Error = EncodeError;
try_from(packet: UciResponse) -> Result<Self, Self::Error>5036     fn try_from(packet: UciResponse) -> Result<Self, Self::Error> {
5037         packet.encode_to_vec()
5038     }
5039 }
5040 impl From<UciResponse> for UciControlPacket {
from(packet: UciResponse) -> UciControlPacket5041     fn from(packet: UciResponse) -> UciControlPacket {
5042         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
5043     }
5044 }
5045 impl TryFrom<UciControlPacket> for UciResponse {
5046     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<UciResponse, Self::Error>5047     fn try_from(packet: UciControlPacket) -> Result<UciResponse, Self::Error> {
5048         UciResponse::new(packet.ucicontrolpacket)
5049     }
5050 }
5051 impl UciResponse {
parse(bytes: &[u8]) -> Result<Self, DecodeError>5052     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
5053         let mut cell = Cell::new(bytes);
5054         let packet = Self::parse_inner(&mut cell)?;
5055         Ok(packet)
5056     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>5057     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
5058         let data = UciControlPacketData::parse_inner(&mut bytes)?;
5059         Self::new(data)
5060     }
specialize(&self) -> UciResponseChild5061     pub fn specialize(&self) -> UciResponseChild {
5062         match &self.uciresponse.child {
5063             UciResponseDataChild::CoreResponse(_) => {
5064                 UciResponseChild::CoreResponse(
5065                     CoreResponse::new(self.ucicontrolpacket.clone()).unwrap(),
5066                 )
5067             }
5068             UciResponseDataChild::SessionConfigResponse(_) => {
5069                 UciResponseChild::SessionConfigResponse(
5070                     SessionConfigResponse::new(self.ucicontrolpacket.clone()).unwrap(),
5071                 )
5072             }
5073             UciResponseDataChild::SessionControlResponse(_) => {
5074                 UciResponseChild::SessionControlResponse(
5075                     SessionControlResponse::new(self.ucicontrolpacket.clone()).unwrap(),
5076                 )
5077             }
5078             UciResponseDataChild::AndroidResponse(_) => {
5079                 UciResponseChild::AndroidResponse(
5080                     AndroidResponse::new(self.ucicontrolpacket.clone()).unwrap(),
5081                 )
5082             }
5083             UciResponseDataChild::TestResponse(_) => {
5084                 UciResponseChild::TestResponse(
5085                     TestResponse::new(self.ucicontrolpacket.clone()).unwrap(),
5086                 )
5087             }
5088             UciResponseDataChild::UciVendor_9_Response(_) => {
5089                 UciResponseChild::UciVendor_9_Response(
5090                     UciVendor_9_Response::new(self.ucicontrolpacket.clone()).unwrap(),
5091                 )
5092             }
5093             UciResponseDataChild::UciVendor_A_Response(_) => {
5094                 UciResponseChild::UciVendor_A_Response(
5095                     UciVendor_A_Response::new(self.ucicontrolpacket.clone()).unwrap(),
5096                 )
5097             }
5098             UciResponseDataChild::UciVendor_B_Response(_) => {
5099                 UciResponseChild::UciVendor_B_Response(
5100                     UciVendor_B_Response::new(self.ucicontrolpacket.clone()).unwrap(),
5101                 )
5102             }
5103             UciResponseDataChild::UciVendor_E_Response(_) => {
5104                 UciResponseChild::UciVendor_E_Response(
5105                     UciVendor_E_Response::new(self.ucicontrolpacket.clone()).unwrap(),
5106                 )
5107             }
5108             UciResponseDataChild::UciVendor_F_Response(_) => {
5109                 UciResponseChild::UciVendor_F_Response(
5110                     UciVendor_F_Response::new(self.ucicontrolpacket.clone()).unwrap(),
5111                 )
5112             }
5113             UciResponseDataChild::Payload(payload) => {
5114                 UciResponseChild::Payload(payload.clone())
5115             }
5116             UciResponseDataChild::None => UciResponseChild::None,
5117         }
5118     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>5119     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
5120         let uciresponse = match &ucicontrolpacket.child {
5121             UciControlPacketDataChild::UciResponse(value) => value.clone(),
5122             _ => {
5123                 return Err(DecodeError::InvalidChildError {
5124                     expected: stringify!(UciControlPacketDataChild::UciResponse),
5125                     actual: format!("{:?}", & ucicontrolpacket.child),
5126                 });
5127             }
5128         };
5129         Ok(Self {
5130             ucicontrolpacket,
5131             uciresponse,
5132         })
5133     }
get_group_id(&self) -> GroupId5134     pub fn get_group_id(&self) -> GroupId {
5135         self.ucicontrolpacket.group_id
5136     }
get_message_type(&self) -> MessageType5137     pub fn get_message_type(&self) -> MessageType {
5138         self.ucicontrolpacket.message_type
5139     }
get_opcode(&self) -> u85140     pub fn get_opcode(&self) -> u8 {
5141         self.ucicontrolpacket.opcode
5142     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>5143     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
5144         self.uciresponse.write_to(buffer)
5145     }
get_size(&self) -> usize5146     pub fn get_size(&self) -> usize {
5147         self.ucicontrolpacket.get_size()
5148     }
5149 }
5150 impl UciResponseBuilder {
build(self) -> UciResponse5151     pub fn build(self) -> UciResponse {
5152         let uciresponse = UciResponseData {
5153             child: match self.payload {
5154                 None => UciResponseDataChild::None,
5155                 Some(bytes) => UciResponseDataChild::Payload(bytes),
5156             },
5157         };
5158         let ucicontrolpacket = UciControlPacketData {
5159             group_id: self.group_id,
5160             message_type: MessageType::Response,
5161             opcode: self.opcode,
5162             child: UciControlPacketDataChild::UciResponse(uciresponse),
5163         };
5164         UciResponse::new(ucicontrolpacket).unwrap()
5165     }
5166 }
5167 impl From<UciResponseBuilder> for UciControlPacket {
from(builder: UciResponseBuilder) -> UciControlPacket5168     fn from(builder: UciResponseBuilder) -> UciControlPacket {
5169         builder.build().into()
5170     }
5171 }
5172 impl From<UciResponseBuilder> for UciResponse {
from(builder: UciResponseBuilder) -> UciResponse5173     fn from(builder: UciResponseBuilder) -> UciResponse {
5174         builder.build().into()
5175     }
5176 }
5177 #[derive(Debug, Clone, PartialEq, Eq)]
5178 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5179 pub enum UciNotificationDataChild {
5180     CoreNotification(CoreNotificationData),
5181     SessionConfigNotification(SessionConfigNotificationData),
5182     SessionControlNotification(SessionControlNotificationData),
5183     AndroidNotification(AndroidNotificationData),
5184     TestNotification(TestNotificationData),
5185     UciVendor_9_Notification(UciVendor_9_NotificationData),
5186     UciVendor_A_Notification(UciVendor_A_NotificationData),
5187     UciVendor_B_Notification(UciVendor_B_NotificationData),
5188     UciVendor_E_Notification(UciVendor_E_NotificationData),
5189     UciVendor_F_Notification(UciVendor_F_NotificationData),
5190     Payload(Bytes),
5191     None,
5192 }
5193 impl UciNotificationDataChild {
get_total_size(&self) -> usize5194     fn get_total_size(&self) -> usize {
5195         match self {
5196             UciNotificationDataChild::CoreNotification(value) => value.get_total_size(),
5197             UciNotificationDataChild::SessionConfigNotification(value) => {
5198                 value.get_total_size()
5199             }
5200             UciNotificationDataChild::SessionControlNotification(value) => {
5201                 value.get_total_size()
5202             }
5203             UciNotificationDataChild::AndroidNotification(value) => {
5204                 value.get_total_size()
5205             }
5206             UciNotificationDataChild::TestNotification(value) => value.get_total_size(),
5207             UciNotificationDataChild::UciVendor_9_Notification(value) => {
5208                 value.get_total_size()
5209             }
5210             UciNotificationDataChild::UciVendor_A_Notification(value) => {
5211                 value.get_total_size()
5212             }
5213             UciNotificationDataChild::UciVendor_B_Notification(value) => {
5214                 value.get_total_size()
5215             }
5216             UciNotificationDataChild::UciVendor_E_Notification(value) => {
5217                 value.get_total_size()
5218             }
5219             UciNotificationDataChild::UciVendor_F_Notification(value) => {
5220                 value.get_total_size()
5221             }
5222             UciNotificationDataChild::Payload(bytes) => bytes.len(),
5223             UciNotificationDataChild::None => 0,
5224         }
5225     }
5226 }
5227 #[derive(Debug, Clone, PartialEq, Eq)]
5228 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5229 pub enum UciNotificationChild {
5230     CoreNotification(CoreNotification),
5231     SessionConfigNotification(SessionConfigNotification),
5232     SessionControlNotification(SessionControlNotification),
5233     AndroidNotification(AndroidNotification),
5234     TestNotification(TestNotification),
5235     UciVendor_9_Notification(UciVendor_9_Notification),
5236     UciVendor_A_Notification(UciVendor_A_Notification),
5237     UciVendor_B_Notification(UciVendor_B_Notification),
5238     UciVendor_E_Notification(UciVendor_E_Notification),
5239     UciVendor_F_Notification(UciVendor_F_Notification),
5240     Payload(Bytes),
5241     None,
5242 }
5243 #[derive(Debug, Clone, PartialEq, Eq)]
5244 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5245 pub struct UciNotificationData {
5246     child: UciNotificationDataChild,
5247 }
5248 #[derive(Debug, Clone, PartialEq, Eq)]
5249 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5250 pub struct UciNotification {
5251     #[cfg_attr(feature = "serde", serde(flatten))]
5252     ucicontrolpacket: UciControlPacketData,
5253     #[cfg_attr(feature = "serde", serde(flatten))]
5254     ucinotification: UciNotificationData,
5255 }
5256 #[derive(Debug)]
5257 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5258 pub struct UciNotificationBuilder {
5259     pub group_id: GroupId,
5260     pub opcode: u8,
5261     pub payload: Option<Bytes>,
5262 }
5263 impl UciNotificationData {
conforms(bytes: &[u8]) -> bool5264     fn conforms(bytes: &[u8]) -> bool {
5265         true
5266     }
parse(bytes: &[u8], group_id: GroupId, opcode: u8) -> Result<Self, DecodeError>5267     fn parse(bytes: &[u8], group_id: GroupId, opcode: u8) -> Result<Self, DecodeError> {
5268         let mut cell = Cell::new(bytes);
5269         let packet = Self::parse_inner(&mut cell, group_id, opcode)?;
5270         Ok(packet)
5271     }
parse_inner( mut bytes: &mut Cell<&[u8]>, group_id: GroupId, opcode: u8, ) -> Result<Self, DecodeError>5272     fn parse_inner(
5273         mut bytes: &mut Cell<&[u8]>,
5274         group_id: GroupId,
5275         opcode: u8,
5276     ) -> Result<Self, DecodeError> {
5277         let payload = bytes.get();
5278         bytes.get_mut().advance(payload.len());
5279         let child = match (group_id) {
5280             (GroupId::Core) if CoreNotificationData::conforms(&payload) => {
5281                 let mut cell = Cell::new(payload);
5282                 let child_data = CoreNotificationData::parse_inner(&mut cell, opcode)?;
5283                 UciNotificationDataChild::CoreNotification(child_data)
5284             }
5285             (GroupId::SessionConfig) if SessionConfigNotificationData::conforms(
5286                 &payload,
5287             ) => {
5288                 let mut cell = Cell::new(payload);
5289                 let child_data = SessionConfigNotificationData::parse_inner(
5290                     &mut cell,
5291                     opcode,
5292                 )?;
5293                 UciNotificationDataChild::SessionConfigNotification(child_data)
5294             }
5295             (GroupId::SessionControl) if SessionControlNotificationData::conforms(
5296                 &payload,
5297             ) => {
5298                 let mut cell = Cell::new(payload);
5299                 let child_data = SessionControlNotificationData::parse_inner(
5300                     &mut cell,
5301                     opcode,
5302                 )?;
5303                 UciNotificationDataChild::SessionControlNotification(child_data)
5304             }
5305             (GroupId::VendorAndroid) if AndroidNotificationData::conforms(&payload) => {
5306                 let mut cell = Cell::new(payload);
5307                 let child_data = AndroidNotificationData::parse_inner(
5308                     &mut cell,
5309                     opcode,
5310                 )?;
5311                 UciNotificationDataChild::AndroidNotification(child_data)
5312             }
5313             (GroupId::Test) if TestNotificationData::conforms(&payload) => {
5314                 let mut cell = Cell::new(payload);
5315                 let child_data = TestNotificationData::parse_inner(&mut cell, opcode)?;
5316                 UciNotificationDataChild::TestNotification(child_data)
5317             }
5318             (GroupId::VendorReserved9) if UciVendor_9_NotificationData::conforms(
5319                 &payload,
5320             ) => {
5321                 let mut cell = Cell::new(payload);
5322                 let child_data = UciVendor_9_NotificationData::parse_inner(&mut cell)?;
5323                 UciNotificationDataChild::UciVendor_9_Notification(child_data)
5324             }
5325             (GroupId::VendorReservedA) if UciVendor_A_NotificationData::conforms(
5326                 &payload,
5327             ) => {
5328                 let mut cell = Cell::new(payload);
5329                 let child_data = UciVendor_A_NotificationData::parse_inner(&mut cell)?;
5330                 UciNotificationDataChild::UciVendor_A_Notification(child_data)
5331             }
5332             (GroupId::VendorReservedB) if UciVendor_B_NotificationData::conforms(
5333                 &payload,
5334             ) => {
5335                 let mut cell = Cell::new(payload);
5336                 let child_data = UciVendor_B_NotificationData::parse_inner(&mut cell)?;
5337                 UciNotificationDataChild::UciVendor_B_Notification(child_data)
5338             }
5339             (GroupId::VendorReservedE) if UciVendor_E_NotificationData::conforms(
5340                 &payload,
5341             ) => {
5342                 let mut cell = Cell::new(payload);
5343                 let child_data = UciVendor_E_NotificationData::parse_inner(&mut cell)?;
5344                 UciNotificationDataChild::UciVendor_E_Notification(child_data)
5345             }
5346             (GroupId::VendorReservedF) if UciVendor_F_NotificationData::conforms(
5347                 &payload,
5348             ) => {
5349                 let mut cell = Cell::new(payload);
5350                 let child_data = UciVendor_F_NotificationData::parse_inner(&mut cell)?;
5351                 UciNotificationDataChild::UciVendor_F_Notification(child_data)
5352             }
5353             _ if !payload.is_empty() => {
5354                 UciNotificationDataChild::Payload(Bytes::copy_from_slice(payload))
5355             }
5356             _ => UciNotificationDataChild::None,
5357         };
5358         Ok(Self { child })
5359     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>5360     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
5361         match &self.child {
5362             UciNotificationDataChild::CoreNotification(child) => child.write_to(buffer)?,
5363             UciNotificationDataChild::SessionConfigNotification(child) => {
5364                 child.write_to(buffer)?
5365             }
5366             UciNotificationDataChild::SessionControlNotification(child) => {
5367                 child.write_to(buffer)?
5368             }
5369             UciNotificationDataChild::AndroidNotification(child) => {
5370                 child.write_to(buffer)?
5371             }
5372             UciNotificationDataChild::TestNotification(child) => child.write_to(buffer)?,
5373             UciNotificationDataChild::UciVendor_9_Notification(child) => {
5374                 child.write_to(buffer)?
5375             }
5376             UciNotificationDataChild::UciVendor_A_Notification(child) => {
5377                 child.write_to(buffer)?
5378             }
5379             UciNotificationDataChild::UciVendor_B_Notification(child) => {
5380                 child.write_to(buffer)?
5381             }
5382             UciNotificationDataChild::UciVendor_E_Notification(child) => {
5383                 child.write_to(buffer)?
5384             }
5385             UciNotificationDataChild::UciVendor_F_Notification(child) => {
5386                 child.write_to(buffer)?
5387             }
5388             UciNotificationDataChild::Payload(payload) => buffer.put_slice(payload),
5389             UciNotificationDataChild::None => {}
5390         }
5391         Ok(())
5392     }
get_total_size(&self) -> usize5393     fn get_total_size(&self) -> usize {
5394         self.get_size()
5395     }
get_size(&self) -> usize5396     fn get_size(&self) -> usize {
5397         self.child.get_total_size()
5398     }
5399 }
5400 impl Packet for UciNotification {
encoded_len(&self) -> usize5401     fn encoded_len(&self) -> usize {
5402         self.get_size()
5403     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>5404     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
5405         self.ucicontrolpacket.write_to(buf)
5406     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>5407     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
5408         unimplemented!("Rust legacy does not implement full packet trait")
5409     }
5410 }
5411 impl TryFrom<UciNotification> for Bytes {
5412     type Error = EncodeError;
try_from(packet: UciNotification) -> Result<Self, Self::Error>5413     fn try_from(packet: UciNotification) -> Result<Self, Self::Error> {
5414         packet.encode_to_bytes()
5415     }
5416 }
5417 impl TryFrom<UciNotification> for Vec<u8> {
5418     type Error = EncodeError;
try_from(packet: UciNotification) -> Result<Self, Self::Error>5419     fn try_from(packet: UciNotification) -> Result<Self, Self::Error> {
5420         packet.encode_to_vec()
5421     }
5422 }
5423 impl From<UciNotification> for UciControlPacket {
from(packet: UciNotification) -> UciControlPacket5424     fn from(packet: UciNotification) -> UciControlPacket {
5425         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
5426     }
5427 }
5428 impl TryFrom<UciControlPacket> for UciNotification {
5429     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<UciNotification, Self::Error>5430     fn try_from(packet: UciControlPacket) -> Result<UciNotification, Self::Error> {
5431         UciNotification::new(packet.ucicontrolpacket)
5432     }
5433 }
5434 impl UciNotification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>5435     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
5436         let mut cell = Cell::new(bytes);
5437         let packet = Self::parse_inner(&mut cell)?;
5438         Ok(packet)
5439     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>5440     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
5441         let data = UciControlPacketData::parse_inner(&mut bytes)?;
5442         Self::new(data)
5443     }
specialize(&self) -> UciNotificationChild5444     pub fn specialize(&self) -> UciNotificationChild {
5445         match &self.ucinotification.child {
5446             UciNotificationDataChild::CoreNotification(_) => {
5447                 UciNotificationChild::CoreNotification(
5448                     CoreNotification::new(self.ucicontrolpacket.clone()).unwrap(),
5449                 )
5450             }
5451             UciNotificationDataChild::SessionConfigNotification(_) => {
5452                 UciNotificationChild::SessionConfigNotification(
5453                     SessionConfigNotification::new(self.ucicontrolpacket.clone())
5454                         .unwrap(),
5455                 )
5456             }
5457             UciNotificationDataChild::SessionControlNotification(_) => {
5458                 UciNotificationChild::SessionControlNotification(
5459                     SessionControlNotification::new(self.ucicontrolpacket.clone())
5460                         .unwrap(),
5461                 )
5462             }
5463             UciNotificationDataChild::AndroidNotification(_) => {
5464                 UciNotificationChild::AndroidNotification(
5465                     AndroidNotification::new(self.ucicontrolpacket.clone()).unwrap(),
5466                 )
5467             }
5468             UciNotificationDataChild::TestNotification(_) => {
5469                 UciNotificationChild::TestNotification(
5470                     TestNotification::new(self.ucicontrolpacket.clone()).unwrap(),
5471                 )
5472             }
5473             UciNotificationDataChild::UciVendor_9_Notification(_) => {
5474                 UciNotificationChild::UciVendor_9_Notification(
5475                     UciVendor_9_Notification::new(self.ucicontrolpacket.clone()).unwrap(),
5476                 )
5477             }
5478             UciNotificationDataChild::UciVendor_A_Notification(_) => {
5479                 UciNotificationChild::UciVendor_A_Notification(
5480                     UciVendor_A_Notification::new(self.ucicontrolpacket.clone()).unwrap(),
5481                 )
5482             }
5483             UciNotificationDataChild::UciVendor_B_Notification(_) => {
5484                 UciNotificationChild::UciVendor_B_Notification(
5485                     UciVendor_B_Notification::new(self.ucicontrolpacket.clone()).unwrap(),
5486                 )
5487             }
5488             UciNotificationDataChild::UciVendor_E_Notification(_) => {
5489                 UciNotificationChild::UciVendor_E_Notification(
5490                     UciVendor_E_Notification::new(self.ucicontrolpacket.clone()).unwrap(),
5491                 )
5492             }
5493             UciNotificationDataChild::UciVendor_F_Notification(_) => {
5494                 UciNotificationChild::UciVendor_F_Notification(
5495                     UciVendor_F_Notification::new(self.ucicontrolpacket.clone()).unwrap(),
5496                 )
5497             }
5498             UciNotificationDataChild::Payload(payload) => {
5499                 UciNotificationChild::Payload(payload.clone())
5500             }
5501             UciNotificationDataChild::None => UciNotificationChild::None,
5502         }
5503     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>5504     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
5505         let ucinotification = match &ucicontrolpacket.child {
5506             UciControlPacketDataChild::UciNotification(value) => value.clone(),
5507             _ => {
5508                 return Err(DecodeError::InvalidChildError {
5509                     expected: stringify!(UciControlPacketDataChild::UciNotification),
5510                     actual: format!("{:?}", & ucicontrolpacket.child),
5511                 });
5512             }
5513         };
5514         Ok(Self {
5515             ucicontrolpacket,
5516             ucinotification,
5517         })
5518     }
get_group_id(&self) -> GroupId5519     pub fn get_group_id(&self) -> GroupId {
5520         self.ucicontrolpacket.group_id
5521     }
get_message_type(&self) -> MessageType5522     pub fn get_message_type(&self) -> MessageType {
5523         self.ucicontrolpacket.message_type
5524     }
get_opcode(&self) -> u85525     pub fn get_opcode(&self) -> u8 {
5526         self.ucicontrolpacket.opcode
5527     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>5528     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
5529         self.ucinotification.write_to(buffer)
5530     }
get_size(&self) -> usize5531     pub fn get_size(&self) -> usize {
5532         self.ucicontrolpacket.get_size()
5533     }
5534 }
5535 impl UciNotificationBuilder {
build(self) -> UciNotification5536     pub fn build(self) -> UciNotification {
5537         let ucinotification = UciNotificationData {
5538             child: match self.payload {
5539                 None => UciNotificationDataChild::None,
5540                 Some(bytes) => UciNotificationDataChild::Payload(bytes),
5541             },
5542         };
5543         let ucicontrolpacket = UciControlPacketData {
5544             group_id: self.group_id,
5545             message_type: MessageType::Notification,
5546             opcode: self.opcode,
5547             child: UciControlPacketDataChild::UciNotification(ucinotification),
5548         };
5549         UciNotification::new(ucicontrolpacket).unwrap()
5550     }
5551 }
5552 impl From<UciNotificationBuilder> for UciControlPacket {
from(builder: UciNotificationBuilder) -> UciControlPacket5553     fn from(builder: UciNotificationBuilder) -> UciControlPacket {
5554         builder.build().into()
5555     }
5556 }
5557 impl From<UciNotificationBuilder> for UciNotification {
from(builder: UciNotificationBuilder) -> UciNotification5558     fn from(builder: UciNotificationBuilder) -> UciNotification {
5559         builder.build().into()
5560     }
5561 }
5562 #[derive(Debug, Clone, PartialEq, Eq)]
5563 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5564 pub enum CoreCommandDataChild {
5565     DeviceResetCmd(DeviceResetCmdData),
5566     GetDeviceInfoCmd(GetDeviceInfoCmdData),
5567     GetCapsInfoCmd(GetCapsInfoCmdData),
5568     SetConfigCmd(SetConfigCmdData),
5569     GetConfigCmd(GetConfigCmdData),
5570     CoreQueryTimeStampCmd(CoreQueryTimeStampCmdData),
5571     Payload(Bytes),
5572     None,
5573 }
5574 impl CoreCommandDataChild {
get_total_size(&self) -> usize5575     fn get_total_size(&self) -> usize {
5576         match self {
5577             CoreCommandDataChild::DeviceResetCmd(value) => value.get_total_size(),
5578             CoreCommandDataChild::GetDeviceInfoCmd(value) => value.get_total_size(),
5579             CoreCommandDataChild::GetCapsInfoCmd(value) => value.get_total_size(),
5580             CoreCommandDataChild::SetConfigCmd(value) => value.get_total_size(),
5581             CoreCommandDataChild::GetConfigCmd(value) => value.get_total_size(),
5582             CoreCommandDataChild::CoreQueryTimeStampCmd(value) => value.get_total_size(),
5583             CoreCommandDataChild::Payload(bytes) => bytes.len(),
5584             CoreCommandDataChild::None => 0,
5585         }
5586     }
5587 }
5588 #[derive(Debug, Clone, PartialEq, Eq)]
5589 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5590 pub enum CoreCommandChild {
5591     DeviceResetCmd(DeviceResetCmd),
5592     GetDeviceInfoCmd(GetDeviceInfoCmd),
5593     GetCapsInfoCmd(GetCapsInfoCmd),
5594     SetConfigCmd(SetConfigCmd),
5595     GetConfigCmd(GetConfigCmd),
5596     CoreQueryTimeStampCmd(CoreQueryTimeStampCmd),
5597     Payload(Bytes),
5598     None,
5599 }
5600 #[derive(Debug, Clone, PartialEq, Eq)]
5601 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5602 pub struct CoreCommandData {
5603     child: CoreCommandDataChild,
5604 }
5605 #[derive(Debug, Clone, PartialEq, Eq)]
5606 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5607 pub struct CoreCommand {
5608     #[cfg_attr(feature = "serde", serde(flatten))]
5609     ucicontrolpacket: UciControlPacketData,
5610     #[cfg_attr(feature = "serde", serde(flatten))]
5611     ucicommand: UciCommandData,
5612     #[cfg_attr(feature = "serde", serde(flatten))]
5613     corecommand: CoreCommandData,
5614 }
5615 #[derive(Debug)]
5616 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5617 pub struct CoreCommandBuilder {
5618     pub opcode: u8,
5619     pub payload: Option<Bytes>,
5620 }
5621 impl CoreCommandData {
conforms(bytes: &[u8]) -> bool5622     fn conforms(bytes: &[u8]) -> bool {
5623         true
5624     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>5625     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
5626         let mut cell = Cell::new(bytes);
5627         let packet = Self::parse_inner(&mut cell, opcode)?;
5628         Ok(packet)
5629     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>5630     fn parse_inner(
5631         mut bytes: &mut Cell<&[u8]>,
5632         opcode: u8,
5633     ) -> Result<Self, DecodeError> {
5634         let payload = bytes.get();
5635         bytes.get_mut().advance(payload.len());
5636         let child = match (opcode) {
5637             (0) if DeviceResetCmdData::conforms(&payload) => {
5638                 let mut cell = Cell::new(payload);
5639                 let child_data = DeviceResetCmdData::parse_inner(&mut cell)?;
5640                 CoreCommandDataChild::DeviceResetCmd(child_data)
5641             }
5642             (2) if GetDeviceInfoCmdData::conforms(&payload) => {
5643                 let mut cell = Cell::new(payload);
5644                 let child_data = GetDeviceInfoCmdData::parse_inner(&mut cell)?;
5645                 CoreCommandDataChild::GetDeviceInfoCmd(child_data)
5646             }
5647             (3) if GetCapsInfoCmdData::conforms(&payload) => {
5648                 let mut cell = Cell::new(payload);
5649                 let child_data = GetCapsInfoCmdData::parse_inner(&mut cell)?;
5650                 CoreCommandDataChild::GetCapsInfoCmd(child_data)
5651             }
5652             (4) if SetConfigCmdData::conforms(&payload) => {
5653                 let mut cell = Cell::new(payload);
5654                 let child_data = SetConfigCmdData::parse_inner(&mut cell)?;
5655                 CoreCommandDataChild::SetConfigCmd(child_data)
5656             }
5657             (5) if GetConfigCmdData::conforms(&payload) => {
5658                 let mut cell = Cell::new(payload);
5659                 let child_data = GetConfigCmdData::parse_inner(&mut cell)?;
5660                 CoreCommandDataChild::GetConfigCmd(child_data)
5661             }
5662             (8) if CoreQueryTimeStampCmdData::conforms(&payload) => {
5663                 let mut cell = Cell::new(payload);
5664                 let child_data = CoreQueryTimeStampCmdData::parse_inner(&mut cell)?;
5665                 CoreCommandDataChild::CoreQueryTimeStampCmd(child_data)
5666             }
5667             _ if !payload.is_empty() => {
5668                 CoreCommandDataChild::Payload(Bytes::copy_from_slice(payload))
5669             }
5670             _ => CoreCommandDataChild::None,
5671         };
5672         Ok(Self { child })
5673     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>5674     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
5675         match &self.child {
5676             CoreCommandDataChild::DeviceResetCmd(child) => child.write_to(buffer)?,
5677             CoreCommandDataChild::GetDeviceInfoCmd(child) => child.write_to(buffer)?,
5678             CoreCommandDataChild::GetCapsInfoCmd(child) => child.write_to(buffer)?,
5679             CoreCommandDataChild::SetConfigCmd(child) => child.write_to(buffer)?,
5680             CoreCommandDataChild::GetConfigCmd(child) => child.write_to(buffer)?,
5681             CoreCommandDataChild::CoreQueryTimeStampCmd(child) => child.write_to(buffer)?,
5682             CoreCommandDataChild::Payload(payload) => buffer.put_slice(payload),
5683             CoreCommandDataChild::None => {}
5684         }
5685         Ok(())
5686     }
get_total_size(&self) -> usize5687     fn get_total_size(&self) -> usize {
5688         self.get_size()
5689     }
get_size(&self) -> usize5690     fn get_size(&self) -> usize {
5691         self.child.get_total_size()
5692     }
5693 }
5694 impl Packet for CoreCommand {
encoded_len(&self) -> usize5695     fn encoded_len(&self) -> usize {
5696         self.get_size()
5697     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>5698     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
5699         self.ucicontrolpacket.write_to(buf)
5700     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>5701     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
5702         unimplemented!("Rust legacy does not implement full packet trait")
5703     }
5704 }
5705 impl TryFrom<CoreCommand> for Bytes {
5706     type Error = EncodeError;
try_from(packet: CoreCommand) -> Result<Self, Self::Error>5707     fn try_from(packet: CoreCommand) -> Result<Self, Self::Error> {
5708         packet.encode_to_bytes()
5709     }
5710 }
5711 impl TryFrom<CoreCommand> for Vec<u8> {
5712     type Error = EncodeError;
try_from(packet: CoreCommand) -> Result<Self, Self::Error>5713     fn try_from(packet: CoreCommand) -> Result<Self, Self::Error> {
5714         packet.encode_to_vec()
5715     }
5716 }
5717 impl From<CoreCommand> for UciControlPacket {
from(packet: CoreCommand) -> UciControlPacket5718     fn from(packet: CoreCommand) -> UciControlPacket {
5719         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
5720     }
5721 }
5722 impl From<CoreCommand> for UciCommand {
from(packet: CoreCommand) -> UciCommand5723     fn from(packet: CoreCommand) -> UciCommand {
5724         UciCommand::new(packet.ucicontrolpacket).unwrap()
5725     }
5726 }
5727 impl TryFrom<UciControlPacket> for CoreCommand {
5728     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<CoreCommand, Self::Error>5729     fn try_from(packet: UciControlPacket) -> Result<CoreCommand, Self::Error> {
5730         CoreCommand::new(packet.ucicontrolpacket)
5731     }
5732 }
5733 impl CoreCommand {
parse(bytes: &[u8]) -> Result<Self, DecodeError>5734     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
5735         let mut cell = Cell::new(bytes);
5736         let packet = Self::parse_inner(&mut cell)?;
5737         Ok(packet)
5738     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>5739     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
5740         let data = UciControlPacketData::parse_inner(&mut bytes)?;
5741         Self::new(data)
5742     }
specialize(&self) -> CoreCommandChild5743     pub fn specialize(&self) -> CoreCommandChild {
5744         match &self.corecommand.child {
5745             CoreCommandDataChild::DeviceResetCmd(_) => {
5746                 CoreCommandChild::DeviceResetCmd(
5747                     DeviceResetCmd::new(self.ucicontrolpacket.clone()).unwrap(),
5748                 )
5749             }
5750             CoreCommandDataChild::GetDeviceInfoCmd(_) => {
5751                 CoreCommandChild::GetDeviceInfoCmd(
5752                     GetDeviceInfoCmd::new(self.ucicontrolpacket.clone()).unwrap(),
5753                 )
5754             }
5755             CoreCommandDataChild::GetCapsInfoCmd(_) => {
5756                 CoreCommandChild::GetCapsInfoCmd(
5757                     GetCapsInfoCmd::new(self.ucicontrolpacket.clone()).unwrap(),
5758                 )
5759             }
5760             CoreCommandDataChild::SetConfigCmd(_) => {
5761                 CoreCommandChild::SetConfigCmd(
5762                     SetConfigCmd::new(self.ucicontrolpacket.clone()).unwrap(),
5763                 )
5764             }
5765             CoreCommandDataChild::GetConfigCmd(_) => {
5766                 CoreCommandChild::GetConfigCmd(
5767                     GetConfigCmd::new(self.ucicontrolpacket.clone()).unwrap(),
5768                 )
5769             }
5770             CoreCommandDataChild::CoreQueryTimeStampCmd(_) => {
5771                 CoreCommandChild::CoreQueryTimeStampCmd(
5772                     CoreQueryTimeStampCmd::new(self.ucicontrolpacket.clone()).unwrap(),
5773                 )
5774             }
5775             CoreCommandDataChild::Payload(payload) => {
5776                 CoreCommandChild::Payload(payload.clone())
5777             }
5778             CoreCommandDataChild::None => CoreCommandChild::None,
5779         }
5780     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>5781     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
5782         let ucicommand = match &ucicontrolpacket.child {
5783             UciControlPacketDataChild::UciCommand(value) => value.clone(),
5784             _ => {
5785                 return Err(DecodeError::InvalidChildError {
5786                     expected: stringify!(UciControlPacketDataChild::UciCommand),
5787                     actual: format!("{:?}", & ucicontrolpacket.child),
5788                 });
5789             }
5790         };
5791         let corecommand = match &ucicommand.child {
5792             UciCommandDataChild::CoreCommand(value) => value.clone(),
5793             _ => {
5794                 return Err(DecodeError::InvalidChildError {
5795                     expected: stringify!(UciCommandDataChild::CoreCommand),
5796                     actual: format!("{:?}", & ucicommand.child),
5797                 });
5798             }
5799         };
5800         Ok(Self {
5801             ucicontrolpacket,
5802             ucicommand,
5803             corecommand,
5804         })
5805     }
get_group_id(&self) -> GroupId5806     pub fn get_group_id(&self) -> GroupId {
5807         self.ucicontrolpacket.group_id
5808     }
get_message_type(&self) -> MessageType5809     pub fn get_message_type(&self) -> MessageType {
5810         self.ucicontrolpacket.message_type
5811     }
get_opcode(&self) -> u85812     pub fn get_opcode(&self) -> u8 {
5813         self.ucicontrolpacket.opcode
5814     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>5815     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
5816         self.corecommand.write_to(buffer)
5817     }
get_size(&self) -> usize5818     pub fn get_size(&self) -> usize {
5819         self.ucicontrolpacket.get_size()
5820     }
5821 }
5822 impl CoreCommandBuilder {
build(self) -> CoreCommand5823     pub fn build(self) -> CoreCommand {
5824         let corecommand = CoreCommandData {
5825             child: match self.payload {
5826                 None => CoreCommandDataChild::None,
5827                 Some(bytes) => CoreCommandDataChild::Payload(bytes),
5828             },
5829         };
5830         let ucicommand = UciCommandData {
5831             child: UciCommandDataChild::CoreCommand(corecommand),
5832         };
5833         let ucicontrolpacket = UciControlPacketData {
5834             group_id: GroupId::Core,
5835             message_type: MessageType::Command,
5836             opcode: self.opcode,
5837             child: UciControlPacketDataChild::UciCommand(ucicommand),
5838         };
5839         CoreCommand::new(ucicontrolpacket).unwrap()
5840     }
5841 }
5842 impl From<CoreCommandBuilder> for UciControlPacket {
from(builder: CoreCommandBuilder) -> UciControlPacket5843     fn from(builder: CoreCommandBuilder) -> UciControlPacket {
5844         builder.build().into()
5845     }
5846 }
5847 impl From<CoreCommandBuilder> for UciCommand {
from(builder: CoreCommandBuilder) -> UciCommand5848     fn from(builder: CoreCommandBuilder) -> UciCommand {
5849         builder.build().into()
5850     }
5851 }
5852 impl From<CoreCommandBuilder> for CoreCommand {
from(builder: CoreCommandBuilder) -> CoreCommand5853     fn from(builder: CoreCommandBuilder) -> CoreCommand {
5854         builder.build().into()
5855     }
5856 }
5857 #[derive(Debug, Clone, PartialEq, Eq)]
5858 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5859 pub enum CoreResponseDataChild {
5860     DeviceResetRsp(DeviceResetRspData),
5861     GetDeviceInfoRsp(GetDeviceInfoRspData),
5862     GetCapsInfoRsp(GetCapsInfoRspData),
5863     SetConfigRsp(SetConfigRspData),
5864     GetConfigRsp(GetConfigRspData),
5865     CoreQueryTimeStampRsp(CoreQueryTimeStampRspData),
5866     Payload(Bytes),
5867     None,
5868 }
5869 impl CoreResponseDataChild {
get_total_size(&self) -> usize5870     fn get_total_size(&self) -> usize {
5871         match self {
5872             CoreResponseDataChild::DeviceResetRsp(value) => value.get_total_size(),
5873             CoreResponseDataChild::GetDeviceInfoRsp(value) => value.get_total_size(),
5874             CoreResponseDataChild::GetCapsInfoRsp(value) => value.get_total_size(),
5875             CoreResponseDataChild::SetConfigRsp(value) => value.get_total_size(),
5876             CoreResponseDataChild::GetConfigRsp(value) => value.get_total_size(),
5877             CoreResponseDataChild::CoreQueryTimeStampRsp(value) => value.get_total_size(),
5878             CoreResponseDataChild::Payload(bytes) => bytes.len(),
5879             CoreResponseDataChild::None => 0,
5880         }
5881     }
5882 }
5883 #[derive(Debug, Clone, PartialEq, Eq)]
5884 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5885 pub enum CoreResponseChild {
5886     DeviceResetRsp(DeviceResetRsp),
5887     GetDeviceInfoRsp(GetDeviceInfoRsp),
5888     GetCapsInfoRsp(GetCapsInfoRsp),
5889     SetConfigRsp(SetConfigRsp),
5890     GetConfigRsp(GetConfigRsp),
5891     CoreQueryTimeStampRsp(CoreQueryTimeStampRsp),
5892     Payload(Bytes),
5893     None,
5894 }
5895 #[derive(Debug, Clone, PartialEq, Eq)]
5896 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5897 pub struct CoreResponseData {
5898     child: CoreResponseDataChild,
5899 }
5900 #[derive(Debug, Clone, PartialEq, Eq)]
5901 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5902 pub struct CoreResponse {
5903     #[cfg_attr(feature = "serde", serde(flatten))]
5904     ucicontrolpacket: UciControlPacketData,
5905     #[cfg_attr(feature = "serde", serde(flatten))]
5906     uciresponse: UciResponseData,
5907     #[cfg_attr(feature = "serde", serde(flatten))]
5908     coreresponse: CoreResponseData,
5909 }
5910 #[derive(Debug)]
5911 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5912 pub struct CoreResponseBuilder {
5913     pub opcode: u8,
5914     pub payload: Option<Bytes>,
5915 }
5916 impl CoreResponseData {
conforms(bytes: &[u8]) -> bool5917     fn conforms(bytes: &[u8]) -> bool {
5918         true
5919     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>5920     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
5921         let mut cell = Cell::new(bytes);
5922         let packet = Self::parse_inner(&mut cell, opcode)?;
5923         Ok(packet)
5924     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>5925     fn parse_inner(
5926         mut bytes: &mut Cell<&[u8]>,
5927         opcode: u8,
5928     ) -> Result<Self, DecodeError> {
5929         let payload = bytes.get();
5930         bytes.get_mut().advance(payload.len());
5931         let child = match (opcode) {
5932             (0) if DeviceResetRspData::conforms(&payload) => {
5933                 let mut cell = Cell::new(payload);
5934                 let child_data = DeviceResetRspData::parse_inner(&mut cell)?;
5935                 CoreResponseDataChild::DeviceResetRsp(child_data)
5936             }
5937             (2) if GetDeviceInfoRspData::conforms(&payload) => {
5938                 let mut cell = Cell::new(payload);
5939                 let child_data = GetDeviceInfoRspData::parse_inner(&mut cell)?;
5940                 CoreResponseDataChild::GetDeviceInfoRsp(child_data)
5941             }
5942             (3) if GetCapsInfoRspData::conforms(&payload) => {
5943                 let mut cell = Cell::new(payload);
5944                 let child_data = GetCapsInfoRspData::parse_inner(&mut cell)?;
5945                 CoreResponseDataChild::GetCapsInfoRsp(child_data)
5946             }
5947             (4) if SetConfigRspData::conforms(&payload) => {
5948                 let mut cell = Cell::new(payload);
5949                 let child_data = SetConfigRspData::parse_inner(&mut cell)?;
5950                 CoreResponseDataChild::SetConfigRsp(child_data)
5951             }
5952             (5) if GetConfigRspData::conforms(&payload) => {
5953                 let mut cell = Cell::new(payload);
5954                 let child_data = GetConfigRspData::parse_inner(&mut cell)?;
5955                 CoreResponseDataChild::GetConfigRsp(child_data)
5956             }
5957             (8) if CoreQueryTimeStampRspData::conforms(&payload) => {
5958                 let mut cell = Cell::new(payload);
5959                 let child_data = CoreQueryTimeStampRspData::parse_inner(&mut cell)?;
5960                 CoreResponseDataChild::CoreQueryTimeStampRsp(child_data)
5961             }
5962             _ if !payload.is_empty() => {
5963                 CoreResponseDataChild::Payload(Bytes::copy_from_slice(payload))
5964             }
5965             _ => CoreResponseDataChild::None,
5966         };
5967         Ok(Self { child })
5968     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>5969     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
5970         match &self.child {
5971             CoreResponseDataChild::DeviceResetRsp(child) => child.write_to(buffer)?,
5972             CoreResponseDataChild::GetDeviceInfoRsp(child) => child.write_to(buffer)?,
5973             CoreResponseDataChild::GetCapsInfoRsp(child) => child.write_to(buffer)?,
5974             CoreResponseDataChild::SetConfigRsp(child) => child.write_to(buffer)?,
5975             CoreResponseDataChild::GetConfigRsp(child) => child.write_to(buffer)?,
5976             CoreResponseDataChild::CoreQueryTimeStampRsp(child) => {
5977                 child.write_to(buffer)?
5978             }
5979             CoreResponseDataChild::Payload(payload) => buffer.put_slice(payload),
5980             CoreResponseDataChild::None => {}
5981         }
5982         Ok(())
5983     }
get_total_size(&self) -> usize5984     fn get_total_size(&self) -> usize {
5985         self.get_size()
5986     }
get_size(&self) -> usize5987     fn get_size(&self) -> usize {
5988         self.child.get_total_size()
5989     }
5990 }
5991 impl Packet for CoreResponse {
encoded_len(&self) -> usize5992     fn encoded_len(&self) -> usize {
5993         self.get_size()
5994     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>5995     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
5996         self.ucicontrolpacket.write_to(buf)
5997     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>5998     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
5999         unimplemented!("Rust legacy does not implement full packet trait")
6000     }
6001 }
6002 impl TryFrom<CoreResponse> for Bytes {
6003     type Error = EncodeError;
try_from(packet: CoreResponse) -> Result<Self, Self::Error>6004     fn try_from(packet: CoreResponse) -> Result<Self, Self::Error> {
6005         packet.encode_to_bytes()
6006     }
6007 }
6008 impl TryFrom<CoreResponse> for Vec<u8> {
6009     type Error = EncodeError;
try_from(packet: CoreResponse) -> Result<Self, Self::Error>6010     fn try_from(packet: CoreResponse) -> Result<Self, Self::Error> {
6011         packet.encode_to_vec()
6012     }
6013 }
6014 impl From<CoreResponse> for UciControlPacket {
from(packet: CoreResponse) -> UciControlPacket6015     fn from(packet: CoreResponse) -> UciControlPacket {
6016         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
6017     }
6018 }
6019 impl From<CoreResponse> for UciResponse {
from(packet: CoreResponse) -> UciResponse6020     fn from(packet: CoreResponse) -> UciResponse {
6021         UciResponse::new(packet.ucicontrolpacket).unwrap()
6022     }
6023 }
6024 impl TryFrom<UciControlPacket> for CoreResponse {
6025     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<CoreResponse, Self::Error>6026     fn try_from(packet: UciControlPacket) -> Result<CoreResponse, Self::Error> {
6027         CoreResponse::new(packet.ucicontrolpacket)
6028     }
6029 }
6030 impl CoreResponse {
parse(bytes: &[u8]) -> Result<Self, DecodeError>6031     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
6032         let mut cell = Cell::new(bytes);
6033         let packet = Self::parse_inner(&mut cell)?;
6034         Ok(packet)
6035     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>6036     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
6037         let data = UciControlPacketData::parse_inner(&mut bytes)?;
6038         Self::new(data)
6039     }
specialize(&self) -> CoreResponseChild6040     pub fn specialize(&self) -> CoreResponseChild {
6041         match &self.coreresponse.child {
6042             CoreResponseDataChild::DeviceResetRsp(_) => {
6043                 CoreResponseChild::DeviceResetRsp(
6044                     DeviceResetRsp::new(self.ucicontrolpacket.clone()).unwrap(),
6045                 )
6046             }
6047             CoreResponseDataChild::GetDeviceInfoRsp(_) => {
6048                 CoreResponseChild::GetDeviceInfoRsp(
6049                     GetDeviceInfoRsp::new(self.ucicontrolpacket.clone()).unwrap(),
6050                 )
6051             }
6052             CoreResponseDataChild::GetCapsInfoRsp(_) => {
6053                 CoreResponseChild::GetCapsInfoRsp(
6054                     GetCapsInfoRsp::new(self.ucicontrolpacket.clone()).unwrap(),
6055                 )
6056             }
6057             CoreResponseDataChild::SetConfigRsp(_) => {
6058                 CoreResponseChild::SetConfigRsp(
6059                     SetConfigRsp::new(self.ucicontrolpacket.clone()).unwrap(),
6060                 )
6061             }
6062             CoreResponseDataChild::GetConfigRsp(_) => {
6063                 CoreResponseChild::GetConfigRsp(
6064                     GetConfigRsp::new(self.ucicontrolpacket.clone()).unwrap(),
6065                 )
6066             }
6067             CoreResponseDataChild::CoreQueryTimeStampRsp(_) => {
6068                 CoreResponseChild::CoreQueryTimeStampRsp(
6069                     CoreQueryTimeStampRsp::new(self.ucicontrolpacket.clone()).unwrap(),
6070                 )
6071             }
6072             CoreResponseDataChild::Payload(payload) => {
6073                 CoreResponseChild::Payload(payload.clone())
6074             }
6075             CoreResponseDataChild::None => CoreResponseChild::None,
6076         }
6077     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>6078     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
6079         let uciresponse = match &ucicontrolpacket.child {
6080             UciControlPacketDataChild::UciResponse(value) => value.clone(),
6081             _ => {
6082                 return Err(DecodeError::InvalidChildError {
6083                     expected: stringify!(UciControlPacketDataChild::UciResponse),
6084                     actual: format!("{:?}", & ucicontrolpacket.child),
6085                 });
6086             }
6087         };
6088         let coreresponse = match &uciresponse.child {
6089             UciResponseDataChild::CoreResponse(value) => value.clone(),
6090             _ => {
6091                 return Err(DecodeError::InvalidChildError {
6092                     expected: stringify!(UciResponseDataChild::CoreResponse),
6093                     actual: format!("{:?}", & uciresponse.child),
6094                 });
6095             }
6096         };
6097         Ok(Self {
6098             ucicontrolpacket,
6099             uciresponse,
6100             coreresponse,
6101         })
6102     }
get_group_id(&self) -> GroupId6103     pub fn get_group_id(&self) -> GroupId {
6104         self.ucicontrolpacket.group_id
6105     }
get_message_type(&self) -> MessageType6106     pub fn get_message_type(&self) -> MessageType {
6107         self.ucicontrolpacket.message_type
6108     }
get_opcode(&self) -> u86109     pub fn get_opcode(&self) -> u8 {
6110         self.ucicontrolpacket.opcode
6111     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>6112     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
6113         self.coreresponse.write_to(buffer)
6114     }
get_size(&self) -> usize6115     pub fn get_size(&self) -> usize {
6116         self.ucicontrolpacket.get_size()
6117     }
6118 }
6119 impl CoreResponseBuilder {
build(self) -> CoreResponse6120     pub fn build(self) -> CoreResponse {
6121         let coreresponse = CoreResponseData {
6122             child: match self.payload {
6123                 None => CoreResponseDataChild::None,
6124                 Some(bytes) => CoreResponseDataChild::Payload(bytes),
6125             },
6126         };
6127         let uciresponse = UciResponseData {
6128             child: UciResponseDataChild::CoreResponse(coreresponse),
6129         };
6130         let ucicontrolpacket = UciControlPacketData {
6131             group_id: GroupId::Core,
6132             message_type: MessageType::Response,
6133             opcode: self.opcode,
6134             child: UciControlPacketDataChild::UciResponse(uciresponse),
6135         };
6136         CoreResponse::new(ucicontrolpacket).unwrap()
6137     }
6138 }
6139 impl From<CoreResponseBuilder> for UciControlPacket {
from(builder: CoreResponseBuilder) -> UciControlPacket6140     fn from(builder: CoreResponseBuilder) -> UciControlPacket {
6141         builder.build().into()
6142     }
6143 }
6144 impl From<CoreResponseBuilder> for UciResponse {
from(builder: CoreResponseBuilder) -> UciResponse6145     fn from(builder: CoreResponseBuilder) -> UciResponse {
6146         builder.build().into()
6147     }
6148 }
6149 impl From<CoreResponseBuilder> for CoreResponse {
from(builder: CoreResponseBuilder) -> CoreResponse6150     fn from(builder: CoreResponseBuilder) -> CoreResponse {
6151         builder.build().into()
6152     }
6153 }
6154 #[derive(Debug, Clone, PartialEq, Eq)]
6155 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6156 pub enum CoreNotificationDataChild {
6157     DeviceStatusNtf(DeviceStatusNtfData),
6158     GenericError(GenericErrorData),
6159     Payload(Bytes),
6160     None,
6161 }
6162 impl CoreNotificationDataChild {
get_total_size(&self) -> usize6163     fn get_total_size(&self) -> usize {
6164         match self {
6165             CoreNotificationDataChild::DeviceStatusNtf(value) => value.get_total_size(),
6166             CoreNotificationDataChild::GenericError(value) => value.get_total_size(),
6167             CoreNotificationDataChild::Payload(bytes) => bytes.len(),
6168             CoreNotificationDataChild::None => 0,
6169         }
6170     }
6171 }
6172 #[derive(Debug, Clone, PartialEq, Eq)]
6173 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6174 pub enum CoreNotificationChild {
6175     DeviceStatusNtf(DeviceStatusNtf),
6176     GenericError(GenericError),
6177     Payload(Bytes),
6178     None,
6179 }
6180 #[derive(Debug, Clone, PartialEq, Eq)]
6181 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6182 pub struct CoreNotificationData {
6183     child: CoreNotificationDataChild,
6184 }
6185 #[derive(Debug, Clone, PartialEq, Eq)]
6186 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6187 pub struct CoreNotification {
6188     #[cfg_attr(feature = "serde", serde(flatten))]
6189     ucicontrolpacket: UciControlPacketData,
6190     #[cfg_attr(feature = "serde", serde(flatten))]
6191     ucinotification: UciNotificationData,
6192     #[cfg_attr(feature = "serde", serde(flatten))]
6193     corenotification: CoreNotificationData,
6194 }
6195 #[derive(Debug)]
6196 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6197 pub struct CoreNotificationBuilder {
6198     pub opcode: u8,
6199     pub payload: Option<Bytes>,
6200 }
6201 impl CoreNotificationData {
conforms(bytes: &[u8]) -> bool6202     fn conforms(bytes: &[u8]) -> bool {
6203         true
6204     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>6205     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
6206         let mut cell = Cell::new(bytes);
6207         let packet = Self::parse_inner(&mut cell, opcode)?;
6208         Ok(packet)
6209     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>6210     fn parse_inner(
6211         mut bytes: &mut Cell<&[u8]>,
6212         opcode: u8,
6213     ) -> Result<Self, DecodeError> {
6214         let payload = bytes.get();
6215         bytes.get_mut().advance(payload.len());
6216         let child = match (opcode) {
6217             (1) if DeviceStatusNtfData::conforms(&payload) => {
6218                 let mut cell = Cell::new(payload);
6219                 let child_data = DeviceStatusNtfData::parse_inner(&mut cell)?;
6220                 CoreNotificationDataChild::DeviceStatusNtf(child_data)
6221             }
6222             (7) if GenericErrorData::conforms(&payload) => {
6223                 let mut cell = Cell::new(payload);
6224                 let child_data = GenericErrorData::parse_inner(&mut cell)?;
6225                 CoreNotificationDataChild::GenericError(child_data)
6226             }
6227             _ if !payload.is_empty() => {
6228                 CoreNotificationDataChild::Payload(Bytes::copy_from_slice(payload))
6229             }
6230             _ => CoreNotificationDataChild::None,
6231         };
6232         Ok(Self { child })
6233     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>6234     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
6235         match &self.child {
6236             CoreNotificationDataChild::DeviceStatusNtf(child) => child.write_to(buffer)?,
6237             CoreNotificationDataChild::GenericError(child) => child.write_to(buffer)?,
6238             CoreNotificationDataChild::Payload(payload) => buffer.put_slice(payload),
6239             CoreNotificationDataChild::None => {}
6240         }
6241         Ok(())
6242     }
get_total_size(&self) -> usize6243     fn get_total_size(&self) -> usize {
6244         self.get_size()
6245     }
get_size(&self) -> usize6246     fn get_size(&self) -> usize {
6247         self.child.get_total_size()
6248     }
6249 }
6250 impl Packet for CoreNotification {
encoded_len(&self) -> usize6251     fn encoded_len(&self) -> usize {
6252         self.get_size()
6253     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>6254     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
6255         self.ucicontrolpacket.write_to(buf)
6256     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>6257     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
6258         unimplemented!("Rust legacy does not implement full packet trait")
6259     }
6260 }
6261 impl TryFrom<CoreNotification> for Bytes {
6262     type Error = EncodeError;
try_from(packet: CoreNotification) -> Result<Self, Self::Error>6263     fn try_from(packet: CoreNotification) -> Result<Self, Self::Error> {
6264         packet.encode_to_bytes()
6265     }
6266 }
6267 impl TryFrom<CoreNotification> for Vec<u8> {
6268     type Error = EncodeError;
try_from(packet: CoreNotification) -> Result<Self, Self::Error>6269     fn try_from(packet: CoreNotification) -> Result<Self, Self::Error> {
6270         packet.encode_to_vec()
6271     }
6272 }
6273 impl From<CoreNotification> for UciControlPacket {
from(packet: CoreNotification) -> UciControlPacket6274     fn from(packet: CoreNotification) -> UciControlPacket {
6275         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
6276     }
6277 }
6278 impl From<CoreNotification> for UciNotification {
from(packet: CoreNotification) -> UciNotification6279     fn from(packet: CoreNotification) -> UciNotification {
6280         UciNotification::new(packet.ucicontrolpacket).unwrap()
6281     }
6282 }
6283 impl TryFrom<UciControlPacket> for CoreNotification {
6284     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<CoreNotification, Self::Error>6285     fn try_from(packet: UciControlPacket) -> Result<CoreNotification, Self::Error> {
6286         CoreNotification::new(packet.ucicontrolpacket)
6287     }
6288 }
6289 impl CoreNotification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>6290     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
6291         let mut cell = Cell::new(bytes);
6292         let packet = Self::parse_inner(&mut cell)?;
6293         Ok(packet)
6294     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>6295     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
6296         let data = UciControlPacketData::parse_inner(&mut bytes)?;
6297         Self::new(data)
6298     }
specialize(&self) -> CoreNotificationChild6299     pub fn specialize(&self) -> CoreNotificationChild {
6300         match &self.corenotification.child {
6301             CoreNotificationDataChild::DeviceStatusNtf(_) => {
6302                 CoreNotificationChild::DeviceStatusNtf(
6303                     DeviceStatusNtf::new(self.ucicontrolpacket.clone()).unwrap(),
6304                 )
6305             }
6306             CoreNotificationDataChild::GenericError(_) => {
6307                 CoreNotificationChild::GenericError(
6308                     GenericError::new(self.ucicontrolpacket.clone()).unwrap(),
6309                 )
6310             }
6311             CoreNotificationDataChild::Payload(payload) => {
6312                 CoreNotificationChild::Payload(payload.clone())
6313             }
6314             CoreNotificationDataChild::None => CoreNotificationChild::None,
6315         }
6316     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>6317     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
6318         let ucinotification = match &ucicontrolpacket.child {
6319             UciControlPacketDataChild::UciNotification(value) => value.clone(),
6320             _ => {
6321                 return Err(DecodeError::InvalidChildError {
6322                     expected: stringify!(UciControlPacketDataChild::UciNotification),
6323                     actual: format!("{:?}", & ucicontrolpacket.child),
6324                 });
6325             }
6326         };
6327         let corenotification = match &ucinotification.child {
6328             UciNotificationDataChild::CoreNotification(value) => value.clone(),
6329             _ => {
6330                 return Err(DecodeError::InvalidChildError {
6331                     expected: stringify!(UciNotificationDataChild::CoreNotification),
6332                     actual: format!("{:?}", & ucinotification.child),
6333                 });
6334             }
6335         };
6336         Ok(Self {
6337             ucicontrolpacket,
6338             ucinotification,
6339             corenotification,
6340         })
6341     }
get_group_id(&self) -> GroupId6342     pub fn get_group_id(&self) -> GroupId {
6343         self.ucicontrolpacket.group_id
6344     }
get_message_type(&self) -> MessageType6345     pub fn get_message_type(&self) -> MessageType {
6346         self.ucicontrolpacket.message_type
6347     }
get_opcode(&self) -> u86348     pub fn get_opcode(&self) -> u8 {
6349         self.ucicontrolpacket.opcode
6350     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>6351     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
6352         self.corenotification.write_to(buffer)
6353     }
get_size(&self) -> usize6354     pub fn get_size(&self) -> usize {
6355         self.ucicontrolpacket.get_size()
6356     }
6357 }
6358 impl CoreNotificationBuilder {
build(self) -> CoreNotification6359     pub fn build(self) -> CoreNotification {
6360         let corenotification = CoreNotificationData {
6361             child: match self.payload {
6362                 None => CoreNotificationDataChild::None,
6363                 Some(bytes) => CoreNotificationDataChild::Payload(bytes),
6364             },
6365         };
6366         let ucinotification = UciNotificationData {
6367             child: UciNotificationDataChild::CoreNotification(corenotification),
6368         };
6369         let ucicontrolpacket = UciControlPacketData {
6370             group_id: GroupId::Core,
6371             message_type: MessageType::Notification,
6372             opcode: self.opcode,
6373             child: UciControlPacketDataChild::UciNotification(ucinotification),
6374         };
6375         CoreNotification::new(ucicontrolpacket).unwrap()
6376     }
6377 }
6378 impl From<CoreNotificationBuilder> for UciControlPacket {
from(builder: CoreNotificationBuilder) -> UciControlPacket6379     fn from(builder: CoreNotificationBuilder) -> UciControlPacket {
6380         builder.build().into()
6381     }
6382 }
6383 impl From<CoreNotificationBuilder> for UciNotification {
from(builder: CoreNotificationBuilder) -> UciNotification6384     fn from(builder: CoreNotificationBuilder) -> UciNotification {
6385         builder.build().into()
6386     }
6387 }
6388 impl From<CoreNotificationBuilder> for CoreNotification {
from(builder: CoreNotificationBuilder) -> CoreNotification6389     fn from(builder: CoreNotificationBuilder) -> CoreNotification {
6390         builder.build().into()
6391     }
6392 }
6393 #[derive(Debug, Clone, PartialEq, Eq)]
6394 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6395 pub enum SessionConfigCommandDataChild {
6396     SessionInitCmd(SessionInitCmdData),
6397     SessionDeinitCmd(SessionDeinitCmdData),
6398     SessionSetAppConfigCmd(SessionSetAppConfigCmdData),
6399     SessionGetAppConfigCmd(SessionGetAppConfigCmdData),
6400     SessionGetCountCmd(SessionGetCountCmdData),
6401     SessionGetStateCmd(SessionGetStateCmdData),
6402     SessionUpdateDtTagRangingRoundsCmd(SessionUpdateDtTagRangingRoundsCmdData),
6403     SessionUpdateControllerMulticastListCmd(SessionUpdateControllerMulticastListCmdData),
6404     SessionQueryMaxDataSizeCmd(SessionQueryMaxDataSizeCmdData),
6405     SessionDataTransferPhaseConfigCmd(SessionDataTransferPhaseConfigCmdData),
6406     SessionSetHybridControllerConfigCmd(SessionSetHybridControllerConfigCmdData),
6407     SessionSetHybridControleeConfigCmd(SessionSetHybridControleeConfigCmdData),
6408     Payload(Bytes),
6409     None,
6410 }
6411 impl SessionConfigCommandDataChild {
get_total_size(&self) -> usize6412     fn get_total_size(&self) -> usize {
6413         match self {
6414             SessionConfigCommandDataChild::SessionInitCmd(value) => {
6415                 value.get_total_size()
6416             }
6417             SessionConfigCommandDataChild::SessionDeinitCmd(value) => {
6418                 value.get_total_size()
6419             }
6420             SessionConfigCommandDataChild::SessionSetAppConfigCmd(value) => {
6421                 value.get_total_size()
6422             }
6423             SessionConfigCommandDataChild::SessionGetAppConfigCmd(value) => {
6424                 value.get_total_size()
6425             }
6426             SessionConfigCommandDataChild::SessionGetCountCmd(value) => {
6427                 value.get_total_size()
6428             }
6429             SessionConfigCommandDataChild::SessionGetStateCmd(value) => {
6430                 value.get_total_size()
6431             }
6432             SessionConfigCommandDataChild::SessionUpdateDtTagRangingRoundsCmd(value) => {
6433                 value.get_total_size()
6434             }
6435             SessionConfigCommandDataChild::SessionUpdateControllerMulticastListCmd(
6436                 value,
6437             ) => value.get_total_size(),
6438             SessionConfigCommandDataChild::SessionQueryMaxDataSizeCmd(value) => {
6439                 value.get_total_size()
6440             }
6441             SessionConfigCommandDataChild::SessionDataTransferPhaseConfigCmd(value) => {
6442                 value.get_total_size()
6443             }
6444             SessionConfigCommandDataChild::SessionSetHybridControllerConfigCmd(value) => {
6445                 value.get_total_size()
6446             }
6447             SessionConfigCommandDataChild::SessionSetHybridControleeConfigCmd(value) => {
6448                 value.get_total_size()
6449             }
6450             SessionConfigCommandDataChild::Payload(bytes) => bytes.len(),
6451             SessionConfigCommandDataChild::None => 0,
6452         }
6453     }
6454 }
6455 #[derive(Debug, Clone, PartialEq, Eq)]
6456 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6457 pub enum SessionConfigCommandChild {
6458     SessionInitCmd(SessionInitCmd),
6459     SessionDeinitCmd(SessionDeinitCmd),
6460     SessionSetAppConfigCmd(SessionSetAppConfigCmd),
6461     SessionGetAppConfigCmd(SessionGetAppConfigCmd),
6462     SessionGetCountCmd(SessionGetCountCmd),
6463     SessionGetStateCmd(SessionGetStateCmd),
6464     SessionUpdateDtTagRangingRoundsCmd(SessionUpdateDtTagRangingRoundsCmd),
6465     SessionUpdateControllerMulticastListCmd(SessionUpdateControllerMulticastListCmd),
6466     SessionQueryMaxDataSizeCmd(SessionQueryMaxDataSizeCmd),
6467     SessionDataTransferPhaseConfigCmd(SessionDataTransferPhaseConfigCmd),
6468     SessionSetHybridControllerConfigCmd(SessionSetHybridControllerConfigCmd),
6469     SessionSetHybridControleeConfigCmd(SessionSetHybridControleeConfigCmd),
6470     Payload(Bytes),
6471     None,
6472 }
6473 #[derive(Debug, Clone, PartialEq, Eq)]
6474 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6475 pub struct SessionConfigCommandData {
6476     child: SessionConfigCommandDataChild,
6477 }
6478 #[derive(Debug, Clone, PartialEq, Eq)]
6479 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6480 pub struct SessionConfigCommand {
6481     #[cfg_attr(feature = "serde", serde(flatten))]
6482     ucicontrolpacket: UciControlPacketData,
6483     #[cfg_attr(feature = "serde", serde(flatten))]
6484     ucicommand: UciCommandData,
6485     #[cfg_attr(feature = "serde", serde(flatten))]
6486     sessionconfigcommand: SessionConfigCommandData,
6487 }
6488 #[derive(Debug)]
6489 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6490 pub struct SessionConfigCommandBuilder {
6491     pub opcode: u8,
6492     pub payload: Option<Bytes>,
6493 }
6494 impl SessionConfigCommandData {
conforms(bytes: &[u8]) -> bool6495     fn conforms(bytes: &[u8]) -> bool {
6496         true
6497     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>6498     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
6499         let mut cell = Cell::new(bytes);
6500         let packet = Self::parse_inner(&mut cell, opcode)?;
6501         Ok(packet)
6502     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>6503     fn parse_inner(
6504         mut bytes: &mut Cell<&[u8]>,
6505         opcode: u8,
6506     ) -> Result<Self, DecodeError> {
6507         let payload = bytes.get();
6508         bytes.get_mut().advance(payload.len());
6509         let child = match (opcode) {
6510             (0) if SessionInitCmdData::conforms(&payload) => {
6511                 let mut cell = Cell::new(payload);
6512                 let child_data = SessionInitCmdData::parse_inner(&mut cell)?;
6513                 SessionConfigCommandDataChild::SessionInitCmd(child_data)
6514             }
6515             (1) if SessionDeinitCmdData::conforms(&payload) => {
6516                 let mut cell = Cell::new(payload);
6517                 let child_data = SessionDeinitCmdData::parse_inner(&mut cell)?;
6518                 SessionConfigCommandDataChild::SessionDeinitCmd(child_data)
6519             }
6520             (3) if SessionSetAppConfigCmdData::conforms(&payload) => {
6521                 let mut cell = Cell::new(payload);
6522                 let child_data = SessionSetAppConfigCmdData::parse_inner(&mut cell)?;
6523                 SessionConfigCommandDataChild::SessionSetAppConfigCmd(child_data)
6524             }
6525             (4) if SessionGetAppConfigCmdData::conforms(&payload) => {
6526                 let mut cell = Cell::new(payload);
6527                 let child_data = SessionGetAppConfigCmdData::parse_inner(&mut cell)?;
6528                 SessionConfigCommandDataChild::SessionGetAppConfigCmd(child_data)
6529             }
6530             (5) if SessionGetCountCmdData::conforms(&payload) => {
6531                 let mut cell = Cell::new(payload);
6532                 let child_data = SessionGetCountCmdData::parse_inner(&mut cell)?;
6533                 SessionConfigCommandDataChild::SessionGetCountCmd(child_data)
6534             }
6535             (6) if SessionGetStateCmdData::conforms(&payload) => {
6536                 let mut cell = Cell::new(payload);
6537                 let child_data = SessionGetStateCmdData::parse_inner(&mut cell)?;
6538                 SessionConfigCommandDataChild::SessionGetStateCmd(child_data)
6539             }
6540             (9) if SessionUpdateDtTagRangingRoundsCmdData::conforms(&payload) => {
6541                 let mut cell = Cell::new(payload);
6542                 let child_data = SessionUpdateDtTagRangingRoundsCmdData::parse_inner(
6543                     &mut cell,
6544                 )?;
6545                 SessionConfigCommandDataChild::SessionUpdateDtTagRangingRoundsCmd(
6546                     child_data,
6547                 )
6548             }
6549             (7) if SessionUpdateControllerMulticastListCmdData::conforms(&payload) => {
6550                 let mut cell = Cell::new(payload);
6551                 let child_data = SessionUpdateControllerMulticastListCmdData::parse_inner(
6552                     &mut cell,
6553                 )?;
6554                 SessionConfigCommandDataChild::SessionUpdateControllerMulticastListCmd(
6555                     child_data,
6556                 )
6557             }
6558             (11) if SessionQueryMaxDataSizeCmdData::conforms(&payload) => {
6559                 let mut cell = Cell::new(payload);
6560                 let child_data = SessionQueryMaxDataSizeCmdData::parse_inner(&mut cell)?;
6561                 SessionConfigCommandDataChild::SessionQueryMaxDataSizeCmd(child_data)
6562             }
6563             (14) if SessionDataTransferPhaseConfigCmdData::conforms(&payload) => {
6564                 let mut cell = Cell::new(payload);
6565                 let child_data = SessionDataTransferPhaseConfigCmdData::parse_inner(
6566                     &mut cell,
6567                 )?;
6568                 SessionConfigCommandDataChild::SessionDataTransferPhaseConfigCmd(
6569                     child_data,
6570                 )
6571             }
6572             (12) if SessionSetHybridControllerConfigCmdData::conforms(&payload) => {
6573                 let mut cell = Cell::new(payload);
6574                 let child_data = SessionSetHybridControllerConfigCmdData::parse_inner(
6575                     &mut cell,
6576                 )?;
6577                 SessionConfigCommandDataChild::SessionSetHybridControllerConfigCmd(
6578                     child_data,
6579                 )
6580             }
6581             (13) if SessionSetHybridControleeConfigCmdData::conforms(&payload) => {
6582                 let mut cell = Cell::new(payload);
6583                 let child_data = SessionSetHybridControleeConfigCmdData::parse_inner(
6584                     &mut cell,
6585                 )?;
6586                 SessionConfigCommandDataChild::SessionSetHybridControleeConfigCmd(
6587                     child_data,
6588                 )
6589             }
6590             _ if !payload.is_empty() => {
6591                 SessionConfigCommandDataChild::Payload(Bytes::copy_from_slice(payload))
6592             }
6593             _ => SessionConfigCommandDataChild::None,
6594         };
6595         Ok(Self { child })
6596     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>6597     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
6598         match &self.child {
6599             SessionConfigCommandDataChild::SessionInitCmd(child) => {
6600                 child.write_to(buffer)?
6601             }
6602             SessionConfigCommandDataChild::SessionDeinitCmd(child) => {
6603                 child.write_to(buffer)?
6604             }
6605             SessionConfigCommandDataChild::SessionSetAppConfigCmd(child) => {
6606                 child.write_to(buffer)?
6607             }
6608             SessionConfigCommandDataChild::SessionGetAppConfigCmd(child) => {
6609                 child.write_to(buffer)?
6610             }
6611             SessionConfigCommandDataChild::SessionGetCountCmd(child) => {
6612                 child.write_to(buffer)?
6613             }
6614             SessionConfigCommandDataChild::SessionGetStateCmd(child) => {
6615                 child.write_to(buffer)?
6616             }
6617             SessionConfigCommandDataChild::SessionUpdateDtTagRangingRoundsCmd(child) => {
6618                 child.write_to(buffer)?
6619             }
6620             SessionConfigCommandDataChild::SessionUpdateControllerMulticastListCmd(
6621                 child,
6622             ) => child.write_to(buffer)?,
6623             SessionConfigCommandDataChild::SessionQueryMaxDataSizeCmd(child) => {
6624                 child.write_to(buffer)?
6625             }
6626             SessionConfigCommandDataChild::SessionDataTransferPhaseConfigCmd(child) => {
6627                 child.write_to(buffer)?
6628             }
6629             SessionConfigCommandDataChild::SessionSetHybridControllerConfigCmd(child) => {
6630                 child.write_to(buffer)?
6631             }
6632             SessionConfigCommandDataChild::SessionSetHybridControleeConfigCmd(child) => {
6633                 child.write_to(buffer)?
6634             }
6635             SessionConfigCommandDataChild::Payload(payload) => buffer.put_slice(payload),
6636             SessionConfigCommandDataChild::None => {}
6637         }
6638         Ok(())
6639     }
get_total_size(&self) -> usize6640     fn get_total_size(&self) -> usize {
6641         self.get_size()
6642     }
get_size(&self) -> usize6643     fn get_size(&self) -> usize {
6644         self.child.get_total_size()
6645     }
6646 }
6647 impl Packet for SessionConfigCommand {
encoded_len(&self) -> usize6648     fn encoded_len(&self) -> usize {
6649         self.get_size()
6650     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>6651     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
6652         self.ucicontrolpacket.write_to(buf)
6653     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>6654     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
6655         unimplemented!("Rust legacy does not implement full packet trait")
6656     }
6657 }
6658 impl TryFrom<SessionConfigCommand> for Bytes {
6659     type Error = EncodeError;
try_from(packet: SessionConfigCommand) -> Result<Self, Self::Error>6660     fn try_from(packet: SessionConfigCommand) -> Result<Self, Self::Error> {
6661         packet.encode_to_bytes()
6662     }
6663 }
6664 impl TryFrom<SessionConfigCommand> for Vec<u8> {
6665     type Error = EncodeError;
try_from(packet: SessionConfigCommand) -> Result<Self, Self::Error>6666     fn try_from(packet: SessionConfigCommand) -> Result<Self, Self::Error> {
6667         packet.encode_to_vec()
6668     }
6669 }
6670 impl From<SessionConfigCommand> for UciControlPacket {
from(packet: SessionConfigCommand) -> UciControlPacket6671     fn from(packet: SessionConfigCommand) -> UciControlPacket {
6672         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
6673     }
6674 }
6675 impl From<SessionConfigCommand> for UciCommand {
from(packet: SessionConfigCommand) -> UciCommand6676     fn from(packet: SessionConfigCommand) -> UciCommand {
6677         UciCommand::new(packet.ucicontrolpacket).unwrap()
6678     }
6679 }
6680 impl TryFrom<UciControlPacket> for SessionConfigCommand {
6681     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionConfigCommand, Self::Error>6682     fn try_from(packet: UciControlPacket) -> Result<SessionConfigCommand, Self::Error> {
6683         SessionConfigCommand::new(packet.ucicontrolpacket)
6684     }
6685 }
6686 impl SessionConfigCommand {
parse(bytes: &[u8]) -> Result<Self, DecodeError>6687     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
6688         let mut cell = Cell::new(bytes);
6689         let packet = Self::parse_inner(&mut cell)?;
6690         Ok(packet)
6691     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>6692     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
6693         let data = UciControlPacketData::parse_inner(&mut bytes)?;
6694         Self::new(data)
6695     }
specialize(&self) -> SessionConfigCommandChild6696     pub fn specialize(&self) -> SessionConfigCommandChild {
6697         match &self.sessionconfigcommand.child {
6698             SessionConfigCommandDataChild::SessionInitCmd(_) => {
6699                 SessionConfigCommandChild::SessionInitCmd(
6700                     SessionInitCmd::new(self.ucicontrolpacket.clone()).unwrap(),
6701                 )
6702             }
6703             SessionConfigCommandDataChild::SessionDeinitCmd(_) => {
6704                 SessionConfigCommandChild::SessionDeinitCmd(
6705                     SessionDeinitCmd::new(self.ucicontrolpacket.clone()).unwrap(),
6706                 )
6707             }
6708             SessionConfigCommandDataChild::SessionSetAppConfigCmd(_) => {
6709                 SessionConfigCommandChild::SessionSetAppConfigCmd(
6710                     SessionSetAppConfigCmd::new(self.ucicontrolpacket.clone()).unwrap(),
6711                 )
6712             }
6713             SessionConfigCommandDataChild::SessionGetAppConfigCmd(_) => {
6714                 SessionConfigCommandChild::SessionGetAppConfigCmd(
6715                     SessionGetAppConfigCmd::new(self.ucicontrolpacket.clone()).unwrap(),
6716                 )
6717             }
6718             SessionConfigCommandDataChild::SessionGetCountCmd(_) => {
6719                 SessionConfigCommandChild::SessionGetCountCmd(
6720                     SessionGetCountCmd::new(self.ucicontrolpacket.clone()).unwrap(),
6721                 )
6722             }
6723             SessionConfigCommandDataChild::SessionGetStateCmd(_) => {
6724                 SessionConfigCommandChild::SessionGetStateCmd(
6725                     SessionGetStateCmd::new(self.ucicontrolpacket.clone()).unwrap(),
6726                 )
6727             }
6728             SessionConfigCommandDataChild::SessionUpdateDtTagRangingRoundsCmd(_) => {
6729                 SessionConfigCommandChild::SessionUpdateDtTagRangingRoundsCmd(
6730                     SessionUpdateDtTagRangingRoundsCmd::new(
6731                             self.ucicontrolpacket.clone(),
6732                         )
6733                         .unwrap(),
6734                 )
6735             }
6736             SessionConfigCommandDataChild::SessionUpdateControllerMulticastListCmd(_) => {
6737                 SessionConfigCommandChild::SessionUpdateControllerMulticastListCmd(
6738                     SessionUpdateControllerMulticastListCmd::new(
6739                             self.ucicontrolpacket.clone(),
6740                         )
6741                         .unwrap(),
6742                 )
6743             }
6744             SessionConfigCommandDataChild::SessionQueryMaxDataSizeCmd(_) => {
6745                 SessionConfigCommandChild::SessionQueryMaxDataSizeCmd(
6746                     SessionQueryMaxDataSizeCmd::new(self.ucicontrolpacket.clone())
6747                         .unwrap(),
6748                 )
6749             }
6750             SessionConfigCommandDataChild::SessionDataTransferPhaseConfigCmd(_) => {
6751                 SessionConfigCommandChild::SessionDataTransferPhaseConfigCmd(
6752                     SessionDataTransferPhaseConfigCmd::new(self.ucicontrolpacket.clone())
6753                         .unwrap(),
6754                 )
6755             }
6756             SessionConfigCommandDataChild::SessionSetHybridControllerConfigCmd(_) => {
6757                 SessionConfigCommandChild::SessionSetHybridControllerConfigCmd(
6758                     SessionSetHybridControllerConfigCmd::new(
6759                             self.ucicontrolpacket.clone(),
6760                         )
6761                         .unwrap(),
6762                 )
6763             }
6764             SessionConfigCommandDataChild::SessionSetHybridControleeConfigCmd(_) => {
6765                 SessionConfigCommandChild::SessionSetHybridControleeConfigCmd(
6766                     SessionSetHybridControleeConfigCmd::new(
6767                             self.ucicontrolpacket.clone(),
6768                         )
6769                         .unwrap(),
6770                 )
6771             }
6772             SessionConfigCommandDataChild::Payload(payload) => {
6773                 SessionConfigCommandChild::Payload(payload.clone())
6774             }
6775             SessionConfigCommandDataChild::None => SessionConfigCommandChild::None,
6776         }
6777     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>6778     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
6779         let ucicommand = match &ucicontrolpacket.child {
6780             UciControlPacketDataChild::UciCommand(value) => value.clone(),
6781             _ => {
6782                 return Err(DecodeError::InvalidChildError {
6783                     expected: stringify!(UciControlPacketDataChild::UciCommand),
6784                     actual: format!("{:?}", & ucicontrolpacket.child),
6785                 });
6786             }
6787         };
6788         let sessionconfigcommand = match &ucicommand.child {
6789             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
6790             _ => {
6791                 return Err(DecodeError::InvalidChildError {
6792                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
6793                     actual: format!("{:?}", & ucicommand.child),
6794                 });
6795             }
6796         };
6797         Ok(Self {
6798             ucicontrolpacket,
6799             ucicommand,
6800             sessionconfigcommand,
6801         })
6802     }
get_group_id(&self) -> GroupId6803     pub fn get_group_id(&self) -> GroupId {
6804         self.ucicontrolpacket.group_id
6805     }
get_message_type(&self) -> MessageType6806     pub fn get_message_type(&self) -> MessageType {
6807         self.ucicontrolpacket.message_type
6808     }
get_opcode(&self) -> u86809     pub fn get_opcode(&self) -> u8 {
6810         self.ucicontrolpacket.opcode
6811     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>6812     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
6813         self.sessionconfigcommand.write_to(buffer)
6814     }
get_size(&self) -> usize6815     pub fn get_size(&self) -> usize {
6816         self.ucicontrolpacket.get_size()
6817     }
6818 }
6819 impl SessionConfigCommandBuilder {
build(self) -> SessionConfigCommand6820     pub fn build(self) -> SessionConfigCommand {
6821         let sessionconfigcommand = SessionConfigCommandData {
6822             child: match self.payload {
6823                 None => SessionConfigCommandDataChild::None,
6824                 Some(bytes) => SessionConfigCommandDataChild::Payload(bytes),
6825             },
6826         };
6827         let ucicommand = UciCommandData {
6828             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
6829         };
6830         let ucicontrolpacket = UciControlPacketData {
6831             group_id: GroupId::SessionConfig,
6832             message_type: MessageType::Command,
6833             opcode: self.opcode,
6834             child: UciControlPacketDataChild::UciCommand(ucicommand),
6835         };
6836         SessionConfigCommand::new(ucicontrolpacket).unwrap()
6837     }
6838 }
6839 impl From<SessionConfigCommandBuilder> for UciControlPacket {
from(builder: SessionConfigCommandBuilder) -> UciControlPacket6840     fn from(builder: SessionConfigCommandBuilder) -> UciControlPacket {
6841         builder.build().into()
6842     }
6843 }
6844 impl From<SessionConfigCommandBuilder> for UciCommand {
from(builder: SessionConfigCommandBuilder) -> UciCommand6845     fn from(builder: SessionConfigCommandBuilder) -> UciCommand {
6846         builder.build().into()
6847     }
6848 }
6849 impl From<SessionConfigCommandBuilder> for SessionConfigCommand {
from(builder: SessionConfigCommandBuilder) -> SessionConfigCommand6850     fn from(builder: SessionConfigCommandBuilder) -> SessionConfigCommand {
6851         builder.build().into()
6852     }
6853 }
6854 #[derive(Debug, Clone, PartialEq, Eq)]
6855 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6856 pub enum SessionConfigResponseDataChild {
6857     SessionInitRsp_V2(SessionInitRsp_V2Data),
6858     SessionInitRsp(SessionInitRspData),
6859     SessionDeinitRsp(SessionDeinitRspData),
6860     SessionSetAppConfigRsp(SessionSetAppConfigRspData),
6861     SessionGetAppConfigRsp(SessionGetAppConfigRspData),
6862     SessionGetCountRsp(SessionGetCountRspData),
6863     SessionGetStateRsp(SessionGetStateRspData),
6864     SessionUpdateDtTagRangingRoundsRsp(SessionUpdateDtTagRangingRoundsRspData),
6865     SessionUpdateControllerMulticastListRsp(SessionUpdateControllerMulticastListRspData),
6866     SessionQueryMaxDataSizeRsp(SessionQueryMaxDataSizeRspData),
6867     SessionDataTransferPhaseConfigRsp(SessionDataTransferPhaseConfigRspData),
6868     SessionSetHybridControllerConfigRsp(SessionSetHybridControllerConfigRspData),
6869     SessionSetHybridControleeConfigRsp(SessionSetHybridControleeConfigRspData),
6870     Payload(Bytes),
6871     None,
6872 }
6873 impl SessionConfigResponseDataChild {
get_total_size(&self) -> usize6874     fn get_total_size(&self) -> usize {
6875         match self {
6876             SessionConfigResponseDataChild::SessionInitRsp_V2(value) => {
6877                 value.get_total_size()
6878             }
6879             SessionConfigResponseDataChild::SessionInitRsp(value) => {
6880                 value.get_total_size()
6881             }
6882             SessionConfigResponseDataChild::SessionDeinitRsp(value) => {
6883                 value.get_total_size()
6884             }
6885             SessionConfigResponseDataChild::SessionSetAppConfigRsp(value) => {
6886                 value.get_total_size()
6887             }
6888             SessionConfigResponseDataChild::SessionGetAppConfigRsp(value) => {
6889                 value.get_total_size()
6890             }
6891             SessionConfigResponseDataChild::SessionGetCountRsp(value) => {
6892                 value.get_total_size()
6893             }
6894             SessionConfigResponseDataChild::SessionGetStateRsp(value) => {
6895                 value.get_total_size()
6896             }
6897             SessionConfigResponseDataChild::SessionUpdateDtTagRangingRoundsRsp(value) => {
6898                 value.get_total_size()
6899             }
6900             SessionConfigResponseDataChild::SessionUpdateControllerMulticastListRsp(
6901                 value,
6902             ) => value.get_total_size(),
6903             SessionConfigResponseDataChild::SessionQueryMaxDataSizeRsp(value) => {
6904                 value.get_total_size()
6905             }
6906             SessionConfigResponseDataChild::SessionDataTransferPhaseConfigRsp(value) => {
6907                 value.get_total_size()
6908             }
6909             SessionConfigResponseDataChild::SessionSetHybridControllerConfigRsp(
6910                 value,
6911             ) => value.get_total_size(),
6912             SessionConfigResponseDataChild::SessionSetHybridControleeConfigRsp(value) => {
6913                 value.get_total_size()
6914             }
6915             SessionConfigResponseDataChild::Payload(bytes) => bytes.len(),
6916             SessionConfigResponseDataChild::None => 0,
6917         }
6918     }
6919 }
6920 #[derive(Debug, Clone, PartialEq, Eq)]
6921 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6922 pub enum SessionConfigResponseChild {
6923     SessionInitRsp_V2(SessionInitRsp_V2),
6924     SessionInitRsp(SessionInitRsp),
6925     SessionDeinitRsp(SessionDeinitRsp),
6926     SessionSetAppConfigRsp(SessionSetAppConfigRsp),
6927     SessionGetAppConfigRsp(SessionGetAppConfigRsp),
6928     SessionGetCountRsp(SessionGetCountRsp),
6929     SessionGetStateRsp(SessionGetStateRsp),
6930     SessionUpdateDtTagRangingRoundsRsp(SessionUpdateDtTagRangingRoundsRsp),
6931     SessionUpdateControllerMulticastListRsp(SessionUpdateControllerMulticastListRsp),
6932     SessionQueryMaxDataSizeRsp(SessionQueryMaxDataSizeRsp),
6933     SessionDataTransferPhaseConfigRsp(SessionDataTransferPhaseConfigRsp),
6934     SessionSetHybridControllerConfigRsp(SessionSetHybridControllerConfigRsp),
6935     SessionSetHybridControleeConfigRsp(SessionSetHybridControleeConfigRsp),
6936     Payload(Bytes),
6937     None,
6938 }
6939 #[derive(Debug, Clone, PartialEq, Eq)]
6940 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6941 pub struct SessionConfigResponseData {
6942     child: SessionConfigResponseDataChild,
6943 }
6944 #[derive(Debug, Clone, PartialEq, Eq)]
6945 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6946 pub struct SessionConfigResponse {
6947     #[cfg_attr(feature = "serde", serde(flatten))]
6948     ucicontrolpacket: UciControlPacketData,
6949     #[cfg_attr(feature = "serde", serde(flatten))]
6950     uciresponse: UciResponseData,
6951     #[cfg_attr(feature = "serde", serde(flatten))]
6952     sessionconfigresponse: SessionConfigResponseData,
6953 }
6954 #[derive(Debug)]
6955 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6956 pub struct SessionConfigResponseBuilder {
6957     pub opcode: u8,
6958     pub payload: Option<Bytes>,
6959 }
6960 impl SessionConfigResponseData {
conforms(bytes: &[u8]) -> bool6961     fn conforms(bytes: &[u8]) -> bool {
6962         true
6963     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>6964     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
6965         let mut cell = Cell::new(bytes);
6966         let packet = Self::parse_inner(&mut cell, opcode)?;
6967         Ok(packet)
6968     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>6969     fn parse_inner(
6970         mut bytes: &mut Cell<&[u8]>,
6971         opcode: u8,
6972     ) -> Result<Self, DecodeError> {
6973         let payload = bytes.get();
6974         bytes.get_mut().advance(payload.len());
6975         let child = match (opcode) {
6976             (0) if SessionInitRsp_V2Data::conforms(&payload) => {
6977                 let mut cell = Cell::new(payload);
6978                 let child_data = SessionInitRsp_V2Data::parse_inner(&mut cell)?;
6979                 SessionConfigResponseDataChild::SessionInitRsp_V2(child_data)
6980             }
6981             (0) if SessionInitRspData::conforms(&payload) => {
6982                 let mut cell = Cell::new(payload);
6983                 let child_data = SessionInitRspData::parse_inner(&mut cell)?;
6984                 SessionConfigResponseDataChild::SessionInitRsp(child_data)
6985             }
6986             (1) if SessionDeinitRspData::conforms(&payload) => {
6987                 let mut cell = Cell::new(payload);
6988                 let child_data = SessionDeinitRspData::parse_inner(&mut cell)?;
6989                 SessionConfigResponseDataChild::SessionDeinitRsp(child_data)
6990             }
6991             (3) if SessionSetAppConfigRspData::conforms(&payload) => {
6992                 let mut cell = Cell::new(payload);
6993                 let child_data = SessionSetAppConfigRspData::parse_inner(&mut cell)?;
6994                 SessionConfigResponseDataChild::SessionSetAppConfigRsp(child_data)
6995             }
6996             (4) if SessionGetAppConfigRspData::conforms(&payload) => {
6997                 let mut cell = Cell::new(payload);
6998                 let child_data = SessionGetAppConfigRspData::parse_inner(&mut cell)?;
6999                 SessionConfigResponseDataChild::SessionGetAppConfigRsp(child_data)
7000             }
7001             (5) if SessionGetCountRspData::conforms(&payload) => {
7002                 let mut cell = Cell::new(payload);
7003                 let child_data = SessionGetCountRspData::parse_inner(&mut cell)?;
7004                 SessionConfigResponseDataChild::SessionGetCountRsp(child_data)
7005             }
7006             (6) if SessionGetStateRspData::conforms(&payload) => {
7007                 let mut cell = Cell::new(payload);
7008                 let child_data = SessionGetStateRspData::parse_inner(&mut cell)?;
7009                 SessionConfigResponseDataChild::SessionGetStateRsp(child_data)
7010             }
7011             (9) if SessionUpdateDtTagRangingRoundsRspData::conforms(&payload) => {
7012                 let mut cell = Cell::new(payload);
7013                 let child_data = SessionUpdateDtTagRangingRoundsRspData::parse_inner(
7014                     &mut cell,
7015                 )?;
7016                 SessionConfigResponseDataChild::SessionUpdateDtTagRangingRoundsRsp(
7017                     child_data,
7018                 )
7019             }
7020             (7) if SessionUpdateControllerMulticastListRspData::conforms(&payload) => {
7021                 let mut cell = Cell::new(payload);
7022                 let child_data = SessionUpdateControllerMulticastListRspData::parse_inner(
7023                     &mut cell,
7024                 )?;
7025                 SessionConfigResponseDataChild::SessionUpdateControllerMulticastListRsp(
7026                     child_data,
7027                 )
7028             }
7029             (11) if SessionQueryMaxDataSizeRspData::conforms(&payload) => {
7030                 let mut cell = Cell::new(payload);
7031                 let child_data = SessionQueryMaxDataSizeRspData::parse_inner(&mut cell)?;
7032                 SessionConfigResponseDataChild::SessionQueryMaxDataSizeRsp(child_data)
7033             }
7034             (14) if SessionDataTransferPhaseConfigRspData::conforms(&payload) => {
7035                 let mut cell = Cell::new(payload);
7036                 let child_data = SessionDataTransferPhaseConfigRspData::parse_inner(
7037                     &mut cell,
7038                 )?;
7039                 SessionConfigResponseDataChild::SessionDataTransferPhaseConfigRsp(
7040                     child_data,
7041                 )
7042             }
7043             (12) if SessionSetHybridControllerConfigRspData::conforms(&payload) => {
7044                 let mut cell = Cell::new(payload);
7045                 let child_data = SessionSetHybridControllerConfigRspData::parse_inner(
7046                     &mut cell,
7047                 )?;
7048                 SessionConfigResponseDataChild::SessionSetHybridControllerConfigRsp(
7049                     child_data,
7050                 )
7051             }
7052             (13) if SessionSetHybridControleeConfigRspData::conforms(&payload) => {
7053                 let mut cell = Cell::new(payload);
7054                 let child_data = SessionSetHybridControleeConfigRspData::parse_inner(
7055                     &mut cell,
7056                 )?;
7057                 SessionConfigResponseDataChild::SessionSetHybridControleeConfigRsp(
7058                     child_data,
7059                 )
7060             }
7061             _ if !payload.is_empty() => {
7062                 SessionConfigResponseDataChild::Payload(Bytes::copy_from_slice(payload))
7063             }
7064             _ => SessionConfigResponseDataChild::None,
7065         };
7066         Ok(Self { child })
7067     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>7068     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
7069         match &self.child {
7070             SessionConfigResponseDataChild::SessionInitRsp_V2(child) => {
7071                 child.write_to(buffer)?
7072             }
7073             SessionConfigResponseDataChild::SessionInitRsp(child) => {
7074                 child.write_to(buffer)?
7075             }
7076             SessionConfigResponseDataChild::SessionDeinitRsp(child) => {
7077                 child.write_to(buffer)?
7078             }
7079             SessionConfigResponseDataChild::SessionSetAppConfigRsp(child) => {
7080                 child.write_to(buffer)?
7081             }
7082             SessionConfigResponseDataChild::SessionGetAppConfigRsp(child) => {
7083                 child.write_to(buffer)?
7084             }
7085             SessionConfigResponseDataChild::SessionGetCountRsp(child) => {
7086                 child.write_to(buffer)?
7087             }
7088             SessionConfigResponseDataChild::SessionGetStateRsp(child) => {
7089                 child.write_to(buffer)?
7090             }
7091             SessionConfigResponseDataChild::SessionUpdateDtTagRangingRoundsRsp(child) => {
7092                 child.write_to(buffer)?
7093             }
7094             SessionConfigResponseDataChild::SessionUpdateControllerMulticastListRsp(
7095                 child,
7096             ) => child.write_to(buffer)?,
7097             SessionConfigResponseDataChild::SessionQueryMaxDataSizeRsp(child) => {
7098                 child.write_to(buffer)?
7099             }
7100             SessionConfigResponseDataChild::SessionDataTransferPhaseConfigRsp(child) => {
7101                 child.write_to(buffer)?
7102             }
7103             SessionConfigResponseDataChild::SessionSetHybridControllerConfigRsp(
7104                 child,
7105             ) => child.write_to(buffer)?,
7106             SessionConfigResponseDataChild::SessionSetHybridControleeConfigRsp(child) => {
7107                 child.write_to(buffer)?
7108             }
7109             SessionConfigResponseDataChild::Payload(payload) => buffer.put_slice(payload),
7110             SessionConfigResponseDataChild::None => {}
7111         }
7112         Ok(())
7113     }
get_total_size(&self) -> usize7114     fn get_total_size(&self) -> usize {
7115         self.get_size()
7116     }
get_size(&self) -> usize7117     fn get_size(&self) -> usize {
7118         self.child.get_total_size()
7119     }
7120 }
7121 impl Packet for SessionConfigResponse {
encoded_len(&self) -> usize7122     fn encoded_len(&self) -> usize {
7123         self.get_size()
7124     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>7125     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
7126         self.ucicontrolpacket.write_to(buf)
7127     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>7128     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
7129         unimplemented!("Rust legacy does not implement full packet trait")
7130     }
7131 }
7132 impl TryFrom<SessionConfigResponse> for Bytes {
7133     type Error = EncodeError;
try_from(packet: SessionConfigResponse) -> Result<Self, Self::Error>7134     fn try_from(packet: SessionConfigResponse) -> Result<Self, Self::Error> {
7135         packet.encode_to_bytes()
7136     }
7137 }
7138 impl TryFrom<SessionConfigResponse> for Vec<u8> {
7139     type Error = EncodeError;
try_from(packet: SessionConfigResponse) -> Result<Self, Self::Error>7140     fn try_from(packet: SessionConfigResponse) -> Result<Self, Self::Error> {
7141         packet.encode_to_vec()
7142     }
7143 }
7144 impl From<SessionConfigResponse> for UciControlPacket {
from(packet: SessionConfigResponse) -> UciControlPacket7145     fn from(packet: SessionConfigResponse) -> UciControlPacket {
7146         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
7147     }
7148 }
7149 impl From<SessionConfigResponse> for UciResponse {
from(packet: SessionConfigResponse) -> UciResponse7150     fn from(packet: SessionConfigResponse) -> UciResponse {
7151         UciResponse::new(packet.ucicontrolpacket).unwrap()
7152     }
7153 }
7154 impl TryFrom<UciControlPacket> for SessionConfigResponse {
7155     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionConfigResponse, Self::Error>7156     fn try_from(packet: UciControlPacket) -> Result<SessionConfigResponse, Self::Error> {
7157         SessionConfigResponse::new(packet.ucicontrolpacket)
7158     }
7159 }
7160 impl SessionConfigResponse {
parse(bytes: &[u8]) -> Result<Self, DecodeError>7161     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
7162         let mut cell = Cell::new(bytes);
7163         let packet = Self::parse_inner(&mut cell)?;
7164         Ok(packet)
7165     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>7166     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
7167         let data = UciControlPacketData::parse_inner(&mut bytes)?;
7168         Self::new(data)
7169     }
specialize(&self) -> SessionConfigResponseChild7170     pub fn specialize(&self) -> SessionConfigResponseChild {
7171         match &self.sessionconfigresponse.child {
7172             SessionConfigResponseDataChild::SessionInitRsp_V2(_) => {
7173                 SessionConfigResponseChild::SessionInitRsp_V2(
7174                     SessionInitRsp_V2::new(self.ucicontrolpacket.clone()).unwrap(),
7175                 )
7176             }
7177             SessionConfigResponseDataChild::SessionInitRsp(_) => {
7178                 SessionConfigResponseChild::SessionInitRsp(
7179                     SessionInitRsp::new(self.ucicontrolpacket.clone()).unwrap(),
7180                 )
7181             }
7182             SessionConfigResponseDataChild::SessionDeinitRsp(_) => {
7183                 SessionConfigResponseChild::SessionDeinitRsp(
7184                     SessionDeinitRsp::new(self.ucicontrolpacket.clone()).unwrap(),
7185                 )
7186             }
7187             SessionConfigResponseDataChild::SessionSetAppConfigRsp(_) => {
7188                 SessionConfigResponseChild::SessionSetAppConfigRsp(
7189                     SessionSetAppConfigRsp::new(self.ucicontrolpacket.clone()).unwrap(),
7190                 )
7191             }
7192             SessionConfigResponseDataChild::SessionGetAppConfigRsp(_) => {
7193                 SessionConfigResponseChild::SessionGetAppConfigRsp(
7194                     SessionGetAppConfigRsp::new(self.ucicontrolpacket.clone()).unwrap(),
7195                 )
7196             }
7197             SessionConfigResponseDataChild::SessionGetCountRsp(_) => {
7198                 SessionConfigResponseChild::SessionGetCountRsp(
7199                     SessionGetCountRsp::new(self.ucicontrolpacket.clone()).unwrap(),
7200                 )
7201             }
7202             SessionConfigResponseDataChild::SessionGetStateRsp(_) => {
7203                 SessionConfigResponseChild::SessionGetStateRsp(
7204                     SessionGetStateRsp::new(self.ucicontrolpacket.clone()).unwrap(),
7205                 )
7206             }
7207             SessionConfigResponseDataChild::SessionUpdateDtTagRangingRoundsRsp(_) => {
7208                 SessionConfigResponseChild::SessionUpdateDtTagRangingRoundsRsp(
7209                     SessionUpdateDtTagRangingRoundsRsp::new(
7210                             self.ucicontrolpacket.clone(),
7211                         )
7212                         .unwrap(),
7213                 )
7214             }
7215             SessionConfigResponseDataChild::SessionUpdateControllerMulticastListRsp(
7216                 _,
7217             ) => {
7218                 SessionConfigResponseChild::SessionUpdateControllerMulticastListRsp(
7219                     SessionUpdateControllerMulticastListRsp::new(
7220                             self.ucicontrolpacket.clone(),
7221                         )
7222                         .unwrap(),
7223                 )
7224             }
7225             SessionConfigResponseDataChild::SessionQueryMaxDataSizeRsp(_) => {
7226                 SessionConfigResponseChild::SessionQueryMaxDataSizeRsp(
7227                     SessionQueryMaxDataSizeRsp::new(self.ucicontrolpacket.clone())
7228                         .unwrap(),
7229                 )
7230             }
7231             SessionConfigResponseDataChild::SessionDataTransferPhaseConfigRsp(_) => {
7232                 SessionConfigResponseChild::SessionDataTransferPhaseConfigRsp(
7233                     SessionDataTransferPhaseConfigRsp::new(self.ucicontrolpacket.clone())
7234                         .unwrap(),
7235                 )
7236             }
7237             SessionConfigResponseDataChild::SessionSetHybridControllerConfigRsp(_) => {
7238                 SessionConfigResponseChild::SessionSetHybridControllerConfigRsp(
7239                     SessionSetHybridControllerConfigRsp::new(
7240                             self.ucicontrolpacket.clone(),
7241                         )
7242                         .unwrap(),
7243                 )
7244             }
7245             SessionConfigResponseDataChild::SessionSetHybridControleeConfigRsp(_) => {
7246                 SessionConfigResponseChild::SessionSetHybridControleeConfigRsp(
7247                     SessionSetHybridControleeConfigRsp::new(
7248                             self.ucicontrolpacket.clone(),
7249                         )
7250                         .unwrap(),
7251                 )
7252             }
7253             SessionConfigResponseDataChild::Payload(payload) => {
7254                 SessionConfigResponseChild::Payload(payload.clone())
7255             }
7256             SessionConfigResponseDataChild::None => SessionConfigResponseChild::None,
7257         }
7258     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>7259     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
7260         let uciresponse = match &ucicontrolpacket.child {
7261             UciControlPacketDataChild::UciResponse(value) => value.clone(),
7262             _ => {
7263                 return Err(DecodeError::InvalidChildError {
7264                     expected: stringify!(UciControlPacketDataChild::UciResponse),
7265                     actual: format!("{:?}", & ucicontrolpacket.child),
7266                 });
7267             }
7268         };
7269         let sessionconfigresponse = match &uciresponse.child {
7270             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
7271             _ => {
7272                 return Err(DecodeError::InvalidChildError {
7273                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
7274                     actual: format!("{:?}", & uciresponse.child),
7275                 });
7276             }
7277         };
7278         Ok(Self {
7279             ucicontrolpacket,
7280             uciresponse,
7281             sessionconfigresponse,
7282         })
7283     }
get_group_id(&self) -> GroupId7284     pub fn get_group_id(&self) -> GroupId {
7285         self.ucicontrolpacket.group_id
7286     }
get_message_type(&self) -> MessageType7287     pub fn get_message_type(&self) -> MessageType {
7288         self.ucicontrolpacket.message_type
7289     }
get_opcode(&self) -> u87290     pub fn get_opcode(&self) -> u8 {
7291         self.ucicontrolpacket.opcode
7292     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>7293     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
7294         self.sessionconfigresponse.write_to(buffer)
7295     }
get_size(&self) -> usize7296     pub fn get_size(&self) -> usize {
7297         self.ucicontrolpacket.get_size()
7298     }
7299 }
7300 impl SessionConfigResponseBuilder {
build(self) -> SessionConfigResponse7301     pub fn build(self) -> SessionConfigResponse {
7302         let sessionconfigresponse = SessionConfigResponseData {
7303             child: match self.payload {
7304                 None => SessionConfigResponseDataChild::None,
7305                 Some(bytes) => SessionConfigResponseDataChild::Payload(bytes),
7306             },
7307         };
7308         let uciresponse = UciResponseData {
7309             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
7310         };
7311         let ucicontrolpacket = UciControlPacketData {
7312             group_id: GroupId::SessionConfig,
7313             message_type: MessageType::Response,
7314             opcode: self.opcode,
7315             child: UciControlPacketDataChild::UciResponse(uciresponse),
7316         };
7317         SessionConfigResponse::new(ucicontrolpacket).unwrap()
7318     }
7319 }
7320 impl From<SessionConfigResponseBuilder> for UciControlPacket {
from(builder: SessionConfigResponseBuilder) -> UciControlPacket7321     fn from(builder: SessionConfigResponseBuilder) -> UciControlPacket {
7322         builder.build().into()
7323     }
7324 }
7325 impl From<SessionConfigResponseBuilder> for UciResponse {
from(builder: SessionConfigResponseBuilder) -> UciResponse7326     fn from(builder: SessionConfigResponseBuilder) -> UciResponse {
7327         builder.build().into()
7328     }
7329 }
7330 impl From<SessionConfigResponseBuilder> for SessionConfigResponse {
from(builder: SessionConfigResponseBuilder) -> SessionConfigResponse7331     fn from(builder: SessionConfigResponseBuilder) -> SessionConfigResponse {
7332         builder.build().into()
7333     }
7334 }
7335 #[derive(Debug, Clone, PartialEq, Eq)]
7336 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7337 pub enum SessionConfigNotificationDataChild {
7338     SessionStatusNtf(SessionStatusNtfData),
7339     SessionUpdateControllerMulticastListNtf(SessionUpdateControllerMulticastListNtfData),
7340     SessionDataTransferPhaseConfigNtf(SessionDataTransferPhaseConfigNtfData),
7341     Payload(Bytes),
7342     None,
7343 }
7344 impl SessionConfigNotificationDataChild {
get_total_size(&self) -> usize7345     fn get_total_size(&self) -> usize {
7346         match self {
7347             SessionConfigNotificationDataChild::SessionStatusNtf(value) => {
7348                 value.get_total_size()
7349             }
7350             SessionConfigNotificationDataChild::SessionUpdateControllerMulticastListNtf(
7351                 value,
7352             ) => value.get_total_size(),
7353             SessionConfigNotificationDataChild::SessionDataTransferPhaseConfigNtf(
7354                 value,
7355             ) => value.get_total_size(),
7356             SessionConfigNotificationDataChild::Payload(bytes) => bytes.len(),
7357             SessionConfigNotificationDataChild::None => 0,
7358         }
7359     }
7360 }
7361 #[derive(Debug, Clone, PartialEq, Eq)]
7362 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7363 pub enum SessionConfigNotificationChild {
7364     SessionStatusNtf(SessionStatusNtf),
7365     SessionUpdateControllerMulticastListNtf(SessionUpdateControllerMulticastListNtf),
7366     SessionDataTransferPhaseConfigNtf(SessionDataTransferPhaseConfigNtf),
7367     Payload(Bytes),
7368     None,
7369 }
7370 #[derive(Debug, Clone, PartialEq, Eq)]
7371 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7372 pub struct SessionConfigNotificationData {
7373     child: SessionConfigNotificationDataChild,
7374 }
7375 #[derive(Debug, Clone, PartialEq, Eq)]
7376 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7377 pub struct SessionConfigNotification {
7378     #[cfg_attr(feature = "serde", serde(flatten))]
7379     ucicontrolpacket: UciControlPacketData,
7380     #[cfg_attr(feature = "serde", serde(flatten))]
7381     ucinotification: UciNotificationData,
7382     #[cfg_attr(feature = "serde", serde(flatten))]
7383     sessionconfignotification: SessionConfigNotificationData,
7384 }
7385 #[derive(Debug)]
7386 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7387 pub struct SessionConfigNotificationBuilder {
7388     pub opcode: u8,
7389     pub payload: Option<Bytes>,
7390 }
7391 impl SessionConfigNotificationData {
conforms(bytes: &[u8]) -> bool7392     fn conforms(bytes: &[u8]) -> bool {
7393         true
7394     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>7395     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
7396         let mut cell = Cell::new(bytes);
7397         let packet = Self::parse_inner(&mut cell, opcode)?;
7398         Ok(packet)
7399     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>7400     fn parse_inner(
7401         mut bytes: &mut Cell<&[u8]>,
7402         opcode: u8,
7403     ) -> Result<Self, DecodeError> {
7404         let payload = bytes.get();
7405         bytes.get_mut().advance(payload.len());
7406         let child = match (opcode) {
7407             (2) if SessionStatusNtfData::conforms(&payload) => {
7408                 let mut cell = Cell::new(payload);
7409                 let child_data = SessionStatusNtfData::parse_inner(&mut cell)?;
7410                 SessionConfigNotificationDataChild::SessionStatusNtf(child_data)
7411             }
7412             (7) if SessionUpdateControllerMulticastListNtfData::conforms(&payload) => {
7413                 let mut cell = Cell::new(payload);
7414                 let child_data = SessionUpdateControllerMulticastListNtfData::parse_inner(
7415                     &mut cell,
7416                 )?;
7417                 SessionConfigNotificationDataChild::SessionUpdateControllerMulticastListNtf(
7418                     child_data,
7419                 )
7420             }
7421             (14) if SessionDataTransferPhaseConfigNtfData::conforms(&payload) => {
7422                 let mut cell = Cell::new(payload);
7423                 let child_data = SessionDataTransferPhaseConfigNtfData::parse_inner(
7424                     &mut cell,
7425                 )?;
7426                 SessionConfigNotificationDataChild::SessionDataTransferPhaseConfigNtf(
7427                     child_data,
7428                 )
7429             }
7430             _ if !payload.is_empty() => {
7431                 SessionConfigNotificationDataChild::Payload(
7432                     Bytes::copy_from_slice(payload),
7433                 )
7434             }
7435             _ => SessionConfigNotificationDataChild::None,
7436         };
7437         Ok(Self { child })
7438     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>7439     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
7440         match &self.child {
7441             SessionConfigNotificationDataChild::SessionStatusNtf(child) => {
7442                 child.write_to(buffer)?
7443             }
7444             SessionConfigNotificationDataChild::SessionUpdateControllerMulticastListNtf(
7445                 child,
7446             ) => child.write_to(buffer)?,
7447             SessionConfigNotificationDataChild::SessionDataTransferPhaseConfigNtf(
7448                 child,
7449             ) => child.write_to(buffer)?,
7450             SessionConfigNotificationDataChild::Payload(payload) => {
7451                 buffer.put_slice(payload)
7452             }
7453             SessionConfigNotificationDataChild::None => {}
7454         }
7455         Ok(())
7456     }
get_total_size(&self) -> usize7457     fn get_total_size(&self) -> usize {
7458         self.get_size()
7459     }
get_size(&self) -> usize7460     fn get_size(&self) -> usize {
7461         self.child.get_total_size()
7462     }
7463 }
7464 impl Packet for SessionConfigNotification {
encoded_len(&self) -> usize7465     fn encoded_len(&self) -> usize {
7466         self.get_size()
7467     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>7468     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
7469         self.ucicontrolpacket.write_to(buf)
7470     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>7471     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
7472         unimplemented!("Rust legacy does not implement full packet trait")
7473     }
7474 }
7475 impl TryFrom<SessionConfigNotification> for Bytes {
7476     type Error = EncodeError;
try_from(packet: SessionConfigNotification) -> Result<Self, Self::Error>7477     fn try_from(packet: SessionConfigNotification) -> Result<Self, Self::Error> {
7478         packet.encode_to_bytes()
7479     }
7480 }
7481 impl TryFrom<SessionConfigNotification> for Vec<u8> {
7482     type Error = EncodeError;
try_from(packet: SessionConfigNotification) -> Result<Self, Self::Error>7483     fn try_from(packet: SessionConfigNotification) -> Result<Self, Self::Error> {
7484         packet.encode_to_vec()
7485     }
7486 }
7487 impl From<SessionConfigNotification> for UciControlPacket {
from(packet: SessionConfigNotification) -> UciControlPacket7488     fn from(packet: SessionConfigNotification) -> UciControlPacket {
7489         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
7490     }
7491 }
7492 impl From<SessionConfigNotification> for UciNotification {
from(packet: SessionConfigNotification) -> UciNotification7493     fn from(packet: SessionConfigNotification) -> UciNotification {
7494         UciNotification::new(packet.ucicontrolpacket).unwrap()
7495     }
7496 }
7497 impl TryFrom<UciControlPacket> for SessionConfigNotification {
7498     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionConfigNotification, Self::Error>7499     fn try_from(
7500         packet: UciControlPacket,
7501     ) -> Result<SessionConfigNotification, Self::Error> {
7502         SessionConfigNotification::new(packet.ucicontrolpacket)
7503     }
7504 }
7505 impl SessionConfigNotification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>7506     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
7507         let mut cell = Cell::new(bytes);
7508         let packet = Self::parse_inner(&mut cell)?;
7509         Ok(packet)
7510     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>7511     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
7512         let data = UciControlPacketData::parse_inner(&mut bytes)?;
7513         Self::new(data)
7514     }
specialize(&self) -> SessionConfigNotificationChild7515     pub fn specialize(&self) -> SessionConfigNotificationChild {
7516         match &self.sessionconfignotification.child {
7517             SessionConfigNotificationDataChild::SessionStatusNtf(_) => {
7518                 SessionConfigNotificationChild::SessionStatusNtf(
7519                     SessionStatusNtf::new(self.ucicontrolpacket.clone()).unwrap(),
7520                 )
7521             }
7522             SessionConfigNotificationDataChild::SessionUpdateControllerMulticastListNtf(
7523                 _,
7524             ) => {
7525                 SessionConfigNotificationChild::SessionUpdateControllerMulticastListNtf(
7526                     SessionUpdateControllerMulticastListNtf::new(
7527                             self.ucicontrolpacket.clone(),
7528                         )
7529                         .unwrap(),
7530                 )
7531             }
7532             SessionConfigNotificationDataChild::SessionDataTransferPhaseConfigNtf(_) => {
7533                 SessionConfigNotificationChild::SessionDataTransferPhaseConfigNtf(
7534                     SessionDataTransferPhaseConfigNtf::new(self.ucicontrolpacket.clone())
7535                         .unwrap(),
7536                 )
7537             }
7538             SessionConfigNotificationDataChild::Payload(payload) => {
7539                 SessionConfigNotificationChild::Payload(payload.clone())
7540             }
7541             SessionConfigNotificationDataChild::None => {
7542                 SessionConfigNotificationChild::None
7543             }
7544         }
7545     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>7546     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
7547         let ucinotification = match &ucicontrolpacket.child {
7548             UciControlPacketDataChild::UciNotification(value) => value.clone(),
7549             _ => {
7550                 return Err(DecodeError::InvalidChildError {
7551                     expected: stringify!(UciControlPacketDataChild::UciNotification),
7552                     actual: format!("{:?}", & ucicontrolpacket.child),
7553                 });
7554             }
7555         };
7556         let sessionconfignotification = match &ucinotification.child {
7557             UciNotificationDataChild::SessionConfigNotification(value) => value.clone(),
7558             _ => {
7559                 return Err(DecodeError::InvalidChildError {
7560                     expected: stringify!(
7561                         UciNotificationDataChild::SessionConfigNotification
7562                     ),
7563                     actual: format!("{:?}", & ucinotification.child),
7564                 });
7565             }
7566         };
7567         Ok(Self {
7568             ucicontrolpacket,
7569             ucinotification,
7570             sessionconfignotification,
7571         })
7572     }
get_group_id(&self) -> GroupId7573     pub fn get_group_id(&self) -> GroupId {
7574         self.ucicontrolpacket.group_id
7575     }
get_message_type(&self) -> MessageType7576     pub fn get_message_type(&self) -> MessageType {
7577         self.ucicontrolpacket.message_type
7578     }
get_opcode(&self) -> u87579     pub fn get_opcode(&self) -> u8 {
7580         self.ucicontrolpacket.opcode
7581     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>7582     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
7583         self.sessionconfignotification.write_to(buffer)
7584     }
get_size(&self) -> usize7585     pub fn get_size(&self) -> usize {
7586         self.ucicontrolpacket.get_size()
7587     }
7588 }
7589 impl SessionConfigNotificationBuilder {
build(self) -> SessionConfigNotification7590     pub fn build(self) -> SessionConfigNotification {
7591         let sessionconfignotification = SessionConfigNotificationData {
7592             child: match self.payload {
7593                 None => SessionConfigNotificationDataChild::None,
7594                 Some(bytes) => SessionConfigNotificationDataChild::Payload(bytes),
7595             },
7596         };
7597         let ucinotification = UciNotificationData {
7598             child: UciNotificationDataChild::SessionConfigNotification(
7599                 sessionconfignotification,
7600             ),
7601         };
7602         let ucicontrolpacket = UciControlPacketData {
7603             group_id: GroupId::SessionConfig,
7604             message_type: MessageType::Notification,
7605             opcode: self.opcode,
7606             child: UciControlPacketDataChild::UciNotification(ucinotification),
7607         };
7608         SessionConfigNotification::new(ucicontrolpacket).unwrap()
7609     }
7610 }
7611 impl From<SessionConfigNotificationBuilder> for UciControlPacket {
from(builder: SessionConfigNotificationBuilder) -> UciControlPacket7612     fn from(builder: SessionConfigNotificationBuilder) -> UciControlPacket {
7613         builder.build().into()
7614     }
7615 }
7616 impl From<SessionConfigNotificationBuilder> for UciNotification {
from(builder: SessionConfigNotificationBuilder) -> UciNotification7617     fn from(builder: SessionConfigNotificationBuilder) -> UciNotification {
7618         builder.build().into()
7619     }
7620 }
7621 impl From<SessionConfigNotificationBuilder> for SessionConfigNotification {
from(builder: SessionConfigNotificationBuilder) -> SessionConfigNotification7622     fn from(builder: SessionConfigNotificationBuilder) -> SessionConfigNotification {
7623         builder.build().into()
7624     }
7625 }
7626 #[derive(Debug, Clone, PartialEq, Eq)]
7627 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7628 pub enum SessionControlCommandDataChild {
7629     SessionStartCmd(SessionStartCmdData),
7630     SessionStopCmd(SessionStopCmdData),
7631     SessionGetRangingCountCmd(SessionGetRangingCountCmdData),
7632     Payload(Bytes),
7633     None,
7634 }
7635 impl SessionControlCommandDataChild {
get_total_size(&self) -> usize7636     fn get_total_size(&self) -> usize {
7637         match self {
7638             SessionControlCommandDataChild::SessionStartCmd(value) => {
7639                 value.get_total_size()
7640             }
7641             SessionControlCommandDataChild::SessionStopCmd(value) => {
7642                 value.get_total_size()
7643             }
7644             SessionControlCommandDataChild::SessionGetRangingCountCmd(value) => {
7645                 value.get_total_size()
7646             }
7647             SessionControlCommandDataChild::Payload(bytes) => bytes.len(),
7648             SessionControlCommandDataChild::None => 0,
7649         }
7650     }
7651 }
7652 #[derive(Debug, Clone, PartialEq, Eq)]
7653 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7654 pub enum SessionControlCommandChild {
7655     SessionStartCmd(SessionStartCmd),
7656     SessionStopCmd(SessionStopCmd),
7657     SessionGetRangingCountCmd(SessionGetRangingCountCmd),
7658     Payload(Bytes),
7659     None,
7660 }
7661 #[derive(Debug, Clone, PartialEq, Eq)]
7662 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7663 pub struct SessionControlCommandData {
7664     child: SessionControlCommandDataChild,
7665 }
7666 #[derive(Debug, Clone, PartialEq, Eq)]
7667 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7668 pub struct SessionControlCommand {
7669     #[cfg_attr(feature = "serde", serde(flatten))]
7670     ucicontrolpacket: UciControlPacketData,
7671     #[cfg_attr(feature = "serde", serde(flatten))]
7672     ucicommand: UciCommandData,
7673     #[cfg_attr(feature = "serde", serde(flatten))]
7674     sessioncontrolcommand: SessionControlCommandData,
7675 }
7676 #[derive(Debug)]
7677 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7678 pub struct SessionControlCommandBuilder {
7679     pub opcode: u8,
7680     pub payload: Option<Bytes>,
7681 }
7682 impl SessionControlCommandData {
conforms(bytes: &[u8]) -> bool7683     fn conforms(bytes: &[u8]) -> bool {
7684         true
7685     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>7686     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
7687         let mut cell = Cell::new(bytes);
7688         let packet = Self::parse_inner(&mut cell, opcode)?;
7689         Ok(packet)
7690     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>7691     fn parse_inner(
7692         mut bytes: &mut Cell<&[u8]>,
7693         opcode: u8,
7694     ) -> Result<Self, DecodeError> {
7695         let payload = bytes.get();
7696         bytes.get_mut().advance(payload.len());
7697         let child = match (opcode) {
7698             (0) if SessionStartCmdData::conforms(&payload) => {
7699                 let mut cell = Cell::new(payload);
7700                 let child_data = SessionStartCmdData::parse_inner(&mut cell)?;
7701                 SessionControlCommandDataChild::SessionStartCmd(child_data)
7702             }
7703             (1) if SessionStopCmdData::conforms(&payload) => {
7704                 let mut cell = Cell::new(payload);
7705                 let child_data = SessionStopCmdData::parse_inner(&mut cell)?;
7706                 SessionControlCommandDataChild::SessionStopCmd(child_data)
7707             }
7708             (3) if SessionGetRangingCountCmdData::conforms(&payload) => {
7709                 let mut cell = Cell::new(payload);
7710                 let child_data = SessionGetRangingCountCmdData::parse_inner(&mut cell)?;
7711                 SessionControlCommandDataChild::SessionGetRangingCountCmd(child_data)
7712             }
7713             _ if !payload.is_empty() => {
7714                 SessionControlCommandDataChild::Payload(Bytes::copy_from_slice(payload))
7715             }
7716             _ => SessionControlCommandDataChild::None,
7717         };
7718         Ok(Self { child })
7719     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>7720     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
7721         match &self.child {
7722             SessionControlCommandDataChild::SessionStartCmd(child) => {
7723                 child.write_to(buffer)?
7724             }
7725             SessionControlCommandDataChild::SessionStopCmd(child) => {
7726                 child.write_to(buffer)?
7727             }
7728             SessionControlCommandDataChild::SessionGetRangingCountCmd(child) => {
7729                 child.write_to(buffer)?
7730             }
7731             SessionControlCommandDataChild::Payload(payload) => buffer.put_slice(payload),
7732             SessionControlCommandDataChild::None => {}
7733         }
7734         Ok(())
7735     }
get_total_size(&self) -> usize7736     fn get_total_size(&self) -> usize {
7737         self.get_size()
7738     }
get_size(&self) -> usize7739     fn get_size(&self) -> usize {
7740         self.child.get_total_size()
7741     }
7742 }
7743 impl Packet for SessionControlCommand {
encoded_len(&self) -> usize7744     fn encoded_len(&self) -> usize {
7745         self.get_size()
7746     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>7747     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
7748         self.ucicontrolpacket.write_to(buf)
7749     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>7750     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
7751         unimplemented!("Rust legacy does not implement full packet trait")
7752     }
7753 }
7754 impl TryFrom<SessionControlCommand> for Bytes {
7755     type Error = EncodeError;
try_from(packet: SessionControlCommand) -> Result<Self, Self::Error>7756     fn try_from(packet: SessionControlCommand) -> Result<Self, Self::Error> {
7757         packet.encode_to_bytes()
7758     }
7759 }
7760 impl TryFrom<SessionControlCommand> for Vec<u8> {
7761     type Error = EncodeError;
try_from(packet: SessionControlCommand) -> Result<Self, Self::Error>7762     fn try_from(packet: SessionControlCommand) -> Result<Self, Self::Error> {
7763         packet.encode_to_vec()
7764     }
7765 }
7766 impl From<SessionControlCommand> for UciControlPacket {
from(packet: SessionControlCommand) -> UciControlPacket7767     fn from(packet: SessionControlCommand) -> UciControlPacket {
7768         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
7769     }
7770 }
7771 impl From<SessionControlCommand> for UciCommand {
from(packet: SessionControlCommand) -> UciCommand7772     fn from(packet: SessionControlCommand) -> UciCommand {
7773         UciCommand::new(packet.ucicontrolpacket).unwrap()
7774     }
7775 }
7776 impl TryFrom<UciControlPacket> for SessionControlCommand {
7777     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionControlCommand, Self::Error>7778     fn try_from(packet: UciControlPacket) -> Result<SessionControlCommand, Self::Error> {
7779         SessionControlCommand::new(packet.ucicontrolpacket)
7780     }
7781 }
7782 impl SessionControlCommand {
parse(bytes: &[u8]) -> Result<Self, DecodeError>7783     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
7784         let mut cell = Cell::new(bytes);
7785         let packet = Self::parse_inner(&mut cell)?;
7786         Ok(packet)
7787     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>7788     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
7789         let data = UciControlPacketData::parse_inner(&mut bytes)?;
7790         Self::new(data)
7791     }
specialize(&self) -> SessionControlCommandChild7792     pub fn specialize(&self) -> SessionControlCommandChild {
7793         match &self.sessioncontrolcommand.child {
7794             SessionControlCommandDataChild::SessionStartCmd(_) => {
7795                 SessionControlCommandChild::SessionStartCmd(
7796                     SessionStartCmd::new(self.ucicontrolpacket.clone()).unwrap(),
7797                 )
7798             }
7799             SessionControlCommandDataChild::SessionStopCmd(_) => {
7800                 SessionControlCommandChild::SessionStopCmd(
7801                     SessionStopCmd::new(self.ucicontrolpacket.clone()).unwrap(),
7802                 )
7803             }
7804             SessionControlCommandDataChild::SessionGetRangingCountCmd(_) => {
7805                 SessionControlCommandChild::SessionGetRangingCountCmd(
7806                     SessionGetRangingCountCmd::new(self.ucicontrolpacket.clone())
7807                         .unwrap(),
7808                 )
7809             }
7810             SessionControlCommandDataChild::Payload(payload) => {
7811                 SessionControlCommandChild::Payload(payload.clone())
7812             }
7813             SessionControlCommandDataChild::None => SessionControlCommandChild::None,
7814         }
7815     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>7816     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
7817         let ucicommand = match &ucicontrolpacket.child {
7818             UciControlPacketDataChild::UciCommand(value) => value.clone(),
7819             _ => {
7820                 return Err(DecodeError::InvalidChildError {
7821                     expected: stringify!(UciControlPacketDataChild::UciCommand),
7822                     actual: format!("{:?}", & ucicontrolpacket.child),
7823                 });
7824             }
7825         };
7826         let sessioncontrolcommand = match &ucicommand.child {
7827             UciCommandDataChild::SessionControlCommand(value) => value.clone(),
7828             _ => {
7829                 return Err(DecodeError::InvalidChildError {
7830                     expected: stringify!(UciCommandDataChild::SessionControlCommand),
7831                     actual: format!("{:?}", & ucicommand.child),
7832                 });
7833             }
7834         };
7835         Ok(Self {
7836             ucicontrolpacket,
7837             ucicommand,
7838             sessioncontrolcommand,
7839         })
7840     }
get_group_id(&self) -> GroupId7841     pub fn get_group_id(&self) -> GroupId {
7842         self.ucicontrolpacket.group_id
7843     }
get_message_type(&self) -> MessageType7844     pub fn get_message_type(&self) -> MessageType {
7845         self.ucicontrolpacket.message_type
7846     }
get_opcode(&self) -> u87847     pub fn get_opcode(&self) -> u8 {
7848         self.ucicontrolpacket.opcode
7849     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>7850     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
7851         self.sessioncontrolcommand.write_to(buffer)
7852     }
get_size(&self) -> usize7853     pub fn get_size(&self) -> usize {
7854         self.ucicontrolpacket.get_size()
7855     }
7856 }
7857 impl SessionControlCommandBuilder {
build(self) -> SessionControlCommand7858     pub fn build(self) -> SessionControlCommand {
7859         let sessioncontrolcommand = SessionControlCommandData {
7860             child: match self.payload {
7861                 None => SessionControlCommandDataChild::None,
7862                 Some(bytes) => SessionControlCommandDataChild::Payload(bytes),
7863             },
7864         };
7865         let ucicommand = UciCommandData {
7866             child: UciCommandDataChild::SessionControlCommand(sessioncontrolcommand),
7867         };
7868         let ucicontrolpacket = UciControlPacketData {
7869             group_id: GroupId::SessionControl,
7870             message_type: MessageType::Command,
7871             opcode: self.opcode,
7872             child: UciControlPacketDataChild::UciCommand(ucicommand),
7873         };
7874         SessionControlCommand::new(ucicontrolpacket).unwrap()
7875     }
7876 }
7877 impl From<SessionControlCommandBuilder> for UciControlPacket {
from(builder: SessionControlCommandBuilder) -> UciControlPacket7878     fn from(builder: SessionControlCommandBuilder) -> UciControlPacket {
7879         builder.build().into()
7880     }
7881 }
7882 impl From<SessionControlCommandBuilder> for UciCommand {
from(builder: SessionControlCommandBuilder) -> UciCommand7883     fn from(builder: SessionControlCommandBuilder) -> UciCommand {
7884         builder.build().into()
7885     }
7886 }
7887 impl From<SessionControlCommandBuilder> for SessionControlCommand {
from(builder: SessionControlCommandBuilder) -> SessionControlCommand7888     fn from(builder: SessionControlCommandBuilder) -> SessionControlCommand {
7889         builder.build().into()
7890     }
7891 }
7892 #[derive(Debug, Clone, PartialEq, Eq)]
7893 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7894 pub enum SessionControlResponseDataChild {
7895     SessionStartRsp(SessionStartRspData),
7896     SessionStopRsp(SessionStopRspData),
7897     SessionGetRangingCountRsp(SessionGetRangingCountRspData),
7898     Payload(Bytes),
7899     None,
7900 }
7901 impl SessionControlResponseDataChild {
get_total_size(&self) -> usize7902     fn get_total_size(&self) -> usize {
7903         match self {
7904             SessionControlResponseDataChild::SessionStartRsp(value) => {
7905                 value.get_total_size()
7906             }
7907             SessionControlResponseDataChild::SessionStopRsp(value) => {
7908                 value.get_total_size()
7909             }
7910             SessionControlResponseDataChild::SessionGetRangingCountRsp(value) => {
7911                 value.get_total_size()
7912             }
7913             SessionControlResponseDataChild::Payload(bytes) => bytes.len(),
7914             SessionControlResponseDataChild::None => 0,
7915         }
7916     }
7917 }
7918 #[derive(Debug, Clone, PartialEq, Eq)]
7919 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7920 pub enum SessionControlResponseChild {
7921     SessionStartRsp(SessionStartRsp),
7922     SessionStopRsp(SessionStopRsp),
7923     SessionGetRangingCountRsp(SessionGetRangingCountRsp),
7924     Payload(Bytes),
7925     None,
7926 }
7927 #[derive(Debug, Clone, PartialEq, Eq)]
7928 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7929 pub struct SessionControlResponseData {
7930     child: SessionControlResponseDataChild,
7931 }
7932 #[derive(Debug, Clone, PartialEq, Eq)]
7933 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7934 pub struct SessionControlResponse {
7935     #[cfg_attr(feature = "serde", serde(flatten))]
7936     ucicontrolpacket: UciControlPacketData,
7937     #[cfg_attr(feature = "serde", serde(flatten))]
7938     uciresponse: UciResponseData,
7939     #[cfg_attr(feature = "serde", serde(flatten))]
7940     sessioncontrolresponse: SessionControlResponseData,
7941 }
7942 #[derive(Debug)]
7943 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
7944 pub struct SessionControlResponseBuilder {
7945     pub opcode: u8,
7946     pub payload: Option<Bytes>,
7947 }
7948 impl SessionControlResponseData {
conforms(bytes: &[u8]) -> bool7949     fn conforms(bytes: &[u8]) -> bool {
7950         true
7951     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>7952     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
7953         let mut cell = Cell::new(bytes);
7954         let packet = Self::parse_inner(&mut cell, opcode)?;
7955         Ok(packet)
7956     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>7957     fn parse_inner(
7958         mut bytes: &mut Cell<&[u8]>,
7959         opcode: u8,
7960     ) -> Result<Self, DecodeError> {
7961         let payload = bytes.get();
7962         bytes.get_mut().advance(payload.len());
7963         let child = match (opcode) {
7964             (0) if SessionStartRspData::conforms(&payload) => {
7965                 let mut cell = Cell::new(payload);
7966                 let child_data = SessionStartRspData::parse_inner(&mut cell)?;
7967                 SessionControlResponseDataChild::SessionStartRsp(child_data)
7968             }
7969             (1) if SessionStopRspData::conforms(&payload) => {
7970                 let mut cell = Cell::new(payload);
7971                 let child_data = SessionStopRspData::parse_inner(&mut cell)?;
7972                 SessionControlResponseDataChild::SessionStopRsp(child_data)
7973             }
7974             (3) if SessionGetRangingCountRspData::conforms(&payload) => {
7975                 let mut cell = Cell::new(payload);
7976                 let child_data = SessionGetRangingCountRspData::parse_inner(&mut cell)?;
7977                 SessionControlResponseDataChild::SessionGetRangingCountRsp(child_data)
7978             }
7979             _ if !payload.is_empty() => {
7980                 SessionControlResponseDataChild::Payload(Bytes::copy_from_slice(payload))
7981             }
7982             _ => SessionControlResponseDataChild::None,
7983         };
7984         Ok(Self { child })
7985     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>7986     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
7987         match &self.child {
7988             SessionControlResponseDataChild::SessionStartRsp(child) => {
7989                 child.write_to(buffer)?
7990             }
7991             SessionControlResponseDataChild::SessionStopRsp(child) => {
7992                 child.write_to(buffer)?
7993             }
7994             SessionControlResponseDataChild::SessionGetRangingCountRsp(child) => {
7995                 child.write_to(buffer)?
7996             }
7997             SessionControlResponseDataChild::Payload(payload) => {
7998                 buffer.put_slice(payload)
7999             }
8000             SessionControlResponseDataChild::None => {}
8001         }
8002         Ok(())
8003     }
get_total_size(&self) -> usize8004     fn get_total_size(&self) -> usize {
8005         self.get_size()
8006     }
get_size(&self) -> usize8007     fn get_size(&self) -> usize {
8008         self.child.get_total_size()
8009     }
8010 }
8011 impl Packet for SessionControlResponse {
encoded_len(&self) -> usize8012     fn encoded_len(&self) -> usize {
8013         self.get_size()
8014     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>8015     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
8016         self.ucicontrolpacket.write_to(buf)
8017     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>8018     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
8019         unimplemented!("Rust legacy does not implement full packet trait")
8020     }
8021 }
8022 impl TryFrom<SessionControlResponse> for Bytes {
8023     type Error = EncodeError;
try_from(packet: SessionControlResponse) -> Result<Self, Self::Error>8024     fn try_from(packet: SessionControlResponse) -> Result<Self, Self::Error> {
8025         packet.encode_to_bytes()
8026     }
8027 }
8028 impl TryFrom<SessionControlResponse> for Vec<u8> {
8029     type Error = EncodeError;
try_from(packet: SessionControlResponse) -> Result<Self, Self::Error>8030     fn try_from(packet: SessionControlResponse) -> Result<Self, Self::Error> {
8031         packet.encode_to_vec()
8032     }
8033 }
8034 impl From<SessionControlResponse> for UciControlPacket {
from(packet: SessionControlResponse) -> UciControlPacket8035     fn from(packet: SessionControlResponse) -> UciControlPacket {
8036         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
8037     }
8038 }
8039 impl From<SessionControlResponse> for UciResponse {
from(packet: SessionControlResponse) -> UciResponse8040     fn from(packet: SessionControlResponse) -> UciResponse {
8041         UciResponse::new(packet.ucicontrolpacket).unwrap()
8042     }
8043 }
8044 impl TryFrom<UciControlPacket> for SessionControlResponse {
8045     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionControlResponse, Self::Error>8046     fn try_from(
8047         packet: UciControlPacket,
8048     ) -> Result<SessionControlResponse, Self::Error> {
8049         SessionControlResponse::new(packet.ucicontrolpacket)
8050     }
8051 }
8052 impl SessionControlResponse {
parse(bytes: &[u8]) -> Result<Self, DecodeError>8053     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
8054         let mut cell = Cell::new(bytes);
8055         let packet = Self::parse_inner(&mut cell)?;
8056         Ok(packet)
8057     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>8058     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
8059         let data = UciControlPacketData::parse_inner(&mut bytes)?;
8060         Self::new(data)
8061     }
specialize(&self) -> SessionControlResponseChild8062     pub fn specialize(&self) -> SessionControlResponseChild {
8063         match &self.sessioncontrolresponse.child {
8064             SessionControlResponseDataChild::SessionStartRsp(_) => {
8065                 SessionControlResponseChild::SessionStartRsp(
8066                     SessionStartRsp::new(self.ucicontrolpacket.clone()).unwrap(),
8067                 )
8068             }
8069             SessionControlResponseDataChild::SessionStopRsp(_) => {
8070                 SessionControlResponseChild::SessionStopRsp(
8071                     SessionStopRsp::new(self.ucicontrolpacket.clone()).unwrap(),
8072                 )
8073             }
8074             SessionControlResponseDataChild::SessionGetRangingCountRsp(_) => {
8075                 SessionControlResponseChild::SessionGetRangingCountRsp(
8076                     SessionGetRangingCountRsp::new(self.ucicontrolpacket.clone())
8077                         .unwrap(),
8078                 )
8079             }
8080             SessionControlResponseDataChild::Payload(payload) => {
8081                 SessionControlResponseChild::Payload(payload.clone())
8082             }
8083             SessionControlResponseDataChild::None => SessionControlResponseChild::None,
8084         }
8085     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>8086     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
8087         let uciresponse = match &ucicontrolpacket.child {
8088             UciControlPacketDataChild::UciResponse(value) => value.clone(),
8089             _ => {
8090                 return Err(DecodeError::InvalidChildError {
8091                     expected: stringify!(UciControlPacketDataChild::UciResponse),
8092                     actual: format!("{:?}", & ucicontrolpacket.child),
8093                 });
8094             }
8095         };
8096         let sessioncontrolresponse = match &uciresponse.child {
8097             UciResponseDataChild::SessionControlResponse(value) => value.clone(),
8098             _ => {
8099                 return Err(DecodeError::InvalidChildError {
8100                     expected: stringify!(UciResponseDataChild::SessionControlResponse),
8101                     actual: format!("{:?}", & uciresponse.child),
8102                 });
8103             }
8104         };
8105         Ok(Self {
8106             ucicontrolpacket,
8107             uciresponse,
8108             sessioncontrolresponse,
8109         })
8110     }
get_group_id(&self) -> GroupId8111     pub fn get_group_id(&self) -> GroupId {
8112         self.ucicontrolpacket.group_id
8113     }
get_message_type(&self) -> MessageType8114     pub fn get_message_type(&self) -> MessageType {
8115         self.ucicontrolpacket.message_type
8116     }
get_opcode(&self) -> u88117     pub fn get_opcode(&self) -> u8 {
8118         self.ucicontrolpacket.opcode
8119     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>8120     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
8121         self.sessioncontrolresponse.write_to(buffer)
8122     }
get_size(&self) -> usize8123     pub fn get_size(&self) -> usize {
8124         self.ucicontrolpacket.get_size()
8125     }
8126 }
8127 impl SessionControlResponseBuilder {
build(self) -> SessionControlResponse8128     pub fn build(self) -> SessionControlResponse {
8129         let sessioncontrolresponse = SessionControlResponseData {
8130             child: match self.payload {
8131                 None => SessionControlResponseDataChild::None,
8132                 Some(bytes) => SessionControlResponseDataChild::Payload(bytes),
8133             },
8134         };
8135         let uciresponse = UciResponseData {
8136             child: UciResponseDataChild::SessionControlResponse(sessioncontrolresponse),
8137         };
8138         let ucicontrolpacket = UciControlPacketData {
8139             group_id: GroupId::SessionControl,
8140             message_type: MessageType::Response,
8141             opcode: self.opcode,
8142             child: UciControlPacketDataChild::UciResponse(uciresponse),
8143         };
8144         SessionControlResponse::new(ucicontrolpacket).unwrap()
8145     }
8146 }
8147 impl From<SessionControlResponseBuilder> for UciControlPacket {
from(builder: SessionControlResponseBuilder) -> UciControlPacket8148     fn from(builder: SessionControlResponseBuilder) -> UciControlPacket {
8149         builder.build().into()
8150     }
8151 }
8152 impl From<SessionControlResponseBuilder> for UciResponse {
from(builder: SessionControlResponseBuilder) -> UciResponse8153     fn from(builder: SessionControlResponseBuilder) -> UciResponse {
8154         builder.build().into()
8155     }
8156 }
8157 impl From<SessionControlResponseBuilder> for SessionControlResponse {
from(builder: SessionControlResponseBuilder) -> SessionControlResponse8158     fn from(builder: SessionControlResponseBuilder) -> SessionControlResponse {
8159         builder.build().into()
8160     }
8161 }
8162 #[derive(Debug, Clone, PartialEq, Eq)]
8163 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8164 pub enum SessionControlNotificationDataChild {
8165     DataCreditNtf(DataCreditNtfData),
8166     DataTransferStatusNtf(DataTransferStatusNtfData),
8167     SessionInfoNtf(SessionInfoNtfData),
8168     Payload(Bytes),
8169     None,
8170 }
8171 impl SessionControlNotificationDataChild {
get_total_size(&self) -> usize8172     fn get_total_size(&self) -> usize {
8173         match self {
8174             SessionControlNotificationDataChild::DataCreditNtf(value) => {
8175                 value.get_total_size()
8176             }
8177             SessionControlNotificationDataChild::DataTransferStatusNtf(value) => {
8178                 value.get_total_size()
8179             }
8180             SessionControlNotificationDataChild::SessionInfoNtf(value) => {
8181                 value.get_total_size()
8182             }
8183             SessionControlNotificationDataChild::Payload(bytes) => bytes.len(),
8184             SessionControlNotificationDataChild::None => 0,
8185         }
8186     }
8187 }
8188 #[derive(Debug, Clone, PartialEq, Eq)]
8189 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8190 pub enum SessionControlNotificationChild {
8191     DataCreditNtf(DataCreditNtf),
8192     DataTransferStatusNtf(DataTransferStatusNtf),
8193     SessionInfoNtf(SessionInfoNtf),
8194     Payload(Bytes),
8195     None,
8196 }
8197 #[derive(Debug, Clone, PartialEq, Eq)]
8198 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8199 pub struct SessionControlNotificationData {
8200     child: SessionControlNotificationDataChild,
8201 }
8202 #[derive(Debug, Clone, PartialEq, Eq)]
8203 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8204 pub struct SessionControlNotification {
8205     #[cfg_attr(feature = "serde", serde(flatten))]
8206     ucicontrolpacket: UciControlPacketData,
8207     #[cfg_attr(feature = "serde", serde(flatten))]
8208     ucinotification: UciNotificationData,
8209     #[cfg_attr(feature = "serde", serde(flatten))]
8210     sessioncontrolnotification: SessionControlNotificationData,
8211 }
8212 #[derive(Debug)]
8213 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8214 pub struct SessionControlNotificationBuilder {
8215     pub opcode: u8,
8216     pub payload: Option<Bytes>,
8217 }
8218 impl SessionControlNotificationData {
conforms(bytes: &[u8]) -> bool8219     fn conforms(bytes: &[u8]) -> bool {
8220         true
8221     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>8222     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
8223         let mut cell = Cell::new(bytes);
8224         let packet = Self::parse_inner(&mut cell, opcode)?;
8225         Ok(packet)
8226     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>8227     fn parse_inner(
8228         mut bytes: &mut Cell<&[u8]>,
8229         opcode: u8,
8230     ) -> Result<Self, DecodeError> {
8231         let payload = bytes.get();
8232         bytes.get_mut().advance(payload.len());
8233         let child = match (opcode) {
8234             (4) if DataCreditNtfData::conforms(&payload) => {
8235                 let mut cell = Cell::new(payload);
8236                 let child_data = DataCreditNtfData::parse_inner(&mut cell)?;
8237                 SessionControlNotificationDataChild::DataCreditNtf(child_data)
8238             }
8239             (5) if DataTransferStatusNtfData::conforms(&payload) => {
8240                 let mut cell = Cell::new(payload);
8241                 let child_data = DataTransferStatusNtfData::parse_inner(&mut cell)?;
8242                 SessionControlNotificationDataChild::DataTransferStatusNtf(child_data)
8243             }
8244             (0) if SessionInfoNtfData::conforms(&payload) => {
8245                 let mut cell = Cell::new(payload);
8246                 let child_data = SessionInfoNtfData::parse_inner(&mut cell)?;
8247                 SessionControlNotificationDataChild::SessionInfoNtf(child_data)
8248             }
8249             _ if !payload.is_empty() => {
8250                 SessionControlNotificationDataChild::Payload(
8251                     Bytes::copy_from_slice(payload),
8252                 )
8253             }
8254             _ => SessionControlNotificationDataChild::None,
8255         };
8256         Ok(Self { child })
8257     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>8258     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
8259         match &self.child {
8260             SessionControlNotificationDataChild::DataCreditNtf(child) => {
8261                 child.write_to(buffer)?
8262             }
8263             SessionControlNotificationDataChild::DataTransferStatusNtf(child) => {
8264                 child.write_to(buffer)?
8265             }
8266             SessionControlNotificationDataChild::SessionInfoNtf(child) => {
8267                 child.write_to(buffer)?
8268             }
8269             SessionControlNotificationDataChild::Payload(payload) => {
8270                 buffer.put_slice(payload)
8271             }
8272             SessionControlNotificationDataChild::None => {}
8273         }
8274         Ok(())
8275     }
get_total_size(&self) -> usize8276     fn get_total_size(&self) -> usize {
8277         self.get_size()
8278     }
get_size(&self) -> usize8279     fn get_size(&self) -> usize {
8280         self.child.get_total_size()
8281     }
8282 }
8283 impl Packet for SessionControlNotification {
encoded_len(&self) -> usize8284     fn encoded_len(&self) -> usize {
8285         self.get_size()
8286     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>8287     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
8288         self.ucicontrolpacket.write_to(buf)
8289     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>8290     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
8291         unimplemented!("Rust legacy does not implement full packet trait")
8292     }
8293 }
8294 impl TryFrom<SessionControlNotification> for Bytes {
8295     type Error = EncodeError;
try_from(packet: SessionControlNotification) -> Result<Self, Self::Error>8296     fn try_from(packet: SessionControlNotification) -> Result<Self, Self::Error> {
8297         packet.encode_to_bytes()
8298     }
8299 }
8300 impl TryFrom<SessionControlNotification> for Vec<u8> {
8301     type Error = EncodeError;
try_from(packet: SessionControlNotification) -> Result<Self, Self::Error>8302     fn try_from(packet: SessionControlNotification) -> Result<Self, Self::Error> {
8303         packet.encode_to_vec()
8304     }
8305 }
8306 impl From<SessionControlNotification> for UciControlPacket {
from(packet: SessionControlNotification) -> UciControlPacket8307     fn from(packet: SessionControlNotification) -> UciControlPacket {
8308         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
8309     }
8310 }
8311 impl From<SessionControlNotification> for UciNotification {
from(packet: SessionControlNotification) -> UciNotification8312     fn from(packet: SessionControlNotification) -> UciNotification {
8313         UciNotification::new(packet.ucicontrolpacket).unwrap()
8314     }
8315 }
8316 impl TryFrom<UciControlPacket> for SessionControlNotification {
8317     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionControlNotification, Self::Error>8318     fn try_from(
8319         packet: UciControlPacket,
8320     ) -> Result<SessionControlNotification, Self::Error> {
8321         SessionControlNotification::new(packet.ucicontrolpacket)
8322     }
8323 }
8324 impl SessionControlNotification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>8325     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
8326         let mut cell = Cell::new(bytes);
8327         let packet = Self::parse_inner(&mut cell)?;
8328         Ok(packet)
8329     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>8330     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
8331         let data = UciControlPacketData::parse_inner(&mut bytes)?;
8332         Self::new(data)
8333     }
specialize(&self) -> SessionControlNotificationChild8334     pub fn specialize(&self) -> SessionControlNotificationChild {
8335         match &self.sessioncontrolnotification.child {
8336             SessionControlNotificationDataChild::DataCreditNtf(_) => {
8337                 SessionControlNotificationChild::DataCreditNtf(
8338                     DataCreditNtf::new(self.ucicontrolpacket.clone()).unwrap(),
8339                 )
8340             }
8341             SessionControlNotificationDataChild::DataTransferStatusNtf(_) => {
8342                 SessionControlNotificationChild::DataTransferStatusNtf(
8343                     DataTransferStatusNtf::new(self.ucicontrolpacket.clone()).unwrap(),
8344                 )
8345             }
8346             SessionControlNotificationDataChild::SessionInfoNtf(_) => {
8347                 SessionControlNotificationChild::SessionInfoNtf(
8348                     SessionInfoNtf::new(self.ucicontrolpacket.clone()).unwrap(),
8349                 )
8350             }
8351             SessionControlNotificationDataChild::Payload(payload) => {
8352                 SessionControlNotificationChild::Payload(payload.clone())
8353             }
8354             SessionControlNotificationDataChild::None => {
8355                 SessionControlNotificationChild::None
8356             }
8357         }
8358     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>8359     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
8360         let ucinotification = match &ucicontrolpacket.child {
8361             UciControlPacketDataChild::UciNotification(value) => value.clone(),
8362             _ => {
8363                 return Err(DecodeError::InvalidChildError {
8364                     expected: stringify!(UciControlPacketDataChild::UciNotification),
8365                     actual: format!("{:?}", & ucicontrolpacket.child),
8366                 });
8367             }
8368         };
8369         let sessioncontrolnotification = match &ucinotification.child {
8370             UciNotificationDataChild::SessionControlNotification(value) => value.clone(),
8371             _ => {
8372                 return Err(DecodeError::InvalidChildError {
8373                     expected: stringify!(
8374                         UciNotificationDataChild::SessionControlNotification
8375                     ),
8376                     actual: format!("{:?}", & ucinotification.child),
8377                 });
8378             }
8379         };
8380         Ok(Self {
8381             ucicontrolpacket,
8382             ucinotification,
8383             sessioncontrolnotification,
8384         })
8385     }
get_group_id(&self) -> GroupId8386     pub fn get_group_id(&self) -> GroupId {
8387         self.ucicontrolpacket.group_id
8388     }
get_message_type(&self) -> MessageType8389     pub fn get_message_type(&self) -> MessageType {
8390         self.ucicontrolpacket.message_type
8391     }
get_opcode(&self) -> u88392     pub fn get_opcode(&self) -> u8 {
8393         self.ucicontrolpacket.opcode
8394     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>8395     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
8396         self.sessioncontrolnotification.write_to(buffer)
8397     }
get_size(&self) -> usize8398     pub fn get_size(&self) -> usize {
8399         self.ucicontrolpacket.get_size()
8400     }
8401 }
8402 impl SessionControlNotificationBuilder {
build(self) -> SessionControlNotification8403     pub fn build(self) -> SessionControlNotification {
8404         let sessioncontrolnotification = SessionControlNotificationData {
8405             child: match self.payload {
8406                 None => SessionControlNotificationDataChild::None,
8407                 Some(bytes) => SessionControlNotificationDataChild::Payload(bytes),
8408             },
8409         };
8410         let ucinotification = UciNotificationData {
8411             child: UciNotificationDataChild::SessionControlNotification(
8412                 sessioncontrolnotification,
8413             ),
8414         };
8415         let ucicontrolpacket = UciControlPacketData {
8416             group_id: GroupId::SessionControl,
8417             message_type: MessageType::Notification,
8418             opcode: self.opcode,
8419             child: UciControlPacketDataChild::UciNotification(ucinotification),
8420         };
8421         SessionControlNotification::new(ucicontrolpacket).unwrap()
8422     }
8423 }
8424 impl From<SessionControlNotificationBuilder> for UciControlPacket {
from(builder: SessionControlNotificationBuilder) -> UciControlPacket8425     fn from(builder: SessionControlNotificationBuilder) -> UciControlPacket {
8426         builder.build().into()
8427     }
8428 }
8429 impl From<SessionControlNotificationBuilder> for UciNotification {
from(builder: SessionControlNotificationBuilder) -> UciNotification8430     fn from(builder: SessionControlNotificationBuilder) -> UciNotification {
8431         builder.build().into()
8432     }
8433 }
8434 impl From<SessionControlNotificationBuilder> for SessionControlNotification {
from(builder: SessionControlNotificationBuilder) -> SessionControlNotification8435     fn from(builder: SessionControlNotificationBuilder) -> SessionControlNotification {
8436         builder.build().into()
8437     }
8438 }
8439 #[derive(Debug, Clone, PartialEq, Eq)]
8440 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8441 pub enum AndroidCommandDataChild {
8442     AndroidGetPowerStatsCmd(AndroidGetPowerStatsCmdData),
8443     AndroidSetCountryCodeCmd(AndroidSetCountryCodeCmdData),
8444     AndroidSetRadarConfigCmd(AndroidSetRadarConfigCmdData),
8445     AndroidGetRadarConfigCmd(AndroidGetRadarConfigCmdData),
8446     Payload(Bytes),
8447     None,
8448 }
8449 impl AndroidCommandDataChild {
get_total_size(&self) -> usize8450     fn get_total_size(&self) -> usize {
8451         match self {
8452             AndroidCommandDataChild::AndroidGetPowerStatsCmd(value) => {
8453                 value.get_total_size()
8454             }
8455             AndroidCommandDataChild::AndroidSetCountryCodeCmd(value) => {
8456                 value.get_total_size()
8457             }
8458             AndroidCommandDataChild::AndroidSetRadarConfigCmd(value) => {
8459                 value.get_total_size()
8460             }
8461             AndroidCommandDataChild::AndroidGetRadarConfigCmd(value) => {
8462                 value.get_total_size()
8463             }
8464             AndroidCommandDataChild::Payload(bytes) => bytes.len(),
8465             AndroidCommandDataChild::None => 0,
8466         }
8467     }
8468 }
8469 #[derive(Debug, Clone, PartialEq, Eq)]
8470 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8471 pub enum AndroidCommandChild {
8472     AndroidGetPowerStatsCmd(AndroidGetPowerStatsCmd),
8473     AndroidSetCountryCodeCmd(AndroidSetCountryCodeCmd),
8474     AndroidSetRadarConfigCmd(AndroidSetRadarConfigCmd),
8475     AndroidGetRadarConfigCmd(AndroidGetRadarConfigCmd),
8476     Payload(Bytes),
8477     None,
8478 }
8479 #[derive(Debug, Clone, PartialEq, Eq)]
8480 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8481 pub struct AndroidCommandData {
8482     child: AndroidCommandDataChild,
8483 }
8484 #[derive(Debug, Clone, PartialEq, Eq)]
8485 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8486 pub struct AndroidCommand {
8487     #[cfg_attr(feature = "serde", serde(flatten))]
8488     ucicontrolpacket: UciControlPacketData,
8489     #[cfg_attr(feature = "serde", serde(flatten))]
8490     ucicommand: UciCommandData,
8491     #[cfg_attr(feature = "serde", serde(flatten))]
8492     androidcommand: AndroidCommandData,
8493 }
8494 #[derive(Debug)]
8495 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8496 pub struct AndroidCommandBuilder {
8497     pub opcode: u8,
8498     pub payload: Option<Bytes>,
8499 }
8500 impl AndroidCommandData {
conforms(bytes: &[u8]) -> bool8501     fn conforms(bytes: &[u8]) -> bool {
8502         true
8503     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>8504     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
8505         let mut cell = Cell::new(bytes);
8506         let packet = Self::parse_inner(&mut cell, opcode)?;
8507         Ok(packet)
8508     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>8509     fn parse_inner(
8510         mut bytes: &mut Cell<&[u8]>,
8511         opcode: u8,
8512     ) -> Result<Self, DecodeError> {
8513         let payload = bytes.get();
8514         bytes.get_mut().advance(payload.len());
8515         let child = match (opcode) {
8516             (0) if AndroidGetPowerStatsCmdData::conforms(&payload) => {
8517                 let mut cell = Cell::new(payload);
8518                 let child_data = AndroidGetPowerStatsCmdData::parse_inner(&mut cell)?;
8519                 AndroidCommandDataChild::AndroidGetPowerStatsCmd(child_data)
8520             }
8521             (1) if AndroidSetCountryCodeCmdData::conforms(&payload) => {
8522                 let mut cell = Cell::new(payload);
8523                 let child_data = AndroidSetCountryCodeCmdData::parse_inner(&mut cell)?;
8524                 AndroidCommandDataChild::AndroidSetCountryCodeCmd(child_data)
8525             }
8526             (17) if AndroidSetRadarConfigCmdData::conforms(&payload) => {
8527                 let mut cell = Cell::new(payload);
8528                 let child_data = AndroidSetRadarConfigCmdData::parse_inner(&mut cell)?;
8529                 AndroidCommandDataChild::AndroidSetRadarConfigCmd(child_data)
8530             }
8531             (18) if AndroidGetRadarConfigCmdData::conforms(&payload) => {
8532                 let mut cell = Cell::new(payload);
8533                 let child_data = AndroidGetRadarConfigCmdData::parse_inner(&mut cell)?;
8534                 AndroidCommandDataChild::AndroidGetRadarConfigCmd(child_data)
8535             }
8536             _ if !payload.is_empty() => {
8537                 AndroidCommandDataChild::Payload(Bytes::copy_from_slice(payload))
8538             }
8539             _ => AndroidCommandDataChild::None,
8540         };
8541         Ok(Self { child })
8542     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>8543     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
8544         match &self.child {
8545             AndroidCommandDataChild::AndroidGetPowerStatsCmd(child) => {
8546                 child.write_to(buffer)?
8547             }
8548             AndroidCommandDataChild::AndroidSetCountryCodeCmd(child) => {
8549                 child.write_to(buffer)?
8550             }
8551             AndroidCommandDataChild::AndroidSetRadarConfigCmd(child) => {
8552                 child.write_to(buffer)?
8553             }
8554             AndroidCommandDataChild::AndroidGetRadarConfigCmd(child) => {
8555                 child.write_to(buffer)?
8556             }
8557             AndroidCommandDataChild::Payload(payload) => buffer.put_slice(payload),
8558             AndroidCommandDataChild::None => {}
8559         }
8560         Ok(())
8561     }
get_total_size(&self) -> usize8562     fn get_total_size(&self) -> usize {
8563         self.get_size()
8564     }
get_size(&self) -> usize8565     fn get_size(&self) -> usize {
8566         self.child.get_total_size()
8567     }
8568 }
8569 impl Packet for AndroidCommand {
encoded_len(&self) -> usize8570     fn encoded_len(&self) -> usize {
8571         self.get_size()
8572     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>8573     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
8574         self.ucicontrolpacket.write_to(buf)
8575     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>8576     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
8577         unimplemented!("Rust legacy does not implement full packet trait")
8578     }
8579 }
8580 impl TryFrom<AndroidCommand> for Bytes {
8581     type Error = EncodeError;
try_from(packet: AndroidCommand) -> Result<Self, Self::Error>8582     fn try_from(packet: AndroidCommand) -> Result<Self, Self::Error> {
8583         packet.encode_to_bytes()
8584     }
8585 }
8586 impl TryFrom<AndroidCommand> for Vec<u8> {
8587     type Error = EncodeError;
try_from(packet: AndroidCommand) -> Result<Self, Self::Error>8588     fn try_from(packet: AndroidCommand) -> Result<Self, Self::Error> {
8589         packet.encode_to_vec()
8590     }
8591 }
8592 impl From<AndroidCommand> for UciControlPacket {
from(packet: AndroidCommand) -> UciControlPacket8593     fn from(packet: AndroidCommand) -> UciControlPacket {
8594         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
8595     }
8596 }
8597 impl From<AndroidCommand> for UciCommand {
from(packet: AndroidCommand) -> UciCommand8598     fn from(packet: AndroidCommand) -> UciCommand {
8599         UciCommand::new(packet.ucicontrolpacket).unwrap()
8600     }
8601 }
8602 impl TryFrom<UciControlPacket> for AndroidCommand {
8603     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<AndroidCommand, Self::Error>8604     fn try_from(packet: UciControlPacket) -> Result<AndroidCommand, Self::Error> {
8605         AndroidCommand::new(packet.ucicontrolpacket)
8606     }
8607 }
8608 impl AndroidCommand {
parse(bytes: &[u8]) -> Result<Self, DecodeError>8609     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
8610         let mut cell = Cell::new(bytes);
8611         let packet = Self::parse_inner(&mut cell)?;
8612         Ok(packet)
8613     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>8614     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
8615         let data = UciControlPacketData::parse_inner(&mut bytes)?;
8616         Self::new(data)
8617     }
specialize(&self) -> AndroidCommandChild8618     pub fn specialize(&self) -> AndroidCommandChild {
8619         match &self.androidcommand.child {
8620             AndroidCommandDataChild::AndroidGetPowerStatsCmd(_) => {
8621                 AndroidCommandChild::AndroidGetPowerStatsCmd(
8622                     AndroidGetPowerStatsCmd::new(self.ucicontrolpacket.clone()).unwrap(),
8623                 )
8624             }
8625             AndroidCommandDataChild::AndroidSetCountryCodeCmd(_) => {
8626                 AndroidCommandChild::AndroidSetCountryCodeCmd(
8627                     AndroidSetCountryCodeCmd::new(self.ucicontrolpacket.clone()).unwrap(),
8628                 )
8629             }
8630             AndroidCommandDataChild::AndroidSetRadarConfigCmd(_) => {
8631                 AndroidCommandChild::AndroidSetRadarConfigCmd(
8632                     AndroidSetRadarConfigCmd::new(self.ucicontrolpacket.clone()).unwrap(),
8633                 )
8634             }
8635             AndroidCommandDataChild::AndroidGetRadarConfigCmd(_) => {
8636                 AndroidCommandChild::AndroidGetRadarConfigCmd(
8637                     AndroidGetRadarConfigCmd::new(self.ucicontrolpacket.clone()).unwrap(),
8638                 )
8639             }
8640             AndroidCommandDataChild::Payload(payload) => {
8641                 AndroidCommandChild::Payload(payload.clone())
8642             }
8643             AndroidCommandDataChild::None => AndroidCommandChild::None,
8644         }
8645     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>8646     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
8647         let ucicommand = match &ucicontrolpacket.child {
8648             UciControlPacketDataChild::UciCommand(value) => value.clone(),
8649             _ => {
8650                 return Err(DecodeError::InvalidChildError {
8651                     expected: stringify!(UciControlPacketDataChild::UciCommand),
8652                     actual: format!("{:?}", & ucicontrolpacket.child),
8653                 });
8654             }
8655         };
8656         let androidcommand = match &ucicommand.child {
8657             UciCommandDataChild::AndroidCommand(value) => value.clone(),
8658             _ => {
8659                 return Err(DecodeError::InvalidChildError {
8660                     expected: stringify!(UciCommandDataChild::AndroidCommand),
8661                     actual: format!("{:?}", & ucicommand.child),
8662                 });
8663             }
8664         };
8665         Ok(Self {
8666             ucicontrolpacket,
8667             ucicommand,
8668             androidcommand,
8669         })
8670     }
get_group_id(&self) -> GroupId8671     pub fn get_group_id(&self) -> GroupId {
8672         self.ucicontrolpacket.group_id
8673     }
get_message_type(&self) -> MessageType8674     pub fn get_message_type(&self) -> MessageType {
8675         self.ucicontrolpacket.message_type
8676     }
get_opcode(&self) -> u88677     pub fn get_opcode(&self) -> u8 {
8678         self.ucicontrolpacket.opcode
8679     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>8680     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
8681         self.androidcommand.write_to(buffer)
8682     }
get_size(&self) -> usize8683     pub fn get_size(&self) -> usize {
8684         self.ucicontrolpacket.get_size()
8685     }
8686 }
8687 impl AndroidCommandBuilder {
build(self) -> AndroidCommand8688     pub fn build(self) -> AndroidCommand {
8689         let androidcommand = AndroidCommandData {
8690             child: match self.payload {
8691                 None => AndroidCommandDataChild::None,
8692                 Some(bytes) => AndroidCommandDataChild::Payload(bytes),
8693             },
8694         };
8695         let ucicommand = UciCommandData {
8696             child: UciCommandDataChild::AndroidCommand(androidcommand),
8697         };
8698         let ucicontrolpacket = UciControlPacketData {
8699             group_id: GroupId::VendorAndroid,
8700             message_type: MessageType::Command,
8701             opcode: self.opcode,
8702             child: UciControlPacketDataChild::UciCommand(ucicommand),
8703         };
8704         AndroidCommand::new(ucicontrolpacket).unwrap()
8705     }
8706 }
8707 impl From<AndroidCommandBuilder> for UciControlPacket {
from(builder: AndroidCommandBuilder) -> UciControlPacket8708     fn from(builder: AndroidCommandBuilder) -> UciControlPacket {
8709         builder.build().into()
8710     }
8711 }
8712 impl From<AndroidCommandBuilder> for UciCommand {
from(builder: AndroidCommandBuilder) -> UciCommand8713     fn from(builder: AndroidCommandBuilder) -> UciCommand {
8714         builder.build().into()
8715     }
8716 }
8717 impl From<AndroidCommandBuilder> for AndroidCommand {
from(builder: AndroidCommandBuilder) -> AndroidCommand8718     fn from(builder: AndroidCommandBuilder) -> AndroidCommand {
8719         builder.build().into()
8720     }
8721 }
8722 #[derive(Debug, Clone, PartialEq, Eq)]
8723 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8724 pub enum AndroidResponseDataChild {
8725     AndroidGetPowerStatsRsp(AndroidGetPowerStatsRspData),
8726     AndroidSetCountryCodeRsp(AndroidSetCountryCodeRspData),
8727     AndroidSetRadarConfigRsp(AndroidSetRadarConfigRspData),
8728     AndroidGetRadarConfigRsp(AndroidGetRadarConfigRspData),
8729     Payload(Bytes),
8730     None,
8731 }
8732 impl AndroidResponseDataChild {
get_total_size(&self) -> usize8733     fn get_total_size(&self) -> usize {
8734         match self {
8735             AndroidResponseDataChild::AndroidGetPowerStatsRsp(value) => {
8736                 value.get_total_size()
8737             }
8738             AndroidResponseDataChild::AndroidSetCountryCodeRsp(value) => {
8739                 value.get_total_size()
8740             }
8741             AndroidResponseDataChild::AndroidSetRadarConfigRsp(value) => {
8742                 value.get_total_size()
8743             }
8744             AndroidResponseDataChild::AndroidGetRadarConfigRsp(value) => {
8745                 value.get_total_size()
8746             }
8747             AndroidResponseDataChild::Payload(bytes) => bytes.len(),
8748             AndroidResponseDataChild::None => 0,
8749         }
8750     }
8751 }
8752 #[derive(Debug, Clone, PartialEq, Eq)]
8753 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8754 pub enum AndroidResponseChild {
8755     AndroidGetPowerStatsRsp(AndroidGetPowerStatsRsp),
8756     AndroidSetCountryCodeRsp(AndroidSetCountryCodeRsp),
8757     AndroidSetRadarConfigRsp(AndroidSetRadarConfigRsp),
8758     AndroidGetRadarConfigRsp(AndroidGetRadarConfigRsp),
8759     Payload(Bytes),
8760     None,
8761 }
8762 #[derive(Debug, Clone, PartialEq, Eq)]
8763 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8764 pub struct AndroidResponseData {
8765     child: AndroidResponseDataChild,
8766 }
8767 #[derive(Debug, Clone, PartialEq, Eq)]
8768 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8769 pub struct AndroidResponse {
8770     #[cfg_attr(feature = "serde", serde(flatten))]
8771     ucicontrolpacket: UciControlPacketData,
8772     #[cfg_attr(feature = "serde", serde(flatten))]
8773     uciresponse: UciResponseData,
8774     #[cfg_attr(feature = "serde", serde(flatten))]
8775     androidresponse: AndroidResponseData,
8776 }
8777 #[derive(Debug)]
8778 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
8779 pub struct AndroidResponseBuilder {
8780     pub opcode: u8,
8781     pub payload: Option<Bytes>,
8782 }
8783 impl AndroidResponseData {
conforms(bytes: &[u8]) -> bool8784     fn conforms(bytes: &[u8]) -> bool {
8785         true
8786     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>8787     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
8788         let mut cell = Cell::new(bytes);
8789         let packet = Self::parse_inner(&mut cell, opcode)?;
8790         Ok(packet)
8791     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>8792     fn parse_inner(
8793         mut bytes: &mut Cell<&[u8]>,
8794         opcode: u8,
8795     ) -> Result<Self, DecodeError> {
8796         let payload = bytes.get();
8797         bytes.get_mut().advance(payload.len());
8798         let child = match (opcode) {
8799             (0) if AndroidGetPowerStatsRspData::conforms(&payload) => {
8800                 let mut cell = Cell::new(payload);
8801                 let child_data = AndroidGetPowerStatsRspData::parse_inner(&mut cell)?;
8802                 AndroidResponseDataChild::AndroidGetPowerStatsRsp(child_data)
8803             }
8804             (1) if AndroidSetCountryCodeRspData::conforms(&payload) => {
8805                 let mut cell = Cell::new(payload);
8806                 let child_data = AndroidSetCountryCodeRspData::parse_inner(&mut cell)?;
8807                 AndroidResponseDataChild::AndroidSetCountryCodeRsp(child_data)
8808             }
8809             (17) if AndroidSetRadarConfigRspData::conforms(&payload) => {
8810                 let mut cell = Cell::new(payload);
8811                 let child_data = AndroidSetRadarConfigRspData::parse_inner(&mut cell)?;
8812                 AndroidResponseDataChild::AndroidSetRadarConfigRsp(child_data)
8813             }
8814             (18) if AndroidGetRadarConfigRspData::conforms(&payload) => {
8815                 let mut cell = Cell::new(payload);
8816                 let child_data = AndroidGetRadarConfigRspData::parse_inner(&mut cell)?;
8817                 AndroidResponseDataChild::AndroidGetRadarConfigRsp(child_data)
8818             }
8819             _ if !payload.is_empty() => {
8820                 AndroidResponseDataChild::Payload(Bytes::copy_from_slice(payload))
8821             }
8822             _ => AndroidResponseDataChild::None,
8823         };
8824         Ok(Self { child })
8825     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>8826     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
8827         match &self.child {
8828             AndroidResponseDataChild::AndroidGetPowerStatsRsp(child) => {
8829                 child.write_to(buffer)?
8830             }
8831             AndroidResponseDataChild::AndroidSetCountryCodeRsp(child) => {
8832                 child.write_to(buffer)?
8833             }
8834             AndroidResponseDataChild::AndroidSetRadarConfigRsp(child) => {
8835                 child.write_to(buffer)?
8836             }
8837             AndroidResponseDataChild::AndroidGetRadarConfigRsp(child) => {
8838                 child.write_to(buffer)?
8839             }
8840             AndroidResponseDataChild::Payload(payload) => buffer.put_slice(payload),
8841             AndroidResponseDataChild::None => {}
8842         }
8843         Ok(())
8844     }
get_total_size(&self) -> usize8845     fn get_total_size(&self) -> usize {
8846         self.get_size()
8847     }
get_size(&self) -> usize8848     fn get_size(&self) -> usize {
8849         self.child.get_total_size()
8850     }
8851 }
8852 impl Packet for AndroidResponse {
encoded_len(&self) -> usize8853     fn encoded_len(&self) -> usize {
8854         self.get_size()
8855     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>8856     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
8857         self.ucicontrolpacket.write_to(buf)
8858     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>8859     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
8860         unimplemented!("Rust legacy does not implement full packet trait")
8861     }
8862 }
8863 impl TryFrom<AndroidResponse> for Bytes {
8864     type Error = EncodeError;
try_from(packet: AndroidResponse) -> Result<Self, Self::Error>8865     fn try_from(packet: AndroidResponse) -> Result<Self, Self::Error> {
8866         packet.encode_to_bytes()
8867     }
8868 }
8869 impl TryFrom<AndroidResponse> for Vec<u8> {
8870     type Error = EncodeError;
try_from(packet: AndroidResponse) -> Result<Self, Self::Error>8871     fn try_from(packet: AndroidResponse) -> Result<Self, Self::Error> {
8872         packet.encode_to_vec()
8873     }
8874 }
8875 impl From<AndroidResponse> for UciControlPacket {
from(packet: AndroidResponse) -> UciControlPacket8876     fn from(packet: AndroidResponse) -> UciControlPacket {
8877         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
8878     }
8879 }
8880 impl From<AndroidResponse> for UciResponse {
from(packet: AndroidResponse) -> UciResponse8881     fn from(packet: AndroidResponse) -> UciResponse {
8882         UciResponse::new(packet.ucicontrolpacket).unwrap()
8883     }
8884 }
8885 impl TryFrom<UciControlPacket> for AndroidResponse {
8886     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<AndroidResponse, Self::Error>8887     fn try_from(packet: UciControlPacket) -> Result<AndroidResponse, Self::Error> {
8888         AndroidResponse::new(packet.ucicontrolpacket)
8889     }
8890 }
8891 impl AndroidResponse {
parse(bytes: &[u8]) -> Result<Self, DecodeError>8892     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
8893         let mut cell = Cell::new(bytes);
8894         let packet = Self::parse_inner(&mut cell)?;
8895         Ok(packet)
8896     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>8897     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
8898         let data = UciControlPacketData::parse_inner(&mut bytes)?;
8899         Self::new(data)
8900     }
specialize(&self) -> AndroidResponseChild8901     pub fn specialize(&self) -> AndroidResponseChild {
8902         match &self.androidresponse.child {
8903             AndroidResponseDataChild::AndroidGetPowerStatsRsp(_) => {
8904                 AndroidResponseChild::AndroidGetPowerStatsRsp(
8905                     AndroidGetPowerStatsRsp::new(self.ucicontrolpacket.clone()).unwrap(),
8906                 )
8907             }
8908             AndroidResponseDataChild::AndroidSetCountryCodeRsp(_) => {
8909                 AndroidResponseChild::AndroidSetCountryCodeRsp(
8910                     AndroidSetCountryCodeRsp::new(self.ucicontrolpacket.clone()).unwrap(),
8911                 )
8912             }
8913             AndroidResponseDataChild::AndroidSetRadarConfigRsp(_) => {
8914                 AndroidResponseChild::AndroidSetRadarConfigRsp(
8915                     AndroidSetRadarConfigRsp::new(self.ucicontrolpacket.clone()).unwrap(),
8916                 )
8917             }
8918             AndroidResponseDataChild::AndroidGetRadarConfigRsp(_) => {
8919                 AndroidResponseChild::AndroidGetRadarConfigRsp(
8920                     AndroidGetRadarConfigRsp::new(self.ucicontrolpacket.clone()).unwrap(),
8921                 )
8922             }
8923             AndroidResponseDataChild::Payload(payload) => {
8924                 AndroidResponseChild::Payload(payload.clone())
8925             }
8926             AndroidResponseDataChild::None => AndroidResponseChild::None,
8927         }
8928     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>8929     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
8930         let uciresponse = match &ucicontrolpacket.child {
8931             UciControlPacketDataChild::UciResponse(value) => value.clone(),
8932             _ => {
8933                 return Err(DecodeError::InvalidChildError {
8934                     expected: stringify!(UciControlPacketDataChild::UciResponse),
8935                     actual: format!("{:?}", & ucicontrolpacket.child),
8936                 });
8937             }
8938         };
8939         let androidresponse = match &uciresponse.child {
8940             UciResponseDataChild::AndroidResponse(value) => value.clone(),
8941             _ => {
8942                 return Err(DecodeError::InvalidChildError {
8943                     expected: stringify!(UciResponseDataChild::AndroidResponse),
8944                     actual: format!("{:?}", & uciresponse.child),
8945                 });
8946             }
8947         };
8948         Ok(Self {
8949             ucicontrolpacket,
8950             uciresponse,
8951             androidresponse,
8952         })
8953     }
get_group_id(&self) -> GroupId8954     pub fn get_group_id(&self) -> GroupId {
8955         self.ucicontrolpacket.group_id
8956     }
get_message_type(&self) -> MessageType8957     pub fn get_message_type(&self) -> MessageType {
8958         self.ucicontrolpacket.message_type
8959     }
get_opcode(&self) -> u88960     pub fn get_opcode(&self) -> u8 {
8961         self.ucicontrolpacket.opcode
8962     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>8963     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
8964         self.androidresponse.write_to(buffer)
8965     }
get_size(&self) -> usize8966     pub fn get_size(&self) -> usize {
8967         self.ucicontrolpacket.get_size()
8968     }
8969 }
8970 impl AndroidResponseBuilder {
build(self) -> AndroidResponse8971     pub fn build(self) -> AndroidResponse {
8972         let androidresponse = AndroidResponseData {
8973             child: match self.payload {
8974                 None => AndroidResponseDataChild::None,
8975                 Some(bytes) => AndroidResponseDataChild::Payload(bytes),
8976             },
8977         };
8978         let uciresponse = UciResponseData {
8979             child: UciResponseDataChild::AndroidResponse(androidresponse),
8980         };
8981         let ucicontrolpacket = UciControlPacketData {
8982             group_id: GroupId::VendorAndroid,
8983             message_type: MessageType::Response,
8984             opcode: self.opcode,
8985             child: UciControlPacketDataChild::UciResponse(uciresponse),
8986         };
8987         AndroidResponse::new(ucicontrolpacket).unwrap()
8988     }
8989 }
8990 impl From<AndroidResponseBuilder> for UciControlPacket {
from(builder: AndroidResponseBuilder) -> UciControlPacket8991     fn from(builder: AndroidResponseBuilder) -> UciControlPacket {
8992         builder.build().into()
8993     }
8994 }
8995 impl From<AndroidResponseBuilder> for UciResponse {
from(builder: AndroidResponseBuilder) -> UciResponse8996     fn from(builder: AndroidResponseBuilder) -> UciResponse {
8997         builder.build().into()
8998     }
8999 }
9000 impl From<AndroidResponseBuilder> for AndroidResponse {
from(builder: AndroidResponseBuilder) -> AndroidResponse9001     fn from(builder: AndroidResponseBuilder) -> AndroidResponse {
9002         builder.build().into()
9003     }
9004 }
9005 #[derive(Debug, Clone, PartialEq, Eq)]
9006 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9007 pub enum AndroidNotificationDataChild {
9008     AndroidRangeDiagnosticsNtf(AndroidRangeDiagnosticsNtfData),
9009     Payload(Bytes),
9010     None,
9011 }
9012 impl AndroidNotificationDataChild {
get_total_size(&self) -> usize9013     fn get_total_size(&self) -> usize {
9014         match self {
9015             AndroidNotificationDataChild::AndroidRangeDiagnosticsNtf(value) => {
9016                 value.get_total_size()
9017             }
9018             AndroidNotificationDataChild::Payload(bytes) => bytes.len(),
9019             AndroidNotificationDataChild::None => 0,
9020         }
9021     }
9022 }
9023 #[derive(Debug, Clone, PartialEq, Eq)]
9024 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9025 pub enum AndroidNotificationChild {
9026     AndroidRangeDiagnosticsNtf(AndroidRangeDiagnosticsNtf),
9027     Payload(Bytes),
9028     None,
9029 }
9030 #[derive(Debug, Clone, PartialEq, Eq)]
9031 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9032 pub struct AndroidNotificationData {
9033     child: AndroidNotificationDataChild,
9034 }
9035 #[derive(Debug, Clone, PartialEq, Eq)]
9036 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9037 pub struct AndroidNotification {
9038     #[cfg_attr(feature = "serde", serde(flatten))]
9039     ucicontrolpacket: UciControlPacketData,
9040     #[cfg_attr(feature = "serde", serde(flatten))]
9041     ucinotification: UciNotificationData,
9042     #[cfg_attr(feature = "serde", serde(flatten))]
9043     androidnotification: AndroidNotificationData,
9044 }
9045 #[derive(Debug)]
9046 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9047 pub struct AndroidNotificationBuilder {
9048     pub opcode: u8,
9049     pub payload: Option<Bytes>,
9050 }
9051 impl AndroidNotificationData {
conforms(bytes: &[u8]) -> bool9052     fn conforms(bytes: &[u8]) -> bool {
9053         true
9054     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>9055     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
9056         let mut cell = Cell::new(bytes);
9057         let packet = Self::parse_inner(&mut cell, opcode)?;
9058         Ok(packet)
9059     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>9060     fn parse_inner(
9061         mut bytes: &mut Cell<&[u8]>,
9062         opcode: u8,
9063     ) -> Result<Self, DecodeError> {
9064         let payload = bytes.get();
9065         bytes.get_mut().advance(payload.len());
9066         let child = match (opcode) {
9067             (2) if AndroidRangeDiagnosticsNtfData::conforms(&payload) => {
9068                 let mut cell = Cell::new(payload);
9069                 let child_data = AndroidRangeDiagnosticsNtfData::parse_inner(&mut cell)?;
9070                 AndroidNotificationDataChild::AndroidRangeDiagnosticsNtf(child_data)
9071             }
9072             _ if !payload.is_empty() => {
9073                 AndroidNotificationDataChild::Payload(Bytes::copy_from_slice(payload))
9074             }
9075             _ => AndroidNotificationDataChild::None,
9076         };
9077         Ok(Self { child })
9078     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>9079     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
9080         match &self.child {
9081             AndroidNotificationDataChild::AndroidRangeDiagnosticsNtf(child) => {
9082                 child.write_to(buffer)?
9083             }
9084             AndroidNotificationDataChild::Payload(payload) => buffer.put_slice(payload),
9085             AndroidNotificationDataChild::None => {}
9086         }
9087         Ok(())
9088     }
get_total_size(&self) -> usize9089     fn get_total_size(&self) -> usize {
9090         self.get_size()
9091     }
get_size(&self) -> usize9092     fn get_size(&self) -> usize {
9093         self.child.get_total_size()
9094     }
9095 }
9096 impl Packet for AndroidNotification {
encoded_len(&self) -> usize9097     fn encoded_len(&self) -> usize {
9098         self.get_size()
9099     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>9100     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
9101         self.ucicontrolpacket.write_to(buf)
9102     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>9103     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
9104         unimplemented!("Rust legacy does not implement full packet trait")
9105     }
9106 }
9107 impl TryFrom<AndroidNotification> for Bytes {
9108     type Error = EncodeError;
try_from(packet: AndroidNotification) -> Result<Self, Self::Error>9109     fn try_from(packet: AndroidNotification) -> Result<Self, Self::Error> {
9110         packet.encode_to_bytes()
9111     }
9112 }
9113 impl TryFrom<AndroidNotification> for Vec<u8> {
9114     type Error = EncodeError;
try_from(packet: AndroidNotification) -> Result<Self, Self::Error>9115     fn try_from(packet: AndroidNotification) -> Result<Self, Self::Error> {
9116         packet.encode_to_vec()
9117     }
9118 }
9119 impl From<AndroidNotification> for UciControlPacket {
from(packet: AndroidNotification) -> UciControlPacket9120     fn from(packet: AndroidNotification) -> UciControlPacket {
9121         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
9122     }
9123 }
9124 impl From<AndroidNotification> for UciNotification {
from(packet: AndroidNotification) -> UciNotification9125     fn from(packet: AndroidNotification) -> UciNotification {
9126         UciNotification::new(packet.ucicontrolpacket).unwrap()
9127     }
9128 }
9129 impl TryFrom<UciControlPacket> for AndroidNotification {
9130     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<AndroidNotification, Self::Error>9131     fn try_from(packet: UciControlPacket) -> Result<AndroidNotification, Self::Error> {
9132         AndroidNotification::new(packet.ucicontrolpacket)
9133     }
9134 }
9135 impl AndroidNotification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>9136     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
9137         let mut cell = Cell::new(bytes);
9138         let packet = Self::parse_inner(&mut cell)?;
9139         Ok(packet)
9140     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>9141     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
9142         let data = UciControlPacketData::parse_inner(&mut bytes)?;
9143         Self::new(data)
9144     }
specialize(&self) -> AndroidNotificationChild9145     pub fn specialize(&self) -> AndroidNotificationChild {
9146         match &self.androidnotification.child {
9147             AndroidNotificationDataChild::AndroidRangeDiagnosticsNtf(_) => {
9148                 AndroidNotificationChild::AndroidRangeDiagnosticsNtf(
9149                     AndroidRangeDiagnosticsNtf::new(self.ucicontrolpacket.clone())
9150                         .unwrap(),
9151                 )
9152             }
9153             AndroidNotificationDataChild::Payload(payload) => {
9154                 AndroidNotificationChild::Payload(payload.clone())
9155             }
9156             AndroidNotificationDataChild::None => AndroidNotificationChild::None,
9157         }
9158     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>9159     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
9160         let ucinotification = match &ucicontrolpacket.child {
9161             UciControlPacketDataChild::UciNotification(value) => value.clone(),
9162             _ => {
9163                 return Err(DecodeError::InvalidChildError {
9164                     expected: stringify!(UciControlPacketDataChild::UciNotification),
9165                     actual: format!("{:?}", & ucicontrolpacket.child),
9166                 });
9167             }
9168         };
9169         let androidnotification = match &ucinotification.child {
9170             UciNotificationDataChild::AndroidNotification(value) => value.clone(),
9171             _ => {
9172                 return Err(DecodeError::InvalidChildError {
9173                     expected: stringify!(UciNotificationDataChild::AndroidNotification),
9174                     actual: format!("{:?}", & ucinotification.child),
9175                 });
9176             }
9177         };
9178         Ok(Self {
9179             ucicontrolpacket,
9180             ucinotification,
9181             androidnotification,
9182         })
9183     }
get_group_id(&self) -> GroupId9184     pub fn get_group_id(&self) -> GroupId {
9185         self.ucicontrolpacket.group_id
9186     }
get_message_type(&self) -> MessageType9187     pub fn get_message_type(&self) -> MessageType {
9188         self.ucicontrolpacket.message_type
9189     }
get_opcode(&self) -> u89190     pub fn get_opcode(&self) -> u8 {
9191         self.ucicontrolpacket.opcode
9192     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>9193     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
9194         self.androidnotification.write_to(buffer)
9195     }
get_size(&self) -> usize9196     pub fn get_size(&self) -> usize {
9197         self.ucicontrolpacket.get_size()
9198     }
9199 }
9200 impl AndroidNotificationBuilder {
build(self) -> AndroidNotification9201     pub fn build(self) -> AndroidNotification {
9202         let androidnotification = AndroidNotificationData {
9203             child: match self.payload {
9204                 None => AndroidNotificationDataChild::None,
9205                 Some(bytes) => AndroidNotificationDataChild::Payload(bytes),
9206             },
9207         };
9208         let ucinotification = UciNotificationData {
9209             child: UciNotificationDataChild::AndroidNotification(androidnotification),
9210         };
9211         let ucicontrolpacket = UciControlPacketData {
9212             group_id: GroupId::VendorAndroid,
9213             message_type: MessageType::Notification,
9214             opcode: self.opcode,
9215             child: UciControlPacketDataChild::UciNotification(ucinotification),
9216         };
9217         AndroidNotification::new(ucicontrolpacket).unwrap()
9218     }
9219 }
9220 impl From<AndroidNotificationBuilder> for UciControlPacket {
from(builder: AndroidNotificationBuilder) -> UciControlPacket9221     fn from(builder: AndroidNotificationBuilder) -> UciControlPacket {
9222         builder.build().into()
9223     }
9224 }
9225 impl From<AndroidNotificationBuilder> for UciNotification {
from(builder: AndroidNotificationBuilder) -> UciNotification9226     fn from(builder: AndroidNotificationBuilder) -> UciNotification {
9227         builder.build().into()
9228     }
9229 }
9230 impl From<AndroidNotificationBuilder> for AndroidNotification {
from(builder: AndroidNotificationBuilder) -> AndroidNotification9231     fn from(builder: AndroidNotificationBuilder) -> AndroidNotification {
9232         builder.build().into()
9233     }
9234 }
9235 #[derive(Debug, Clone, PartialEq, Eq)]
9236 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9237 pub enum TestCommandDataChild {
9238     SessionSetRfTestConfigCmd(SessionSetRfTestConfigCmdData),
9239     TestPeriodicTxCmd(TestPeriodicTxCmdData),
9240     StopRfTestCmd(StopRfTestCmdData),
9241     Payload(Bytes),
9242     None,
9243 }
9244 impl TestCommandDataChild {
get_total_size(&self) -> usize9245     fn get_total_size(&self) -> usize {
9246         match self {
9247             TestCommandDataChild::SessionSetRfTestConfigCmd(value) => {
9248                 value.get_total_size()
9249             }
9250             TestCommandDataChild::TestPeriodicTxCmd(value) => value.get_total_size(),
9251             TestCommandDataChild::StopRfTestCmd(value) => value.get_total_size(),
9252             TestCommandDataChild::Payload(bytes) => bytes.len(),
9253             TestCommandDataChild::None => 0,
9254         }
9255     }
9256 }
9257 #[derive(Debug, Clone, PartialEq, Eq)]
9258 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9259 pub enum TestCommandChild {
9260     SessionSetRfTestConfigCmd(SessionSetRfTestConfigCmd),
9261     TestPeriodicTxCmd(TestPeriodicTxCmd),
9262     StopRfTestCmd(StopRfTestCmd),
9263     Payload(Bytes),
9264     None,
9265 }
9266 #[derive(Debug, Clone, PartialEq, Eq)]
9267 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9268 pub struct TestCommandData {
9269     child: TestCommandDataChild,
9270 }
9271 #[derive(Debug, Clone, PartialEq, Eq)]
9272 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9273 pub struct TestCommand {
9274     #[cfg_attr(feature = "serde", serde(flatten))]
9275     ucicontrolpacket: UciControlPacketData,
9276     #[cfg_attr(feature = "serde", serde(flatten))]
9277     ucicommand: UciCommandData,
9278     #[cfg_attr(feature = "serde", serde(flatten))]
9279     testcommand: TestCommandData,
9280 }
9281 #[derive(Debug)]
9282 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9283 pub struct TestCommandBuilder {
9284     pub opcode: u8,
9285     pub payload: Option<Bytes>,
9286 }
9287 impl TestCommandData {
conforms(bytes: &[u8]) -> bool9288     fn conforms(bytes: &[u8]) -> bool {
9289         true
9290     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>9291     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
9292         let mut cell = Cell::new(bytes);
9293         let packet = Self::parse_inner(&mut cell, opcode)?;
9294         Ok(packet)
9295     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>9296     fn parse_inner(
9297         mut bytes: &mut Cell<&[u8]>,
9298         opcode: u8,
9299     ) -> Result<Self, DecodeError> {
9300         let payload = bytes.get();
9301         bytes.get_mut().advance(payload.len());
9302         let child = match (opcode) {
9303             (0) if SessionSetRfTestConfigCmdData::conforms(&payload) => {
9304                 let mut cell = Cell::new(payload);
9305                 let child_data = SessionSetRfTestConfigCmdData::parse_inner(&mut cell)?;
9306                 TestCommandDataChild::SessionSetRfTestConfigCmd(child_data)
9307             }
9308             (2) if TestPeriodicTxCmdData::conforms(&payload) => {
9309                 let mut cell = Cell::new(payload);
9310                 let child_data = TestPeriodicTxCmdData::parse_inner(&mut cell)?;
9311                 TestCommandDataChild::TestPeriodicTxCmd(child_data)
9312             }
9313             (7) if StopRfTestCmdData::conforms(&payload) => {
9314                 let mut cell = Cell::new(payload);
9315                 let child_data = StopRfTestCmdData::parse_inner(&mut cell)?;
9316                 TestCommandDataChild::StopRfTestCmd(child_data)
9317             }
9318             _ if !payload.is_empty() => {
9319                 TestCommandDataChild::Payload(Bytes::copy_from_slice(payload))
9320             }
9321             _ => TestCommandDataChild::None,
9322         };
9323         Ok(Self { child })
9324     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>9325     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
9326         match &self.child {
9327             TestCommandDataChild::SessionSetRfTestConfigCmd(child) => {
9328                 child.write_to(buffer)?
9329             }
9330             TestCommandDataChild::TestPeriodicTxCmd(child) => child.write_to(buffer)?,
9331             TestCommandDataChild::StopRfTestCmd(child) => child.write_to(buffer)?,
9332             TestCommandDataChild::Payload(payload) => buffer.put_slice(payload),
9333             TestCommandDataChild::None => {}
9334         }
9335         Ok(())
9336     }
get_total_size(&self) -> usize9337     fn get_total_size(&self) -> usize {
9338         self.get_size()
9339     }
get_size(&self) -> usize9340     fn get_size(&self) -> usize {
9341         self.child.get_total_size()
9342     }
9343 }
9344 impl Packet for TestCommand {
encoded_len(&self) -> usize9345     fn encoded_len(&self) -> usize {
9346         self.get_size()
9347     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>9348     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
9349         self.ucicontrolpacket.write_to(buf)
9350     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>9351     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
9352         unimplemented!("Rust legacy does not implement full packet trait")
9353     }
9354 }
9355 impl TryFrom<TestCommand> for Bytes {
9356     type Error = EncodeError;
try_from(packet: TestCommand) -> Result<Self, Self::Error>9357     fn try_from(packet: TestCommand) -> Result<Self, Self::Error> {
9358         packet.encode_to_bytes()
9359     }
9360 }
9361 impl TryFrom<TestCommand> for Vec<u8> {
9362     type Error = EncodeError;
try_from(packet: TestCommand) -> Result<Self, Self::Error>9363     fn try_from(packet: TestCommand) -> Result<Self, Self::Error> {
9364         packet.encode_to_vec()
9365     }
9366 }
9367 impl From<TestCommand> for UciControlPacket {
from(packet: TestCommand) -> UciControlPacket9368     fn from(packet: TestCommand) -> UciControlPacket {
9369         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
9370     }
9371 }
9372 impl From<TestCommand> for UciCommand {
from(packet: TestCommand) -> UciCommand9373     fn from(packet: TestCommand) -> UciCommand {
9374         UciCommand::new(packet.ucicontrolpacket).unwrap()
9375     }
9376 }
9377 impl TryFrom<UciControlPacket> for TestCommand {
9378     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<TestCommand, Self::Error>9379     fn try_from(packet: UciControlPacket) -> Result<TestCommand, Self::Error> {
9380         TestCommand::new(packet.ucicontrolpacket)
9381     }
9382 }
9383 impl TestCommand {
parse(bytes: &[u8]) -> Result<Self, DecodeError>9384     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
9385         let mut cell = Cell::new(bytes);
9386         let packet = Self::parse_inner(&mut cell)?;
9387         Ok(packet)
9388     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>9389     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
9390         let data = UciControlPacketData::parse_inner(&mut bytes)?;
9391         Self::new(data)
9392     }
specialize(&self) -> TestCommandChild9393     pub fn specialize(&self) -> TestCommandChild {
9394         match &self.testcommand.child {
9395             TestCommandDataChild::SessionSetRfTestConfigCmd(_) => {
9396                 TestCommandChild::SessionSetRfTestConfigCmd(
9397                     SessionSetRfTestConfigCmd::new(self.ucicontrolpacket.clone())
9398                         .unwrap(),
9399                 )
9400             }
9401             TestCommandDataChild::TestPeriodicTxCmd(_) => {
9402                 TestCommandChild::TestPeriodicTxCmd(
9403                     TestPeriodicTxCmd::new(self.ucicontrolpacket.clone()).unwrap(),
9404                 )
9405             }
9406             TestCommandDataChild::StopRfTestCmd(_) => {
9407                 TestCommandChild::StopRfTestCmd(
9408                     StopRfTestCmd::new(self.ucicontrolpacket.clone()).unwrap(),
9409                 )
9410             }
9411             TestCommandDataChild::Payload(payload) => {
9412                 TestCommandChild::Payload(payload.clone())
9413             }
9414             TestCommandDataChild::None => TestCommandChild::None,
9415         }
9416     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>9417     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
9418         let ucicommand = match &ucicontrolpacket.child {
9419             UciControlPacketDataChild::UciCommand(value) => value.clone(),
9420             _ => {
9421                 return Err(DecodeError::InvalidChildError {
9422                     expected: stringify!(UciControlPacketDataChild::UciCommand),
9423                     actual: format!("{:?}", & ucicontrolpacket.child),
9424                 });
9425             }
9426         };
9427         let testcommand = match &ucicommand.child {
9428             UciCommandDataChild::TestCommand(value) => value.clone(),
9429             _ => {
9430                 return Err(DecodeError::InvalidChildError {
9431                     expected: stringify!(UciCommandDataChild::TestCommand),
9432                     actual: format!("{:?}", & ucicommand.child),
9433                 });
9434             }
9435         };
9436         Ok(Self {
9437             ucicontrolpacket,
9438             ucicommand,
9439             testcommand,
9440         })
9441     }
get_group_id(&self) -> GroupId9442     pub fn get_group_id(&self) -> GroupId {
9443         self.ucicontrolpacket.group_id
9444     }
get_message_type(&self) -> MessageType9445     pub fn get_message_type(&self) -> MessageType {
9446         self.ucicontrolpacket.message_type
9447     }
get_opcode(&self) -> u89448     pub fn get_opcode(&self) -> u8 {
9449         self.ucicontrolpacket.opcode
9450     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>9451     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
9452         self.testcommand.write_to(buffer)
9453     }
get_size(&self) -> usize9454     pub fn get_size(&self) -> usize {
9455         self.ucicontrolpacket.get_size()
9456     }
9457 }
9458 impl TestCommandBuilder {
build(self) -> TestCommand9459     pub fn build(self) -> TestCommand {
9460         let testcommand = TestCommandData {
9461             child: match self.payload {
9462                 None => TestCommandDataChild::None,
9463                 Some(bytes) => TestCommandDataChild::Payload(bytes),
9464             },
9465         };
9466         let ucicommand = UciCommandData {
9467             child: UciCommandDataChild::TestCommand(testcommand),
9468         };
9469         let ucicontrolpacket = UciControlPacketData {
9470             group_id: GroupId::Test,
9471             message_type: MessageType::Command,
9472             opcode: self.opcode,
9473             child: UciControlPacketDataChild::UciCommand(ucicommand),
9474         };
9475         TestCommand::new(ucicontrolpacket).unwrap()
9476     }
9477 }
9478 impl From<TestCommandBuilder> for UciControlPacket {
from(builder: TestCommandBuilder) -> UciControlPacket9479     fn from(builder: TestCommandBuilder) -> UciControlPacket {
9480         builder.build().into()
9481     }
9482 }
9483 impl From<TestCommandBuilder> for UciCommand {
from(builder: TestCommandBuilder) -> UciCommand9484     fn from(builder: TestCommandBuilder) -> UciCommand {
9485         builder.build().into()
9486     }
9487 }
9488 impl From<TestCommandBuilder> for TestCommand {
from(builder: TestCommandBuilder) -> TestCommand9489     fn from(builder: TestCommandBuilder) -> TestCommand {
9490         builder.build().into()
9491     }
9492 }
9493 #[derive(Debug, Clone, PartialEq, Eq)]
9494 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9495 pub enum TestResponseDataChild {
9496     SessionSetRfTestConfigRsp(SessionSetRfTestConfigRspData),
9497     TestPeriodicTxRsp(TestPeriodicTxRspData),
9498     StopRfTestRsp(StopRfTestRspData),
9499     Payload(Bytes),
9500     None,
9501 }
9502 impl TestResponseDataChild {
get_total_size(&self) -> usize9503     fn get_total_size(&self) -> usize {
9504         match self {
9505             TestResponseDataChild::SessionSetRfTestConfigRsp(value) => {
9506                 value.get_total_size()
9507             }
9508             TestResponseDataChild::TestPeriodicTxRsp(value) => value.get_total_size(),
9509             TestResponseDataChild::StopRfTestRsp(value) => value.get_total_size(),
9510             TestResponseDataChild::Payload(bytes) => bytes.len(),
9511             TestResponseDataChild::None => 0,
9512         }
9513     }
9514 }
9515 #[derive(Debug, Clone, PartialEq, Eq)]
9516 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9517 pub enum TestResponseChild {
9518     SessionSetRfTestConfigRsp(SessionSetRfTestConfigRsp),
9519     TestPeriodicTxRsp(TestPeriodicTxRsp),
9520     StopRfTestRsp(StopRfTestRsp),
9521     Payload(Bytes),
9522     None,
9523 }
9524 #[derive(Debug, Clone, PartialEq, Eq)]
9525 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9526 pub struct TestResponseData {
9527     child: TestResponseDataChild,
9528 }
9529 #[derive(Debug, Clone, PartialEq, Eq)]
9530 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9531 pub struct TestResponse {
9532     #[cfg_attr(feature = "serde", serde(flatten))]
9533     ucicontrolpacket: UciControlPacketData,
9534     #[cfg_attr(feature = "serde", serde(flatten))]
9535     uciresponse: UciResponseData,
9536     #[cfg_attr(feature = "serde", serde(flatten))]
9537     testresponse: TestResponseData,
9538 }
9539 #[derive(Debug)]
9540 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9541 pub struct TestResponseBuilder {
9542     pub opcode: u8,
9543     pub payload: Option<Bytes>,
9544 }
9545 impl TestResponseData {
conforms(bytes: &[u8]) -> bool9546     fn conforms(bytes: &[u8]) -> bool {
9547         true
9548     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>9549     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
9550         let mut cell = Cell::new(bytes);
9551         let packet = Self::parse_inner(&mut cell, opcode)?;
9552         Ok(packet)
9553     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>9554     fn parse_inner(
9555         mut bytes: &mut Cell<&[u8]>,
9556         opcode: u8,
9557     ) -> Result<Self, DecodeError> {
9558         let payload = bytes.get();
9559         bytes.get_mut().advance(payload.len());
9560         let child = match (opcode) {
9561             (0) if SessionSetRfTestConfigRspData::conforms(&payload) => {
9562                 let mut cell = Cell::new(payload);
9563                 let child_data = SessionSetRfTestConfigRspData::parse_inner(&mut cell)?;
9564                 TestResponseDataChild::SessionSetRfTestConfigRsp(child_data)
9565             }
9566             (2) if TestPeriodicTxRspData::conforms(&payload) => {
9567                 let mut cell = Cell::new(payload);
9568                 let child_data = TestPeriodicTxRspData::parse_inner(&mut cell)?;
9569                 TestResponseDataChild::TestPeriodicTxRsp(child_data)
9570             }
9571             (7) if StopRfTestRspData::conforms(&payload) => {
9572                 let mut cell = Cell::new(payload);
9573                 let child_data = StopRfTestRspData::parse_inner(&mut cell)?;
9574                 TestResponseDataChild::StopRfTestRsp(child_data)
9575             }
9576             _ if !payload.is_empty() => {
9577                 TestResponseDataChild::Payload(Bytes::copy_from_slice(payload))
9578             }
9579             _ => TestResponseDataChild::None,
9580         };
9581         Ok(Self { child })
9582     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>9583     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
9584         match &self.child {
9585             TestResponseDataChild::SessionSetRfTestConfigRsp(child) => {
9586                 child.write_to(buffer)?
9587             }
9588             TestResponseDataChild::TestPeriodicTxRsp(child) => child.write_to(buffer)?,
9589             TestResponseDataChild::StopRfTestRsp(child) => child.write_to(buffer)?,
9590             TestResponseDataChild::Payload(payload) => buffer.put_slice(payload),
9591             TestResponseDataChild::None => {}
9592         }
9593         Ok(())
9594     }
get_total_size(&self) -> usize9595     fn get_total_size(&self) -> usize {
9596         self.get_size()
9597     }
get_size(&self) -> usize9598     fn get_size(&self) -> usize {
9599         self.child.get_total_size()
9600     }
9601 }
9602 impl Packet for TestResponse {
encoded_len(&self) -> usize9603     fn encoded_len(&self) -> usize {
9604         self.get_size()
9605     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>9606     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
9607         self.ucicontrolpacket.write_to(buf)
9608     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>9609     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
9610         unimplemented!("Rust legacy does not implement full packet trait")
9611     }
9612 }
9613 impl TryFrom<TestResponse> for Bytes {
9614     type Error = EncodeError;
try_from(packet: TestResponse) -> Result<Self, Self::Error>9615     fn try_from(packet: TestResponse) -> Result<Self, Self::Error> {
9616         packet.encode_to_bytes()
9617     }
9618 }
9619 impl TryFrom<TestResponse> for Vec<u8> {
9620     type Error = EncodeError;
try_from(packet: TestResponse) -> Result<Self, Self::Error>9621     fn try_from(packet: TestResponse) -> Result<Self, Self::Error> {
9622         packet.encode_to_vec()
9623     }
9624 }
9625 impl From<TestResponse> for UciControlPacket {
from(packet: TestResponse) -> UciControlPacket9626     fn from(packet: TestResponse) -> UciControlPacket {
9627         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
9628     }
9629 }
9630 impl From<TestResponse> for UciResponse {
from(packet: TestResponse) -> UciResponse9631     fn from(packet: TestResponse) -> UciResponse {
9632         UciResponse::new(packet.ucicontrolpacket).unwrap()
9633     }
9634 }
9635 impl TryFrom<UciControlPacket> for TestResponse {
9636     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<TestResponse, Self::Error>9637     fn try_from(packet: UciControlPacket) -> Result<TestResponse, Self::Error> {
9638         TestResponse::new(packet.ucicontrolpacket)
9639     }
9640 }
9641 impl TestResponse {
parse(bytes: &[u8]) -> Result<Self, DecodeError>9642     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
9643         let mut cell = Cell::new(bytes);
9644         let packet = Self::parse_inner(&mut cell)?;
9645         Ok(packet)
9646     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>9647     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
9648         let data = UciControlPacketData::parse_inner(&mut bytes)?;
9649         Self::new(data)
9650     }
specialize(&self) -> TestResponseChild9651     pub fn specialize(&self) -> TestResponseChild {
9652         match &self.testresponse.child {
9653             TestResponseDataChild::SessionSetRfTestConfigRsp(_) => {
9654                 TestResponseChild::SessionSetRfTestConfigRsp(
9655                     SessionSetRfTestConfigRsp::new(self.ucicontrolpacket.clone())
9656                         .unwrap(),
9657                 )
9658             }
9659             TestResponseDataChild::TestPeriodicTxRsp(_) => {
9660                 TestResponseChild::TestPeriodicTxRsp(
9661                     TestPeriodicTxRsp::new(self.ucicontrolpacket.clone()).unwrap(),
9662                 )
9663             }
9664             TestResponseDataChild::StopRfTestRsp(_) => {
9665                 TestResponseChild::StopRfTestRsp(
9666                     StopRfTestRsp::new(self.ucicontrolpacket.clone()).unwrap(),
9667                 )
9668             }
9669             TestResponseDataChild::Payload(payload) => {
9670                 TestResponseChild::Payload(payload.clone())
9671             }
9672             TestResponseDataChild::None => TestResponseChild::None,
9673         }
9674     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>9675     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
9676         let uciresponse = match &ucicontrolpacket.child {
9677             UciControlPacketDataChild::UciResponse(value) => value.clone(),
9678             _ => {
9679                 return Err(DecodeError::InvalidChildError {
9680                     expected: stringify!(UciControlPacketDataChild::UciResponse),
9681                     actual: format!("{:?}", & ucicontrolpacket.child),
9682                 });
9683             }
9684         };
9685         let testresponse = match &uciresponse.child {
9686             UciResponseDataChild::TestResponse(value) => value.clone(),
9687             _ => {
9688                 return Err(DecodeError::InvalidChildError {
9689                     expected: stringify!(UciResponseDataChild::TestResponse),
9690                     actual: format!("{:?}", & uciresponse.child),
9691                 });
9692             }
9693         };
9694         Ok(Self {
9695             ucicontrolpacket,
9696             uciresponse,
9697             testresponse,
9698         })
9699     }
get_group_id(&self) -> GroupId9700     pub fn get_group_id(&self) -> GroupId {
9701         self.ucicontrolpacket.group_id
9702     }
get_message_type(&self) -> MessageType9703     pub fn get_message_type(&self) -> MessageType {
9704         self.ucicontrolpacket.message_type
9705     }
get_opcode(&self) -> u89706     pub fn get_opcode(&self) -> u8 {
9707         self.ucicontrolpacket.opcode
9708     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>9709     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
9710         self.testresponse.write_to(buffer)
9711     }
get_size(&self) -> usize9712     pub fn get_size(&self) -> usize {
9713         self.ucicontrolpacket.get_size()
9714     }
9715 }
9716 impl TestResponseBuilder {
build(self) -> TestResponse9717     pub fn build(self) -> TestResponse {
9718         let testresponse = TestResponseData {
9719             child: match self.payload {
9720                 None => TestResponseDataChild::None,
9721                 Some(bytes) => TestResponseDataChild::Payload(bytes),
9722             },
9723         };
9724         let uciresponse = UciResponseData {
9725             child: UciResponseDataChild::TestResponse(testresponse),
9726         };
9727         let ucicontrolpacket = UciControlPacketData {
9728             group_id: GroupId::Test,
9729             message_type: MessageType::Response,
9730             opcode: self.opcode,
9731             child: UciControlPacketDataChild::UciResponse(uciresponse),
9732         };
9733         TestResponse::new(ucicontrolpacket).unwrap()
9734     }
9735 }
9736 impl From<TestResponseBuilder> for UciControlPacket {
from(builder: TestResponseBuilder) -> UciControlPacket9737     fn from(builder: TestResponseBuilder) -> UciControlPacket {
9738         builder.build().into()
9739     }
9740 }
9741 impl From<TestResponseBuilder> for UciResponse {
from(builder: TestResponseBuilder) -> UciResponse9742     fn from(builder: TestResponseBuilder) -> UciResponse {
9743         builder.build().into()
9744     }
9745 }
9746 impl From<TestResponseBuilder> for TestResponse {
from(builder: TestResponseBuilder) -> TestResponse9747     fn from(builder: TestResponseBuilder) -> TestResponse {
9748         builder.build().into()
9749     }
9750 }
9751 #[derive(Debug, Clone, PartialEq, Eq)]
9752 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9753 pub enum TestNotificationDataChild {
9754     TestPeriodicTxNtf(TestPeriodicTxNtfData),
9755     Payload(Bytes),
9756     None,
9757 }
9758 impl TestNotificationDataChild {
get_total_size(&self) -> usize9759     fn get_total_size(&self) -> usize {
9760         match self {
9761             TestNotificationDataChild::TestPeriodicTxNtf(value) => value.get_total_size(),
9762             TestNotificationDataChild::Payload(bytes) => bytes.len(),
9763             TestNotificationDataChild::None => 0,
9764         }
9765     }
9766 }
9767 #[derive(Debug, Clone, PartialEq, Eq)]
9768 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9769 pub enum TestNotificationChild {
9770     TestPeriodicTxNtf(TestPeriodicTxNtf),
9771     Payload(Bytes),
9772     None,
9773 }
9774 #[derive(Debug, Clone, PartialEq, Eq)]
9775 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9776 pub struct TestNotificationData {
9777     child: TestNotificationDataChild,
9778 }
9779 #[derive(Debug, Clone, PartialEq, Eq)]
9780 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9781 pub struct TestNotification {
9782     #[cfg_attr(feature = "serde", serde(flatten))]
9783     ucicontrolpacket: UciControlPacketData,
9784     #[cfg_attr(feature = "serde", serde(flatten))]
9785     ucinotification: UciNotificationData,
9786     #[cfg_attr(feature = "serde", serde(flatten))]
9787     testnotification: TestNotificationData,
9788 }
9789 #[derive(Debug)]
9790 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9791 pub struct TestNotificationBuilder {
9792     pub opcode: u8,
9793     pub payload: Option<Bytes>,
9794 }
9795 impl TestNotificationData {
conforms(bytes: &[u8]) -> bool9796     fn conforms(bytes: &[u8]) -> bool {
9797         true
9798     }
parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError>9799     fn parse(bytes: &[u8], opcode: u8) -> Result<Self, DecodeError> {
9800         let mut cell = Cell::new(bytes);
9801         let packet = Self::parse_inner(&mut cell, opcode)?;
9802         Ok(packet)
9803     }
parse_inner( mut bytes: &mut Cell<&[u8]>, opcode: u8, ) -> Result<Self, DecodeError>9804     fn parse_inner(
9805         mut bytes: &mut Cell<&[u8]>,
9806         opcode: u8,
9807     ) -> Result<Self, DecodeError> {
9808         let payload = bytes.get();
9809         bytes.get_mut().advance(payload.len());
9810         let child = match (opcode) {
9811             (2) if TestPeriodicTxNtfData::conforms(&payload) => {
9812                 let mut cell = Cell::new(payload);
9813                 let child_data = TestPeriodicTxNtfData::parse_inner(&mut cell)?;
9814                 TestNotificationDataChild::TestPeriodicTxNtf(child_data)
9815             }
9816             _ if !payload.is_empty() => {
9817                 TestNotificationDataChild::Payload(Bytes::copy_from_slice(payload))
9818             }
9819             _ => TestNotificationDataChild::None,
9820         };
9821         Ok(Self { child })
9822     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>9823     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
9824         match &self.child {
9825             TestNotificationDataChild::TestPeriodicTxNtf(child) => {
9826                 child.write_to(buffer)?
9827             }
9828             TestNotificationDataChild::Payload(payload) => buffer.put_slice(payload),
9829             TestNotificationDataChild::None => {}
9830         }
9831         Ok(())
9832     }
get_total_size(&self) -> usize9833     fn get_total_size(&self) -> usize {
9834         self.get_size()
9835     }
get_size(&self) -> usize9836     fn get_size(&self) -> usize {
9837         self.child.get_total_size()
9838     }
9839 }
9840 impl Packet for TestNotification {
encoded_len(&self) -> usize9841     fn encoded_len(&self) -> usize {
9842         self.get_size()
9843     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>9844     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
9845         self.ucicontrolpacket.write_to(buf)
9846     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>9847     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
9848         unimplemented!("Rust legacy does not implement full packet trait")
9849     }
9850 }
9851 impl TryFrom<TestNotification> for Bytes {
9852     type Error = EncodeError;
try_from(packet: TestNotification) -> Result<Self, Self::Error>9853     fn try_from(packet: TestNotification) -> Result<Self, Self::Error> {
9854         packet.encode_to_bytes()
9855     }
9856 }
9857 impl TryFrom<TestNotification> for Vec<u8> {
9858     type Error = EncodeError;
try_from(packet: TestNotification) -> Result<Self, Self::Error>9859     fn try_from(packet: TestNotification) -> Result<Self, Self::Error> {
9860         packet.encode_to_vec()
9861     }
9862 }
9863 impl From<TestNotification> for UciControlPacket {
from(packet: TestNotification) -> UciControlPacket9864     fn from(packet: TestNotification) -> UciControlPacket {
9865         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
9866     }
9867 }
9868 impl From<TestNotification> for UciNotification {
from(packet: TestNotification) -> UciNotification9869     fn from(packet: TestNotification) -> UciNotification {
9870         UciNotification::new(packet.ucicontrolpacket).unwrap()
9871     }
9872 }
9873 impl TryFrom<UciControlPacket> for TestNotification {
9874     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<TestNotification, Self::Error>9875     fn try_from(packet: UciControlPacket) -> Result<TestNotification, Self::Error> {
9876         TestNotification::new(packet.ucicontrolpacket)
9877     }
9878 }
9879 impl TestNotification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>9880     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
9881         let mut cell = Cell::new(bytes);
9882         let packet = Self::parse_inner(&mut cell)?;
9883         Ok(packet)
9884     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>9885     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
9886         let data = UciControlPacketData::parse_inner(&mut bytes)?;
9887         Self::new(data)
9888     }
specialize(&self) -> TestNotificationChild9889     pub fn specialize(&self) -> TestNotificationChild {
9890         match &self.testnotification.child {
9891             TestNotificationDataChild::TestPeriodicTxNtf(_) => {
9892                 TestNotificationChild::TestPeriodicTxNtf(
9893                     TestPeriodicTxNtf::new(self.ucicontrolpacket.clone()).unwrap(),
9894                 )
9895             }
9896             TestNotificationDataChild::Payload(payload) => {
9897                 TestNotificationChild::Payload(payload.clone())
9898             }
9899             TestNotificationDataChild::None => TestNotificationChild::None,
9900         }
9901     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>9902     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
9903         let ucinotification = match &ucicontrolpacket.child {
9904             UciControlPacketDataChild::UciNotification(value) => value.clone(),
9905             _ => {
9906                 return Err(DecodeError::InvalidChildError {
9907                     expected: stringify!(UciControlPacketDataChild::UciNotification),
9908                     actual: format!("{:?}", & ucicontrolpacket.child),
9909                 });
9910             }
9911         };
9912         let testnotification = match &ucinotification.child {
9913             UciNotificationDataChild::TestNotification(value) => value.clone(),
9914             _ => {
9915                 return Err(DecodeError::InvalidChildError {
9916                     expected: stringify!(UciNotificationDataChild::TestNotification),
9917                     actual: format!("{:?}", & ucinotification.child),
9918                 });
9919             }
9920         };
9921         Ok(Self {
9922             ucicontrolpacket,
9923             ucinotification,
9924             testnotification,
9925         })
9926     }
get_group_id(&self) -> GroupId9927     pub fn get_group_id(&self) -> GroupId {
9928         self.ucicontrolpacket.group_id
9929     }
get_message_type(&self) -> MessageType9930     pub fn get_message_type(&self) -> MessageType {
9931         self.ucicontrolpacket.message_type
9932     }
get_opcode(&self) -> u89933     pub fn get_opcode(&self) -> u8 {
9934         self.ucicontrolpacket.opcode
9935     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>9936     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
9937         self.testnotification.write_to(buffer)
9938     }
get_size(&self) -> usize9939     pub fn get_size(&self) -> usize {
9940         self.ucicontrolpacket.get_size()
9941     }
9942 }
9943 impl TestNotificationBuilder {
build(self) -> TestNotification9944     pub fn build(self) -> TestNotification {
9945         let testnotification = TestNotificationData {
9946             child: match self.payload {
9947                 None => TestNotificationDataChild::None,
9948                 Some(bytes) => TestNotificationDataChild::Payload(bytes),
9949             },
9950         };
9951         let ucinotification = UciNotificationData {
9952             child: UciNotificationDataChild::TestNotification(testnotification),
9953         };
9954         let ucicontrolpacket = UciControlPacketData {
9955             group_id: GroupId::Test,
9956             message_type: MessageType::Notification,
9957             opcode: self.opcode,
9958             child: UciControlPacketDataChild::UciNotification(ucinotification),
9959         };
9960         TestNotification::new(ucicontrolpacket).unwrap()
9961     }
9962 }
9963 impl From<TestNotificationBuilder> for UciControlPacket {
from(builder: TestNotificationBuilder) -> UciControlPacket9964     fn from(builder: TestNotificationBuilder) -> UciControlPacket {
9965         builder.build().into()
9966     }
9967 }
9968 impl From<TestNotificationBuilder> for UciNotification {
from(builder: TestNotificationBuilder) -> UciNotification9969     fn from(builder: TestNotificationBuilder) -> UciNotification {
9970         builder.build().into()
9971     }
9972 }
9973 impl From<TestNotificationBuilder> for TestNotification {
from(builder: TestNotificationBuilder) -> TestNotification9974     fn from(builder: TestNotificationBuilder) -> TestNotification {
9975         builder.build().into()
9976     }
9977 }
9978 #[derive(Debug, Clone, PartialEq, Eq)]
9979 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9980 pub struct DeviceResetCmdData {
9981     reset_config: ResetConfig,
9982 }
9983 #[derive(Debug, Clone, PartialEq, Eq)]
9984 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9985 pub struct DeviceResetCmd {
9986     #[cfg_attr(feature = "serde", serde(flatten))]
9987     ucicontrolpacket: UciControlPacketData,
9988     #[cfg_attr(feature = "serde", serde(flatten))]
9989     ucicommand: UciCommandData,
9990     #[cfg_attr(feature = "serde", serde(flatten))]
9991     corecommand: CoreCommandData,
9992     #[cfg_attr(feature = "serde", serde(flatten))]
9993     deviceresetcmd: DeviceResetCmdData,
9994 }
9995 #[derive(Debug)]
9996 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9997 pub struct DeviceResetCmdBuilder {
9998     pub reset_config: ResetConfig,
9999 }
10000 impl DeviceResetCmdData {
conforms(bytes: &[u8]) -> bool10001     fn conforms(bytes: &[u8]) -> bool {
10002         bytes.len() >= 1
10003     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>10004     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
10005         let mut cell = Cell::new(bytes);
10006         let packet = Self::parse_inner(&mut cell)?;
10007         Ok(packet)
10008     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>10009     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
10010         if bytes.get().remaining() < 1 {
10011             return Err(DecodeError::InvalidLengthError {
10012                 obj: "DeviceResetCmd",
10013                 wanted: 1,
10014                 got: bytes.get().remaining(),
10015             });
10016         }
10017         let reset_config = ResetConfig::try_from(bytes.get_mut().get_u8())
10018             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
10019                 obj: "DeviceResetCmd",
10020                 field: "reset_config",
10021                 value: unknown_val as u64,
10022                 type_: "ResetConfig",
10023             })?;
10024         Ok(Self { reset_config })
10025     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>10026     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
10027         buffer.put_u8(u8::from(self.reset_config));
10028         Ok(())
10029     }
get_total_size(&self) -> usize10030     fn get_total_size(&self) -> usize {
10031         self.get_size()
10032     }
get_size(&self) -> usize10033     fn get_size(&self) -> usize {
10034         1
10035     }
10036 }
10037 impl Packet for DeviceResetCmd {
encoded_len(&self) -> usize10038     fn encoded_len(&self) -> usize {
10039         self.get_size()
10040     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>10041     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
10042         self.ucicontrolpacket.write_to(buf)
10043     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>10044     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
10045         unimplemented!("Rust legacy does not implement full packet trait")
10046     }
10047 }
10048 impl TryFrom<DeviceResetCmd> for Bytes {
10049     type Error = EncodeError;
try_from(packet: DeviceResetCmd) -> Result<Self, Self::Error>10050     fn try_from(packet: DeviceResetCmd) -> Result<Self, Self::Error> {
10051         packet.encode_to_bytes()
10052     }
10053 }
10054 impl TryFrom<DeviceResetCmd> for Vec<u8> {
10055     type Error = EncodeError;
try_from(packet: DeviceResetCmd) -> Result<Self, Self::Error>10056     fn try_from(packet: DeviceResetCmd) -> Result<Self, Self::Error> {
10057         packet.encode_to_vec()
10058     }
10059 }
10060 impl From<DeviceResetCmd> for UciControlPacket {
from(packet: DeviceResetCmd) -> UciControlPacket10061     fn from(packet: DeviceResetCmd) -> UciControlPacket {
10062         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
10063     }
10064 }
10065 impl From<DeviceResetCmd> for UciCommand {
from(packet: DeviceResetCmd) -> UciCommand10066     fn from(packet: DeviceResetCmd) -> UciCommand {
10067         UciCommand::new(packet.ucicontrolpacket).unwrap()
10068     }
10069 }
10070 impl From<DeviceResetCmd> for CoreCommand {
from(packet: DeviceResetCmd) -> CoreCommand10071     fn from(packet: DeviceResetCmd) -> CoreCommand {
10072         CoreCommand::new(packet.ucicontrolpacket).unwrap()
10073     }
10074 }
10075 impl TryFrom<UciControlPacket> for DeviceResetCmd {
10076     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<DeviceResetCmd, Self::Error>10077     fn try_from(packet: UciControlPacket) -> Result<DeviceResetCmd, Self::Error> {
10078         DeviceResetCmd::new(packet.ucicontrolpacket)
10079     }
10080 }
10081 impl DeviceResetCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>10082     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
10083         let mut cell = Cell::new(bytes);
10084         let packet = Self::parse_inner(&mut cell)?;
10085         Ok(packet)
10086     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>10087     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
10088         let data = UciControlPacketData::parse_inner(&mut bytes)?;
10089         Self::new(data)
10090     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>10091     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
10092         let ucicommand = match &ucicontrolpacket.child {
10093             UciControlPacketDataChild::UciCommand(value) => value.clone(),
10094             _ => {
10095                 return Err(DecodeError::InvalidChildError {
10096                     expected: stringify!(UciControlPacketDataChild::UciCommand),
10097                     actual: format!("{:?}", & ucicontrolpacket.child),
10098                 });
10099             }
10100         };
10101         let corecommand = match &ucicommand.child {
10102             UciCommandDataChild::CoreCommand(value) => value.clone(),
10103             _ => {
10104                 return Err(DecodeError::InvalidChildError {
10105                     expected: stringify!(UciCommandDataChild::CoreCommand),
10106                     actual: format!("{:?}", & ucicommand.child),
10107                 });
10108             }
10109         };
10110         let deviceresetcmd = match &corecommand.child {
10111             CoreCommandDataChild::DeviceResetCmd(value) => value.clone(),
10112             _ => {
10113                 return Err(DecodeError::InvalidChildError {
10114                     expected: stringify!(CoreCommandDataChild::DeviceResetCmd),
10115                     actual: format!("{:?}", & corecommand.child),
10116                 });
10117             }
10118         };
10119         Ok(Self {
10120             ucicontrolpacket,
10121             ucicommand,
10122             corecommand,
10123             deviceresetcmd,
10124         })
10125     }
get_group_id(&self) -> GroupId10126     pub fn get_group_id(&self) -> GroupId {
10127         self.ucicontrolpacket.group_id
10128     }
get_message_type(&self) -> MessageType10129     pub fn get_message_type(&self) -> MessageType {
10130         self.ucicontrolpacket.message_type
10131     }
get_opcode(&self) -> u810132     pub fn get_opcode(&self) -> u8 {
10133         self.ucicontrolpacket.opcode
10134     }
get_reset_config(&self) -> ResetConfig10135     pub fn get_reset_config(&self) -> ResetConfig {
10136         self.deviceresetcmd.reset_config
10137     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>10138     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
10139         self.deviceresetcmd.write_to(buffer)
10140     }
get_size(&self) -> usize10141     pub fn get_size(&self) -> usize {
10142         self.ucicontrolpacket.get_size()
10143     }
10144 }
10145 impl DeviceResetCmdBuilder {
build(self) -> DeviceResetCmd10146     pub fn build(self) -> DeviceResetCmd {
10147         let deviceresetcmd = DeviceResetCmdData {
10148             reset_config: self.reset_config,
10149         };
10150         let corecommand = CoreCommandData {
10151             child: CoreCommandDataChild::DeviceResetCmd(deviceresetcmd),
10152         };
10153         let ucicommand = UciCommandData {
10154             child: UciCommandDataChild::CoreCommand(corecommand),
10155         };
10156         let ucicontrolpacket = UciControlPacketData {
10157             group_id: GroupId::Core,
10158             message_type: MessageType::Command,
10159             opcode: 0,
10160             child: UciControlPacketDataChild::UciCommand(ucicommand),
10161         };
10162         DeviceResetCmd::new(ucicontrolpacket).unwrap()
10163     }
10164 }
10165 impl From<DeviceResetCmdBuilder> for UciControlPacket {
from(builder: DeviceResetCmdBuilder) -> UciControlPacket10166     fn from(builder: DeviceResetCmdBuilder) -> UciControlPacket {
10167         builder.build().into()
10168     }
10169 }
10170 impl From<DeviceResetCmdBuilder> for UciCommand {
from(builder: DeviceResetCmdBuilder) -> UciCommand10171     fn from(builder: DeviceResetCmdBuilder) -> UciCommand {
10172         builder.build().into()
10173     }
10174 }
10175 impl From<DeviceResetCmdBuilder> for CoreCommand {
from(builder: DeviceResetCmdBuilder) -> CoreCommand10176     fn from(builder: DeviceResetCmdBuilder) -> CoreCommand {
10177         builder.build().into()
10178     }
10179 }
10180 impl From<DeviceResetCmdBuilder> for DeviceResetCmd {
from(builder: DeviceResetCmdBuilder) -> DeviceResetCmd10181     fn from(builder: DeviceResetCmdBuilder) -> DeviceResetCmd {
10182         builder.build().into()
10183     }
10184 }
10185 #[derive(Debug, Clone, PartialEq, Eq)]
10186 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10187 pub struct DeviceResetRspData {
10188     status: StatusCode,
10189 }
10190 #[derive(Debug, Clone, PartialEq, Eq)]
10191 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10192 pub struct DeviceResetRsp {
10193     #[cfg_attr(feature = "serde", serde(flatten))]
10194     ucicontrolpacket: UciControlPacketData,
10195     #[cfg_attr(feature = "serde", serde(flatten))]
10196     uciresponse: UciResponseData,
10197     #[cfg_attr(feature = "serde", serde(flatten))]
10198     coreresponse: CoreResponseData,
10199     #[cfg_attr(feature = "serde", serde(flatten))]
10200     deviceresetrsp: DeviceResetRspData,
10201 }
10202 #[derive(Debug)]
10203 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10204 pub struct DeviceResetRspBuilder {
10205     pub status: StatusCode,
10206 }
10207 impl DeviceResetRspData {
conforms(bytes: &[u8]) -> bool10208     fn conforms(bytes: &[u8]) -> bool {
10209         bytes.len() >= 1
10210     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>10211     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
10212         let mut cell = Cell::new(bytes);
10213         let packet = Self::parse_inner(&mut cell)?;
10214         Ok(packet)
10215     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>10216     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
10217         if bytes.get().remaining() < 1 {
10218             return Err(DecodeError::InvalidLengthError {
10219                 obj: "DeviceResetRsp",
10220                 wanted: 1,
10221                 got: bytes.get().remaining(),
10222             });
10223         }
10224         let status = StatusCode::try_from(bytes.get_mut().get_u8())
10225             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
10226                 obj: "DeviceResetRsp",
10227                 field: "status",
10228                 value: unknown_val as u64,
10229                 type_: "StatusCode",
10230             })?;
10231         Ok(Self { status })
10232     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>10233     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
10234         buffer.put_u8(u8::from(self.status));
10235         Ok(())
10236     }
get_total_size(&self) -> usize10237     fn get_total_size(&self) -> usize {
10238         self.get_size()
10239     }
get_size(&self) -> usize10240     fn get_size(&self) -> usize {
10241         1
10242     }
10243 }
10244 impl Packet for DeviceResetRsp {
encoded_len(&self) -> usize10245     fn encoded_len(&self) -> usize {
10246         self.get_size()
10247     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>10248     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
10249         self.ucicontrolpacket.write_to(buf)
10250     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>10251     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
10252         unimplemented!("Rust legacy does not implement full packet trait")
10253     }
10254 }
10255 impl TryFrom<DeviceResetRsp> for Bytes {
10256     type Error = EncodeError;
try_from(packet: DeviceResetRsp) -> Result<Self, Self::Error>10257     fn try_from(packet: DeviceResetRsp) -> Result<Self, Self::Error> {
10258         packet.encode_to_bytes()
10259     }
10260 }
10261 impl TryFrom<DeviceResetRsp> for Vec<u8> {
10262     type Error = EncodeError;
try_from(packet: DeviceResetRsp) -> Result<Self, Self::Error>10263     fn try_from(packet: DeviceResetRsp) -> Result<Self, Self::Error> {
10264         packet.encode_to_vec()
10265     }
10266 }
10267 impl From<DeviceResetRsp> for UciControlPacket {
from(packet: DeviceResetRsp) -> UciControlPacket10268     fn from(packet: DeviceResetRsp) -> UciControlPacket {
10269         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
10270     }
10271 }
10272 impl From<DeviceResetRsp> for UciResponse {
from(packet: DeviceResetRsp) -> UciResponse10273     fn from(packet: DeviceResetRsp) -> UciResponse {
10274         UciResponse::new(packet.ucicontrolpacket).unwrap()
10275     }
10276 }
10277 impl From<DeviceResetRsp> for CoreResponse {
from(packet: DeviceResetRsp) -> CoreResponse10278     fn from(packet: DeviceResetRsp) -> CoreResponse {
10279         CoreResponse::new(packet.ucicontrolpacket).unwrap()
10280     }
10281 }
10282 impl TryFrom<UciControlPacket> for DeviceResetRsp {
10283     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<DeviceResetRsp, Self::Error>10284     fn try_from(packet: UciControlPacket) -> Result<DeviceResetRsp, Self::Error> {
10285         DeviceResetRsp::new(packet.ucicontrolpacket)
10286     }
10287 }
10288 impl DeviceResetRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>10289     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
10290         let mut cell = Cell::new(bytes);
10291         let packet = Self::parse_inner(&mut cell)?;
10292         Ok(packet)
10293     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>10294     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
10295         let data = UciControlPacketData::parse_inner(&mut bytes)?;
10296         Self::new(data)
10297     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>10298     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
10299         let uciresponse = match &ucicontrolpacket.child {
10300             UciControlPacketDataChild::UciResponse(value) => value.clone(),
10301             _ => {
10302                 return Err(DecodeError::InvalidChildError {
10303                     expected: stringify!(UciControlPacketDataChild::UciResponse),
10304                     actual: format!("{:?}", & ucicontrolpacket.child),
10305                 });
10306             }
10307         };
10308         let coreresponse = match &uciresponse.child {
10309             UciResponseDataChild::CoreResponse(value) => value.clone(),
10310             _ => {
10311                 return Err(DecodeError::InvalidChildError {
10312                     expected: stringify!(UciResponseDataChild::CoreResponse),
10313                     actual: format!("{:?}", & uciresponse.child),
10314                 });
10315             }
10316         };
10317         let deviceresetrsp = match &coreresponse.child {
10318             CoreResponseDataChild::DeviceResetRsp(value) => value.clone(),
10319             _ => {
10320                 return Err(DecodeError::InvalidChildError {
10321                     expected: stringify!(CoreResponseDataChild::DeviceResetRsp),
10322                     actual: format!("{:?}", & coreresponse.child),
10323                 });
10324             }
10325         };
10326         Ok(Self {
10327             ucicontrolpacket,
10328             uciresponse,
10329             coreresponse,
10330             deviceresetrsp,
10331         })
10332     }
get_group_id(&self) -> GroupId10333     pub fn get_group_id(&self) -> GroupId {
10334         self.ucicontrolpacket.group_id
10335     }
get_message_type(&self) -> MessageType10336     pub fn get_message_type(&self) -> MessageType {
10337         self.ucicontrolpacket.message_type
10338     }
get_opcode(&self) -> u810339     pub fn get_opcode(&self) -> u8 {
10340         self.ucicontrolpacket.opcode
10341     }
get_status(&self) -> StatusCode10342     pub fn get_status(&self) -> StatusCode {
10343         self.deviceresetrsp.status
10344     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>10345     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
10346         self.deviceresetrsp.write_to(buffer)
10347     }
get_size(&self) -> usize10348     pub fn get_size(&self) -> usize {
10349         self.ucicontrolpacket.get_size()
10350     }
10351 }
10352 impl DeviceResetRspBuilder {
build(self) -> DeviceResetRsp10353     pub fn build(self) -> DeviceResetRsp {
10354         let deviceresetrsp = DeviceResetRspData {
10355             status: self.status,
10356         };
10357         let coreresponse = CoreResponseData {
10358             child: CoreResponseDataChild::DeviceResetRsp(deviceresetrsp),
10359         };
10360         let uciresponse = UciResponseData {
10361             child: UciResponseDataChild::CoreResponse(coreresponse),
10362         };
10363         let ucicontrolpacket = UciControlPacketData {
10364             group_id: GroupId::Core,
10365             message_type: MessageType::Response,
10366             opcode: 0,
10367             child: UciControlPacketDataChild::UciResponse(uciresponse),
10368         };
10369         DeviceResetRsp::new(ucicontrolpacket).unwrap()
10370     }
10371 }
10372 impl From<DeviceResetRspBuilder> for UciControlPacket {
from(builder: DeviceResetRspBuilder) -> UciControlPacket10373     fn from(builder: DeviceResetRspBuilder) -> UciControlPacket {
10374         builder.build().into()
10375     }
10376 }
10377 impl From<DeviceResetRspBuilder> for UciResponse {
from(builder: DeviceResetRspBuilder) -> UciResponse10378     fn from(builder: DeviceResetRspBuilder) -> UciResponse {
10379         builder.build().into()
10380     }
10381 }
10382 impl From<DeviceResetRspBuilder> for CoreResponse {
from(builder: DeviceResetRspBuilder) -> CoreResponse10383     fn from(builder: DeviceResetRspBuilder) -> CoreResponse {
10384         builder.build().into()
10385     }
10386 }
10387 impl From<DeviceResetRspBuilder> for DeviceResetRsp {
from(builder: DeviceResetRspBuilder) -> DeviceResetRsp10388     fn from(builder: DeviceResetRspBuilder) -> DeviceResetRsp {
10389         builder.build().into()
10390     }
10391 }
10392 #[derive(Debug, Clone, PartialEq, Eq)]
10393 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10394 pub struct DeviceStatusNtfData {
10395     device_state: DeviceState,
10396 }
10397 #[derive(Debug, Clone, PartialEq, Eq)]
10398 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10399 pub struct DeviceStatusNtf {
10400     #[cfg_attr(feature = "serde", serde(flatten))]
10401     ucicontrolpacket: UciControlPacketData,
10402     #[cfg_attr(feature = "serde", serde(flatten))]
10403     ucinotification: UciNotificationData,
10404     #[cfg_attr(feature = "serde", serde(flatten))]
10405     corenotification: CoreNotificationData,
10406     #[cfg_attr(feature = "serde", serde(flatten))]
10407     devicestatusntf: DeviceStatusNtfData,
10408 }
10409 #[derive(Debug)]
10410 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10411 pub struct DeviceStatusNtfBuilder {
10412     pub device_state: DeviceState,
10413 }
10414 impl DeviceStatusNtfData {
conforms(bytes: &[u8]) -> bool10415     fn conforms(bytes: &[u8]) -> bool {
10416         bytes.len() >= 1
10417     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>10418     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
10419         let mut cell = Cell::new(bytes);
10420         let packet = Self::parse_inner(&mut cell)?;
10421         Ok(packet)
10422     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>10423     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
10424         if bytes.get().remaining() < 1 {
10425             return Err(DecodeError::InvalidLengthError {
10426                 obj: "DeviceStatusNtf",
10427                 wanted: 1,
10428                 got: bytes.get().remaining(),
10429             });
10430         }
10431         let device_state = DeviceState::try_from(bytes.get_mut().get_u8())
10432             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
10433                 obj: "DeviceStatusNtf",
10434                 field: "device_state",
10435                 value: unknown_val as u64,
10436                 type_: "DeviceState",
10437             })?;
10438         Ok(Self { device_state })
10439     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>10440     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
10441         buffer.put_u8(u8::from(self.device_state));
10442         Ok(())
10443     }
get_total_size(&self) -> usize10444     fn get_total_size(&self) -> usize {
10445         self.get_size()
10446     }
get_size(&self) -> usize10447     fn get_size(&self) -> usize {
10448         1
10449     }
10450 }
10451 impl Packet for DeviceStatusNtf {
encoded_len(&self) -> usize10452     fn encoded_len(&self) -> usize {
10453         self.get_size()
10454     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>10455     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
10456         self.ucicontrolpacket.write_to(buf)
10457     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>10458     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
10459         unimplemented!("Rust legacy does not implement full packet trait")
10460     }
10461 }
10462 impl TryFrom<DeviceStatusNtf> for Bytes {
10463     type Error = EncodeError;
try_from(packet: DeviceStatusNtf) -> Result<Self, Self::Error>10464     fn try_from(packet: DeviceStatusNtf) -> Result<Self, Self::Error> {
10465         packet.encode_to_bytes()
10466     }
10467 }
10468 impl TryFrom<DeviceStatusNtf> for Vec<u8> {
10469     type Error = EncodeError;
try_from(packet: DeviceStatusNtf) -> Result<Self, Self::Error>10470     fn try_from(packet: DeviceStatusNtf) -> Result<Self, Self::Error> {
10471         packet.encode_to_vec()
10472     }
10473 }
10474 impl From<DeviceStatusNtf> for UciControlPacket {
from(packet: DeviceStatusNtf) -> UciControlPacket10475     fn from(packet: DeviceStatusNtf) -> UciControlPacket {
10476         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
10477     }
10478 }
10479 impl From<DeviceStatusNtf> for UciNotification {
from(packet: DeviceStatusNtf) -> UciNotification10480     fn from(packet: DeviceStatusNtf) -> UciNotification {
10481         UciNotification::new(packet.ucicontrolpacket).unwrap()
10482     }
10483 }
10484 impl From<DeviceStatusNtf> for CoreNotification {
from(packet: DeviceStatusNtf) -> CoreNotification10485     fn from(packet: DeviceStatusNtf) -> CoreNotification {
10486         CoreNotification::new(packet.ucicontrolpacket).unwrap()
10487     }
10488 }
10489 impl TryFrom<UciControlPacket> for DeviceStatusNtf {
10490     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<DeviceStatusNtf, Self::Error>10491     fn try_from(packet: UciControlPacket) -> Result<DeviceStatusNtf, Self::Error> {
10492         DeviceStatusNtf::new(packet.ucicontrolpacket)
10493     }
10494 }
10495 impl DeviceStatusNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>10496     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
10497         let mut cell = Cell::new(bytes);
10498         let packet = Self::parse_inner(&mut cell)?;
10499         Ok(packet)
10500     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>10501     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
10502         let data = UciControlPacketData::parse_inner(&mut bytes)?;
10503         Self::new(data)
10504     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>10505     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
10506         let ucinotification = match &ucicontrolpacket.child {
10507             UciControlPacketDataChild::UciNotification(value) => value.clone(),
10508             _ => {
10509                 return Err(DecodeError::InvalidChildError {
10510                     expected: stringify!(UciControlPacketDataChild::UciNotification),
10511                     actual: format!("{:?}", & ucicontrolpacket.child),
10512                 });
10513             }
10514         };
10515         let corenotification = match &ucinotification.child {
10516             UciNotificationDataChild::CoreNotification(value) => value.clone(),
10517             _ => {
10518                 return Err(DecodeError::InvalidChildError {
10519                     expected: stringify!(UciNotificationDataChild::CoreNotification),
10520                     actual: format!("{:?}", & ucinotification.child),
10521                 });
10522             }
10523         };
10524         let devicestatusntf = match &corenotification.child {
10525             CoreNotificationDataChild::DeviceStatusNtf(value) => value.clone(),
10526             _ => {
10527                 return Err(DecodeError::InvalidChildError {
10528                     expected: stringify!(CoreNotificationDataChild::DeviceStatusNtf),
10529                     actual: format!("{:?}", & corenotification.child),
10530                 });
10531             }
10532         };
10533         Ok(Self {
10534             ucicontrolpacket,
10535             ucinotification,
10536             corenotification,
10537             devicestatusntf,
10538         })
10539     }
get_device_state(&self) -> DeviceState10540     pub fn get_device_state(&self) -> DeviceState {
10541         self.devicestatusntf.device_state
10542     }
get_group_id(&self) -> GroupId10543     pub fn get_group_id(&self) -> GroupId {
10544         self.ucicontrolpacket.group_id
10545     }
get_message_type(&self) -> MessageType10546     pub fn get_message_type(&self) -> MessageType {
10547         self.ucicontrolpacket.message_type
10548     }
get_opcode(&self) -> u810549     pub fn get_opcode(&self) -> u8 {
10550         self.ucicontrolpacket.opcode
10551     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>10552     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
10553         self.devicestatusntf.write_to(buffer)
10554     }
get_size(&self) -> usize10555     pub fn get_size(&self) -> usize {
10556         self.ucicontrolpacket.get_size()
10557     }
10558 }
10559 impl DeviceStatusNtfBuilder {
build(self) -> DeviceStatusNtf10560     pub fn build(self) -> DeviceStatusNtf {
10561         let devicestatusntf = DeviceStatusNtfData {
10562             device_state: self.device_state,
10563         };
10564         let corenotification = CoreNotificationData {
10565             child: CoreNotificationDataChild::DeviceStatusNtf(devicestatusntf),
10566         };
10567         let ucinotification = UciNotificationData {
10568             child: UciNotificationDataChild::CoreNotification(corenotification),
10569         };
10570         let ucicontrolpacket = UciControlPacketData {
10571             group_id: GroupId::Core,
10572             message_type: MessageType::Notification,
10573             opcode: 1,
10574             child: UciControlPacketDataChild::UciNotification(ucinotification),
10575         };
10576         DeviceStatusNtf::new(ucicontrolpacket).unwrap()
10577     }
10578 }
10579 impl From<DeviceStatusNtfBuilder> for UciControlPacket {
from(builder: DeviceStatusNtfBuilder) -> UciControlPacket10580     fn from(builder: DeviceStatusNtfBuilder) -> UciControlPacket {
10581         builder.build().into()
10582     }
10583 }
10584 impl From<DeviceStatusNtfBuilder> for UciNotification {
from(builder: DeviceStatusNtfBuilder) -> UciNotification10585     fn from(builder: DeviceStatusNtfBuilder) -> UciNotification {
10586         builder.build().into()
10587     }
10588 }
10589 impl From<DeviceStatusNtfBuilder> for CoreNotification {
from(builder: DeviceStatusNtfBuilder) -> CoreNotification10590     fn from(builder: DeviceStatusNtfBuilder) -> CoreNotification {
10591         builder.build().into()
10592     }
10593 }
10594 impl From<DeviceStatusNtfBuilder> for DeviceStatusNtf {
from(builder: DeviceStatusNtfBuilder) -> DeviceStatusNtf10595     fn from(builder: DeviceStatusNtfBuilder) -> DeviceStatusNtf {
10596         builder.build().into()
10597     }
10598 }
10599 #[derive(Debug, Clone, PartialEq, Eq)]
10600 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10601 pub struct GetDeviceInfoCmdData {}
10602 #[derive(Debug, Clone, PartialEq, Eq)]
10603 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10604 pub struct GetDeviceInfoCmd {
10605     #[cfg_attr(feature = "serde", serde(flatten))]
10606     ucicontrolpacket: UciControlPacketData,
10607     #[cfg_attr(feature = "serde", serde(flatten))]
10608     ucicommand: UciCommandData,
10609     #[cfg_attr(feature = "serde", serde(flatten))]
10610     corecommand: CoreCommandData,
10611     #[cfg_attr(feature = "serde", serde(flatten))]
10612     getdeviceinfocmd: GetDeviceInfoCmdData,
10613 }
10614 #[derive(Debug)]
10615 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10616 pub struct GetDeviceInfoCmdBuilder {}
10617 impl GetDeviceInfoCmdData {
conforms(bytes: &[u8]) -> bool10618     fn conforms(bytes: &[u8]) -> bool {
10619         true
10620     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>10621     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
10622         let mut cell = Cell::new(bytes);
10623         let packet = Self::parse_inner(&mut cell)?;
10624         Ok(packet)
10625     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>10626     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
10627         Ok(Self {})
10628     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>10629     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
10630         Ok(())
10631     }
get_total_size(&self) -> usize10632     fn get_total_size(&self) -> usize {
10633         self.get_size()
10634     }
get_size(&self) -> usize10635     fn get_size(&self) -> usize {
10636         0
10637     }
10638 }
10639 impl Packet for GetDeviceInfoCmd {
encoded_len(&self) -> usize10640     fn encoded_len(&self) -> usize {
10641         self.get_size()
10642     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>10643     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
10644         self.ucicontrolpacket.write_to(buf)
10645     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>10646     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
10647         unimplemented!("Rust legacy does not implement full packet trait")
10648     }
10649 }
10650 impl TryFrom<GetDeviceInfoCmd> for Bytes {
10651     type Error = EncodeError;
try_from(packet: GetDeviceInfoCmd) -> Result<Self, Self::Error>10652     fn try_from(packet: GetDeviceInfoCmd) -> Result<Self, Self::Error> {
10653         packet.encode_to_bytes()
10654     }
10655 }
10656 impl TryFrom<GetDeviceInfoCmd> for Vec<u8> {
10657     type Error = EncodeError;
try_from(packet: GetDeviceInfoCmd) -> Result<Self, Self::Error>10658     fn try_from(packet: GetDeviceInfoCmd) -> Result<Self, Self::Error> {
10659         packet.encode_to_vec()
10660     }
10661 }
10662 impl From<GetDeviceInfoCmd> for UciControlPacket {
from(packet: GetDeviceInfoCmd) -> UciControlPacket10663     fn from(packet: GetDeviceInfoCmd) -> UciControlPacket {
10664         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
10665     }
10666 }
10667 impl From<GetDeviceInfoCmd> for UciCommand {
from(packet: GetDeviceInfoCmd) -> UciCommand10668     fn from(packet: GetDeviceInfoCmd) -> UciCommand {
10669         UciCommand::new(packet.ucicontrolpacket).unwrap()
10670     }
10671 }
10672 impl From<GetDeviceInfoCmd> for CoreCommand {
from(packet: GetDeviceInfoCmd) -> CoreCommand10673     fn from(packet: GetDeviceInfoCmd) -> CoreCommand {
10674         CoreCommand::new(packet.ucicontrolpacket).unwrap()
10675     }
10676 }
10677 impl TryFrom<UciControlPacket> for GetDeviceInfoCmd {
10678     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<GetDeviceInfoCmd, Self::Error>10679     fn try_from(packet: UciControlPacket) -> Result<GetDeviceInfoCmd, Self::Error> {
10680         GetDeviceInfoCmd::new(packet.ucicontrolpacket)
10681     }
10682 }
10683 impl GetDeviceInfoCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>10684     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
10685         let mut cell = Cell::new(bytes);
10686         let packet = Self::parse_inner(&mut cell)?;
10687         Ok(packet)
10688     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>10689     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
10690         let data = UciControlPacketData::parse_inner(&mut bytes)?;
10691         Self::new(data)
10692     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>10693     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
10694         let ucicommand = match &ucicontrolpacket.child {
10695             UciControlPacketDataChild::UciCommand(value) => value.clone(),
10696             _ => {
10697                 return Err(DecodeError::InvalidChildError {
10698                     expected: stringify!(UciControlPacketDataChild::UciCommand),
10699                     actual: format!("{:?}", & ucicontrolpacket.child),
10700                 });
10701             }
10702         };
10703         let corecommand = match &ucicommand.child {
10704             UciCommandDataChild::CoreCommand(value) => value.clone(),
10705             _ => {
10706                 return Err(DecodeError::InvalidChildError {
10707                     expected: stringify!(UciCommandDataChild::CoreCommand),
10708                     actual: format!("{:?}", & ucicommand.child),
10709                 });
10710             }
10711         };
10712         let getdeviceinfocmd = match &corecommand.child {
10713             CoreCommandDataChild::GetDeviceInfoCmd(value) => value.clone(),
10714             _ => {
10715                 return Err(DecodeError::InvalidChildError {
10716                     expected: stringify!(CoreCommandDataChild::GetDeviceInfoCmd),
10717                     actual: format!("{:?}", & corecommand.child),
10718                 });
10719             }
10720         };
10721         Ok(Self {
10722             ucicontrolpacket,
10723             ucicommand,
10724             corecommand,
10725             getdeviceinfocmd,
10726         })
10727     }
get_group_id(&self) -> GroupId10728     pub fn get_group_id(&self) -> GroupId {
10729         self.ucicontrolpacket.group_id
10730     }
get_message_type(&self) -> MessageType10731     pub fn get_message_type(&self) -> MessageType {
10732         self.ucicontrolpacket.message_type
10733     }
get_opcode(&self) -> u810734     pub fn get_opcode(&self) -> u8 {
10735         self.ucicontrolpacket.opcode
10736     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>10737     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
10738         self.getdeviceinfocmd.write_to(buffer)
10739     }
get_size(&self) -> usize10740     pub fn get_size(&self) -> usize {
10741         self.ucicontrolpacket.get_size()
10742     }
10743 }
10744 impl GetDeviceInfoCmdBuilder {
build(self) -> GetDeviceInfoCmd10745     pub fn build(self) -> GetDeviceInfoCmd {
10746         let getdeviceinfocmd = GetDeviceInfoCmdData {};
10747         let corecommand = CoreCommandData {
10748             child: CoreCommandDataChild::GetDeviceInfoCmd(getdeviceinfocmd),
10749         };
10750         let ucicommand = UciCommandData {
10751             child: UciCommandDataChild::CoreCommand(corecommand),
10752         };
10753         let ucicontrolpacket = UciControlPacketData {
10754             group_id: GroupId::Core,
10755             message_type: MessageType::Command,
10756             opcode: 2,
10757             child: UciControlPacketDataChild::UciCommand(ucicommand),
10758         };
10759         GetDeviceInfoCmd::new(ucicontrolpacket).unwrap()
10760     }
10761 }
10762 impl From<GetDeviceInfoCmdBuilder> for UciControlPacket {
from(builder: GetDeviceInfoCmdBuilder) -> UciControlPacket10763     fn from(builder: GetDeviceInfoCmdBuilder) -> UciControlPacket {
10764         builder.build().into()
10765     }
10766 }
10767 impl From<GetDeviceInfoCmdBuilder> for UciCommand {
from(builder: GetDeviceInfoCmdBuilder) -> UciCommand10768     fn from(builder: GetDeviceInfoCmdBuilder) -> UciCommand {
10769         builder.build().into()
10770     }
10771 }
10772 impl From<GetDeviceInfoCmdBuilder> for CoreCommand {
from(builder: GetDeviceInfoCmdBuilder) -> CoreCommand10773     fn from(builder: GetDeviceInfoCmdBuilder) -> CoreCommand {
10774         builder.build().into()
10775     }
10776 }
10777 impl From<GetDeviceInfoCmdBuilder> for GetDeviceInfoCmd {
from(builder: GetDeviceInfoCmdBuilder) -> GetDeviceInfoCmd10778     fn from(builder: GetDeviceInfoCmdBuilder) -> GetDeviceInfoCmd {
10779         builder.build().into()
10780     }
10781 }
10782 #[derive(Debug, Clone, PartialEq, Eq)]
10783 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10784 pub struct GetDeviceInfoRspData {
10785     status: StatusCode,
10786     uci_version: u16,
10787     mac_version: u16,
10788     phy_version: u16,
10789     uci_test_version: u16,
10790     vendor_spec_info: Vec<u8>,
10791 }
10792 #[derive(Debug, Clone, PartialEq, Eq)]
10793 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10794 pub struct GetDeviceInfoRsp {
10795     #[cfg_attr(feature = "serde", serde(flatten))]
10796     ucicontrolpacket: UciControlPacketData,
10797     #[cfg_attr(feature = "serde", serde(flatten))]
10798     uciresponse: UciResponseData,
10799     #[cfg_attr(feature = "serde", serde(flatten))]
10800     coreresponse: CoreResponseData,
10801     #[cfg_attr(feature = "serde", serde(flatten))]
10802     getdeviceinforsp: GetDeviceInfoRspData,
10803 }
10804 #[derive(Debug)]
10805 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
10806 pub struct GetDeviceInfoRspBuilder {
10807     pub mac_version: u16,
10808     pub phy_version: u16,
10809     pub status: StatusCode,
10810     pub uci_test_version: u16,
10811     pub uci_version: u16,
10812     pub vendor_spec_info: Vec<u8>,
10813 }
10814 impl GetDeviceInfoRspData {
conforms(bytes: &[u8]) -> bool10815     fn conforms(bytes: &[u8]) -> bool {
10816         bytes.len() >= 10
10817     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>10818     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
10819         let mut cell = Cell::new(bytes);
10820         let packet = Self::parse_inner(&mut cell)?;
10821         Ok(packet)
10822     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>10823     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
10824         if bytes.get().remaining() < 1 {
10825             return Err(DecodeError::InvalidLengthError {
10826                 obj: "GetDeviceInfoRsp",
10827                 wanted: 1,
10828                 got: bytes.get().remaining(),
10829             });
10830         }
10831         let status = StatusCode::try_from(bytes.get_mut().get_u8())
10832             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
10833                 obj: "GetDeviceInfoRsp",
10834                 field: "status",
10835                 value: unknown_val as u64,
10836                 type_: "StatusCode",
10837             })?;
10838         if bytes.get().remaining() < 2 {
10839             return Err(DecodeError::InvalidLengthError {
10840                 obj: "GetDeviceInfoRsp",
10841                 wanted: 2,
10842                 got: bytes.get().remaining(),
10843             });
10844         }
10845         let uci_version = bytes.get_mut().get_u16_le();
10846         if bytes.get().remaining() < 2 {
10847             return Err(DecodeError::InvalidLengthError {
10848                 obj: "GetDeviceInfoRsp",
10849                 wanted: 2,
10850                 got: bytes.get().remaining(),
10851             });
10852         }
10853         let mac_version = bytes.get_mut().get_u16_le();
10854         if bytes.get().remaining() < 2 {
10855             return Err(DecodeError::InvalidLengthError {
10856                 obj: "GetDeviceInfoRsp",
10857                 wanted: 2,
10858                 got: bytes.get().remaining(),
10859             });
10860         }
10861         let phy_version = bytes.get_mut().get_u16_le();
10862         if bytes.get().remaining() < 2 {
10863             return Err(DecodeError::InvalidLengthError {
10864                 obj: "GetDeviceInfoRsp",
10865                 wanted: 2,
10866                 got: bytes.get().remaining(),
10867             });
10868         }
10869         let uci_test_version = bytes.get_mut().get_u16_le();
10870         if bytes.get().remaining() < 1 {
10871             return Err(DecodeError::InvalidLengthError {
10872                 obj: "GetDeviceInfoRsp",
10873                 wanted: 1,
10874                 got: bytes.get().remaining(),
10875             });
10876         }
10877         let vendor_spec_info_count = bytes.get_mut().get_u8() as usize;
10878         if bytes.get().remaining() < vendor_spec_info_count * 1usize {
10879             return Err(DecodeError::InvalidLengthError {
10880                 obj: "GetDeviceInfoRsp",
10881                 wanted: vendor_spec_info_count * 1usize,
10882                 got: bytes.get().remaining(),
10883             });
10884         }
10885         let vendor_spec_info = (0..vendor_spec_info_count)
10886             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
10887             .collect::<Result<Vec<_>, DecodeError>>()?;
10888         Ok(Self {
10889             status,
10890             uci_version,
10891             mac_version,
10892             phy_version,
10893             uci_test_version,
10894             vendor_spec_info,
10895         })
10896     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>10897     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
10898         buffer.put_u8(u8::from(self.status));
10899         buffer.put_u16_le(self.uci_version);
10900         buffer.put_u16_le(self.mac_version);
10901         buffer.put_u16_le(self.phy_version);
10902         buffer.put_u16_le(self.uci_test_version);
10903         buffer.put_u8(self.vendor_spec_info.len() as u8);
10904         for elem in &self.vendor_spec_info {
10905             buffer.put_u8(*elem);
10906         }
10907         Ok(())
10908     }
get_total_size(&self) -> usize10909     fn get_total_size(&self) -> usize {
10910         self.get_size()
10911     }
get_size(&self) -> usize10912     fn get_size(&self) -> usize {
10913         10 + self.vendor_spec_info.len()
10914     }
10915 }
10916 impl Packet for GetDeviceInfoRsp {
encoded_len(&self) -> usize10917     fn encoded_len(&self) -> usize {
10918         self.get_size()
10919     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>10920     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
10921         self.ucicontrolpacket.write_to(buf)
10922     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>10923     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
10924         unimplemented!("Rust legacy does not implement full packet trait")
10925     }
10926 }
10927 impl TryFrom<GetDeviceInfoRsp> for Bytes {
10928     type Error = EncodeError;
try_from(packet: GetDeviceInfoRsp) -> Result<Self, Self::Error>10929     fn try_from(packet: GetDeviceInfoRsp) -> Result<Self, Self::Error> {
10930         packet.encode_to_bytes()
10931     }
10932 }
10933 impl TryFrom<GetDeviceInfoRsp> for Vec<u8> {
10934     type Error = EncodeError;
try_from(packet: GetDeviceInfoRsp) -> Result<Self, Self::Error>10935     fn try_from(packet: GetDeviceInfoRsp) -> Result<Self, Self::Error> {
10936         packet.encode_to_vec()
10937     }
10938 }
10939 impl From<GetDeviceInfoRsp> for UciControlPacket {
from(packet: GetDeviceInfoRsp) -> UciControlPacket10940     fn from(packet: GetDeviceInfoRsp) -> UciControlPacket {
10941         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
10942     }
10943 }
10944 impl From<GetDeviceInfoRsp> for UciResponse {
from(packet: GetDeviceInfoRsp) -> UciResponse10945     fn from(packet: GetDeviceInfoRsp) -> UciResponse {
10946         UciResponse::new(packet.ucicontrolpacket).unwrap()
10947     }
10948 }
10949 impl From<GetDeviceInfoRsp> for CoreResponse {
from(packet: GetDeviceInfoRsp) -> CoreResponse10950     fn from(packet: GetDeviceInfoRsp) -> CoreResponse {
10951         CoreResponse::new(packet.ucicontrolpacket).unwrap()
10952     }
10953 }
10954 impl TryFrom<UciControlPacket> for GetDeviceInfoRsp {
10955     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<GetDeviceInfoRsp, Self::Error>10956     fn try_from(packet: UciControlPacket) -> Result<GetDeviceInfoRsp, Self::Error> {
10957         GetDeviceInfoRsp::new(packet.ucicontrolpacket)
10958     }
10959 }
10960 impl GetDeviceInfoRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>10961     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
10962         let mut cell = Cell::new(bytes);
10963         let packet = Self::parse_inner(&mut cell)?;
10964         Ok(packet)
10965     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>10966     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
10967         let data = UciControlPacketData::parse_inner(&mut bytes)?;
10968         Self::new(data)
10969     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>10970     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
10971         let uciresponse = match &ucicontrolpacket.child {
10972             UciControlPacketDataChild::UciResponse(value) => value.clone(),
10973             _ => {
10974                 return Err(DecodeError::InvalidChildError {
10975                     expected: stringify!(UciControlPacketDataChild::UciResponse),
10976                     actual: format!("{:?}", & ucicontrolpacket.child),
10977                 });
10978             }
10979         };
10980         let coreresponse = match &uciresponse.child {
10981             UciResponseDataChild::CoreResponse(value) => value.clone(),
10982             _ => {
10983                 return Err(DecodeError::InvalidChildError {
10984                     expected: stringify!(UciResponseDataChild::CoreResponse),
10985                     actual: format!("{:?}", & uciresponse.child),
10986                 });
10987             }
10988         };
10989         let getdeviceinforsp = match &coreresponse.child {
10990             CoreResponseDataChild::GetDeviceInfoRsp(value) => value.clone(),
10991             _ => {
10992                 return Err(DecodeError::InvalidChildError {
10993                     expected: stringify!(CoreResponseDataChild::GetDeviceInfoRsp),
10994                     actual: format!("{:?}", & coreresponse.child),
10995                 });
10996             }
10997         };
10998         Ok(Self {
10999             ucicontrolpacket,
11000             uciresponse,
11001             coreresponse,
11002             getdeviceinforsp,
11003         })
11004     }
get_group_id(&self) -> GroupId11005     pub fn get_group_id(&self) -> GroupId {
11006         self.ucicontrolpacket.group_id
11007     }
get_mac_version(&self) -> u1611008     pub fn get_mac_version(&self) -> u16 {
11009         self.getdeviceinforsp.mac_version
11010     }
get_message_type(&self) -> MessageType11011     pub fn get_message_type(&self) -> MessageType {
11012         self.ucicontrolpacket.message_type
11013     }
get_opcode(&self) -> u811014     pub fn get_opcode(&self) -> u8 {
11015         self.ucicontrolpacket.opcode
11016     }
get_phy_version(&self) -> u1611017     pub fn get_phy_version(&self) -> u16 {
11018         self.getdeviceinforsp.phy_version
11019     }
get_status(&self) -> StatusCode11020     pub fn get_status(&self) -> StatusCode {
11021         self.getdeviceinforsp.status
11022     }
get_uci_test_version(&self) -> u1611023     pub fn get_uci_test_version(&self) -> u16 {
11024         self.getdeviceinforsp.uci_test_version
11025     }
get_uci_version(&self) -> u1611026     pub fn get_uci_version(&self) -> u16 {
11027         self.getdeviceinforsp.uci_version
11028     }
get_vendor_spec_info(&self) -> &Vec<u8>11029     pub fn get_vendor_spec_info(&self) -> &Vec<u8> {
11030         &self.getdeviceinforsp.vendor_spec_info
11031     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>11032     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
11033         self.getdeviceinforsp.write_to(buffer)
11034     }
get_size(&self) -> usize11035     pub fn get_size(&self) -> usize {
11036         self.ucicontrolpacket.get_size()
11037     }
11038 }
11039 impl GetDeviceInfoRspBuilder {
build(self) -> GetDeviceInfoRsp11040     pub fn build(self) -> GetDeviceInfoRsp {
11041         let getdeviceinforsp = GetDeviceInfoRspData {
11042             mac_version: self.mac_version,
11043             phy_version: self.phy_version,
11044             status: self.status,
11045             uci_test_version: self.uci_test_version,
11046             uci_version: self.uci_version,
11047             vendor_spec_info: self.vendor_spec_info,
11048         };
11049         let coreresponse = CoreResponseData {
11050             child: CoreResponseDataChild::GetDeviceInfoRsp(getdeviceinforsp),
11051         };
11052         let uciresponse = UciResponseData {
11053             child: UciResponseDataChild::CoreResponse(coreresponse),
11054         };
11055         let ucicontrolpacket = UciControlPacketData {
11056             group_id: GroupId::Core,
11057             message_type: MessageType::Response,
11058             opcode: 2,
11059             child: UciControlPacketDataChild::UciResponse(uciresponse),
11060         };
11061         GetDeviceInfoRsp::new(ucicontrolpacket).unwrap()
11062     }
11063 }
11064 impl From<GetDeviceInfoRspBuilder> for UciControlPacket {
from(builder: GetDeviceInfoRspBuilder) -> UciControlPacket11065     fn from(builder: GetDeviceInfoRspBuilder) -> UciControlPacket {
11066         builder.build().into()
11067     }
11068 }
11069 impl From<GetDeviceInfoRspBuilder> for UciResponse {
from(builder: GetDeviceInfoRspBuilder) -> UciResponse11070     fn from(builder: GetDeviceInfoRspBuilder) -> UciResponse {
11071         builder.build().into()
11072     }
11073 }
11074 impl From<GetDeviceInfoRspBuilder> for CoreResponse {
from(builder: GetDeviceInfoRspBuilder) -> CoreResponse11075     fn from(builder: GetDeviceInfoRspBuilder) -> CoreResponse {
11076         builder.build().into()
11077     }
11078 }
11079 impl From<GetDeviceInfoRspBuilder> for GetDeviceInfoRsp {
from(builder: GetDeviceInfoRspBuilder) -> GetDeviceInfoRsp11080     fn from(builder: GetDeviceInfoRspBuilder) -> GetDeviceInfoRsp {
11081         builder.build().into()
11082     }
11083 }
11084 #[derive(Debug, Clone, PartialEq, Eq)]
11085 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11086 pub struct GetCapsInfoCmdData {}
11087 #[derive(Debug, Clone, PartialEq, Eq)]
11088 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11089 pub struct GetCapsInfoCmd {
11090     #[cfg_attr(feature = "serde", serde(flatten))]
11091     ucicontrolpacket: UciControlPacketData,
11092     #[cfg_attr(feature = "serde", serde(flatten))]
11093     ucicommand: UciCommandData,
11094     #[cfg_attr(feature = "serde", serde(flatten))]
11095     corecommand: CoreCommandData,
11096     #[cfg_attr(feature = "serde", serde(flatten))]
11097     getcapsinfocmd: GetCapsInfoCmdData,
11098 }
11099 #[derive(Debug)]
11100 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11101 pub struct GetCapsInfoCmdBuilder {}
11102 impl GetCapsInfoCmdData {
conforms(bytes: &[u8]) -> bool11103     fn conforms(bytes: &[u8]) -> bool {
11104         true
11105     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>11106     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
11107         let mut cell = Cell::new(bytes);
11108         let packet = Self::parse_inner(&mut cell)?;
11109         Ok(packet)
11110     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>11111     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
11112         Ok(Self {})
11113     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>11114     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
11115         Ok(())
11116     }
get_total_size(&self) -> usize11117     fn get_total_size(&self) -> usize {
11118         self.get_size()
11119     }
get_size(&self) -> usize11120     fn get_size(&self) -> usize {
11121         0
11122     }
11123 }
11124 impl Packet for GetCapsInfoCmd {
encoded_len(&self) -> usize11125     fn encoded_len(&self) -> usize {
11126         self.get_size()
11127     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>11128     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
11129         self.ucicontrolpacket.write_to(buf)
11130     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>11131     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
11132         unimplemented!("Rust legacy does not implement full packet trait")
11133     }
11134 }
11135 impl TryFrom<GetCapsInfoCmd> for Bytes {
11136     type Error = EncodeError;
try_from(packet: GetCapsInfoCmd) -> Result<Self, Self::Error>11137     fn try_from(packet: GetCapsInfoCmd) -> Result<Self, Self::Error> {
11138         packet.encode_to_bytes()
11139     }
11140 }
11141 impl TryFrom<GetCapsInfoCmd> for Vec<u8> {
11142     type Error = EncodeError;
try_from(packet: GetCapsInfoCmd) -> Result<Self, Self::Error>11143     fn try_from(packet: GetCapsInfoCmd) -> Result<Self, Self::Error> {
11144         packet.encode_to_vec()
11145     }
11146 }
11147 impl From<GetCapsInfoCmd> for UciControlPacket {
from(packet: GetCapsInfoCmd) -> UciControlPacket11148     fn from(packet: GetCapsInfoCmd) -> UciControlPacket {
11149         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
11150     }
11151 }
11152 impl From<GetCapsInfoCmd> for UciCommand {
from(packet: GetCapsInfoCmd) -> UciCommand11153     fn from(packet: GetCapsInfoCmd) -> UciCommand {
11154         UciCommand::new(packet.ucicontrolpacket).unwrap()
11155     }
11156 }
11157 impl From<GetCapsInfoCmd> for CoreCommand {
from(packet: GetCapsInfoCmd) -> CoreCommand11158     fn from(packet: GetCapsInfoCmd) -> CoreCommand {
11159         CoreCommand::new(packet.ucicontrolpacket).unwrap()
11160     }
11161 }
11162 impl TryFrom<UciControlPacket> for GetCapsInfoCmd {
11163     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<GetCapsInfoCmd, Self::Error>11164     fn try_from(packet: UciControlPacket) -> Result<GetCapsInfoCmd, Self::Error> {
11165         GetCapsInfoCmd::new(packet.ucicontrolpacket)
11166     }
11167 }
11168 impl GetCapsInfoCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>11169     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
11170         let mut cell = Cell::new(bytes);
11171         let packet = Self::parse_inner(&mut cell)?;
11172         Ok(packet)
11173     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>11174     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
11175         let data = UciControlPacketData::parse_inner(&mut bytes)?;
11176         Self::new(data)
11177     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>11178     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
11179         let ucicommand = match &ucicontrolpacket.child {
11180             UciControlPacketDataChild::UciCommand(value) => value.clone(),
11181             _ => {
11182                 return Err(DecodeError::InvalidChildError {
11183                     expected: stringify!(UciControlPacketDataChild::UciCommand),
11184                     actual: format!("{:?}", & ucicontrolpacket.child),
11185                 });
11186             }
11187         };
11188         let corecommand = match &ucicommand.child {
11189             UciCommandDataChild::CoreCommand(value) => value.clone(),
11190             _ => {
11191                 return Err(DecodeError::InvalidChildError {
11192                     expected: stringify!(UciCommandDataChild::CoreCommand),
11193                     actual: format!("{:?}", & ucicommand.child),
11194                 });
11195             }
11196         };
11197         let getcapsinfocmd = match &corecommand.child {
11198             CoreCommandDataChild::GetCapsInfoCmd(value) => value.clone(),
11199             _ => {
11200                 return Err(DecodeError::InvalidChildError {
11201                     expected: stringify!(CoreCommandDataChild::GetCapsInfoCmd),
11202                     actual: format!("{:?}", & corecommand.child),
11203                 });
11204             }
11205         };
11206         Ok(Self {
11207             ucicontrolpacket,
11208             ucicommand,
11209             corecommand,
11210             getcapsinfocmd,
11211         })
11212     }
get_group_id(&self) -> GroupId11213     pub fn get_group_id(&self) -> GroupId {
11214         self.ucicontrolpacket.group_id
11215     }
get_message_type(&self) -> MessageType11216     pub fn get_message_type(&self) -> MessageType {
11217         self.ucicontrolpacket.message_type
11218     }
get_opcode(&self) -> u811219     pub fn get_opcode(&self) -> u8 {
11220         self.ucicontrolpacket.opcode
11221     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>11222     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
11223         self.getcapsinfocmd.write_to(buffer)
11224     }
get_size(&self) -> usize11225     pub fn get_size(&self) -> usize {
11226         self.ucicontrolpacket.get_size()
11227     }
11228 }
11229 impl GetCapsInfoCmdBuilder {
build(self) -> GetCapsInfoCmd11230     pub fn build(self) -> GetCapsInfoCmd {
11231         let getcapsinfocmd = GetCapsInfoCmdData {};
11232         let corecommand = CoreCommandData {
11233             child: CoreCommandDataChild::GetCapsInfoCmd(getcapsinfocmd),
11234         };
11235         let ucicommand = UciCommandData {
11236             child: UciCommandDataChild::CoreCommand(corecommand),
11237         };
11238         let ucicontrolpacket = UciControlPacketData {
11239             group_id: GroupId::Core,
11240             message_type: MessageType::Command,
11241             opcode: 3,
11242             child: UciControlPacketDataChild::UciCommand(ucicommand),
11243         };
11244         GetCapsInfoCmd::new(ucicontrolpacket).unwrap()
11245     }
11246 }
11247 impl From<GetCapsInfoCmdBuilder> for UciControlPacket {
from(builder: GetCapsInfoCmdBuilder) -> UciControlPacket11248     fn from(builder: GetCapsInfoCmdBuilder) -> UciControlPacket {
11249         builder.build().into()
11250     }
11251 }
11252 impl From<GetCapsInfoCmdBuilder> for UciCommand {
from(builder: GetCapsInfoCmdBuilder) -> UciCommand11253     fn from(builder: GetCapsInfoCmdBuilder) -> UciCommand {
11254         builder.build().into()
11255     }
11256 }
11257 impl From<GetCapsInfoCmdBuilder> for CoreCommand {
from(builder: GetCapsInfoCmdBuilder) -> CoreCommand11258     fn from(builder: GetCapsInfoCmdBuilder) -> CoreCommand {
11259         builder.build().into()
11260     }
11261 }
11262 impl From<GetCapsInfoCmdBuilder> for GetCapsInfoCmd {
from(builder: GetCapsInfoCmdBuilder) -> GetCapsInfoCmd11263     fn from(builder: GetCapsInfoCmdBuilder) -> GetCapsInfoCmd {
11264         builder.build().into()
11265     }
11266 }
11267 #[derive(Debug, Clone, PartialEq, Eq)]
11268 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11269 pub struct CapTlv {
11270     pub t: CapTlvType,
11271     pub v: Vec<u8>,
11272 }
11273 impl CapTlv {
conforms(bytes: &[u8]) -> bool11274     fn conforms(bytes: &[u8]) -> bool {
11275         bytes.len() >= 2
11276     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>11277     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
11278         let mut cell = Cell::new(bytes);
11279         let packet = Self::parse_inner(&mut cell)?;
11280         Ok(packet)
11281     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>11282     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
11283         if bytes.get().remaining() < 1 {
11284             return Err(DecodeError::InvalidLengthError {
11285                 obj: "CapTlv",
11286                 wanted: 1,
11287                 got: bytes.get().remaining(),
11288             });
11289         }
11290         let t = CapTlvType::try_from(bytes.get_mut().get_u8())
11291             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
11292                 obj: "CapTlv",
11293                 field: "t",
11294                 value: unknown_val as u64,
11295                 type_: "CapTlvType",
11296             })?;
11297         if bytes.get().remaining() < 1 {
11298             return Err(DecodeError::InvalidLengthError {
11299                 obj: "CapTlv",
11300                 wanted: 1,
11301                 got: bytes.get().remaining(),
11302             });
11303         }
11304         let v_count = bytes.get_mut().get_u8() as usize;
11305         if bytes.get().remaining() < v_count * 1usize {
11306             return Err(DecodeError::InvalidLengthError {
11307                 obj: "CapTlv",
11308                 wanted: v_count * 1usize,
11309                 got: bytes.get().remaining(),
11310             });
11311         }
11312         let v = (0..v_count)
11313             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
11314             .collect::<Result<Vec<_>, DecodeError>>()?;
11315         Ok(Self { t, v })
11316     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>11317     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
11318         buffer.put_u8(u8::from(self.t));
11319         buffer.put_u8(self.v.len() as u8);
11320         for elem in &self.v {
11321             buffer.put_u8(*elem);
11322         }
11323         Ok(())
11324     }
get_total_size(&self) -> usize11325     fn get_total_size(&self) -> usize {
11326         self.get_size()
11327     }
get_size(&self) -> usize11328     fn get_size(&self) -> usize {
11329         2 + self.v.len()
11330     }
11331 }
11332 #[derive(Debug, Clone, PartialEq, Eq)]
11333 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11334 pub struct GetCapsInfoRspData {
11335     status: StatusCode,
11336     tlvs: Vec<CapTlv>,
11337 }
11338 #[derive(Debug, Clone, PartialEq, Eq)]
11339 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11340 pub struct GetCapsInfoRsp {
11341     #[cfg_attr(feature = "serde", serde(flatten))]
11342     ucicontrolpacket: UciControlPacketData,
11343     #[cfg_attr(feature = "serde", serde(flatten))]
11344     uciresponse: UciResponseData,
11345     #[cfg_attr(feature = "serde", serde(flatten))]
11346     coreresponse: CoreResponseData,
11347     #[cfg_attr(feature = "serde", serde(flatten))]
11348     getcapsinforsp: GetCapsInfoRspData,
11349 }
11350 #[derive(Debug)]
11351 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11352 pub struct GetCapsInfoRspBuilder {
11353     pub status: StatusCode,
11354     pub tlvs: Vec<CapTlv>,
11355 }
11356 impl GetCapsInfoRspData {
conforms(bytes: &[u8]) -> bool11357     fn conforms(bytes: &[u8]) -> bool {
11358         bytes.len() >= 2
11359     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>11360     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
11361         let mut cell = Cell::new(bytes);
11362         let packet = Self::parse_inner(&mut cell)?;
11363         Ok(packet)
11364     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>11365     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
11366         if bytes.get().remaining() < 1 {
11367             return Err(DecodeError::InvalidLengthError {
11368                 obj: "GetCapsInfoRsp",
11369                 wanted: 1,
11370                 got: bytes.get().remaining(),
11371             });
11372         }
11373         let status = StatusCode::try_from(bytes.get_mut().get_u8())
11374             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
11375                 obj: "GetCapsInfoRsp",
11376                 field: "status",
11377                 value: unknown_val as u64,
11378                 type_: "StatusCode",
11379             })?;
11380         if bytes.get().remaining() < 1 {
11381             return Err(DecodeError::InvalidLengthError {
11382                 obj: "GetCapsInfoRsp",
11383                 wanted: 1,
11384                 got: bytes.get().remaining(),
11385             });
11386         }
11387         let tlvs_count = bytes.get_mut().get_u8() as usize;
11388         let tlvs = (0..tlvs_count)
11389             .map(|_| CapTlv::parse_inner(bytes))
11390             .collect::<Result<Vec<_>, DecodeError>>()?;
11391         Ok(Self { status, tlvs })
11392     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>11393     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
11394         buffer.put_u8(u8::from(self.status));
11395         buffer.put_u8(self.tlvs.len() as u8);
11396         for elem in &self.tlvs {
11397             elem.write_to(buffer)?;
11398         }
11399         Ok(())
11400     }
get_total_size(&self) -> usize11401     fn get_total_size(&self) -> usize {
11402         self.get_size()
11403     }
get_size(&self) -> usize11404     fn get_size(&self) -> usize {
11405         2 + self.tlvs.iter().map(|elem| elem.get_size()).sum::<usize>()
11406     }
11407 }
11408 impl Packet for GetCapsInfoRsp {
encoded_len(&self) -> usize11409     fn encoded_len(&self) -> usize {
11410         self.get_size()
11411     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>11412     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
11413         self.ucicontrolpacket.write_to(buf)
11414     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>11415     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
11416         unimplemented!("Rust legacy does not implement full packet trait")
11417     }
11418 }
11419 impl TryFrom<GetCapsInfoRsp> for Bytes {
11420     type Error = EncodeError;
try_from(packet: GetCapsInfoRsp) -> Result<Self, Self::Error>11421     fn try_from(packet: GetCapsInfoRsp) -> Result<Self, Self::Error> {
11422         packet.encode_to_bytes()
11423     }
11424 }
11425 impl TryFrom<GetCapsInfoRsp> for Vec<u8> {
11426     type Error = EncodeError;
try_from(packet: GetCapsInfoRsp) -> Result<Self, Self::Error>11427     fn try_from(packet: GetCapsInfoRsp) -> Result<Self, Self::Error> {
11428         packet.encode_to_vec()
11429     }
11430 }
11431 impl From<GetCapsInfoRsp> for UciControlPacket {
from(packet: GetCapsInfoRsp) -> UciControlPacket11432     fn from(packet: GetCapsInfoRsp) -> UciControlPacket {
11433         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
11434     }
11435 }
11436 impl From<GetCapsInfoRsp> for UciResponse {
from(packet: GetCapsInfoRsp) -> UciResponse11437     fn from(packet: GetCapsInfoRsp) -> UciResponse {
11438         UciResponse::new(packet.ucicontrolpacket).unwrap()
11439     }
11440 }
11441 impl From<GetCapsInfoRsp> for CoreResponse {
from(packet: GetCapsInfoRsp) -> CoreResponse11442     fn from(packet: GetCapsInfoRsp) -> CoreResponse {
11443         CoreResponse::new(packet.ucicontrolpacket).unwrap()
11444     }
11445 }
11446 impl TryFrom<UciControlPacket> for GetCapsInfoRsp {
11447     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<GetCapsInfoRsp, Self::Error>11448     fn try_from(packet: UciControlPacket) -> Result<GetCapsInfoRsp, Self::Error> {
11449         GetCapsInfoRsp::new(packet.ucicontrolpacket)
11450     }
11451 }
11452 impl GetCapsInfoRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>11453     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
11454         let mut cell = Cell::new(bytes);
11455         let packet = Self::parse_inner(&mut cell)?;
11456         Ok(packet)
11457     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>11458     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
11459         let data = UciControlPacketData::parse_inner(&mut bytes)?;
11460         Self::new(data)
11461     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>11462     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
11463         let uciresponse = match &ucicontrolpacket.child {
11464             UciControlPacketDataChild::UciResponse(value) => value.clone(),
11465             _ => {
11466                 return Err(DecodeError::InvalidChildError {
11467                     expected: stringify!(UciControlPacketDataChild::UciResponse),
11468                     actual: format!("{:?}", & ucicontrolpacket.child),
11469                 });
11470             }
11471         };
11472         let coreresponse = match &uciresponse.child {
11473             UciResponseDataChild::CoreResponse(value) => value.clone(),
11474             _ => {
11475                 return Err(DecodeError::InvalidChildError {
11476                     expected: stringify!(UciResponseDataChild::CoreResponse),
11477                     actual: format!("{:?}", & uciresponse.child),
11478                 });
11479             }
11480         };
11481         let getcapsinforsp = match &coreresponse.child {
11482             CoreResponseDataChild::GetCapsInfoRsp(value) => value.clone(),
11483             _ => {
11484                 return Err(DecodeError::InvalidChildError {
11485                     expected: stringify!(CoreResponseDataChild::GetCapsInfoRsp),
11486                     actual: format!("{:?}", & coreresponse.child),
11487                 });
11488             }
11489         };
11490         Ok(Self {
11491             ucicontrolpacket,
11492             uciresponse,
11493             coreresponse,
11494             getcapsinforsp,
11495         })
11496     }
get_group_id(&self) -> GroupId11497     pub fn get_group_id(&self) -> GroupId {
11498         self.ucicontrolpacket.group_id
11499     }
get_message_type(&self) -> MessageType11500     pub fn get_message_type(&self) -> MessageType {
11501         self.ucicontrolpacket.message_type
11502     }
get_opcode(&self) -> u811503     pub fn get_opcode(&self) -> u8 {
11504         self.ucicontrolpacket.opcode
11505     }
get_status(&self) -> StatusCode11506     pub fn get_status(&self) -> StatusCode {
11507         self.getcapsinforsp.status
11508     }
get_tlvs(&self) -> &Vec<CapTlv>11509     pub fn get_tlvs(&self) -> &Vec<CapTlv> {
11510         &self.getcapsinforsp.tlvs
11511     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>11512     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
11513         self.getcapsinforsp.write_to(buffer)
11514     }
get_size(&self) -> usize11515     pub fn get_size(&self) -> usize {
11516         self.ucicontrolpacket.get_size()
11517     }
11518 }
11519 impl GetCapsInfoRspBuilder {
build(self) -> GetCapsInfoRsp11520     pub fn build(self) -> GetCapsInfoRsp {
11521         let getcapsinforsp = GetCapsInfoRspData {
11522             status: self.status,
11523             tlvs: self.tlvs,
11524         };
11525         let coreresponse = CoreResponseData {
11526             child: CoreResponseDataChild::GetCapsInfoRsp(getcapsinforsp),
11527         };
11528         let uciresponse = UciResponseData {
11529             child: UciResponseDataChild::CoreResponse(coreresponse),
11530         };
11531         let ucicontrolpacket = UciControlPacketData {
11532             group_id: GroupId::Core,
11533             message_type: MessageType::Response,
11534             opcode: 3,
11535             child: UciControlPacketDataChild::UciResponse(uciresponse),
11536         };
11537         GetCapsInfoRsp::new(ucicontrolpacket).unwrap()
11538     }
11539 }
11540 impl From<GetCapsInfoRspBuilder> for UciControlPacket {
from(builder: GetCapsInfoRspBuilder) -> UciControlPacket11541     fn from(builder: GetCapsInfoRspBuilder) -> UciControlPacket {
11542         builder.build().into()
11543     }
11544 }
11545 impl From<GetCapsInfoRspBuilder> for UciResponse {
from(builder: GetCapsInfoRspBuilder) -> UciResponse11546     fn from(builder: GetCapsInfoRspBuilder) -> UciResponse {
11547         builder.build().into()
11548     }
11549 }
11550 impl From<GetCapsInfoRspBuilder> for CoreResponse {
from(builder: GetCapsInfoRspBuilder) -> CoreResponse11551     fn from(builder: GetCapsInfoRspBuilder) -> CoreResponse {
11552         builder.build().into()
11553     }
11554 }
11555 impl From<GetCapsInfoRspBuilder> for GetCapsInfoRsp {
from(builder: GetCapsInfoRspBuilder) -> GetCapsInfoRsp11556     fn from(builder: GetCapsInfoRspBuilder) -> GetCapsInfoRsp {
11557         builder.build().into()
11558     }
11559 }
11560 #[derive(Debug, Clone, PartialEq, Eq)]
11561 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11562 pub struct DeviceConfigTlv {
11563     pub cfg_id: DeviceConfigId,
11564     pub v: Vec<u8>,
11565 }
11566 impl DeviceConfigTlv {
conforms(bytes: &[u8]) -> bool11567     fn conforms(bytes: &[u8]) -> bool {
11568         bytes.len() >= 2
11569     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>11570     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
11571         let mut cell = Cell::new(bytes);
11572         let packet = Self::parse_inner(&mut cell)?;
11573         Ok(packet)
11574     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>11575     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
11576         if bytes.get().remaining() < 1 {
11577             return Err(DecodeError::InvalidLengthError {
11578                 obj: "DeviceConfigTlv",
11579                 wanted: 1,
11580                 got: bytes.get().remaining(),
11581             });
11582         }
11583         let cfg_id = DeviceConfigId::try_from(bytes.get_mut().get_u8())
11584             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
11585                 obj: "DeviceConfigTlv",
11586                 field: "cfg_id",
11587                 value: unknown_val as u64,
11588                 type_: "DeviceConfigId",
11589             })?;
11590         if bytes.get().remaining() < 1 {
11591             return Err(DecodeError::InvalidLengthError {
11592                 obj: "DeviceConfigTlv",
11593                 wanted: 1,
11594                 got: bytes.get().remaining(),
11595             });
11596         }
11597         let v_count = bytes.get_mut().get_u8() as usize;
11598         if bytes.get().remaining() < v_count * 1usize {
11599             return Err(DecodeError::InvalidLengthError {
11600                 obj: "DeviceConfigTlv",
11601                 wanted: v_count * 1usize,
11602                 got: bytes.get().remaining(),
11603             });
11604         }
11605         let v = (0..v_count)
11606             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
11607             .collect::<Result<Vec<_>, DecodeError>>()?;
11608         Ok(Self { cfg_id, v })
11609     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>11610     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
11611         buffer.put_u8(u8::from(self.cfg_id));
11612         buffer.put_u8(self.v.len() as u8);
11613         for elem in &self.v {
11614             buffer.put_u8(*elem);
11615         }
11616         Ok(())
11617     }
get_total_size(&self) -> usize11618     fn get_total_size(&self) -> usize {
11619         self.get_size()
11620     }
get_size(&self) -> usize11621     fn get_size(&self) -> usize {
11622         2 + self.v.len()
11623     }
11624 }
11625 #[derive(Debug, Clone, PartialEq, Eq)]
11626 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11627 pub struct SetConfigCmdData {
11628     tlvs: Vec<DeviceConfigTlv>,
11629 }
11630 #[derive(Debug, Clone, PartialEq, Eq)]
11631 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11632 pub struct SetConfigCmd {
11633     #[cfg_attr(feature = "serde", serde(flatten))]
11634     ucicontrolpacket: UciControlPacketData,
11635     #[cfg_attr(feature = "serde", serde(flatten))]
11636     ucicommand: UciCommandData,
11637     #[cfg_attr(feature = "serde", serde(flatten))]
11638     corecommand: CoreCommandData,
11639     #[cfg_attr(feature = "serde", serde(flatten))]
11640     setconfigcmd: SetConfigCmdData,
11641 }
11642 #[derive(Debug)]
11643 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11644 pub struct SetConfigCmdBuilder {
11645     pub tlvs: Vec<DeviceConfigTlv>,
11646 }
11647 impl SetConfigCmdData {
conforms(bytes: &[u8]) -> bool11648     fn conforms(bytes: &[u8]) -> bool {
11649         bytes.len() >= 1
11650     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>11651     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
11652         let mut cell = Cell::new(bytes);
11653         let packet = Self::parse_inner(&mut cell)?;
11654         Ok(packet)
11655     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>11656     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
11657         if bytes.get().remaining() < 1 {
11658             return Err(DecodeError::InvalidLengthError {
11659                 obj: "SetConfigCmd",
11660                 wanted: 1,
11661                 got: bytes.get().remaining(),
11662             });
11663         }
11664         let tlvs_count = bytes.get_mut().get_u8() as usize;
11665         let tlvs = (0..tlvs_count)
11666             .map(|_| DeviceConfigTlv::parse_inner(bytes))
11667             .collect::<Result<Vec<_>, DecodeError>>()?;
11668         Ok(Self { tlvs })
11669     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>11670     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
11671         buffer.put_u8(self.tlvs.len() as u8);
11672         for elem in &self.tlvs {
11673             elem.write_to(buffer)?;
11674         }
11675         Ok(())
11676     }
get_total_size(&self) -> usize11677     fn get_total_size(&self) -> usize {
11678         self.get_size()
11679     }
get_size(&self) -> usize11680     fn get_size(&self) -> usize {
11681         1 + self.tlvs.iter().map(|elem| elem.get_size()).sum::<usize>()
11682     }
11683 }
11684 impl Packet for SetConfigCmd {
encoded_len(&self) -> usize11685     fn encoded_len(&self) -> usize {
11686         self.get_size()
11687     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>11688     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
11689         self.ucicontrolpacket.write_to(buf)
11690     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>11691     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
11692         unimplemented!("Rust legacy does not implement full packet trait")
11693     }
11694 }
11695 impl TryFrom<SetConfigCmd> for Bytes {
11696     type Error = EncodeError;
try_from(packet: SetConfigCmd) -> Result<Self, Self::Error>11697     fn try_from(packet: SetConfigCmd) -> Result<Self, Self::Error> {
11698         packet.encode_to_bytes()
11699     }
11700 }
11701 impl TryFrom<SetConfigCmd> for Vec<u8> {
11702     type Error = EncodeError;
try_from(packet: SetConfigCmd) -> Result<Self, Self::Error>11703     fn try_from(packet: SetConfigCmd) -> Result<Self, Self::Error> {
11704         packet.encode_to_vec()
11705     }
11706 }
11707 impl From<SetConfigCmd> for UciControlPacket {
from(packet: SetConfigCmd) -> UciControlPacket11708     fn from(packet: SetConfigCmd) -> UciControlPacket {
11709         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
11710     }
11711 }
11712 impl From<SetConfigCmd> for UciCommand {
from(packet: SetConfigCmd) -> UciCommand11713     fn from(packet: SetConfigCmd) -> UciCommand {
11714         UciCommand::new(packet.ucicontrolpacket).unwrap()
11715     }
11716 }
11717 impl From<SetConfigCmd> for CoreCommand {
from(packet: SetConfigCmd) -> CoreCommand11718     fn from(packet: SetConfigCmd) -> CoreCommand {
11719         CoreCommand::new(packet.ucicontrolpacket).unwrap()
11720     }
11721 }
11722 impl TryFrom<UciControlPacket> for SetConfigCmd {
11723     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SetConfigCmd, Self::Error>11724     fn try_from(packet: UciControlPacket) -> Result<SetConfigCmd, Self::Error> {
11725         SetConfigCmd::new(packet.ucicontrolpacket)
11726     }
11727 }
11728 impl SetConfigCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>11729     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
11730         let mut cell = Cell::new(bytes);
11731         let packet = Self::parse_inner(&mut cell)?;
11732         Ok(packet)
11733     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>11734     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
11735         let data = UciControlPacketData::parse_inner(&mut bytes)?;
11736         Self::new(data)
11737     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>11738     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
11739         let ucicommand = match &ucicontrolpacket.child {
11740             UciControlPacketDataChild::UciCommand(value) => value.clone(),
11741             _ => {
11742                 return Err(DecodeError::InvalidChildError {
11743                     expected: stringify!(UciControlPacketDataChild::UciCommand),
11744                     actual: format!("{:?}", & ucicontrolpacket.child),
11745                 });
11746             }
11747         };
11748         let corecommand = match &ucicommand.child {
11749             UciCommandDataChild::CoreCommand(value) => value.clone(),
11750             _ => {
11751                 return Err(DecodeError::InvalidChildError {
11752                     expected: stringify!(UciCommandDataChild::CoreCommand),
11753                     actual: format!("{:?}", & ucicommand.child),
11754                 });
11755             }
11756         };
11757         let setconfigcmd = match &corecommand.child {
11758             CoreCommandDataChild::SetConfigCmd(value) => value.clone(),
11759             _ => {
11760                 return Err(DecodeError::InvalidChildError {
11761                     expected: stringify!(CoreCommandDataChild::SetConfigCmd),
11762                     actual: format!("{:?}", & corecommand.child),
11763                 });
11764             }
11765         };
11766         Ok(Self {
11767             ucicontrolpacket,
11768             ucicommand,
11769             corecommand,
11770             setconfigcmd,
11771         })
11772     }
get_group_id(&self) -> GroupId11773     pub fn get_group_id(&self) -> GroupId {
11774         self.ucicontrolpacket.group_id
11775     }
get_message_type(&self) -> MessageType11776     pub fn get_message_type(&self) -> MessageType {
11777         self.ucicontrolpacket.message_type
11778     }
get_opcode(&self) -> u811779     pub fn get_opcode(&self) -> u8 {
11780         self.ucicontrolpacket.opcode
11781     }
get_tlvs(&self) -> &Vec<DeviceConfigTlv>11782     pub fn get_tlvs(&self) -> &Vec<DeviceConfigTlv> {
11783         &self.setconfigcmd.tlvs
11784     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>11785     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
11786         self.setconfigcmd.write_to(buffer)
11787     }
get_size(&self) -> usize11788     pub fn get_size(&self) -> usize {
11789         self.ucicontrolpacket.get_size()
11790     }
11791 }
11792 impl SetConfigCmdBuilder {
build(self) -> SetConfigCmd11793     pub fn build(self) -> SetConfigCmd {
11794         let setconfigcmd = SetConfigCmdData {
11795             tlvs: self.tlvs,
11796         };
11797         let corecommand = CoreCommandData {
11798             child: CoreCommandDataChild::SetConfigCmd(setconfigcmd),
11799         };
11800         let ucicommand = UciCommandData {
11801             child: UciCommandDataChild::CoreCommand(corecommand),
11802         };
11803         let ucicontrolpacket = UciControlPacketData {
11804             group_id: GroupId::Core,
11805             message_type: MessageType::Command,
11806             opcode: 4,
11807             child: UciControlPacketDataChild::UciCommand(ucicommand),
11808         };
11809         SetConfigCmd::new(ucicontrolpacket).unwrap()
11810     }
11811 }
11812 impl From<SetConfigCmdBuilder> for UciControlPacket {
from(builder: SetConfigCmdBuilder) -> UciControlPacket11813     fn from(builder: SetConfigCmdBuilder) -> UciControlPacket {
11814         builder.build().into()
11815     }
11816 }
11817 impl From<SetConfigCmdBuilder> for UciCommand {
from(builder: SetConfigCmdBuilder) -> UciCommand11818     fn from(builder: SetConfigCmdBuilder) -> UciCommand {
11819         builder.build().into()
11820     }
11821 }
11822 impl From<SetConfigCmdBuilder> for CoreCommand {
from(builder: SetConfigCmdBuilder) -> CoreCommand11823     fn from(builder: SetConfigCmdBuilder) -> CoreCommand {
11824         builder.build().into()
11825     }
11826 }
11827 impl From<SetConfigCmdBuilder> for SetConfigCmd {
from(builder: SetConfigCmdBuilder) -> SetConfigCmd11828     fn from(builder: SetConfigCmdBuilder) -> SetConfigCmd {
11829         builder.build().into()
11830     }
11831 }
11832 #[derive(Debug, Clone, PartialEq, Eq)]
11833 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11834 pub struct DeviceConfigStatus {
11835     pub cfg_id: DeviceConfigId,
11836     pub status: StatusCode,
11837 }
11838 impl DeviceConfigStatus {
conforms(bytes: &[u8]) -> bool11839     fn conforms(bytes: &[u8]) -> bool {
11840         bytes.len() >= 2
11841     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>11842     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
11843         let mut cell = Cell::new(bytes);
11844         let packet = Self::parse_inner(&mut cell)?;
11845         Ok(packet)
11846     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>11847     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
11848         if bytes.get().remaining() < 1 {
11849             return Err(DecodeError::InvalidLengthError {
11850                 obj: "DeviceConfigStatus",
11851                 wanted: 1,
11852                 got: bytes.get().remaining(),
11853             });
11854         }
11855         let cfg_id = DeviceConfigId::try_from(bytes.get_mut().get_u8())
11856             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
11857                 obj: "DeviceConfigStatus",
11858                 field: "cfg_id",
11859                 value: unknown_val as u64,
11860                 type_: "DeviceConfigId",
11861             })?;
11862         if bytes.get().remaining() < 1 {
11863             return Err(DecodeError::InvalidLengthError {
11864                 obj: "DeviceConfigStatus",
11865                 wanted: 1,
11866                 got: bytes.get().remaining(),
11867             });
11868         }
11869         let status = StatusCode::try_from(bytes.get_mut().get_u8())
11870             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
11871                 obj: "DeviceConfigStatus",
11872                 field: "status",
11873                 value: unknown_val as u64,
11874                 type_: "StatusCode",
11875             })?;
11876         Ok(Self { cfg_id, status })
11877     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>11878     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
11879         buffer.put_u8(u8::from(self.cfg_id));
11880         buffer.put_u8(u8::from(self.status));
11881         Ok(())
11882     }
get_total_size(&self) -> usize11883     fn get_total_size(&self) -> usize {
11884         self.get_size()
11885     }
get_size(&self) -> usize11886     fn get_size(&self) -> usize {
11887         2
11888     }
11889 }
11890 #[derive(Debug, Clone, PartialEq, Eq)]
11891 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11892 pub struct SetConfigRspData {
11893     status: StatusCode,
11894     cfg_status: Vec<DeviceConfigStatus>,
11895 }
11896 #[derive(Debug, Clone, PartialEq, Eq)]
11897 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11898 pub struct SetConfigRsp {
11899     #[cfg_attr(feature = "serde", serde(flatten))]
11900     ucicontrolpacket: UciControlPacketData,
11901     #[cfg_attr(feature = "serde", serde(flatten))]
11902     uciresponse: UciResponseData,
11903     #[cfg_attr(feature = "serde", serde(flatten))]
11904     coreresponse: CoreResponseData,
11905     #[cfg_attr(feature = "serde", serde(flatten))]
11906     setconfigrsp: SetConfigRspData,
11907 }
11908 #[derive(Debug)]
11909 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
11910 pub struct SetConfigRspBuilder {
11911     pub cfg_status: Vec<DeviceConfigStatus>,
11912     pub status: StatusCode,
11913 }
11914 impl SetConfigRspData {
conforms(bytes: &[u8]) -> bool11915     fn conforms(bytes: &[u8]) -> bool {
11916         bytes.len() >= 2
11917     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>11918     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
11919         let mut cell = Cell::new(bytes);
11920         let packet = Self::parse_inner(&mut cell)?;
11921         Ok(packet)
11922     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>11923     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
11924         if bytes.get().remaining() < 1 {
11925             return Err(DecodeError::InvalidLengthError {
11926                 obj: "SetConfigRsp",
11927                 wanted: 1,
11928                 got: bytes.get().remaining(),
11929             });
11930         }
11931         let status = StatusCode::try_from(bytes.get_mut().get_u8())
11932             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
11933                 obj: "SetConfigRsp",
11934                 field: "status",
11935                 value: unknown_val as u64,
11936                 type_: "StatusCode",
11937             })?;
11938         if bytes.get().remaining() < 1 {
11939             return Err(DecodeError::InvalidLengthError {
11940                 obj: "SetConfigRsp",
11941                 wanted: 1,
11942                 got: bytes.get().remaining(),
11943             });
11944         }
11945         let cfg_status_count = bytes.get_mut().get_u8() as usize;
11946         if bytes.get().remaining() < cfg_status_count * 2usize {
11947             return Err(DecodeError::InvalidLengthError {
11948                 obj: "SetConfigRsp",
11949                 wanted: cfg_status_count * 2usize,
11950                 got: bytes.get().remaining(),
11951             });
11952         }
11953         let cfg_status = (0..cfg_status_count)
11954             .map(|_| DeviceConfigStatus::parse_inner(bytes))
11955             .collect::<Result<Vec<_>, DecodeError>>()?;
11956         Ok(Self { status, cfg_status })
11957     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>11958     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
11959         buffer.put_u8(u8::from(self.status));
11960         buffer.put_u8(self.cfg_status.len() as u8);
11961         for elem in &self.cfg_status {
11962             elem.write_to(buffer)?;
11963         }
11964         Ok(())
11965     }
get_total_size(&self) -> usize11966     fn get_total_size(&self) -> usize {
11967         self.get_size()
11968     }
get_size(&self) -> usize11969     fn get_size(&self) -> usize {
11970         2 + self.cfg_status.iter().map(|elem| elem.get_size()).sum::<usize>()
11971     }
11972 }
11973 impl Packet for SetConfigRsp {
encoded_len(&self) -> usize11974     fn encoded_len(&self) -> usize {
11975         self.get_size()
11976     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>11977     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
11978         self.ucicontrolpacket.write_to(buf)
11979     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>11980     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
11981         unimplemented!("Rust legacy does not implement full packet trait")
11982     }
11983 }
11984 impl TryFrom<SetConfigRsp> for Bytes {
11985     type Error = EncodeError;
try_from(packet: SetConfigRsp) -> Result<Self, Self::Error>11986     fn try_from(packet: SetConfigRsp) -> Result<Self, Self::Error> {
11987         packet.encode_to_bytes()
11988     }
11989 }
11990 impl TryFrom<SetConfigRsp> for Vec<u8> {
11991     type Error = EncodeError;
try_from(packet: SetConfigRsp) -> Result<Self, Self::Error>11992     fn try_from(packet: SetConfigRsp) -> Result<Self, Self::Error> {
11993         packet.encode_to_vec()
11994     }
11995 }
11996 impl From<SetConfigRsp> for UciControlPacket {
from(packet: SetConfigRsp) -> UciControlPacket11997     fn from(packet: SetConfigRsp) -> UciControlPacket {
11998         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
11999     }
12000 }
12001 impl From<SetConfigRsp> for UciResponse {
from(packet: SetConfigRsp) -> UciResponse12002     fn from(packet: SetConfigRsp) -> UciResponse {
12003         UciResponse::new(packet.ucicontrolpacket).unwrap()
12004     }
12005 }
12006 impl From<SetConfigRsp> for CoreResponse {
from(packet: SetConfigRsp) -> CoreResponse12007     fn from(packet: SetConfigRsp) -> CoreResponse {
12008         CoreResponse::new(packet.ucicontrolpacket).unwrap()
12009     }
12010 }
12011 impl TryFrom<UciControlPacket> for SetConfigRsp {
12012     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SetConfigRsp, Self::Error>12013     fn try_from(packet: UciControlPacket) -> Result<SetConfigRsp, Self::Error> {
12014         SetConfigRsp::new(packet.ucicontrolpacket)
12015     }
12016 }
12017 impl SetConfigRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>12018     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
12019         let mut cell = Cell::new(bytes);
12020         let packet = Self::parse_inner(&mut cell)?;
12021         Ok(packet)
12022     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>12023     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
12024         let data = UciControlPacketData::parse_inner(&mut bytes)?;
12025         Self::new(data)
12026     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>12027     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
12028         let uciresponse = match &ucicontrolpacket.child {
12029             UciControlPacketDataChild::UciResponse(value) => value.clone(),
12030             _ => {
12031                 return Err(DecodeError::InvalidChildError {
12032                     expected: stringify!(UciControlPacketDataChild::UciResponse),
12033                     actual: format!("{:?}", & ucicontrolpacket.child),
12034                 });
12035             }
12036         };
12037         let coreresponse = match &uciresponse.child {
12038             UciResponseDataChild::CoreResponse(value) => value.clone(),
12039             _ => {
12040                 return Err(DecodeError::InvalidChildError {
12041                     expected: stringify!(UciResponseDataChild::CoreResponse),
12042                     actual: format!("{:?}", & uciresponse.child),
12043                 });
12044             }
12045         };
12046         let setconfigrsp = match &coreresponse.child {
12047             CoreResponseDataChild::SetConfigRsp(value) => value.clone(),
12048             _ => {
12049                 return Err(DecodeError::InvalidChildError {
12050                     expected: stringify!(CoreResponseDataChild::SetConfigRsp),
12051                     actual: format!("{:?}", & coreresponse.child),
12052                 });
12053             }
12054         };
12055         Ok(Self {
12056             ucicontrolpacket,
12057             uciresponse,
12058             coreresponse,
12059             setconfigrsp,
12060         })
12061     }
get_cfg_status(&self) -> &Vec<DeviceConfigStatus>12062     pub fn get_cfg_status(&self) -> &Vec<DeviceConfigStatus> {
12063         &self.setconfigrsp.cfg_status
12064     }
get_group_id(&self) -> GroupId12065     pub fn get_group_id(&self) -> GroupId {
12066         self.ucicontrolpacket.group_id
12067     }
get_message_type(&self) -> MessageType12068     pub fn get_message_type(&self) -> MessageType {
12069         self.ucicontrolpacket.message_type
12070     }
get_opcode(&self) -> u812071     pub fn get_opcode(&self) -> u8 {
12072         self.ucicontrolpacket.opcode
12073     }
get_status(&self) -> StatusCode12074     pub fn get_status(&self) -> StatusCode {
12075         self.setconfigrsp.status
12076     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>12077     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
12078         self.setconfigrsp.write_to(buffer)
12079     }
get_size(&self) -> usize12080     pub fn get_size(&self) -> usize {
12081         self.ucicontrolpacket.get_size()
12082     }
12083 }
12084 impl SetConfigRspBuilder {
build(self) -> SetConfigRsp12085     pub fn build(self) -> SetConfigRsp {
12086         let setconfigrsp = SetConfigRspData {
12087             cfg_status: self.cfg_status,
12088             status: self.status,
12089         };
12090         let coreresponse = CoreResponseData {
12091             child: CoreResponseDataChild::SetConfigRsp(setconfigrsp),
12092         };
12093         let uciresponse = UciResponseData {
12094             child: UciResponseDataChild::CoreResponse(coreresponse),
12095         };
12096         let ucicontrolpacket = UciControlPacketData {
12097             group_id: GroupId::Core,
12098             message_type: MessageType::Response,
12099             opcode: 4,
12100             child: UciControlPacketDataChild::UciResponse(uciresponse),
12101         };
12102         SetConfigRsp::new(ucicontrolpacket).unwrap()
12103     }
12104 }
12105 impl From<SetConfigRspBuilder> for UciControlPacket {
from(builder: SetConfigRspBuilder) -> UciControlPacket12106     fn from(builder: SetConfigRspBuilder) -> UciControlPacket {
12107         builder.build().into()
12108     }
12109 }
12110 impl From<SetConfigRspBuilder> for UciResponse {
from(builder: SetConfigRspBuilder) -> UciResponse12111     fn from(builder: SetConfigRspBuilder) -> UciResponse {
12112         builder.build().into()
12113     }
12114 }
12115 impl From<SetConfigRspBuilder> for CoreResponse {
from(builder: SetConfigRspBuilder) -> CoreResponse12116     fn from(builder: SetConfigRspBuilder) -> CoreResponse {
12117         builder.build().into()
12118     }
12119 }
12120 impl From<SetConfigRspBuilder> for SetConfigRsp {
from(builder: SetConfigRspBuilder) -> SetConfigRsp12121     fn from(builder: SetConfigRspBuilder) -> SetConfigRsp {
12122         builder.build().into()
12123     }
12124 }
12125 #[derive(Debug, Clone, PartialEq, Eq)]
12126 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12127 pub struct GetConfigCmdData {
12128     cfg_id: Vec<u8>,
12129 }
12130 #[derive(Debug, Clone, PartialEq, Eq)]
12131 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12132 pub struct GetConfigCmd {
12133     #[cfg_attr(feature = "serde", serde(flatten))]
12134     ucicontrolpacket: UciControlPacketData,
12135     #[cfg_attr(feature = "serde", serde(flatten))]
12136     ucicommand: UciCommandData,
12137     #[cfg_attr(feature = "serde", serde(flatten))]
12138     corecommand: CoreCommandData,
12139     #[cfg_attr(feature = "serde", serde(flatten))]
12140     getconfigcmd: GetConfigCmdData,
12141 }
12142 #[derive(Debug)]
12143 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12144 pub struct GetConfigCmdBuilder {
12145     pub cfg_id: Vec<u8>,
12146 }
12147 impl GetConfigCmdData {
conforms(bytes: &[u8]) -> bool12148     fn conforms(bytes: &[u8]) -> bool {
12149         bytes.len() >= 1
12150     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>12151     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
12152         let mut cell = Cell::new(bytes);
12153         let packet = Self::parse_inner(&mut cell)?;
12154         Ok(packet)
12155     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>12156     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
12157         if bytes.get().remaining() < 1 {
12158             return Err(DecodeError::InvalidLengthError {
12159                 obj: "GetConfigCmd",
12160                 wanted: 1,
12161                 got: bytes.get().remaining(),
12162             });
12163         }
12164         let cfg_id_count = bytes.get_mut().get_u8() as usize;
12165         if bytes.get().remaining() < cfg_id_count * 1usize {
12166             return Err(DecodeError::InvalidLengthError {
12167                 obj: "GetConfigCmd",
12168                 wanted: cfg_id_count * 1usize,
12169                 got: bytes.get().remaining(),
12170             });
12171         }
12172         let cfg_id = (0..cfg_id_count)
12173             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
12174             .collect::<Result<Vec<_>, DecodeError>>()?;
12175         Ok(Self { cfg_id })
12176     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>12177     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
12178         buffer.put_u8(self.cfg_id.len() as u8);
12179         for elem in &self.cfg_id {
12180             buffer.put_u8(*elem);
12181         }
12182         Ok(())
12183     }
get_total_size(&self) -> usize12184     fn get_total_size(&self) -> usize {
12185         self.get_size()
12186     }
get_size(&self) -> usize12187     fn get_size(&self) -> usize {
12188         1 + self.cfg_id.len()
12189     }
12190 }
12191 impl Packet for GetConfigCmd {
encoded_len(&self) -> usize12192     fn encoded_len(&self) -> usize {
12193         self.get_size()
12194     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>12195     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
12196         self.ucicontrolpacket.write_to(buf)
12197     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>12198     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
12199         unimplemented!("Rust legacy does not implement full packet trait")
12200     }
12201 }
12202 impl TryFrom<GetConfigCmd> for Bytes {
12203     type Error = EncodeError;
try_from(packet: GetConfigCmd) -> Result<Self, Self::Error>12204     fn try_from(packet: GetConfigCmd) -> Result<Self, Self::Error> {
12205         packet.encode_to_bytes()
12206     }
12207 }
12208 impl TryFrom<GetConfigCmd> for Vec<u8> {
12209     type Error = EncodeError;
try_from(packet: GetConfigCmd) -> Result<Self, Self::Error>12210     fn try_from(packet: GetConfigCmd) -> Result<Self, Self::Error> {
12211         packet.encode_to_vec()
12212     }
12213 }
12214 impl From<GetConfigCmd> for UciControlPacket {
from(packet: GetConfigCmd) -> UciControlPacket12215     fn from(packet: GetConfigCmd) -> UciControlPacket {
12216         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
12217     }
12218 }
12219 impl From<GetConfigCmd> for UciCommand {
from(packet: GetConfigCmd) -> UciCommand12220     fn from(packet: GetConfigCmd) -> UciCommand {
12221         UciCommand::new(packet.ucicontrolpacket).unwrap()
12222     }
12223 }
12224 impl From<GetConfigCmd> for CoreCommand {
from(packet: GetConfigCmd) -> CoreCommand12225     fn from(packet: GetConfigCmd) -> CoreCommand {
12226         CoreCommand::new(packet.ucicontrolpacket).unwrap()
12227     }
12228 }
12229 impl TryFrom<UciControlPacket> for GetConfigCmd {
12230     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<GetConfigCmd, Self::Error>12231     fn try_from(packet: UciControlPacket) -> Result<GetConfigCmd, Self::Error> {
12232         GetConfigCmd::new(packet.ucicontrolpacket)
12233     }
12234 }
12235 impl GetConfigCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>12236     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
12237         let mut cell = Cell::new(bytes);
12238         let packet = Self::parse_inner(&mut cell)?;
12239         Ok(packet)
12240     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>12241     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
12242         let data = UciControlPacketData::parse_inner(&mut bytes)?;
12243         Self::new(data)
12244     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>12245     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
12246         let ucicommand = match &ucicontrolpacket.child {
12247             UciControlPacketDataChild::UciCommand(value) => value.clone(),
12248             _ => {
12249                 return Err(DecodeError::InvalidChildError {
12250                     expected: stringify!(UciControlPacketDataChild::UciCommand),
12251                     actual: format!("{:?}", & ucicontrolpacket.child),
12252                 });
12253             }
12254         };
12255         let corecommand = match &ucicommand.child {
12256             UciCommandDataChild::CoreCommand(value) => value.clone(),
12257             _ => {
12258                 return Err(DecodeError::InvalidChildError {
12259                     expected: stringify!(UciCommandDataChild::CoreCommand),
12260                     actual: format!("{:?}", & ucicommand.child),
12261                 });
12262             }
12263         };
12264         let getconfigcmd = match &corecommand.child {
12265             CoreCommandDataChild::GetConfigCmd(value) => value.clone(),
12266             _ => {
12267                 return Err(DecodeError::InvalidChildError {
12268                     expected: stringify!(CoreCommandDataChild::GetConfigCmd),
12269                     actual: format!("{:?}", & corecommand.child),
12270                 });
12271             }
12272         };
12273         Ok(Self {
12274             ucicontrolpacket,
12275             ucicommand,
12276             corecommand,
12277             getconfigcmd,
12278         })
12279     }
get_cfg_id(&self) -> &Vec<u8>12280     pub fn get_cfg_id(&self) -> &Vec<u8> {
12281         &self.getconfigcmd.cfg_id
12282     }
get_group_id(&self) -> GroupId12283     pub fn get_group_id(&self) -> GroupId {
12284         self.ucicontrolpacket.group_id
12285     }
get_message_type(&self) -> MessageType12286     pub fn get_message_type(&self) -> MessageType {
12287         self.ucicontrolpacket.message_type
12288     }
get_opcode(&self) -> u812289     pub fn get_opcode(&self) -> u8 {
12290         self.ucicontrolpacket.opcode
12291     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>12292     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
12293         self.getconfigcmd.write_to(buffer)
12294     }
get_size(&self) -> usize12295     pub fn get_size(&self) -> usize {
12296         self.ucicontrolpacket.get_size()
12297     }
12298 }
12299 impl GetConfigCmdBuilder {
build(self) -> GetConfigCmd12300     pub fn build(self) -> GetConfigCmd {
12301         let getconfigcmd = GetConfigCmdData {
12302             cfg_id: self.cfg_id,
12303         };
12304         let corecommand = CoreCommandData {
12305             child: CoreCommandDataChild::GetConfigCmd(getconfigcmd),
12306         };
12307         let ucicommand = UciCommandData {
12308             child: UciCommandDataChild::CoreCommand(corecommand),
12309         };
12310         let ucicontrolpacket = UciControlPacketData {
12311             group_id: GroupId::Core,
12312             message_type: MessageType::Command,
12313             opcode: 5,
12314             child: UciControlPacketDataChild::UciCommand(ucicommand),
12315         };
12316         GetConfigCmd::new(ucicontrolpacket).unwrap()
12317     }
12318 }
12319 impl From<GetConfigCmdBuilder> for UciControlPacket {
from(builder: GetConfigCmdBuilder) -> UciControlPacket12320     fn from(builder: GetConfigCmdBuilder) -> UciControlPacket {
12321         builder.build().into()
12322     }
12323 }
12324 impl From<GetConfigCmdBuilder> for UciCommand {
from(builder: GetConfigCmdBuilder) -> UciCommand12325     fn from(builder: GetConfigCmdBuilder) -> UciCommand {
12326         builder.build().into()
12327     }
12328 }
12329 impl From<GetConfigCmdBuilder> for CoreCommand {
from(builder: GetConfigCmdBuilder) -> CoreCommand12330     fn from(builder: GetConfigCmdBuilder) -> CoreCommand {
12331         builder.build().into()
12332     }
12333 }
12334 impl From<GetConfigCmdBuilder> for GetConfigCmd {
from(builder: GetConfigCmdBuilder) -> GetConfigCmd12335     fn from(builder: GetConfigCmdBuilder) -> GetConfigCmd {
12336         builder.build().into()
12337     }
12338 }
12339 #[derive(Debug, Clone, PartialEq, Eq)]
12340 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12341 pub struct GetConfigRspData {
12342     status: StatusCode,
12343     tlvs: Vec<DeviceConfigTlv>,
12344 }
12345 #[derive(Debug, Clone, PartialEq, Eq)]
12346 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12347 pub struct GetConfigRsp {
12348     #[cfg_attr(feature = "serde", serde(flatten))]
12349     ucicontrolpacket: UciControlPacketData,
12350     #[cfg_attr(feature = "serde", serde(flatten))]
12351     uciresponse: UciResponseData,
12352     #[cfg_attr(feature = "serde", serde(flatten))]
12353     coreresponse: CoreResponseData,
12354     #[cfg_attr(feature = "serde", serde(flatten))]
12355     getconfigrsp: GetConfigRspData,
12356 }
12357 #[derive(Debug)]
12358 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12359 pub struct GetConfigRspBuilder {
12360     pub status: StatusCode,
12361     pub tlvs: Vec<DeviceConfigTlv>,
12362 }
12363 impl GetConfigRspData {
conforms(bytes: &[u8]) -> bool12364     fn conforms(bytes: &[u8]) -> bool {
12365         bytes.len() >= 2
12366     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>12367     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
12368         let mut cell = Cell::new(bytes);
12369         let packet = Self::parse_inner(&mut cell)?;
12370         Ok(packet)
12371     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>12372     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
12373         if bytes.get().remaining() < 1 {
12374             return Err(DecodeError::InvalidLengthError {
12375                 obj: "GetConfigRsp",
12376                 wanted: 1,
12377                 got: bytes.get().remaining(),
12378             });
12379         }
12380         let status = StatusCode::try_from(bytes.get_mut().get_u8())
12381             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
12382                 obj: "GetConfigRsp",
12383                 field: "status",
12384                 value: unknown_val as u64,
12385                 type_: "StatusCode",
12386             })?;
12387         if bytes.get().remaining() < 1 {
12388             return Err(DecodeError::InvalidLengthError {
12389                 obj: "GetConfigRsp",
12390                 wanted: 1,
12391                 got: bytes.get().remaining(),
12392             });
12393         }
12394         let tlvs_count = bytes.get_mut().get_u8() as usize;
12395         let tlvs = (0..tlvs_count)
12396             .map(|_| DeviceConfigTlv::parse_inner(bytes))
12397             .collect::<Result<Vec<_>, DecodeError>>()?;
12398         Ok(Self { status, tlvs })
12399     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>12400     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
12401         buffer.put_u8(u8::from(self.status));
12402         buffer.put_u8(self.tlvs.len() as u8);
12403         for elem in &self.tlvs {
12404             elem.write_to(buffer)?;
12405         }
12406         Ok(())
12407     }
get_total_size(&self) -> usize12408     fn get_total_size(&self) -> usize {
12409         self.get_size()
12410     }
get_size(&self) -> usize12411     fn get_size(&self) -> usize {
12412         2 + self.tlvs.iter().map(|elem| elem.get_size()).sum::<usize>()
12413     }
12414 }
12415 impl Packet for GetConfigRsp {
encoded_len(&self) -> usize12416     fn encoded_len(&self) -> usize {
12417         self.get_size()
12418     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>12419     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
12420         self.ucicontrolpacket.write_to(buf)
12421     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>12422     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
12423         unimplemented!("Rust legacy does not implement full packet trait")
12424     }
12425 }
12426 impl TryFrom<GetConfigRsp> for Bytes {
12427     type Error = EncodeError;
try_from(packet: GetConfigRsp) -> Result<Self, Self::Error>12428     fn try_from(packet: GetConfigRsp) -> Result<Self, Self::Error> {
12429         packet.encode_to_bytes()
12430     }
12431 }
12432 impl TryFrom<GetConfigRsp> for Vec<u8> {
12433     type Error = EncodeError;
try_from(packet: GetConfigRsp) -> Result<Self, Self::Error>12434     fn try_from(packet: GetConfigRsp) -> Result<Self, Self::Error> {
12435         packet.encode_to_vec()
12436     }
12437 }
12438 impl From<GetConfigRsp> for UciControlPacket {
from(packet: GetConfigRsp) -> UciControlPacket12439     fn from(packet: GetConfigRsp) -> UciControlPacket {
12440         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
12441     }
12442 }
12443 impl From<GetConfigRsp> for UciResponse {
from(packet: GetConfigRsp) -> UciResponse12444     fn from(packet: GetConfigRsp) -> UciResponse {
12445         UciResponse::new(packet.ucicontrolpacket).unwrap()
12446     }
12447 }
12448 impl From<GetConfigRsp> for CoreResponse {
from(packet: GetConfigRsp) -> CoreResponse12449     fn from(packet: GetConfigRsp) -> CoreResponse {
12450         CoreResponse::new(packet.ucicontrolpacket).unwrap()
12451     }
12452 }
12453 impl TryFrom<UciControlPacket> for GetConfigRsp {
12454     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<GetConfigRsp, Self::Error>12455     fn try_from(packet: UciControlPacket) -> Result<GetConfigRsp, Self::Error> {
12456         GetConfigRsp::new(packet.ucicontrolpacket)
12457     }
12458 }
12459 impl GetConfigRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>12460     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
12461         let mut cell = Cell::new(bytes);
12462         let packet = Self::parse_inner(&mut cell)?;
12463         Ok(packet)
12464     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>12465     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
12466         let data = UciControlPacketData::parse_inner(&mut bytes)?;
12467         Self::new(data)
12468     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>12469     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
12470         let uciresponse = match &ucicontrolpacket.child {
12471             UciControlPacketDataChild::UciResponse(value) => value.clone(),
12472             _ => {
12473                 return Err(DecodeError::InvalidChildError {
12474                     expected: stringify!(UciControlPacketDataChild::UciResponse),
12475                     actual: format!("{:?}", & ucicontrolpacket.child),
12476                 });
12477             }
12478         };
12479         let coreresponse = match &uciresponse.child {
12480             UciResponseDataChild::CoreResponse(value) => value.clone(),
12481             _ => {
12482                 return Err(DecodeError::InvalidChildError {
12483                     expected: stringify!(UciResponseDataChild::CoreResponse),
12484                     actual: format!("{:?}", & uciresponse.child),
12485                 });
12486             }
12487         };
12488         let getconfigrsp = match &coreresponse.child {
12489             CoreResponseDataChild::GetConfigRsp(value) => value.clone(),
12490             _ => {
12491                 return Err(DecodeError::InvalidChildError {
12492                     expected: stringify!(CoreResponseDataChild::GetConfigRsp),
12493                     actual: format!("{:?}", & coreresponse.child),
12494                 });
12495             }
12496         };
12497         Ok(Self {
12498             ucicontrolpacket,
12499             uciresponse,
12500             coreresponse,
12501             getconfigrsp,
12502         })
12503     }
get_group_id(&self) -> GroupId12504     pub fn get_group_id(&self) -> GroupId {
12505         self.ucicontrolpacket.group_id
12506     }
get_message_type(&self) -> MessageType12507     pub fn get_message_type(&self) -> MessageType {
12508         self.ucicontrolpacket.message_type
12509     }
get_opcode(&self) -> u812510     pub fn get_opcode(&self) -> u8 {
12511         self.ucicontrolpacket.opcode
12512     }
get_status(&self) -> StatusCode12513     pub fn get_status(&self) -> StatusCode {
12514         self.getconfigrsp.status
12515     }
get_tlvs(&self) -> &Vec<DeviceConfigTlv>12516     pub fn get_tlvs(&self) -> &Vec<DeviceConfigTlv> {
12517         &self.getconfigrsp.tlvs
12518     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>12519     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
12520         self.getconfigrsp.write_to(buffer)
12521     }
get_size(&self) -> usize12522     pub fn get_size(&self) -> usize {
12523         self.ucicontrolpacket.get_size()
12524     }
12525 }
12526 impl GetConfigRspBuilder {
build(self) -> GetConfigRsp12527     pub fn build(self) -> GetConfigRsp {
12528         let getconfigrsp = GetConfigRspData {
12529             status: self.status,
12530             tlvs: self.tlvs,
12531         };
12532         let coreresponse = CoreResponseData {
12533             child: CoreResponseDataChild::GetConfigRsp(getconfigrsp),
12534         };
12535         let uciresponse = UciResponseData {
12536             child: UciResponseDataChild::CoreResponse(coreresponse),
12537         };
12538         let ucicontrolpacket = UciControlPacketData {
12539             group_id: GroupId::Core,
12540             message_type: MessageType::Response,
12541             opcode: 5,
12542             child: UciControlPacketDataChild::UciResponse(uciresponse),
12543         };
12544         GetConfigRsp::new(ucicontrolpacket).unwrap()
12545     }
12546 }
12547 impl From<GetConfigRspBuilder> for UciControlPacket {
from(builder: GetConfigRspBuilder) -> UciControlPacket12548     fn from(builder: GetConfigRspBuilder) -> UciControlPacket {
12549         builder.build().into()
12550     }
12551 }
12552 impl From<GetConfigRspBuilder> for UciResponse {
from(builder: GetConfigRspBuilder) -> UciResponse12553     fn from(builder: GetConfigRspBuilder) -> UciResponse {
12554         builder.build().into()
12555     }
12556 }
12557 impl From<GetConfigRspBuilder> for CoreResponse {
from(builder: GetConfigRspBuilder) -> CoreResponse12558     fn from(builder: GetConfigRspBuilder) -> CoreResponse {
12559         builder.build().into()
12560     }
12561 }
12562 impl From<GetConfigRspBuilder> for GetConfigRsp {
from(builder: GetConfigRspBuilder) -> GetConfigRsp12563     fn from(builder: GetConfigRspBuilder) -> GetConfigRsp {
12564         builder.build().into()
12565     }
12566 }
12567 #[derive(Debug, Clone, PartialEq, Eq)]
12568 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12569 pub struct GenericErrorData {
12570     status: StatusCode,
12571 }
12572 #[derive(Debug, Clone, PartialEq, Eq)]
12573 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12574 pub struct GenericError {
12575     #[cfg_attr(feature = "serde", serde(flatten))]
12576     ucicontrolpacket: UciControlPacketData,
12577     #[cfg_attr(feature = "serde", serde(flatten))]
12578     ucinotification: UciNotificationData,
12579     #[cfg_attr(feature = "serde", serde(flatten))]
12580     corenotification: CoreNotificationData,
12581     #[cfg_attr(feature = "serde", serde(flatten))]
12582     genericerror: GenericErrorData,
12583 }
12584 #[derive(Debug)]
12585 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12586 pub struct GenericErrorBuilder {
12587     pub status: StatusCode,
12588 }
12589 impl GenericErrorData {
conforms(bytes: &[u8]) -> bool12590     fn conforms(bytes: &[u8]) -> bool {
12591         bytes.len() >= 1
12592     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>12593     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
12594         let mut cell = Cell::new(bytes);
12595         let packet = Self::parse_inner(&mut cell)?;
12596         Ok(packet)
12597     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>12598     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
12599         if bytes.get().remaining() < 1 {
12600             return Err(DecodeError::InvalidLengthError {
12601                 obj: "GenericError",
12602                 wanted: 1,
12603                 got: bytes.get().remaining(),
12604             });
12605         }
12606         let status = StatusCode::try_from(bytes.get_mut().get_u8())
12607             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
12608                 obj: "GenericError",
12609                 field: "status",
12610                 value: unknown_val as u64,
12611                 type_: "StatusCode",
12612             })?;
12613         Ok(Self { status })
12614     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>12615     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
12616         buffer.put_u8(u8::from(self.status));
12617         Ok(())
12618     }
get_total_size(&self) -> usize12619     fn get_total_size(&self) -> usize {
12620         self.get_size()
12621     }
get_size(&self) -> usize12622     fn get_size(&self) -> usize {
12623         1
12624     }
12625 }
12626 impl Packet for GenericError {
encoded_len(&self) -> usize12627     fn encoded_len(&self) -> usize {
12628         self.get_size()
12629     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>12630     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
12631         self.ucicontrolpacket.write_to(buf)
12632     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>12633     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
12634         unimplemented!("Rust legacy does not implement full packet trait")
12635     }
12636 }
12637 impl TryFrom<GenericError> for Bytes {
12638     type Error = EncodeError;
try_from(packet: GenericError) -> Result<Self, Self::Error>12639     fn try_from(packet: GenericError) -> Result<Self, Self::Error> {
12640         packet.encode_to_bytes()
12641     }
12642 }
12643 impl TryFrom<GenericError> for Vec<u8> {
12644     type Error = EncodeError;
try_from(packet: GenericError) -> Result<Self, Self::Error>12645     fn try_from(packet: GenericError) -> Result<Self, Self::Error> {
12646         packet.encode_to_vec()
12647     }
12648 }
12649 impl From<GenericError> for UciControlPacket {
from(packet: GenericError) -> UciControlPacket12650     fn from(packet: GenericError) -> UciControlPacket {
12651         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
12652     }
12653 }
12654 impl From<GenericError> for UciNotification {
from(packet: GenericError) -> UciNotification12655     fn from(packet: GenericError) -> UciNotification {
12656         UciNotification::new(packet.ucicontrolpacket).unwrap()
12657     }
12658 }
12659 impl From<GenericError> for CoreNotification {
from(packet: GenericError) -> CoreNotification12660     fn from(packet: GenericError) -> CoreNotification {
12661         CoreNotification::new(packet.ucicontrolpacket).unwrap()
12662     }
12663 }
12664 impl TryFrom<UciControlPacket> for GenericError {
12665     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<GenericError, Self::Error>12666     fn try_from(packet: UciControlPacket) -> Result<GenericError, Self::Error> {
12667         GenericError::new(packet.ucicontrolpacket)
12668     }
12669 }
12670 impl GenericError {
parse(bytes: &[u8]) -> Result<Self, DecodeError>12671     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
12672         let mut cell = Cell::new(bytes);
12673         let packet = Self::parse_inner(&mut cell)?;
12674         Ok(packet)
12675     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>12676     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
12677         let data = UciControlPacketData::parse_inner(&mut bytes)?;
12678         Self::new(data)
12679     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>12680     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
12681         let ucinotification = match &ucicontrolpacket.child {
12682             UciControlPacketDataChild::UciNotification(value) => value.clone(),
12683             _ => {
12684                 return Err(DecodeError::InvalidChildError {
12685                     expected: stringify!(UciControlPacketDataChild::UciNotification),
12686                     actual: format!("{:?}", & ucicontrolpacket.child),
12687                 });
12688             }
12689         };
12690         let corenotification = match &ucinotification.child {
12691             UciNotificationDataChild::CoreNotification(value) => value.clone(),
12692             _ => {
12693                 return Err(DecodeError::InvalidChildError {
12694                     expected: stringify!(UciNotificationDataChild::CoreNotification),
12695                     actual: format!("{:?}", & ucinotification.child),
12696                 });
12697             }
12698         };
12699         let genericerror = match &corenotification.child {
12700             CoreNotificationDataChild::GenericError(value) => value.clone(),
12701             _ => {
12702                 return Err(DecodeError::InvalidChildError {
12703                     expected: stringify!(CoreNotificationDataChild::GenericError),
12704                     actual: format!("{:?}", & corenotification.child),
12705                 });
12706             }
12707         };
12708         Ok(Self {
12709             ucicontrolpacket,
12710             ucinotification,
12711             corenotification,
12712             genericerror,
12713         })
12714     }
get_group_id(&self) -> GroupId12715     pub fn get_group_id(&self) -> GroupId {
12716         self.ucicontrolpacket.group_id
12717     }
get_message_type(&self) -> MessageType12718     pub fn get_message_type(&self) -> MessageType {
12719         self.ucicontrolpacket.message_type
12720     }
get_opcode(&self) -> u812721     pub fn get_opcode(&self) -> u8 {
12722         self.ucicontrolpacket.opcode
12723     }
get_status(&self) -> StatusCode12724     pub fn get_status(&self) -> StatusCode {
12725         self.genericerror.status
12726     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>12727     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
12728         self.genericerror.write_to(buffer)
12729     }
get_size(&self) -> usize12730     pub fn get_size(&self) -> usize {
12731         self.ucicontrolpacket.get_size()
12732     }
12733 }
12734 impl GenericErrorBuilder {
build(self) -> GenericError12735     pub fn build(self) -> GenericError {
12736         let genericerror = GenericErrorData {
12737             status: self.status,
12738         };
12739         let corenotification = CoreNotificationData {
12740             child: CoreNotificationDataChild::GenericError(genericerror),
12741         };
12742         let ucinotification = UciNotificationData {
12743             child: UciNotificationDataChild::CoreNotification(corenotification),
12744         };
12745         let ucicontrolpacket = UciControlPacketData {
12746             group_id: GroupId::Core,
12747             message_type: MessageType::Notification,
12748             opcode: 7,
12749             child: UciControlPacketDataChild::UciNotification(ucinotification),
12750         };
12751         GenericError::new(ucicontrolpacket).unwrap()
12752     }
12753 }
12754 impl From<GenericErrorBuilder> for UciControlPacket {
from(builder: GenericErrorBuilder) -> UciControlPacket12755     fn from(builder: GenericErrorBuilder) -> UciControlPacket {
12756         builder.build().into()
12757     }
12758 }
12759 impl From<GenericErrorBuilder> for UciNotification {
from(builder: GenericErrorBuilder) -> UciNotification12760     fn from(builder: GenericErrorBuilder) -> UciNotification {
12761         builder.build().into()
12762     }
12763 }
12764 impl From<GenericErrorBuilder> for CoreNotification {
from(builder: GenericErrorBuilder) -> CoreNotification12765     fn from(builder: GenericErrorBuilder) -> CoreNotification {
12766         builder.build().into()
12767     }
12768 }
12769 impl From<GenericErrorBuilder> for GenericError {
from(builder: GenericErrorBuilder) -> GenericError12770     fn from(builder: GenericErrorBuilder) -> GenericError {
12771         builder.build().into()
12772     }
12773 }
12774 #[derive(Debug, Clone, PartialEq, Eq)]
12775 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12776 pub struct CoreQueryTimeStampCmdData {}
12777 #[derive(Debug, Clone, PartialEq, Eq)]
12778 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12779 pub struct CoreQueryTimeStampCmd {
12780     #[cfg_attr(feature = "serde", serde(flatten))]
12781     ucicontrolpacket: UciControlPacketData,
12782     #[cfg_attr(feature = "serde", serde(flatten))]
12783     ucicommand: UciCommandData,
12784     #[cfg_attr(feature = "serde", serde(flatten))]
12785     corecommand: CoreCommandData,
12786     #[cfg_attr(feature = "serde", serde(flatten))]
12787     corequerytimestampcmd: CoreQueryTimeStampCmdData,
12788 }
12789 #[derive(Debug)]
12790 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12791 pub struct CoreQueryTimeStampCmdBuilder {}
12792 impl CoreQueryTimeStampCmdData {
conforms(bytes: &[u8]) -> bool12793     fn conforms(bytes: &[u8]) -> bool {
12794         true
12795     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>12796     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
12797         let mut cell = Cell::new(bytes);
12798         let packet = Self::parse_inner(&mut cell)?;
12799         Ok(packet)
12800     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>12801     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
12802         Ok(Self {})
12803     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>12804     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
12805         Ok(())
12806     }
get_total_size(&self) -> usize12807     fn get_total_size(&self) -> usize {
12808         self.get_size()
12809     }
get_size(&self) -> usize12810     fn get_size(&self) -> usize {
12811         0
12812     }
12813 }
12814 impl Packet for CoreQueryTimeStampCmd {
encoded_len(&self) -> usize12815     fn encoded_len(&self) -> usize {
12816         self.get_size()
12817     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>12818     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
12819         self.ucicontrolpacket.write_to(buf)
12820     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>12821     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
12822         unimplemented!("Rust legacy does not implement full packet trait")
12823     }
12824 }
12825 impl TryFrom<CoreQueryTimeStampCmd> for Bytes {
12826     type Error = EncodeError;
try_from(packet: CoreQueryTimeStampCmd) -> Result<Self, Self::Error>12827     fn try_from(packet: CoreQueryTimeStampCmd) -> Result<Self, Self::Error> {
12828         packet.encode_to_bytes()
12829     }
12830 }
12831 impl TryFrom<CoreQueryTimeStampCmd> for Vec<u8> {
12832     type Error = EncodeError;
try_from(packet: CoreQueryTimeStampCmd) -> Result<Self, Self::Error>12833     fn try_from(packet: CoreQueryTimeStampCmd) -> Result<Self, Self::Error> {
12834         packet.encode_to_vec()
12835     }
12836 }
12837 impl From<CoreQueryTimeStampCmd> for UciControlPacket {
from(packet: CoreQueryTimeStampCmd) -> UciControlPacket12838     fn from(packet: CoreQueryTimeStampCmd) -> UciControlPacket {
12839         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
12840     }
12841 }
12842 impl From<CoreQueryTimeStampCmd> for UciCommand {
from(packet: CoreQueryTimeStampCmd) -> UciCommand12843     fn from(packet: CoreQueryTimeStampCmd) -> UciCommand {
12844         UciCommand::new(packet.ucicontrolpacket).unwrap()
12845     }
12846 }
12847 impl From<CoreQueryTimeStampCmd> for CoreCommand {
from(packet: CoreQueryTimeStampCmd) -> CoreCommand12848     fn from(packet: CoreQueryTimeStampCmd) -> CoreCommand {
12849         CoreCommand::new(packet.ucicontrolpacket).unwrap()
12850     }
12851 }
12852 impl TryFrom<UciControlPacket> for CoreQueryTimeStampCmd {
12853     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<CoreQueryTimeStampCmd, Self::Error>12854     fn try_from(packet: UciControlPacket) -> Result<CoreQueryTimeStampCmd, Self::Error> {
12855         CoreQueryTimeStampCmd::new(packet.ucicontrolpacket)
12856     }
12857 }
12858 impl CoreQueryTimeStampCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>12859     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
12860         let mut cell = Cell::new(bytes);
12861         let packet = Self::parse_inner(&mut cell)?;
12862         Ok(packet)
12863     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>12864     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
12865         let data = UciControlPacketData::parse_inner(&mut bytes)?;
12866         Self::new(data)
12867     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>12868     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
12869         let ucicommand = match &ucicontrolpacket.child {
12870             UciControlPacketDataChild::UciCommand(value) => value.clone(),
12871             _ => {
12872                 return Err(DecodeError::InvalidChildError {
12873                     expected: stringify!(UciControlPacketDataChild::UciCommand),
12874                     actual: format!("{:?}", & ucicontrolpacket.child),
12875                 });
12876             }
12877         };
12878         let corecommand = match &ucicommand.child {
12879             UciCommandDataChild::CoreCommand(value) => value.clone(),
12880             _ => {
12881                 return Err(DecodeError::InvalidChildError {
12882                     expected: stringify!(UciCommandDataChild::CoreCommand),
12883                     actual: format!("{:?}", & ucicommand.child),
12884                 });
12885             }
12886         };
12887         let corequerytimestampcmd = match &corecommand.child {
12888             CoreCommandDataChild::CoreQueryTimeStampCmd(value) => value.clone(),
12889             _ => {
12890                 return Err(DecodeError::InvalidChildError {
12891                     expected: stringify!(CoreCommandDataChild::CoreQueryTimeStampCmd),
12892                     actual: format!("{:?}", & corecommand.child),
12893                 });
12894             }
12895         };
12896         Ok(Self {
12897             ucicontrolpacket,
12898             ucicommand,
12899             corecommand,
12900             corequerytimestampcmd,
12901         })
12902     }
get_group_id(&self) -> GroupId12903     pub fn get_group_id(&self) -> GroupId {
12904         self.ucicontrolpacket.group_id
12905     }
get_message_type(&self) -> MessageType12906     pub fn get_message_type(&self) -> MessageType {
12907         self.ucicontrolpacket.message_type
12908     }
get_opcode(&self) -> u812909     pub fn get_opcode(&self) -> u8 {
12910         self.ucicontrolpacket.opcode
12911     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>12912     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
12913         self.corequerytimestampcmd.write_to(buffer)
12914     }
get_size(&self) -> usize12915     pub fn get_size(&self) -> usize {
12916         self.ucicontrolpacket.get_size()
12917     }
12918 }
12919 impl CoreQueryTimeStampCmdBuilder {
build(self) -> CoreQueryTimeStampCmd12920     pub fn build(self) -> CoreQueryTimeStampCmd {
12921         let corequerytimestampcmd = CoreQueryTimeStampCmdData {};
12922         let corecommand = CoreCommandData {
12923             child: CoreCommandDataChild::CoreQueryTimeStampCmd(corequerytimestampcmd),
12924         };
12925         let ucicommand = UciCommandData {
12926             child: UciCommandDataChild::CoreCommand(corecommand),
12927         };
12928         let ucicontrolpacket = UciControlPacketData {
12929             group_id: GroupId::Core,
12930             message_type: MessageType::Command,
12931             opcode: 8,
12932             child: UciControlPacketDataChild::UciCommand(ucicommand),
12933         };
12934         CoreQueryTimeStampCmd::new(ucicontrolpacket).unwrap()
12935     }
12936 }
12937 impl From<CoreQueryTimeStampCmdBuilder> for UciControlPacket {
from(builder: CoreQueryTimeStampCmdBuilder) -> UciControlPacket12938     fn from(builder: CoreQueryTimeStampCmdBuilder) -> UciControlPacket {
12939         builder.build().into()
12940     }
12941 }
12942 impl From<CoreQueryTimeStampCmdBuilder> for UciCommand {
from(builder: CoreQueryTimeStampCmdBuilder) -> UciCommand12943     fn from(builder: CoreQueryTimeStampCmdBuilder) -> UciCommand {
12944         builder.build().into()
12945     }
12946 }
12947 impl From<CoreQueryTimeStampCmdBuilder> for CoreCommand {
from(builder: CoreQueryTimeStampCmdBuilder) -> CoreCommand12948     fn from(builder: CoreQueryTimeStampCmdBuilder) -> CoreCommand {
12949         builder.build().into()
12950     }
12951 }
12952 impl From<CoreQueryTimeStampCmdBuilder> for CoreQueryTimeStampCmd {
from(builder: CoreQueryTimeStampCmdBuilder) -> CoreQueryTimeStampCmd12953     fn from(builder: CoreQueryTimeStampCmdBuilder) -> CoreQueryTimeStampCmd {
12954         builder.build().into()
12955     }
12956 }
12957 #[derive(Debug, Clone, PartialEq, Eq)]
12958 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12959 pub struct CoreQueryTimeStampRspData {
12960     status: StatusCode,
12961     timeStamp: u64,
12962 }
12963 #[derive(Debug, Clone, PartialEq, Eq)]
12964 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12965 pub struct CoreQueryTimeStampRsp {
12966     #[cfg_attr(feature = "serde", serde(flatten))]
12967     ucicontrolpacket: UciControlPacketData,
12968     #[cfg_attr(feature = "serde", serde(flatten))]
12969     uciresponse: UciResponseData,
12970     #[cfg_attr(feature = "serde", serde(flatten))]
12971     coreresponse: CoreResponseData,
12972     #[cfg_attr(feature = "serde", serde(flatten))]
12973     corequerytimestamprsp: CoreQueryTimeStampRspData,
12974 }
12975 #[derive(Debug)]
12976 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12977 pub struct CoreQueryTimeStampRspBuilder {
12978     pub status: StatusCode,
12979     pub timeStamp: u64,
12980 }
12981 impl CoreQueryTimeStampRspData {
conforms(bytes: &[u8]) -> bool12982     fn conforms(bytes: &[u8]) -> bool {
12983         bytes.len() >= 9
12984     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>12985     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
12986         let mut cell = Cell::new(bytes);
12987         let packet = Self::parse_inner(&mut cell)?;
12988         Ok(packet)
12989     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>12990     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
12991         if bytes.get().remaining() < 1 {
12992             return Err(DecodeError::InvalidLengthError {
12993                 obj: "CoreQueryTimeStampRsp",
12994                 wanted: 1,
12995                 got: bytes.get().remaining(),
12996             });
12997         }
12998         let status = StatusCode::try_from(bytes.get_mut().get_u8())
12999             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
13000                 obj: "CoreQueryTimeStampRsp",
13001                 field: "status",
13002                 value: unknown_val as u64,
13003                 type_: "StatusCode",
13004             })?;
13005         if bytes.get().remaining() < 8 {
13006             return Err(DecodeError::InvalidLengthError {
13007                 obj: "CoreQueryTimeStampRsp",
13008                 wanted: 8,
13009                 got: bytes.get().remaining(),
13010             });
13011         }
13012         let timeStamp = bytes.get_mut().get_u64_le();
13013         Ok(Self { status, timeStamp })
13014     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>13015     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
13016         buffer.put_u8(u8::from(self.status));
13017         buffer.put_u64_le(self.timeStamp);
13018         Ok(())
13019     }
get_total_size(&self) -> usize13020     fn get_total_size(&self) -> usize {
13021         self.get_size()
13022     }
get_size(&self) -> usize13023     fn get_size(&self) -> usize {
13024         9
13025     }
13026 }
13027 impl Packet for CoreQueryTimeStampRsp {
encoded_len(&self) -> usize13028     fn encoded_len(&self) -> usize {
13029         self.get_size()
13030     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>13031     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
13032         self.ucicontrolpacket.write_to(buf)
13033     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>13034     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
13035         unimplemented!("Rust legacy does not implement full packet trait")
13036     }
13037 }
13038 impl TryFrom<CoreQueryTimeStampRsp> for Bytes {
13039     type Error = EncodeError;
try_from(packet: CoreQueryTimeStampRsp) -> Result<Self, Self::Error>13040     fn try_from(packet: CoreQueryTimeStampRsp) -> Result<Self, Self::Error> {
13041         packet.encode_to_bytes()
13042     }
13043 }
13044 impl TryFrom<CoreQueryTimeStampRsp> for Vec<u8> {
13045     type Error = EncodeError;
try_from(packet: CoreQueryTimeStampRsp) -> Result<Self, Self::Error>13046     fn try_from(packet: CoreQueryTimeStampRsp) -> Result<Self, Self::Error> {
13047         packet.encode_to_vec()
13048     }
13049 }
13050 impl From<CoreQueryTimeStampRsp> for UciControlPacket {
from(packet: CoreQueryTimeStampRsp) -> UciControlPacket13051     fn from(packet: CoreQueryTimeStampRsp) -> UciControlPacket {
13052         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
13053     }
13054 }
13055 impl From<CoreQueryTimeStampRsp> for UciResponse {
from(packet: CoreQueryTimeStampRsp) -> UciResponse13056     fn from(packet: CoreQueryTimeStampRsp) -> UciResponse {
13057         UciResponse::new(packet.ucicontrolpacket).unwrap()
13058     }
13059 }
13060 impl From<CoreQueryTimeStampRsp> for CoreResponse {
from(packet: CoreQueryTimeStampRsp) -> CoreResponse13061     fn from(packet: CoreQueryTimeStampRsp) -> CoreResponse {
13062         CoreResponse::new(packet.ucicontrolpacket).unwrap()
13063     }
13064 }
13065 impl TryFrom<UciControlPacket> for CoreQueryTimeStampRsp {
13066     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<CoreQueryTimeStampRsp, Self::Error>13067     fn try_from(packet: UciControlPacket) -> Result<CoreQueryTimeStampRsp, Self::Error> {
13068         CoreQueryTimeStampRsp::new(packet.ucicontrolpacket)
13069     }
13070 }
13071 impl CoreQueryTimeStampRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>13072     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
13073         let mut cell = Cell::new(bytes);
13074         let packet = Self::parse_inner(&mut cell)?;
13075         Ok(packet)
13076     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>13077     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
13078         let data = UciControlPacketData::parse_inner(&mut bytes)?;
13079         Self::new(data)
13080     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>13081     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
13082         let uciresponse = match &ucicontrolpacket.child {
13083             UciControlPacketDataChild::UciResponse(value) => value.clone(),
13084             _ => {
13085                 return Err(DecodeError::InvalidChildError {
13086                     expected: stringify!(UciControlPacketDataChild::UciResponse),
13087                     actual: format!("{:?}", & ucicontrolpacket.child),
13088                 });
13089             }
13090         };
13091         let coreresponse = match &uciresponse.child {
13092             UciResponseDataChild::CoreResponse(value) => value.clone(),
13093             _ => {
13094                 return Err(DecodeError::InvalidChildError {
13095                     expected: stringify!(UciResponseDataChild::CoreResponse),
13096                     actual: format!("{:?}", & uciresponse.child),
13097                 });
13098             }
13099         };
13100         let corequerytimestamprsp = match &coreresponse.child {
13101             CoreResponseDataChild::CoreQueryTimeStampRsp(value) => value.clone(),
13102             _ => {
13103                 return Err(DecodeError::InvalidChildError {
13104                     expected: stringify!(CoreResponseDataChild::CoreQueryTimeStampRsp),
13105                     actual: format!("{:?}", & coreresponse.child),
13106                 });
13107             }
13108         };
13109         Ok(Self {
13110             ucicontrolpacket,
13111             uciresponse,
13112             coreresponse,
13113             corequerytimestamprsp,
13114         })
13115     }
get_group_id(&self) -> GroupId13116     pub fn get_group_id(&self) -> GroupId {
13117         self.ucicontrolpacket.group_id
13118     }
get_message_type(&self) -> MessageType13119     pub fn get_message_type(&self) -> MessageType {
13120         self.ucicontrolpacket.message_type
13121     }
get_opcode(&self) -> u813122     pub fn get_opcode(&self) -> u8 {
13123         self.ucicontrolpacket.opcode
13124     }
get_status(&self) -> StatusCode13125     pub fn get_status(&self) -> StatusCode {
13126         self.corequerytimestamprsp.status
13127     }
get_timeStamp(&self) -> u6413128     pub fn get_timeStamp(&self) -> u64 {
13129         self.corequerytimestamprsp.timeStamp
13130     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>13131     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
13132         self.corequerytimestamprsp.write_to(buffer)
13133     }
get_size(&self) -> usize13134     pub fn get_size(&self) -> usize {
13135         self.ucicontrolpacket.get_size()
13136     }
13137 }
13138 impl CoreQueryTimeStampRspBuilder {
build(self) -> CoreQueryTimeStampRsp13139     pub fn build(self) -> CoreQueryTimeStampRsp {
13140         let corequerytimestamprsp = CoreQueryTimeStampRspData {
13141             status: self.status,
13142             timeStamp: self.timeStamp,
13143         };
13144         let coreresponse = CoreResponseData {
13145             child: CoreResponseDataChild::CoreQueryTimeStampRsp(corequerytimestamprsp),
13146         };
13147         let uciresponse = UciResponseData {
13148             child: UciResponseDataChild::CoreResponse(coreresponse),
13149         };
13150         let ucicontrolpacket = UciControlPacketData {
13151             group_id: GroupId::Core,
13152             message_type: MessageType::Response,
13153             opcode: 8,
13154             child: UciControlPacketDataChild::UciResponse(uciresponse),
13155         };
13156         CoreQueryTimeStampRsp::new(ucicontrolpacket).unwrap()
13157     }
13158 }
13159 impl From<CoreQueryTimeStampRspBuilder> for UciControlPacket {
from(builder: CoreQueryTimeStampRspBuilder) -> UciControlPacket13160     fn from(builder: CoreQueryTimeStampRspBuilder) -> UciControlPacket {
13161         builder.build().into()
13162     }
13163 }
13164 impl From<CoreQueryTimeStampRspBuilder> for UciResponse {
from(builder: CoreQueryTimeStampRspBuilder) -> UciResponse13165     fn from(builder: CoreQueryTimeStampRspBuilder) -> UciResponse {
13166         builder.build().into()
13167     }
13168 }
13169 impl From<CoreQueryTimeStampRspBuilder> for CoreResponse {
from(builder: CoreQueryTimeStampRspBuilder) -> CoreResponse13170     fn from(builder: CoreQueryTimeStampRspBuilder) -> CoreResponse {
13171         builder.build().into()
13172     }
13173 }
13174 impl From<CoreQueryTimeStampRspBuilder> for CoreQueryTimeStampRsp {
from(builder: CoreQueryTimeStampRspBuilder) -> CoreQueryTimeStampRsp13175     fn from(builder: CoreQueryTimeStampRspBuilder) -> CoreQueryTimeStampRsp {
13176         builder.build().into()
13177     }
13178 }
13179 #[derive(Debug, Clone, PartialEq, Eq)]
13180 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13181 pub struct SessionInitCmdData {
13182     session_id: u32,
13183     session_type: SessionType,
13184 }
13185 #[derive(Debug, Clone, PartialEq, Eq)]
13186 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13187 pub struct SessionInitCmd {
13188     #[cfg_attr(feature = "serde", serde(flatten))]
13189     ucicontrolpacket: UciControlPacketData,
13190     #[cfg_attr(feature = "serde", serde(flatten))]
13191     ucicommand: UciCommandData,
13192     #[cfg_attr(feature = "serde", serde(flatten))]
13193     sessionconfigcommand: SessionConfigCommandData,
13194     #[cfg_attr(feature = "serde", serde(flatten))]
13195     sessioninitcmd: SessionInitCmdData,
13196 }
13197 #[derive(Debug)]
13198 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13199 pub struct SessionInitCmdBuilder {
13200     pub session_id: u32,
13201     pub session_type: SessionType,
13202 }
13203 impl SessionInitCmdData {
conforms(bytes: &[u8]) -> bool13204     fn conforms(bytes: &[u8]) -> bool {
13205         bytes.len() >= 5
13206     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>13207     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
13208         let mut cell = Cell::new(bytes);
13209         let packet = Self::parse_inner(&mut cell)?;
13210         Ok(packet)
13211     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>13212     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
13213         if bytes.get().remaining() < 4 {
13214             return Err(DecodeError::InvalidLengthError {
13215                 obj: "SessionInitCmd",
13216                 wanted: 4,
13217                 got: bytes.get().remaining(),
13218             });
13219         }
13220         let session_id = bytes.get_mut().get_u32_le();
13221         if bytes.get().remaining() < 1 {
13222             return Err(DecodeError::InvalidLengthError {
13223                 obj: "SessionInitCmd",
13224                 wanted: 1,
13225                 got: bytes.get().remaining(),
13226             });
13227         }
13228         let session_type = SessionType::try_from(bytes.get_mut().get_u8())
13229             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
13230                 obj: "SessionInitCmd",
13231                 field: "session_type",
13232                 value: unknown_val as u64,
13233                 type_: "SessionType",
13234             })?;
13235         Ok(Self { session_id, session_type })
13236     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>13237     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
13238         buffer.put_u32_le(self.session_id);
13239         buffer.put_u8(u8::from(self.session_type));
13240         Ok(())
13241     }
get_total_size(&self) -> usize13242     fn get_total_size(&self) -> usize {
13243         self.get_size()
13244     }
get_size(&self) -> usize13245     fn get_size(&self) -> usize {
13246         5
13247     }
13248 }
13249 impl Packet for SessionInitCmd {
encoded_len(&self) -> usize13250     fn encoded_len(&self) -> usize {
13251         self.get_size()
13252     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>13253     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
13254         self.ucicontrolpacket.write_to(buf)
13255     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>13256     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
13257         unimplemented!("Rust legacy does not implement full packet trait")
13258     }
13259 }
13260 impl TryFrom<SessionInitCmd> for Bytes {
13261     type Error = EncodeError;
try_from(packet: SessionInitCmd) -> Result<Self, Self::Error>13262     fn try_from(packet: SessionInitCmd) -> Result<Self, Self::Error> {
13263         packet.encode_to_bytes()
13264     }
13265 }
13266 impl TryFrom<SessionInitCmd> for Vec<u8> {
13267     type Error = EncodeError;
try_from(packet: SessionInitCmd) -> Result<Self, Self::Error>13268     fn try_from(packet: SessionInitCmd) -> Result<Self, Self::Error> {
13269         packet.encode_to_vec()
13270     }
13271 }
13272 impl From<SessionInitCmd> for UciControlPacket {
from(packet: SessionInitCmd) -> UciControlPacket13273     fn from(packet: SessionInitCmd) -> UciControlPacket {
13274         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
13275     }
13276 }
13277 impl From<SessionInitCmd> for UciCommand {
from(packet: SessionInitCmd) -> UciCommand13278     fn from(packet: SessionInitCmd) -> UciCommand {
13279         UciCommand::new(packet.ucicontrolpacket).unwrap()
13280     }
13281 }
13282 impl From<SessionInitCmd> for SessionConfigCommand {
from(packet: SessionInitCmd) -> SessionConfigCommand13283     fn from(packet: SessionInitCmd) -> SessionConfigCommand {
13284         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
13285     }
13286 }
13287 impl TryFrom<UciControlPacket> for SessionInitCmd {
13288     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionInitCmd, Self::Error>13289     fn try_from(packet: UciControlPacket) -> Result<SessionInitCmd, Self::Error> {
13290         SessionInitCmd::new(packet.ucicontrolpacket)
13291     }
13292 }
13293 impl SessionInitCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>13294     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
13295         let mut cell = Cell::new(bytes);
13296         let packet = Self::parse_inner(&mut cell)?;
13297         Ok(packet)
13298     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>13299     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
13300         let data = UciControlPacketData::parse_inner(&mut bytes)?;
13301         Self::new(data)
13302     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>13303     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
13304         let ucicommand = match &ucicontrolpacket.child {
13305             UciControlPacketDataChild::UciCommand(value) => value.clone(),
13306             _ => {
13307                 return Err(DecodeError::InvalidChildError {
13308                     expected: stringify!(UciControlPacketDataChild::UciCommand),
13309                     actual: format!("{:?}", & ucicontrolpacket.child),
13310                 });
13311             }
13312         };
13313         let sessionconfigcommand = match &ucicommand.child {
13314             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
13315             _ => {
13316                 return Err(DecodeError::InvalidChildError {
13317                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
13318                     actual: format!("{:?}", & ucicommand.child),
13319                 });
13320             }
13321         };
13322         let sessioninitcmd = match &sessionconfigcommand.child {
13323             SessionConfigCommandDataChild::SessionInitCmd(value) => value.clone(),
13324             _ => {
13325                 return Err(DecodeError::InvalidChildError {
13326                     expected: stringify!(SessionConfigCommandDataChild::SessionInitCmd),
13327                     actual: format!("{:?}", & sessionconfigcommand.child),
13328                 });
13329             }
13330         };
13331         Ok(Self {
13332             ucicontrolpacket,
13333             ucicommand,
13334             sessionconfigcommand,
13335             sessioninitcmd,
13336         })
13337     }
get_group_id(&self) -> GroupId13338     pub fn get_group_id(&self) -> GroupId {
13339         self.ucicontrolpacket.group_id
13340     }
get_message_type(&self) -> MessageType13341     pub fn get_message_type(&self) -> MessageType {
13342         self.ucicontrolpacket.message_type
13343     }
get_opcode(&self) -> u813344     pub fn get_opcode(&self) -> u8 {
13345         self.ucicontrolpacket.opcode
13346     }
get_session_id(&self) -> u3213347     pub fn get_session_id(&self) -> u32 {
13348         self.sessioninitcmd.session_id
13349     }
get_session_type(&self) -> SessionType13350     pub fn get_session_type(&self) -> SessionType {
13351         self.sessioninitcmd.session_type
13352     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>13353     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
13354         self.sessioninitcmd.write_to(buffer)
13355     }
get_size(&self) -> usize13356     pub fn get_size(&self) -> usize {
13357         self.ucicontrolpacket.get_size()
13358     }
13359 }
13360 impl SessionInitCmdBuilder {
build(self) -> SessionInitCmd13361     pub fn build(self) -> SessionInitCmd {
13362         let sessioninitcmd = SessionInitCmdData {
13363             session_id: self.session_id,
13364             session_type: self.session_type,
13365         };
13366         let sessionconfigcommand = SessionConfigCommandData {
13367             child: SessionConfigCommandDataChild::SessionInitCmd(sessioninitcmd),
13368         };
13369         let ucicommand = UciCommandData {
13370             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
13371         };
13372         let ucicontrolpacket = UciControlPacketData {
13373             group_id: GroupId::SessionConfig,
13374             message_type: MessageType::Command,
13375             opcode: 0,
13376             child: UciControlPacketDataChild::UciCommand(ucicommand),
13377         };
13378         SessionInitCmd::new(ucicontrolpacket).unwrap()
13379     }
13380 }
13381 impl From<SessionInitCmdBuilder> for UciControlPacket {
from(builder: SessionInitCmdBuilder) -> UciControlPacket13382     fn from(builder: SessionInitCmdBuilder) -> UciControlPacket {
13383         builder.build().into()
13384     }
13385 }
13386 impl From<SessionInitCmdBuilder> for UciCommand {
from(builder: SessionInitCmdBuilder) -> UciCommand13387     fn from(builder: SessionInitCmdBuilder) -> UciCommand {
13388         builder.build().into()
13389     }
13390 }
13391 impl From<SessionInitCmdBuilder> for SessionConfigCommand {
from(builder: SessionInitCmdBuilder) -> SessionConfigCommand13392     fn from(builder: SessionInitCmdBuilder) -> SessionConfigCommand {
13393         builder.build().into()
13394     }
13395 }
13396 impl From<SessionInitCmdBuilder> for SessionInitCmd {
from(builder: SessionInitCmdBuilder) -> SessionInitCmd13397     fn from(builder: SessionInitCmdBuilder) -> SessionInitCmd {
13398         builder.build().into()
13399     }
13400 }
13401 #[derive(Debug, Clone, PartialEq, Eq)]
13402 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13403 pub struct SessionInitRsp_V2Data {
13404     status: StatusCode,
13405     session_handle: u32,
13406 }
13407 #[derive(Debug, Clone, PartialEq, Eq)]
13408 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13409 pub struct SessionInitRsp_V2 {
13410     #[cfg_attr(feature = "serde", serde(flatten))]
13411     ucicontrolpacket: UciControlPacketData,
13412     #[cfg_attr(feature = "serde", serde(flatten))]
13413     uciresponse: UciResponseData,
13414     #[cfg_attr(feature = "serde", serde(flatten))]
13415     sessionconfigresponse: SessionConfigResponseData,
13416     #[cfg_attr(feature = "serde", serde(flatten))]
13417     sessioninitrsp_v2: SessionInitRsp_V2Data,
13418 }
13419 #[derive(Debug)]
13420 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13421 pub struct SessionInitRsp_V2Builder {
13422     pub session_handle: u32,
13423     pub status: StatusCode,
13424 }
13425 impl SessionInitRsp_V2Data {
conforms(bytes: &[u8]) -> bool13426     fn conforms(bytes: &[u8]) -> bool {
13427         bytes.len() >= 5
13428     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>13429     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
13430         let mut cell = Cell::new(bytes);
13431         let packet = Self::parse_inner(&mut cell)?;
13432         Ok(packet)
13433     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>13434     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
13435         if bytes.get().remaining() < 1 {
13436             return Err(DecodeError::InvalidLengthError {
13437                 obj: "SessionInitRsp_V2",
13438                 wanted: 1,
13439                 got: bytes.get().remaining(),
13440             });
13441         }
13442         let status = StatusCode::try_from(bytes.get_mut().get_u8())
13443             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
13444                 obj: "SessionInitRsp_V2",
13445                 field: "status",
13446                 value: unknown_val as u64,
13447                 type_: "StatusCode",
13448             })?;
13449         if bytes.get().remaining() < 4 {
13450             return Err(DecodeError::InvalidLengthError {
13451                 obj: "SessionInitRsp_V2",
13452                 wanted: 4,
13453                 got: bytes.get().remaining(),
13454             });
13455         }
13456         let session_handle = bytes.get_mut().get_u32_le();
13457         Ok(Self { status, session_handle })
13458     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>13459     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
13460         buffer.put_u8(u8::from(self.status));
13461         buffer.put_u32_le(self.session_handle);
13462         Ok(())
13463     }
get_total_size(&self) -> usize13464     fn get_total_size(&self) -> usize {
13465         self.get_size()
13466     }
get_size(&self) -> usize13467     fn get_size(&self) -> usize {
13468         5
13469     }
13470 }
13471 impl Packet for SessionInitRsp_V2 {
encoded_len(&self) -> usize13472     fn encoded_len(&self) -> usize {
13473         self.get_size()
13474     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>13475     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
13476         self.ucicontrolpacket.write_to(buf)
13477     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>13478     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
13479         unimplemented!("Rust legacy does not implement full packet trait")
13480     }
13481 }
13482 impl TryFrom<SessionInitRsp_V2> for Bytes {
13483     type Error = EncodeError;
try_from(packet: SessionInitRsp_V2) -> Result<Self, Self::Error>13484     fn try_from(packet: SessionInitRsp_V2) -> Result<Self, Self::Error> {
13485         packet.encode_to_bytes()
13486     }
13487 }
13488 impl TryFrom<SessionInitRsp_V2> for Vec<u8> {
13489     type Error = EncodeError;
try_from(packet: SessionInitRsp_V2) -> Result<Self, Self::Error>13490     fn try_from(packet: SessionInitRsp_V2) -> Result<Self, Self::Error> {
13491         packet.encode_to_vec()
13492     }
13493 }
13494 impl From<SessionInitRsp_V2> for UciControlPacket {
from(packet: SessionInitRsp_V2) -> UciControlPacket13495     fn from(packet: SessionInitRsp_V2) -> UciControlPacket {
13496         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
13497     }
13498 }
13499 impl From<SessionInitRsp_V2> for UciResponse {
from(packet: SessionInitRsp_V2) -> UciResponse13500     fn from(packet: SessionInitRsp_V2) -> UciResponse {
13501         UciResponse::new(packet.ucicontrolpacket).unwrap()
13502     }
13503 }
13504 impl From<SessionInitRsp_V2> for SessionConfigResponse {
from(packet: SessionInitRsp_V2) -> SessionConfigResponse13505     fn from(packet: SessionInitRsp_V2) -> SessionConfigResponse {
13506         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
13507     }
13508 }
13509 impl TryFrom<UciControlPacket> for SessionInitRsp_V2 {
13510     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionInitRsp_V2, Self::Error>13511     fn try_from(packet: UciControlPacket) -> Result<SessionInitRsp_V2, Self::Error> {
13512         SessionInitRsp_V2::new(packet.ucicontrolpacket)
13513     }
13514 }
13515 impl SessionInitRsp_V2 {
parse(bytes: &[u8]) -> Result<Self, DecodeError>13516     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
13517         let mut cell = Cell::new(bytes);
13518         let packet = Self::parse_inner(&mut cell)?;
13519         Ok(packet)
13520     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>13521     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
13522         let data = UciControlPacketData::parse_inner(&mut bytes)?;
13523         Self::new(data)
13524     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>13525     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
13526         let uciresponse = match &ucicontrolpacket.child {
13527             UciControlPacketDataChild::UciResponse(value) => value.clone(),
13528             _ => {
13529                 return Err(DecodeError::InvalidChildError {
13530                     expected: stringify!(UciControlPacketDataChild::UciResponse),
13531                     actual: format!("{:?}", & ucicontrolpacket.child),
13532                 });
13533             }
13534         };
13535         let sessionconfigresponse = match &uciresponse.child {
13536             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
13537             _ => {
13538                 return Err(DecodeError::InvalidChildError {
13539                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
13540                     actual: format!("{:?}", & uciresponse.child),
13541                 });
13542             }
13543         };
13544         let sessioninitrsp_v2 = match &sessionconfigresponse.child {
13545             SessionConfigResponseDataChild::SessionInitRsp_V2(value) => value.clone(),
13546             _ => {
13547                 return Err(DecodeError::InvalidChildError {
13548                     expected: stringify!(
13549                         SessionConfigResponseDataChild::SessionInitRsp_V2
13550                     ),
13551                     actual: format!("{:?}", & sessionconfigresponse.child),
13552                 });
13553             }
13554         };
13555         Ok(Self {
13556             ucicontrolpacket,
13557             uciresponse,
13558             sessionconfigresponse,
13559             sessioninitrsp_v2,
13560         })
13561     }
get_group_id(&self) -> GroupId13562     pub fn get_group_id(&self) -> GroupId {
13563         self.ucicontrolpacket.group_id
13564     }
get_message_type(&self) -> MessageType13565     pub fn get_message_type(&self) -> MessageType {
13566         self.ucicontrolpacket.message_type
13567     }
get_opcode(&self) -> u813568     pub fn get_opcode(&self) -> u8 {
13569         self.ucicontrolpacket.opcode
13570     }
get_session_handle(&self) -> u3213571     pub fn get_session_handle(&self) -> u32 {
13572         self.sessioninitrsp_v2.session_handle
13573     }
get_status(&self) -> StatusCode13574     pub fn get_status(&self) -> StatusCode {
13575         self.sessioninitrsp_v2.status
13576     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>13577     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
13578         self.sessioninitrsp_v2.write_to(buffer)
13579     }
get_size(&self) -> usize13580     pub fn get_size(&self) -> usize {
13581         self.ucicontrolpacket.get_size()
13582     }
13583 }
13584 impl SessionInitRsp_V2Builder {
build(self) -> SessionInitRsp_V213585     pub fn build(self) -> SessionInitRsp_V2 {
13586         let sessioninitrsp_v2 = SessionInitRsp_V2Data {
13587             session_handle: self.session_handle,
13588             status: self.status,
13589         };
13590         let sessionconfigresponse = SessionConfigResponseData {
13591             child: SessionConfigResponseDataChild::SessionInitRsp_V2(sessioninitrsp_v2),
13592         };
13593         let uciresponse = UciResponseData {
13594             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
13595         };
13596         let ucicontrolpacket = UciControlPacketData {
13597             group_id: GroupId::SessionConfig,
13598             message_type: MessageType::Response,
13599             opcode: 0,
13600             child: UciControlPacketDataChild::UciResponse(uciresponse),
13601         };
13602         SessionInitRsp_V2::new(ucicontrolpacket).unwrap()
13603     }
13604 }
13605 impl From<SessionInitRsp_V2Builder> for UciControlPacket {
from(builder: SessionInitRsp_V2Builder) -> UciControlPacket13606     fn from(builder: SessionInitRsp_V2Builder) -> UciControlPacket {
13607         builder.build().into()
13608     }
13609 }
13610 impl From<SessionInitRsp_V2Builder> for UciResponse {
from(builder: SessionInitRsp_V2Builder) -> UciResponse13611     fn from(builder: SessionInitRsp_V2Builder) -> UciResponse {
13612         builder.build().into()
13613     }
13614 }
13615 impl From<SessionInitRsp_V2Builder> for SessionConfigResponse {
from(builder: SessionInitRsp_V2Builder) -> SessionConfigResponse13616     fn from(builder: SessionInitRsp_V2Builder) -> SessionConfigResponse {
13617         builder.build().into()
13618     }
13619 }
13620 impl From<SessionInitRsp_V2Builder> for SessionInitRsp_V2 {
from(builder: SessionInitRsp_V2Builder) -> SessionInitRsp_V213621     fn from(builder: SessionInitRsp_V2Builder) -> SessionInitRsp_V2 {
13622         builder.build().into()
13623     }
13624 }
13625 #[derive(Debug, Clone, PartialEq, Eq)]
13626 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13627 pub struct SessionInitRspData {
13628     status: StatusCode,
13629 }
13630 #[derive(Debug, Clone, PartialEq, Eq)]
13631 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13632 pub struct SessionInitRsp {
13633     #[cfg_attr(feature = "serde", serde(flatten))]
13634     ucicontrolpacket: UciControlPacketData,
13635     #[cfg_attr(feature = "serde", serde(flatten))]
13636     uciresponse: UciResponseData,
13637     #[cfg_attr(feature = "serde", serde(flatten))]
13638     sessionconfigresponse: SessionConfigResponseData,
13639     #[cfg_attr(feature = "serde", serde(flatten))]
13640     sessioninitrsp: SessionInitRspData,
13641 }
13642 #[derive(Debug)]
13643 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13644 pub struct SessionInitRspBuilder {
13645     pub status: StatusCode,
13646 }
13647 impl SessionInitRspData {
conforms(bytes: &[u8]) -> bool13648     fn conforms(bytes: &[u8]) -> bool {
13649         bytes.len() >= 1
13650     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>13651     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
13652         let mut cell = Cell::new(bytes);
13653         let packet = Self::parse_inner(&mut cell)?;
13654         Ok(packet)
13655     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>13656     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
13657         if bytes.get().remaining() < 1 {
13658             return Err(DecodeError::InvalidLengthError {
13659                 obj: "SessionInitRsp",
13660                 wanted: 1,
13661                 got: bytes.get().remaining(),
13662             });
13663         }
13664         let status = StatusCode::try_from(bytes.get_mut().get_u8())
13665             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
13666                 obj: "SessionInitRsp",
13667                 field: "status",
13668                 value: unknown_val as u64,
13669                 type_: "StatusCode",
13670             })?;
13671         Ok(Self { status })
13672     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>13673     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
13674         buffer.put_u8(u8::from(self.status));
13675         Ok(())
13676     }
get_total_size(&self) -> usize13677     fn get_total_size(&self) -> usize {
13678         self.get_size()
13679     }
get_size(&self) -> usize13680     fn get_size(&self) -> usize {
13681         1
13682     }
13683 }
13684 impl Packet for SessionInitRsp {
encoded_len(&self) -> usize13685     fn encoded_len(&self) -> usize {
13686         self.get_size()
13687     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>13688     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
13689         self.ucicontrolpacket.write_to(buf)
13690     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>13691     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
13692         unimplemented!("Rust legacy does not implement full packet trait")
13693     }
13694 }
13695 impl TryFrom<SessionInitRsp> for Bytes {
13696     type Error = EncodeError;
try_from(packet: SessionInitRsp) -> Result<Self, Self::Error>13697     fn try_from(packet: SessionInitRsp) -> Result<Self, Self::Error> {
13698         packet.encode_to_bytes()
13699     }
13700 }
13701 impl TryFrom<SessionInitRsp> for Vec<u8> {
13702     type Error = EncodeError;
try_from(packet: SessionInitRsp) -> Result<Self, Self::Error>13703     fn try_from(packet: SessionInitRsp) -> Result<Self, Self::Error> {
13704         packet.encode_to_vec()
13705     }
13706 }
13707 impl From<SessionInitRsp> for UciControlPacket {
from(packet: SessionInitRsp) -> UciControlPacket13708     fn from(packet: SessionInitRsp) -> UciControlPacket {
13709         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
13710     }
13711 }
13712 impl From<SessionInitRsp> for UciResponse {
from(packet: SessionInitRsp) -> UciResponse13713     fn from(packet: SessionInitRsp) -> UciResponse {
13714         UciResponse::new(packet.ucicontrolpacket).unwrap()
13715     }
13716 }
13717 impl From<SessionInitRsp> for SessionConfigResponse {
from(packet: SessionInitRsp) -> SessionConfigResponse13718     fn from(packet: SessionInitRsp) -> SessionConfigResponse {
13719         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
13720     }
13721 }
13722 impl TryFrom<UciControlPacket> for SessionInitRsp {
13723     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionInitRsp, Self::Error>13724     fn try_from(packet: UciControlPacket) -> Result<SessionInitRsp, Self::Error> {
13725         SessionInitRsp::new(packet.ucicontrolpacket)
13726     }
13727 }
13728 impl SessionInitRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>13729     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
13730         let mut cell = Cell::new(bytes);
13731         let packet = Self::parse_inner(&mut cell)?;
13732         Ok(packet)
13733     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>13734     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
13735         let data = UciControlPacketData::parse_inner(&mut bytes)?;
13736         Self::new(data)
13737     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>13738     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
13739         let uciresponse = match &ucicontrolpacket.child {
13740             UciControlPacketDataChild::UciResponse(value) => value.clone(),
13741             _ => {
13742                 return Err(DecodeError::InvalidChildError {
13743                     expected: stringify!(UciControlPacketDataChild::UciResponse),
13744                     actual: format!("{:?}", & ucicontrolpacket.child),
13745                 });
13746             }
13747         };
13748         let sessionconfigresponse = match &uciresponse.child {
13749             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
13750             _ => {
13751                 return Err(DecodeError::InvalidChildError {
13752                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
13753                     actual: format!("{:?}", & uciresponse.child),
13754                 });
13755             }
13756         };
13757         let sessioninitrsp = match &sessionconfigresponse.child {
13758             SessionConfigResponseDataChild::SessionInitRsp(value) => value.clone(),
13759             _ => {
13760                 return Err(DecodeError::InvalidChildError {
13761                     expected: stringify!(SessionConfigResponseDataChild::SessionInitRsp),
13762                     actual: format!("{:?}", & sessionconfigresponse.child),
13763                 });
13764             }
13765         };
13766         Ok(Self {
13767             ucicontrolpacket,
13768             uciresponse,
13769             sessionconfigresponse,
13770             sessioninitrsp,
13771         })
13772     }
get_group_id(&self) -> GroupId13773     pub fn get_group_id(&self) -> GroupId {
13774         self.ucicontrolpacket.group_id
13775     }
get_message_type(&self) -> MessageType13776     pub fn get_message_type(&self) -> MessageType {
13777         self.ucicontrolpacket.message_type
13778     }
get_opcode(&self) -> u813779     pub fn get_opcode(&self) -> u8 {
13780         self.ucicontrolpacket.opcode
13781     }
get_status(&self) -> StatusCode13782     pub fn get_status(&self) -> StatusCode {
13783         self.sessioninitrsp.status
13784     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>13785     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
13786         self.sessioninitrsp.write_to(buffer)
13787     }
get_size(&self) -> usize13788     pub fn get_size(&self) -> usize {
13789         self.ucicontrolpacket.get_size()
13790     }
13791 }
13792 impl SessionInitRspBuilder {
build(self) -> SessionInitRsp13793     pub fn build(self) -> SessionInitRsp {
13794         let sessioninitrsp = SessionInitRspData {
13795             status: self.status,
13796         };
13797         let sessionconfigresponse = SessionConfigResponseData {
13798             child: SessionConfigResponseDataChild::SessionInitRsp(sessioninitrsp),
13799         };
13800         let uciresponse = UciResponseData {
13801             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
13802         };
13803         let ucicontrolpacket = UciControlPacketData {
13804             group_id: GroupId::SessionConfig,
13805             message_type: MessageType::Response,
13806             opcode: 0,
13807             child: UciControlPacketDataChild::UciResponse(uciresponse),
13808         };
13809         SessionInitRsp::new(ucicontrolpacket).unwrap()
13810     }
13811 }
13812 impl From<SessionInitRspBuilder> for UciControlPacket {
from(builder: SessionInitRspBuilder) -> UciControlPacket13813     fn from(builder: SessionInitRspBuilder) -> UciControlPacket {
13814         builder.build().into()
13815     }
13816 }
13817 impl From<SessionInitRspBuilder> for UciResponse {
from(builder: SessionInitRspBuilder) -> UciResponse13818     fn from(builder: SessionInitRspBuilder) -> UciResponse {
13819         builder.build().into()
13820     }
13821 }
13822 impl From<SessionInitRspBuilder> for SessionConfigResponse {
from(builder: SessionInitRspBuilder) -> SessionConfigResponse13823     fn from(builder: SessionInitRspBuilder) -> SessionConfigResponse {
13824         builder.build().into()
13825     }
13826 }
13827 impl From<SessionInitRspBuilder> for SessionInitRsp {
from(builder: SessionInitRspBuilder) -> SessionInitRsp13828     fn from(builder: SessionInitRspBuilder) -> SessionInitRsp {
13829         builder.build().into()
13830     }
13831 }
13832 #[derive(Debug, Clone, PartialEq, Eq)]
13833 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13834 pub struct SessionDeinitCmdData {
13835     session_token: u32,
13836 }
13837 #[derive(Debug, Clone, PartialEq, Eq)]
13838 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13839 pub struct SessionDeinitCmd {
13840     #[cfg_attr(feature = "serde", serde(flatten))]
13841     ucicontrolpacket: UciControlPacketData,
13842     #[cfg_attr(feature = "serde", serde(flatten))]
13843     ucicommand: UciCommandData,
13844     #[cfg_attr(feature = "serde", serde(flatten))]
13845     sessionconfigcommand: SessionConfigCommandData,
13846     #[cfg_attr(feature = "serde", serde(flatten))]
13847     sessiondeinitcmd: SessionDeinitCmdData,
13848 }
13849 #[derive(Debug)]
13850 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
13851 pub struct SessionDeinitCmdBuilder {
13852     pub session_token: u32,
13853 }
13854 impl SessionDeinitCmdData {
conforms(bytes: &[u8]) -> bool13855     fn conforms(bytes: &[u8]) -> bool {
13856         bytes.len() >= 4
13857     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>13858     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
13859         let mut cell = Cell::new(bytes);
13860         let packet = Self::parse_inner(&mut cell)?;
13861         Ok(packet)
13862     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>13863     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
13864         if bytes.get().remaining() < 4 {
13865             return Err(DecodeError::InvalidLengthError {
13866                 obj: "SessionDeinitCmd",
13867                 wanted: 4,
13868                 got: bytes.get().remaining(),
13869             });
13870         }
13871         let session_token = bytes.get_mut().get_u32_le();
13872         Ok(Self { session_token })
13873     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>13874     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
13875         buffer.put_u32_le(self.session_token);
13876         Ok(())
13877     }
get_total_size(&self) -> usize13878     fn get_total_size(&self) -> usize {
13879         self.get_size()
13880     }
get_size(&self) -> usize13881     fn get_size(&self) -> usize {
13882         4
13883     }
13884 }
13885 impl Packet for SessionDeinitCmd {
encoded_len(&self) -> usize13886     fn encoded_len(&self) -> usize {
13887         self.get_size()
13888     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>13889     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
13890         self.ucicontrolpacket.write_to(buf)
13891     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>13892     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
13893         unimplemented!("Rust legacy does not implement full packet trait")
13894     }
13895 }
13896 impl TryFrom<SessionDeinitCmd> for Bytes {
13897     type Error = EncodeError;
try_from(packet: SessionDeinitCmd) -> Result<Self, Self::Error>13898     fn try_from(packet: SessionDeinitCmd) -> Result<Self, Self::Error> {
13899         packet.encode_to_bytes()
13900     }
13901 }
13902 impl TryFrom<SessionDeinitCmd> for Vec<u8> {
13903     type Error = EncodeError;
try_from(packet: SessionDeinitCmd) -> Result<Self, Self::Error>13904     fn try_from(packet: SessionDeinitCmd) -> Result<Self, Self::Error> {
13905         packet.encode_to_vec()
13906     }
13907 }
13908 impl From<SessionDeinitCmd> for UciControlPacket {
from(packet: SessionDeinitCmd) -> UciControlPacket13909     fn from(packet: SessionDeinitCmd) -> UciControlPacket {
13910         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
13911     }
13912 }
13913 impl From<SessionDeinitCmd> for UciCommand {
from(packet: SessionDeinitCmd) -> UciCommand13914     fn from(packet: SessionDeinitCmd) -> UciCommand {
13915         UciCommand::new(packet.ucicontrolpacket).unwrap()
13916     }
13917 }
13918 impl From<SessionDeinitCmd> for SessionConfigCommand {
from(packet: SessionDeinitCmd) -> SessionConfigCommand13919     fn from(packet: SessionDeinitCmd) -> SessionConfigCommand {
13920         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
13921     }
13922 }
13923 impl TryFrom<UciControlPacket> for SessionDeinitCmd {
13924     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionDeinitCmd, Self::Error>13925     fn try_from(packet: UciControlPacket) -> Result<SessionDeinitCmd, Self::Error> {
13926         SessionDeinitCmd::new(packet.ucicontrolpacket)
13927     }
13928 }
13929 impl SessionDeinitCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>13930     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
13931         let mut cell = Cell::new(bytes);
13932         let packet = Self::parse_inner(&mut cell)?;
13933         Ok(packet)
13934     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>13935     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
13936         let data = UciControlPacketData::parse_inner(&mut bytes)?;
13937         Self::new(data)
13938     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>13939     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
13940         let ucicommand = match &ucicontrolpacket.child {
13941             UciControlPacketDataChild::UciCommand(value) => value.clone(),
13942             _ => {
13943                 return Err(DecodeError::InvalidChildError {
13944                     expected: stringify!(UciControlPacketDataChild::UciCommand),
13945                     actual: format!("{:?}", & ucicontrolpacket.child),
13946                 });
13947             }
13948         };
13949         let sessionconfigcommand = match &ucicommand.child {
13950             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
13951             _ => {
13952                 return Err(DecodeError::InvalidChildError {
13953                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
13954                     actual: format!("{:?}", & ucicommand.child),
13955                 });
13956             }
13957         };
13958         let sessiondeinitcmd = match &sessionconfigcommand.child {
13959             SessionConfigCommandDataChild::SessionDeinitCmd(value) => value.clone(),
13960             _ => {
13961                 return Err(DecodeError::InvalidChildError {
13962                     expected: stringify!(
13963                         SessionConfigCommandDataChild::SessionDeinitCmd
13964                     ),
13965                     actual: format!("{:?}", & sessionconfigcommand.child),
13966                 });
13967             }
13968         };
13969         Ok(Self {
13970             ucicontrolpacket,
13971             ucicommand,
13972             sessionconfigcommand,
13973             sessiondeinitcmd,
13974         })
13975     }
get_group_id(&self) -> GroupId13976     pub fn get_group_id(&self) -> GroupId {
13977         self.ucicontrolpacket.group_id
13978     }
get_message_type(&self) -> MessageType13979     pub fn get_message_type(&self) -> MessageType {
13980         self.ucicontrolpacket.message_type
13981     }
get_opcode(&self) -> u813982     pub fn get_opcode(&self) -> u8 {
13983         self.ucicontrolpacket.opcode
13984     }
get_session_token(&self) -> u3213985     pub fn get_session_token(&self) -> u32 {
13986         self.sessiondeinitcmd.session_token
13987     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>13988     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
13989         self.sessiondeinitcmd.write_to(buffer)
13990     }
get_size(&self) -> usize13991     pub fn get_size(&self) -> usize {
13992         self.ucicontrolpacket.get_size()
13993     }
13994 }
13995 impl SessionDeinitCmdBuilder {
build(self) -> SessionDeinitCmd13996     pub fn build(self) -> SessionDeinitCmd {
13997         let sessiondeinitcmd = SessionDeinitCmdData {
13998             session_token: self.session_token,
13999         };
14000         let sessionconfigcommand = SessionConfigCommandData {
14001             child: SessionConfigCommandDataChild::SessionDeinitCmd(sessiondeinitcmd),
14002         };
14003         let ucicommand = UciCommandData {
14004             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
14005         };
14006         let ucicontrolpacket = UciControlPacketData {
14007             group_id: GroupId::SessionConfig,
14008             message_type: MessageType::Command,
14009             opcode: 1,
14010             child: UciControlPacketDataChild::UciCommand(ucicommand),
14011         };
14012         SessionDeinitCmd::new(ucicontrolpacket).unwrap()
14013     }
14014 }
14015 impl From<SessionDeinitCmdBuilder> for UciControlPacket {
from(builder: SessionDeinitCmdBuilder) -> UciControlPacket14016     fn from(builder: SessionDeinitCmdBuilder) -> UciControlPacket {
14017         builder.build().into()
14018     }
14019 }
14020 impl From<SessionDeinitCmdBuilder> for UciCommand {
from(builder: SessionDeinitCmdBuilder) -> UciCommand14021     fn from(builder: SessionDeinitCmdBuilder) -> UciCommand {
14022         builder.build().into()
14023     }
14024 }
14025 impl From<SessionDeinitCmdBuilder> for SessionConfigCommand {
from(builder: SessionDeinitCmdBuilder) -> SessionConfigCommand14026     fn from(builder: SessionDeinitCmdBuilder) -> SessionConfigCommand {
14027         builder.build().into()
14028     }
14029 }
14030 impl From<SessionDeinitCmdBuilder> for SessionDeinitCmd {
from(builder: SessionDeinitCmdBuilder) -> SessionDeinitCmd14031     fn from(builder: SessionDeinitCmdBuilder) -> SessionDeinitCmd {
14032         builder.build().into()
14033     }
14034 }
14035 #[derive(Debug, Clone, PartialEq, Eq)]
14036 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14037 pub struct SessionDeinitRspData {
14038     status: StatusCode,
14039 }
14040 #[derive(Debug, Clone, PartialEq, Eq)]
14041 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14042 pub struct SessionDeinitRsp {
14043     #[cfg_attr(feature = "serde", serde(flatten))]
14044     ucicontrolpacket: UciControlPacketData,
14045     #[cfg_attr(feature = "serde", serde(flatten))]
14046     uciresponse: UciResponseData,
14047     #[cfg_attr(feature = "serde", serde(flatten))]
14048     sessionconfigresponse: SessionConfigResponseData,
14049     #[cfg_attr(feature = "serde", serde(flatten))]
14050     sessiondeinitrsp: SessionDeinitRspData,
14051 }
14052 #[derive(Debug)]
14053 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14054 pub struct SessionDeinitRspBuilder {
14055     pub status: StatusCode,
14056 }
14057 impl SessionDeinitRspData {
conforms(bytes: &[u8]) -> bool14058     fn conforms(bytes: &[u8]) -> bool {
14059         bytes.len() >= 1
14060     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>14061     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
14062         let mut cell = Cell::new(bytes);
14063         let packet = Self::parse_inner(&mut cell)?;
14064         Ok(packet)
14065     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>14066     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
14067         if bytes.get().remaining() < 1 {
14068             return Err(DecodeError::InvalidLengthError {
14069                 obj: "SessionDeinitRsp",
14070                 wanted: 1,
14071                 got: bytes.get().remaining(),
14072             });
14073         }
14074         let status = StatusCode::try_from(bytes.get_mut().get_u8())
14075             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
14076                 obj: "SessionDeinitRsp",
14077                 field: "status",
14078                 value: unknown_val as u64,
14079                 type_: "StatusCode",
14080             })?;
14081         Ok(Self { status })
14082     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>14083     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
14084         buffer.put_u8(u8::from(self.status));
14085         Ok(())
14086     }
get_total_size(&self) -> usize14087     fn get_total_size(&self) -> usize {
14088         self.get_size()
14089     }
get_size(&self) -> usize14090     fn get_size(&self) -> usize {
14091         1
14092     }
14093 }
14094 impl Packet for SessionDeinitRsp {
encoded_len(&self) -> usize14095     fn encoded_len(&self) -> usize {
14096         self.get_size()
14097     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>14098     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
14099         self.ucicontrolpacket.write_to(buf)
14100     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>14101     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
14102         unimplemented!("Rust legacy does not implement full packet trait")
14103     }
14104 }
14105 impl TryFrom<SessionDeinitRsp> for Bytes {
14106     type Error = EncodeError;
try_from(packet: SessionDeinitRsp) -> Result<Self, Self::Error>14107     fn try_from(packet: SessionDeinitRsp) -> Result<Self, Self::Error> {
14108         packet.encode_to_bytes()
14109     }
14110 }
14111 impl TryFrom<SessionDeinitRsp> for Vec<u8> {
14112     type Error = EncodeError;
try_from(packet: SessionDeinitRsp) -> Result<Self, Self::Error>14113     fn try_from(packet: SessionDeinitRsp) -> Result<Self, Self::Error> {
14114         packet.encode_to_vec()
14115     }
14116 }
14117 impl From<SessionDeinitRsp> for UciControlPacket {
from(packet: SessionDeinitRsp) -> UciControlPacket14118     fn from(packet: SessionDeinitRsp) -> UciControlPacket {
14119         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
14120     }
14121 }
14122 impl From<SessionDeinitRsp> for UciResponse {
from(packet: SessionDeinitRsp) -> UciResponse14123     fn from(packet: SessionDeinitRsp) -> UciResponse {
14124         UciResponse::new(packet.ucicontrolpacket).unwrap()
14125     }
14126 }
14127 impl From<SessionDeinitRsp> for SessionConfigResponse {
from(packet: SessionDeinitRsp) -> SessionConfigResponse14128     fn from(packet: SessionDeinitRsp) -> SessionConfigResponse {
14129         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
14130     }
14131 }
14132 impl TryFrom<UciControlPacket> for SessionDeinitRsp {
14133     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionDeinitRsp, Self::Error>14134     fn try_from(packet: UciControlPacket) -> Result<SessionDeinitRsp, Self::Error> {
14135         SessionDeinitRsp::new(packet.ucicontrolpacket)
14136     }
14137 }
14138 impl SessionDeinitRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>14139     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
14140         let mut cell = Cell::new(bytes);
14141         let packet = Self::parse_inner(&mut cell)?;
14142         Ok(packet)
14143     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>14144     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
14145         let data = UciControlPacketData::parse_inner(&mut bytes)?;
14146         Self::new(data)
14147     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>14148     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
14149         let uciresponse = match &ucicontrolpacket.child {
14150             UciControlPacketDataChild::UciResponse(value) => value.clone(),
14151             _ => {
14152                 return Err(DecodeError::InvalidChildError {
14153                     expected: stringify!(UciControlPacketDataChild::UciResponse),
14154                     actual: format!("{:?}", & ucicontrolpacket.child),
14155                 });
14156             }
14157         };
14158         let sessionconfigresponse = match &uciresponse.child {
14159             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
14160             _ => {
14161                 return Err(DecodeError::InvalidChildError {
14162                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
14163                     actual: format!("{:?}", & uciresponse.child),
14164                 });
14165             }
14166         };
14167         let sessiondeinitrsp = match &sessionconfigresponse.child {
14168             SessionConfigResponseDataChild::SessionDeinitRsp(value) => value.clone(),
14169             _ => {
14170                 return Err(DecodeError::InvalidChildError {
14171                     expected: stringify!(
14172                         SessionConfigResponseDataChild::SessionDeinitRsp
14173                     ),
14174                     actual: format!("{:?}", & sessionconfigresponse.child),
14175                 });
14176             }
14177         };
14178         Ok(Self {
14179             ucicontrolpacket,
14180             uciresponse,
14181             sessionconfigresponse,
14182             sessiondeinitrsp,
14183         })
14184     }
get_group_id(&self) -> GroupId14185     pub fn get_group_id(&self) -> GroupId {
14186         self.ucicontrolpacket.group_id
14187     }
get_message_type(&self) -> MessageType14188     pub fn get_message_type(&self) -> MessageType {
14189         self.ucicontrolpacket.message_type
14190     }
get_opcode(&self) -> u814191     pub fn get_opcode(&self) -> u8 {
14192         self.ucicontrolpacket.opcode
14193     }
get_status(&self) -> StatusCode14194     pub fn get_status(&self) -> StatusCode {
14195         self.sessiondeinitrsp.status
14196     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>14197     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
14198         self.sessiondeinitrsp.write_to(buffer)
14199     }
get_size(&self) -> usize14200     pub fn get_size(&self) -> usize {
14201         self.ucicontrolpacket.get_size()
14202     }
14203 }
14204 impl SessionDeinitRspBuilder {
build(self) -> SessionDeinitRsp14205     pub fn build(self) -> SessionDeinitRsp {
14206         let sessiondeinitrsp = SessionDeinitRspData {
14207             status: self.status,
14208         };
14209         let sessionconfigresponse = SessionConfigResponseData {
14210             child: SessionConfigResponseDataChild::SessionDeinitRsp(sessiondeinitrsp),
14211         };
14212         let uciresponse = UciResponseData {
14213             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
14214         };
14215         let ucicontrolpacket = UciControlPacketData {
14216             group_id: GroupId::SessionConfig,
14217             message_type: MessageType::Response,
14218             opcode: 1,
14219             child: UciControlPacketDataChild::UciResponse(uciresponse),
14220         };
14221         SessionDeinitRsp::new(ucicontrolpacket).unwrap()
14222     }
14223 }
14224 impl From<SessionDeinitRspBuilder> for UciControlPacket {
from(builder: SessionDeinitRspBuilder) -> UciControlPacket14225     fn from(builder: SessionDeinitRspBuilder) -> UciControlPacket {
14226         builder.build().into()
14227     }
14228 }
14229 impl From<SessionDeinitRspBuilder> for UciResponse {
from(builder: SessionDeinitRspBuilder) -> UciResponse14230     fn from(builder: SessionDeinitRspBuilder) -> UciResponse {
14231         builder.build().into()
14232     }
14233 }
14234 impl From<SessionDeinitRspBuilder> for SessionConfigResponse {
from(builder: SessionDeinitRspBuilder) -> SessionConfigResponse14235     fn from(builder: SessionDeinitRspBuilder) -> SessionConfigResponse {
14236         builder.build().into()
14237     }
14238 }
14239 impl From<SessionDeinitRspBuilder> for SessionDeinitRsp {
from(builder: SessionDeinitRspBuilder) -> SessionDeinitRsp14240     fn from(builder: SessionDeinitRspBuilder) -> SessionDeinitRsp {
14241         builder.build().into()
14242     }
14243 }
14244 #[derive(Debug, Clone, PartialEq, Eq)]
14245 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14246 pub struct SessionStatusNtfData {
14247     session_token: u32,
14248     session_state: SessionState,
14249     reason_code: u8,
14250 }
14251 #[derive(Debug, Clone, PartialEq, Eq)]
14252 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14253 pub struct SessionStatusNtf {
14254     #[cfg_attr(feature = "serde", serde(flatten))]
14255     ucicontrolpacket: UciControlPacketData,
14256     #[cfg_attr(feature = "serde", serde(flatten))]
14257     ucinotification: UciNotificationData,
14258     #[cfg_attr(feature = "serde", serde(flatten))]
14259     sessionconfignotification: SessionConfigNotificationData,
14260     #[cfg_attr(feature = "serde", serde(flatten))]
14261     sessionstatusntf: SessionStatusNtfData,
14262 }
14263 #[derive(Debug)]
14264 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14265 pub struct SessionStatusNtfBuilder {
14266     pub reason_code: u8,
14267     pub session_state: SessionState,
14268     pub session_token: u32,
14269 }
14270 impl SessionStatusNtfData {
conforms(bytes: &[u8]) -> bool14271     fn conforms(bytes: &[u8]) -> bool {
14272         bytes.len() >= 6
14273     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>14274     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
14275         let mut cell = Cell::new(bytes);
14276         let packet = Self::parse_inner(&mut cell)?;
14277         Ok(packet)
14278     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>14279     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
14280         if bytes.get().remaining() < 4 {
14281             return Err(DecodeError::InvalidLengthError {
14282                 obj: "SessionStatusNtf",
14283                 wanted: 4,
14284                 got: bytes.get().remaining(),
14285             });
14286         }
14287         let session_token = bytes.get_mut().get_u32_le();
14288         if bytes.get().remaining() < 1 {
14289             return Err(DecodeError::InvalidLengthError {
14290                 obj: "SessionStatusNtf",
14291                 wanted: 1,
14292                 got: bytes.get().remaining(),
14293             });
14294         }
14295         let session_state = SessionState::try_from(bytes.get_mut().get_u8())
14296             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
14297                 obj: "SessionStatusNtf",
14298                 field: "session_state",
14299                 value: unknown_val as u64,
14300                 type_: "SessionState",
14301             })?;
14302         if bytes.get().remaining() < 1 {
14303             return Err(DecodeError::InvalidLengthError {
14304                 obj: "SessionStatusNtf",
14305                 wanted: 1,
14306                 got: bytes.get().remaining(),
14307             });
14308         }
14309         let reason_code = bytes.get_mut().get_u8();
14310         Ok(Self {
14311             session_token,
14312             session_state,
14313             reason_code,
14314         })
14315     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>14316     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
14317         buffer.put_u32_le(self.session_token);
14318         buffer.put_u8(u8::from(self.session_state));
14319         buffer.put_u8(self.reason_code);
14320         Ok(())
14321     }
get_total_size(&self) -> usize14322     fn get_total_size(&self) -> usize {
14323         self.get_size()
14324     }
get_size(&self) -> usize14325     fn get_size(&self) -> usize {
14326         6
14327     }
14328 }
14329 impl Packet for SessionStatusNtf {
encoded_len(&self) -> usize14330     fn encoded_len(&self) -> usize {
14331         self.get_size()
14332     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>14333     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
14334         self.ucicontrolpacket.write_to(buf)
14335     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>14336     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
14337         unimplemented!("Rust legacy does not implement full packet trait")
14338     }
14339 }
14340 impl TryFrom<SessionStatusNtf> for Bytes {
14341     type Error = EncodeError;
try_from(packet: SessionStatusNtf) -> Result<Self, Self::Error>14342     fn try_from(packet: SessionStatusNtf) -> Result<Self, Self::Error> {
14343         packet.encode_to_bytes()
14344     }
14345 }
14346 impl TryFrom<SessionStatusNtf> for Vec<u8> {
14347     type Error = EncodeError;
try_from(packet: SessionStatusNtf) -> Result<Self, Self::Error>14348     fn try_from(packet: SessionStatusNtf) -> Result<Self, Self::Error> {
14349         packet.encode_to_vec()
14350     }
14351 }
14352 impl From<SessionStatusNtf> for UciControlPacket {
from(packet: SessionStatusNtf) -> UciControlPacket14353     fn from(packet: SessionStatusNtf) -> UciControlPacket {
14354         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
14355     }
14356 }
14357 impl From<SessionStatusNtf> for UciNotification {
from(packet: SessionStatusNtf) -> UciNotification14358     fn from(packet: SessionStatusNtf) -> UciNotification {
14359         UciNotification::new(packet.ucicontrolpacket).unwrap()
14360     }
14361 }
14362 impl From<SessionStatusNtf> for SessionConfigNotification {
from(packet: SessionStatusNtf) -> SessionConfigNotification14363     fn from(packet: SessionStatusNtf) -> SessionConfigNotification {
14364         SessionConfigNotification::new(packet.ucicontrolpacket).unwrap()
14365     }
14366 }
14367 impl TryFrom<UciControlPacket> for SessionStatusNtf {
14368     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionStatusNtf, Self::Error>14369     fn try_from(packet: UciControlPacket) -> Result<SessionStatusNtf, Self::Error> {
14370         SessionStatusNtf::new(packet.ucicontrolpacket)
14371     }
14372 }
14373 impl SessionStatusNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>14374     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
14375         let mut cell = Cell::new(bytes);
14376         let packet = Self::parse_inner(&mut cell)?;
14377         Ok(packet)
14378     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>14379     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
14380         let data = UciControlPacketData::parse_inner(&mut bytes)?;
14381         Self::new(data)
14382     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>14383     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
14384         let ucinotification = match &ucicontrolpacket.child {
14385             UciControlPacketDataChild::UciNotification(value) => value.clone(),
14386             _ => {
14387                 return Err(DecodeError::InvalidChildError {
14388                     expected: stringify!(UciControlPacketDataChild::UciNotification),
14389                     actual: format!("{:?}", & ucicontrolpacket.child),
14390                 });
14391             }
14392         };
14393         let sessionconfignotification = match &ucinotification.child {
14394             UciNotificationDataChild::SessionConfigNotification(value) => value.clone(),
14395             _ => {
14396                 return Err(DecodeError::InvalidChildError {
14397                     expected: stringify!(
14398                         UciNotificationDataChild::SessionConfigNotification
14399                     ),
14400                     actual: format!("{:?}", & ucinotification.child),
14401                 });
14402             }
14403         };
14404         let sessionstatusntf = match &sessionconfignotification.child {
14405             SessionConfigNotificationDataChild::SessionStatusNtf(value) => value.clone(),
14406             _ => {
14407                 return Err(DecodeError::InvalidChildError {
14408                     expected: stringify!(
14409                         SessionConfigNotificationDataChild::SessionStatusNtf
14410                     ),
14411                     actual: format!("{:?}", & sessionconfignotification.child),
14412                 });
14413             }
14414         };
14415         Ok(Self {
14416             ucicontrolpacket,
14417             ucinotification,
14418             sessionconfignotification,
14419             sessionstatusntf,
14420         })
14421     }
get_group_id(&self) -> GroupId14422     pub fn get_group_id(&self) -> GroupId {
14423         self.ucicontrolpacket.group_id
14424     }
get_message_type(&self) -> MessageType14425     pub fn get_message_type(&self) -> MessageType {
14426         self.ucicontrolpacket.message_type
14427     }
get_opcode(&self) -> u814428     pub fn get_opcode(&self) -> u8 {
14429         self.ucicontrolpacket.opcode
14430     }
get_reason_code(&self) -> u814431     pub fn get_reason_code(&self) -> u8 {
14432         self.sessionstatusntf.reason_code
14433     }
get_session_state(&self) -> SessionState14434     pub fn get_session_state(&self) -> SessionState {
14435         self.sessionstatusntf.session_state
14436     }
get_session_token(&self) -> u3214437     pub fn get_session_token(&self) -> u32 {
14438         self.sessionstatusntf.session_token
14439     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>14440     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
14441         self.sessionstatusntf.write_to(buffer)
14442     }
get_size(&self) -> usize14443     pub fn get_size(&self) -> usize {
14444         self.ucicontrolpacket.get_size()
14445     }
14446 }
14447 impl SessionStatusNtfBuilder {
build(self) -> SessionStatusNtf14448     pub fn build(self) -> SessionStatusNtf {
14449         let sessionstatusntf = SessionStatusNtfData {
14450             reason_code: self.reason_code,
14451             session_state: self.session_state,
14452             session_token: self.session_token,
14453         };
14454         let sessionconfignotification = SessionConfigNotificationData {
14455             child: SessionConfigNotificationDataChild::SessionStatusNtf(sessionstatusntf),
14456         };
14457         let ucinotification = UciNotificationData {
14458             child: UciNotificationDataChild::SessionConfigNotification(
14459                 sessionconfignotification,
14460             ),
14461         };
14462         let ucicontrolpacket = UciControlPacketData {
14463             group_id: GroupId::SessionConfig,
14464             message_type: MessageType::Notification,
14465             opcode: 2,
14466             child: UciControlPacketDataChild::UciNotification(ucinotification),
14467         };
14468         SessionStatusNtf::new(ucicontrolpacket).unwrap()
14469     }
14470 }
14471 impl From<SessionStatusNtfBuilder> for UciControlPacket {
from(builder: SessionStatusNtfBuilder) -> UciControlPacket14472     fn from(builder: SessionStatusNtfBuilder) -> UciControlPacket {
14473         builder.build().into()
14474     }
14475 }
14476 impl From<SessionStatusNtfBuilder> for UciNotification {
from(builder: SessionStatusNtfBuilder) -> UciNotification14477     fn from(builder: SessionStatusNtfBuilder) -> UciNotification {
14478         builder.build().into()
14479     }
14480 }
14481 impl From<SessionStatusNtfBuilder> for SessionConfigNotification {
from(builder: SessionStatusNtfBuilder) -> SessionConfigNotification14482     fn from(builder: SessionStatusNtfBuilder) -> SessionConfigNotification {
14483         builder.build().into()
14484     }
14485 }
14486 impl From<SessionStatusNtfBuilder> for SessionStatusNtf {
from(builder: SessionStatusNtfBuilder) -> SessionStatusNtf14487     fn from(builder: SessionStatusNtfBuilder) -> SessionStatusNtf {
14488         builder.build().into()
14489     }
14490 }
14491 #[derive(Debug, Clone, PartialEq, Eq)]
14492 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14493 pub struct AppConfigTlv {
14494     pub cfg_id: AppConfigTlvType,
14495     pub v: Vec<u8>,
14496 }
14497 impl AppConfigTlv {
conforms(bytes: &[u8]) -> bool14498     fn conforms(bytes: &[u8]) -> bool {
14499         bytes.len() >= 2
14500     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>14501     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
14502         let mut cell = Cell::new(bytes);
14503         let packet = Self::parse_inner(&mut cell)?;
14504         Ok(packet)
14505     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>14506     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
14507         if bytes.get().remaining() < 1 {
14508             return Err(DecodeError::InvalidLengthError {
14509                 obj: "AppConfigTlv",
14510                 wanted: 1,
14511                 got: bytes.get().remaining(),
14512             });
14513         }
14514         let cfg_id = AppConfigTlvType::try_from(bytes.get_mut().get_u8())
14515             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
14516                 obj: "AppConfigTlv",
14517                 field: "cfg_id",
14518                 value: unknown_val as u64,
14519                 type_: "AppConfigTlvType",
14520             })?;
14521         if bytes.get().remaining() < 1 {
14522             return Err(DecodeError::InvalidLengthError {
14523                 obj: "AppConfigTlv",
14524                 wanted: 1,
14525                 got: bytes.get().remaining(),
14526             });
14527         }
14528         let v_count = bytes.get_mut().get_u8() as usize;
14529         if bytes.get().remaining() < v_count * 1usize {
14530             return Err(DecodeError::InvalidLengthError {
14531                 obj: "AppConfigTlv",
14532                 wanted: v_count * 1usize,
14533                 got: bytes.get().remaining(),
14534             });
14535         }
14536         let v = (0..v_count)
14537             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
14538             .collect::<Result<Vec<_>, DecodeError>>()?;
14539         Ok(Self { cfg_id, v })
14540     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>14541     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
14542         buffer.put_u8(u8::from(self.cfg_id));
14543         buffer.put_u8(self.v.len() as u8);
14544         for elem in &self.v {
14545             buffer.put_u8(*elem);
14546         }
14547         Ok(())
14548     }
get_total_size(&self) -> usize14549     fn get_total_size(&self) -> usize {
14550         self.get_size()
14551     }
get_size(&self) -> usize14552     fn get_size(&self) -> usize {
14553         2 + self.v.len()
14554     }
14555 }
14556 #[derive(Debug, Clone, PartialEq, Eq)]
14557 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14558 pub struct SessionSetAppConfigCmdData {
14559     session_token: u32,
14560     tlvs: Vec<AppConfigTlv>,
14561 }
14562 #[derive(Debug, Clone, PartialEq, Eq)]
14563 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14564 pub struct SessionSetAppConfigCmd {
14565     #[cfg_attr(feature = "serde", serde(flatten))]
14566     ucicontrolpacket: UciControlPacketData,
14567     #[cfg_attr(feature = "serde", serde(flatten))]
14568     ucicommand: UciCommandData,
14569     #[cfg_attr(feature = "serde", serde(flatten))]
14570     sessionconfigcommand: SessionConfigCommandData,
14571     #[cfg_attr(feature = "serde", serde(flatten))]
14572     sessionsetappconfigcmd: SessionSetAppConfigCmdData,
14573 }
14574 #[derive(Debug)]
14575 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14576 pub struct SessionSetAppConfigCmdBuilder {
14577     pub session_token: u32,
14578     pub tlvs: Vec<AppConfigTlv>,
14579 }
14580 impl SessionSetAppConfigCmdData {
conforms(bytes: &[u8]) -> bool14581     fn conforms(bytes: &[u8]) -> bool {
14582         bytes.len() >= 5
14583     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>14584     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
14585         let mut cell = Cell::new(bytes);
14586         let packet = Self::parse_inner(&mut cell)?;
14587         Ok(packet)
14588     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>14589     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
14590         if bytes.get().remaining() < 4 {
14591             return Err(DecodeError::InvalidLengthError {
14592                 obj: "SessionSetAppConfigCmd",
14593                 wanted: 4,
14594                 got: bytes.get().remaining(),
14595             });
14596         }
14597         let session_token = bytes.get_mut().get_u32_le();
14598         if bytes.get().remaining() < 1 {
14599             return Err(DecodeError::InvalidLengthError {
14600                 obj: "SessionSetAppConfigCmd",
14601                 wanted: 1,
14602                 got: bytes.get().remaining(),
14603             });
14604         }
14605         let tlvs_count = bytes.get_mut().get_u8() as usize;
14606         let tlvs = (0..tlvs_count)
14607             .map(|_| AppConfigTlv::parse_inner(bytes))
14608             .collect::<Result<Vec<_>, DecodeError>>()?;
14609         Ok(Self { session_token, tlvs })
14610     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>14611     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
14612         buffer.put_u32_le(self.session_token);
14613         buffer.put_u8(self.tlvs.len() as u8);
14614         for elem in &self.tlvs {
14615             elem.write_to(buffer)?;
14616         }
14617         Ok(())
14618     }
get_total_size(&self) -> usize14619     fn get_total_size(&self) -> usize {
14620         self.get_size()
14621     }
get_size(&self) -> usize14622     fn get_size(&self) -> usize {
14623         5 + self.tlvs.iter().map(|elem| elem.get_size()).sum::<usize>()
14624     }
14625 }
14626 impl Packet for SessionSetAppConfigCmd {
encoded_len(&self) -> usize14627     fn encoded_len(&self) -> usize {
14628         self.get_size()
14629     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>14630     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
14631         self.ucicontrolpacket.write_to(buf)
14632     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>14633     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
14634         unimplemented!("Rust legacy does not implement full packet trait")
14635     }
14636 }
14637 impl TryFrom<SessionSetAppConfigCmd> for Bytes {
14638     type Error = EncodeError;
try_from(packet: SessionSetAppConfigCmd) -> Result<Self, Self::Error>14639     fn try_from(packet: SessionSetAppConfigCmd) -> Result<Self, Self::Error> {
14640         packet.encode_to_bytes()
14641     }
14642 }
14643 impl TryFrom<SessionSetAppConfigCmd> for Vec<u8> {
14644     type Error = EncodeError;
try_from(packet: SessionSetAppConfigCmd) -> Result<Self, Self::Error>14645     fn try_from(packet: SessionSetAppConfigCmd) -> Result<Self, Self::Error> {
14646         packet.encode_to_vec()
14647     }
14648 }
14649 impl From<SessionSetAppConfigCmd> for UciControlPacket {
from(packet: SessionSetAppConfigCmd) -> UciControlPacket14650     fn from(packet: SessionSetAppConfigCmd) -> UciControlPacket {
14651         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
14652     }
14653 }
14654 impl From<SessionSetAppConfigCmd> for UciCommand {
from(packet: SessionSetAppConfigCmd) -> UciCommand14655     fn from(packet: SessionSetAppConfigCmd) -> UciCommand {
14656         UciCommand::new(packet.ucicontrolpacket).unwrap()
14657     }
14658 }
14659 impl From<SessionSetAppConfigCmd> for SessionConfigCommand {
from(packet: SessionSetAppConfigCmd) -> SessionConfigCommand14660     fn from(packet: SessionSetAppConfigCmd) -> SessionConfigCommand {
14661         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
14662     }
14663 }
14664 impl TryFrom<UciControlPacket> for SessionSetAppConfigCmd {
14665     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionSetAppConfigCmd, Self::Error>14666     fn try_from(
14667         packet: UciControlPacket,
14668     ) -> Result<SessionSetAppConfigCmd, Self::Error> {
14669         SessionSetAppConfigCmd::new(packet.ucicontrolpacket)
14670     }
14671 }
14672 impl SessionSetAppConfigCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>14673     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
14674         let mut cell = Cell::new(bytes);
14675         let packet = Self::parse_inner(&mut cell)?;
14676         Ok(packet)
14677     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>14678     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
14679         let data = UciControlPacketData::parse_inner(&mut bytes)?;
14680         Self::new(data)
14681     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>14682     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
14683         let ucicommand = match &ucicontrolpacket.child {
14684             UciControlPacketDataChild::UciCommand(value) => value.clone(),
14685             _ => {
14686                 return Err(DecodeError::InvalidChildError {
14687                     expected: stringify!(UciControlPacketDataChild::UciCommand),
14688                     actual: format!("{:?}", & ucicontrolpacket.child),
14689                 });
14690             }
14691         };
14692         let sessionconfigcommand = match &ucicommand.child {
14693             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
14694             _ => {
14695                 return Err(DecodeError::InvalidChildError {
14696                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
14697                     actual: format!("{:?}", & ucicommand.child),
14698                 });
14699             }
14700         };
14701         let sessionsetappconfigcmd = match &sessionconfigcommand.child {
14702             SessionConfigCommandDataChild::SessionSetAppConfigCmd(value) => value.clone(),
14703             _ => {
14704                 return Err(DecodeError::InvalidChildError {
14705                     expected: stringify!(
14706                         SessionConfigCommandDataChild::SessionSetAppConfigCmd
14707                     ),
14708                     actual: format!("{:?}", & sessionconfigcommand.child),
14709                 });
14710             }
14711         };
14712         Ok(Self {
14713             ucicontrolpacket,
14714             ucicommand,
14715             sessionconfigcommand,
14716             sessionsetappconfigcmd,
14717         })
14718     }
get_group_id(&self) -> GroupId14719     pub fn get_group_id(&self) -> GroupId {
14720         self.ucicontrolpacket.group_id
14721     }
get_message_type(&self) -> MessageType14722     pub fn get_message_type(&self) -> MessageType {
14723         self.ucicontrolpacket.message_type
14724     }
get_opcode(&self) -> u814725     pub fn get_opcode(&self) -> u8 {
14726         self.ucicontrolpacket.opcode
14727     }
get_session_token(&self) -> u3214728     pub fn get_session_token(&self) -> u32 {
14729         self.sessionsetappconfigcmd.session_token
14730     }
get_tlvs(&self) -> &Vec<AppConfigTlv>14731     pub fn get_tlvs(&self) -> &Vec<AppConfigTlv> {
14732         &self.sessionsetappconfigcmd.tlvs
14733     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>14734     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
14735         self.sessionsetappconfigcmd.write_to(buffer)
14736     }
get_size(&self) -> usize14737     pub fn get_size(&self) -> usize {
14738         self.ucicontrolpacket.get_size()
14739     }
14740 }
14741 impl SessionSetAppConfigCmdBuilder {
build(self) -> SessionSetAppConfigCmd14742     pub fn build(self) -> SessionSetAppConfigCmd {
14743         let sessionsetappconfigcmd = SessionSetAppConfigCmdData {
14744             session_token: self.session_token,
14745             tlvs: self.tlvs,
14746         };
14747         let sessionconfigcommand = SessionConfigCommandData {
14748             child: SessionConfigCommandDataChild::SessionSetAppConfigCmd(
14749                 sessionsetappconfigcmd,
14750             ),
14751         };
14752         let ucicommand = UciCommandData {
14753             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
14754         };
14755         let ucicontrolpacket = UciControlPacketData {
14756             group_id: GroupId::SessionConfig,
14757             message_type: MessageType::Command,
14758             opcode: 3,
14759             child: UciControlPacketDataChild::UciCommand(ucicommand),
14760         };
14761         SessionSetAppConfigCmd::new(ucicontrolpacket).unwrap()
14762     }
14763 }
14764 impl From<SessionSetAppConfigCmdBuilder> for UciControlPacket {
from(builder: SessionSetAppConfigCmdBuilder) -> UciControlPacket14765     fn from(builder: SessionSetAppConfigCmdBuilder) -> UciControlPacket {
14766         builder.build().into()
14767     }
14768 }
14769 impl From<SessionSetAppConfigCmdBuilder> for UciCommand {
from(builder: SessionSetAppConfigCmdBuilder) -> UciCommand14770     fn from(builder: SessionSetAppConfigCmdBuilder) -> UciCommand {
14771         builder.build().into()
14772     }
14773 }
14774 impl From<SessionSetAppConfigCmdBuilder> for SessionConfigCommand {
from(builder: SessionSetAppConfigCmdBuilder) -> SessionConfigCommand14775     fn from(builder: SessionSetAppConfigCmdBuilder) -> SessionConfigCommand {
14776         builder.build().into()
14777     }
14778 }
14779 impl From<SessionSetAppConfigCmdBuilder> for SessionSetAppConfigCmd {
from(builder: SessionSetAppConfigCmdBuilder) -> SessionSetAppConfigCmd14780     fn from(builder: SessionSetAppConfigCmdBuilder) -> SessionSetAppConfigCmd {
14781         builder.build().into()
14782     }
14783 }
14784 #[derive(Debug, Clone, PartialEq, Eq)]
14785 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14786 pub struct AppConfigStatus {
14787     pub cfg_id: AppConfigTlvType,
14788     pub status: StatusCode,
14789 }
14790 impl AppConfigStatus {
conforms(bytes: &[u8]) -> bool14791     fn conforms(bytes: &[u8]) -> bool {
14792         bytes.len() >= 2
14793     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>14794     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
14795         let mut cell = Cell::new(bytes);
14796         let packet = Self::parse_inner(&mut cell)?;
14797         Ok(packet)
14798     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>14799     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
14800         if bytes.get().remaining() < 1 {
14801             return Err(DecodeError::InvalidLengthError {
14802                 obj: "AppConfigStatus",
14803                 wanted: 1,
14804                 got: bytes.get().remaining(),
14805             });
14806         }
14807         let cfg_id = AppConfigTlvType::try_from(bytes.get_mut().get_u8())
14808             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
14809                 obj: "AppConfigStatus",
14810                 field: "cfg_id",
14811                 value: unknown_val as u64,
14812                 type_: "AppConfigTlvType",
14813             })?;
14814         if bytes.get().remaining() < 1 {
14815             return Err(DecodeError::InvalidLengthError {
14816                 obj: "AppConfigStatus",
14817                 wanted: 1,
14818                 got: bytes.get().remaining(),
14819             });
14820         }
14821         let status = StatusCode::try_from(bytes.get_mut().get_u8())
14822             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
14823                 obj: "AppConfigStatus",
14824                 field: "status",
14825                 value: unknown_val as u64,
14826                 type_: "StatusCode",
14827             })?;
14828         Ok(Self { cfg_id, status })
14829     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>14830     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
14831         buffer.put_u8(u8::from(self.cfg_id));
14832         buffer.put_u8(u8::from(self.status));
14833         Ok(())
14834     }
get_total_size(&self) -> usize14835     fn get_total_size(&self) -> usize {
14836         self.get_size()
14837     }
get_size(&self) -> usize14838     fn get_size(&self) -> usize {
14839         2
14840     }
14841 }
14842 #[derive(Debug, Clone, PartialEq, Eq)]
14843 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14844 pub struct SessionSetAppConfigRspData {
14845     status: StatusCode,
14846     cfg_status: Vec<AppConfigStatus>,
14847 }
14848 #[derive(Debug, Clone, PartialEq, Eq)]
14849 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14850 pub struct SessionSetAppConfigRsp {
14851     #[cfg_attr(feature = "serde", serde(flatten))]
14852     ucicontrolpacket: UciControlPacketData,
14853     #[cfg_attr(feature = "serde", serde(flatten))]
14854     uciresponse: UciResponseData,
14855     #[cfg_attr(feature = "serde", serde(flatten))]
14856     sessionconfigresponse: SessionConfigResponseData,
14857     #[cfg_attr(feature = "serde", serde(flatten))]
14858     sessionsetappconfigrsp: SessionSetAppConfigRspData,
14859 }
14860 #[derive(Debug)]
14861 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
14862 pub struct SessionSetAppConfigRspBuilder {
14863     pub cfg_status: Vec<AppConfigStatus>,
14864     pub status: StatusCode,
14865 }
14866 impl SessionSetAppConfigRspData {
conforms(bytes: &[u8]) -> bool14867     fn conforms(bytes: &[u8]) -> bool {
14868         bytes.len() >= 2
14869     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>14870     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
14871         let mut cell = Cell::new(bytes);
14872         let packet = Self::parse_inner(&mut cell)?;
14873         Ok(packet)
14874     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>14875     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
14876         if bytes.get().remaining() < 1 {
14877             return Err(DecodeError::InvalidLengthError {
14878                 obj: "SessionSetAppConfigRsp",
14879                 wanted: 1,
14880                 got: bytes.get().remaining(),
14881             });
14882         }
14883         let status = StatusCode::try_from(bytes.get_mut().get_u8())
14884             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
14885                 obj: "SessionSetAppConfigRsp",
14886                 field: "status",
14887                 value: unknown_val as u64,
14888                 type_: "StatusCode",
14889             })?;
14890         if bytes.get().remaining() < 1 {
14891             return Err(DecodeError::InvalidLengthError {
14892                 obj: "SessionSetAppConfigRsp",
14893                 wanted: 1,
14894                 got: bytes.get().remaining(),
14895             });
14896         }
14897         let cfg_status_count = bytes.get_mut().get_u8() as usize;
14898         if bytes.get().remaining() < cfg_status_count * 2usize {
14899             return Err(DecodeError::InvalidLengthError {
14900                 obj: "SessionSetAppConfigRsp",
14901                 wanted: cfg_status_count * 2usize,
14902                 got: bytes.get().remaining(),
14903             });
14904         }
14905         let cfg_status = (0..cfg_status_count)
14906             .map(|_| AppConfigStatus::parse_inner(bytes))
14907             .collect::<Result<Vec<_>, DecodeError>>()?;
14908         Ok(Self { status, cfg_status })
14909     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>14910     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
14911         buffer.put_u8(u8::from(self.status));
14912         buffer.put_u8(self.cfg_status.len() as u8);
14913         for elem in &self.cfg_status {
14914             elem.write_to(buffer)?;
14915         }
14916         Ok(())
14917     }
get_total_size(&self) -> usize14918     fn get_total_size(&self) -> usize {
14919         self.get_size()
14920     }
get_size(&self) -> usize14921     fn get_size(&self) -> usize {
14922         2 + self.cfg_status.iter().map(|elem| elem.get_size()).sum::<usize>()
14923     }
14924 }
14925 impl Packet for SessionSetAppConfigRsp {
encoded_len(&self) -> usize14926     fn encoded_len(&self) -> usize {
14927         self.get_size()
14928     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>14929     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
14930         self.ucicontrolpacket.write_to(buf)
14931     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>14932     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
14933         unimplemented!("Rust legacy does not implement full packet trait")
14934     }
14935 }
14936 impl TryFrom<SessionSetAppConfigRsp> for Bytes {
14937     type Error = EncodeError;
try_from(packet: SessionSetAppConfigRsp) -> Result<Self, Self::Error>14938     fn try_from(packet: SessionSetAppConfigRsp) -> Result<Self, Self::Error> {
14939         packet.encode_to_bytes()
14940     }
14941 }
14942 impl TryFrom<SessionSetAppConfigRsp> for Vec<u8> {
14943     type Error = EncodeError;
try_from(packet: SessionSetAppConfigRsp) -> Result<Self, Self::Error>14944     fn try_from(packet: SessionSetAppConfigRsp) -> Result<Self, Self::Error> {
14945         packet.encode_to_vec()
14946     }
14947 }
14948 impl From<SessionSetAppConfigRsp> for UciControlPacket {
from(packet: SessionSetAppConfigRsp) -> UciControlPacket14949     fn from(packet: SessionSetAppConfigRsp) -> UciControlPacket {
14950         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
14951     }
14952 }
14953 impl From<SessionSetAppConfigRsp> for UciResponse {
from(packet: SessionSetAppConfigRsp) -> UciResponse14954     fn from(packet: SessionSetAppConfigRsp) -> UciResponse {
14955         UciResponse::new(packet.ucicontrolpacket).unwrap()
14956     }
14957 }
14958 impl From<SessionSetAppConfigRsp> for SessionConfigResponse {
from(packet: SessionSetAppConfigRsp) -> SessionConfigResponse14959     fn from(packet: SessionSetAppConfigRsp) -> SessionConfigResponse {
14960         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
14961     }
14962 }
14963 impl TryFrom<UciControlPacket> for SessionSetAppConfigRsp {
14964     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionSetAppConfigRsp, Self::Error>14965     fn try_from(
14966         packet: UciControlPacket,
14967     ) -> Result<SessionSetAppConfigRsp, Self::Error> {
14968         SessionSetAppConfigRsp::new(packet.ucicontrolpacket)
14969     }
14970 }
14971 impl SessionSetAppConfigRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>14972     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
14973         let mut cell = Cell::new(bytes);
14974         let packet = Self::parse_inner(&mut cell)?;
14975         Ok(packet)
14976     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>14977     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
14978         let data = UciControlPacketData::parse_inner(&mut bytes)?;
14979         Self::new(data)
14980     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>14981     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
14982         let uciresponse = match &ucicontrolpacket.child {
14983             UciControlPacketDataChild::UciResponse(value) => value.clone(),
14984             _ => {
14985                 return Err(DecodeError::InvalidChildError {
14986                     expected: stringify!(UciControlPacketDataChild::UciResponse),
14987                     actual: format!("{:?}", & ucicontrolpacket.child),
14988                 });
14989             }
14990         };
14991         let sessionconfigresponse = match &uciresponse.child {
14992             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
14993             _ => {
14994                 return Err(DecodeError::InvalidChildError {
14995                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
14996                     actual: format!("{:?}", & uciresponse.child),
14997                 });
14998             }
14999         };
15000         let sessionsetappconfigrsp = match &sessionconfigresponse.child {
15001             SessionConfigResponseDataChild::SessionSetAppConfigRsp(value) => {
15002                 value.clone()
15003             }
15004             _ => {
15005                 return Err(DecodeError::InvalidChildError {
15006                     expected: stringify!(
15007                         SessionConfigResponseDataChild::SessionSetAppConfigRsp
15008                     ),
15009                     actual: format!("{:?}", & sessionconfigresponse.child),
15010                 });
15011             }
15012         };
15013         Ok(Self {
15014             ucicontrolpacket,
15015             uciresponse,
15016             sessionconfigresponse,
15017             sessionsetappconfigrsp,
15018         })
15019     }
get_cfg_status(&self) -> &Vec<AppConfigStatus>15020     pub fn get_cfg_status(&self) -> &Vec<AppConfigStatus> {
15021         &self.sessionsetappconfigrsp.cfg_status
15022     }
get_group_id(&self) -> GroupId15023     pub fn get_group_id(&self) -> GroupId {
15024         self.ucicontrolpacket.group_id
15025     }
get_message_type(&self) -> MessageType15026     pub fn get_message_type(&self) -> MessageType {
15027         self.ucicontrolpacket.message_type
15028     }
get_opcode(&self) -> u815029     pub fn get_opcode(&self) -> u8 {
15030         self.ucicontrolpacket.opcode
15031     }
get_status(&self) -> StatusCode15032     pub fn get_status(&self) -> StatusCode {
15033         self.sessionsetappconfigrsp.status
15034     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>15035     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
15036         self.sessionsetappconfigrsp.write_to(buffer)
15037     }
get_size(&self) -> usize15038     pub fn get_size(&self) -> usize {
15039         self.ucicontrolpacket.get_size()
15040     }
15041 }
15042 impl SessionSetAppConfigRspBuilder {
build(self) -> SessionSetAppConfigRsp15043     pub fn build(self) -> SessionSetAppConfigRsp {
15044         let sessionsetappconfigrsp = SessionSetAppConfigRspData {
15045             cfg_status: self.cfg_status,
15046             status: self.status,
15047         };
15048         let sessionconfigresponse = SessionConfigResponseData {
15049             child: SessionConfigResponseDataChild::SessionSetAppConfigRsp(
15050                 sessionsetappconfigrsp,
15051             ),
15052         };
15053         let uciresponse = UciResponseData {
15054             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
15055         };
15056         let ucicontrolpacket = UciControlPacketData {
15057             group_id: GroupId::SessionConfig,
15058             message_type: MessageType::Response,
15059             opcode: 3,
15060             child: UciControlPacketDataChild::UciResponse(uciresponse),
15061         };
15062         SessionSetAppConfigRsp::new(ucicontrolpacket).unwrap()
15063     }
15064 }
15065 impl From<SessionSetAppConfigRspBuilder> for UciControlPacket {
from(builder: SessionSetAppConfigRspBuilder) -> UciControlPacket15066     fn from(builder: SessionSetAppConfigRspBuilder) -> UciControlPacket {
15067         builder.build().into()
15068     }
15069 }
15070 impl From<SessionSetAppConfigRspBuilder> for UciResponse {
from(builder: SessionSetAppConfigRspBuilder) -> UciResponse15071     fn from(builder: SessionSetAppConfigRspBuilder) -> UciResponse {
15072         builder.build().into()
15073     }
15074 }
15075 impl From<SessionSetAppConfigRspBuilder> for SessionConfigResponse {
from(builder: SessionSetAppConfigRspBuilder) -> SessionConfigResponse15076     fn from(builder: SessionSetAppConfigRspBuilder) -> SessionConfigResponse {
15077         builder.build().into()
15078     }
15079 }
15080 impl From<SessionSetAppConfigRspBuilder> for SessionSetAppConfigRsp {
from(builder: SessionSetAppConfigRspBuilder) -> SessionSetAppConfigRsp15081     fn from(builder: SessionSetAppConfigRspBuilder) -> SessionSetAppConfigRsp {
15082         builder.build().into()
15083     }
15084 }
15085 #[derive(Debug, Clone, PartialEq, Eq)]
15086 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15087 pub struct SessionGetAppConfigCmdData {
15088     session_token: u32,
15089     app_cfg: Vec<u8>,
15090 }
15091 #[derive(Debug, Clone, PartialEq, Eq)]
15092 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15093 pub struct SessionGetAppConfigCmd {
15094     #[cfg_attr(feature = "serde", serde(flatten))]
15095     ucicontrolpacket: UciControlPacketData,
15096     #[cfg_attr(feature = "serde", serde(flatten))]
15097     ucicommand: UciCommandData,
15098     #[cfg_attr(feature = "serde", serde(flatten))]
15099     sessionconfigcommand: SessionConfigCommandData,
15100     #[cfg_attr(feature = "serde", serde(flatten))]
15101     sessiongetappconfigcmd: SessionGetAppConfigCmdData,
15102 }
15103 #[derive(Debug)]
15104 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15105 pub struct SessionGetAppConfigCmdBuilder {
15106     pub app_cfg: Vec<u8>,
15107     pub session_token: u32,
15108 }
15109 impl SessionGetAppConfigCmdData {
conforms(bytes: &[u8]) -> bool15110     fn conforms(bytes: &[u8]) -> bool {
15111         bytes.len() >= 5
15112     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>15113     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
15114         let mut cell = Cell::new(bytes);
15115         let packet = Self::parse_inner(&mut cell)?;
15116         Ok(packet)
15117     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>15118     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
15119         if bytes.get().remaining() < 4 {
15120             return Err(DecodeError::InvalidLengthError {
15121                 obj: "SessionGetAppConfigCmd",
15122                 wanted: 4,
15123                 got: bytes.get().remaining(),
15124             });
15125         }
15126         let session_token = bytes.get_mut().get_u32_le();
15127         if bytes.get().remaining() < 1 {
15128             return Err(DecodeError::InvalidLengthError {
15129                 obj: "SessionGetAppConfigCmd",
15130                 wanted: 1,
15131                 got: bytes.get().remaining(),
15132             });
15133         }
15134         let app_cfg_count = bytes.get_mut().get_u8() as usize;
15135         if bytes.get().remaining() < app_cfg_count * 1usize {
15136             return Err(DecodeError::InvalidLengthError {
15137                 obj: "SessionGetAppConfigCmd",
15138                 wanted: app_cfg_count * 1usize,
15139                 got: bytes.get().remaining(),
15140             });
15141         }
15142         let app_cfg = (0..app_cfg_count)
15143             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
15144             .collect::<Result<Vec<_>, DecodeError>>()?;
15145         Ok(Self { session_token, app_cfg })
15146     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>15147     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
15148         buffer.put_u32_le(self.session_token);
15149         buffer.put_u8(self.app_cfg.len() as u8);
15150         for elem in &self.app_cfg {
15151             buffer.put_u8(*elem);
15152         }
15153         Ok(())
15154     }
get_total_size(&self) -> usize15155     fn get_total_size(&self) -> usize {
15156         self.get_size()
15157     }
get_size(&self) -> usize15158     fn get_size(&self) -> usize {
15159         5 + self.app_cfg.len()
15160     }
15161 }
15162 impl Packet for SessionGetAppConfigCmd {
encoded_len(&self) -> usize15163     fn encoded_len(&self) -> usize {
15164         self.get_size()
15165     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>15166     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
15167         self.ucicontrolpacket.write_to(buf)
15168     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>15169     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
15170         unimplemented!("Rust legacy does not implement full packet trait")
15171     }
15172 }
15173 impl TryFrom<SessionGetAppConfigCmd> for Bytes {
15174     type Error = EncodeError;
try_from(packet: SessionGetAppConfigCmd) -> Result<Self, Self::Error>15175     fn try_from(packet: SessionGetAppConfigCmd) -> Result<Self, Self::Error> {
15176         packet.encode_to_bytes()
15177     }
15178 }
15179 impl TryFrom<SessionGetAppConfigCmd> for Vec<u8> {
15180     type Error = EncodeError;
try_from(packet: SessionGetAppConfigCmd) -> Result<Self, Self::Error>15181     fn try_from(packet: SessionGetAppConfigCmd) -> Result<Self, Self::Error> {
15182         packet.encode_to_vec()
15183     }
15184 }
15185 impl From<SessionGetAppConfigCmd> for UciControlPacket {
from(packet: SessionGetAppConfigCmd) -> UciControlPacket15186     fn from(packet: SessionGetAppConfigCmd) -> UciControlPacket {
15187         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
15188     }
15189 }
15190 impl From<SessionGetAppConfigCmd> for UciCommand {
from(packet: SessionGetAppConfigCmd) -> UciCommand15191     fn from(packet: SessionGetAppConfigCmd) -> UciCommand {
15192         UciCommand::new(packet.ucicontrolpacket).unwrap()
15193     }
15194 }
15195 impl From<SessionGetAppConfigCmd> for SessionConfigCommand {
from(packet: SessionGetAppConfigCmd) -> SessionConfigCommand15196     fn from(packet: SessionGetAppConfigCmd) -> SessionConfigCommand {
15197         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
15198     }
15199 }
15200 impl TryFrom<UciControlPacket> for SessionGetAppConfigCmd {
15201     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionGetAppConfigCmd, Self::Error>15202     fn try_from(
15203         packet: UciControlPacket,
15204     ) -> Result<SessionGetAppConfigCmd, Self::Error> {
15205         SessionGetAppConfigCmd::new(packet.ucicontrolpacket)
15206     }
15207 }
15208 impl SessionGetAppConfigCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>15209     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
15210         let mut cell = Cell::new(bytes);
15211         let packet = Self::parse_inner(&mut cell)?;
15212         Ok(packet)
15213     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>15214     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
15215         let data = UciControlPacketData::parse_inner(&mut bytes)?;
15216         Self::new(data)
15217     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>15218     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
15219         let ucicommand = match &ucicontrolpacket.child {
15220             UciControlPacketDataChild::UciCommand(value) => value.clone(),
15221             _ => {
15222                 return Err(DecodeError::InvalidChildError {
15223                     expected: stringify!(UciControlPacketDataChild::UciCommand),
15224                     actual: format!("{:?}", & ucicontrolpacket.child),
15225                 });
15226             }
15227         };
15228         let sessionconfigcommand = match &ucicommand.child {
15229             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
15230             _ => {
15231                 return Err(DecodeError::InvalidChildError {
15232                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
15233                     actual: format!("{:?}", & ucicommand.child),
15234                 });
15235             }
15236         };
15237         let sessiongetappconfigcmd = match &sessionconfigcommand.child {
15238             SessionConfigCommandDataChild::SessionGetAppConfigCmd(value) => value.clone(),
15239             _ => {
15240                 return Err(DecodeError::InvalidChildError {
15241                     expected: stringify!(
15242                         SessionConfigCommandDataChild::SessionGetAppConfigCmd
15243                     ),
15244                     actual: format!("{:?}", & sessionconfigcommand.child),
15245                 });
15246             }
15247         };
15248         Ok(Self {
15249             ucicontrolpacket,
15250             ucicommand,
15251             sessionconfigcommand,
15252             sessiongetappconfigcmd,
15253         })
15254     }
get_app_cfg(&self) -> &Vec<u8>15255     pub fn get_app_cfg(&self) -> &Vec<u8> {
15256         &self.sessiongetappconfigcmd.app_cfg
15257     }
get_group_id(&self) -> GroupId15258     pub fn get_group_id(&self) -> GroupId {
15259         self.ucicontrolpacket.group_id
15260     }
get_message_type(&self) -> MessageType15261     pub fn get_message_type(&self) -> MessageType {
15262         self.ucicontrolpacket.message_type
15263     }
get_opcode(&self) -> u815264     pub fn get_opcode(&self) -> u8 {
15265         self.ucicontrolpacket.opcode
15266     }
get_session_token(&self) -> u3215267     pub fn get_session_token(&self) -> u32 {
15268         self.sessiongetappconfigcmd.session_token
15269     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>15270     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
15271         self.sessiongetappconfigcmd.write_to(buffer)
15272     }
get_size(&self) -> usize15273     pub fn get_size(&self) -> usize {
15274         self.ucicontrolpacket.get_size()
15275     }
15276 }
15277 impl SessionGetAppConfigCmdBuilder {
build(self) -> SessionGetAppConfigCmd15278     pub fn build(self) -> SessionGetAppConfigCmd {
15279         let sessiongetappconfigcmd = SessionGetAppConfigCmdData {
15280             app_cfg: self.app_cfg,
15281             session_token: self.session_token,
15282         };
15283         let sessionconfigcommand = SessionConfigCommandData {
15284             child: SessionConfigCommandDataChild::SessionGetAppConfigCmd(
15285                 sessiongetappconfigcmd,
15286             ),
15287         };
15288         let ucicommand = UciCommandData {
15289             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
15290         };
15291         let ucicontrolpacket = UciControlPacketData {
15292             group_id: GroupId::SessionConfig,
15293             message_type: MessageType::Command,
15294             opcode: 4,
15295             child: UciControlPacketDataChild::UciCommand(ucicommand),
15296         };
15297         SessionGetAppConfigCmd::new(ucicontrolpacket).unwrap()
15298     }
15299 }
15300 impl From<SessionGetAppConfigCmdBuilder> for UciControlPacket {
from(builder: SessionGetAppConfigCmdBuilder) -> UciControlPacket15301     fn from(builder: SessionGetAppConfigCmdBuilder) -> UciControlPacket {
15302         builder.build().into()
15303     }
15304 }
15305 impl From<SessionGetAppConfigCmdBuilder> for UciCommand {
from(builder: SessionGetAppConfigCmdBuilder) -> UciCommand15306     fn from(builder: SessionGetAppConfigCmdBuilder) -> UciCommand {
15307         builder.build().into()
15308     }
15309 }
15310 impl From<SessionGetAppConfigCmdBuilder> for SessionConfigCommand {
from(builder: SessionGetAppConfigCmdBuilder) -> SessionConfigCommand15311     fn from(builder: SessionGetAppConfigCmdBuilder) -> SessionConfigCommand {
15312         builder.build().into()
15313     }
15314 }
15315 impl From<SessionGetAppConfigCmdBuilder> for SessionGetAppConfigCmd {
from(builder: SessionGetAppConfigCmdBuilder) -> SessionGetAppConfigCmd15316     fn from(builder: SessionGetAppConfigCmdBuilder) -> SessionGetAppConfigCmd {
15317         builder.build().into()
15318     }
15319 }
15320 #[derive(Debug, Clone, PartialEq, Eq)]
15321 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15322 pub struct SessionGetAppConfigRspData {
15323     status: StatusCode,
15324     tlvs: Vec<AppConfigTlv>,
15325 }
15326 #[derive(Debug, Clone, PartialEq, Eq)]
15327 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15328 pub struct SessionGetAppConfigRsp {
15329     #[cfg_attr(feature = "serde", serde(flatten))]
15330     ucicontrolpacket: UciControlPacketData,
15331     #[cfg_attr(feature = "serde", serde(flatten))]
15332     uciresponse: UciResponseData,
15333     #[cfg_attr(feature = "serde", serde(flatten))]
15334     sessionconfigresponse: SessionConfigResponseData,
15335     #[cfg_attr(feature = "serde", serde(flatten))]
15336     sessiongetappconfigrsp: SessionGetAppConfigRspData,
15337 }
15338 #[derive(Debug)]
15339 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15340 pub struct SessionGetAppConfigRspBuilder {
15341     pub status: StatusCode,
15342     pub tlvs: Vec<AppConfigTlv>,
15343 }
15344 impl SessionGetAppConfigRspData {
conforms(bytes: &[u8]) -> bool15345     fn conforms(bytes: &[u8]) -> bool {
15346         bytes.len() >= 2
15347     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>15348     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
15349         let mut cell = Cell::new(bytes);
15350         let packet = Self::parse_inner(&mut cell)?;
15351         Ok(packet)
15352     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>15353     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
15354         if bytes.get().remaining() < 1 {
15355             return Err(DecodeError::InvalidLengthError {
15356                 obj: "SessionGetAppConfigRsp",
15357                 wanted: 1,
15358                 got: bytes.get().remaining(),
15359             });
15360         }
15361         let status = StatusCode::try_from(bytes.get_mut().get_u8())
15362             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
15363                 obj: "SessionGetAppConfigRsp",
15364                 field: "status",
15365                 value: unknown_val as u64,
15366                 type_: "StatusCode",
15367             })?;
15368         if bytes.get().remaining() < 1 {
15369             return Err(DecodeError::InvalidLengthError {
15370                 obj: "SessionGetAppConfigRsp",
15371                 wanted: 1,
15372                 got: bytes.get().remaining(),
15373             });
15374         }
15375         let tlvs_count = bytes.get_mut().get_u8() as usize;
15376         let tlvs = (0..tlvs_count)
15377             .map(|_| AppConfigTlv::parse_inner(bytes))
15378             .collect::<Result<Vec<_>, DecodeError>>()?;
15379         Ok(Self { status, tlvs })
15380     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>15381     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
15382         buffer.put_u8(u8::from(self.status));
15383         buffer.put_u8(self.tlvs.len() as u8);
15384         for elem in &self.tlvs {
15385             elem.write_to(buffer)?;
15386         }
15387         Ok(())
15388     }
get_total_size(&self) -> usize15389     fn get_total_size(&self) -> usize {
15390         self.get_size()
15391     }
get_size(&self) -> usize15392     fn get_size(&self) -> usize {
15393         2 + self.tlvs.iter().map(|elem| elem.get_size()).sum::<usize>()
15394     }
15395 }
15396 impl Packet for SessionGetAppConfigRsp {
encoded_len(&self) -> usize15397     fn encoded_len(&self) -> usize {
15398         self.get_size()
15399     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>15400     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
15401         self.ucicontrolpacket.write_to(buf)
15402     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>15403     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
15404         unimplemented!("Rust legacy does not implement full packet trait")
15405     }
15406 }
15407 impl TryFrom<SessionGetAppConfigRsp> for Bytes {
15408     type Error = EncodeError;
try_from(packet: SessionGetAppConfigRsp) -> Result<Self, Self::Error>15409     fn try_from(packet: SessionGetAppConfigRsp) -> Result<Self, Self::Error> {
15410         packet.encode_to_bytes()
15411     }
15412 }
15413 impl TryFrom<SessionGetAppConfigRsp> for Vec<u8> {
15414     type Error = EncodeError;
try_from(packet: SessionGetAppConfigRsp) -> Result<Self, Self::Error>15415     fn try_from(packet: SessionGetAppConfigRsp) -> Result<Self, Self::Error> {
15416         packet.encode_to_vec()
15417     }
15418 }
15419 impl From<SessionGetAppConfigRsp> for UciControlPacket {
from(packet: SessionGetAppConfigRsp) -> UciControlPacket15420     fn from(packet: SessionGetAppConfigRsp) -> UciControlPacket {
15421         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
15422     }
15423 }
15424 impl From<SessionGetAppConfigRsp> for UciResponse {
from(packet: SessionGetAppConfigRsp) -> UciResponse15425     fn from(packet: SessionGetAppConfigRsp) -> UciResponse {
15426         UciResponse::new(packet.ucicontrolpacket).unwrap()
15427     }
15428 }
15429 impl From<SessionGetAppConfigRsp> for SessionConfigResponse {
from(packet: SessionGetAppConfigRsp) -> SessionConfigResponse15430     fn from(packet: SessionGetAppConfigRsp) -> SessionConfigResponse {
15431         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
15432     }
15433 }
15434 impl TryFrom<UciControlPacket> for SessionGetAppConfigRsp {
15435     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionGetAppConfigRsp, Self::Error>15436     fn try_from(
15437         packet: UciControlPacket,
15438     ) -> Result<SessionGetAppConfigRsp, Self::Error> {
15439         SessionGetAppConfigRsp::new(packet.ucicontrolpacket)
15440     }
15441 }
15442 impl SessionGetAppConfigRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>15443     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
15444         let mut cell = Cell::new(bytes);
15445         let packet = Self::parse_inner(&mut cell)?;
15446         Ok(packet)
15447     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>15448     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
15449         let data = UciControlPacketData::parse_inner(&mut bytes)?;
15450         Self::new(data)
15451     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>15452     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
15453         let uciresponse = match &ucicontrolpacket.child {
15454             UciControlPacketDataChild::UciResponse(value) => value.clone(),
15455             _ => {
15456                 return Err(DecodeError::InvalidChildError {
15457                     expected: stringify!(UciControlPacketDataChild::UciResponse),
15458                     actual: format!("{:?}", & ucicontrolpacket.child),
15459                 });
15460             }
15461         };
15462         let sessionconfigresponse = match &uciresponse.child {
15463             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
15464             _ => {
15465                 return Err(DecodeError::InvalidChildError {
15466                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
15467                     actual: format!("{:?}", & uciresponse.child),
15468                 });
15469             }
15470         };
15471         let sessiongetappconfigrsp = match &sessionconfigresponse.child {
15472             SessionConfigResponseDataChild::SessionGetAppConfigRsp(value) => {
15473                 value.clone()
15474             }
15475             _ => {
15476                 return Err(DecodeError::InvalidChildError {
15477                     expected: stringify!(
15478                         SessionConfigResponseDataChild::SessionGetAppConfigRsp
15479                     ),
15480                     actual: format!("{:?}", & sessionconfigresponse.child),
15481                 });
15482             }
15483         };
15484         Ok(Self {
15485             ucicontrolpacket,
15486             uciresponse,
15487             sessionconfigresponse,
15488             sessiongetappconfigrsp,
15489         })
15490     }
get_group_id(&self) -> GroupId15491     pub fn get_group_id(&self) -> GroupId {
15492         self.ucicontrolpacket.group_id
15493     }
get_message_type(&self) -> MessageType15494     pub fn get_message_type(&self) -> MessageType {
15495         self.ucicontrolpacket.message_type
15496     }
get_opcode(&self) -> u815497     pub fn get_opcode(&self) -> u8 {
15498         self.ucicontrolpacket.opcode
15499     }
get_status(&self) -> StatusCode15500     pub fn get_status(&self) -> StatusCode {
15501         self.sessiongetappconfigrsp.status
15502     }
get_tlvs(&self) -> &Vec<AppConfigTlv>15503     pub fn get_tlvs(&self) -> &Vec<AppConfigTlv> {
15504         &self.sessiongetappconfigrsp.tlvs
15505     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>15506     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
15507         self.sessiongetappconfigrsp.write_to(buffer)
15508     }
get_size(&self) -> usize15509     pub fn get_size(&self) -> usize {
15510         self.ucicontrolpacket.get_size()
15511     }
15512 }
15513 impl SessionGetAppConfigRspBuilder {
build(self) -> SessionGetAppConfigRsp15514     pub fn build(self) -> SessionGetAppConfigRsp {
15515         let sessiongetappconfigrsp = SessionGetAppConfigRspData {
15516             status: self.status,
15517             tlvs: self.tlvs,
15518         };
15519         let sessionconfigresponse = SessionConfigResponseData {
15520             child: SessionConfigResponseDataChild::SessionGetAppConfigRsp(
15521                 sessiongetappconfigrsp,
15522             ),
15523         };
15524         let uciresponse = UciResponseData {
15525             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
15526         };
15527         let ucicontrolpacket = UciControlPacketData {
15528             group_id: GroupId::SessionConfig,
15529             message_type: MessageType::Response,
15530             opcode: 4,
15531             child: UciControlPacketDataChild::UciResponse(uciresponse),
15532         };
15533         SessionGetAppConfigRsp::new(ucicontrolpacket).unwrap()
15534     }
15535 }
15536 impl From<SessionGetAppConfigRspBuilder> for UciControlPacket {
from(builder: SessionGetAppConfigRspBuilder) -> UciControlPacket15537     fn from(builder: SessionGetAppConfigRspBuilder) -> UciControlPacket {
15538         builder.build().into()
15539     }
15540 }
15541 impl From<SessionGetAppConfigRspBuilder> for UciResponse {
from(builder: SessionGetAppConfigRspBuilder) -> UciResponse15542     fn from(builder: SessionGetAppConfigRspBuilder) -> UciResponse {
15543         builder.build().into()
15544     }
15545 }
15546 impl From<SessionGetAppConfigRspBuilder> for SessionConfigResponse {
from(builder: SessionGetAppConfigRspBuilder) -> SessionConfigResponse15547     fn from(builder: SessionGetAppConfigRspBuilder) -> SessionConfigResponse {
15548         builder.build().into()
15549     }
15550 }
15551 impl From<SessionGetAppConfigRspBuilder> for SessionGetAppConfigRsp {
from(builder: SessionGetAppConfigRspBuilder) -> SessionGetAppConfigRsp15552     fn from(builder: SessionGetAppConfigRspBuilder) -> SessionGetAppConfigRsp {
15553         builder.build().into()
15554     }
15555 }
15556 #[derive(Debug, Clone, PartialEq, Eq)]
15557 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15558 pub struct SessionGetCountCmdData {}
15559 #[derive(Debug, Clone, PartialEq, Eq)]
15560 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15561 pub struct SessionGetCountCmd {
15562     #[cfg_attr(feature = "serde", serde(flatten))]
15563     ucicontrolpacket: UciControlPacketData,
15564     #[cfg_attr(feature = "serde", serde(flatten))]
15565     ucicommand: UciCommandData,
15566     #[cfg_attr(feature = "serde", serde(flatten))]
15567     sessionconfigcommand: SessionConfigCommandData,
15568     #[cfg_attr(feature = "serde", serde(flatten))]
15569     sessiongetcountcmd: SessionGetCountCmdData,
15570 }
15571 #[derive(Debug)]
15572 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15573 pub struct SessionGetCountCmdBuilder {}
15574 impl SessionGetCountCmdData {
conforms(bytes: &[u8]) -> bool15575     fn conforms(bytes: &[u8]) -> bool {
15576         true
15577     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>15578     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
15579         let mut cell = Cell::new(bytes);
15580         let packet = Self::parse_inner(&mut cell)?;
15581         Ok(packet)
15582     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>15583     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
15584         Ok(Self {})
15585     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>15586     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
15587         Ok(())
15588     }
get_total_size(&self) -> usize15589     fn get_total_size(&self) -> usize {
15590         self.get_size()
15591     }
get_size(&self) -> usize15592     fn get_size(&self) -> usize {
15593         0
15594     }
15595 }
15596 impl Packet for SessionGetCountCmd {
encoded_len(&self) -> usize15597     fn encoded_len(&self) -> usize {
15598         self.get_size()
15599     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>15600     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
15601         self.ucicontrolpacket.write_to(buf)
15602     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>15603     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
15604         unimplemented!("Rust legacy does not implement full packet trait")
15605     }
15606 }
15607 impl TryFrom<SessionGetCountCmd> for Bytes {
15608     type Error = EncodeError;
try_from(packet: SessionGetCountCmd) -> Result<Self, Self::Error>15609     fn try_from(packet: SessionGetCountCmd) -> Result<Self, Self::Error> {
15610         packet.encode_to_bytes()
15611     }
15612 }
15613 impl TryFrom<SessionGetCountCmd> for Vec<u8> {
15614     type Error = EncodeError;
try_from(packet: SessionGetCountCmd) -> Result<Self, Self::Error>15615     fn try_from(packet: SessionGetCountCmd) -> Result<Self, Self::Error> {
15616         packet.encode_to_vec()
15617     }
15618 }
15619 impl From<SessionGetCountCmd> for UciControlPacket {
from(packet: SessionGetCountCmd) -> UciControlPacket15620     fn from(packet: SessionGetCountCmd) -> UciControlPacket {
15621         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
15622     }
15623 }
15624 impl From<SessionGetCountCmd> for UciCommand {
from(packet: SessionGetCountCmd) -> UciCommand15625     fn from(packet: SessionGetCountCmd) -> UciCommand {
15626         UciCommand::new(packet.ucicontrolpacket).unwrap()
15627     }
15628 }
15629 impl From<SessionGetCountCmd> for SessionConfigCommand {
from(packet: SessionGetCountCmd) -> SessionConfigCommand15630     fn from(packet: SessionGetCountCmd) -> SessionConfigCommand {
15631         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
15632     }
15633 }
15634 impl TryFrom<UciControlPacket> for SessionGetCountCmd {
15635     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionGetCountCmd, Self::Error>15636     fn try_from(packet: UciControlPacket) -> Result<SessionGetCountCmd, Self::Error> {
15637         SessionGetCountCmd::new(packet.ucicontrolpacket)
15638     }
15639 }
15640 impl SessionGetCountCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>15641     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
15642         let mut cell = Cell::new(bytes);
15643         let packet = Self::parse_inner(&mut cell)?;
15644         Ok(packet)
15645     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>15646     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
15647         let data = UciControlPacketData::parse_inner(&mut bytes)?;
15648         Self::new(data)
15649     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>15650     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
15651         let ucicommand = match &ucicontrolpacket.child {
15652             UciControlPacketDataChild::UciCommand(value) => value.clone(),
15653             _ => {
15654                 return Err(DecodeError::InvalidChildError {
15655                     expected: stringify!(UciControlPacketDataChild::UciCommand),
15656                     actual: format!("{:?}", & ucicontrolpacket.child),
15657                 });
15658             }
15659         };
15660         let sessionconfigcommand = match &ucicommand.child {
15661             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
15662             _ => {
15663                 return Err(DecodeError::InvalidChildError {
15664                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
15665                     actual: format!("{:?}", & ucicommand.child),
15666                 });
15667             }
15668         };
15669         let sessiongetcountcmd = match &sessionconfigcommand.child {
15670             SessionConfigCommandDataChild::SessionGetCountCmd(value) => value.clone(),
15671             _ => {
15672                 return Err(DecodeError::InvalidChildError {
15673                     expected: stringify!(
15674                         SessionConfigCommandDataChild::SessionGetCountCmd
15675                     ),
15676                     actual: format!("{:?}", & sessionconfigcommand.child),
15677                 });
15678             }
15679         };
15680         Ok(Self {
15681             ucicontrolpacket,
15682             ucicommand,
15683             sessionconfigcommand,
15684             sessiongetcountcmd,
15685         })
15686     }
get_group_id(&self) -> GroupId15687     pub fn get_group_id(&self) -> GroupId {
15688         self.ucicontrolpacket.group_id
15689     }
get_message_type(&self) -> MessageType15690     pub fn get_message_type(&self) -> MessageType {
15691         self.ucicontrolpacket.message_type
15692     }
get_opcode(&self) -> u815693     pub fn get_opcode(&self) -> u8 {
15694         self.ucicontrolpacket.opcode
15695     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>15696     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
15697         self.sessiongetcountcmd.write_to(buffer)
15698     }
get_size(&self) -> usize15699     pub fn get_size(&self) -> usize {
15700         self.ucicontrolpacket.get_size()
15701     }
15702 }
15703 impl SessionGetCountCmdBuilder {
build(self) -> SessionGetCountCmd15704     pub fn build(self) -> SessionGetCountCmd {
15705         let sessiongetcountcmd = SessionGetCountCmdData {};
15706         let sessionconfigcommand = SessionConfigCommandData {
15707             child: SessionConfigCommandDataChild::SessionGetCountCmd(sessiongetcountcmd),
15708         };
15709         let ucicommand = UciCommandData {
15710             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
15711         };
15712         let ucicontrolpacket = UciControlPacketData {
15713             group_id: GroupId::SessionConfig,
15714             message_type: MessageType::Command,
15715             opcode: 5,
15716             child: UciControlPacketDataChild::UciCommand(ucicommand),
15717         };
15718         SessionGetCountCmd::new(ucicontrolpacket).unwrap()
15719     }
15720 }
15721 impl From<SessionGetCountCmdBuilder> for UciControlPacket {
from(builder: SessionGetCountCmdBuilder) -> UciControlPacket15722     fn from(builder: SessionGetCountCmdBuilder) -> UciControlPacket {
15723         builder.build().into()
15724     }
15725 }
15726 impl From<SessionGetCountCmdBuilder> for UciCommand {
from(builder: SessionGetCountCmdBuilder) -> UciCommand15727     fn from(builder: SessionGetCountCmdBuilder) -> UciCommand {
15728         builder.build().into()
15729     }
15730 }
15731 impl From<SessionGetCountCmdBuilder> for SessionConfigCommand {
from(builder: SessionGetCountCmdBuilder) -> SessionConfigCommand15732     fn from(builder: SessionGetCountCmdBuilder) -> SessionConfigCommand {
15733         builder.build().into()
15734     }
15735 }
15736 impl From<SessionGetCountCmdBuilder> for SessionGetCountCmd {
from(builder: SessionGetCountCmdBuilder) -> SessionGetCountCmd15737     fn from(builder: SessionGetCountCmdBuilder) -> SessionGetCountCmd {
15738         builder.build().into()
15739     }
15740 }
15741 #[derive(Debug, Clone, PartialEq, Eq)]
15742 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15743 pub struct SessionGetCountRspData {
15744     status: StatusCode,
15745     session_count: u8,
15746 }
15747 #[derive(Debug, Clone, PartialEq, Eq)]
15748 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15749 pub struct SessionGetCountRsp {
15750     #[cfg_attr(feature = "serde", serde(flatten))]
15751     ucicontrolpacket: UciControlPacketData,
15752     #[cfg_attr(feature = "serde", serde(flatten))]
15753     uciresponse: UciResponseData,
15754     #[cfg_attr(feature = "serde", serde(flatten))]
15755     sessionconfigresponse: SessionConfigResponseData,
15756     #[cfg_attr(feature = "serde", serde(flatten))]
15757     sessiongetcountrsp: SessionGetCountRspData,
15758 }
15759 #[derive(Debug)]
15760 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15761 pub struct SessionGetCountRspBuilder {
15762     pub session_count: u8,
15763     pub status: StatusCode,
15764 }
15765 impl SessionGetCountRspData {
conforms(bytes: &[u8]) -> bool15766     fn conforms(bytes: &[u8]) -> bool {
15767         bytes.len() >= 2
15768     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>15769     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
15770         let mut cell = Cell::new(bytes);
15771         let packet = Self::parse_inner(&mut cell)?;
15772         Ok(packet)
15773     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>15774     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
15775         if bytes.get().remaining() < 1 {
15776             return Err(DecodeError::InvalidLengthError {
15777                 obj: "SessionGetCountRsp",
15778                 wanted: 1,
15779                 got: bytes.get().remaining(),
15780             });
15781         }
15782         let status = StatusCode::try_from(bytes.get_mut().get_u8())
15783             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
15784                 obj: "SessionGetCountRsp",
15785                 field: "status",
15786                 value: unknown_val as u64,
15787                 type_: "StatusCode",
15788             })?;
15789         if bytes.get().remaining() < 1 {
15790             return Err(DecodeError::InvalidLengthError {
15791                 obj: "SessionGetCountRsp",
15792                 wanted: 1,
15793                 got: bytes.get().remaining(),
15794             });
15795         }
15796         let session_count = bytes.get_mut().get_u8();
15797         Ok(Self { status, session_count })
15798     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>15799     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
15800         buffer.put_u8(u8::from(self.status));
15801         buffer.put_u8(self.session_count);
15802         Ok(())
15803     }
get_total_size(&self) -> usize15804     fn get_total_size(&self) -> usize {
15805         self.get_size()
15806     }
get_size(&self) -> usize15807     fn get_size(&self) -> usize {
15808         2
15809     }
15810 }
15811 impl Packet for SessionGetCountRsp {
encoded_len(&self) -> usize15812     fn encoded_len(&self) -> usize {
15813         self.get_size()
15814     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>15815     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
15816         self.ucicontrolpacket.write_to(buf)
15817     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>15818     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
15819         unimplemented!("Rust legacy does not implement full packet trait")
15820     }
15821 }
15822 impl TryFrom<SessionGetCountRsp> for Bytes {
15823     type Error = EncodeError;
try_from(packet: SessionGetCountRsp) -> Result<Self, Self::Error>15824     fn try_from(packet: SessionGetCountRsp) -> Result<Self, Self::Error> {
15825         packet.encode_to_bytes()
15826     }
15827 }
15828 impl TryFrom<SessionGetCountRsp> for Vec<u8> {
15829     type Error = EncodeError;
try_from(packet: SessionGetCountRsp) -> Result<Self, Self::Error>15830     fn try_from(packet: SessionGetCountRsp) -> Result<Self, Self::Error> {
15831         packet.encode_to_vec()
15832     }
15833 }
15834 impl From<SessionGetCountRsp> for UciControlPacket {
from(packet: SessionGetCountRsp) -> UciControlPacket15835     fn from(packet: SessionGetCountRsp) -> UciControlPacket {
15836         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
15837     }
15838 }
15839 impl From<SessionGetCountRsp> for UciResponse {
from(packet: SessionGetCountRsp) -> UciResponse15840     fn from(packet: SessionGetCountRsp) -> UciResponse {
15841         UciResponse::new(packet.ucicontrolpacket).unwrap()
15842     }
15843 }
15844 impl From<SessionGetCountRsp> for SessionConfigResponse {
from(packet: SessionGetCountRsp) -> SessionConfigResponse15845     fn from(packet: SessionGetCountRsp) -> SessionConfigResponse {
15846         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
15847     }
15848 }
15849 impl TryFrom<UciControlPacket> for SessionGetCountRsp {
15850     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionGetCountRsp, Self::Error>15851     fn try_from(packet: UciControlPacket) -> Result<SessionGetCountRsp, Self::Error> {
15852         SessionGetCountRsp::new(packet.ucicontrolpacket)
15853     }
15854 }
15855 impl SessionGetCountRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>15856     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
15857         let mut cell = Cell::new(bytes);
15858         let packet = Self::parse_inner(&mut cell)?;
15859         Ok(packet)
15860     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>15861     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
15862         let data = UciControlPacketData::parse_inner(&mut bytes)?;
15863         Self::new(data)
15864     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>15865     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
15866         let uciresponse = match &ucicontrolpacket.child {
15867             UciControlPacketDataChild::UciResponse(value) => value.clone(),
15868             _ => {
15869                 return Err(DecodeError::InvalidChildError {
15870                     expected: stringify!(UciControlPacketDataChild::UciResponse),
15871                     actual: format!("{:?}", & ucicontrolpacket.child),
15872                 });
15873             }
15874         };
15875         let sessionconfigresponse = match &uciresponse.child {
15876             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
15877             _ => {
15878                 return Err(DecodeError::InvalidChildError {
15879                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
15880                     actual: format!("{:?}", & uciresponse.child),
15881                 });
15882             }
15883         };
15884         let sessiongetcountrsp = match &sessionconfigresponse.child {
15885             SessionConfigResponseDataChild::SessionGetCountRsp(value) => value.clone(),
15886             _ => {
15887                 return Err(DecodeError::InvalidChildError {
15888                     expected: stringify!(
15889                         SessionConfigResponseDataChild::SessionGetCountRsp
15890                     ),
15891                     actual: format!("{:?}", & sessionconfigresponse.child),
15892                 });
15893             }
15894         };
15895         Ok(Self {
15896             ucicontrolpacket,
15897             uciresponse,
15898             sessionconfigresponse,
15899             sessiongetcountrsp,
15900         })
15901     }
get_group_id(&self) -> GroupId15902     pub fn get_group_id(&self) -> GroupId {
15903         self.ucicontrolpacket.group_id
15904     }
get_message_type(&self) -> MessageType15905     pub fn get_message_type(&self) -> MessageType {
15906         self.ucicontrolpacket.message_type
15907     }
get_opcode(&self) -> u815908     pub fn get_opcode(&self) -> u8 {
15909         self.ucicontrolpacket.opcode
15910     }
get_session_count(&self) -> u815911     pub fn get_session_count(&self) -> u8 {
15912         self.sessiongetcountrsp.session_count
15913     }
get_status(&self) -> StatusCode15914     pub fn get_status(&self) -> StatusCode {
15915         self.sessiongetcountrsp.status
15916     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>15917     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
15918         self.sessiongetcountrsp.write_to(buffer)
15919     }
get_size(&self) -> usize15920     pub fn get_size(&self) -> usize {
15921         self.ucicontrolpacket.get_size()
15922     }
15923 }
15924 impl SessionGetCountRspBuilder {
build(self) -> SessionGetCountRsp15925     pub fn build(self) -> SessionGetCountRsp {
15926         let sessiongetcountrsp = SessionGetCountRspData {
15927             session_count: self.session_count,
15928             status: self.status,
15929         };
15930         let sessionconfigresponse = SessionConfigResponseData {
15931             child: SessionConfigResponseDataChild::SessionGetCountRsp(sessiongetcountrsp),
15932         };
15933         let uciresponse = UciResponseData {
15934             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
15935         };
15936         let ucicontrolpacket = UciControlPacketData {
15937             group_id: GroupId::SessionConfig,
15938             message_type: MessageType::Response,
15939             opcode: 5,
15940             child: UciControlPacketDataChild::UciResponse(uciresponse),
15941         };
15942         SessionGetCountRsp::new(ucicontrolpacket).unwrap()
15943     }
15944 }
15945 impl From<SessionGetCountRspBuilder> for UciControlPacket {
from(builder: SessionGetCountRspBuilder) -> UciControlPacket15946     fn from(builder: SessionGetCountRspBuilder) -> UciControlPacket {
15947         builder.build().into()
15948     }
15949 }
15950 impl From<SessionGetCountRspBuilder> for UciResponse {
from(builder: SessionGetCountRspBuilder) -> UciResponse15951     fn from(builder: SessionGetCountRspBuilder) -> UciResponse {
15952         builder.build().into()
15953     }
15954 }
15955 impl From<SessionGetCountRspBuilder> for SessionConfigResponse {
from(builder: SessionGetCountRspBuilder) -> SessionConfigResponse15956     fn from(builder: SessionGetCountRspBuilder) -> SessionConfigResponse {
15957         builder.build().into()
15958     }
15959 }
15960 impl From<SessionGetCountRspBuilder> for SessionGetCountRsp {
from(builder: SessionGetCountRspBuilder) -> SessionGetCountRsp15961     fn from(builder: SessionGetCountRspBuilder) -> SessionGetCountRsp {
15962         builder.build().into()
15963     }
15964 }
15965 #[derive(Debug, Clone, PartialEq, Eq)]
15966 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15967 pub struct SessionGetStateCmdData {
15968     session_token: u32,
15969 }
15970 #[derive(Debug, Clone, PartialEq, Eq)]
15971 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15972 pub struct SessionGetStateCmd {
15973     #[cfg_attr(feature = "serde", serde(flatten))]
15974     ucicontrolpacket: UciControlPacketData,
15975     #[cfg_attr(feature = "serde", serde(flatten))]
15976     ucicommand: UciCommandData,
15977     #[cfg_attr(feature = "serde", serde(flatten))]
15978     sessionconfigcommand: SessionConfigCommandData,
15979     #[cfg_attr(feature = "serde", serde(flatten))]
15980     sessiongetstatecmd: SessionGetStateCmdData,
15981 }
15982 #[derive(Debug)]
15983 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15984 pub struct SessionGetStateCmdBuilder {
15985     pub session_token: u32,
15986 }
15987 impl SessionGetStateCmdData {
conforms(bytes: &[u8]) -> bool15988     fn conforms(bytes: &[u8]) -> bool {
15989         bytes.len() >= 4
15990     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>15991     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
15992         let mut cell = Cell::new(bytes);
15993         let packet = Self::parse_inner(&mut cell)?;
15994         Ok(packet)
15995     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>15996     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
15997         if bytes.get().remaining() < 4 {
15998             return Err(DecodeError::InvalidLengthError {
15999                 obj: "SessionGetStateCmd",
16000                 wanted: 4,
16001                 got: bytes.get().remaining(),
16002             });
16003         }
16004         let session_token = bytes.get_mut().get_u32_le();
16005         Ok(Self { session_token })
16006     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>16007     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
16008         buffer.put_u32_le(self.session_token);
16009         Ok(())
16010     }
get_total_size(&self) -> usize16011     fn get_total_size(&self) -> usize {
16012         self.get_size()
16013     }
get_size(&self) -> usize16014     fn get_size(&self) -> usize {
16015         4
16016     }
16017 }
16018 impl Packet for SessionGetStateCmd {
encoded_len(&self) -> usize16019     fn encoded_len(&self) -> usize {
16020         self.get_size()
16021     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>16022     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
16023         self.ucicontrolpacket.write_to(buf)
16024     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>16025     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
16026         unimplemented!("Rust legacy does not implement full packet trait")
16027     }
16028 }
16029 impl TryFrom<SessionGetStateCmd> for Bytes {
16030     type Error = EncodeError;
try_from(packet: SessionGetStateCmd) -> Result<Self, Self::Error>16031     fn try_from(packet: SessionGetStateCmd) -> Result<Self, Self::Error> {
16032         packet.encode_to_bytes()
16033     }
16034 }
16035 impl TryFrom<SessionGetStateCmd> for Vec<u8> {
16036     type Error = EncodeError;
try_from(packet: SessionGetStateCmd) -> Result<Self, Self::Error>16037     fn try_from(packet: SessionGetStateCmd) -> Result<Self, Self::Error> {
16038         packet.encode_to_vec()
16039     }
16040 }
16041 impl From<SessionGetStateCmd> for UciControlPacket {
from(packet: SessionGetStateCmd) -> UciControlPacket16042     fn from(packet: SessionGetStateCmd) -> UciControlPacket {
16043         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
16044     }
16045 }
16046 impl From<SessionGetStateCmd> for UciCommand {
from(packet: SessionGetStateCmd) -> UciCommand16047     fn from(packet: SessionGetStateCmd) -> UciCommand {
16048         UciCommand::new(packet.ucicontrolpacket).unwrap()
16049     }
16050 }
16051 impl From<SessionGetStateCmd> for SessionConfigCommand {
from(packet: SessionGetStateCmd) -> SessionConfigCommand16052     fn from(packet: SessionGetStateCmd) -> SessionConfigCommand {
16053         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
16054     }
16055 }
16056 impl TryFrom<UciControlPacket> for SessionGetStateCmd {
16057     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionGetStateCmd, Self::Error>16058     fn try_from(packet: UciControlPacket) -> Result<SessionGetStateCmd, Self::Error> {
16059         SessionGetStateCmd::new(packet.ucicontrolpacket)
16060     }
16061 }
16062 impl SessionGetStateCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>16063     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
16064         let mut cell = Cell::new(bytes);
16065         let packet = Self::parse_inner(&mut cell)?;
16066         Ok(packet)
16067     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>16068     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
16069         let data = UciControlPacketData::parse_inner(&mut bytes)?;
16070         Self::new(data)
16071     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>16072     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
16073         let ucicommand = match &ucicontrolpacket.child {
16074             UciControlPacketDataChild::UciCommand(value) => value.clone(),
16075             _ => {
16076                 return Err(DecodeError::InvalidChildError {
16077                     expected: stringify!(UciControlPacketDataChild::UciCommand),
16078                     actual: format!("{:?}", & ucicontrolpacket.child),
16079                 });
16080             }
16081         };
16082         let sessionconfigcommand = match &ucicommand.child {
16083             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
16084             _ => {
16085                 return Err(DecodeError::InvalidChildError {
16086                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
16087                     actual: format!("{:?}", & ucicommand.child),
16088                 });
16089             }
16090         };
16091         let sessiongetstatecmd = match &sessionconfigcommand.child {
16092             SessionConfigCommandDataChild::SessionGetStateCmd(value) => value.clone(),
16093             _ => {
16094                 return Err(DecodeError::InvalidChildError {
16095                     expected: stringify!(
16096                         SessionConfigCommandDataChild::SessionGetStateCmd
16097                     ),
16098                     actual: format!("{:?}", & sessionconfigcommand.child),
16099                 });
16100             }
16101         };
16102         Ok(Self {
16103             ucicontrolpacket,
16104             ucicommand,
16105             sessionconfigcommand,
16106             sessiongetstatecmd,
16107         })
16108     }
get_group_id(&self) -> GroupId16109     pub fn get_group_id(&self) -> GroupId {
16110         self.ucicontrolpacket.group_id
16111     }
get_message_type(&self) -> MessageType16112     pub fn get_message_type(&self) -> MessageType {
16113         self.ucicontrolpacket.message_type
16114     }
get_opcode(&self) -> u816115     pub fn get_opcode(&self) -> u8 {
16116         self.ucicontrolpacket.opcode
16117     }
get_session_token(&self) -> u3216118     pub fn get_session_token(&self) -> u32 {
16119         self.sessiongetstatecmd.session_token
16120     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>16121     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
16122         self.sessiongetstatecmd.write_to(buffer)
16123     }
get_size(&self) -> usize16124     pub fn get_size(&self) -> usize {
16125         self.ucicontrolpacket.get_size()
16126     }
16127 }
16128 impl SessionGetStateCmdBuilder {
build(self) -> SessionGetStateCmd16129     pub fn build(self) -> SessionGetStateCmd {
16130         let sessiongetstatecmd = SessionGetStateCmdData {
16131             session_token: self.session_token,
16132         };
16133         let sessionconfigcommand = SessionConfigCommandData {
16134             child: SessionConfigCommandDataChild::SessionGetStateCmd(sessiongetstatecmd),
16135         };
16136         let ucicommand = UciCommandData {
16137             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
16138         };
16139         let ucicontrolpacket = UciControlPacketData {
16140             group_id: GroupId::SessionConfig,
16141             message_type: MessageType::Command,
16142             opcode: 6,
16143             child: UciControlPacketDataChild::UciCommand(ucicommand),
16144         };
16145         SessionGetStateCmd::new(ucicontrolpacket).unwrap()
16146     }
16147 }
16148 impl From<SessionGetStateCmdBuilder> for UciControlPacket {
from(builder: SessionGetStateCmdBuilder) -> UciControlPacket16149     fn from(builder: SessionGetStateCmdBuilder) -> UciControlPacket {
16150         builder.build().into()
16151     }
16152 }
16153 impl From<SessionGetStateCmdBuilder> for UciCommand {
from(builder: SessionGetStateCmdBuilder) -> UciCommand16154     fn from(builder: SessionGetStateCmdBuilder) -> UciCommand {
16155         builder.build().into()
16156     }
16157 }
16158 impl From<SessionGetStateCmdBuilder> for SessionConfigCommand {
from(builder: SessionGetStateCmdBuilder) -> SessionConfigCommand16159     fn from(builder: SessionGetStateCmdBuilder) -> SessionConfigCommand {
16160         builder.build().into()
16161     }
16162 }
16163 impl From<SessionGetStateCmdBuilder> for SessionGetStateCmd {
from(builder: SessionGetStateCmdBuilder) -> SessionGetStateCmd16164     fn from(builder: SessionGetStateCmdBuilder) -> SessionGetStateCmd {
16165         builder.build().into()
16166     }
16167 }
16168 #[derive(Debug, Clone, PartialEq, Eq)]
16169 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16170 pub struct SessionGetStateRspData {
16171     status: StatusCode,
16172     session_state: SessionState,
16173 }
16174 #[derive(Debug, Clone, PartialEq, Eq)]
16175 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16176 pub struct SessionGetStateRsp {
16177     #[cfg_attr(feature = "serde", serde(flatten))]
16178     ucicontrolpacket: UciControlPacketData,
16179     #[cfg_attr(feature = "serde", serde(flatten))]
16180     uciresponse: UciResponseData,
16181     #[cfg_attr(feature = "serde", serde(flatten))]
16182     sessionconfigresponse: SessionConfigResponseData,
16183     #[cfg_attr(feature = "serde", serde(flatten))]
16184     sessiongetstatersp: SessionGetStateRspData,
16185 }
16186 #[derive(Debug)]
16187 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16188 pub struct SessionGetStateRspBuilder {
16189     pub session_state: SessionState,
16190     pub status: StatusCode,
16191 }
16192 impl SessionGetStateRspData {
conforms(bytes: &[u8]) -> bool16193     fn conforms(bytes: &[u8]) -> bool {
16194         bytes.len() >= 2
16195     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>16196     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
16197         let mut cell = Cell::new(bytes);
16198         let packet = Self::parse_inner(&mut cell)?;
16199         Ok(packet)
16200     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>16201     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
16202         if bytes.get().remaining() < 1 {
16203             return Err(DecodeError::InvalidLengthError {
16204                 obj: "SessionGetStateRsp",
16205                 wanted: 1,
16206                 got: bytes.get().remaining(),
16207             });
16208         }
16209         let status = StatusCode::try_from(bytes.get_mut().get_u8())
16210             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
16211                 obj: "SessionGetStateRsp",
16212                 field: "status",
16213                 value: unknown_val as u64,
16214                 type_: "StatusCode",
16215             })?;
16216         if bytes.get().remaining() < 1 {
16217             return Err(DecodeError::InvalidLengthError {
16218                 obj: "SessionGetStateRsp",
16219                 wanted: 1,
16220                 got: bytes.get().remaining(),
16221             });
16222         }
16223         let session_state = SessionState::try_from(bytes.get_mut().get_u8())
16224             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
16225                 obj: "SessionGetStateRsp",
16226                 field: "session_state",
16227                 value: unknown_val as u64,
16228                 type_: "SessionState",
16229             })?;
16230         Ok(Self { status, session_state })
16231     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>16232     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
16233         buffer.put_u8(u8::from(self.status));
16234         buffer.put_u8(u8::from(self.session_state));
16235         Ok(())
16236     }
get_total_size(&self) -> usize16237     fn get_total_size(&self) -> usize {
16238         self.get_size()
16239     }
get_size(&self) -> usize16240     fn get_size(&self) -> usize {
16241         2
16242     }
16243 }
16244 impl Packet for SessionGetStateRsp {
encoded_len(&self) -> usize16245     fn encoded_len(&self) -> usize {
16246         self.get_size()
16247     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>16248     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
16249         self.ucicontrolpacket.write_to(buf)
16250     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>16251     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
16252         unimplemented!("Rust legacy does not implement full packet trait")
16253     }
16254 }
16255 impl TryFrom<SessionGetStateRsp> for Bytes {
16256     type Error = EncodeError;
try_from(packet: SessionGetStateRsp) -> Result<Self, Self::Error>16257     fn try_from(packet: SessionGetStateRsp) -> Result<Self, Self::Error> {
16258         packet.encode_to_bytes()
16259     }
16260 }
16261 impl TryFrom<SessionGetStateRsp> for Vec<u8> {
16262     type Error = EncodeError;
try_from(packet: SessionGetStateRsp) -> Result<Self, Self::Error>16263     fn try_from(packet: SessionGetStateRsp) -> Result<Self, Self::Error> {
16264         packet.encode_to_vec()
16265     }
16266 }
16267 impl From<SessionGetStateRsp> for UciControlPacket {
from(packet: SessionGetStateRsp) -> UciControlPacket16268     fn from(packet: SessionGetStateRsp) -> UciControlPacket {
16269         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
16270     }
16271 }
16272 impl From<SessionGetStateRsp> for UciResponse {
from(packet: SessionGetStateRsp) -> UciResponse16273     fn from(packet: SessionGetStateRsp) -> UciResponse {
16274         UciResponse::new(packet.ucicontrolpacket).unwrap()
16275     }
16276 }
16277 impl From<SessionGetStateRsp> for SessionConfigResponse {
from(packet: SessionGetStateRsp) -> SessionConfigResponse16278     fn from(packet: SessionGetStateRsp) -> SessionConfigResponse {
16279         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
16280     }
16281 }
16282 impl TryFrom<UciControlPacket> for SessionGetStateRsp {
16283     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionGetStateRsp, Self::Error>16284     fn try_from(packet: UciControlPacket) -> Result<SessionGetStateRsp, Self::Error> {
16285         SessionGetStateRsp::new(packet.ucicontrolpacket)
16286     }
16287 }
16288 impl SessionGetStateRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>16289     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
16290         let mut cell = Cell::new(bytes);
16291         let packet = Self::parse_inner(&mut cell)?;
16292         Ok(packet)
16293     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>16294     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
16295         let data = UciControlPacketData::parse_inner(&mut bytes)?;
16296         Self::new(data)
16297     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>16298     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
16299         let uciresponse = match &ucicontrolpacket.child {
16300             UciControlPacketDataChild::UciResponse(value) => value.clone(),
16301             _ => {
16302                 return Err(DecodeError::InvalidChildError {
16303                     expected: stringify!(UciControlPacketDataChild::UciResponse),
16304                     actual: format!("{:?}", & ucicontrolpacket.child),
16305                 });
16306             }
16307         };
16308         let sessionconfigresponse = match &uciresponse.child {
16309             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
16310             _ => {
16311                 return Err(DecodeError::InvalidChildError {
16312                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
16313                     actual: format!("{:?}", & uciresponse.child),
16314                 });
16315             }
16316         };
16317         let sessiongetstatersp = match &sessionconfigresponse.child {
16318             SessionConfigResponseDataChild::SessionGetStateRsp(value) => value.clone(),
16319             _ => {
16320                 return Err(DecodeError::InvalidChildError {
16321                     expected: stringify!(
16322                         SessionConfigResponseDataChild::SessionGetStateRsp
16323                     ),
16324                     actual: format!("{:?}", & sessionconfigresponse.child),
16325                 });
16326             }
16327         };
16328         Ok(Self {
16329             ucicontrolpacket,
16330             uciresponse,
16331             sessionconfigresponse,
16332             sessiongetstatersp,
16333         })
16334     }
get_group_id(&self) -> GroupId16335     pub fn get_group_id(&self) -> GroupId {
16336         self.ucicontrolpacket.group_id
16337     }
get_message_type(&self) -> MessageType16338     pub fn get_message_type(&self) -> MessageType {
16339         self.ucicontrolpacket.message_type
16340     }
get_opcode(&self) -> u816341     pub fn get_opcode(&self) -> u8 {
16342         self.ucicontrolpacket.opcode
16343     }
get_session_state(&self) -> SessionState16344     pub fn get_session_state(&self) -> SessionState {
16345         self.sessiongetstatersp.session_state
16346     }
get_status(&self) -> StatusCode16347     pub fn get_status(&self) -> StatusCode {
16348         self.sessiongetstatersp.status
16349     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>16350     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
16351         self.sessiongetstatersp.write_to(buffer)
16352     }
get_size(&self) -> usize16353     pub fn get_size(&self) -> usize {
16354         self.ucicontrolpacket.get_size()
16355     }
16356 }
16357 impl SessionGetStateRspBuilder {
build(self) -> SessionGetStateRsp16358     pub fn build(self) -> SessionGetStateRsp {
16359         let sessiongetstatersp = SessionGetStateRspData {
16360             session_state: self.session_state,
16361             status: self.status,
16362         };
16363         let sessionconfigresponse = SessionConfigResponseData {
16364             child: SessionConfigResponseDataChild::SessionGetStateRsp(sessiongetstatersp),
16365         };
16366         let uciresponse = UciResponseData {
16367             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
16368         };
16369         let ucicontrolpacket = UciControlPacketData {
16370             group_id: GroupId::SessionConfig,
16371             message_type: MessageType::Response,
16372             opcode: 6,
16373             child: UciControlPacketDataChild::UciResponse(uciresponse),
16374         };
16375         SessionGetStateRsp::new(ucicontrolpacket).unwrap()
16376     }
16377 }
16378 impl From<SessionGetStateRspBuilder> for UciControlPacket {
from(builder: SessionGetStateRspBuilder) -> UciControlPacket16379     fn from(builder: SessionGetStateRspBuilder) -> UciControlPacket {
16380         builder.build().into()
16381     }
16382 }
16383 impl From<SessionGetStateRspBuilder> for UciResponse {
from(builder: SessionGetStateRspBuilder) -> UciResponse16384     fn from(builder: SessionGetStateRspBuilder) -> UciResponse {
16385         builder.build().into()
16386     }
16387 }
16388 impl From<SessionGetStateRspBuilder> for SessionConfigResponse {
from(builder: SessionGetStateRspBuilder) -> SessionConfigResponse16389     fn from(builder: SessionGetStateRspBuilder) -> SessionConfigResponse {
16390         builder.build().into()
16391     }
16392 }
16393 impl From<SessionGetStateRspBuilder> for SessionGetStateRsp {
from(builder: SessionGetStateRspBuilder) -> SessionGetStateRsp16394     fn from(builder: SessionGetStateRspBuilder) -> SessionGetStateRsp {
16395         builder.build().into()
16396     }
16397 }
16398 #[derive(Debug, Clone, PartialEq, Eq)]
16399 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16400 pub struct SessionUpdateDtTagRangingRoundsCmdData {
16401     session_token: u32,
16402     ranging_round_indexes: Vec<u8>,
16403 }
16404 #[derive(Debug, Clone, PartialEq, Eq)]
16405 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16406 pub struct SessionUpdateDtTagRangingRoundsCmd {
16407     #[cfg_attr(feature = "serde", serde(flatten))]
16408     ucicontrolpacket: UciControlPacketData,
16409     #[cfg_attr(feature = "serde", serde(flatten))]
16410     ucicommand: UciCommandData,
16411     #[cfg_attr(feature = "serde", serde(flatten))]
16412     sessionconfigcommand: SessionConfigCommandData,
16413     #[cfg_attr(feature = "serde", serde(flatten))]
16414     sessionupdatedttagrangingroundscmd: SessionUpdateDtTagRangingRoundsCmdData,
16415 }
16416 #[derive(Debug)]
16417 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16418 pub struct SessionUpdateDtTagRangingRoundsCmdBuilder {
16419     pub ranging_round_indexes: Vec<u8>,
16420     pub session_token: u32,
16421 }
16422 impl SessionUpdateDtTagRangingRoundsCmdData {
conforms(bytes: &[u8]) -> bool16423     fn conforms(bytes: &[u8]) -> bool {
16424         bytes.len() >= 5
16425     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>16426     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
16427         let mut cell = Cell::new(bytes);
16428         let packet = Self::parse_inner(&mut cell)?;
16429         Ok(packet)
16430     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>16431     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
16432         if bytes.get().remaining() < 4 {
16433             return Err(DecodeError::InvalidLengthError {
16434                 obj: "SessionUpdateDtTagRangingRoundsCmd",
16435                 wanted: 4,
16436                 got: bytes.get().remaining(),
16437             });
16438         }
16439         let session_token = bytes.get_mut().get_u32_le();
16440         if bytes.get().remaining() < 1 {
16441             return Err(DecodeError::InvalidLengthError {
16442                 obj: "SessionUpdateDtTagRangingRoundsCmd",
16443                 wanted: 1,
16444                 got: bytes.get().remaining(),
16445             });
16446         }
16447         let ranging_round_indexes_count = bytes.get_mut().get_u8() as usize;
16448         if bytes.get().remaining() < ranging_round_indexes_count * 1usize {
16449             return Err(DecodeError::InvalidLengthError {
16450                 obj: "SessionUpdateDtTagRangingRoundsCmd",
16451                 wanted: ranging_round_indexes_count * 1usize,
16452                 got: bytes.get().remaining(),
16453             });
16454         }
16455         let ranging_round_indexes = (0..ranging_round_indexes_count)
16456             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
16457             .collect::<Result<Vec<_>, DecodeError>>()?;
16458         Ok(Self {
16459             session_token,
16460             ranging_round_indexes,
16461         })
16462     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>16463     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
16464         buffer.put_u32_le(self.session_token);
16465         buffer.put_u8(self.ranging_round_indexes.len() as u8);
16466         for elem in &self.ranging_round_indexes {
16467             buffer.put_u8(*elem);
16468         }
16469         Ok(())
16470     }
get_total_size(&self) -> usize16471     fn get_total_size(&self) -> usize {
16472         self.get_size()
16473     }
get_size(&self) -> usize16474     fn get_size(&self) -> usize {
16475         5 + self.ranging_round_indexes.len()
16476     }
16477 }
16478 impl Packet for SessionUpdateDtTagRangingRoundsCmd {
encoded_len(&self) -> usize16479     fn encoded_len(&self) -> usize {
16480         self.get_size()
16481     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>16482     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
16483         self.ucicontrolpacket.write_to(buf)
16484     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>16485     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
16486         unimplemented!("Rust legacy does not implement full packet trait")
16487     }
16488 }
16489 impl TryFrom<SessionUpdateDtTagRangingRoundsCmd> for Bytes {
16490     type Error = EncodeError;
try_from( packet: SessionUpdateDtTagRangingRoundsCmd, ) -> Result<Self, Self::Error>16491     fn try_from(
16492         packet: SessionUpdateDtTagRangingRoundsCmd,
16493     ) -> Result<Self, Self::Error> {
16494         packet.encode_to_bytes()
16495     }
16496 }
16497 impl TryFrom<SessionUpdateDtTagRangingRoundsCmd> for Vec<u8> {
16498     type Error = EncodeError;
try_from( packet: SessionUpdateDtTagRangingRoundsCmd, ) -> Result<Self, Self::Error>16499     fn try_from(
16500         packet: SessionUpdateDtTagRangingRoundsCmd,
16501     ) -> Result<Self, Self::Error> {
16502         packet.encode_to_vec()
16503     }
16504 }
16505 impl From<SessionUpdateDtTagRangingRoundsCmd> for UciControlPacket {
from(packet: SessionUpdateDtTagRangingRoundsCmd) -> UciControlPacket16506     fn from(packet: SessionUpdateDtTagRangingRoundsCmd) -> UciControlPacket {
16507         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
16508     }
16509 }
16510 impl From<SessionUpdateDtTagRangingRoundsCmd> for UciCommand {
from(packet: SessionUpdateDtTagRangingRoundsCmd) -> UciCommand16511     fn from(packet: SessionUpdateDtTagRangingRoundsCmd) -> UciCommand {
16512         UciCommand::new(packet.ucicontrolpacket).unwrap()
16513     }
16514 }
16515 impl From<SessionUpdateDtTagRangingRoundsCmd> for SessionConfigCommand {
from(packet: SessionUpdateDtTagRangingRoundsCmd) -> SessionConfigCommand16516     fn from(packet: SessionUpdateDtTagRangingRoundsCmd) -> SessionConfigCommand {
16517         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
16518     }
16519 }
16520 impl TryFrom<UciControlPacket> for SessionUpdateDtTagRangingRoundsCmd {
16521     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionUpdateDtTagRangingRoundsCmd, Self::Error>16522     fn try_from(
16523         packet: UciControlPacket,
16524     ) -> Result<SessionUpdateDtTagRangingRoundsCmd, Self::Error> {
16525         SessionUpdateDtTagRangingRoundsCmd::new(packet.ucicontrolpacket)
16526     }
16527 }
16528 impl SessionUpdateDtTagRangingRoundsCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>16529     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
16530         let mut cell = Cell::new(bytes);
16531         let packet = Self::parse_inner(&mut cell)?;
16532         Ok(packet)
16533     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>16534     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
16535         let data = UciControlPacketData::parse_inner(&mut bytes)?;
16536         Self::new(data)
16537     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>16538     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
16539         let ucicommand = match &ucicontrolpacket.child {
16540             UciControlPacketDataChild::UciCommand(value) => value.clone(),
16541             _ => {
16542                 return Err(DecodeError::InvalidChildError {
16543                     expected: stringify!(UciControlPacketDataChild::UciCommand),
16544                     actual: format!("{:?}", & ucicontrolpacket.child),
16545                 });
16546             }
16547         };
16548         let sessionconfigcommand = match &ucicommand.child {
16549             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
16550             _ => {
16551                 return Err(DecodeError::InvalidChildError {
16552                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
16553                     actual: format!("{:?}", & ucicommand.child),
16554                 });
16555             }
16556         };
16557         let sessionupdatedttagrangingroundscmd = match &sessionconfigcommand.child {
16558             SessionConfigCommandDataChild::SessionUpdateDtTagRangingRoundsCmd(value) => {
16559                 value.clone()
16560             }
16561             _ => {
16562                 return Err(DecodeError::InvalidChildError {
16563                     expected: stringify!(
16564                         SessionConfigCommandDataChild::SessionUpdateDtTagRangingRoundsCmd
16565                     ),
16566                     actual: format!("{:?}", & sessionconfigcommand.child),
16567                 });
16568             }
16569         };
16570         Ok(Self {
16571             ucicontrolpacket,
16572             ucicommand,
16573             sessionconfigcommand,
16574             sessionupdatedttagrangingroundscmd,
16575         })
16576     }
get_group_id(&self) -> GroupId16577     pub fn get_group_id(&self) -> GroupId {
16578         self.ucicontrolpacket.group_id
16579     }
get_message_type(&self) -> MessageType16580     pub fn get_message_type(&self) -> MessageType {
16581         self.ucicontrolpacket.message_type
16582     }
get_opcode(&self) -> u816583     pub fn get_opcode(&self) -> u8 {
16584         self.ucicontrolpacket.opcode
16585     }
get_ranging_round_indexes(&self) -> &Vec<u8>16586     pub fn get_ranging_round_indexes(&self) -> &Vec<u8> {
16587         &self.sessionupdatedttagrangingroundscmd.ranging_round_indexes
16588     }
get_session_token(&self) -> u3216589     pub fn get_session_token(&self) -> u32 {
16590         self.sessionupdatedttagrangingroundscmd.session_token
16591     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>16592     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
16593         self.sessionupdatedttagrangingroundscmd.write_to(buffer)
16594     }
get_size(&self) -> usize16595     pub fn get_size(&self) -> usize {
16596         self.ucicontrolpacket.get_size()
16597     }
16598 }
16599 impl SessionUpdateDtTagRangingRoundsCmdBuilder {
build(self) -> SessionUpdateDtTagRangingRoundsCmd16600     pub fn build(self) -> SessionUpdateDtTagRangingRoundsCmd {
16601         let sessionupdatedttagrangingroundscmd = SessionUpdateDtTagRangingRoundsCmdData {
16602             ranging_round_indexes: self.ranging_round_indexes,
16603             session_token: self.session_token,
16604         };
16605         let sessionconfigcommand = SessionConfigCommandData {
16606             child: SessionConfigCommandDataChild::SessionUpdateDtTagRangingRoundsCmd(
16607                 sessionupdatedttagrangingroundscmd,
16608             ),
16609         };
16610         let ucicommand = UciCommandData {
16611             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
16612         };
16613         let ucicontrolpacket = UciControlPacketData {
16614             group_id: GroupId::SessionConfig,
16615             message_type: MessageType::Command,
16616             opcode: 9,
16617             child: UciControlPacketDataChild::UciCommand(ucicommand),
16618         };
16619         SessionUpdateDtTagRangingRoundsCmd::new(ucicontrolpacket).unwrap()
16620     }
16621 }
16622 impl From<SessionUpdateDtTagRangingRoundsCmdBuilder> for UciControlPacket {
from(builder: SessionUpdateDtTagRangingRoundsCmdBuilder) -> UciControlPacket16623     fn from(builder: SessionUpdateDtTagRangingRoundsCmdBuilder) -> UciControlPacket {
16624         builder.build().into()
16625     }
16626 }
16627 impl From<SessionUpdateDtTagRangingRoundsCmdBuilder> for UciCommand {
from(builder: SessionUpdateDtTagRangingRoundsCmdBuilder) -> UciCommand16628     fn from(builder: SessionUpdateDtTagRangingRoundsCmdBuilder) -> UciCommand {
16629         builder.build().into()
16630     }
16631 }
16632 impl From<SessionUpdateDtTagRangingRoundsCmdBuilder> for SessionConfigCommand {
from(builder: SessionUpdateDtTagRangingRoundsCmdBuilder) -> SessionConfigCommand16633     fn from(builder: SessionUpdateDtTagRangingRoundsCmdBuilder) -> SessionConfigCommand {
16634         builder.build().into()
16635     }
16636 }
16637 impl From<SessionUpdateDtTagRangingRoundsCmdBuilder>
16638 for SessionUpdateDtTagRangingRoundsCmd {
from( builder: SessionUpdateDtTagRangingRoundsCmdBuilder, ) -> SessionUpdateDtTagRangingRoundsCmd16639     fn from(
16640         builder: SessionUpdateDtTagRangingRoundsCmdBuilder,
16641     ) -> SessionUpdateDtTagRangingRoundsCmd {
16642         builder.build().into()
16643     }
16644 }
16645 #[derive(Debug, Clone, PartialEq, Eq)]
16646 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16647 pub struct SessionUpdateDtTagRangingRoundsRspData {
16648     status: StatusCode,
16649     ranging_round_indexes: Vec<u8>,
16650 }
16651 #[derive(Debug, Clone, PartialEq, Eq)]
16652 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16653 pub struct SessionUpdateDtTagRangingRoundsRsp {
16654     #[cfg_attr(feature = "serde", serde(flatten))]
16655     ucicontrolpacket: UciControlPacketData,
16656     #[cfg_attr(feature = "serde", serde(flatten))]
16657     uciresponse: UciResponseData,
16658     #[cfg_attr(feature = "serde", serde(flatten))]
16659     sessionconfigresponse: SessionConfigResponseData,
16660     #[cfg_attr(feature = "serde", serde(flatten))]
16661     sessionupdatedttagrangingroundsrsp: SessionUpdateDtTagRangingRoundsRspData,
16662 }
16663 #[derive(Debug)]
16664 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16665 pub struct SessionUpdateDtTagRangingRoundsRspBuilder {
16666     pub ranging_round_indexes: Vec<u8>,
16667     pub status: StatusCode,
16668 }
16669 impl SessionUpdateDtTagRangingRoundsRspData {
conforms(bytes: &[u8]) -> bool16670     fn conforms(bytes: &[u8]) -> bool {
16671         bytes.len() >= 2
16672     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>16673     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
16674         let mut cell = Cell::new(bytes);
16675         let packet = Self::parse_inner(&mut cell)?;
16676         Ok(packet)
16677     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>16678     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
16679         if bytes.get().remaining() < 1 {
16680             return Err(DecodeError::InvalidLengthError {
16681                 obj: "SessionUpdateDtTagRangingRoundsRsp",
16682                 wanted: 1,
16683                 got: bytes.get().remaining(),
16684             });
16685         }
16686         let status = StatusCode::try_from(bytes.get_mut().get_u8())
16687             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
16688                 obj: "SessionUpdateDtTagRangingRoundsRsp",
16689                 field: "status",
16690                 value: unknown_val as u64,
16691                 type_: "StatusCode",
16692             })?;
16693         if bytes.get().remaining() < 1 {
16694             return Err(DecodeError::InvalidLengthError {
16695                 obj: "SessionUpdateDtTagRangingRoundsRsp",
16696                 wanted: 1,
16697                 got: bytes.get().remaining(),
16698             });
16699         }
16700         let ranging_round_indexes_count = bytes.get_mut().get_u8() as usize;
16701         if bytes.get().remaining() < ranging_round_indexes_count * 1usize {
16702             return Err(DecodeError::InvalidLengthError {
16703                 obj: "SessionUpdateDtTagRangingRoundsRsp",
16704                 wanted: ranging_round_indexes_count * 1usize,
16705                 got: bytes.get().remaining(),
16706             });
16707         }
16708         let ranging_round_indexes = (0..ranging_round_indexes_count)
16709             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
16710             .collect::<Result<Vec<_>, DecodeError>>()?;
16711         Ok(Self {
16712             status,
16713             ranging_round_indexes,
16714         })
16715     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>16716     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
16717         buffer.put_u8(u8::from(self.status));
16718         buffer.put_u8(self.ranging_round_indexes.len() as u8);
16719         for elem in &self.ranging_round_indexes {
16720             buffer.put_u8(*elem);
16721         }
16722         Ok(())
16723     }
get_total_size(&self) -> usize16724     fn get_total_size(&self) -> usize {
16725         self.get_size()
16726     }
get_size(&self) -> usize16727     fn get_size(&self) -> usize {
16728         2 + self.ranging_round_indexes.len()
16729     }
16730 }
16731 impl Packet for SessionUpdateDtTagRangingRoundsRsp {
encoded_len(&self) -> usize16732     fn encoded_len(&self) -> usize {
16733         self.get_size()
16734     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>16735     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
16736         self.ucicontrolpacket.write_to(buf)
16737     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>16738     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
16739         unimplemented!("Rust legacy does not implement full packet trait")
16740     }
16741 }
16742 impl TryFrom<SessionUpdateDtTagRangingRoundsRsp> for Bytes {
16743     type Error = EncodeError;
try_from( packet: SessionUpdateDtTagRangingRoundsRsp, ) -> Result<Self, Self::Error>16744     fn try_from(
16745         packet: SessionUpdateDtTagRangingRoundsRsp,
16746     ) -> Result<Self, Self::Error> {
16747         packet.encode_to_bytes()
16748     }
16749 }
16750 impl TryFrom<SessionUpdateDtTagRangingRoundsRsp> for Vec<u8> {
16751     type Error = EncodeError;
try_from( packet: SessionUpdateDtTagRangingRoundsRsp, ) -> Result<Self, Self::Error>16752     fn try_from(
16753         packet: SessionUpdateDtTagRangingRoundsRsp,
16754     ) -> Result<Self, Self::Error> {
16755         packet.encode_to_vec()
16756     }
16757 }
16758 impl From<SessionUpdateDtTagRangingRoundsRsp> for UciControlPacket {
from(packet: SessionUpdateDtTagRangingRoundsRsp) -> UciControlPacket16759     fn from(packet: SessionUpdateDtTagRangingRoundsRsp) -> UciControlPacket {
16760         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
16761     }
16762 }
16763 impl From<SessionUpdateDtTagRangingRoundsRsp> for UciResponse {
from(packet: SessionUpdateDtTagRangingRoundsRsp) -> UciResponse16764     fn from(packet: SessionUpdateDtTagRangingRoundsRsp) -> UciResponse {
16765         UciResponse::new(packet.ucicontrolpacket).unwrap()
16766     }
16767 }
16768 impl From<SessionUpdateDtTagRangingRoundsRsp> for SessionConfigResponse {
from(packet: SessionUpdateDtTagRangingRoundsRsp) -> SessionConfigResponse16769     fn from(packet: SessionUpdateDtTagRangingRoundsRsp) -> SessionConfigResponse {
16770         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
16771     }
16772 }
16773 impl TryFrom<UciControlPacket> for SessionUpdateDtTagRangingRoundsRsp {
16774     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionUpdateDtTagRangingRoundsRsp, Self::Error>16775     fn try_from(
16776         packet: UciControlPacket,
16777     ) -> Result<SessionUpdateDtTagRangingRoundsRsp, Self::Error> {
16778         SessionUpdateDtTagRangingRoundsRsp::new(packet.ucicontrolpacket)
16779     }
16780 }
16781 impl SessionUpdateDtTagRangingRoundsRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>16782     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
16783         let mut cell = Cell::new(bytes);
16784         let packet = Self::parse_inner(&mut cell)?;
16785         Ok(packet)
16786     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>16787     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
16788         let data = UciControlPacketData::parse_inner(&mut bytes)?;
16789         Self::new(data)
16790     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>16791     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
16792         let uciresponse = match &ucicontrolpacket.child {
16793             UciControlPacketDataChild::UciResponse(value) => value.clone(),
16794             _ => {
16795                 return Err(DecodeError::InvalidChildError {
16796                     expected: stringify!(UciControlPacketDataChild::UciResponse),
16797                     actual: format!("{:?}", & ucicontrolpacket.child),
16798                 });
16799             }
16800         };
16801         let sessionconfigresponse = match &uciresponse.child {
16802             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
16803             _ => {
16804                 return Err(DecodeError::InvalidChildError {
16805                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
16806                     actual: format!("{:?}", & uciresponse.child),
16807                 });
16808             }
16809         };
16810         let sessionupdatedttagrangingroundsrsp = match &sessionconfigresponse.child {
16811             SessionConfigResponseDataChild::SessionUpdateDtTagRangingRoundsRsp(value) => {
16812                 value.clone()
16813             }
16814             _ => {
16815                 return Err(DecodeError::InvalidChildError {
16816                     expected: stringify!(
16817                         SessionConfigResponseDataChild::SessionUpdateDtTagRangingRoundsRsp
16818                     ),
16819                     actual: format!("{:?}", & sessionconfigresponse.child),
16820                 });
16821             }
16822         };
16823         Ok(Self {
16824             ucicontrolpacket,
16825             uciresponse,
16826             sessionconfigresponse,
16827             sessionupdatedttagrangingroundsrsp,
16828         })
16829     }
get_group_id(&self) -> GroupId16830     pub fn get_group_id(&self) -> GroupId {
16831         self.ucicontrolpacket.group_id
16832     }
get_message_type(&self) -> MessageType16833     pub fn get_message_type(&self) -> MessageType {
16834         self.ucicontrolpacket.message_type
16835     }
get_opcode(&self) -> u816836     pub fn get_opcode(&self) -> u8 {
16837         self.ucicontrolpacket.opcode
16838     }
get_ranging_round_indexes(&self) -> &Vec<u8>16839     pub fn get_ranging_round_indexes(&self) -> &Vec<u8> {
16840         &self.sessionupdatedttagrangingroundsrsp.ranging_round_indexes
16841     }
get_status(&self) -> StatusCode16842     pub fn get_status(&self) -> StatusCode {
16843         self.sessionupdatedttagrangingroundsrsp.status
16844     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>16845     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
16846         self.sessionupdatedttagrangingroundsrsp.write_to(buffer)
16847     }
get_size(&self) -> usize16848     pub fn get_size(&self) -> usize {
16849         self.ucicontrolpacket.get_size()
16850     }
16851 }
16852 impl SessionUpdateDtTagRangingRoundsRspBuilder {
build(self) -> SessionUpdateDtTagRangingRoundsRsp16853     pub fn build(self) -> SessionUpdateDtTagRangingRoundsRsp {
16854         let sessionupdatedttagrangingroundsrsp = SessionUpdateDtTagRangingRoundsRspData {
16855             ranging_round_indexes: self.ranging_round_indexes,
16856             status: self.status,
16857         };
16858         let sessionconfigresponse = SessionConfigResponseData {
16859             child: SessionConfigResponseDataChild::SessionUpdateDtTagRangingRoundsRsp(
16860                 sessionupdatedttagrangingroundsrsp,
16861             ),
16862         };
16863         let uciresponse = UciResponseData {
16864             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
16865         };
16866         let ucicontrolpacket = UciControlPacketData {
16867             group_id: GroupId::SessionConfig,
16868             message_type: MessageType::Response,
16869             opcode: 9,
16870             child: UciControlPacketDataChild::UciResponse(uciresponse),
16871         };
16872         SessionUpdateDtTagRangingRoundsRsp::new(ucicontrolpacket).unwrap()
16873     }
16874 }
16875 impl From<SessionUpdateDtTagRangingRoundsRspBuilder> for UciControlPacket {
from(builder: SessionUpdateDtTagRangingRoundsRspBuilder) -> UciControlPacket16876     fn from(builder: SessionUpdateDtTagRangingRoundsRspBuilder) -> UciControlPacket {
16877         builder.build().into()
16878     }
16879 }
16880 impl From<SessionUpdateDtTagRangingRoundsRspBuilder> for UciResponse {
from(builder: SessionUpdateDtTagRangingRoundsRspBuilder) -> UciResponse16881     fn from(builder: SessionUpdateDtTagRangingRoundsRspBuilder) -> UciResponse {
16882         builder.build().into()
16883     }
16884 }
16885 impl From<SessionUpdateDtTagRangingRoundsRspBuilder> for SessionConfigResponse {
from( builder: SessionUpdateDtTagRangingRoundsRspBuilder, ) -> SessionConfigResponse16886     fn from(
16887         builder: SessionUpdateDtTagRangingRoundsRspBuilder,
16888     ) -> SessionConfigResponse {
16889         builder.build().into()
16890     }
16891 }
16892 impl From<SessionUpdateDtTagRangingRoundsRspBuilder>
16893 for SessionUpdateDtTagRangingRoundsRsp {
from( builder: SessionUpdateDtTagRangingRoundsRspBuilder, ) -> SessionUpdateDtTagRangingRoundsRsp16894     fn from(
16895         builder: SessionUpdateDtTagRangingRoundsRspBuilder,
16896     ) -> SessionUpdateDtTagRangingRoundsRsp {
16897         builder.build().into()
16898     }
16899 }
16900 #[derive(Debug, Clone, PartialEq, Eq)]
16901 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16902 pub struct Controlee {
16903     pub short_address: [u8; 2],
16904     pub subsession_id: u32,
16905 }
16906 impl Controlee {
conforms(bytes: &[u8]) -> bool16907     fn conforms(bytes: &[u8]) -> bool {
16908         bytes.len() >= 6
16909     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>16910     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
16911         let mut cell = Cell::new(bytes);
16912         let packet = Self::parse_inner(&mut cell)?;
16913         Ok(packet)
16914     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>16915     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
16916         if bytes.get().remaining() < 2 {
16917             return Err(DecodeError::InvalidLengthError {
16918                 obj: "Controlee",
16919                 wanted: 2,
16920                 got: bytes.get().remaining(),
16921             });
16922         }
16923         let short_address = (0..2)
16924             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
16925             .collect::<Result<Vec<_>, DecodeError>>()?
16926             .try_into()
16927             .map_err(|_| DecodeError::InvalidPacketError)?;
16928         if bytes.get().remaining() < 4 {
16929             return Err(DecodeError::InvalidLengthError {
16930                 obj: "Controlee",
16931                 wanted: 4,
16932                 got: bytes.get().remaining(),
16933             });
16934         }
16935         let subsession_id = bytes.get_mut().get_u32_le();
16936         Ok(Self {
16937             short_address,
16938             subsession_id,
16939         })
16940     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>16941     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
16942         for elem in &self.short_address {
16943             buffer.put_u8(*elem);
16944         }
16945         buffer.put_u32_le(self.subsession_id);
16946         Ok(())
16947     }
get_total_size(&self) -> usize16948     fn get_total_size(&self) -> usize {
16949         self.get_size()
16950     }
get_size(&self) -> usize16951     fn get_size(&self) -> usize {
16952         6
16953     }
16954 }
16955 #[derive(Debug, Clone, PartialEq, Eq)]
16956 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
16957 pub struct Controlee_V2_0_16_Byte_Version {
16958     pub short_address: [u8; 2],
16959     pub subsession_id: u32,
16960     pub subsession_key: [u8; 16],
16961 }
16962 impl Controlee_V2_0_16_Byte_Version {
conforms(bytes: &[u8]) -> bool16963     fn conforms(bytes: &[u8]) -> bool {
16964         bytes.len() >= 22
16965     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>16966     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
16967         let mut cell = Cell::new(bytes);
16968         let packet = Self::parse_inner(&mut cell)?;
16969         Ok(packet)
16970     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>16971     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
16972         if bytes.get().remaining() < 2 {
16973             return Err(DecodeError::InvalidLengthError {
16974                 obj: "Controlee_V2_0_16_Byte_Version",
16975                 wanted: 2,
16976                 got: bytes.get().remaining(),
16977             });
16978         }
16979         let short_address = (0..2)
16980             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
16981             .collect::<Result<Vec<_>, DecodeError>>()?
16982             .try_into()
16983             .map_err(|_| DecodeError::InvalidPacketError)?;
16984         if bytes.get().remaining() < 4 {
16985             return Err(DecodeError::InvalidLengthError {
16986                 obj: "Controlee_V2_0_16_Byte_Version",
16987                 wanted: 4,
16988                 got: bytes.get().remaining(),
16989             });
16990         }
16991         let subsession_id = bytes.get_mut().get_u32_le();
16992         if bytes.get().remaining() < 16 {
16993             return Err(DecodeError::InvalidLengthError {
16994                 obj: "Controlee_V2_0_16_Byte_Version",
16995                 wanted: 16,
16996                 got: bytes.get().remaining(),
16997             });
16998         }
16999         let subsession_key = (0..16)
17000             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
17001             .collect::<Result<Vec<_>, DecodeError>>()?
17002             .try_into()
17003             .map_err(|_| DecodeError::InvalidPacketError)?;
17004         Ok(Self {
17005             short_address,
17006             subsession_id,
17007             subsession_key,
17008         })
17009     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>17010     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
17011         for elem in &self.short_address {
17012             buffer.put_u8(*elem);
17013         }
17014         buffer.put_u32_le(self.subsession_id);
17015         for elem in &self.subsession_key {
17016             buffer.put_u8(*elem);
17017         }
17018         Ok(())
17019     }
get_total_size(&self) -> usize17020     fn get_total_size(&self) -> usize {
17021         self.get_size()
17022     }
get_size(&self) -> usize17023     fn get_size(&self) -> usize {
17024         22
17025     }
17026 }
17027 #[derive(Debug, Clone, PartialEq, Eq)]
17028 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17029 pub struct Controlee_V2_0_32_Byte_Version {
17030     pub short_address: [u8; 2],
17031     pub subsession_id: u32,
17032     pub subsession_key: [u8; 32],
17033 }
17034 impl Controlee_V2_0_32_Byte_Version {
conforms(bytes: &[u8]) -> bool17035     fn conforms(bytes: &[u8]) -> bool {
17036         bytes.len() >= 38
17037     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>17038     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
17039         let mut cell = Cell::new(bytes);
17040         let packet = Self::parse_inner(&mut cell)?;
17041         Ok(packet)
17042     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>17043     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
17044         if bytes.get().remaining() < 2 {
17045             return Err(DecodeError::InvalidLengthError {
17046                 obj: "Controlee_V2_0_32_Byte_Version",
17047                 wanted: 2,
17048                 got: bytes.get().remaining(),
17049             });
17050         }
17051         let short_address = (0..2)
17052             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
17053             .collect::<Result<Vec<_>, DecodeError>>()?
17054             .try_into()
17055             .map_err(|_| DecodeError::InvalidPacketError)?;
17056         if bytes.get().remaining() < 4 {
17057             return Err(DecodeError::InvalidLengthError {
17058                 obj: "Controlee_V2_0_32_Byte_Version",
17059                 wanted: 4,
17060                 got: bytes.get().remaining(),
17061             });
17062         }
17063         let subsession_id = bytes.get_mut().get_u32_le();
17064         if bytes.get().remaining() < 32 {
17065             return Err(DecodeError::InvalidLengthError {
17066                 obj: "Controlee_V2_0_32_Byte_Version",
17067                 wanted: 32,
17068                 got: bytes.get().remaining(),
17069             });
17070         }
17071         let subsession_key = (0..32)
17072             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
17073             .collect::<Result<Vec<_>, DecodeError>>()?
17074             .try_into()
17075             .map_err(|_| DecodeError::InvalidPacketError)?;
17076         Ok(Self {
17077             short_address,
17078             subsession_id,
17079             subsession_key,
17080         })
17081     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>17082     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
17083         for elem in &self.short_address {
17084             buffer.put_u8(*elem);
17085         }
17086         buffer.put_u32_le(self.subsession_id);
17087         for elem in &self.subsession_key {
17088             buffer.put_u8(*elem);
17089         }
17090         Ok(())
17091     }
get_total_size(&self) -> usize17092     fn get_total_size(&self) -> usize {
17093         self.get_size()
17094     }
get_size(&self) -> usize17095     fn get_size(&self) -> usize {
17096         38
17097     }
17098 }
17099 #[repr(u64)]
17100 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
17101 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17102 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
17103 pub enum UpdateMulticastListAction {
17104     AddControlee = 0x0,
17105     RemoveControlee = 0x1,
17106     AddControleeWithShortSubSessionKey = 0x2,
17107     AddControleeWithLongSubSessionKey = 0x3,
17108 }
17109 impl TryFrom<u8> for UpdateMulticastListAction {
17110     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>17111     fn try_from(value: u8) -> Result<Self, Self::Error> {
17112         match value {
17113             0x0 => Ok(UpdateMulticastListAction::AddControlee),
17114             0x1 => Ok(UpdateMulticastListAction::RemoveControlee),
17115             0x2 => Ok(UpdateMulticastListAction::AddControleeWithShortSubSessionKey),
17116             0x3 => Ok(UpdateMulticastListAction::AddControleeWithLongSubSessionKey),
17117             _ => Err(value),
17118         }
17119     }
17120 }
17121 impl From<&UpdateMulticastListAction> for u8 {
from(value: &UpdateMulticastListAction) -> Self17122     fn from(value: &UpdateMulticastListAction) -> Self {
17123         match value {
17124             UpdateMulticastListAction::AddControlee => 0x0,
17125             UpdateMulticastListAction::RemoveControlee => 0x1,
17126             UpdateMulticastListAction::AddControleeWithShortSubSessionKey => 0x2,
17127             UpdateMulticastListAction::AddControleeWithLongSubSessionKey => 0x3,
17128         }
17129     }
17130 }
17131 impl From<UpdateMulticastListAction> for u8 {
from(value: UpdateMulticastListAction) -> Self17132     fn from(value: UpdateMulticastListAction) -> Self {
17133         (&value).into()
17134     }
17135 }
17136 impl From<UpdateMulticastListAction> for i16 {
from(value: UpdateMulticastListAction) -> Self17137     fn from(value: UpdateMulticastListAction) -> Self {
17138         u8::from(value) as Self
17139     }
17140 }
17141 impl From<UpdateMulticastListAction> for i32 {
from(value: UpdateMulticastListAction) -> Self17142     fn from(value: UpdateMulticastListAction) -> Self {
17143         u8::from(value) as Self
17144     }
17145 }
17146 impl From<UpdateMulticastListAction> for i64 {
from(value: UpdateMulticastListAction) -> Self17147     fn from(value: UpdateMulticastListAction) -> Self {
17148         u8::from(value) as Self
17149     }
17150 }
17151 impl From<UpdateMulticastListAction> for u16 {
from(value: UpdateMulticastListAction) -> Self17152     fn from(value: UpdateMulticastListAction) -> Self {
17153         u8::from(value) as Self
17154     }
17155 }
17156 impl From<UpdateMulticastListAction> for u32 {
from(value: UpdateMulticastListAction) -> Self17157     fn from(value: UpdateMulticastListAction) -> Self {
17158         u8::from(value) as Self
17159     }
17160 }
17161 impl From<UpdateMulticastListAction> for u64 {
from(value: UpdateMulticastListAction) -> Self17162     fn from(value: UpdateMulticastListAction) -> Self {
17163         u8::from(value) as Self
17164     }
17165 }
17166 #[derive(Debug, Clone, PartialEq, Eq)]
17167 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17168 pub enum SessionUpdateControllerMulticastListCmdDataChild {
17169     Payload(Bytes),
17170     None,
17171 }
17172 impl SessionUpdateControllerMulticastListCmdDataChild {
get_total_size(&self) -> usize17173     fn get_total_size(&self) -> usize {
17174         match self {
17175             SessionUpdateControllerMulticastListCmdDataChild::Payload(bytes) => {
17176                 bytes.len()
17177             }
17178             SessionUpdateControllerMulticastListCmdDataChild::None => 0,
17179         }
17180     }
17181 }
17182 #[derive(Debug, Clone, PartialEq, Eq)]
17183 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17184 pub enum SessionUpdateControllerMulticastListCmdChild {
17185     Payload(Bytes),
17186     None,
17187 }
17188 #[derive(Debug, Clone, PartialEq, Eq)]
17189 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17190 pub struct SessionUpdateControllerMulticastListCmdData {
17191     session_token: u32,
17192     action: UpdateMulticastListAction,
17193     child: SessionUpdateControllerMulticastListCmdDataChild,
17194 }
17195 #[derive(Debug, Clone, PartialEq, Eq)]
17196 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17197 pub struct SessionUpdateControllerMulticastListCmd {
17198     #[cfg_attr(feature = "serde", serde(flatten))]
17199     ucicontrolpacket: UciControlPacketData,
17200     #[cfg_attr(feature = "serde", serde(flatten))]
17201     ucicommand: UciCommandData,
17202     #[cfg_attr(feature = "serde", serde(flatten))]
17203     sessionconfigcommand: SessionConfigCommandData,
17204     #[cfg_attr(feature = "serde", serde(flatten))]
17205     sessionupdatecontrollermulticastlistcmd: SessionUpdateControllerMulticastListCmdData,
17206 }
17207 #[derive(Debug)]
17208 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17209 pub struct SessionUpdateControllerMulticastListCmdBuilder {
17210     pub action: UpdateMulticastListAction,
17211     pub session_token: u32,
17212     pub payload: Option<Bytes>,
17213 }
17214 impl SessionUpdateControllerMulticastListCmdData {
conforms(bytes: &[u8]) -> bool17215     fn conforms(bytes: &[u8]) -> bool {
17216         bytes.len() >= 5
17217     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>17218     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
17219         let mut cell = Cell::new(bytes);
17220         let packet = Self::parse_inner(&mut cell)?;
17221         Ok(packet)
17222     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>17223     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
17224         if bytes.get().remaining() < 4 {
17225             return Err(DecodeError::InvalidLengthError {
17226                 obj: "SessionUpdateControllerMulticastListCmd",
17227                 wanted: 4,
17228                 got: bytes.get().remaining(),
17229             });
17230         }
17231         let session_token = bytes.get_mut().get_u32_le();
17232         if bytes.get().remaining() < 1 {
17233             return Err(DecodeError::InvalidLengthError {
17234                 obj: "SessionUpdateControllerMulticastListCmd",
17235                 wanted: 1,
17236                 got: bytes.get().remaining(),
17237             });
17238         }
17239         let action = UpdateMulticastListAction::try_from(bytes.get_mut().get_u8())
17240             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
17241                 obj: "SessionUpdateControllerMulticastListCmd",
17242                 field: "action",
17243                 value: unknown_val as u64,
17244                 type_: "UpdateMulticastListAction",
17245             })?;
17246         let payload = bytes.get();
17247         bytes.get_mut().advance(payload.len());
17248         let child = match () {
17249             _ if !payload.is_empty() => {
17250                 SessionUpdateControllerMulticastListCmdDataChild::Payload(
17251                     Bytes::copy_from_slice(payload),
17252                 )
17253             }
17254             _ => SessionUpdateControllerMulticastListCmdDataChild::None,
17255         };
17256         Ok(Self {
17257             session_token,
17258             action,
17259             child,
17260         })
17261     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>17262     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
17263         buffer.put_u32_le(self.session_token);
17264         buffer.put_u8(u8::from(self.action));
17265         match &self.child {
17266             SessionUpdateControllerMulticastListCmdDataChild::Payload(payload) => {
17267                 buffer.put_slice(payload)
17268             }
17269             SessionUpdateControllerMulticastListCmdDataChild::None => {}
17270         }
17271         Ok(())
17272     }
get_total_size(&self) -> usize17273     fn get_total_size(&self) -> usize {
17274         self.get_size()
17275     }
get_size(&self) -> usize17276     fn get_size(&self) -> usize {
17277         5 + self.child.get_total_size()
17278     }
17279 }
17280 impl Packet for SessionUpdateControllerMulticastListCmd {
encoded_len(&self) -> usize17281     fn encoded_len(&self) -> usize {
17282         self.get_size()
17283     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>17284     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
17285         self.ucicontrolpacket.write_to(buf)
17286     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>17287     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
17288         unimplemented!("Rust legacy does not implement full packet trait")
17289     }
17290 }
17291 impl TryFrom<SessionUpdateControllerMulticastListCmd> for Bytes {
17292     type Error = EncodeError;
try_from( packet: SessionUpdateControllerMulticastListCmd, ) -> Result<Self, Self::Error>17293     fn try_from(
17294         packet: SessionUpdateControllerMulticastListCmd,
17295     ) -> Result<Self, Self::Error> {
17296         packet.encode_to_bytes()
17297     }
17298 }
17299 impl TryFrom<SessionUpdateControllerMulticastListCmd> for Vec<u8> {
17300     type Error = EncodeError;
try_from( packet: SessionUpdateControllerMulticastListCmd, ) -> Result<Self, Self::Error>17301     fn try_from(
17302         packet: SessionUpdateControllerMulticastListCmd,
17303     ) -> Result<Self, Self::Error> {
17304         packet.encode_to_vec()
17305     }
17306 }
17307 impl From<SessionUpdateControllerMulticastListCmd> for UciControlPacket {
from(packet: SessionUpdateControllerMulticastListCmd) -> UciControlPacket17308     fn from(packet: SessionUpdateControllerMulticastListCmd) -> UciControlPacket {
17309         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
17310     }
17311 }
17312 impl From<SessionUpdateControllerMulticastListCmd> for UciCommand {
from(packet: SessionUpdateControllerMulticastListCmd) -> UciCommand17313     fn from(packet: SessionUpdateControllerMulticastListCmd) -> UciCommand {
17314         UciCommand::new(packet.ucicontrolpacket).unwrap()
17315     }
17316 }
17317 impl From<SessionUpdateControllerMulticastListCmd> for SessionConfigCommand {
from(packet: SessionUpdateControllerMulticastListCmd) -> SessionConfigCommand17318     fn from(packet: SessionUpdateControllerMulticastListCmd) -> SessionConfigCommand {
17319         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
17320     }
17321 }
17322 impl TryFrom<UciControlPacket> for SessionUpdateControllerMulticastListCmd {
17323     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionUpdateControllerMulticastListCmd, Self::Error>17324     fn try_from(
17325         packet: UciControlPacket,
17326     ) -> Result<SessionUpdateControllerMulticastListCmd, Self::Error> {
17327         SessionUpdateControllerMulticastListCmd::new(packet.ucicontrolpacket)
17328     }
17329 }
17330 impl SessionUpdateControllerMulticastListCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>17331     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
17332         let mut cell = Cell::new(bytes);
17333         let packet = Self::parse_inner(&mut cell)?;
17334         Ok(packet)
17335     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>17336     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
17337         let data = UciControlPacketData::parse_inner(&mut bytes)?;
17338         Self::new(data)
17339     }
specialize(&self) -> SessionUpdateControllerMulticastListCmdChild17340     pub fn specialize(&self) -> SessionUpdateControllerMulticastListCmdChild {
17341         match &self.sessionupdatecontrollermulticastlistcmd.child {
17342             SessionUpdateControllerMulticastListCmdDataChild::Payload(payload) => {
17343                 SessionUpdateControllerMulticastListCmdChild::Payload(payload.clone())
17344             }
17345             SessionUpdateControllerMulticastListCmdDataChild::None => {
17346                 SessionUpdateControllerMulticastListCmdChild::None
17347             }
17348         }
17349     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>17350     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
17351         let ucicommand = match &ucicontrolpacket.child {
17352             UciControlPacketDataChild::UciCommand(value) => value.clone(),
17353             _ => {
17354                 return Err(DecodeError::InvalidChildError {
17355                     expected: stringify!(UciControlPacketDataChild::UciCommand),
17356                     actual: format!("{:?}", & ucicontrolpacket.child),
17357                 });
17358             }
17359         };
17360         let sessionconfigcommand = match &ucicommand.child {
17361             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
17362             _ => {
17363                 return Err(DecodeError::InvalidChildError {
17364                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
17365                     actual: format!("{:?}", & ucicommand.child),
17366                 });
17367             }
17368         };
17369         let sessionupdatecontrollermulticastlistcmd = match &sessionconfigcommand.child {
17370             SessionConfigCommandDataChild::SessionUpdateControllerMulticastListCmd(
17371                 value,
17372             ) => value.clone(),
17373             _ => {
17374                 return Err(DecodeError::InvalidChildError {
17375                     expected: stringify!(
17376                         SessionConfigCommandDataChild::SessionUpdateControllerMulticastListCmd
17377                     ),
17378                     actual: format!("{:?}", & sessionconfigcommand.child),
17379                 });
17380             }
17381         };
17382         Ok(Self {
17383             ucicontrolpacket,
17384             ucicommand,
17385             sessionconfigcommand,
17386             sessionupdatecontrollermulticastlistcmd,
17387         })
17388     }
get_action(&self) -> UpdateMulticastListAction17389     pub fn get_action(&self) -> UpdateMulticastListAction {
17390         self.sessionupdatecontrollermulticastlistcmd.action
17391     }
get_group_id(&self) -> GroupId17392     pub fn get_group_id(&self) -> GroupId {
17393         self.ucicontrolpacket.group_id
17394     }
get_message_type(&self) -> MessageType17395     pub fn get_message_type(&self) -> MessageType {
17396         self.ucicontrolpacket.message_type
17397     }
get_opcode(&self) -> u817398     pub fn get_opcode(&self) -> u8 {
17399         self.ucicontrolpacket.opcode
17400     }
get_session_token(&self) -> u3217401     pub fn get_session_token(&self) -> u32 {
17402         self.sessionupdatecontrollermulticastlistcmd.session_token
17403     }
get_payload(&self) -> &[u8]17404     pub fn get_payload(&self) -> &[u8] {
17405         match &self.sessionupdatecontrollermulticastlistcmd.child {
17406             SessionUpdateControllerMulticastListCmdDataChild::Payload(bytes) => &bytes,
17407             SessionUpdateControllerMulticastListCmdDataChild::None => &[],
17408         }
17409     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>17410     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
17411         self.sessionupdatecontrollermulticastlistcmd.write_to(buffer)
17412     }
get_size(&self) -> usize17413     pub fn get_size(&self) -> usize {
17414         self.ucicontrolpacket.get_size()
17415     }
17416 }
17417 impl SessionUpdateControllerMulticastListCmdBuilder {
build(self) -> SessionUpdateControllerMulticastListCmd17418     pub fn build(self) -> SessionUpdateControllerMulticastListCmd {
17419         let sessionupdatecontrollermulticastlistcmd = SessionUpdateControllerMulticastListCmdData {
17420             action: self.action,
17421             session_token: self.session_token,
17422             child: match self.payload {
17423                 None => SessionUpdateControllerMulticastListCmdDataChild::None,
17424                 Some(bytes) => {
17425                     SessionUpdateControllerMulticastListCmdDataChild::Payload(bytes)
17426                 }
17427             },
17428         };
17429         let sessionconfigcommand = SessionConfigCommandData {
17430             child: SessionConfigCommandDataChild::SessionUpdateControllerMulticastListCmd(
17431                 sessionupdatecontrollermulticastlistcmd,
17432             ),
17433         };
17434         let ucicommand = UciCommandData {
17435             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
17436         };
17437         let ucicontrolpacket = UciControlPacketData {
17438             group_id: GroupId::SessionConfig,
17439             message_type: MessageType::Command,
17440             opcode: 7,
17441             child: UciControlPacketDataChild::UciCommand(ucicommand),
17442         };
17443         SessionUpdateControllerMulticastListCmd::new(ucicontrolpacket).unwrap()
17444     }
17445 }
17446 impl From<SessionUpdateControllerMulticastListCmdBuilder> for UciControlPacket {
from( builder: SessionUpdateControllerMulticastListCmdBuilder, ) -> UciControlPacket17447     fn from(
17448         builder: SessionUpdateControllerMulticastListCmdBuilder,
17449     ) -> UciControlPacket {
17450         builder.build().into()
17451     }
17452 }
17453 impl From<SessionUpdateControllerMulticastListCmdBuilder> for UciCommand {
from(builder: SessionUpdateControllerMulticastListCmdBuilder) -> UciCommand17454     fn from(builder: SessionUpdateControllerMulticastListCmdBuilder) -> UciCommand {
17455         builder.build().into()
17456     }
17457 }
17458 impl From<SessionUpdateControllerMulticastListCmdBuilder> for SessionConfigCommand {
from( builder: SessionUpdateControllerMulticastListCmdBuilder, ) -> SessionConfigCommand17459     fn from(
17460         builder: SessionUpdateControllerMulticastListCmdBuilder,
17461     ) -> SessionConfigCommand {
17462         builder.build().into()
17463     }
17464 }
17465 impl From<SessionUpdateControllerMulticastListCmdBuilder>
17466 for SessionUpdateControllerMulticastListCmd {
from( builder: SessionUpdateControllerMulticastListCmdBuilder, ) -> SessionUpdateControllerMulticastListCmd17467     fn from(
17468         builder: SessionUpdateControllerMulticastListCmdBuilder,
17469     ) -> SessionUpdateControllerMulticastListCmd {
17470         builder.build().into()
17471     }
17472 }
17473 #[derive(Debug, Clone, PartialEq, Eq)]
17474 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17475 pub struct SessionUpdateControllerMulticastListCmdPayload {
17476     pub controlees: Vec<Controlee>,
17477 }
17478 impl SessionUpdateControllerMulticastListCmdPayload {
conforms(bytes: &[u8]) -> bool17479     fn conforms(bytes: &[u8]) -> bool {
17480         bytes.len() >= 1
17481     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>17482     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
17483         let mut cell = Cell::new(bytes);
17484         let packet = Self::parse_inner(&mut cell)?;
17485         Ok(packet)
17486     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>17487     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
17488         if bytes.get().remaining() < 1 {
17489             return Err(DecodeError::InvalidLengthError {
17490                 obj: "SessionUpdateControllerMulticastListCmdPayload",
17491                 wanted: 1,
17492                 got: bytes.get().remaining(),
17493             });
17494         }
17495         let controlees_count = bytes.get_mut().get_u8() as usize;
17496         if bytes.get().remaining() < controlees_count * 6usize {
17497             return Err(DecodeError::InvalidLengthError {
17498                 obj: "SessionUpdateControllerMulticastListCmdPayload",
17499                 wanted: controlees_count * 6usize,
17500                 got: bytes.get().remaining(),
17501             });
17502         }
17503         let controlees = (0..controlees_count)
17504             .map(|_| Controlee::parse_inner(bytes))
17505             .collect::<Result<Vec<_>, DecodeError>>()?;
17506         Ok(Self { controlees })
17507     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>17508     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
17509         buffer.put_u8(self.controlees.len() as u8);
17510         for elem in &self.controlees {
17511             elem.write_to(buffer)?;
17512         }
17513         Ok(())
17514     }
get_total_size(&self) -> usize17515     fn get_total_size(&self) -> usize {
17516         self.get_size()
17517     }
get_size(&self) -> usize17518     fn get_size(&self) -> usize {
17519         1 + self.controlees.iter().map(|elem| elem.get_size()).sum::<usize>()
17520     }
17521 }
17522 #[derive(Debug, Clone, PartialEq, Eq)]
17523 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17524 pub struct SessionUpdateControllerMulticastListCmd_2_0_16_Byte_Payload {
17525     pub controlees: Vec<Controlee_V2_0_16_Byte_Version>,
17526 }
17527 impl SessionUpdateControllerMulticastListCmd_2_0_16_Byte_Payload {
conforms(bytes: &[u8]) -> bool17528     fn conforms(bytes: &[u8]) -> bool {
17529         bytes.len() >= 1
17530     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>17531     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
17532         let mut cell = Cell::new(bytes);
17533         let packet = Self::parse_inner(&mut cell)?;
17534         Ok(packet)
17535     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>17536     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
17537         if bytes.get().remaining() < 1 {
17538             return Err(DecodeError::InvalidLengthError {
17539                 obj: "SessionUpdateControllerMulticastListCmd_2_0_16_Byte_Payload",
17540                 wanted: 1,
17541                 got: bytes.get().remaining(),
17542             });
17543         }
17544         let controlees_count = bytes.get_mut().get_u8() as usize;
17545         if bytes.get().remaining() < controlees_count * 22usize {
17546             return Err(DecodeError::InvalidLengthError {
17547                 obj: "SessionUpdateControllerMulticastListCmd_2_0_16_Byte_Payload",
17548                 wanted: controlees_count * 22usize,
17549                 got: bytes.get().remaining(),
17550             });
17551         }
17552         let controlees = (0..controlees_count)
17553             .map(|_| Controlee_V2_0_16_Byte_Version::parse_inner(bytes))
17554             .collect::<Result<Vec<_>, DecodeError>>()?;
17555         Ok(Self { controlees })
17556     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>17557     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
17558         buffer.put_u8(self.controlees.len() as u8);
17559         for elem in &self.controlees {
17560             elem.write_to(buffer)?;
17561         }
17562         Ok(())
17563     }
get_total_size(&self) -> usize17564     fn get_total_size(&self) -> usize {
17565         self.get_size()
17566     }
get_size(&self) -> usize17567     fn get_size(&self) -> usize {
17568         1 + self.controlees.iter().map(|elem| elem.get_size()).sum::<usize>()
17569     }
17570 }
17571 #[derive(Debug, Clone, PartialEq, Eq)]
17572 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17573 pub struct SessionUpdateControllerMulticastListCmd_2_0_32_Byte_Payload {
17574     pub controlees: Vec<Controlee_V2_0_32_Byte_Version>,
17575 }
17576 impl SessionUpdateControllerMulticastListCmd_2_0_32_Byte_Payload {
conforms(bytes: &[u8]) -> bool17577     fn conforms(bytes: &[u8]) -> bool {
17578         bytes.len() >= 1
17579     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>17580     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
17581         let mut cell = Cell::new(bytes);
17582         let packet = Self::parse_inner(&mut cell)?;
17583         Ok(packet)
17584     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>17585     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
17586         if bytes.get().remaining() < 1 {
17587             return Err(DecodeError::InvalidLengthError {
17588                 obj: "SessionUpdateControllerMulticastListCmd_2_0_32_Byte_Payload",
17589                 wanted: 1,
17590                 got: bytes.get().remaining(),
17591             });
17592         }
17593         let controlees_count = bytes.get_mut().get_u8() as usize;
17594         if bytes.get().remaining() < controlees_count * 38usize {
17595             return Err(DecodeError::InvalidLengthError {
17596                 obj: "SessionUpdateControllerMulticastListCmd_2_0_32_Byte_Payload",
17597                 wanted: controlees_count * 38usize,
17598                 got: bytes.get().remaining(),
17599             });
17600         }
17601         let controlees = (0..controlees_count)
17602             .map(|_| Controlee_V2_0_32_Byte_Version::parse_inner(bytes))
17603             .collect::<Result<Vec<_>, DecodeError>>()?;
17604         Ok(Self { controlees })
17605     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>17606     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
17607         buffer.put_u8(self.controlees.len() as u8);
17608         for elem in &self.controlees {
17609             elem.write_to(buffer)?;
17610         }
17611         Ok(())
17612     }
get_total_size(&self) -> usize17613     fn get_total_size(&self) -> usize {
17614         self.get_size()
17615     }
get_size(&self) -> usize17616     fn get_size(&self) -> usize {
17617         1 + self.controlees.iter().map(|elem| elem.get_size()).sum::<usize>()
17618     }
17619 }
17620 #[derive(Debug, Clone, PartialEq, Eq)]
17621 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17622 pub enum SessionUpdateControllerMulticastListRspDataChild {
17623     Payload(Bytes),
17624     None,
17625 }
17626 impl SessionUpdateControllerMulticastListRspDataChild {
get_total_size(&self) -> usize17627     fn get_total_size(&self) -> usize {
17628         match self {
17629             SessionUpdateControllerMulticastListRspDataChild::Payload(bytes) => {
17630                 bytes.len()
17631             }
17632             SessionUpdateControllerMulticastListRspDataChild::None => 0,
17633         }
17634     }
17635 }
17636 #[derive(Debug, Clone, PartialEq, Eq)]
17637 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17638 pub enum SessionUpdateControllerMulticastListRspChild {
17639     Payload(Bytes),
17640     None,
17641 }
17642 #[derive(Debug, Clone, PartialEq, Eq)]
17643 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17644 pub struct SessionUpdateControllerMulticastListRspData {
17645     child: SessionUpdateControllerMulticastListRspDataChild,
17646 }
17647 #[derive(Debug, Clone, PartialEq, Eq)]
17648 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17649 pub struct SessionUpdateControllerMulticastListRsp {
17650     #[cfg_attr(feature = "serde", serde(flatten))]
17651     ucicontrolpacket: UciControlPacketData,
17652     #[cfg_attr(feature = "serde", serde(flatten))]
17653     uciresponse: UciResponseData,
17654     #[cfg_attr(feature = "serde", serde(flatten))]
17655     sessionconfigresponse: SessionConfigResponseData,
17656     #[cfg_attr(feature = "serde", serde(flatten))]
17657     sessionupdatecontrollermulticastlistrsp: SessionUpdateControllerMulticastListRspData,
17658 }
17659 #[derive(Debug)]
17660 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17661 pub struct SessionUpdateControllerMulticastListRspBuilder {
17662     pub payload: Option<Bytes>,
17663 }
17664 impl SessionUpdateControllerMulticastListRspData {
conforms(bytes: &[u8]) -> bool17665     fn conforms(bytes: &[u8]) -> bool {
17666         true
17667     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>17668     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
17669         let mut cell = Cell::new(bytes);
17670         let packet = Self::parse_inner(&mut cell)?;
17671         Ok(packet)
17672     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>17673     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
17674         let payload = bytes.get();
17675         bytes.get_mut().advance(payload.len());
17676         let child = match () {
17677             _ if !payload.is_empty() => {
17678                 SessionUpdateControllerMulticastListRspDataChild::Payload(
17679                     Bytes::copy_from_slice(payload),
17680                 )
17681             }
17682             _ => SessionUpdateControllerMulticastListRspDataChild::None,
17683         };
17684         Ok(Self { child })
17685     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>17686     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
17687         match &self.child {
17688             SessionUpdateControllerMulticastListRspDataChild::Payload(payload) => {
17689                 buffer.put_slice(payload)
17690             }
17691             SessionUpdateControllerMulticastListRspDataChild::None => {}
17692         }
17693         Ok(())
17694     }
get_total_size(&self) -> usize17695     fn get_total_size(&self) -> usize {
17696         self.get_size()
17697     }
get_size(&self) -> usize17698     fn get_size(&self) -> usize {
17699         self.child.get_total_size()
17700     }
17701 }
17702 impl Packet for SessionUpdateControllerMulticastListRsp {
encoded_len(&self) -> usize17703     fn encoded_len(&self) -> usize {
17704         self.get_size()
17705     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>17706     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
17707         self.ucicontrolpacket.write_to(buf)
17708     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>17709     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
17710         unimplemented!("Rust legacy does not implement full packet trait")
17711     }
17712 }
17713 impl TryFrom<SessionUpdateControllerMulticastListRsp> for Bytes {
17714     type Error = EncodeError;
try_from( packet: SessionUpdateControllerMulticastListRsp, ) -> Result<Self, Self::Error>17715     fn try_from(
17716         packet: SessionUpdateControllerMulticastListRsp,
17717     ) -> Result<Self, Self::Error> {
17718         packet.encode_to_bytes()
17719     }
17720 }
17721 impl TryFrom<SessionUpdateControllerMulticastListRsp> for Vec<u8> {
17722     type Error = EncodeError;
try_from( packet: SessionUpdateControllerMulticastListRsp, ) -> Result<Self, Self::Error>17723     fn try_from(
17724         packet: SessionUpdateControllerMulticastListRsp,
17725     ) -> Result<Self, Self::Error> {
17726         packet.encode_to_vec()
17727     }
17728 }
17729 impl From<SessionUpdateControllerMulticastListRsp> for UciControlPacket {
from(packet: SessionUpdateControllerMulticastListRsp) -> UciControlPacket17730     fn from(packet: SessionUpdateControllerMulticastListRsp) -> UciControlPacket {
17731         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
17732     }
17733 }
17734 impl From<SessionUpdateControllerMulticastListRsp> for UciResponse {
from(packet: SessionUpdateControllerMulticastListRsp) -> UciResponse17735     fn from(packet: SessionUpdateControllerMulticastListRsp) -> UciResponse {
17736         UciResponse::new(packet.ucicontrolpacket).unwrap()
17737     }
17738 }
17739 impl From<SessionUpdateControllerMulticastListRsp> for SessionConfigResponse {
from(packet: SessionUpdateControllerMulticastListRsp) -> SessionConfigResponse17740     fn from(packet: SessionUpdateControllerMulticastListRsp) -> SessionConfigResponse {
17741         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
17742     }
17743 }
17744 impl TryFrom<UciControlPacket> for SessionUpdateControllerMulticastListRsp {
17745     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionUpdateControllerMulticastListRsp, Self::Error>17746     fn try_from(
17747         packet: UciControlPacket,
17748     ) -> Result<SessionUpdateControllerMulticastListRsp, Self::Error> {
17749         SessionUpdateControllerMulticastListRsp::new(packet.ucicontrolpacket)
17750     }
17751 }
17752 impl SessionUpdateControllerMulticastListRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>17753     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
17754         let mut cell = Cell::new(bytes);
17755         let packet = Self::parse_inner(&mut cell)?;
17756         Ok(packet)
17757     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>17758     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
17759         let data = UciControlPacketData::parse_inner(&mut bytes)?;
17760         Self::new(data)
17761     }
specialize(&self) -> SessionUpdateControllerMulticastListRspChild17762     pub fn specialize(&self) -> SessionUpdateControllerMulticastListRspChild {
17763         match &self.sessionupdatecontrollermulticastlistrsp.child {
17764             SessionUpdateControllerMulticastListRspDataChild::Payload(payload) => {
17765                 SessionUpdateControllerMulticastListRspChild::Payload(payload.clone())
17766             }
17767             SessionUpdateControllerMulticastListRspDataChild::None => {
17768                 SessionUpdateControllerMulticastListRspChild::None
17769             }
17770         }
17771     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>17772     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
17773         let uciresponse = match &ucicontrolpacket.child {
17774             UciControlPacketDataChild::UciResponse(value) => value.clone(),
17775             _ => {
17776                 return Err(DecodeError::InvalidChildError {
17777                     expected: stringify!(UciControlPacketDataChild::UciResponse),
17778                     actual: format!("{:?}", & ucicontrolpacket.child),
17779                 });
17780             }
17781         };
17782         let sessionconfigresponse = match &uciresponse.child {
17783             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
17784             _ => {
17785                 return Err(DecodeError::InvalidChildError {
17786                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
17787                     actual: format!("{:?}", & uciresponse.child),
17788                 });
17789             }
17790         };
17791         let sessionupdatecontrollermulticastlistrsp = match &sessionconfigresponse.child
17792         {
17793             SessionConfigResponseDataChild::SessionUpdateControllerMulticastListRsp(
17794                 value,
17795             ) => value.clone(),
17796             _ => {
17797                 return Err(DecodeError::InvalidChildError {
17798                     expected: stringify!(
17799                         SessionConfigResponseDataChild::SessionUpdateControllerMulticastListRsp
17800                     ),
17801                     actual: format!("{:?}", & sessionconfigresponse.child),
17802                 });
17803             }
17804         };
17805         Ok(Self {
17806             ucicontrolpacket,
17807             uciresponse,
17808             sessionconfigresponse,
17809             sessionupdatecontrollermulticastlistrsp,
17810         })
17811     }
get_group_id(&self) -> GroupId17812     pub fn get_group_id(&self) -> GroupId {
17813         self.ucicontrolpacket.group_id
17814     }
get_message_type(&self) -> MessageType17815     pub fn get_message_type(&self) -> MessageType {
17816         self.ucicontrolpacket.message_type
17817     }
get_opcode(&self) -> u817818     pub fn get_opcode(&self) -> u8 {
17819         self.ucicontrolpacket.opcode
17820     }
get_payload(&self) -> &[u8]17821     pub fn get_payload(&self) -> &[u8] {
17822         match &self.sessionupdatecontrollermulticastlistrsp.child {
17823             SessionUpdateControllerMulticastListRspDataChild::Payload(bytes) => &bytes,
17824             SessionUpdateControllerMulticastListRspDataChild::None => &[],
17825         }
17826     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>17827     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
17828         self.sessionupdatecontrollermulticastlistrsp.write_to(buffer)
17829     }
get_size(&self) -> usize17830     pub fn get_size(&self) -> usize {
17831         self.ucicontrolpacket.get_size()
17832     }
17833 }
17834 impl SessionUpdateControllerMulticastListRspBuilder {
build(self) -> SessionUpdateControllerMulticastListRsp17835     pub fn build(self) -> SessionUpdateControllerMulticastListRsp {
17836         let sessionupdatecontrollermulticastlistrsp = SessionUpdateControllerMulticastListRspData {
17837             child: match self.payload {
17838                 None => SessionUpdateControllerMulticastListRspDataChild::None,
17839                 Some(bytes) => {
17840                     SessionUpdateControllerMulticastListRspDataChild::Payload(bytes)
17841                 }
17842             },
17843         };
17844         let sessionconfigresponse = SessionConfigResponseData {
17845             child: SessionConfigResponseDataChild::SessionUpdateControllerMulticastListRsp(
17846                 sessionupdatecontrollermulticastlistrsp,
17847             ),
17848         };
17849         let uciresponse = UciResponseData {
17850             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
17851         };
17852         let ucicontrolpacket = UciControlPacketData {
17853             group_id: GroupId::SessionConfig,
17854             message_type: MessageType::Response,
17855             opcode: 7,
17856             child: UciControlPacketDataChild::UciResponse(uciresponse),
17857         };
17858         SessionUpdateControllerMulticastListRsp::new(ucicontrolpacket).unwrap()
17859     }
17860 }
17861 impl From<SessionUpdateControllerMulticastListRspBuilder> for UciControlPacket {
from( builder: SessionUpdateControllerMulticastListRspBuilder, ) -> UciControlPacket17862     fn from(
17863         builder: SessionUpdateControllerMulticastListRspBuilder,
17864     ) -> UciControlPacket {
17865         builder.build().into()
17866     }
17867 }
17868 impl From<SessionUpdateControllerMulticastListRspBuilder> for UciResponse {
from(builder: SessionUpdateControllerMulticastListRspBuilder) -> UciResponse17869     fn from(builder: SessionUpdateControllerMulticastListRspBuilder) -> UciResponse {
17870         builder.build().into()
17871     }
17872 }
17873 impl From<SessionUpdateControllerMulticastListRspBuilder> for SessionConfigResponse {
from( builder: SessionUpdateControllerMulticastListRspBuilder, ) -> SessionConfigResponse17874     fn from(
17875         builder: SessionUpdateControllerMulticastListRspBuilder,
17876     ) -> SessionConfigResponse {
17877         builder.build().into()
17878     }
17879 }
17880 impl From<SessionUpdateControllerMulticastListRspBuilder>
17881 for SessionUpdateControllerMulticastListRsp {
from( builder: SessionUpdateControllerMulticastListRspBuilder, ) -> SessionUpdateControllerMulticastListRsp17882     fn from(
17883         builder: SessionUpdateControllerMulticastListRspBuilder,
17884     ) -> SessionUpdateControllerMulticastListRsp {
17885         builder.build().into()
17886     }
17887 }
17888 #[derive(Debug, Clone, PartialEq, Eq)]
17889 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17890 pub struct SessionUpdateControllerMulticastListRspV1Payload {
17891     pub status: StatusCode,
17892 }
17893 impl SessionUpdateControllerMulticastListRspV1Payload {
conforms(bytes: &[u8]) -> bool17894     fn conforms(bytes: &[u8]) -> bool {
17895         bytes.len() >= 1
17896     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>17897     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
17898         let mut cell = Cell::new(bytes);
17899         let packet = Self::parse_inner(&mut cell)?;
17900         Ok(packet)
17901     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>17902     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
17903         if bytes.get().remaining() < 1 {
17904             return Err(DecodeError::InvalidLengthError {
17905                 obj: "SessionUpdateControllerMulticastListRspV1Payload",
17906                 wanted: 1,
17907                 got: bytes.get().remaining(),
17908             });
17909         }
17910         let status = StatusCode::try_from(bytes.get_mut().get_u8())
17911             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
17912                 obj: "SessionUpdateControllerMulticastListRspV1Payload",
17913                 field: "status",
17914                 value: unknown_val as u64,
17915                 type_: "StatusCode",
17916             })?;
17917         Ok(Self { status })
17918     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>17919     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
17920         buffer.put_u8(u8::from(self.status));
17921         Ok(())
17922     }
get_total_size(&self) -> usize17923     fn get_total_size(&self) -> usize {
17924         self.get_size()
17925     }
get_size(&self) -> usize17926     fn get_size(&self) -> usize {
17927         1
17928     }
17929 }
17930 #[derive(Debug, Clone, PartialEq, Eq)]
17931 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17932 pub struct SessionUpdateControllerMulticastListRspV2Payload {
17933     pub status: StatusCode,
17934     pub controlee_status: Vec<ControleeStatusV2>,
17935 }
17936 impl SessionUpdateControllerMulticastListRspV2Payload {
conforms(bytes: &[u8]) -> bool17937     fn conforms(bytes: &[u8]) -> bool {
17938         bytes.len() >= 2
17939     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>17940     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
17941         let mut cell = Cell::new(bytes);
17942         let packet = Self::parse_inner(&mut cell)?;
17943         Ok(packet)
17944     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>17945     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
17946         if bytes.get().remaining() < 1 {
17947             return Err(DecodeError::InvalidLengthError {
17948                 obj: "SessionUpdateControllerMulticastListRspV2Payload",
17949                 wanted: 1,
17950                 got: bytes.get().remaining(),
17951             });
17952         }
17953         let status = StatusCode::try_from(bytes.get_mut().get_u8())
17954             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
17955                 obj: "SessionUpdateControllerMulticastListRspV2Payload",
17956                 field: "status",
17957                 value: unknown_val as u64,
17958                 type_: "StatusCode",
17959             })?;
17960         if bytes.get().remaining() < 1 {
17961             return Err(DecodeError::InvalidLengthError {
17962                 obj: "SessionUpdateControllerMulticastListRspV2Payload",
17963                 wanted: 1,
17964                 got: bytes.get().remaining(),
17965             });
17966         }
17967         let controlee_status_count = bytes.get_mut().get_u8() as usize;
17968         if bytes.get().remaining() < controlee_status_count * 3usize {
17969             return Err(DecodeError::InvalidLengthError {
17970                 obj: "SessionUpdateControllerMulticastListRspV2Payload",
17971                 wanted: controlee_status_count * 3usize,
17972                 got: bytes.get().remaining(),
17973             });
17974         }
17975         let controlee_status = (0..controlee_status_count)
17976             .map(|_| ControleeStatusV2::parse_inner(bytes))
17977             .collect::<Result<Vec<_>, DecodeError>>()?;
17978         Ok(Self { status, controlee_status })
17979     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>17980     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
17981         buffer.put_u8(u8::from(self.status));
17982         buffer.put_u8(self.controlee_status.len() as u8);
17983         for elem in &self.controlee_status {
17984             elem.write_to(buffer)?;
17985         }
17986         Ok(())
17987     }
get_total_size(&self) -> usize17988     fn get_total_size(&self) -> usize {
17989         self.get_size()
17990     }
get_size(&self) -> usize17991     fn get_size(&self) -> usize {
17992         2 + self.controlee_status.iter().map(|elem| elem.get_size()).sum::<usize>()
17993     }
17994 }
17995 #[derive(Debug, Clone, PartialEq, Eq)]
17996 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
17997 pub struct ControleeStatusV1 {
17998     pub mac_address: [u8; 2],
17999     pub subsession_id: u32,
18000     pub status: MulticastUpdateStatusCode,
18001 }
18002 impl ControleeStatusV1 {
conforms(bytes: &[u8]) -> bool18003     fn conforms(bytes: &[u8]) -> bool {
18004         bytes.len() >= 7
18005     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>18006     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
18007         let mut cell = Cell::new(bytes);
18008         let packet = Self::parse_inner(&mut cell)?;
18009         Ok(packet)
18010     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>18011     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
18012         if bytes.get().remaining() < 2 {
18013             return Err(DecodeError::InvalidLengthError {
18014                 obj: "ControleeStatusV1",
18015                 wanted: 2,
18016                 got: bytes.get().remaining(),
18017             });
18018         }
18019         let mac_address = (0..2)
18020             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
18021             .collect::<Result<Vec<_>, DecodeError>>()?
18022             .try_into()
18023             .map_err(|_| DecodeError::InvalidPacketError)?;
18024         if bytes.get().remaining() < 4 {
18025             return Err(DecodeError::InvalidLengthError {
18026                 obj: "ControleeStatusV1",
18027                 wanted: 4,
18028                 got: bytes.get().remaining(),
18029             });
18030         }
18031         let subsession_id = bytes.get_mut().get_u32_le();
18032         if bytes.get().remaining() < 1 {
18033             return Err(DecodeError::InvalidLengthError {
18034                 obj: "ControleeStatusV1",
18035                 wanted: 1,
18036                 got: bytes.get().remaining(),
18037             });
18038         }
18039         let status = MulticastUpdateStatusCode::try_from(bytes.get_mut().get_u8())
18040             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
18041                 obj: "ControleeStatusV1",
18042                 field: "status",
18043                 value: unknown_val as u64,
18044                 type_: "MulticastUpdateStatusCode",
18045             })?;
18046         Ok(Self {
18047             mac_address,
18048             subsession_id,
18049             status,
18050         })
18051     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>18052     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
18053         for elem in &self.mac_address {
18054             buffer.put_u8(*elem);
18055         }
18056         buffer.put_u32_le(self.subsession_id);
18057         buffer.put_u8(u8::from(self.status));
18058         Ok(())
18059     }
get_total_size(&self) -> usize18060     fn get_total_size(&self) -> usize {
18061         self.get_size()
18062     }
get_size(&self) -> usize18063     fn get_size(&self) -> usize {
18064         7
18065     }
18066 }
18067 #[derive(Debug, Clone, PartialEq, Eq)]
18068 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18069 pub struct ControleeStatusV2 {
18070     pub mac_address: [u8; 2],
18071     pub status: MulticastUpdateStatusCode,
18072 }
18073 impl ControleeStatusV2 {
conforms(bytes: &[u8]) -> bool18074     fn conforms(bytes: &[u8]) -> bool {
18075         bytes.len() >= 3
18076     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>18077     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
18078         let mut cell = Cell::new(bytes);
18079         let packet = Self::parse_inner(&mut cell)?;
18080         Ok(packet)
18081     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>18082     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
18083         if bytes.get().remaining() < 2 {
18084             return Err(DecodeError::InvalidLengthError {
18085                 obj: "ControleeStatusV2",
18086                 wanted: 2,
18087                 got: bytes.get().remaining(),
18088             });
18089         }
18090         let mac_address = (0..2)
18091             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
18092             .collect::<Result<Vec<_>, DecodeError>>()?
18093             .try_into()
18094             .map_err(|_| DecodeError::InvalidPacketError)?;
18095         if bytes.get().remaining() < 1 {
18096             return Err(DecodeError::InvalidLengthError {
18097                 obj: "ControleeStatusV2",
18098                 wanted: 1,
18099                 got: bytes.get().remaining(),
18100             });
18101         }
18102         let status = MulticastUpdateStatusCode::try_from(bytes.get_mut().get_u8())
18103             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
18104                 obj: "ControleeStatusV2",
18105                 field: "status",
18106                 value: unknown_val as u64,
18107                 type_: "MulticastUpdateStatusCode",
18108             })?;
18109         Ok(Self { mac_address, status })
18110     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>18111     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
18112         for elem in &self.mac_address {
18113             buffer.put_u8(*elem);
18114         }
18115         buffer.put_u8(u8::from(self.status));
18116         Ok(())
18117     }
get_total_size(&self) -> usize18118     fn get_total_size(&self) -> usize {
18119         self.get_size()
18120     }
get_size(&self) -> usize18121     fn get_size(&self) -> usize {
18122         3
18123     }
18124 }
18125 #[derive(Debug, Clone, PartialEq, Eq)]
18126 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18127 pub enum SessionUpdateControllerMulticastListNtfDataChild {
18128     Payload(Bytes),
18129     None,
18130 }
18131 impl SessionUpdateControllerMulticastListNtfDataChild {
get_total_size(&self) -> usize18132     fn get_total_size(&self) -> usize {
18133         match self {
18134             SessionUpdateControllerMulticastListNtfDataChild::Payload(bytes) => {
18135                 bytes.len()
18136             }
18137             SessionUpdateControllerMulticastListNtfDataChild::None => 0,
18138         }
18139     }
18140 }
18141 #[derive(Debug, Clone, PartialEq, Eq)]
18142 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18143 pub enum SessionUpdateControllerMulticastListNtfChild {
18144     Payload(Bytes),
18145     None,
18146 }
18147 #[derive(Debug, Clone, PartialEq, Eq)]
18148 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18149 pub struct SessionUpdateControllerMulticastListNtfData {
18150     session_token: u32,
18151     child: SessionUpdateControllerMulticastListNtfDataChild,
18152 }
18153 #[derive(Debug, Clone, PartialEq, Eq)]
18154 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18155 pub struct SessionUpdateControllerMulticastListNtf {
18156     #[cfg_attr(feature = "serde", serde(flatten))]
18157     ucicontrolpacket: UciControlPacketData,
18158     #[cfg_attr(feature = "serde", serde(flatten))]
18159     ucinotification: UciNotificationData,
18160     #[cfg_attr(feature = "serde", serde(flatten))]
18161     sessionconfignotification: SessionConfigNotificationData,
18162     #[cfg_attr(feature = "serde", serde(flatten))]
18163     sessionupdatecontrollermulticastlistntf: SessionUpdateControllerMulticastListNtfData,
18164 }
18165 #[derive(Debug)]
18166 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18167 pub struct SessionUpdateControllerMulticastListNtfBuilder {
18168     pub session_token: u32,
18169     pub payload: Option<Bytes>,
18170 }
18171 impl SessionUpdateControllerMulticastListNtfData {
conforms(bytes: &[u8]) -> bool18172     fn conforms(bytes: &[u8]) -> bool {
18173         bytes.len() >= 4
18174     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>18175     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
18176         let mut cell = Cell::new(bytes);
18177         let packet = Self::parse_inner(&mut cell)?;
18178         Ok(packet)
18179     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>18180     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
18181         if bytes.get().remaining() < 4 {
18182             return Err(DecodeError::InvalidLengthError {
18183                 obj: "SessionUpdateControllerMulticastListNtf",
18184                 wanted: 4,
18185                 got: bytes.get().remaining(),
18186             });
18187         }
18188         let session_token = bytes.get_mut().get_u32_le();
18189         let payload = bytes.get();
18190         bytes.get_mut().advance(payload.len());
18191         let child = match () {
18192             _ if !payload.is_empty() => {
18193                 SessionUpdateControllerMulticastListNtfDataChild::Payload(
18194                     Bytes::copy_from_slice(payload),
18195                 )
18196             }
18197             _ => SessionUpdateControllerMulticastListNtfDataChild::None,
18198         };
18199         Ok(Self { session_token, child })
18200     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>18201     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
18202         buffer.put_u32_le(self.session_token);
18203         match &self.child {
18204             SessionUpdateControllerMulticastListNtfDataChild::Payload(payload) => {
18205                 buffer.put_slice(payload)
18206             }
18207             SessionUpdateControllerMulticastListNtfDataChild::None => {}
18208         }
18209         Ok(())
18210     }
get_total_size(&self) -> usize18211     fn get_total_size(&self) -> usize {
18212         self.get_size()
18213     }
get_size(&self) -> usize18214     fn get_size(&self) -> usize {
18215         4 + self.child.get_total_size()
18216     }
18217 }
18218 impl Packet for SessionUpdateControllerMulticastListNtf {
encoded_len(&self) -> usize18219     fn encoded_len(&self) -> usize {
18220         self.get_size()
18221     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>18222     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
18223         self.ucicontrolpacket.write_to(buf)
18224     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>18225     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
18226         unimplemented!("Rust legacy does not implement full packet trait")
18227     }
18228 }
18229 impl TryFrom<SessionUpdateControllerMulticastListNtf> for Bytes {
18230     type Error = EncodeError;
try_from( packet: SessionUpdateControllerMulticastListNtf, ) -> Result<Self, Self::Error>18231     fn try_from(
18232         packet: SessionUpdateControllerMulticastListNtf,
18233     ) -> Result<Self, Self::Error> {
18234         packet.encode_to_bytes()
18235     }
18236 }
18237 impl TryFrom<SessionUpdateControllerMulticastListNtf> for Vec<u8> {
18238     type Error = EncodeError;
try_from( packet: SessionUpdateControllerMulticastListNtf, ) -> Result<Self, Self::Error>18239     fn try_from(
18240         packet: SessionUpdateControllerMulticastListNtf,
18241     ) -> Result<Self, Self::Error> {
18242         packet.encode_to_vec()
18243     }
18244 }
18245 impl From<SessionUpdateControllerMulticastListNtf> for UciControlPacket {
from(packet: SessionUpdateControllerMulticastListNtf) -> UciControlPacket18246     fn from(packet: SessionUpdateControllerMulticastListNtf) -> UciControlPacket {
18247         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
18248     }
18249 }
18250 impl From<SessionUpdateControllerMulticastListNtf> for UciNotification {
from(packet: SessionUpdateControllerMulticastListNtf) -> UciNotification18251     fn from(packet: SessionUpdateControllerMulticastListNtf) -> UciNotification {
18252         UciNotification::new(packet.ucicontrolpacket).unwrap()
18253     }
18254 }
18255 impl From<SessionUpdateControllerMulticastListNtf> for SessionConfigNotification {
from( packet: SessionUpdateControllerMulticastListNtf, ) -> SessionConfigNotification18256     fn from(
18257         packet: SessionUpdateControllerMulticastListNtf,
18258     ) -> SessionConfigNotification {
18259         SessionConfigNotification::new(packet.ucicontrolpacket).unwrap()
18260     }
18261 }
18262 impl TryFrom<UciControlPacket> for SessionUpdateControllerMulticastListNtf {
18263     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionUpdateControllerMulticastListNtf, Self::Error>18264     fn try_from(
18265         packet: UciControlPacket,
18266     ) -> Result<SessionUpdateControllerMulticastListNtf, Self::Error> {
18267         SessionUpdateControllerMulticastListNtf::new(packet.ucicontrolpacket)
18268     }
18269 }
18270 impl SessionUpdateControllerMulticastListNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>18271     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
18272         let mut cell = Cell::new(bytes);
18273         let packet = Self::parse_inner(&mut cell)?;
18274         Ok(packet)
18275     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>18276     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
18277         let data = UciControlPacketData::parse_inner(&mut bytes)?;
18278         Self::new(data)
18279     }
specialize(&self) -> SessionUpdateControllerMulticastListNtfChild18280     pub fn specialize(&self) -> SessionUpdateControllerMulticastListNtfChild {
18281         match &self.sessionupdatecontrollermulticastlistntf.child {
18282             SessionUpdateControllerMulticastListNtfDataChild::Payload(payload) => {
18283                 SessionUpdateControllerMulticastListNtfChild::Payload(payload.clone())
18284             }
18285             SessionUpdateControllerMulticastListNtfDataChild::None => {
18286                 SessionUpdateControllerMulticastListNtfChild::None
18287             }
18288         }
18289     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>18290     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
18291         let ucinotification = match &ucicontrolpacket.child {
18292             UciControlPacketDataChild::UciNotification(value) => value.clone(),
18293             _ => {
18294                 return Err(DecodeError::InvalidChildError {
18295                     expected: stringify!(UciControlPacketDataChild::UciNotification),
18296                     actual: format!("{:?}", & ucicontrolpacket.child),
18297                 });
18298             }
18299         };
18300         let sessionconfignotification = match &ucinotification.child {
18301             UciNotificationDataChild::SessionConfigNotification(value) => value.clone(),
18302             _ => {
18303                 return Err(DecodeError::InvalidChildError {
18304                     expected: stringify!(
18305                         UciNotificationDataChild::SessionConfigNotification
18306                     ),
18307                     actual: format!("{:?}", & ucinotification.child),
18308                 });
18309             }
18310         };
18311         let sessionupdatecontrollermulticastlistntf = match &sessionconfignotification
18312             .child
18313         {
18314             SessionConfigNotificationDataChild::SessionUpdateControllerMulticastListNtf(
18315                 value,
18316             ) => value.clone(),
18317             _ => {
18318                 return Err(DecodeError::InvalidChildError {
18319                     expected: stringify!(
18320                         SessionConfigNotificationDataChild::SessionUpdateControllerMulticastListNtf
18321                     ),
18322                     actual: format!("{:?}", & sessionconfignotification.child),
18323                 });
18324             }
18325         };
18326         Ok(Self {
18327             ucicontrolpacket,
18328             ucinotification,
18329             sessionconfignotification,
18330             sessionupdatecontrollermulticastlistntf,
18331         })
18332     }
get_group_id(&self) -> GroupId18333     pub fn get_group_id(&self) -> GroupId {
18334         self.ucicontrolpacket.group_id
18335     }
get_message_type(&self) -> MessageType18336     pub fn get_message_type(&self) -> MessageType {
18337         self.ucicontrolpacket.message_type
18338     }
get_opcode(&self) -> u818339     pub fn get_opcode(&self) -> u8 {
18340         self.ucicontrolpacket.opcode
18341     }
get_session_token(&self) -> u3218342     pub fn get_session_token(&self) -> u32 {
18343         self.sessionupdatecontrollermulticastlistntf.session_token
18344     }
get_payload(&self) -> &[u8]18345     pub fn get_payload(&self) -> &[u8] {
18346         match &self.sessionupdatecontrollermulticastlistntf.child {
18347             SessionUpdateControllerMulticastListNtfDataChild::Payload(bytes) => &bytes,
18348             SessionUpdateControllerMulticastListNtfDataChild::None => &[],
18349         }
18350     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>18351     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
18352         self.sessionupdatecontrollermulticastlistntf.write_to(buffer)
18353     }
get_size(&self) -> usize18354     pub fn get_size(&self) -> usize {
18355         self.ucicontrolpacket.get_size()
18356     }
18357 }
18358 impl SessionUpdateControllerMulticastListNtfBuilder {
build(self) -> SessionUpdateControllerMulticastListNtf18359     pub fn build(self) -> SessionUpdateControllerMulticastListNtf {
18360         let sessionupdatecontrollermulticastlistntf = SessionUpdateControllerMulticastListNtfData {
18361             session_token: self.session_token,
18362             child: match self.payload {
18363                 None => SessionUpdateControllerMulticastListNtfDataChild::None,
18364                 Some(bytes) => {
18365                     SessionUpdateControllerMulticastListNtfDataChild::Payload(bytes)
18366                 }
18367             },
18368         };
18369         let sessionconfignotification = SessionConfigNotificationData {
18370             child: SessionConfigNotificationDataChild::SessionUpdateControllerMulticastListNtf(
18371                 sessionupdatecontrollermulticastlistntf,
18372             ),
18373         };
18374         let ucinotification = UciNotificationData {
18375             child: UciNotificationDataChild::SessionConfigNotification(
18376                 sessionconfignotification,
18377             ),
18378         };
18379         let ucicontrolpacket = UciControlPacketData {
18380             group_id: GroupId::SessionConfig,
18381             message_type: MessageType::Notification,
18382             opcode: 7,
18383             child: UciControlPacketDataChild::UciNotification(ucinotification),
18384         };
18385         SessionUpdateControllerMulticastListNtf::new(ucicontrolpacket).unwrap()
18386     }
18387 }
18388 impl From<SessionUpdateControllerMulticastListNtfBuilder> for UciControlPacket {
from( builder: SessionUpdateControllerMulticastListNtfBuilder, ) -> UciControlPacket18389     fn from(
18390         builder: SessionUpdateControllerMulticastListNtfBuilder,
18391     ) -> UciControlPacket {
18392         builder.build().into()
18393     }
18394 }
18395 impl From<SessionUpdateControllerMulticastListNtfBuilder> for UciNotification {
from(builder: SessionUpdateControllerMulticastListNtfBuilder) -> UciNotification18396     fn from(builder: SessionUpdateControllerMulticastListNtfBuilder) -> UciNotification {
18397         builder.build().into()
18398     }
18399 }
18400 impl From<SessionUpdateControllerMulticastListNtfBuilder> for SessionConfigNotification {
from( builder: SessionUpdateControllerMulticastListNtfBuilder, ) -> SessionConfigNotification18401     fn from(
18402         builder: SessionUpdateControllerMulticastListNtfBuilder,
18403     ) -> SessionConfigNotification {
18404         builder.build().into()
18405     }
18406 }
18407 impl From<SessionUpdateControllerMulticastListNtfBuilder>
18408 for SessionUpdateControllerMulticastListNtf {
from( builder: SessionUpdateControllerMulticastListNtfBuilder, ) -> SessionUpdateControllerMulticastListNtf18409     fn from(
18410         builder: SessionUpdateControllerMulticastListNtfBuilder,
18411     ) -> SessionUpdateControllerMulticastListNtf {
18412         builder.build().into()
18413     }
18414 }
18415 #[derive(Debug, Clone, PartialEq, Eq)]
18416 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18417 pub struct SessionUpdateControllerMulticastListNtfV1Payload {
18418     pub remaining_multicast_list_size: u8,
18419     pub controlee_status: Vec<ControleeStatusV1>,
18420 }
18421 impl SessionUpdateControllerMulticastListNtfV1Payload {
conforms(bytes: &[u8]) -> bool18422     fn conforms(bytes: &[u8]) -> bool {
18423         bytes.len() >= 2
18424     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>18425     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
18426         let mut cell = Cell::new(bytes);
18427         let packet = Self::parse_inner(&mut cell)?;
18428         Ok(packet)
18429     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>18430     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
18431         if bytes.get().remaining() < 1 {
18432             return Err(DecodeError::InvalidLengthError {
18433                 obj: "SessionUpdateControllerMulticastListNtfV1Payload",
18434                 wanted: 1,
18435                 got: bytes.get().remaining(),
18436             });
18437         }
18438         let remaining_multicast_list_size = bytes.get_mut().get_u8();
18439         if bytes.get().remaining() < 1 {
18440             return Err(DecodeError::InvalidLengthError {
18441                 obj: "SessionUpdateControllerMulticastListNtfV1Payload",
18442                 wanted: 1,
18443                 got: bytes.get().remaining(),
18444             });
18445         }
18446         let controlee_status_count = bytes.get_mut().get_u8() as usize;
18447         if bytes.get().remaining() < controlee_status_count * 7usize {
18448             return Err(DecodeError::InvalidLengthError {
18449                 obj: "SessionUpdateControllerMulticastListNtfV1Payload",
18450                 wanted: controlee_status_count * 7usize,
18451                 got: bytes.get().remaining(),
18452             });
18453         }
18454         let controlee_status = (0..controlee_status_count)
18455             .map(|_| ControleeStatusV1::parse_inner(bytes))
18456             .collect::<Result<Vec<_>, DecodeError>>()?;
18457         Ok(Self {
18458             remaining_multicast_list_size,
18459             controlee_status,
18460         })
18461     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>18462     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
18463         buffer.put_u8(self.remaining_multicast_list_size);
18464         buffer.put_u8(self.controlee_status.len() as u8);
18465         for elem in &self.controlee_status {
18466             elem.write_to(buffer)?;
18467         }
18468         Ok(())
18469     }
get_total_size(&self) -> usize18470     fn get_total_size(&self) -> usize {
18471         self.get_size()
18472     }
get_size(&self) -> usize18473     fn get_size(&self) -> usize {
18474         2 + self.controlee_status.iter().map(|elem| elem.get_size()).sum::<usize>()
18475     }
18476 }
18477 #[derive(Debug, Clone, PartialEq, Eq)]
18478 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18479 pub struct SessionUpdateControllerMulticastListNtfV2Payload {
18480     pub controlee_status: Vec<ControleeStatusV2>,
18481 }
18482 impl SessionUpdateControllerMulticastListNtfV2Payload {
conforms(bytes: &[u8]) -> bool18483     fn conforms(bytes: &[u8]) -> bool {
18484         bytes.len() >= 1
18485     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>18486     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
18487         let mut cell = Cell::new(bytes);
18488         let packet = Self::parse_inner(&mut cell)?;
18489         Ok(packet)
18490     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>18491     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
18492         if bytes.get().remaining() < 1 {
18493             return Err(DecodeError::InvalidLengthError {
18494                 obj: "SessionUpdateControllerMulticastListNtfV2Payload",
18495                 wanted: 1,
18496                 got: bytes.get().remaining(),
18497             });
18498         }
18499         let controlee_status_count = bytes.get_mut().get_u8() as usize;
18500         if bytes.get().remaining() < controlee_status_count * 3usize {
18501             return Err(DecodeError::InvalidLengthError {
18502                 obj: "SessionUpdateControllerMulticastListNtfV2Payload",
18503                 wanted: controlee_status_count * 3usize,
18504                 got: bytes.get().remaining(),
18505             });
18506         }
18507         let controlee_status = (0..controlee_status_count)
18508             .map(|_| ControleeStatusV2::parse_inner(bytes))
18509             .collect::<Result<Vec<_>, DecodeError>>()?;
18510         Ok(Self { controlee_status })
18511     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>18512     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
18513         buffer.put_u8(self.controlee_status.len() as u8);
18514         for elem in &self.controlee_status {
18515             elem.write_to(buffer)?;
18516         }
18517         Ok(())
18518     }
get_total_size(&self) -> usize18519     fn get_total_size(&self) -> usize {
18520         self.get_size()
18521     }
get_size(&self) -> usize18522     fn get_size(&self) -> usize {
18523         1 + self.controlee_status.iter().map(|elem| elem.get_size()).sum::<usize>()
18524     }
18525 }
18526 #[derive(Debug, Clone, PartialEq, Eq)]
18527 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18528 pub struct DataCreditNtfData {
18529     session_token: u32,
18530     credit_availability: CreditAvailability,
18531 }
18532 #[derive(Debug, Clone, PartialEq, Eq)]
18533 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18534 pub struct DataCreditNtf {
18535     #[cfg_attr(feature = "serde", serde(flatten))]
18536     ucicontrolpacket: UciControlPacketData,
18537     #[cfg_attr(feature = "serde", serde(flatten))]
18538     ucinotification: UciNotificationData,
18539     #[cfg_attr(feature = "serde", serde(flatten))]
18540     sessioncontrolnotification: SessionControlNotificationData,
18541     #[cfg_attr(feature = "serde", serde(flatten))]
18542     datacreditntf: DataCreditNtfData,
18543 }
18544 #[derive(Debug)]
18545 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18546 pub struct DataCreditNtfBuilder {
18547     pub credit_availability: CreditAvailability,
18548     pub session_token: u32,
18549 }
18550 impl DataCreditNtfData {
conforms(bytes: &[u8]) -> bool18551     fn conforms(bytes: &[u8]) -> bool {
18552         bytes.len() >= 5
18553     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>18554     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
18555         let mut cell = Cell::new(bytes);
18556         let packet = Self::parse_inner(&mut cell)?;
18557         Ok(packet)
18558     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>18559     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
18560         if bytes.get().remaining() < 4 {
18561             return Err(DecodeError::InvalidLengthError {
18562                 obj: "DataCreditNtf",
18563                 wanted: 4,
18564                 got: bytes.get().remaining(),
18565             });
18566         }
18567         let session_token = bytes.get_mut().get_u32_le();
18568         if bytes.get().remaining() < 1 {
18569             return Err(DecodeError::InvalidLengthError {
18570                 obj: "DataCreditNtf",
18571                 wanted: 1,
18572                 got: bytes.get().remaining(),
18573             });
18574         }
18575         let credit_availability = CreditAvailability::try_from(bytes.get_mut().get_u8())
18576             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
18577                 obj: "DataCreditNtf",
18578                 field: "credit_availability",
18579                 value: unknown_val as u64,
18580                 type_: "CreditAvailability",
18581             })?;
18582         Ok(Self {
18583             session_token,
18584             credit_availability,
18585         })
18586     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>18587     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
18588         buffer.put_u32_le(self.session_token);
18589         buffer.put_u8(u8::from(self.credit_availability));
18590         Ok(())
18591     }
get_total_size(&self) -> usize18592     fn get_total_size(&self) -> usize {
18593         self.get_size()
18594     }
get_size(&self) -> usize18595     fn get_size(&self) -> usize {
18596         5
18597     }
18598 }
18599 impl Packet for DataCreditNtf {
encoded_len(&self) -> usize18600     fn encoded_len(&self) -> usize {
18601         self.get_size()
18602     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>18603     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
18604         self.ucicontrolpacket.write_to(buf)
18605     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>18606     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
18607         unimplemented!("Rust legacy does not implement full packet trait")
18608     }
18609 }
18610 impl TryFrom<DataCreditNtf> for Bytes {
18611     type Error = EncodeError;
try_from(packet: DataCreditNtf) -> Result<Self, Self::Error>18612     fn try_from(packet: DataCreditNtf) -> Result<Self, Self::Error> {
18613         packet.encode_to_bytes()
18614     }
18615 }
18616 impl TryFrom<DataCreditNtf> for Vec<u8> {
18617     type Error = EncodeError;
try_from(packet: DataCreditNtf) -> Result<Self, Self::Error>18618     fn try_from(packet: DataCreditNtf) -> Result<Self, Self::Error> {
18619         packet.encode_to_vec()
18620     }
18621 }
18622 impl From<DataCreditNtf> for UciControlPacket {
from(packet: DataCreditNtf) -> UciControlPacket18623     fn from(packet: DataCreditNtf) -> UciControlPacket {
18624         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
18625     }
18626 }
18627 impl From<DataCreditNtf> for UciNotification {
from(packet: DataCreditNtf) -> UciNotification18628     fn from(packet: DataCreditNtf) -> UciNotification {
18629         UciNotification::new(packet.ucicontrolpacket).unwrap()
18630     }
18631 }
18632 impl From<DataCreditNtf> for SessionControlNotification {
from(packet: DataCreditNtf) -> SessionControlNotification18633     fn from(packet: DataCreditNtf) -> SessionControlNotification {
18634         SessionControlNotification::new(packet.ucicontrolpacket).unwrap()
18635     }
18636 }
18637 impl TryFrom<UciControlPacket> for DataCreditNtf {
18638     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<DataCreditNtf, Self::Error>18639     fn try_from(packet: UciControlPacket) -> Result<DataCreditNtf, Self::Error> {
18640         DataCreditNtf::new(packet.ucicontrolpacket)
18641     }
18642 }
18643 impl DataCreditNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>18644     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
18645         let mut cell = Cell::new(bytes);
18646         let packet = Self::parse_inner(&mut cell)?;
18647         Ok(packet)
18648     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>18649     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
18650         let data = UciControlPacketData::parse_inner(&mut bytes)?;
18651         Self::new(data)
18652     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>18653     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
18654         let ucinotification = match &ucicontrolpacket.child {
18655             UciControlPacketDataChild::UciNotification(value) => value.clone(),
18656             _ => {
18657                 return Err(DecodeError::InvalidChildError {
18658                     expected: stringify!(UciControlPacketDataChild::UciNotification),
18659                     actual: format!("{:?}", & ucicontrolpacket.child),
18660                 });
18661             }
18662         };
18663         let sessioncontrolnotification = match &ucinotification.child {
18664             UciNotificationDataChild::SessionControlNotification(value) => value.clone(),
18665             _ => {
18666                 return Err(DecodeError::InvalidChildError {
18667                     expected: stringify!(
18668                         UciNotificationDataChild::SessionControlNotification
18669                     ),
18670                     actual: format!("{:?}", & ucinotification.child),
18671                 });
18672             }
18673         };
18674         let datacreditntf = match &sessioncontrolnotification.child {
18675             SessionControlNotificationDataChild::DataCreditNtf(value) => value.clone(),
18676             _ => {
18677                 return Err(DecodeError::InvalidChildError {
18678                     expected: stringify!(
18679                         SessionControlNotificationDataChild::DataCreditNtf
18680                     ),
18681                     actual: format!("{:?}", & sessioncontrolnotification.child),
18682                 });
18683             }
18684         };
18685         Ok(Self {
18686             ucicontrolpacket,
18687             ucinotification,
18688             sessioncontrolnotification,
18689             datacreditntf,
18690         })
18691     }
get_credit_availability(&self) -> CreditAvailability18692     pub fn get_credit_availability(&self) -> CreditAvailability {
18693         self.datacreditntf.credit_availability
18694     }
get_group_id(&self) -> GroupId18695     pub fn get_group_id(&self) -> GroupId {
18696         self.ucicontrolpacket.group_id
18697     }
get_message_type(&self) -> MessageType18698     pub fn get_message_type(&self) -> MessageType {
18699         self.ucicontrolpacket.message_type
18700     }
get_opcode(&self) -> u818701     pub fn get_opcode(&self) -> u8 {
18702         self.ucicontrolpacket.opcode
18703     }
get_session_token(&self) -> u3218704     pub fn get_session_token(&self) -> u32 {
18705         self.datacreditntf.session_token
18706     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>18707     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
18708         self.datacreditntf.write_to(buffer)
18709     }
get_size(&self) -> usize18710     pub fn get_size(&self) -> usize {
18711         self.ucicontrolpacket.get_size()
18712     }
18713 }
18714 impl DataCreditNtfBuilder {
build(self) -> DataCreditNtf18715     pub fn build(self) -> DataCreditNtf {
18716         let datacreditntf = DataCreditNtfData {
18717             credit_availability: self.credit_availability,
18718             session_token: self.session_token,
18719         };
18720         let sessioncontrolnotification = SessionControlNotificationData {
18721             child: SessionControlNotificationDataChild::DataCreditNtf(datacreditntf),
18722         };
18723         let ucinotification = UciNotificationData {
18724             child: UciNotificationDataChild::SessionControlNotification(
18725                 sessioncontrolnotification,
18726             ),
18727         };
18728         let ucicontrolpacket = UciControlPacketData {
18729             group_id: GroupId::SessionControl,
18730             message_type: MessageType::Notification,
18731             opcode: 4,
18732             child: UciControlPacketDataChild::UciNotification(ucinotification),
18733         };
18734         DataCreditNtf::new(ucicontrolpacket).unwrap()
18735     }
18736 }
18737 impl From<DataCreditNtfBuilder> for UciControlPacket {
from(builder: DataCreditNtfBuilder) -> UciControlPacket18738     fn from(builder: DataCreditNtfBuilder) -> UciControlPacket {
18739         builder.build().into()
18740     }
18741 }
18742 impl From<DataCreditNtfBuilder> for UciNotification {
from(builder: DataCreditNtfBuilder) -> UciNotification18743     fn from(builder: DataCreditNtfBuilder) -> UciNotification {
18744         builder.build().into()
18745     }
18746 }
18747 impl From<DataCreditNtfBuilder> for SessionControlNotification {
from(builder: DataCreditNtfBuilder) -> SessionControlNotification18748     fn from(builder: DataCreditNtfBuilder) -> SessionControlNotification {
18749         builder.build().into()
18750     }
18751 }
18752 impl From<DataCreditNtfBuilder> for DataCreditNtf {
from(builder: DataCreditNtfBuilder) -> DataCreditNtf18753     fn from(builder: DataCreditNtfBuilder) -> DataCreditNtf {
18754         builder.build().into()
18755     }
18756 }
18757 #[derive(Debug, Clone, PartialEq, Eq)]
18758 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18759 pub struct DataTransferStatusNtfData {
18760     session_token: u32,
18761     uci_sequence_number: u16,
18762     status: DataTransferNtfStatusCode,
18763     tx_count: u8,
18764 }
18765 #[derive(Debug, Clone, PartialEq, Eq)]
18766 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18767 pub struct DataTransferStatusNtf {
18768     #[cfg_attr(feature = "serde", serde(flatten))]
18769     ucicontrolpacket: UciControlPacketData,
18770     #[cfg_attr(feature = "serde", serde(flatten))]
18771     ucinotification: UciNotificationData,
18772     #[cfg_attr(feature = "serde", serde(flatten))]
18773     sessioncontrolnotification: SessionControlNotificationData,
18774     #[cfg_attr(feature = "serde", serde(flatten))]
18775     datatransferstatusntf: DataTransferStatusNtfData,
18776 }
18777 #[derive(Debug)]
18778 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18779 pub struct DataTransferStatusNtfBuilder {
18780     pub session_token: u32,
18781     pub status: DataTransferNtfStatusCode,
18782     pub tx_count: u8,
18783     pub uci_sequence_number: u16,
18784 }
18785 impl DataTransferStatusNtfData {
conforms(bytes: &[u8]) -> bool18786     fn conforms(bytes: &[u8]) -> bool {
18787         bytes.len() >= 8
18788     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>18789     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
18790         let mut cell = Cell::new(bytes);
18791         let packet = Self::parse_inner(&mut cell)?;
18792         Ok(packet)
18793     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>18794     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
18795         if bytes.get().remaining() < 4 {
18796             return Err(DecodeError::InvalidLengthError {
18797                 obj: "DataTransferStatusNtf",
18798                 wanted: 4,
18799                 got: bytes.get().remaining(),
18800             });
18801         }
18802         let session_token = bytes.get_mut().get_u32_le();
18803         if bytes.get().remaining() < 2 {
18804             return Err(DecodeError::InvalidLengthError {
18805                 obj: "DataTransferStatusNtf",
18806                 wanted: 2,
18807                 got: bytes.get().remaining(),
18808             });
18809         }
18810         let uci_sequence_number = bytes.get_mut().get_u16_le();
18811         if bytes.get().remaining() < 1 {
18812             return Err(DecodeError::InvalidLengthError {
18813                 obj: "DataTransferStatusNtf",
18814                 wanted: 1,
18815                 got: bytes.get().remaining(),
18816             });
18817         }
18818         let status = DataTransferNtfStatusCode::try_from(bytes.get_mut().get_u8())
18819             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
18820                 obj: "DataTransferStatusNtf",
18821                 field: "status",
18822                 value: unknown_val as u64,
18823                 type_: "DataTransferNtfStatusCode",
18824             })?;
18825         if bytes.get().remaining() < 1 {
18826             return Err(DecodeError::InvalidLengthError {
18827                 obj: "DataTransferStatusNtf",
18828                 wanted: 1,
18829                 got: bytes.get().remaining(),
18830             });
18831         }
18832         let tx_count = bytes.get_mut().get_u8();
18833         Ok(Self {
18834             session_token,
18835             uci_sequence_number,
18836             status,
18837             tx_count,
18838         })
18839     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>18840     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
18841         buffer.put_u32_le(self.session_token);
18842         buffer.put_u16_le(self.uci_sequence_number);
18843         buffer.put_u8(u8::from(self.status));
18844         buffer.put_u8(self.tx_count);
18845         Ok(())
18846     }
get_total_size(&self) -> usize18847     fn get_total_size(&self) -> usize {
18848         self.get_size()
18849     }
get_size(&self) -> usize18850     fn get_size(&self) -> usize {
18851         8
18852     }
18853 }
18854 impl Packet for DataTransferStatusNtf {
encoded_len(&self) -> usize18855     fn encoded_len(&self) -> usize {
18856         self.get_size()
18857     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>18858     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
18859         self.ucicontrolpacket.write_to(buf)
18860     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>18861     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
18862         unimplemented!("Rust legacy does not implement full packet trait")
18863     }
18864 }
18865 impl TryFrom<DataTransferStatusNtf> for Bytes {
18866     type Error = EncodeError;
try_from(packet: DataTransferStatusNtf) -> Result<Self, Self::Error>18867     fn try_from(packet: DataTransferStatusNtf) -> Result<Self, Self::Error> {
18868         packet.encode_to_bytes()
18869     }
18870 }
18871 impl TryFrom<DataTransferStatusNtf> for Vec<u8> {
18872     type Error = EncodeError;
try_from(packet: DataTransferStatusNtf) -> Result<Self, Self::Error>18873     fn try_from(packet: DataTransferStatusNtf) -> Result<Self, Self::Error> {
18874         packet.encode_to_vec()
18875     }
18876 }
18877 impl From<DataTransferStatusNtf> for UciControlPacket {
from(packet: DataTransferStatusNtf) -> UciControlPacket18878     fn from(packet: DataTransferStatusNtf) -> UciControlPacket {
18879         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
18880     }
18881 }
18882 impl From<DataTransferStatusNtf> for UciNotification {
from(packet: DataTransferStatusNtf) -> UciNotification18883     fn from(packet: DataTransferStatusNtf) -> UciNotification {
18884         UciNotification::new(packet.ucicontrolpacket).unwrap()
18885     }
18886 }
18887 impl From<DataTransferStatusNtf> for SessionControlNotification {
from(packet: DataTransferStatusNtf) -> SessionControlNotification18888     fn from(packet: DataTransferStatusNtf) -> SessionControlNotification {
18889         SessionControlNotification::new(packet.ucicontrolpacket).unwrap()
18890     }
18891 }
18892 impl TryFrom<UciControlPacket> for DataTransferStatusNtf {
18893     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<DataTransferStatusNtf, Self::Error>18894     fn try_from(packet: UciControlPacket) -> Result<DataTransferStatusNtf, Self::Error> {
18895         DataTransferStatusNtf::new(packet.ucicontrolpacket)
18896     }
18897 }
18898 impl DataTransferStatusNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>18899     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
18900         let mut cell = Cell::new(bytes);
18901         let packet = Self::parse_inner(&mut cell)?;
18902         Ok(packet)
18903     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>18904     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
18905         let data = UciControlPacketData::parse_inner(&mut bytes)?;
18906         Self::new(data)
18907     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>18908     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
18909         let ucinotification = match &ucicontrolpacket.child {
18910             UciControlPacketDataChild::UciNotification(value) => value.clone(),
18911             _ => {
18912                 return Err(DecodeError::InvalidChildError {
18913                     expected: stringify!(UciControlPacketDataChild::UciNotification),
18914                     actual: format!("{:?}", & ucicontrolpacket.child),
18915                 });
18916             }
18917         };
18918         let sessioncontrolnotification = match &ucinotification.child {
18919             UciNotificationDataChild::SessionControlNotification(value) => value.clone(),
18920             _ => {
18921                 return Err(DecodeError::InvalidChildError {
18922                     expected: stringify!(
18923                         UciNotificationDataChild::SessionControlNotification
18924                     ),
18925                     actual: format!("{:?}", & ucinotification.child),
18926                 });
18927             }
18928         };
18929         let datatransferstatusntf = match &sessioncontrolnotification.child {
18930             SessionControlNotificationDataChild::DataTransferStatusNtf(value) => {
18931                 value.clone()
18932             }
18933             _ => {
18934                 return Err(DecodeError::InvalidChildError {
18935                     expected: stringify!(
18936                         SessionControlNotificationDataChild::DataTransferStatusNtf
18937                     ),
18938                     actual: format!("{:?}", & sessioncontrolnotification.child),
18939                 });
18940             }
18941         };
18942         Ok(Self {
18943             ucicontrolpacket,
18944             ucinotification,
18945             sessioncontrolnotification,
18946             datatransferstatusntf,
18947         })
18948     }
get_group_id(&self) -> GroupId18949     pub fn get_group_id(&self) -> GroupId {
18950         self.ucicontrolpacket.group_id
18951     }
get_message_type(&self) -> MessageType18952     pub fn get_message_type(&self) -> MessageType {
18953         self.ucicontrolpacket.message_type
18954     }
get_opcode(&self) -> u818955     pub fn get_opcode(&self) -> u8 {
18956         self.ucicontrolpacket.opcode
18957     }
get_session_token(&self) -> u3218958     pub fn get_session_token(&self) -> u32 {
18959         self.datatransferstatusntf.session_token
18960     }
get_status(&self) -> DataTransferNtfStatusCode18961     pub fn get_status(&self) -> DataTransferNtfStatusCode {
18962         self.datatransferstatusntf.status
18963     }
get_tx_count(&self) -> u818964     pub fn get_tx_count(&self) -> u8 {
18965         self.datatransferstatusntf.tx_count
18966     }
get_uci_sequence_number(&self) -> u1618967     pub fn get_uci_sequence_number(&self) -> u16 {
18968         self.datatransferstatusntf.uci_sequence_number
18969     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>18970     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
18971         self.datatransferstatusntf.write_to(buffer)
18972     }
get_size(&self) -> usize18973     pub fn get_size(&self) -> usize {
18974         self.ucicontrolpacket.get_size()
18975     }
18976 }
18977 impl DataTransferStatusNtfBuilder {
build(self) -> DataTransferStatusNtf18978     pub fn build(self) -> DataTransferStatusNtf {
18979         let datatransferstatusntf = DataTransferStatusNtfData {
18980             session_token: self.session_token,
18981             status: self.status,
18982             tx_count: self.tx_count,
18983             uci_sequence_number: self.uci_sequence_number,
18984         };
18985         let sessioncontrolnotification = SessionControlNotificationData {
18986             child: SessionControlNotificationDataChild::DataTransferStatusNtf(
18987                 datatransferstatusntf,
18988             ),
18989         };
18990         let ucinotification = UciNotificationData {
18991             child: UciNotificationDataChild::SessionControlNotification(
18992                 sessioncontrolnotification,
18993             ),
18994         };
18995         let ucicontrolpacket = UciControlPacketData {
18996             group_id: GroupId::SessionControl,
18997             message_type: MessageType::Notification,
18998             opcode: 5,
18999             child: UciControlPacketDataChild::UciNotification(ucinotification),
19000         };
19001         DataTransferStatusNtf::new(ucicontrolpacket).unwrap()
19002     }
19003 }
19004 impl From<DataTransferStatusNtfBuilder> for UciControlPacket {
from(builder: DataTransferStatusNtfBuilder) -> UciControlPacket19005     fn from(builder: DataTransferStatusNtfBuilder) -> UciControlPacket {
19006         builder.build().into()
19007     }
19008 }
19009 impl From<DataTransferStatusNtfBuilder> for UciNotification {
from(builder: DataTransferStatusNtfBuilder) -> UciNotification19010     fn from(builder: DataTransferStatusNtfBuilder) -> UciNotification {
19011         builder.build().into()
19012     }
19013 }
19014 impl From<DataTransferStatusNtfBuilder> for SessionControlNotification {
from(builder: DataTransferStatusNtfBuilder) -> SessionControlNotification19015     fn from(builder: DataTransferStatusNtfBuilder) -> SessionControlNotification {
19016         builder.build().into()
19017     }
19018 }
19019 impl From<DataTransferStatusNtfBuilder> for DataTransferStatusNtf {
from(builder: DataTransferStatusNtfBuilder) -> DataTransferStatusNtf19020     fn from(builder: DataTransferStatusNtfBuilder) -> DataTransferStatusNtf {
19021         builder.build().into()
19022     }
19023 }
19024 #[derive(Debug, Clone, PartialEq, Eq)]
19025 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19026 pub struct SessionQueryMaxDataSizeCmdData {
19027     session_token: u32,
19028 }
19029 #[derive(Debug, Clone, PartialEq, Eq)]
19030 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19031 pub struct SessionQueryMaxDataSizeCmd {
19032     #[cfg_attr(feature = "serde", serde(flatten))]
19033     ucicontrolpacket: UciControlPacketData,
19034     #[cfg_attr(feature = "serde", serde(flatten))]
19035     ucicommand: UciCommandData,
19036     #[cfg_attr(feature = "serde", serde(flatten))]
19037     sessionconfigcommand: SessionConfigCommandData,
19038     #[cfg_attr(feature = "serde", serde(flatten))]
19039     sessionquerymaxdatasizecmd: SessionQueryMaxDataSizeCmdData,
19040 }
19041 #[derive(Debug)]
19042 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19043 pub struct SessionQueryMaxDataSizeCmdBuilder {
19044     pub session_token: u32,
19045 }
19046 impl SessionQueryMaxDataSizeCmdData {
conforms(bytes: &[u8]) -> bool19047     fn conforms(bytes: &[u8]) -> bool {
19048         bytes.len() >= 4
19049     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>19050     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
19051         let mut cell = Cell::new(bytes);
19052         let packet = Self::parse_inner(&mut cell)?;
19053         Ok(packet)
19054     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>19055     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
19056         if bytes.get().remaining() < 4 {
19057             return Err(DecodeError::InvalidLengthError {
19058                 obj: "SessionQueryMaxDataSizeCmd",
19059                 wanted: 4,
19060                 got: bytes.get().remaining(),
19061             });
19062         }
19063         let session_token = bytes.get_mut().get_u32_le();
19064         Ok(Self { session_token })
19065     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>19066     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
19067         buffer.put_u32_le(self.session_token);
19068         Ok(())
19069     }
get_total_size(&self) -> usize19070     fn get_total_size(&self) -> usize {
19071         self.get_size()
19072     }
get_size(&self) -> usize19073     fn get_size(&self) -> usize {
19074         4
19075     }
19076 }
19077 impl Packet for SessionQueryMaxDataSizeCmd {
encoded_len(&self) -> usize19078     fn encoded_len(&self) -> usize {
19079         self.get_size()
19080     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>19081     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
19082         self.ucicontrolpacket.write_to(buf)
19083     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>19084     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
19085         unimplemented!("Rust legacy does not implement full packet trait")
19086     }
19087 }
19088 impl TryFrom<SessionQueryMaxDataSizeCmd> for Bytes {
19089     type Error = EncodeError;
try_from(packet: SessionQueryMaxDataSizeCmd) -> Result<Self, Self::Error>19090     fn try_from(packet: SessionQueryMaxDataSizeCmd) -> Result<Self, Self::Error> {
19091         packet.encode_to_bytes()
19092     }
19093 }
19094 impl TryFrom<SessionQueryMaxDataSizeCmd> for Vec<u8> {
19095     type Error = EncodeError;
try_from(packet: SessionQueryMaxDataSizeCmd) -> Result<Self, Self::Error>19096     fn try_from(packet: SessionQueryMaxDataSizeCmd) -> Result<Self, Self::Error> {
19097         packet.encode_to_vec()
19098     }
19099 }
19100 impl From<SessionQueryMaxDataSizeCmd> for UciControlPacket {
from(packet: SessionQueryMaxDataSizeCmd) -> UciControlPacket19101     fn from(packet: SessionQueryMaxDataSizeCmd) -> UciControlPacket {
19102         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
19103     }
19104 }
19105 impl From<SessionQueryMaxDataSizeCmd> for UciCommand {
from(packet: SessionQueryMaxDataSizeCmd) -> UciCommand19106     fn from(packet: SessionQueryMaxDataSizeCmd) -> UciCommand {
19107         UciCommand::new(packet.ucicontrolpacket).unwrap()
19108     }
19109 }
19110 impl From<SessionQueryMaxDataSizeCmd> for SessionConfigCommand {
from(packet: SessionQueryMaxDataSizeCmd) -> SessionConfigCommand19111     fn from(packet: SessionQueryMaxDataSizeCmd) -> SessionConfigCommand {
19112         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
19113     }
19114 }
19115 impl TryFrom<UciControlPacket> for SessionQueryMaxDataSizeCmd {
19116     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionQueryMaxDataSizeCmd, Self::Error>19117     fn try_from(
19118         packet: UciControlPacket,
19119     ) -> Result<SessionQueryMaxDataSizeCmd, Self::Error> {
19120         SessionQueryMaxDataSizeCmd::new(packet.ucicontrolpacket)
19121     }
19122 }
19123 impl SessionQueryMaxDataSizeCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>19124     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
19125         let mut cell = Cell::new(bytes);
19126         let packet = Self::parse_inner(&mut cell)?;
19127         Ok(packet)
19128     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>19129     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
19130         let data = UciControlPacketData::parse_inner(&mut bytes)?;
19131         Self::new(data)
19132     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>19133     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
19134         let ucicommand = match &ucicontrolpacket.child {
19135             UciControlPacketDataChild::UciCommand(value) => value.clone(),
19136             _ => {
19137                 return Err(DecodeError::InvalidChildError {
19138                     expected: stringify!(UciControlPacketDataChild::UciCommand),
19139                     actual: format!("{:?}", & ucicontrolpacket.child),
19140                 });
19141             }
19142         };
19143         let sessionconfigcommand = match &ucicommand.child {
19144             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
19145             _ => {
19146                 return Err(DecodeError::InvalidChildError {
19147                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
19148                     actual: format!("{:?}", & ucicommand.child),
19149                 });
19150             }
19151         };
19152         let sessionquerymaxdatasizecmd = match &sessionconfigcommand.child {
19153             SessionConfigCommandDataChild::SessionQueryMaxDataSizeCmd(value) => {
19154                 value.clone()
19155             }
19156             _ => {
19157                 return Err(DecodeError::InvalidChildError {
19158                     expected: stringify!(
19159                         SessionConfigCommandDataChild::SessionQueryMaxDataSizeCmd
19160                     ),
19161                     actual: format!("{:?}", & sessionconfigcommand.child),
19162                 });
19163             }
19164         };
19165         Ok(Self {
19166             ucicontrolpacket,
19167             ucicommand,
19168             sessionconfigcommand,
19169             sessionquerymaxdatasizecmd,
19170         })
19171     }
get_group_id(&self) -> GroupId19172     pub fn get_group_id(&self) -> GroupId {
19173         self.ucicontrolpacket.group_id
19174     }
get_message_type(&self) -> MessageType19175     pub fn get_message_type(&self) -> MessageType {
19176         self.ucicontrolpacket.message_type
19177     }
get_opcode(&self) -> u819178     pub fn get_opcode(&self) -> u8 {
19179         self.ucicontrolpacket.opcode
19180     }
get_session_token(&self) -> u3219181     pub fn get_session_token(&self) -> u32 {
19182         self.sessionquerymaxdatasizecmd.session_token
19183     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>19184     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
19185         self.sessionquerymaxdatasizecmd.write_to(buffer)
19186     }
get_size(&self) -> usize19187     pub fn get_size(&self) -> usize {
19188         self.ucicontrolpacket.get_size()
19189     }
19190 }
19191 impl SessionQueryMaxDataSizeCmdBuilder {
build(self) -> SessionQueryMaxDataSizeCmd19192     pub fn build(self) -> SessionQueryMaxDataSizeCmd {
19193         let sessionquerymaxdatasizecmd = SessionQueryMaxDataSizeCmdData {
19194             session_token: self.session_token,
19195         };
19196         let sessionconfigcommand = SessionConfigCommandData {
19197             child: SessionConfigCommandDataChild::SessionQueryMaxDataSizeCmd(
19198                 sessionquerymaxdatasizecmd,
19199             ),
19200         };
19201         let ucicommand = UciCommandData {
19202             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
19203         };
19204         let ucicontrolpacket = UciControlPacketData {
19205             group_id: GroupId::SessionConfig,
19206             message_type: MessageType::Command,
19207             opcode: 11,
19208             child: UciControlPacketDataChild::UciCommand(ucicommand),
19209         };
19210         SessionQueryMaxDataSizeCmd::new(ucicontrolpacket).unwrap()
19211     }
19212 }
19213 impl From<SessionQueryMaxDataSizeCmdBuilder> for UciControlPacket {
from(builder: SessionQueryMaxDataSizeCmdBuilder) -> UciControlPacket19214     fn from(builder: SessionQueryMaxDataSizeCmdBuilder) -> UciControlPacket {
19215         builder.build().into()
19216     }
19217 }
19218 impl From<SessionQueryMaxDataSizeCmdBuilder> for UciCommand {
from(builder: SessionQueryMaxDataSizeCmdBuilder) -> UciCommand19219     fn from(builder: SessionQueryMaxDataSizeCmdBuilder) -> UciCommand {
19220         builder.build().into()
19221     }
19222 }
19223 impl From<SessionQueryMaxDataSizeCmdBuilder> for SessionConfigCommand {
from(builder: SessionQueryMaxDataSizeCmdBuilder) -> SessionConfigCommand19224     fn from(builder: SessionQueryMaxDataSizeCmdBuilder) -> SessionConfigCommand {
19225         builder.build().into()
19226     }
19227 }
19228 impl From<SessionQueryMaxDataSizeCmdBuilder> for SessionQueryMaxDataSizeCmd {
from(builder: SessionQueryMaxDataSizeCmdBuilder) -> SessionQueryMaxDataSizeCmd19229     fn from(builder: SessionQueryMaxDataSizeCmdBuilder) -> SessionQueryMaxDataSizeCmd {
19230         builder.build().into()
19231     }
19232 }
19233 #[derive(Debug, Clone, PartialEq, Eq)]
19234 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19235 pub struct SessionQueryMaxDataSizeRspData {
19236     session_token: u32,
19237     status: StatusCode,
19238     max_data_size: u16,
19239 }
19240 #[derive(Debug, Clone, PartialEq, Eq)]
19241 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19242 pub struct SessionQueryMaxDataSizeRsp {
19243     #[cfg_attr(feature = "serde", serde(flatten))]
19244     ucicontrolpacket: UciControlPacketData,
19245     #[cfg_attr(feature = "serde", serde(flatten))]
19246     uciresponse: UciResponseData,
19247     #[cfg_attr(feature = "serde", serde(flatten))]
19248     sessionconfigresponse: SessionConfigResponseData,
19249     #[cfg_attr(feature = "serde", serde(flatten))]
19250     sessionquerymaxdatasizersp: SessionQueryMaxDataSizeRspData,
19251 }
19252 #[derive(Debug)]
19253 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19254 pub struct SessionQueryMaxDataSizeRspBuilder {
19255     pub max_data_size: u16,
19256     pub session_token: u32,
19257     pub status: StatusCode,
19258 }
19259 impl SessionQueryMaxDataSizeRspData {
conforms(bytes: &[u8]) -> bool19260     fn conforms(bytes: &[u8]) -> bool {
19261         bytes.len() >= 7
19262     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>19263     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
19264         let mut cell = Cell::new(bytes);
19265         let packet = Self::parse_inner(&mut cell)?;
19266         Ok(packet)
19267     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>19268     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
19269         if bytes.get().remaining() < 4 {
19270             return Err(DecodeError::InvalidLengthError {
19271                 obj: "SessionQueryMaxDataSizeRsp",
19272                 wanted: 4,
19273                 got: bytes.get().remaining(),
19274             });
19275         }
19276         let session_token = bytes.get_mut().get_u32_le();
19277         if bytes.get().remaining() < 1 {
19278             return Err(DecodeError::InvalidLengthError {
19279                 obj: "SessionQueryMaxDataSizeRsp",
19280                 wanted: 1,
19281                 got: bytes.get().remaining(),
19282             });
19283         }
19284         let status = StatusCode::try_from(bytes.get_mut().get_u8())
19285             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
19286                 obj: "SessionQueryMaxDataSizeRsp",
19287                 field: "status",
19288                 value: unknown_val as u64,
19289                 type_: "StatusCode",
19290             })?;
19291         if bytes.get().remaining() < 2 {
19292             return Err(DecodeError::InvalidLengthError {
19293                 obj: "SessionQueryMaxDataSizeRsp",
19294                 wanted: 2,
19295                 got: bytes.get().remaining(),
19296             });
19297         }
19298         let max_data_size = bytes.get_mut().get_u16_le();
19299         Ok(Self {
19300             session_token,
19301             status,
19302             max_data_size,
19303         })
19304     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>19305     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
19306         buffer.put_u32_le(self.session_token);
19307         buffer.put_u8(u8::from(self.status));
19308         buffer.put_u16_le(self.max_data_size);
19309         Ok(())
19310     }
get_total_size(&self) -> usize19311     fn get_total_size(&self) -> usize {
19312         self.get_size()
19313     }
get_size(&self) -> usize19314     fn get_size(&self) -> usize {
19315         7
19316     }
19317 }
19318 impl Packet for SessionQueryMaxDataSizeRsp {
encoded_len(&self) -> usize19319     fn encoded_len(&self) -> usize {
19320         self.get_size()
19321     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>19322     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
19323         self.ucicontrolpacket.write_to(buf)
19324     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>19325     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
19326         unimplemented!("Rust legacy does not implement full packet trait")
19327     }
19328 }
19329 impl TryFrom<SessionQueryMaxDataSizeRsp> for Bytes {
19330     type Error = EncodeError;
try_from(packet: SessionQueryMaxDataSizeRsp) -> Result<Self, Self::Error>19331     fn try_from(packet: SessionQueryMaxDataSizeRsp) -> Result<Self, Self::Error> {
19332         packet.encode_to_bytes()
19333     }
19334 }
19335 impl TryFrom<SessionQueryMaxDataSizeRsp> for Vec<u8> {
19336     type Error = EncodeError;
try_from(packet: SessionQueryMaxDataSizeRsp) -> Result<Self, Self::Error>19337     fn try_from(packet: SessionQueryMaxDataSizeRsp) -> Result<Self, Self::Error> {
19338         packet.encode_to_vec()
19339     }
19340 }
19341 impl From<SessionQueryMaxDataSizeRsp> for UciControlPacket {
from(packet: SessionQueryMaxDataSizeRsp) -> UciControlPacket19342     fn from(packet: SessionQueryMaxDataSizeRsp) -> UciControlPacket {
19343         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
19344     }
19345 }
19346 impl From<SessionQueryMaxDataSizeRsp> for UciResponse {
from(packet: SessionQueryMaxDataSizeRsp) -> UciResponse19347     fn from(packet: SessionQueryMaxDataSizeRsp) -> UciResponse {
19348         UciResponse::new(packet.ucicontrolpacket).unwrap()
19349     }
19350 }
19351 impl From<SessionQueryMaxDataSizeRsp> for SessionConfigResponse {
from(packet: SessionQueryMaxDataSizeRsp) -> SessionConfigResponse19352     fn from(packet: SessionQueryMaxDataSizeRsp) -> SessionConfigResponse {
19353         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
19354     }
19355 }
19356 impl TryFrom<UciControlPacket> for SessionQueryMaxDataSizeRsp {
19357     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionQueryMaxDataSizeRsp, Self::Error>19358     fn try_from(
19359         packet: UciControlPacket,
19360     ) -> Result<SessionQueryMaxDataSizeRsp, Self::Error> {
19361         SessionQueryMaxDataSizeRsp::new(packet.ucicontrolpacket)
19362     }
19363 }
19364 impl SessionQueryMaxDataSizeRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>19365     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
19366         let mut cell = Cell::new(bytes);
19367         let packet = Self::parse_inner(&mut cell)?;
19368         Ok(packet)
19369     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>19370     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
19371         let data = UciControlPacketData::parse_inner(&mut bytes)?;
19372         Self::new(data)
19373     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>19374     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
19375         let uciresponse = match &ucicontrolpacket.child {
19376             UciControlPacketDataChild::UciResponse(value) => value.clone(),
19377             _ => {
19378                 return Err(DecodeError::InvalidChildError {
19379                     expected: stringify!(UciControlPacketDataChild::UciResponse),
19380                     actual: format!("{:?}", & ucicontrolpacket.child),
19381                 });
19382             }
19383         };
19384         let sessionconfigresponse = match &uciresponse.child {
19385             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
19386             _ => {
19387                 return Err(DecodeError::InvalidChildError {
19388                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
19389                     actual: format!("{:?}", & uciresponse.child),
19390                 });
19391             }
19392         };
19393         let sessionquerymaxdatasizersp = match &sessionconfigresponse.child {
19394             SessionConfigResponseDataChild::SessionQueryMaxDataSizeRsp(value) => {
19395                 value.clone()
19396             }
19397             _ => {
19398                 return Err(DecodeError::InvalidChildError {
19399                     expected: stringify!(
19400                         SessionConfigResponseDataChild::SessionQueryMaxDataSizeRsp
19401                     ),
19402                     actual: format!("{:?}", & sessionconfigresponse.child),
19403                 });
19404             }
19405         };
19406         Ok(Self {
19407             ucicontrolpacket,
19408             uciresponse,
19409             sessionconfigresponse,
19410             sessionquerymaxdatasizersp,
19411         })
19412     }
get_group_id(&self) -> GroupId19413     pub fn get_group_id(&self) -> GroupId {
19414         self.ucicontrolpacket.group_id
19415     }
get_max_data_size(&self) -> u1619416     pub fn get_max_data_size(&self) -> u16 {
19417         self.sessionquerymaxdatasizersp.max_data_size
19418     }
get_message_type(&self) -> MessageType19419     pub fn get_message_type(&self) -> MessageType {
19420         self.ucicontrolpacket.message_type
19421     }
get_opcode(&self) -> u819422     pub fn get_opcode(&self) -> u8 {
19423         self.ucicontrolpacket.opcode
19424     }
get_session_token(&self) -> u3219425     pub fn get_session_token(&self) -> u32 {
19426         self.sessionquerymaxdatasizersp.session_token
19427     }
get_status(&self) -> StatusCode19428     pub fn get_status(&self) -> StatusCode {
19429         self.sessionquerymaxdatasizersp.status
19430     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>19431     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
19432         self.sessionquerymaxdatasizersp.write_to(buffer)
19433     }
get_size(&self) -> usize19434     pub fn get_size(&self) -> usize {
19435         self.ucicontrolpacket.get_size()
19436     }
19437 }
19438 impl SessionQueryMaxDataSizeRspBuilder {
build(self) -> SessionQueryMaxDataSizeRsp19439     pub fn build(self) -> SessionQueryMaxDataSizeRsp {
19440         let sessionquerymaxdatasizersp = SessionQueryMaxDataSizeRspData {
19441             max_data_size: self.max_data_size,
19442             session_token: self.session_token,
19443             status: self.status,
19444         };
19445         let sessionconfigresponse = SessionConfigResponseData {
19446             child: SessionConfigResponseDataChild::SessionQueryMaxDataSizeRsp(
19447                 sessionquerymaxdatasizersp,
19448             ),
19449         };
19450         let uciresponse = UciResponseData {
19451             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
19452         };
19453         let ucicontrolpacket = UciControlPacketData {
19454             group_id: GroupId::SessionConfig,
19455             message_type: MessageType::Response,
19456             opcode: 11,
19457             child: UciControlPacketDataChild::UciResponse(uciresponse),
19458         };
19459         SessionQueryMaxDataSizeRsp::new(ucicontrolpacket).unwrap()
19460     }
19461 }
19462 impl From<SessionQueryMaxDataSizeRspBuilder> for UciControlPacket {
from(builder: SessionQueryMaxDataSizeRspBuilder) -> UciControlPacket19463     fn from(builder: SessionQueryMaxDataSizeRspBuilder) -> UciControlPacket {
19464         builder.build().into()
19465     }
19466 }
19467 impl From<SessionQueryMaxDataSizeRspBuilder> for UciResponse {
from(builder: SessionQueryMaxDataSizeRspBuilder) -> UciResponse19468     fn from(builder: SessionQueryMaxDataSizeRspBuilder) -> UciResponse {
19469         builder.build().into()
19470     }
19471 }
19472 impl From<SessionQueryMaxDataSizeRspBuilder> for SessionConfigResponse {
from(builder: SessionQueryMaxDataSizeRspBuilder) -> SessionConfigResponse19473     fn from(builder: SessionQueryMaxDataSizeRspBuilder) -> SessionConfigResponse {
19474         builder.build().into()
19475     }
19476 }
19477 impl From<SessionQueryMaxDataSizeRspBuilder> for SessionQueryMaxDataSizeRsp {
from(builder: SessionQueryMaxDataSizeRspBuilder) -> SessionQueryMaxDataSizeRsp19478     fn from(builder: SessionQueryMaxDataSizeRspBuilder) -> SessionQueryMaxDataSizeRsp {
19479         builder.build().into()
19480     }
19481 }
19482 #[derive(Debug, Clone, PartialEq, Eq)]
19483 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19484 pub enum SessionDataTransferPhaseConfigCmdDataChild {
19485     Payload(Bytes),
19486     None,
19487 }
19488 impl SessionDataTransferPhaseConfigCmdDataChild {
get_total_size(&self) -> usize19489     fn get_total_size(&self) -> usize {
19490         match self {
19491             SessionDataTransferPhaseConfigCmdDataChild::Payload(bytes) => bytes.len(),
19492             SessionDataTransferPhaseConfigCmdDataChild::None => 0,
19493         }
19494     }
19495 }
19496 #[derive(Debug, Clone, PartialEq, Eq)]
19497 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19498 pub enum SessionDataTransferPhaseConfigCmdChild {
19499     Payload(Bytes),
19500     None,
19501 }
19502 #[derive(Debug, Clone, PartialEq, Eq)]
19503 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19504 pub struct SessionDataTransferPhaseConfigCmdData {
19505     session_token: u32,
19506     dtpcm_repetition: u8,
19507     data_transfer_control: u8,
19508     dtpml_size: u8,
19509     child: SessionDataTransferPhaseConfigCmdDataChild,
19510 }
19511 #[derive(Debug, Clone, PartialEq, Eq)]
19512 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19513 pub struct SessionDataTransferPhaseConfigCmd {
19514     #[cfg_attr(feature = "serde", serde(flatten))]
19515     ucicontrolpacket: UciControlPacketData,
19516     #[cfg_attr(feature = "serde", serde(flatten))]
19517     ucicommand: UciCommandData,
19518     #[cfg_attr(feature = "serde", serde(flatten))]
19519     sessionconfigcommand: SessionConfigCommandData,
19520     #[cfg_attr(feature = "serde", serde(flatten))]
19521     sessiondatatransferphaseconfigcmd: SessionDataTransferPhaseConfigCmdData,
19522 }
19523 #[derive(Debug)]
19524 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19525 pub struct SessionDataTransferPhaseConfigCmdBuilder {
19526     pub data_transfer_control: u8,
19527     pub dtpcm_repetition: u8,
19528     pub dtpml_size: u8,
19529     pub session_token: u32,
19530     pub payload: Option<Bytes>,
19531 }
19532 impl SessionDataTransferPhaseConfigCmdData {
conforms(bytes: &[u8]) -> bool19533     fn conforms(bytes: &[u8]) -> bool {
19534         bytes.len() >= 7
19535     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>19536     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
19537         let mut cell = Cell::new(bytes);
19538         let packet = Self::parse_inner(&mut cell)?;
19539         Ok(packet)
19540     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>19541     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
19542         if bytes.get().remaining() < 4 {
19543             return Err(DecodeError::InvalidLengthError {
19544                 obj: "SessionDataTransferPhaseConfigCmd",
19545                 wanted: 4,
19546                 got: bytes.get().remaining(),
19547             });
19548         }
19549         let session_token = bytes.get_mut().get_u32_le();
19550         if bytes.get().remaining() < 1 {
19551             return Err(DecodeError::InvalidLengthError {
19552                 obj: "SessionDataTransferPhaseConfigCmd",
19553                 wanted: 1,
19554                 got: bytes.get().remaining(),
19555             });
19556         }
19557         let dtpcm_repetition = bytes.get_mut().get_u8();
19558         if bytes.get().remaining() < 1 {
19559             return Err(DecodeError::InvalidLengthError {
19560                 obj: "SessionDataTransferPhaseConfigCmd",
19561                 wanted: 1,
19562                 got: bytes.get().remaining(),
19563             });
19564         }
19565         let data_transfer_control = bytes.get_mut().get_u8();
19566         if bytes.get().remaining() < 1 {
19567             return Err(DecodeError::InvalidLengthError {
19568                 obj: "SessionDataTransferPhaseConfigCmd",
19569                 wanted: 1,
19570                 got: bytes.get().remaining(),
19571             });
19572         }
19573         let dtpml_size = bytes.get_mut().get_u8();
19574         let payload = bytes.get();
19575         bytes.get_mut().advance(payload.len());
19576         let child = match () {
19577             _ if !payload.is_empty() => {
19578                 SessionDataTransferPhaseConfigCmdDataChild::Payload(
19579                     Bytes::copy_from_slice(payload),
19580                 )
19581             }
19582             _ => SessionDataTransferPhaseConfigCmdDataChild::None,
19583         };
19584         Ok(Self {
19585             session_token,
19586             dtpcm_repetition,
19587             data_transfer_control,
19588             dtpml_size,
19589             child,
19590         })
19591     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>19592     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
19593         buffer.put_u32_le(self.session_token);
19594         buffer.put_u8(self.dtpcm_repetition);
19595         buffer.put_u8(self.data_transfer_control);
19596         buffer.put_u8(self.dtpml_size);
19597         match &self.child {
19598             SessionDataTransferPhaseConfigCmdDataChild::Payload(payload) => {
19599                 buffer.put_slice(payload)
19600             }
19601             SessionDataTransferPhaseConfigCmdDataChild::None => {}
19602         }
19603         Ok(())
19604     }
get_total_size(&self) -> usize19605     fn get_total_size(&self) -> usize {
19606         self.get_size()
19607     }
get_size(&self) -> usize19608     fn get_size(&self) -> usize {
19609         7 + self.child.get_total_size()
19610     }
19611 }
19612 impl Packet for SessionDataTransferPhaseConfigCmd {
encoded_len(&self) -> usize19613     fn encoded_len(&self) -> usize {
19614         self.get_size()
19615     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>19616     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
19617         self.ucicontrolpacket.write_to(buf)
19618     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>19619     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
19620         unimplemented!("Rust legacy does not implement full packet trait")
19621     }
19622 }
19623 impl TryFrom<SessionDataTransferPhaseConfigCmd> for Bytes {
19624     type Error = EncodeError;
try_from(packet: SessionDataTransferPhaseConfigCmd) -> Result<Self, Self::Error>19625     fn try_from(packet: SessionDataTransferPhaseConfigCmd) -> Result<Self, Self::Error> {
19626         packet.encode_to_bytes()
19627     }
19628 }
19629 impl TryFrom<SessionDataTransferPhaseConfigCmd> for Vec<u8> {
19630     type Error = EncodeError;
try_from(packet: SessionDataTransferPhaseConfigCmd) -> Result<Self, Self::Error>19631     fn try_from(packet: SessionDataTransferPhaseConfigCmd) -> Result<Self, Self::Error> {
19632         packet.encode_to_vec()
19633     }
19634 }
19635 impl From<SessionDataTransferPhaseConfigCmd> for UciControlPacket {
from(packet: SessionDataTransferPhaseConfigCmd) -> UciControlPacket19636     fn from(packet: SessionDataTransferPhaseConfigCmd) -> UciControlPacket {
19637         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
19638     }
19639 }
19640 impl From<SessionDataTransferPhaseConfigCmd> for UciCommand {
from(packet: SessionDataTransferPhaseConfigCmd) -> UciCommand19641     fn from(packet: SessionDataTransferPhaseConfigCmd) -> UciCommand {
19642         UciCommand::new(packet.ucicontrolpacket).unwrap()
19643     }
19644 }
19645 impl From<SessionDataTransferPhaseConfigCmd> for SessionConfigCommand {
from(packet: SessionDataTransferPhaseConfigCmd) -> SessionConfigCommand19646     fn from(packet: SessionDataTransferPhaseConfigCmd) -> SessionConfigCommand {
19647         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
19648     }
19649 }
19650 impl TryFrom<UciControlPacket> for SessionDataTransferPhaseConfigCmd {
19651     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionDataTransferPhaseConfigCmd, Self::Error>19652     fn try_from(
19653         packet: UciControlPacket,
19654     ) -> Result<SessionDataTransferPhaseConfigCmd, Self::Error> {
19655         SessionDataTransferPhaseConfigCmd::new(packet.ucicontrolpacket)
19656     }
19657 }
19658 impl SessionDataTransferPhaseConfigCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>19659     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
19660         let mut cell = Cell::new(bytes);
19661         let packet = Self::parse_inner(&mut cell)?;
19662         Ok(packet)
19663     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>19664     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
19665         let data = UciControlPacketData::parse_inner(&mut bytes)?;
19666         Self::new(data)
19667     }
specialize(&self) -> SessionDataTransferPhaseConfigCmdChild19668     pub fn specialize(&self) -> SessionDataTransferPhaseConfigCmdChild {
19669         match &self.sessiondatatransferphaseconfigcmd.child {
19670             SessionDataTransferPhaseConfigCmdDataChild::Payload(payload) => {
19671                 SessionDataTransferPhaseConfigCmdChild::Payload(payload.clone())
19672             }
19673             SessionDataTransferPhaseConfigCmdDataChild::None => {
19674                 SessionDataTransferPhaseConfigCmdChild::None
19675             }
19676         }
19677     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>19678     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
19679         let ucicommand = match &ucicontrolpacket.child {
19680             UciControlPacketDataChild::UciCommand(value) => value.clone(),
19681             _ => {
19682                 return Err(DecodeError::InvalidChildError {
19683                     expected: stringify!(UciControlPacketDataChild::UciCommand),
19684                     actual: format!("{:?}", & ucicontrolpacket.child),
19685                 });
19686             }
19687         };
19688         let sessionconfigcommand = match &ucicommand.child {
19689             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
19690             _ => {
19691                 return Err(DecodeError::InvalidChildError {
19692                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
19693                     actual: format!("{:?}", & ucicommand.child),
19694                 });
19695             }
19696         };
19697         let sessiondatatransferphaseconfigcmd = match &sessionconfigcommand.child {
19698             SessionConfigCommandDataChild::SessionDataTransferPhaseConfigCmd(value) => {
19699                 value.clone()
19700             }
19701             _ => {
19702                 return Err(DecodeError::InvalidChildError {
19703                     expected: stringify!(
19704                         SessionConfigCommandDataChild::SessionDataTransferPhaseConfigCmd
19705                     ),
19706                     actual: format!("{:?}", & sessionconfigcommand.child),
19707                 });
19708             }
19709         };
19710         Ok(Self {
19711             ucicontrolpacket,
19712             ucicommand,
19713             sessionconfigcommand,
19714             sessiondatatransferphaseconfigcmd,
19715         })
19716     }
get_data_transfer_control(&self) -> u819717     pub fn get_data_transfer_control(&self) -> u8 {
19718         self.sessiondatatransferphaseconfigcmd.data_transfer_control
19719     }
get_dtpcm_repetition(&self) -> u819720     pub fn get_dtpcm_repetition(&self) -> u8 {
19721         self.sessiondatatransferphaseconfigcmd.dtpcm_repetition
19722     }
get_dtpml_size(&self) -> u819723     pub fn get_dtpml_size(&self) -> u8 {
19724         self.sessiondatatransferphaseconfigcmd.dtpml_size
19725     }
get_group_id(&self) -> GroupId19726     pub fn get_group_id(&self) -> GroupId {
19727         self.ucicontrolpacket.group_id
19728     }
get_message_type(&self) -> MessageType19729     pub fn get_message_type(&self) -> MessageType {
19730         self.ucicontrolpacket.message_type
19731     }
get_opcode(&self) -> u819732     pub fn get_opcode(&self) -> u8 {
19733         self.ucicontrolpacket.opcode
19734     }
get_session_token(&self) -> u3219735     pub fn get_session_token(&self) -> u32 {
19736         self.sessiondatatransferphaseconfigcmd.session_token
19737     }
get_payload(&self) -> &[u8]19738     pub fn get_payload(&self) -> &[u8] {
19739         match &self.sessiondatatransferphaseconfigcmd.child {
19740             SessionDataTransferPhaseConfigCmdDataChild::Payload(bytes) => &bytes,
19741             SessionDataTransferPhaseConfigCmdDataChild::None => &[],
19742         }
19743     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>19744     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
19745         self.sessiondatatransferphaseconfigcmd.write_to(buffer)
19746     }
get_size(&self) -> usize19747     pub fn get_size(&self) -> usize {
19748         self.ucicontrolpacket.get_size()
19749     }
19750 }
19751 impl SessionDataTransferPhaseConfigCmdBuilder {
build(self) -> SessionDataTransferPhaseConfigCmd19752     pub fn build(self) -> SessionDataTransferPhaseConfigCmd {
19753         let sessiondatatransferphaseconfigcmd = SessionDataTransferPhaseConfigCmdData {
19754             data_transfer_control: self.data_transfer_control,
19755             dtpcm_repetition: self.dtpcm_repetition,
19756             dtpml_size: self.dtpml_size,
19757             session_token: self.session_token,
19758             child: match self.payload {
19759                 None => SessionDataTransferPhaseConfigCmdDataChild::None,
19760                 Some(bytes) => SessionDataTransferPhaseConfigCmdDataChild::Payload(bytes),
19761             },
19762         };
19763         let sessionconfigcommand = SessionConfigCommandData {
19764             child: SessionConfigCommandDataChild::SessionDataTransferPhaseConfigCmd(
19765                 sessiondatatransferphaseconfigcmd,
19766             ),
19767         };
19768         let ucicommand = UciCommandData {
19769             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
19770         };
19771         let ucicontrolpacket = UciControlPacketData {
19772             group_id: GroupId::SessionConfig,
19773             message_type: MessageType::Command,
19774             opcode: 14,
19775             child: UciControlPacketDataChild::UciCommand(ucicommand),
19776         };
19777         SessionDataTransferPhaseConfigCmd::new(ucicontrolpacket).unwrap()
19778     }
19779 }
19780 impl From<SessionDataTransferPhaseConfigCmdBuilder> for UciControlPacket {
from(builder: SessionDataTransferPhaseConfigCmdBuilder) -> UciControlPacket19781     fn from(builder: SessionDataTransferPhaseConfigCmdBuilder) -> UciControlPacket {
19782         builder.build().into()
19783     }
19784 }
19785 impl From<SessionDataTransferPhaseConfigCmdBuilder> for UciCommand {
from(builder: SessionDataTransferPhaseConfigCmdBuilder) -> UciCommand19786     fn from(builder: SessionDataTransferPhaseConfigCmdBuilder) -> UciCommand {
19787         builder.build().into()
19788     }
19789 }
19790 impl From<SessionDataTransferPhaseConfigCmdBuilder> for SessionConfigCommand {
from(builder: SessionDataTransferPhaseConfigCmdBuilder) -> SessionConfigCommand19791     fn from(builder: SessionDataTransferPhaseConfigCmdBuilder) -> SessionConfigCommand {
19792         builder.build().into()
19793     }
19794 }
19795 impl From<SessionDataTransferPhaseConfigCmdBuilder>
19796 for SessionDataTransferPhaseConfigCmd {
from( builder: SessionDataTransferPhaseConfigCmdBuilder, ) -> SessionDataTransferPhaseConfigCmd19797     fn from(
19798         builder: SessionDataTransferPhaseConfigCmdBuilder,
19799     ) -> SessionDataTransferPhaseConfigCmd {
19800         builder.build().into()
19801     }
19802 }
19803 #[derive(Debug, Clone, PartialEq, Eq)]
19804 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19805 pub struct SessionDataTransferPhaseConfigRspData {
19806     status: StatusCode,
19807 }
19808 #[derive(Debug, Clone, PartialEq, Eq)]
19809 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19810 pub struct SessionDataTransferPhaseConfigRsp {
19811     #[cfg_attr(feature = "serde", serde(flatten))]
19812     ucicontrolpacket: UciControlPacketData,
19813     #[cfg_attr(feature = "serde", serde(flatten))]
19814     uciresponse: UciResponseData,
19815     #[cfg_attr(feature = "serde", serde(flatten))]
19816     sessionconfigresponse: SessionConfigResponseData,
19817     #[cfg_attr(feature = "serde", serde(flatten))]
19818     sessiondatatransferphaseconfigrsp: SessionDataTransferPhaseConfigRspData,
19819 }
19820 #[derive(Debug)]
19821 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
19822 pub struct SessionDataTransferPhaseConfigRspBuilder {
19823     pub status: StatusCode,
19824 }
19825 impl SessionDataTransferPhaseConfigRspData {
conforms(bytes: &[u8]) -> bool19826     fn conforms(bytes: &[u8]) -> bool {
19827         bytes.len() >= 1
19828     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>19829     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
19830         let mut cell = Cell::new(bytes);
19831         let packet = Self::parse_inner(&mut cell)?;
19832         Ok(packet)
19833     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>19834     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
19835         if bytes.get().remaining() < 1 {
19836             return Err(DecodeError::InvalidLengthError {
19837                 obj: "SessionDataTransferPhaseConfigRsp",
19838                 wanted: 1,
19839                 got: bytes.get().remaining(),
19840             });
19841         }
19842         let status = StatusCode::try_from(bytes.get_mut().get_u8())
19843             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
19844                 obj: "SessionDataTransferPhaseConfigRsp",
19845                 field: "status",
19846                 value: unknown_val as u64,
19847                 type_: "StatusCode",
19848             })?;
19849         Ok(Self { status })
19850     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>19851     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
19852         buffer.put_u8(u8::from(self.status));
19853         Ok(())
19854     }
get_total_size(&self) -> usize19855     fn get_total_size(&self) -> usize {
19856         self.get_size()
19857     }
get_size(&self) -> usize19858     fn get_size(&self) -> usize {
19859         1
19860     }
19861 }
19862 impl Packet for SessionDataTransferPhaseConfigRsp {
encoded_len(&self) -> usize19863     fn encoded_len(&self) -> usize {
19864         self.get_size()
19865     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>19866     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
19867         self.ucicontrolpacket.write_to(buf)
19868     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>19869     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
19870         unimplemented!("Rust legacy does not implement full packet trait")
19871     }
19872 }
19873 impl TryFrom<SessionDataTransferPhaseConfigRsp> for Bytes {
19874     type Error = EncodeError;
try_from(packet: SessionDataTransferPhaseConfigRsp) -> Result<Self, Self::Error>19875     fn try_from(packet: SessionDataTransferPhaseConfigRsp) -> Result<Self, Self::Error> {
19876         packet.encode_to_bytes()
19877     }
19878 }
19879 impl TryFrom<SessionDataTransferPhaseConfigRsp> for Vec<u8> {
19880     type Error = EncodeError;
try_from(packet: SessionDataTransferPhaseConfigRsp) -> Result<Self, Self::Error>19881     fn try_from(packet: SessionDataTransferPhaseConfigRsp) -> Result<Self, Self::Error> {
19882         packet.encode_to_vec()
19883     }
19884 }
19885 impl From<SessionDataTransferPhaseConfigRsp> for UciControlPacket {
from(packet: SessionDataTransferPhaseConfigRsp) -> UciControlPacket19886     fn from(packet: SessionDataTransferPhaseConfigRsp) -> UciControlPacket {
19887         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
19888     }
19889 }
19890 impl From<SessionDataTransferPhaseConfigRsp> for UciResponse {
from(packet: SessionDataTransferPhaseConfigRsp) -> UciResponse19891     fn from(packet: SessionDataTransferPhaseConfigRsp) -> UciResponse {
19892         UciResponse::new(packet.ucicontrolpacket).unwrap()
19893     }
19894 }
19895 impl From<SessionDataTransferPhaseConfigRsp> for SessionConfigResponse {
from(packet: SessionDataTransferPhaseConfigRsp) -> SessionConfigResponse19896     fn from(packet: SessionDataTransferPhaseConfigRsp) -> SessionConfigResponse {
19897         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
19898     }
19899 }
19900 impl TryFrom<UciControlPacket> for SessionDataTransferPhaseConfigRsp {
19901     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionDataTransferPhaseConfigRsp, Self::Error>19902     fn try_from(
19903         packet: UciControlPacket,
19904     ) -> Result<SessionDataTransferPhaseConfigRsp, Self::Error> {
19905         SessionDataTransferPhaseConfigRsp::new(packet.ucicontrolpacket)
19906     }
19907 }
19908 impl SessionDataTransferPhaseConfigRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>19909     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
19910         let mut cell = Cell::new(bytes);
19911         let packet = Self::parse_inner(&mut cell)?;
19912         Ok(packet)
19913     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>19914     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
19915         let data = UciControlPacketData::parse_inner(&mut bytes)?;
19916         Self::new(data)
19917     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>19918     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
19919         let uciresponse = match &ucicontrolpacket.child {
19920             UciControlPacketDataChild::UciResponse(value) => value.clone(),
19921             _ => {
19922                 return Err(DecodeError::InvalidChildError {
19923                     expected: stringify!(UciControlPacketDataChild::UciResponse),
19924                     actual: format!("{:?}", & ucicontrolpacket.child),
19925                 });
19926             }
19927         };
19928         let sessionconfigresponse = match &uciresponse.child {
19929             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
19930             _ => {
19931                 return Err(DecodeError::InvalidChildError {
19932                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
19933                     actual: format!("{:?}", & uciresponse.child),
19934                 });
19935             }
19936         };
19937         let sessiondatatransferphaseconfigrsp = match &sessionconfigresponse.child {
19938             SessionConfigResponseDataChild::SessionDataTransferPhaseConfigRsp(value) => {
19939                 value.clone()
19940             }
19941             _ => {
19942                 return Err(DecodeError::InvalidChildError {
19943                     expected: stringify!(
19944                         SessionConfigResponseDataChild::SessionDataTransferPhaseConfigRsp
19945                     ),
19946                     actual: format!("{:?}", & sessionconfigresponse.child),
19947                 });
19948             }
19949         };
19950         Ok(Self {
19951             ucicontrolpacket,
19952             uciresponse,
19953             sessionconfigresponse,
19954             sessiondatatransferphaseconfigrsp,
19955         })
19956     }
get_group_id(&self) -> GroupId19957     pub fn get_group_id(&self) -> GroupId {
19958         self.ucicontrolpacket.group_id
19959     }
get_message_type(&self) -> MessageType19960     pub fn get_message_type(&self) -> MessageType {
19961         self.ucicontrolpacket.message_type
19962     }
get_opcode(&self) -> u819963     pub fn get_opcode(&self) -> u8 {
19964         self.ucicontrolpacket.opcode
19965     }
get_status(&self) -> StatusCode19966     pub fn get_status(&self) -> StatusCode {
19967         self.sessiondatatransferphaseconfigrsp.status
19968     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>19969     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
19970         self.sessiondatatransferphaseconfigrsp.write_to(buffer)
19971     }
get_size(&self) -> usize19972     pub fn get_size(&self) -> usize {
19973         self.ucicontrolpacket.get_size()
19974     }
19975 }
19976 impl SessionDataTransferPhaseConfigRspBuilder {
build(self) -> SessionDataTransferPhaseConfigRsp19977     pub fn build(self) -> SessionDataTransferPhaseConfigRsp {
19978         let sessiondatatransferphaseconfigrsp = SessionDataTransferPhaseConfigRspData {
19979             status: self.status,
19980         };
19981         let sessionconfigresponse = SessionConfigResponseData {
19982             child: SessionConfigResponseDataChild::SessionDataTransferPhaseConfigRsp(
19983                 sessiondatatransferphaseconfigrsp,
19984             ),
19985         };
19986         let uciresponse = UciResponseData {
19987             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
19988         };
19989         let ucicontrolpacket = UciControlPacketData {
19990             group_id: GroupId::SessionConfig,
19991             message_type: MessageType::Response,
19992             opcode: 14,
19993             child: UciControlPacketDataChild::UciResponse(uciresponse),
19994         };
19995         SessionDataTransferPhaseConfigRsp::new(ucicontrolpacket).unwrap()
19996     }
19997 }
19998 impl From<SessionDataTransferPhaseConfigRspBuilder> for UciControlPacket {
from(builder: SessionDataTransferPhaseConfigRspBuilder) -> UciControlPacket19999     fn from(builder: SessionDataTransferPhaseConfigRspBuilder) -> UciControlPacket {
20000         builder.build().into()
20001     }
20002 }
20003 impl From<SessionDataTransferPhaseConfigRspBuilder> for UciResponse {
from(builder: SessionDataTransferPhaseConfigRspBuilder) -> UciResponse20004     fn from(builder: SessionDataTransferPhaseConfigRspBuilder) -> UciResponse {
20005         builder.build().into()
20006     }
20007 }
20008 impl From<SessionDataTransferPhaseConfigRspBuilder> for SessionConfigResponse {
from(builder: SessionDataTransferPhaseConfigRspBuilder) -> SessionConfigResponse20009     fn from(builder: SessionDataTransferPhaseConfigRspBuilder) -> SessionConfigResponse {
20010         builder.build().into()
20011     }
20012 }
20013 impl From<SessionDataTransferPhaseConfigRspBuilder>
20014 for SessionDataTransferPhaseConfigRsp {
from( builder: SessionDataTransferPhaseConfigRspBuilder, ) -> SessionDataTransferPhaseConfigRsp20015     fn from(
20016         builder: SessionDataTransferPhaseConfigRspBuilder,
20017     ) -> SessionDataTransferPhaseConfigRsp {
20018         builder.build().into()
20019     }
20020 }
20021 #[derive(Debug, Clone, PartialEq, Eq)]
20022 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20023 pub struct SessionDataTransferPhaseConfigNtfData {
20024     session_token: u32,
20025     status: DataTransferPhaseConfigUpdateStatusCode,
20026 }
20027 #[derive(Debug, Clone, PartialEq, Eq)]
20028 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20029 pub struct SessionDataTransferPhaseConfigNtf {
20030     #[cfg_attr(feature = "serde", serde(flatten))]
20031     ucicontrolpacket: UciControlPacketData,
20032     #[cfg_attr(feature = "serde", serde(flatten))]
20033     ucinotification: UciNotificationData,
20034     #[cfg_attr(feature = "serde", serde(flatten))]
20035     sessionconfignotification: SessionConfigNotificationData,
20036     #[cfg_attr(feature = "serde", serde(flatten))]
20037     sessiondatatransferphaseconfigntf: SessionDataTransferPhaseConfigNtfData,
20038 }
20039 #[derive(Debug)]
20040 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20041 pub struct SessionDataTransferPhaseConfigNtfBuilder {
20042     pub session_token: u32,
20043     pub status: DataTransferPhaseConfigUpdateStatusCode,
20044 }
20045 impl SessionDataTransferPhaseConfigNtfData {
conforms(bytes: &[u8]) -> bool20046     fn conforms(bytes: &[u8]) -> bool {
20047         bytes.len() >= 5
20048     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>20049     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
20050         let mut cell = Cell::new(bytes);
20051         let packet = Self::parse_inner(&mut cell)?;
20052         Ok(packet)
20053     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>20054     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
20055         if bytes.get().remaining() < 4 {
20056             return Err(DecodeError::InvalidLengthError {
20057                 obj: "SessionDataTransferPhaseConfigNtf",
20058                 wanted: 4,
20059                 got: bytes.get().remaining(),
20060             });
20061         }
20062         let session_token = bytes.get_mut().get_u32_le();
20063         if bytes.get().remaining() < 1 {
20064             return Err(DecodeError::InvalidLengthError {
20065                 obj: "SessionDataTransferPhaseConfigNtf",
20066                 wanted: 1,
20067                 got: bytes.get().remaining(),
20068             });
20069         }
20070         let status = DataTransferPhaseConfigUpdateStatusCode::try_from(
20071                 bytes.get_mut().get_u8(),
20072             )
20073             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
20074                 obj: "SessionDataTransferPhaseConfigNtf",
20075                 field: "status",
20076                 value: unknown_val as u64,
20077                 type_: "DataTransferPhaseConfigUpdateStatusCode",
20078             })?;
20079         Ok(Self { session_token, status })
20080     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>20081     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
20082         buffer.put_u32_le(self.session_token);
20083         buffer.put_u8(u8::from(self.status));
20084         Ok(())
20085     }
get_total_size(&self) -> usize20086     fn get_total_size(&self) -> usize {
20087         self.get_size()
20088     }
get_size(&self) -> usize20089     fn get_size(&self) -> usize {
20090         5
20091     }
20092 }
20093 impl Packet for SessionDataTransferPhaseConfigNtf {
encoded_len(&self) -> usize20094     fn encoded_len(&self) -> usize {
20095         self.get_size()
20096     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>20097     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
20098         self.ucicontrolpacket.write_to(buf)
20099     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>20100     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
20101         unimplemented!("Rust legacy does not implement full packet trait")
20102     }
20103 }
20104 impl TryFrom<SessionDataTransferPhaseConfigNtf> for Bytes {
20105     type Error = EncodeError;
try_from(packet: SessionDataTransferPhaseConfigNtf) -> Result<Self, Self::Error>20106     fn try_from(packet: SessionDataTransferPhaseConfigNtf) -> Result<Self, Self::Error> {
20107         packet.encode_to_bytes()
20108     }
20109 }
20110 impl TryFrom<SessionDataTransferPhaseConfigNtf> for Vec<u8> {
20111     type Error = EncodeError;
try_from(packet: SessionDataTransferPhaseConfigNtf) -> Result<Self, Self::Error>20112     fn try_from(packet: SessionDataTransferPhaseConfigNtf) -> Result<Self, Self::Error> {
20113         packet.encode_to_vec()
20114     }
20115 }
20116 impl From<SessionDataTransferPhaseConfigNtf> for UciControlPacket {
from(packet: SessionDataTransferPhaseConfigNtf) -> UciControlPacket20117     fn from(packet: SessionDataTransferPhaseConfigNtf) -> UciControlPacket {
20118         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
20119     }
20120 }
20121 impl From<SessionDataTransferPhaseConfigNtf> for UciNotification {
from(packet: SessionDataTransferPhaseConfigNtf) -> UciNotification20122     fn from(packet: SessionDataTransferPhaseConfigNtf) -> UciNotification {
20123         UciNotification::new(packet.ucicontrolpacket).unwrap()
20124     }
20125 }
20126 impl From<SessionDataTransferPhaseConfigNtf> for SessionConfigNotification {
from(packet: SessionDataTransferPhaseConfigNtf) -> SessionConfigNotification20127     fn from(packet: SessionDataTransferPhaseConfigNtf) -> SessionConfigNotification {
20128         SessionConfigNotification::new(packet.ucicontrolpacket).unwrap()
20129     }
20130 }
20131 impl TryFrom<UciControlPacket> for SessionDataTransferPhaseConfigNtf {
20132     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionDataTransferPhaseConfigNtf, Self::Error>20133     fn try_from(
20134         packet: UciControlPacket,
20135     ) -> Result<SessionDataTransferPhaseConfigNtf, Self::Error> {
20136         SessionDataTransferPhaseConfigNtf::new(packet.ucicontrolpacket)
20137     }
20138 }
20139 impl SessionDataTransferPhaseConfigNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>20140     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
20141         let mut cell = Cell::new(bytes);
20142         let packet = Self::parse_inner(&mut cell)?;
20143         Ok(packet)
20144     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>20145     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
20146         let data = UciControlPacketData::parse_inner(&mut bytes)?;
20147         Self::new(data)
20148     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>20149     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
20150         let ucinotification = match &ucicontrolpacket.child {
20151             UciControlPacketDataChild::UciNotification(value) => value.clone(),
20152             _ => {
20153                 return Err(DecodeError::InvalidChildError {
20154                     expected: stringify!(UciControlPacketDataChild::UciNotification),
20155                     actual: format!("{:?}", & ucicontrolpacket.child),
20156                 });
20157             }
20158         };
20159         let sessionconfignotification = match &ucinotification.child {
20160             UciNotificationDataChild::SessionConfigNotification(value) => value.clone(),
20161             _ => {
20162                 return Err(DecodeError::InvalidChildError {
20163                     expected: stringify!(
20164                         UciNotificationDataChild::SessionConfigNotification
20165                     ),
20166                     actual: format!("{:?}", & ucinotification.child),
20167                 });
20168             }
20169         };
20170         let sessiondatatransferphaseconfigntf = match &sessionconfignotification.child {
20171             SessionConfigNotificationDataChild::SessionDataTransferPhaseConfigNtf(
20172                 value,
20173             ) => value.clone(),
20174             _ => {
20175                 return Err(DecodeError::InvalidChildError {
20176                     expected: stringify!(
20177                         SessionConfigNotificationDataChild::SessionDataTransferPhaseConfigNtf
20178                     ),
20179                     actual: format!("{:?}", & sessionconfignotification.child),
20180                 });
20181             }
20182         };
20183         Ok(Self {
20184             ucicontrolpacket,
20185             ucinotification,
20186             sessionconfignotification,
20187             sessiondatatransferphaseconfigntf,
20188         })
20189     }
get_group_id(&self) -> GroupId20190     pub fn get_group_id(&self) -> GroupId {
20191         self.ucicontrolpacket.group_id
20192     }
get_message_type(&self) -> MessageType20193     pub fn get_message_type(&self) -> MessageType {
20194         self.ucicontrolpacket.message_type
20195     }
get_opcode(&self) -> u820196     pub fn get_opcode(&self) -> u8 {
20197         self.ucicontrolpacket.opcode
20198     }
get_session_token(&self) -> u3220199     pub fn get_session_token(&self) -> u32 {
20200         self.sessiondatatransferphaseconfigntf.session_token
20201     }
get_status(&self) -> DataTransferPhaseConfigUpdateStatusCode20202     pub fn get_status(&self) -> DataTransferPhaseConfigUpdateStatusCode {
20203         self.sessiondatatransferphaseconfigntf.status
20204     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>20205     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
20206         self.sessiondatatransferphaseconfigntf.write_to(buffer)
20207     }
get_size(&self) -> usize20208     pub fn get_size(&self) -> usize {
20209         self.ucicontrolpacket.get_size()
20210     }
20211 }
20212 impl SessionDataTransferPhaseConfigNtfBuilder {
build(self) -> SessionDataTransferPhaseConfigNtf20213     pub fn build(self) -> SessionDataTransferPhaseConfigNtf {
20214         let sessiondatatransferphaseconfigntf = SessionDataTransferPhaseConfigNtfData {
20215             session_token: self.session_token,
20216             status: self.status,
20217         };
20218         let sessionconfignotification = SessionConfigNotificationData {
20219             child: SessionConfigNotificationDataChild::SessionDataTransferPhaseConfigNtf(
20220                 sessiondatatransferphaseconfigntf,
20221             ),
20222         };
20223         let ucinotification = UciNotificationData {
20224             child: UciNotificationDataChild::SessionConfigNotification(
20225                 sessionconfignotification,
20226             ),
20227         };
20228         let ucicontrolpacket = UciControlPacketData {
20229             group_id: GroupId::SessionConfig,
20230             message_type: MessageType::Notification,
20231             opcode: 14,
20232             child: UciControlPacketDataChild::UciNotification(ucinotification),
20233         };
20234         SessionDataTransferPhaseConfigNtf::new(ucicontrolpacket).unwrap()
20235     }
20236 }
20237 impl From<SessionDataTransferPhaseConfigNtfBuilder> for UciControlPacket {
from(builder: SessionDataTransferPhaseConfigNtfBuilder) -> UciControlPacket20238     fn from(builder: SessionDataTransferPhaseConfigNtfBuilder) -> UciControlPacket {
20239         builder.build().into()
20240     }
20241 }
20242 impl From<SessionDataTransferPhaseConfigNtfBuilder> for UciNotification {
from(builder: SessionDataTransferPhaseConfigNtfBuilder) -> UciNotification20243     fn from(builder: SessionDataTransferPhaseConfigNtfBuilder) -> UciNotification {
20244         builder.build().into()
20245     }
20246 }
20247 impl From<SessionDataTransferPhaseConfigNtfBuilder> for SessionConfigNotification {
from( builder: SessionDataTransferPhaseConfigNtfBuilder, ) -> SessionConfigNotification20248     fn from(
20249         builder: SessionDataTransferPhaseConfigNtfBuilder,
20250     ) -> SessionConfigNotification {
20251         builder.build().into()
20252     }
20253 }
20254 impl From<SessionDataTransferPhaseConfigNtfBuilder>
20255 for SessionDataTransferPhaseConfigNtf {
from( builder: SessionDataTransferPhaseConfigNtfBuilder, ) -> SessionDataTransferPhaseConfigNtf20256     fn from(
20257         builder: SessionDataTransferPhaseConfigNtfBuilder,
20258     ) -> SessionDataTransferPhaseConfigNtf {
20259         builder.build().into()
20260     }
20261 }
20262 #[derive(Debug, Clone, PartialEq, Eq)]
20263 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20264 pub struct PhaseListShortMacAddress {
20265     pub session_token: u32,
20266     pub start_slot_index: u16,
20267     pub end_slot_index: u16,
20268     pub phase_participation: u8,
20269     pub mac_address: [u8; 2],
20270 }
20271 impl PhaseListShortMacAddress {
conforms(bytes: &[u8]) -> bool20272     fn conforms(bytes: &[u8]) -> bool {
20273         bytes.len() >= 11
20274     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>20275     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
20276         let mut cell = Cell::new(bytes);
20277         let packet = Self::parse_inner(&mut cell)?;
20278         Ok(packet)
20279     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>20280     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
20281         if bytes.get().remaining() < 4 {
20282             return Err(DecodeError::InvalidLengthError {
20283                 obj: "PhaseListShortMacAddress",
20284                 wanted: 4,
20285                 got: bytes.get().remaining(),
20286             });
20287         }
20288         let session_token = bytes.get_mut().get_u32_le();
20289         if bytes.get().remaining() < 2 {
20290             return Err(DecodeError::InvalidLengthError {
20291                 obj: "PhaseListShortMacAddress",
20292                 wanted: 2,
20293                 got: bytes.get().remaining(),
20294             });
20295         }
20296         let start_slot_index = bytes.get_mut().get_u16_le();
20297         if bytes.get().remaining() < 2 {
20298             return Err(DecodeError::InvalidLengthError {
20299                 obj: "PhaseListShortMacAddress",
20300                 wanted: 2,
20301                 got: bytes.get().remaining(),
20302             });
20303         }
20304         let end_slot_index = bytes.get_mut().get_u16_le();
20305         if bytes.get().remaining() < 1 {
20306             return Err(DecodeError::InvalidLengthError {
20307                 obj: "PhaseListShortMacAddress",
20308                 wanted: 1,
20309                 got: bytes.get().remaining(),
20310             });
20311         }
20312         let phase_participation = bytes.get_mut().get_u8();
20313         if bytes.get().remaining() < 2 {
20314             return Err(DecodeError::InvalidLengthError {
20315                 obj: "PhaseListShortMacAddress",
20316                 wanted: 2,
20317                 got: bytes.get().remaining(),
20318             });
20319         }
20320         let mac_address = (0..2)
20321             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
20322             .collect::<Result<Vec<_>, DecodeError>>()?
20323             .try_into()
20324             .map_err(|_| DecodeError::InvalidPacketError)?;
20325         Ok(Self {
20326             session_token,
20327             start_slot_index,
20328             end_slot_index,
20329             phase_participation,
20330             mac_address,
20331         })
20332     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>20333     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
20334         buffer.put_u32_le(self.session_token);
20335         buffer.put_u16_le(self.start_slot_index);
20336         buffer.put_u16_le(self.end_slot_index);
20337         buffer.put_u8(self.phase_participation);
20338         for elem in &self.mac_address {
20339             buffer.put_u8(*elem);
20340         }
20341         Ok(())
20342     }
get_total_size(&self) -> usize20343     fn get_total_size(&self) -> usize {
20344         self.get_size()
20345     }
get_size(&self) -> usize20346     fn get_size(&self) -> usize {
20347         11
20348     }
20349 }
20350 #[derive(Debug, Clone, PartialEq, Eq)]
20351 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20352 pub struct PhaseListExtendedMacAddress {
20353     pub session_token: u32,
20354     pub start_slot_index: u16,
20355     pub end_slot_index: u16,
20356     pub phase_participation: u8,
20357     pub mac_address: [u8; 8],
20358 }
20359 impl PhaseListExtendedMacAddress {
conforms(bytes: &[u8]) -> bool20360     fn conforms(bytes: &[u8]) -> bool {
20361         bytes.len() >= 17
20362     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>20363     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
20364         let mut cell = Cell::new(bytes);
20365         let packet = Self::parse_inner(&mut cell)?;
20366         Ok(packet)
20367     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>20368     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
20369         if bytes.get().remaining() < 4 {
20370             return Err(DecodeError::InvalidLengthError {
20371                 obj: "PhaseListExtendedMacAddress",
20372                 wanted: 4,
20373                 got: bytes.get().remaining(),
20374             });
20375         }
20376         let session_token = bytes.get_mut().get_u32_le();
20377         if bytes.get().remaining() < 2 {
20378             return Err(DecodeError::InvalidLengthError {
20379                 obj: "PhaseListExtendedMacAddress",
20380                 wanted: 2,
20381                 got: bytes.get().remaining(),
20382             });
20383         }
20384         let start_slot_index = bytes.get_mut().get_u16_le();
20385         if bytes.get().remaining() < 2 {
20386             return Err(DecodeError::InvalidLengthError {
20387                 obj: "PhaseListExtendedMacAddress",
20388                 wanted: 2,
20389                 got: bytes.get().remaining(),
20390             });
20391         }
20392         let end_slot_index = bytes.get_mut().get_u16_le();
20393         if bytes.get().remaining() < 1 {
20394             return Err(DecodeError::InvalidLengthError {
20395                 obj: "PhaseListExtendedMacAddress",
20396                 wanted: 1,
20397                 got: bytes.get().remaining(),
20398             });
20399         }
20400         let phase_participation = bytes.get_mut().get_u8();
20401         if bytes.get().remaining() < 8 {
20402             return Err(DecodeError::InvalidLengthError {
20403                 obj: "PhaseListExtendedMacAddress",
20404                 wanted: 8,
20405                 got: bytes.get().remaining(),
20406             });
20407         }
20408         let mac_address = (0..8)
20409             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
20410             .collect::<Result<Vec<_>, DecodeError>>()?
20411             .try_into()
20412             .map_err(|_| DecodeError::InvalidPacketError)?;
20413         Ok(Self {
20414             session_token,
20415             start_slot_index,
20416             end_slot_index,
20417             phase_participation,
20418             mac_address,
20419         })
20420     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>20421     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
20422         buffer.put_u32_le(self.session_token);
20423         buffer.put_u16_le(self.start_slot_index);
20424         buffer.put_u16_le(self.end_slot_index);
20425         buffer.put_u8(self.phase_participation);
20426         for elem in &self.mac_address {
20427             buffer.put_u8(*elem);
20428         }
20429         Ok(())
20430     }
get_total_size(&self) -> usize20431     fn get_total_size(&self) -> usize {
20432         self.get_size()
20433     }
get_size(&self) -> usize20434     fn get_size(&self) -> usize {
20435         17
20436     }
20437 }
20438 #[derive(Debug, Clone, PartialEq, Eq)]
20439 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20440 pub enum SessionSetHybridControllerConfigCmdDataChild {
20441     Payload(Bytes),
20442     None,
20443 }
20444 impl SessionSetHybridControllerConfigCmdDataChild {
get_total_size(&self) -> usize20445     fn get_total_size(&self) -> usize {
20446         match self {
20447             SessionSetHybridControllerConfigCmdDataChild::Payload(bytes) => bytes.len(),
20448             SessionSetHybridControllerConfigCmdDataChild::None => 0,
20449         }
20450     }
20451 }
20452 #[derive(Debug, Clone, PartialEq, Eq)]
20453 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20454 pub enum SessionSetHybridControllerConfigCmdChild {
20455     Payload(Bytes),
20456     None,
20457 }
20458 #[derive(Debug, Clone, PartialEq, Eq)]
20459 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20460 pub struct SessionSetHybridControllerConfigCmdData {
20461     session_token: u32,
20462     message_control: u8,
20463     number_of_phases: u8,
20464     update_time: [u8; 8],
20465     child: SessionSetHybridControllerConfigCmdDataChild,
20466 }
20467 #[derive(Debug, Clone, PartialEq, Eq)]
20468 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20469 pub struct SessionSetHybridControllerConfigCmd {
20470     #[cfg_attr(feature = "serde", serde(flatten))]
20471     ucicontrolpacket: UciControlPacketData,
20472     #[cfg_attr(feature = "serde", serde(flatten))]
20473     ucicommand: UciCommandData,
20474     #[cfg_attr(feature = "serde", serde(flatten))]
20475     sessionconfigcommand: SessionConfigCommandData,
20476     #[cfg_attr(feature = "serde", serde(flatten))]
20477     sessionsethybridcontrollerconfigcmd: SessionSetHybridControllerConfigCmdData,
20478 }
20479 #[derive(Debug)]
20480 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20481 pub struct SessionSetHybridControllerConfigCmdBuilder {
20482     pub message_control: u8,
20483     pub number_of_phases: u8,
20484     pub session_token: u32,
20485     pub update_time: [u8; 8],
20486     pub payload: Option<Bytes>,
20487 }
20488 impl SessionSetHybridControllerConfigCmdData {
conforms(bytes: &[u8]) -> bool20489     fn conforms(bytes: &[u8]) -> bool {
20490         bytes.len() >= 14
20491     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>20492     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
20493         let mut cell = Cell::new(bytes);
20494         let packet = Self::parse_inner(&mut cell)?;
20495         Ok(packet)
20496     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>20497     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
20498         if bytes.get().remaining() < 4 {
20499             return Err(DecodeError::InvalidLengthError {
20500                 obj: "SessionSetHybridControllerConfigCmd",
20501                 wanted: 4,
20502                 got: bytes.get().remaining(),
20503             });
20504         }
20505         let session_token = bytes.get_mut().get_u32_le();
20506         if bytes.get().remaining() < 1 {
20507             return Err(DecodeError::InvalidLengthError {
20508                 obj: "SessionSetHybridControllerConfigCmd",
20509                 wanted: 1,
20510                 got: bytes.get().remaining(),
20511             });
20512         }
20513         let message_control = bytes.get_mut().get_u8();
20514         if bytes.get().remaining() < 1 {
20515             return Err(DecodeError::InvalidLengthError {
20516                 obj: "SessionSetHybridControllerConfigCmd",
20517                 wanted: 1,
20518                 got: bytes.get().remaining(),
20519             });
20520         }
20521         let number_of_phases = bytes.get_mut().get_u8();
20522         if bytes.get().remaining() < 8 {
20523             return Err(DecodeError::InvalidLengthError {
20524                 obj: "SessionSetHybridControllerConfigCmd",
20525                 wanted: 8,
20526                 got: bytes.get().remaining(),
20527             });
20528         }
20529         let update_time = (0..8)
20530             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
20531             .collect::<Result<Vec<_>, DecodeError>>()?
20532             .try_into()
20533             .map_err(|_| DecodeError::InvalidPacketError)?;
20534         let payload = bytes.get();
20535         bytes.get_mut().advance(payload.len());
20536         let child = match () {
20537             _ if !payload.is_empty() => {
20538                 SessionSetHybridControllerConfigCmdDataChild::Payload(
20539                     Bytes::copy_from_slice(payload),
20540                 )
20541             }
20542             _ => SessionSetHybridControllerConfigCmdDataChild::None,
20543         };
20544         Ok(Self {
20545             session_token,
20546             message_control,
20547             number_of_phases,
20548             update_time,
20549             child,
20550         })
20551     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>20552     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
20553         buffer.put_u32_le(self.session_token);
20554         buffer.put_u8(self.message_control);
20555         buffer.put_u8(self.number_of_phases);
20556         for elem in &self.update_time {
20557             buffer.put_u8(*elem);
20558         }
20559         match &self.child {
20560             SessionSetHybridControllerConfigCmdDataChild::Payload(payload) => {
20561                 buffer.put_slice(payload)
20562             }
20563             SessionSetHybridControllerConfigCmdDataChild::None => {}
20564         }
20565         Ok(())
20566     }
get_total_size(&self) -> usize20567     fn get_total_size(&self) -> usize {
20568         self.get_size()
20569     }
get_size(&self) -> usize20570     fn get_size(&self) -> usize {
20571         14 + self.child.get_total_size()
20572     }
20573 }
20574 impl Packet for SessionSetHybridControllerConfigCmd {
encoded_len(&self) -> usize20575     fn encoded_len(&self) -> usize {
20576         self.get_size()
20577     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>20578     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
20579         self.ucicontrolpacket.write_to(buf)
20580     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>20581     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
20582         unimplemented!("Rust legacy does not implement full packet trait")
20583     }
20584 }
20585 impl TryFrom<SessionSetHybridControllerConfigCmd> for Bytes {
20586     type Error = EncodeError;
try_from( packet: SessionSetHybridControllerConfigCmd, ) -> Result<Self, Self::Error>20587     fn try_from(
20588         packet: SessionSetHybridControllerConfigCmd,
20589     ) -> Result<Self, Self::Error> {
20590         packet.encode_to_bytes()
20591     }
20592 }
20593 impl TryFrom<SessionSetHybridControllerConfigCmd> for Vec<u8> {
20594     type Error = EncodeError;
try_from( packet: SessionSetHybridControllerConfigCmd, ) -> Result<Self, Self::Error>20595     fn try_from(
20596         packet: SessionSetHybridControllerConfigCmd,
20597     ) -> Result<Self, Self::Error> {
20598         packet.encode_to_vec()
20599     }
20600 }
20601 impl From<SessionSetHybridControllerConfigCmd> for UciControlPacket {
from(packet: SessionSetHybridControllerConfigCmd) -> UciControlPacket20602     fn from(packet: SessionSetHybridControllerConfigCmd) -> UciControlPacket {
20603         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
20604     }
20605 }
20606 impl From<SessionSetHybridControllerConfigCmd> for UciCommand {
from(packet: SessionSetHybridControllerConfigCmd) -> UciCommand20607     fn from(packet: SessionSetHybridControllerConfigCmd) -> UciCommand {
20608         UciCommand::new(packet.ucicontrolpacket).unwrap()
20609     }
20610 }
20611 impl From<SessionSetHybridControllerConfigCmd> for SessionConfigCommand {
from(packet: SessionSetHybridControllerConfigCmd) -> SessionConfigCommand20612     fn from(packet: SessionSetHybridControllerConfigCmd) -> SessionConfigCommand {
20613         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
20614     }
20615 }
20616 impl TryFrom<UciControlPacket> for SessionSetHybridControllerConfigCmd {
20617     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionSetHybridControllerConfigCmd, Self::Error>20618     fn try_from(
20619         packet: UciControlPacket,
20620     ) -> Result<SessionSetHybridControllerConfigCmd, Self::Error> {
20621         SessionSetHybridControllerConfigCmd::new(packet.ucicontrolpacket)
20622     }
20623 }
20624 impl SessionSetHybridControllerConfigCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>20625     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
20626         let mut cell = Cell::new(bytes);
20627         let packet = Self::parse_inner(&mut cell)?;
20628         Ok(packet)
20629     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>20630     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
20631         let data = UciControlPacketData::parse_inner(&mut bytes)?;
20632         Self::new(data)
20633     }
specialize(&self) -> SessionSetHybridControllerConfigCmdChild20634     pub fn specialize(&self) -> SessionSetHybridControllerConfigCmdChild {
20635         match &self.sessionsethybridcontrollerconfigcmd.child {
20636             SessionSetHybridControllerConfigCmdDataChild::Payload(payload) => {
20637                 SessionSetHybridControllerConfigCmdChild::Payload(payload.clone())
20638             }
20639             SessionSetHybridControllerConfigCmdDataChild::None => {
20640                 SessionSetHybridControllerConfigCmdChild::None
20641             }
20642         }
20643     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>20644     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
20645         let ucicommand = match &ucicontrolpacket.child {
20646             UciControlPacketDataChild::UciCommand(value) => value.clone(),
20647             _ => {
20648                 return Err(DecodeError::InvalidChildError {
20649                     expected: stringify!(UciControlPacketDataChild::UciCommand),
20650                     actual: format!("{:?}", & ucicontrolpacket.child),
20651                 });
20652             }
20653         };
20654         let sessionconfigcommand = match &ucicommand.child {
20655             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
20656             _ => {
20657                 return Err(DecodeError::InvalidChildError {
20658                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
20659                     actual: format!("{:?}", & ucicommand.child),
20660                 });
20661             }
20662         };
20663         let sessionsethybridcontrollerconfigcmd = match &sessionconfigcommand.child {
20664             SessionConfigCommandDataChild::SessionSetHybridControllerConfigCmd(value) => {
20665                 value.clone()
20666             }
20667             _ => {
20668                 return Err(DecodeError::InvalidChildError {
20669                     expected: stringify!(
20670                         SessionConfigCommandDataChild::SessionSetHybridControllerConfigCmd
20671                     ),
20672                     actual: format!("{:?}", & sessionconfigcommand.child),
20673                 });
20674             }
20675         };
20676         Ok(Self {
20677             ucicontrolpacket,
20678             ucicommand,
20679             sessionconfigcommand,
20680             sessionsethybridcontrollerconfigcmd,
20681         })
20682     }
get_group_id(&self) -> GroupId20683     pub fn get_group_id(&self) -> GroupId {
20684         self.ucicontrolpacket.group_id
20685     }
get_message_control(&self) -> u820686     pub fn get_message_control(&self) -> u8 {
20687         self.sessionsethybridcontrollerconfigcmd.message_control
20688     }
get_message_type(&self) -> MessageType20689     pub fn get_message_type(&self) -> MessageType {
20690         self.ucicontrolpacket.message_type
20691     }
get_number_of_phases(&self) -> u820692     pub fn get_number_of_phases(&self) -> u8 {
20693         self.sessionsethybridcontrollerconfigcmd.number_of_phases
20694     }
get_opcode(&self) -> u820695     pub fn get_opcode(&self) -> u8 {
20696         self.ucicontrolpacket.opcode
20697     }
get_session_token(&self) -> u3220698     pub fn get_session_token(&self) -> u32 {
20699         self.sessionsethybridcontrollerconfigcmd.session_token
20700     }
get_update_time(&self) -> &[u8; 8]20701     pub fn get_update_time(&self) -> &[u8; 8] {
20702         &self.sessionsethybridcontrollerconfigcmd.update_time
20703     }
get_payload(&self) -> &[u8]20704     pub fn get_payload(&self) -> &[u8] {
20705         match &self.sessionsethybridcontrollerconfigcmd.child {
20706             SessionSetHybridControllerConfigCmdDataChild::Payload(bytes) => &bytes,
20707             SessionSetHybridControllerConfigCmdDataChild::None => &[],
20708         }
20709     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>20710     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
20711         self.sessionsethybridcontrollerconfigcmd.write_to(buffer)
20712     }
get_size(&self) -> usize20713     pub fn get_size(&self) -> usize {
20714         self.ucicontrolpacket.get_size()
20715     }
20716 }
20717 impl SessionSetHybridControllerConfigCmdBuilder {
build(self) -> SessionSetHybridControllerConfigCmd20718     pub fn build(self) -> SessionSetHybridControllerConfigCmd {
20719         let sessionsethybridcontrollerconfigcmd = SessionSetHybridControllerConfigCmdData {
20720             message_control: self.message_control,
20721             number_of_phases: self.number_of_phases,
20722             session_token: self.session_token,
20723             update_time: self.update_time,
20724             child: match self.payload {
20725                 None => SessionSetHybridControllerConfigCmdDataChild::None,
20726                 Some(bytes) => {
20727                     SessionSetHybridControllerConfigCmdDataChild::Payload(bytes)
20728                 }
20729             },
20730         };
20731         let sessionconfigcommand = SessionConfigCommandData {
20732             child: SessionConfigCommandDataChild::SessionSetHybridControllerConfigCmd(
20733                 sessionsethybridcontrollerconfigcmd,
20734             ),
20735         };
20736         let ucicommand = UciCommandData {
20737             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
20738         };
20739         let ucicontrolpacket = UciControlPacketData {
20740             group_id: GroupId::SessionConfig,
20741             message_type: MessageType::Command,
20742             opcode: 12,
20743             child: UciControlPacketDataChild::UciCommand(ucicommand),
20744         };
20745         SessionSetHybridControllerConfigCmd::new(ucicontrolpacket).unwrap()
20746     }
20747 }
20748 impl From<SessionSetHybridControllerConfigCmdBuilder> for UciControlPacket {
from(builder: SessionSetHybridControllerConfigCmdBuilder) -> UciControlPacket20749     fn from(builder: SessionSetHybridControllerConfigCmdBuilder) -> UciControlPacket {
20750         builder.build().into()
20751     }
20752 }
20753 impl From<SessionSetHybridControllerConfigCmdBuilder> for UciCommand {
from(builder: SessionSetHybridControllerConfigCmdBuilder) -> UciCommand20754     fn from(builder: SessionSetHybridControllerConfigCmdBuilder) -> UciCommand {
20755         builder.build().into()
20756     }
20757 }
20758 impl From<SessionSetHybridControllerConfigCmdBuilder> for SessionConfigCommand {
from( builder: SessionSetHybridControllerConfigCmdBuilder, ) -> SessionConfigCommand20759     fn from(
20760         builder: SessionSetHybridControllerConfigCmdBuilder,
20761     ) -> SessionConfigCommand {
20762         builder.build().into()
20763     }
20764 }
20765 impl From<SessionSetHybridControllerConfigCmdBuilder>
20766 for SessionSetHybridControllerConfigCmd {
from( builder: SessionSetHybridControllerConfigCmdBuilder, ) -> SessionSetHybridControllerConfigCmd20767     fn from(
20768         builder: SessionSetHybridControllerConfigCmdBuilder,
20769     ) -> SessionSetHybridControllerConfigCmd {
20770         builder.build().into()
20771     }
20772 }
20773 #[derive(Debug, Clone, PartialEq, Eq)]
20774 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20775 pub struct SessionSetHybridControllerConfigRspData {
20776     status: StatusCode,
20777 }
20778 #[derive(Debug, Clone, PartialEq, Eq)]
20779 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20780 pub struct SessionSetHybridControllerConfigRsp {
20781     #[cfg_attr(feature = "serde", serde(flatten))]
20782     ucicontrolpacket: UciControlPacketData,
20783     #[cfg_attr(feature = "serde", serde(flatten))]
20784     uciresponse: UciResponseData,
20785     #[cfg_attr(feature = "serde", serde(flatten))]
20786     sessionconfigresponse: SessionConfigResponseData,
20787     #[cfg_attr(feature = "serde", serde(flatten))]
20788     sessionsethybridcontrollerconfigrsp: SessionSetHybridControllerConfigRspData,
20789 }
20790 #[derive(Debug)]
20791 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20792 pub struct SessionSetHybridControllerConfigRspBuilder {
20793     pub status: StatusCode,
20794 }
20795 impl SessionSetHybridControllerConfigRspData {
conforms(bytes: &[u8]) -> bool20796     fn conforms(bytes: &[u8]) -> bool {
20797         bytes.len() >= 1
20798     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>20799     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
20800         let mut cell = Cell::new(bytes);
20801         let packet = Self::parse_inner(&mut cell)?;
20802         Ok(packet)
20803     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>20804     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
20805         if bytes.get().remaining() < 1 {
20806             return Err(DecodeError::InvalidLengthError {
20807                 obj: "SessionSetHybridControllerConfigRsp",
20808                 wanted: 1,
20809                 got: bytes.get().remaining(),
20810             });
20811         }
20812         let status = StatusCode::try_from(bytes.get_mut().get_u8())
20813             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
20814                 obj: "SessionSetHybridControllerConfigRsp",
20815                 field: "status",
20816                 value: unknown_val as u64,
20817                 type_: "StatusCode",
20818             })?;
20819         Ok(Self { status })
20820     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>20821     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
20822         buffer.put_u8(u8::from(self.status));
20823         Ok(())
20824     }
get_total_size(&self) -> usize20825     fn get_total_size(&self) -> usize {
20826         self.get_size()
20827     }
get_size(&self) -> usize20828     fn get_size(&self) -> usize {
20829         1
20830     }
20831 }
20832 impl Packet for SessionSetHybridControllerConfigRsp {
encoded_len(&self) -> usize20833     fn encoded_len(&self) -> usize {
20834         self.get_size()
20835     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>20836     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
20837         self.ucicontrolpacket.write_to(buf)
20838     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>20839     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
20840         unimplemented!("Rust legacy does not implement full packet trait")
20841     }
20842 }
20843 impl TryFrom<SessionSetHybridControllerConfigRsp> for Bytes {
20844     type Error = EncodeError;
try_from( packet: SessionSetHybridControllerConfigRsp, ) -> Result<Self, Self::Error>20845     fn try_from(
20846         packet: SessionSetHybridControllerConfigRsp,
20847     ) -> Result<Self, Self::Error> {
20848         packet.encode_to_bytes()
20849     }
20850 }
20851 impl TryFrom<SessionSetHybridControllerConfigRsp> for Vec<u8> {
20852     type Error = EncodeError;
try_from( packet: SessionSetHybridControllerConfigRsp, ) -> Result<Self, Self::Error>20853     fn try_from(
20854         packet: SessionSetHybridControllerConfigRsp,
20855     ) -> Result<Self, Self::Error> {
20856         packet.encode_to_vec()
20857     }
20858 }
20859 impl From<SessionSetHybridControllerConfigRsp> for UciControlPacket {
from(packet: SessionSetHybridControllerConfigRsp) -> UciControlPacket20860     fn from(packet: SessionSetHybridControllerConfigRsp) -> UciControlPacket {
20861         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
20862     }
20863 }
20864 impl From<SessionSetHybridControllerConfigRsp> for UciResponse {
from(packet: SessionSetHybridControllerConfigRsp) -> UciResponse20865     fn from(packet: SessionSetHybridControllerConfigRsp) -> UciResponse {
20866         UciResponse::new(packet.ucicontrolpacket).unwrap()
20867     }
20868 }
20869 impl From<SessionSetHybridControllerConfigRsp> for SessionConfigResponse {
from(packet: SessionSetHybridControllerConfigRsp) -> SessionConfigResponse20870     fn from(packet: SessionSetHybridControllerConfigRsp) -> SessionConfigResponse {
20871         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
20872     }
20873 }
20874 impl TryFrom<UciControlPacket> for SessionSetHybridControllerConfigRsp {
20875     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionSetHybridControllerConfigRsp, Self::Error>20876     fn try_from(
20877         packet: UciControlPacket,
20878     ) -> Result<SessionSetHybridControllerConfigRsp, Self::Error> {
20879         SessionSetHybridControllerConfigRsp::new(packet.ucicontrolpacket)
20880     }
20881 }
20882 impl SessionSetHybridControllerConfigRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>20883     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
20884         let mut cell = Cell::new(bytes);
20885         let packet = Self::parse_inner(&mut cell)?;
20886         Ok(packet)
20887     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>20888     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
20889         let data = UciControlPacketData::parse_inner(&mut bytes)?;
20890         Self::new(data)
20891     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>20892     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
20893         let uciresponse = match &ucicontrolpacket.child {
20894             UciControlPacketDataChild::UciResponse(value) => value.clone(),
20895             _ => {
20896                 return Err(DecodeError::InvalidChildError {
20897                     expected: stringify!(UciControlPacketDataChild::UciResponse),
20898                     actual: format!("{:?}", & ucicontrolpacket.child),
20899                 });
20900             }
20901         };
20902         let sessionconfigresponse = match &uciresponse.child {
20903             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
20904             _ => {
20905                 return Err(DecodeError::InvalidChildError {
20906                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
20907                     actual: format!("{:?}", & uciresponse.child),
20908                 });
20909             }
20910         };
20911         let sessionsethybridcontrollerconfigrsp = match &sessionconfigresponse.child {
20912             SessionConfigResponseDataChild::SessionSetHybridControllerConfigRsp(
20913                 value,
20914             ) => value.clone(),
20915             _ => {
20916                 return Err(DecodeError::InvalidChildError {
20917                     expected: stringify!(
20918                         SessionConfigResponseDataChild::SessionSetHybridControllerConfigRsp
20919                     ),
20920                     actual: format!("{:?}", & sessionconfigresponse.child),
20921                 });
20922             }
20923         };
20924         Ok(Self {
20925             ucicontrolpacket,
20926             uciresponse,
20927             sessionconfigresponse,
20928             sessionsethybridcontrollerconfigrsp,
20929         })
20930     }
get_group_id(&self) -> GroupId20931     pub fn get_group_id(&self) -> GroupId {
20932         self.ucicontrolpacket.group_id
20933     }
get_message_type(&self) -> MessageType20934     pub fn get_message_type(&self) -> MessageType {
20935         self.ucicontrolpacket.message_type
20936     }
get_opcode(&self) -> u820937     pub fn get_opcode(&self) -> u8 {
20938         self.ucicontrolpacket.opcode
20939     }
get_status(&self) -> StatusCode20940     pub fn get_status(&self) -> StatusCode {
20941         self.sessionsethybridcontrollerconfigrsp.status
20942     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>20943     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
20944         self.sessionsethybridcontrollerconfigrsp.write_to(buffer)
20945     }
get_size(&self) -> usize20946     pub fn get_size(&self) -> usize {
20947         self.ucicontrolpacket.get_size()
20948     }
20949 }
20950 impl SessionSetHybridControllerConfigRspBuilder {
build(self) -> SessionSetHybridControllerConfigRsp20951     pub fn build(self) -> SessionSetHybridControllerConfigRsp {
20952         let sessionsethybridcontrollerconfigrsp = SessionSetHybridControllerConfigRspData {
20953             status: self.status,
20954         };
20955         let sessionconfigresponse = SessionConfigResponseData {
20956             child: SessionConfigResponseDataChild::SessionSetHybridControllerConfigRsp(
20957                 sessionsethybridcontrollerconfigrsp,
20958             ),
20959         };
20960         let uciresponse = UciResponseData {
20961             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
20962         };
20963         let ucicontrolpacket = UciControlPacketData {
20964             group_id: GroupId::SessionConfig,
20965             message_type: MessageType::Response,
20966             opcode: 12,
20967             child: UciControlPacketDataChild::UciResponse(uciresponse),
20968         };
20969         SessionSetHybridControllerConfigRsp::new(ucicontrolpacket).unwrap()
20970     }
20971 }
20972 impl From<SessionSetHybridControllerConfigRspBuilder> for UciControlPacket {
from(builder: SessionSetHybridControllerConfigRspBuilder) -> UciControlPacket20973     fn from(builder: SessionSetHybridControllerConfigRspBuilder) -> UciControlPacket {
20974         builder.build().into()
20975     }
20976 }
20977 impl From<SessionSetHybridControllerConfigRspBuilder> for UciResponse {
from(builder: SessionSetHybridControllerConfigRspBuilder) -> UciResponse20978     fn from(builder: SessionSetHybridControllerConfigRspBuilder) -> UciResponse {
20979         builder.build().into()
20980     }
20981 }
20982 impl From<SessionSetHybridControllerConfigRspBuilder> for SessionConfigResponse {
from( builder: SessionSetHybridControllerConfigRspBuilder, ) -> SessionConfigResponse20983     fn from(
20984         builder: SessionSetHybridControllerConfigRspBuilder,
20985     ) -> SessionConfigResponse {
20986         builder.build().into()
20987     }
20988 }
20989 impl From<SessionSetHybridControllerConfigRspBuilder>
20990 for SessionSetHybridControllerConfigRsp {
from( builder: SessionSetHybridControllerConfigRspBuilder, ) -> SessionSetHybridControllerConfigRsp20991     fn from(
20992         builder: SessionSetHybridControllerConfigRspBuilder,
20993     ) -> SessionSetHybridControllerConfigRsp {
20994         builder.build().into()
20995     }
20996 }
20997 #[derive(Debug, Clone, PartialEq, Eq)]
20998 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20999 pub struct ControleePhaseList {
21000     pub session_token: u32,
21001     pub phase_participation: u8,
21002 }
21003 impl ControleePhaseList {
conforms(bytes: &[u8]) -> bool21004     fn conforms(bytes: &[u8]) -> bool {
21005         bytes.len() >= 5
21006     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>21007     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
21008         let mut cell = Cell::new(bytes);
21009         let packet = Self::parse_inner(&mut cell)?;
21010         Ok(packet)
21011     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>21012     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
21013         if bytes.get().remaining() < 4 {
21014             return Err(DecodeError::InvalidLengthError {
21015                 obj: "ControleePhaseList",
21016                 wanted: 4,
21017                 got: bytes.get().remaining(),
21018             });
21019         }
21020         let session_token = bytes.get_mut().get_u32_le();
21021         if bytes.get().remaining() < 1 {
21022             return Err(DecodeError::InvalidLengthError {
21023                 obj: "ControleePhaseList",
21024                 wanted: 1,
21025                 got: bytes.get().remaining(),
21026             });
21027         }
21028         let phase_participation = bytes.get_mut().get_u8();
21029         Ok(Self {
21030             session_token,
21031             phase_participation,
21032         })
21033     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>21034     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
21035         buffer.put_u32_le(self.session_token);
21036         buffer.put_u8(self.phase_participation);
21037         Ok(())
21038     }
get_total_size(&self) -> usize21039     fn get_total_size(&self) -> usize {
21040         self.get_size()
21041     }
get_size(&self) -> usize21042     fn get_size(&self) -> usize {
21043         5
21044     }
21045 }
21046 #[derive(Debug, Clone, PartialEq, Eq)]
21047 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21048 pub struct SessionSetHybridControleeConfigCmdData {
21049     session_token: u32,
21050     controlee_phase_list: Vec<ControleePhaseList>,
21051 }
21052 #[derive(Debug, Clone, PartialEq, Eq)]
21053 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21054 pub struct SessionSetHybridControleeConfigCmd {
21055     #[cfg_attr(feature = "serde", serde(flatten))]
21056     ucicontrolpacket: UciControlPacketData,
21057     #[cfg_attr(feature = "serde", serde(flatten))]
21058     ucicommand: UciCommandData,
21059     #[cfg_attr(feature = "serde", serde(flatten))]
21060     sessionconfigcommand: SessionConfigCommandData,
21061     #[cfg_attr(feature = "serde", serde(flatten))]
21062     sessionsethybridcontroleeconfigcmd: SessionSetHybridControleeConfigCmdData,
21063 }
21064 #[derive(Debug)]
21065 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21066 pub struct SessionSetHybridControleeConfigCmdBuilder {
21067     pub controlee_phase_list: Vec<ControleePhaseList>,
21068     pub session_token: u32,
21069 }
21070 impl SessionSetHybridControleeConfigCmdData {
conforms(bytes: &[u8]) -> bool21071     fn conforms(bytes: &[u8]) -> bool {
21072         bytes.len() >= 5
21073     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>21074     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
21075         let mut cell = Cell::new(bytes);
21076         let packet = Self::parse_inner(&mut cell)?;
21077         Ok(packet)
21078     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>21079     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
21080         if bytes.get().remaining() < 4 {
21081             return Err(DecodeError::InvalidLengthError {
21082                 obj: "SessionSetHybridControleeConfigCmd",
21083                 wanted: 4,
21084                 got: bytes.get().remaining(),
21085             });
21086         }
21087         let session_token = bytes.get_mut().get_u32_le();
21088         if bytes.get().remaining() < 1 {
21089             return Err(DecodeError::InvalidLengthError {
21090                 obj: "SessionSetHybridControleeConfigCmd",
21091                 wanted: 1,
21092                 got: bytes.get().remaining(),
21093             });
21094         }
21095         let controlee_phase_list_count = bytes.get_mut().get_u8() as usize;
21096         if bytes.get().remaining() < controlee_phase_list_count * 5usize {
21097             return Err(DecodeError::InvalidLengthError {
21098                 obj: "SessionSetHybridControleeConfigCmd",
21099                 wanted: controlee_phase_list_count * 5usize,
21100                 got: bytes.get().remaining(),
21101             });
21102         }
21103         let controlee_phase_list = (0..controlee_phase_list_count)
21104             .map(|_| ControleePhaseList::parse_inner(bytes))
21105             .collect::<Result<Vec<_>, DecodeError>>()?;
21106         Ok(Self {
21107             session_token,
21108             controlee_phase_list,
21109         })
21110     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>21111     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
21112         buffer.put_u32_le(self.session_token);
21113         buffer.put_u8(self.controlee_phase_list.len() as u8);
21114         for elem in &self.controlee_phase_list {
21115             elem.write_to(buffer)?;
21116         }
21117         Ok(())
21118     }
get_total_size(&self) -> usize21119     fn get_total_size(&self) -> usize {
21120         self.get_size()
21121     }
get_size(&self) -> usize21122     fn get_size(&self) -> usize {
21123         5 + self.controlee_phase_list.iter().map(|elem| elem.get_size()).sum::<usize>()
21124     }
21125 }
21126 impl Packet for SessionSetHybridControleeConfigCmd {
encoded_len(&self) -> usize21127     fn encoded_len(&self) -> usize {
21128         self.get_size()
21129     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>21130     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
21131         self.ucicontrolpacket.write_to(buf)
21132     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>21133     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
21134         unimplemented!("Rust legacy does not implement full packet trait")
21135     }
21136 }
21137 impl TryFrom<SessionSetHybridControleeConfigCmd> for Bytes {
21138     type Error = EncodeError;
try_from( packet: SessionSetHybridControleeConfigCmd, ) -> Result<Self, Self::Error>21139     fn try_from(
21140         packet: SessionSetHybridControleeConfigCmd,
21141     ) -> Result<Self, Self::Error> {
21142         packet.encode_to_bytes()
21143     }
21144 }
21145 impl TryFrom<SessionSetHybridControleeConfigCmd> for Vec<u8> {
21146     type Error = EncodeError;
try_from( packet: SessionSetHybridControleeConfigCmd, ) -> Result<Self, Self::Error>21147     fn try_from(
21148         packet: SessionSetHybridControleeConfigCmd,
21149     ) -> Result<Self, Self::Error> {
21150         packet.encode_to_vec()
21151     }
21152 }
21153 impl From<SessionSetHybridControleeConfigCmd> for UciControlPacket {
from(packet: SessionSetHybridControleeConfigCmd) -> UciControlPacket21154     fn from(packet: SessionSetHybridControleeConfigCmd) -> UciControlPacket {
21155         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
21156     }
21157 }
21158 impl From<SessionSetHybridControleeConfigCmd> for UciCommand {
from(packet: SessionSetHybridControleeConfigCmd) -> UciCommand21159     fn from(packet: SessionSetHybridControleeConfigCmd) -> UciCommand {
21160         UciCommand::new(packet.ucicontrolpacket).unwrap()
21161     }
21162 }
21163 impl From<SessionSetHybridControleeConfigCmd> for SessionConfigCommand {
from(packet: SessionSetHybridControleeConfigCmd) -> SessionConfigCommand21164     fn from(packet: SessionSetHybridControleeConfigCmd) -> SessionConfigCommand {
21165         SessionConfigCommand::new(packet.ucicontrolpacket).unwrap()
21166     }
21167 }
21168 impl TryFrom<UciControlPacket> for SessionSetHybridControleeConfigCmd {
21169     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionSetHybridControleeConfigCmd, Self::Error>21170     fn try_from(
21171         packet: UciControlPacket,
21172     ) -> Result<SessionSetHybridControleeConfigCmd, Self::Error> {
21173         SessionSetHybridControleeConfigCmd::new(packet.ucicontrolpacket)
21174     }
21175 }
21176 impl SessionSetHybridControleeConfigCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>21177     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
21178         let mut cell = Cell::new(bytes);
21179         let packet = Self::parse_inner(&mut cell)?;
21180         Ok(packet)
21181     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>21182     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
21183         let data = UciControlPacketData::parse_inner(&mut bytes)?;
21184         Self::new(data)
21185     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>21186     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
21187         let ucicommand = match &ucicontrolpacket.child {
21188             UciControlPacketDataChild::UciCommand(value) => value.clone(),
21189             _ => {
21190                 return Err(DecodeError::InvalidChildError {
21191                     expected: stringify!(UciControlPacketDataChild::UciCommand),
21192                     actual: format!("{:?}", & ucicontrolpacket.child),
21193                 });
21194             }
21195         };
21196         let sessionconfigcommand = match &ucicommand.child {
21197             UciCommandDataChild::SessionConfigCommand(value) => value.clone(),
21198             _ => {
21199                 return Err(DecodeError::InvalidChildError {
21200                     expected: stringify!(UciCommandDataChild::SessionConfigCommand),
21201                     actual: format!("{:?}", & ucicommand.child),
21202                 });
21203             }
21204         };
21205         let sessionsethybridcontroleeconfigcmd = match &sessionconfigcommand.child {
21206             SessionConfigCommandDataChild::SessionSetHybridControleeConfigCmd(value) => {
21207                 value.clone()
21208             }
21209             _ => {
21210                 return Err(DecodeError::InvalidChildError {
21211                     expected: stringify!(
21212                         SessionConfigCommandDataChild::SessionSetHybridControleeConfigCmd
21213                     ),
21214                     actual: format!("{:?}", & sessionconfigcommand.child),
21215                 });
21216             }
21217         };
21218         Ok(Self {
21219             ucicontrolpacket,
21220             ucicommand,
21221             sessionconfigcommand,
21222             sessionsethybridcontroleeconfigcmd,
21223         })
21224     }
get_controlee_phase_list(&self) -> &Vec<ControleePhaseList>21225     pub fn get_controlee_phase_list(&self) -> &Vec<ControleePhaseList> {
21226         &self.sessionsethybridcontroleeconfigcmd.controlee_phase_list
21227     }
get_group_id(&self) -> GroupId21228     pub fn get_group_id(&self) -> GroupId {
21229         self.ucicontrolpacket.group_id
21230     }
get_message_type(&self) -> MessageType21231     pub fn get_message_type(&self) -> MessageType {
21232         self.ucicontrolpacket.message_type
21233     }
get_opcode(&self) -> u821234     pub fn get_opcode(&self) -> u8 {
21235         self.ucicontrolpacket.opcode
21236     }
get_session_token(&self) -> u3221237     pub fn get_session_token(&self) -> u32 {
21238         self.sessionsethybridcontroleeconfigcmd.session_token
21239     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>21240     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
21241         self.sessionsethybridcontroleeconfigcmd.write_to(buffer)
21242     }
get_size(&self) -> usize21243     pub fn get_size(&self) -> usize {
21244         self.ucicontrolpacket.get_size()
21245     }
21246 }
21247 impl SessionSetHybridControleeConfigCmdBuilder {
build(self) -> SessionSetHybridControleeConfigCmd21248     pub fn build(self) -> SessionSetHybridControleeConfigCmd {
21249         let sessionsethybridcontroleeconfigcmd = SessionSetHybridControleeConfigCmdData {
21250             controlee_phase_list: self.controlee_phase_list,
21251             session_token: self.session_token,
21252         };
21253         let sessionconfigcommand = SessionConfigCommandData {
21254             child: SessionConfigCommandDataChild::SessionSetHybridControleeConfigCmd(
21255                 sessionsethybridcontroleeconfigcmd,
21256             ),
21257         };
21258         let ucicommand = UciCommandData {
21259             child: UciCommandDataChild::SessionConfigCommand(sessionconfigcommand),
21260         };
21261         let ucicontrolpacket = UciControlPacketData {
21262             group_id: GroupId::SessionConfig,
21263             message_type: MessageType::Command,
21264             opcode: 13,
21265             child: UciControlPacketDataChild::UciCommand(ucicommand),
21266         };
21267         SessionSetHybridControleeConfigCmd::new(ucicontrolpacket).unwrap()
21268     }
21269 }
21270 impl From<SessionSetHybridControleeConfigCmdBuilder> for UciControlPacket {
from(builder: SessionSetHybridControleeConfigCmdBuilder) -> UciControlPacket21271     fn from(builder: SessionSetHybridControleeConfigCmdBuilder) -> UciControlPacket {
21272         builder.build().into()
21273     }
21274 }
21275 impl From<SessionSetHybridControleeConfigCmdBuilder> for UciCommand {
from(builder: SessionSetHybridControleeConfigCmdBuilder) -> UciCommand21276     fn from(builder: SessionSetHybridControleeConfigCmdBuilder) -> UciCommand {
21277         builder.build().into()
21278     }
21279 }
21280 impl From<SessionSetHybridControleeConfigCmdBuilder> for SessionConfigCommand {
from(builder: SessionSetHybridControleeConfigCmdBuilder) -> SessionConfigCommand21281     fn from(builder: SessionSetHybridControleeConfigCmdBuilder) -> SessionConfigCommand {
21282         builder.build().into()
21283     }
21284 }
21285 impl From<SessionSetHybridControleeConfigCmdBuilder>
21286 for SessionSetHybridControleeConfigCmd {
from( builder: SessionSetHybridControleeConfigCmdBuilder, ) -> SessionSetHybridControleeConfigCmd21287     fn from(
21288         builder: SessionSetHybridControleeConfigCmdBuilder,
21289     ) -> SessionSetHybridControleeConfigCmd {
21290         builder.build().into()
21291     }
21292 }
21293 #[derive(Debug, Clone, PartialEq, Eq)]
21294 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21295 pub struct SessionSetHybridControleeConfigRspData {
21296     status: StatusCode,
21297 }
21298 #[derive(Debug, Clone, PartialEq, Eq)]
21299 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21300 pub struct SessionSetHybridControleeConfigRsp {
21301     #[cfg_attr(feature = "serde", serde(flatten))]
21302     ucicontrolpacket: UciControlPacketData,
21303     #[cfg_attr(feature = "serde", serde(flatten))]
21304     uciresponse: UciResponseData,
21305     #[cfg_attr(feature = "serde", serde(flatten))]
21306     sessionconfigresponse: SessionConfigResponseData,
21307     #[cfg_attr(feature = "serde", serde(flatten))]
21308     sessionsethybridcontroleeconfigrsp: SessionSetHybridControleeConfigRspData,
21309 }
21310 #[derive(Debug)]
21311 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21312 pub struct SessionSetHybridControleeConfigRspBuilder {
21313     pub status: StatusCode,
21314 }
21315 impl SessionSetHybridControleeConfigRspData {
conforms(bytes: &[u8]) -> bool21316     fn conforms(bytes: &[u8]) -> bool {
21317         bytes.len() >= 1
21318     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>21319     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
21320         let mut cell = Cell::new(bytes);
21321         let packet = Self::parse_inner(&mut cell)?;
21322         Ok(packet)
21323     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>21324     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
21325         if bytes.get().remaining() < 1 {
21326             return Err(DecodeError::InvalidLengthError {
21327                 obj: "SessionSetHybridControleeConfigRsp",
21328                 wanted: 1,
21329                 got: bytes.get().remaining(),
21330             });
21331         }
21332         let status = StatusCode::try_from(bytes.get_mut().get_u8())
21333             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
21334                 obj: "SessionSetHybridControleeConfigRsp",
21335                 field: "status",
21336                 value: unknown_val as u64,
21337                 type_: "StatusCode",
21338             })?;
21339         Ok(Self { status })
21340     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>21341     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
21342         buffer.put_u8(u8::from(self.status));
21343         Ok(())
21344     }
get_total_size(&self) -> usize21345     fn get_total_size(&self) -> usize {
21346         self.get_size()
21347     }
get_size(&self) -> usize21348     fn get_size(&self) -> usize {
21349         1
21350     }
21351 }
21352 impl Packet for SessionSetHybridControleeConfigRsp {
encoded_len(&self) -> usize21353     fn encoded_len(&self) -> usize {
21354         self.get_size()
21355     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>21356     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
21357         self.ucicontrolpacket.write_to(buf)
21358     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>21359     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
21360         unimplemented!("Rust legacy does not implement full packet trait")
21361     }
21362 }
21363 impl TryFrom<SessionSetHybridControleeConfigRsp> for Bytes {
21364     type Error = EncodeError;
try_from( packet: SessionSetHybridControleeConfigRsp, ) -> Result<Self, Self::Error>21365     fn try_from(
21366         packet: SessionSetHybridControleeConfigRsp,
21367     ) -> Result<Self, Self::Error> {
21368         packet.encode_to_bytes()
21369     }
21370 }
21371 impl TryFrom<SessionSetHybridControleeConfigRsp> for Vec<u8> {
21372     type Error = EncodeError;
try_from( packet: SessionSetHybridControleeConfigRsp, ) -> Result<Self, Self::Error>21373     fn try_from(
21374         packet: SessionSetHybridControleeConfigRsp,
21375     ) -> Result<Self, Self::Error> {
21376         packet.encode_to_vec()
21377     }
21378 }
21379 impl From<SessionSetHybridControleeConfigRsp> for UciControlPacket {
from(packet: SessionSetHybridControleeConfigRsp) -> UciControlPacket21380     fn from(packet: SessionSetHybridControleeConfigRsp) -> UciControlPacket {
21381         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
21382     }
21383 }
21384 impl From<SessionSetHybridControleeConfigRsp> for UciResponse {
from(packet: SessionSetHybridControleeConfigRsp) -> UciResponse21385     fn from(packet: SessionSetHybridControleeConfigRsp) -> UciResponse {
21386         UciResponse::new(packet.ucicontrolpacket).unwrap()
21387     }
21388 }
21389 impl From<SessionSetHybridControleeConfigRsp> for SessionConfigResponse {
from(packet: SessionSetHybridControleeConfigRsp) -> SessionConfigResponse21390     fn from(packet: SessionSetHybridControleeConfigRsp) -> SessionConfigResponse {
21391         SessionConfigResponse::new(packet.ucicontrolpacket).unwrap()
21392     }
21393 }
21394 impl TryFrom<UciControlPacket> for SessionSetHybridControleeConfigRsp {
21395     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionSetHybridControleeConfigRsp, Self::Error>21396     fn try_from(
21397         packet: UciControlPacket,
21398     ) -> Result<SessionSetHybridControleeConfigRsp, Self::Error> {
21399         SessionSetHybridControleeConfigRsp::new(packet.ucicontrolpacket)
21400     }
21401 }
21402 impl SessionSetHybridControleeConfigRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>21403     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
21404         let mut cell = Cell::new(bytes);
21405         let packet = Self::parse_inner(&mut cell)?;
21406         Ok(packet)
21407     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>21408     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
21409         let data = UciControlPacketData::parse_inner(&mut bytes)?;
21410         Self::new(data)
21411     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>21412     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
21413         let uciresponse = match &ucicontrolpacket.child {
21414             UciControlPacketDataChild::UciResponse(value) => value.clone(),
21415             _ => {
21416                 return Err(DecodeError::InvalidChildError {
21417                     expected: stringify!(UciControlPacketDataChild::UciResponse),
21418                     actual: format!("{:?}", & ucicontrolpacket.child),
21419                 });
21420             }
21421         };
21422         let sessionconfigresponse = match &uciresponse.child {
21423             UciResponseDataChild::SessionConfigResponse(value) => value.clone(),
21424             _ => {
21425                 return Err(DecodeError::InvalidChildError {
21426                     expected: stringify!(UciResponseDataChild::SessionConfigResponse),
21427                     actual: format!("{:?}", & uciresponse.child),
21428                 });
21429             }
21430         };
21431         let sessionsethybridcontroleeconfigrsp = match &sessionconfigresponse.child {
21432             SessionConfigResponseDataChild::SessionSetHybridControleeConfigRsp(value) => {
21433                 value.clone()
21434             }
21435             _ => {
21436                 return Err(DecodeError::InvalidChildError {
21437                     expected: stringify!(
21438                         SessionConfigResponseDataChild::SessionSetHybridControleeConfigRsp
21439                     ),
21440                     actual: format!("{:?}", & sessionconfigresponse.child),
21441                 });
21442             }
21443         };
21444         Ok(Self {
21445             ucicontrolpacket,
21446             uciresponse,
21447             sessionconfigresponse,
21448             sessionsethybridcontroleeconfigrsp,
21449         })
21450     }
get_group_id(&self) -> GroupId21451     pub fn get_group_id(&self) -> GroupId {
21452         self.ucicontrolpacket.group_id
21453     }
get_message_type(&self) -> MessageType21454     pub fn get_message_type(&self) -> MessageType {
21455         self.ucicontrolpacket.message_type
21456     }
get_opcode(&self) -> u821457     pub fn get_opcode(&self) -> u8 {
21458         self.ucicontrolpacket.opcode
21459     }
get_status(&self) -> StatusCode21460     pub fn get_status(&self) -> StatusCode {
21461         self.sessionsethybridcontroleeconfigrsp.status
21462     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>21463     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
21464         self.sessionsethybridcontroleeconfigrsp.write_to(buffer)
21465     }
get_size(&self) -> usize21466     pub fn get_size(&self) -> usize {
21467         self.ucicontrolpacket.get_size()
21468     }
21469 }
21470 impl SessionSetHybridControleeConfigRspBuilder {
build(self) -> SessionSetHybridControleeConfigRsp21471     pub fn build(self) -> SessionSetHybridControleeConfigRsp {
21472         let sessionsethybridcontroleeconfigrsp = SessionSetHybridControleeConfigRspData {
21473             status: self.status,
21474         };
21475         let sessionconfigresponse = SessionConfigResponseData {
21476             child: SessionConfigResponseDataChild::SessionSetHybridControleeConfigRsp(
21477                 sessionsethybridcontroleeconfigrsp,
21478             ),
21479         };
21480         let uciresponse = UciResponseData {
21481             child: UciResponseDataChild::SessionConfigResponse(sessionconfigresponse),
21482         };
21483         let ucicontrolpacket = UciControlPacketData {
21484             group_id: GroupId::SessionConfig,
21485             message_type: MessageType::Response,
21486             opcode: 13,
21487             child: UciControlPacketDataChild::UciResponse(uciresponse),
21488         };
21489         SessionSetHybridControleeConfigRsp::new(ucicontrolpacket).unwrap()
21490     }
21491 }
21492 impl From<SessionSetHybridControleeConfigRspBuilder> for UciControlPacket {
from(builder: SessionSetHybridControleeConfigRspBuilder) -> UciControlPacket21493     fn from(builder: SessionSetHybridControleeConfigRspBuilder) -> UciControlPacket {
21494         builder.build().into()
21495     }
21496 }
21497 impl From<SessionSetHybridControleeConfigRspBuilder> for UciResponse {
from(builder: SessionSetHybridControleeConfigRspBuilder) -> UciResponse21498     fn from(builder: SessionSetHybridControleeConfigRspBuilder) -> UciResponse {
21499         builder.build().into()
21500     }
21501 }
21502 impl From<SessionSetHybridControleeConfigRspBuilder> for SessionConfigResponse {
from( builder: SessionSetHybridControleeConfigRspBuilder, ) -> SessionConfigResponse21503     fn from(
21504         builder: SessionSetHybridControleeConfigRspBuilder,
21505     ) -> SessionConfigResponse {
21506         builder.build().into()
21507     }
21508 }
21509 impl From<SessionSetHybridControleeConfigRspBuilder>
21510 for SessionSetHybridControleeConfigRsp {
from( builder: SessionSetHybridControleeConfigRspBuilder, ) -> SessionSetHybridControleeConfigRsp21511     fn from(
21512         builder: SessionSetHybridControleeConfigRspBuilder,
21513     ) -> SessionSetHybridControleeConfigRsp {
21514         builder.build().into()
21515     }
21516 }
21517 #[derive(Debug, Clone, PartialEq, Eq)]
21518 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21519 pub struct SessionStartCmdData {
21520     session_token: u32,
21521 }
21522 #[derive(Debug, Clone, PartialEq, Eq)]
21523 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21524 pub struct SessionStartCmd {
21525     #[cfg_attr(feature = "serde", serde(flatten))]
21526     ucicontrolpacket: UciControlPacketData,
21527     #[cfg_attr(feature = "serde", serde(flatten))]
21528     ucicommand: UciCommandData,
21529     #[cfg_attr(feature = "serde", serde(flatten))]
21530     sessioncontrolcommand: SessionControlCommandData,
21531     #[cfg_attr(feature = "serde", serde(flatten))]
21532     sessionstartcmd: SessionStartCmdData,
21533 }
21534 #[derive(Debug)]
21535 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21536 pub struct SessionStartCmdBuilder {
21537     pub session_token: u32,
21538 }
21539 impl SessionStartCmdData {
conforms(bytes: &[u8]) -> bool21540     fn conforms(bytes: &[u8]) -> bool {
21541         bytes.len() >= 4
21542     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>21543     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
21544         let mut cell = Cell::new(bytes);
21545         let packet = Self::parse_inner(&mut cell)?;
21546         Ok(packet)
21547     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>21548     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
21549         if bytes.get().remaining() < 4 {
21550             return Err(DecodeError::InvalidLengthError {
21551                 obj: "SessionStartCmd",
21552                 wanted: 4,
21553                 got: bytes.get().remaining(),
21554             });
21555         }
21556         let session_token = bytes.get_mut().get_u32_le();
21557         Ok(Self { session_token })
21558     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>21559     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
21560         buffer.put_u32_le(self.session_token);
21561         Ok(())
21562     }
get_total_size(&self) -> usize21563     fn get_total_size(&self) -> usize {
21564         self.get_size()
21565     }
get_size(&self) -> usize21566     fn get_size(&self) -> usize {
21567         4
21568     }
21569 }
21570 impl Packet for SessionStartCmd {
encoded_len(&self) -> usize21571     fn encoded_len(&self) -> usize {
21572         self.get_size()
21573     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>21574     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
21575         self.ucicontrolpacket.write_to(buf)
21576     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>21577     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
21578         unimplemented!("Rust legacy does not implement full packet trait")
21579     }
21580 }
21581 impl TryFrom<SessionStartCmd> for Bytes {
21582     type Error = EncodeError;
try_from(packet: SessionStartCmd) -> Result<Self, Self::Error>21583     fn try_from(packet: SessionStartCmd) -> Result<Self, Self::Error> {
21584         packet.encode_to_bytes()
21585     }
21586 }
21587 impl TryFrom<SessionStartCmd> for Vec<u8> {
21588     type Error = EncodeError;
try_from(packet: SessionStartCmd) -> Result<Self, Self::Error>21589     fn try_from(packet: SessionStartCmd) -> Result<Self, Self::Error> {
21590         packet.encode_to_vec()
21591     }
21592 }
21593 impl From<SessionStartCmd> for UciControlPacket {
from(packet: SessionStartCmd) -> UciControlPacket21594     fn from(packet: SessionStartCmd) -> UciControlPacket {
21595         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
21596     }
21597 }
21598 impl From<SessionStartCmd> for UciCommand {
from(packet: SessionStartCmd) -> UciCommand21599     fn from(packet: SessionStartCmd) -> UciCommand {
21600         UciCommand::new(packet.ucicontrolpacket).unwrap()
21601     }
21602 }
21603 impl From<SessionStartCmd> for SessionControlCommand {
from(packet: SessionStartCmd) -> SessionControlCommand21604     fn from(packet: SessionStartCmd) -> SessionControlCommand {
21605         SessionControlCommand::new(packet.ucicontrolpacket).unwrap()
21606     }
21607 }
21608 impl TryFrom<UciControlPacket> for SessionStartCmd {
21609     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionStartCmd, Self::Error>21610     fn try_from(packet: UciControlPacket) -> Result<SessionStartCmd, Self::Error> {
21611         SessionStartCmd::new(packet.ucicontrolpacket)
21612     }
21613 }
21614 impl SessionStartCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>21615     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
21616         let mut cell = Cell::new(bytes);
21617         let packet = Self::parse_inner(&mut cell)?;
21618         Ok(packet)
21619     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>21620     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
21621         let data = UciControlPacketData::parse_inner(&mut bytes)?;
21622         Self::new(data)
21623     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>21624     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
21625         let ucicommand = match &ucicontrolpacket.child {
21626             UciControlPacketDataChild::UciCommand(value) => value.clone(),
21627             _ => {
21628                 return Err(DecodeError::InvalidChildError {
21629                     expected: stringify!(UciControlPacketDataChild::UciCommand),
21630                     actual: format!("{:?}", & ucicontrolpacket.child),
21631                 });
21632             }
21633         };
21634         let sessioncontrolcommand = match &ucicommand.child {
21635             UciCommandDataChild::SessionControlCommand(value) => value.clone(),
21636             _ => {
21637                 return Err(DecodeError::InvalidChildError {
21638                     expected: stringify!(UciCommandDataChild::SessionControlCommand),
21639                     actual: format!("{:?}", & ucicommand.child),
21640                 });
21641             }
21642         };
21643         let sessionstartcmd = match &sessioncontrolcommand.child {
21644             SessionControlCommandDataChild::SessionStartCmd(value) => value.clone(),
21645             _ => {
21646                 return Err(DecodeError::InvalidChildError {
21647                     expected: stringify!(
21648                         SessionControlCommandDataChild::SessionStartCmd
21649                     ),
21650                     actual: format!("{:?}", & sessioncontrolcommand.child),
21651                 });
21652             }
21653         };
21654         Ok(Self {
21655             ucicontrolpacket,
21656             ucicommand,
21657             sessioncontrolcommand,
21658             sessionstartcmd,
21659         })
21660     }
get_group_id(&self) -> GroupId21661     pub fn get_group_id(&self) -> GroupId {
21662         self.ucicontrolpacket.group_id
21663     }
get_message_type(&self) -> MessageType21664     pub fn get_message_type(&self) -> MessageType {
21665         self.ucicontrolpacket.message_type
21666     }
get_opcode(&self) -> u821667     pub fn get_opcode(&self) -> u8 {
21668         self.ucicontrolpacket.opcode
21669     }
get_session_token(&self) -> u3221670     pub fn get_session_token(&self) -> u32 {
21671         self.sessionstartcmd.session_token
21672     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>21673     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
21674         self.sessionstartcmd.write_to(buffer)
21675     }
get_size(&self) -> usize21676     pub fn get_size(&self) -> usize {
21677         self.ucicontrolpacket.get_size()
21678     }
21679 }
21680 impl SessionStartCmdBuilder {
build(self) -> SessionStartCmd21681     pub fn build(self) -> SessionStartCmd {
21682         let sessionstartcmd = SessionStartCmdData {
21683             session_token: self.session_token,
21684         };
21685         let sessioncontrolcommand = SessionControlCommandData {
21686             child: SessionControlCommandDataChild::SessionStartCmd(sessionstartcmd),
21687         };
21688         let ucicommand = UciCommandData {
21689             child: UciCommandDataChild::SessionControlCommand(sessioncontrolcommand),
21690         };
21691         let ucicontrolpacket = UciControlPacketData {
21692             group_id: GroupId::SessionControl,
21693             message_type: MessageType::Command,
21694             opcode: 0,
21695             child: UciControlPacketDataChild::UciCommand(ucicommand),
21696         };
21697         SessionStartCmd::new(ucicontrolpacket).unwrap()
21698     }
21699 }
21700 impl From<SessionStartCmdBuilder> for UciControlPacket {
from(builder: SessionStartCmdBuilder) -> UciControlPacket21701     fn from(builder: SessionStartCmdBuilder) -> UciControlPacket {
21702         builder.build().into()
21703     }
21704 }
21705 impl From<SessionStartCmdBuilder> for UciCommand {
from(builder: SessionStartCmdBuilder) -> UciCommand21706     fn from(builder: SessionStartCmdBuilder) -> UciCommand {
21707         builder.build().into()
21708     }
21709 }
21710 impl From<SessionStartCmdBuilder> for SessionControlCommand {
from(builder: SessionStartCmdBuilder) -> SessionControlCommand21711     fn from(builder: SessionStartCmdBuilder) -> SessionControlCommand {
21712         builder.build().into()
21713     }
21714 }
21715 impl From<SessionStartCmdBuilder> for SessionStartCmd {
from(builder: SessionStartCmdBuilder) -> SessionStartCmd21716     fn from(builder: SessionStartCmdBuilder) -> SessionStartCmd {
21717         builder.build().into()
21718     }
21719 }
21720 #[derive(Debug, Clone, PartialEq, Eq)]
21721 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21722 pub struct SessionStartRspData {
21723     status: StatusCode,
21724 }
21725 #[derive(Debug, Clone, PartialEq, Eq)]
21726 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21727 pub struct SessionStartRsp {
21728     #[cfg_attr(feature = "serde", serde(flatten))]
21729     ucicontrolpacket: UciControlPacketData,
21730     #[cfg_attr(feature = "serde", serde(flatten))]
21731     uciresponse: UciResponseData,
21732     #[cfg_attr(feature = "serde", serde(flatten))]
21733     sessioncontrolresponse: SessionControlResponseData,
21734     #[cfg_attr(feature = "serde", serde(flatten))]
21735     sessionstartrsp: SessionStartRspData,
21736 }
21737 #[derive(Debug)]
21738 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21739 pub struct SessionStartRspBuilder {
21740     pub status: StatusCode,
21741 }
21742 impl SessionStartRspData {
conforms(bytes: &[u8]) -> bool21743     fn conforms(bytes: &[u8]) -> bool {
21744         bytes.len() >= 1
21745     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>21746     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
21747         let mut cell = Cell::new(bytes);
21748         let packet = Self::parse_inner(&mut cell)?;
21749         Ok(packet)
21750     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>21751     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
21752         if bytes.get().remaining() < 1 {
21753             return Err(DecodeError::InvalidLengthError {
21754                 obj: "SessionStartRsp",
21755                 wanted: 1,
21756                 got: bytes.get().remaining(),
21757             });
21758         }
21759         let status = StatusCode::try_from(bytes.get_mut().get_u8())
21760             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
21761                 obj: "SessionStartRsp",
21762                 field: "status",
21763                 value: unknown_val as u64,
21764                 type_: "StatusCode",
21765             })?;
21766         Ok(Self { status })
21767     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>21768     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
21769         buffer.put_u8(u8::from(self.status));
21770         Ok(())
21771     }
get_total_size(&self) -> usize21772     fn get_total_size(&self) -> usize {
21773         self.get_size()
21774     }
get_size(&self) -> usize21775     fn get_size(&self) -> usize {
21776         1
21777     }
21778 }
21779 impl Packet for SessionStartRsp {
encoded_len(&self) -> usize21780     fn encoded_len(&self) -> usize {
21781         self.get_size()
21782     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>21783     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
21784         self.ucicontrolpacket.write_to(buf)
21785     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>21786     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
21787         unimplemented!("Rust legacy does not implement full packet trait")
21788     }
21789 }
21790 impl TryFrom<SessionStartRsp> for Bytes {
21791     type Error = EncodeError;
try_from(packet: SessionStartRsp) -> Result<Self, Self::Error>21792     fn try_from(packet: SessionStartRsp) -> Result<Self, Self::Error> {
21793         packet.encode_to_bytes()
21794     }
21795 }
21796 impl TryFrom<SessionStartRsp> for Vec<u8> {
21797     type Error = EncodeError;
try_from(packet: SessionStartRsp) -> Result<Self, Self::Error>21798     fn try_from(packet: SessionStartRsp) -> Result<Self, Self::Error> {
21799         packet.encode_to_vec()
21800     }
21801 }
21802 impl From<SessionStartRsp> for UciControlPacket {
from(packet: SessionStartRsp) -> UciControlPacket21803     fn from(packet: SessionStartRsp) -> UciControlPacket {
21804         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
21805     }
21806 }
21807 impl From<SessionStartRsp> for UciResponse {
from(packet: SessionStartRsp) -> UciResponse21808     fn from(packet: SessionStartRsp) -> UciResponse {
21809         UciResponse::new(packet.ucicontrolpacket).unwrap()
21810     }
21811 }
21812 impl From<SessionStartRsp> for SessionControlResponse {
from(packet: SessionStartRsp) -> SessionControlResponse21813     fn from(packet: SessionStartRsp) -> SessionControlResponse {
21814         SessionControlResponse::new(packet.ucicontrolpacket).unwrap()
21815     }
21816 }
21817 impl TryFrom<UciControlPacket> for SessionStartRsp {
21818     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionStartRsp, Self::Error>21819     fn try_from(packet: UciControlPacket) -> Result<SessionStartRsp, Self::Error> {
21820         SessionStartRsp::new(packet.ucicontrolpacket)
21821     }
21822 }
21823 impl SessionStartRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>21824     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
21825         let mut cell = Cell::new(bytes);
21826         let packet = Self::parse_inner(&mut cell)?;
21827         Ok(packet)
21828     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>21829     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
21830         let data = UciControlPacketData::parse_inner(&mut bytes)?;
21831         Self::new(data)
21832     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>21833     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
21834         let uciresponse = match &ucicontrolpacket.child {
21835             UciControlPacketDataChild::UciResponse(value) => value.clone(),
21836             _ => {
21837                 return Err(DecodeError::InvalidChildError {
21838                     expected: stringify!(UciControlPacketDataChild::UciResponse),
21839                     actual: format!("{:?}", & ucicontrolpacket.child),
21840                 });
21841             }
21842         };
21843         let sessioncontrolresponse = match &uciresponse.child {
21844             UciResponseDataChild::SessionControlResponse(value) => value.clone(),
21845             _ => {
21846                 return Err(DecodeError::InvalidChildError {
21847                     expected: stringify!(UciResponseDataChild::SessionControlResponse),
21848                     actual: format!("{:?}", & uciresponse.child),
21849                 });
21850             }
21851         };
21852         let sessionstartrsp = match &sessioncontrolresponse.child {
21853             SessionControlResponseDataChild::SessionStartRsp(value) => value.clone(),
21854             _ => {
21855                 return Err(DecodeError::InvalidChildError {
21856                     expected: stringify!(
21857                         SessionControlResponseDataChild::SessionStartRsp
21858                     ),
21859                     actual: format!("{:?}", & sessioncontrolresponse.child),
21860                 });
21861             }
21862         };
21863         Ok(Self {
21864             ucicontrolpacket,
21865             uciresponse,
21866             sessioncontrolresponse,
21867             sessionstartrsp,
21868         })
21869     }
get_group_id(&self) -> GroupId21870     pub fn get_group_id(&self) -> GroupId {
21871         self.ucicontrolpacket.group_id
21872     }
get_message_type(&self) -> MessageType21873     pub fn get_message_type(&self) -> MessageType {
21874         self.ucicontrolpacket.message_type
21875     }
get_opcode(&self) -> u821876     pub fn get_opcode(&self) -> u8 {
21877         self.ucicontrolpacket.opcode
21878     }
get_status(&self) -> StatusCode21879     pub fn get_status(&self) -> StatusCode {
21880         self.sessionstartrsp.status
21881     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>21882     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
21883         self.sessionstartrsp.write_to(buffer)
21884     }
get_size(&self) -> usize21885     pub fn get_size(&self) -> usize {
21886         self.ucicontrolpacket.get_size()
21887     }
21888 }
21889 impl SessionStartRspBuilder {
build(self) -> SessionStartRsp21890     pub fn build(self) -> SessionStartRsp {
21891         let sessionstartrsp = SessionStartRspData {
21892             status: self.status,
21893         };
21894         let sessioncontrolresponse = SessionControlResponseData {
21895             child: SessionControlResponseDataChild::SessionStartRsp(sessionstartrsp),
21896         };
21897         let uciresponse = UciResponseData {
21898             child: UciResponseDataChild::SessionControlResponse(sessioncontrolresponse),
21899         };
21900         let ucicontrolpacket = UciControlPacketData {
21901             group_id: GroupId::SessionControl,
21902             message_type: MessageType::Response,
21903             opcode: 0,
21904             child: UciControlPacketDataChild::UciResponse(uciresponse),
21905         };
21906         SessionStartRsp::new(ucicontrolpacket).unwrap()
21907     }
21908 }
21909 impl From<SessionStartRspBuilder> for UciControlPacket {
from(builder: SessionStartRspBuilder) -> UciControlPacket21910     fn from(builder: SessionStartRspBuilder) -> UciControlPacket {
21911         builder.build().into()
21912     }
21913 }
21914 impl From<SessionStartRspBuilder> for UciResponse {
from(builder: SessionStartRspBuilder) -> UciResponse21915     fn from(builder: SessionStartRspBuilder) -> UciResponse {
21916         builder.build().into()
21917     }
21918 }
21919 impl From<SessionStartRspBuilder> for SessionControlResponse {
from(builder: SessionStartRspBuilder) -> SessionControlResponse21920     fn from(builder: SessionStartRspBuilder) -> SessionControlResponse {
21921         builder.build().into()
21922     }
21923 }
21924 impl From<SessionStartRspBuilder> for SessionStartRsp {
from(builder: SessionStartRspBuilder) -> SessionStartRsp21925     fn from(builder: SessionStartRspBuilder) -> SessionStartRsp {
21926         builder.build().into()
21927     }
21928 }
21929 #[derive(Debug, Clone, PartialEq, Eq)]
21930 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21931 pub struct ShortAddressTwoWayRangingMeasurement {
21932     pub mac_address: u16,
21933     pub status: StatusCode,
21934     pub nlos: u8,
21935     pub distance: u16,
21936     pub aoa_azimuth: u16,
21937     pub aoa_azimuth_fom: u8,
21938     pub aoa_elevation: u16,
21939     pub aoa_elevation_fom: u8,
21940     pub aoa_destination_azimuth: u16,
21941     pub aoa_destination_azimuth_fom: u8,
21942     pub aoa_destination_elevation: u16,
21943     pub aoa_destination_elevation_fom: u8,
21944     pub slot_index: u8,
21945     pub rssi: u8,
21946 }
21947 impl ShortAddressTwoWayRangingMeasurement {
conforms(bytes: &[u8]) -> bool21948     fn conforms(bytes: &[u8]) -> bool {
21949         bytes.len() >= 31
21950     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>21951     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
21952         let mut cell = Cell::new(bytes);
21953         let packet = Self::parse_inner(&mut cell)?;
21954         Ok(packet)
21955     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>21956     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
21957         if bytes.get().remaining() < 2 {
21958             return Err(DecodeError::InvalidLengthError {
21959                 obj: "ShortAddressTwoWayRangingMeasurement",
21960                 wanted: 2,
21961                 got: bytes.get().remaining(),
21962             });
21963         }
21964         let mac_address = bytes.get_mut().get_u16_le();
21965         if bytes.get().remaining() < 1 {
21966             return Err(DecodeError::InvalidLengthError {
21967                 obj: "ShortAddressTwoWayRangingMeasurement",
21968                 wanted: 1,
21969                 got: bytes.get().remaining(),
21970             });
21971         }
21972         let status = StatusCode::try_from(bytes.get_mut().get_u8())
21973             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
21974                 obj: "ShortAddressTwoWayRangingMeasurement",
21975                 field: "status",
21976                 value: unknown_val as u64,
21977                 type_: "StatusCode",
21978             })?;
21979         if bytes.get().remaining() < 1 {
21980             return Err(DecodeError::InvalidLengthError {
21981                 obj: "ShortAddressTwoWayRangingMeasurement",
21982                 wanted: 1,
21983                 got: bytes.get().remaining(),
21984             });
21985         }
21986         let nlos = bytes.get_mut().get_u8();
21987         if bytes.get().remaining() < 2 {
21988             return Err(DecodeError::InvalidLengthError {
21989                 obj: "ShortAddressTwoWayRangingMeasurement",
21990                 wanted: 2,
21991                 got: bytes.get().remaining(),
21992             });
21993         }
21994         let distance = bytes.get_mut().get_u16_le();
21995         if bytes.get().remaining() < 2 {
21996             return Err(DecodeError::InvalidLengthError {
21997                 obj: "ShortAddressTwoWayRangingMeasurement",
21998                 wanted: 2,
21999                 got: bytes.get().remaining(),
22000             });
22001         }
22002         let aoa_azimuth = bytes.get_mut().get_u16_le();
22003         if bytes.get().remaining() < 1 {
22004             return Err(DecodeError::InvalidLengthError {
22005                 obj: "ShortAddressTwoWayRangingMeasurement",
22006                 wanted: 1,
22007                 got: bytes.get().remaining(),
22008             });
22009         }
22010         let aoa_azimuth_fom = bytes.get_mut().get_u8();
22011         if bytes.get().remaining() < 2 {
22012             return Err(DecodeError::InvalidLengthError {
22013                 obj: "ShortAddressTwoWayRangingMeasurement",
22014                 wanted: 2,
22015                 got: bytes.get().remaining(),
22016             });
22017         }
22018         let aoa_elevation = bytes.get_mut().get_u16_le();
22019         if bytes.get().remaining() < 1 {
22020             return Err(DecodeError::InvalidLengthError {
22021                 obj: "ShortAddressTwoWayRangingMeasurement",
22022                 wanted: 1,
22023                 got: bytes.get().remaining(),
22024             });
22025         }
22026         let aoa_elevation_fom = bytes.get_mut().get_u8();
22027         if bytes.get().remaining() < 2 {
22028             return Err(DecodeError::InvalidLengthError {
22029                 obj: "ShortAddressTwoWayRangingMeasurement",
22030                 wanted: 2,
22031                 got: bytes.get().remaining(),
22032             });
22033         }
22034         let aoa_destination_azimuth = bytes.get_mut().get_u16_le();
22035         if bytes.get().remaining() < 1 {
22036             return Err(DecodeError::InvalidLengthError {
22037                 obj: "ShortAddressTwoWayRangingMeasurement",
22038                 wanted: 1,
22039                 got: bytes.get().remaining(),
22040             });
22041         }
22042         let aoa_destination_azimuth_fom = bytes.get_mut().get_u8();
22043         if bytes.get().remaining() < 2 {
22044             return Err(DecodeError::InvalidLengthError {
22045                 obj: "ShortAddressTwoWayRangingMeasurement",
22046                 wanted: 2,
22047                 got: bytes.get().remaining(),
22048             });
22049         }
22050         let aoa_destination_elevation = bytes.get_mut().get_u16_le();
22051         if bytes.get().remaining() < 1 {
22052             return Err(DecodeError::InvalidLengthError {
22053                 obj: "ShortAddressTwoWayRangingMeasurement",
22054                 wanted: 1,
22055                 got: bytes.get().remaining(),
22056             });
22057         }
22058         let aoa_destination_elevation_fom = bytes.get_mut().get_u8();
22059         if bytes.get().remaining() < 1 {
22060             return Err(DecodeError::InvalidLengthError {
22061                 obj: "ShortAddressTwoWayRangingMeasurement",
22062                 wanted: 1,
22063                 got: bytes.get().remaining(),
22064             });
22065         }
22066         let slot_index = bytes.get_mut().get_u8();
22067         if bytes.get().remaining() < 1 {
22068             return Err(DecodeError::InvalidLengthError {
22069                 obj: "ShortAddressTwoWayRangingMeasurement",
22070                 wanted: 1,
22071                 got: bytes.get().remaining(),
22072             });
22073         }
22074         let rssi = bytes.get_mut().get_u8();
22075         if bytes.get().remaining() < 8 {
22076             return Err(DecodeError::InvalidLengthError {
22077                 obj: "ShortAddressTwoWayRangingMeasurement",
22078                 wanted: 8,
22079                 got: bytes.get().remaining(),
22080             });
22081         }
22082         bytes.get_mut().advance(8);
22083         if bytes.get().remaining() < 3 {
22084             return Err(DecodeError::InvalidLengthError {
22085                 obj: "ShortAddressTwoWayRangingMeasurement",
22086                 wanted: 3,
22087                 got: bytes.get().remaining(),
22088             });
22089         }
22090         bytes.get_mut().advance(3);
22091         Ok(Self {
22092             mac_address,
22093             status,
22094             nlos,
22095             distance,
22096             aoa_azimuth,
22097             aoa_azimuth_fom,
22098             aoa_elevation,
22099             aoa_elevation_fom,
22100             aoa_destination_azimuth,
22101             aoa_destination_azimuth_fom,
22102             aoa_destination_elevation,
22103             aoa_destination_elevation_fom,
22104             slot_index,
22105             rssi,
22106         })
22107     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>22108     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
22109         buffer.put_u16_le(self.mac_address);
22110         buffer.put_u8(u8::from(self.status));
22111         buffer.put_u8(self.nlos);
22112         buffer.put_u16_le(self.distance);
22113         buffer.put_u16_le(self.aoa_azimuth);
22114         buffer.put_u8(self.aoa_azimuth_fom);
22115         buffer.put_u16_le(self.aoa_elevation);
22116         buffer.put_u8(self.aoa_elevation_fom);
22117         buffer.put_u16_le(self.aoa_destination_azimuth);
22118         buffer.put_u8(self.aoa_destination_azimuth_fom);
22119         buffer.put_u16_le(self.aoa_destination_elevation);
22120         buffer.put_u8(self.aoa_destination_elevation_fom);
22121         buffer.put_u8(self.slot_index);
22122         buffer.put_u8(self.rssi);
22123         buffer.put_bytes(0, 8);
22124         buffer.put_bytes(0, 3);
22125         Ok(())
22126     }
get_total_size(&self) -> usize22127     fn get_total_size(&self) -> usize {
22128         self.get_size()
22129     }
get_size(&self) -> usize22130     fn get_size(&self) -> usize {
22131         31
22132     }
22133 }
22134 #[derive(Debug, Clone, PartialEq, Eq)]
22135 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
22136 pub struct ExtendedAddressTwoWayRangingMeasurement {
22137     pub mac_address: u64,
22138     pub status: StatusCode,
22139     pub nlos: u8,
22140     pub distance: u16,
22141     pub aoa_azimuth: u16,
22142     pub aoa_azimuth_fom: u8,
22143     pub aoa_elevation: u16,
22144     pub aoa_elevation_fom: u8,
22145     pub aoa_destination_azimuth: u16,
22146     pub aoa_destination_azimuth_fom: u8,
22147     pub aoa_destination_elevation: u16,
22148     pub aoa_destination_elevation_fom: u8,
22149     pub slot_index: u8,
22150     pub rssi: u8,
22151 }
22152 impl ExtendedAddressTwoWayRangingMeasurement {
conforms(bytes: &[u8]) -> bool22153     fn conforms(bytes: &[u8]) -> bool {
22154         bytes.len() >= 31
22155     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>22156     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
22157         let mut cell = Cell::new(bytes);
22158         let packet = Self::parse_inner(&mut cell)?;
22159         Ok(packet)
22160     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>22161     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
22162         if bytes.get().remaining() < 8 {
22163             return Err(DecodeError::InvalidLengthError {
22164                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22165                 wanted: 8,
22166                 got: bytes.get().remaining(),
22167             });
22168         }
22169         let mac_address = bytes.get_mut().get_u64_le();
22170         if bytes.get().remaining() < 1 {
22171             return Err(DecodeError::InvalidLengthError {
22172                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22173                 wanted: 1,
22174                 got: bytes.get().remaining(),
22175             });
22176         }
22177         let status = StatusCode::try_from(bytes.get_mut().get_u8())
22178             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
22179                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22180                 field: "status",
22181                 value: unknown_val as u64,
22182                 type_: "StatusCode",
22183             })?;
22184         if bytes.get().remaining() < 1 {
22185             return Err(DecodeError::InvalidLengthError {
22186                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22187                 wanted: 1,
22188                 got: bytes.get().remaining(),
22189             });
22190         }
22191         let nlos = bytes.get_mut().get_u8();
22192         if bytes.get().remaining() < 2 {
22193             return Err(DecodeError::InvalidLengthError {
22194                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22195                 wanted: 2,
22196                 got: bytes.get().remaining(),
22197             });
22198         }
22199         let distance = bytes.get_mut().get_u16_le();
22200         if bytes.get().remaining() < 2 {
22201             return Err(DecodeError::InvalidLengthError {
22202                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22203                 wanted: 2,
22204                 got: bytes.get().remaining(),
22205             });
22206         }
22207         let aoa_azimuth = bytes.get_mut().get_u16_le();
22208         if bytes.get().remaining() < 1 {
22209             return Err(DecodeError::InvalidLengthError {
22210                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22211                 wanted: 1,
22212                 got: bytes.get().remaining(),
22213             });
22214         }
22215         let aoa_azimuth_fom = bytes.get_mut().get_u8();
22216         if bytes.get().remaining() < 2 {
22217             return Err(DecodeError::InvalidLengthError {
22218                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22219                 wanted: 2,
22220                 got: bytes.get().remaining(),
22221             });
22222         }
22223         let aoa_elevation = bytes.get_mut().get_u16_le();
22224         if bytes.get().remaining() < 1 {
22225             return Err(DecodeError::InvalidLengthError {
22226                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22227                 wanted: 1,
22228                 got: bytes.get().remaining(),
22229             });
22230         }
22231         let aoa_elevation_fom = bytes.get_mut().get_u8();
22232         if bytes.get().remaining() < 2 {
22233             return Err(DecodeError::InvalidLengthError {
22234                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22235                 wanted: 2,
22236                 got: bytes.get().remaining(),
22237             });
22238         }
22239         let aoa_destination_azimuth = bytes.get_mut().get_u16_le();
22240         if bytes.get().remaining() < 1 {
22241             return Err(DecodeError::InvalidLengthError {
22242                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22243                 wanted: 1,
22244                 got: bytes.get().remaining(),
22245             });
22246         }
22247         let aoa_destination_azimuth_fom = bytes.get_mut().get_u8();
22248         if bytes.get().remaining() < 2 {
22249             return Err(DecodeError::InvalidLengthError {
22250                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22251                 wanted: 2,
22252                 got: bytes.get().remaining(),
22253             });
22254         }
22255         let aoa_destination_elevation = bytes.get_mut().get_u16_le();
22256         if bytes.get().remaining() < 1 {
22257             return Err(DecodeError::InvalidLengthError {
22258                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22259                 wanted: 1,
22260                 got: bytes.get().remaining(),
22261             });
22262         }
22263         let aoa_destination_elevation_fom = bytes.get_mut().get_u8();
22264         if bytes.get().remaining() < 1 {
22265             return Err(DecodeError::InvalidLengthError {
22266                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22267                 wanted: 1,
22268                 got: bytes.get().remaining(),
22269             });
22270         }
22271         let slot_index = bytes.get_mut().get_u8();
22272         if bytes.get().remaining() < 1 {
22273             return Err(DecodeError::InvalidLengthError {
22274                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22275                 wanted: 1,
22276                 got: bytes.get().remaining(),
22277             });
22278         }
22279         let rssi = bytes.get_mut().get_u8();
22280         if bytes.get().remaining() < 5 {
22281             return Err(DecodeError::InvalidLengthError {
22282                 obj: "ExtendedAddressTwoWayRangingMeasurement",
22283                 wanted: 5,
22284                 got: bytes.get().remaining(),
22285             });
22286         }
22287         bytes.get_mut().advance(5);
22288         Ok(Self {
22289             mac_address,
22290             status,
22291             nlos,
22292             distance,
22293             aoa_azimuth,
22294             aoa_azimuth_fom,
22295             aoa_elevation,
22296             aoa_elevation_fom,
22297             aoa_destination_azimuth,
22298             aoa_destination_azimuth_fom,
22299             aoa_destination_elevation,
22300             aoa_destination_elevation_fom,
22301             slot_index,
22302             rssi,
22303         })
22304     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>22305     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
22306         buffer.put_u64_le(self.mac_address);
22307         buffer.put_u8(u8::from(self.status));
22308         buffer.put_u8(self.nlos);
22309         buffer.put_u16_le(self.distance);
22310         buffer.put_u16_le(self.aoa_azimuth);
22311         buffer.put_u8(self.aoa_azimuth_fom);
22312         buffer.put_u16_le(self.aoa_elevation);
22313         buffer.put_u8(self.aoa_elevation_fom);
22314         buffer.put_u16_le(self.aoa_destination_azimuth);
22315         buffer.put_u8(self.aoa_destination_azimuth_fom);
22316         buffer.put_u16_le(self.aoa_destination_elevation);
22317         buffer.put_u8(self.aoa_destination_elevation_fom);
22318         buffer.put_u8(self.slot_index);
22319         buffer.put_u8(self.rssi);
22320         buffer.put_bytes(0, 5);
22321         Ok(())
22322     }
get_total_size(&self) -> usize22323     fn get_total_size(&self) -> usize {
22324         self.get_size()
22325     }
get_size(&self) -> usize22326     fn get_size(&self) -> usize {
22327         31
22328     }
22329 }
22330 #[derive(Debug, Clone, PartialEq, Eq)]
22331 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
22332 pub struct ShortAddressOwrAoaRangingMeasurement {
22333     pub mac_address: u16,
22334     pub status: StatusCode,
22335     pub nlos: u8,
22336     pub frame_sequence_number: u8,
22337     pub block_index: u16,
22338     pub aoa_azimuth: u16,
22339     pub aoa_azimuth_fom: u8,
22340     pub aoa_elevation: u16,
22341     pub aoa_elevation_fom: u8,
22342 }
22343 impl ShortAddressOwrAoaRangingMeasurement {
conforms(bytes: &[u8]) -> bool22344     fn conforms(bytes: &[u8]) -> bool {
22345         bytes.len() >= 13
22346     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>22347     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
22348         let mut cell = Cell::new(bytes);
22349         let packet = Self::parse_inner(&mut cell)?;
22350         Ok(packet)
22351     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>22352     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
22353         if bytes.get().remaining() < 2 {
22354             return Err(DecodeError::InvalidLengthError {
22355                 obj: "ShortAddressOwrAoaRangingMeasurement",
22356                 wanted: 2,
22357                 got: bytes.get().remaining(),
22358             });
22359         }
22360         let mac_address = bytes.get_mut().get_u16_le();
22361         if bytes.get().remaining() < 1 {
22362             return Err(DecodeError::InvalidLengthError {
22363                 obj: "ShortAddressOwrAoaRangingMeasurement",
22364                 wanted: 1,
22365                 got: bytes.get().remaining(),
22366             });
22367         }
22368         let status = StatusCode::try_from(bytes.get_mut().get_u8())
22369             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
22370                 obj: "ShortAddressOwrAoaRangingMeasurement",
22371                 field: "status",
22372                 value: unknown_val as u64,
22373                 type_: "StatusCode",
22374             })?;
22375         if bytes.get().remaining() < 1 {
22376             return Err(DecodeError::InvalidLengthError {
22377                 obj: "ShortAddressOwrAoaRangingMeasurement",
22378                 wanted: 1,
22379                 got: bytes.get().remaining(),
22380             });
22381         }
22382         let nlos = bytes.get_mut().get_u8();
22383         if bytes.get().remaining() < 1 {
22384             return Err(DecodeError::InvalidLengthError {
22385                 obj: "ShortAddressOwrAoaRangingMeasurement",
22386                 wanted: 1,
22387                 got: bytes.get().remaining(),
22388             });
22389         }
22390         let frame_sequence_number = bytes.get_mut().get_u8();
22391         if bytes.get().remaining() < 2 {
22392             return Err(DecodeError::InvalidLengthError {
22393                 obj: "ShortAddressOwrAoaRangingMeasurement",
22394                 wanted: 2,
22395                 got: bytes.get().remaining(),
22396             });
22397         }
22398         let block_index = bytes.get_mut().get_u16_le();
22399         if bytes.get().remaining() < 2 {
22400             return Err(DecodeError::InvalidLengthError {
22401                 obj: "ShortAddressOwrAoaRangingMeasurement",
22402                 wanted: 2,
22403                 got: bytes.get().remaining(),
22404             });
22405         }
22406         let aoa_azimuth = bytes.get_mut().get_u16_le();
22407         if bytes.get().remaining() < 1 {
22408             return Err(DecodeError::InvalidLengthError {
22409                 obj: "ShortAddressOwrAoaRangingMeasurement",
22410                 wanted: 1,
22411                 got: bytes.get().remaining(),
22412             });
22413         }
22414         let aoa_azimuth_fom = bytes.get_mut().get_u8();
22415         if bytes.get().remaining() < 2 {
22416             return Err(DecodeError::InvalidLengthError {
22417                 obj: "ShortAddressOwrAoaRangingMeasurement",
22418                 wanted: 2,
22419                 got: bytes.get().remaining(),
22420             });
22421         }
22422         let aoa_elevation = bytes.get_mut().get_u16_le();
22423         if bytes.get().remaining() < 1 {
22424             return Err(DecodeError::InvalidLengthError {
22425                 obj: "ShortAddressOwrAoaRangingMeasurement",
22426                 wanted: 1,
22427                 got: bytes.get().remaining(),
22428             });
22429         }
22430         let aoa_elevation_fom = bytes.get_mut().get_u8();
22431         Ok(Self {
22432             mac_address,
22433             status,
22434             nlos,
22435             frame_sequence_number,
22436             block_index,
22437             aoa_azimuth,
22438             aoa_azimuth_fom,
22439             aoa_elevation,
22440             aoa_elevation_fom,
22441         })
22442     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>22443     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
22444         buffer.put_u16_le(self.mac_address);
22445         buffer.put_u8(u8::from(self.status));
22446         buffer.put_u8(self.nlos);
22447         buffer.put_u8(self.frame_sequence_number);
22448         buffer.put_u16_le(self.block_index);
22449         buffer.put_u16_le(self.aoa_azimuth);
22450         buffer.put_u8(self.aoa_azimuth_fom);
22451         buffer.put_u16_le(self.aoa_elevation);
22452         buffer.put_u8(self.aoa_elevation_fom);
22453         Ok(())
22454     }
get_total_size(&self) -> usize22455     fn get_total_size(&self) -> usize {
22456         self.get_size()
22457     }
get_size(&self) -> usize22458     fn get_size(&self) -> usize {
22459         13
22460     }
22461 }
22462 #[derive(Debug, Clone, PartialEq, Eq)]
22463 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
22464 pub struct ExtendedAddressOwrAoaRangingMeasurement {
22465     pub mac_address: u64,
22466     pub status: StatusCode,
22467     pub nlos: u8,
22468     pub frame_sequence_number: u8,
22469     pub block_index: u16,
22470     pub aoa_azimuth: u16,
22471     pub aoa_azimuth_fom: u8,
22472     pub aoa_elevation: u16,
22473     pub aoa_elevation_fom: u8,
22474 }
22475 impl ExtendedAddressOwrAoaRangingMeasurement {
conforms(bytes: &[u8]) -> bool22476     fn conforms(bytes: &[u8]) -> bool {
22477         bytes.len() >= 19
22478     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>22479     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
22480         let mut cell = Cell::new(bytes);
22481         let packet = Self::parse_inner(&mut cell)?;
22482         Ok(packet)
22483     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>22484     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
22485         if bytes.get().remaining() < 8 {
22486             return Err(DecodeError::InvalidLengthError {
22487                 obj: "ExtendedAddressOwrAoaRangingMeasurement",
22488                 wanted: 8,
22489                 got: bytes.get().remaining(),
22490             });
22491         }
22492         let mac_address = bytes.get_mut().get_u64_le();
22493         if bytes.get().remaining() < 1 {
22494             return Err(DecodeError::InvalidLengthError {
22495                 obj: "ExtendedAddressOwrAoaRangingMeasurement",
22496                 wanted: 1,
22497                 got: bytes.get().remaining(),
22498             });
22499         }
22500         let status = StatusCode::try_from(bytes.get_mut().get_u8())
22501             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
22502                 obj: "ExtendedAddressOwrAoaRangingMeasurement",
22503                 field: "status",
22504                 value: unknown_val as u64,
22505                 type_: "StatusCode",
22506             })?;
22507         if bytes.get().remaining() < 1 {
22508             return Err(DecodeError::InvalidLengthError {
22509                 obj: "ExtendedAddressOwrAoaRangingMeasurement",
22510                 wanted: 1,
22511                 got: bytes.get().remaining(),
22512             });
22513         }
22514         let nlos = bytes.get_mut().get_u8();
22515         if bytes.get().remaining() < 1 {
22516             return Err(DecodeError::InvalidLengthError {
22517                 obj: "ExtendedAddressOwrAoaRangingMeasurement",
22518                 wanted: 1,
22519                 got: bytes.get().remaining(),
22520             });
22521         }
22522         let frame_sequence_number = bytes.get_mut().get_u8();
22523         if bytes.get().remaining() < 2 {
22524             return Err(DecodeError::InvalidLengthError {
22525                 obj: "ExtendedAddressOwrAoaRangingMeasurement",
22526                 wanted: 2,
22527                 got: bytes.get().remaining(),
22528             });
22529         }
22530         let block_index = bytes.get_mut().get_u16_le();
22531         if bytes.get().remaining() < 2 {
22532             return Err(DecodeError::InvalidLengthError {
22533                 obj: "ExtendedAddressOwrAoaRangingMeasurement",
22534                 wanted: 2,
22535                 got: bytes.get().remaining(),
22536             });
22537         }
22538         let aoa_azimuth = bytes.get_mut().get_u16_le();
22539         if bytes.get().remaining() < 1 {
22540             return Err(DecodeError::InvalidLengthError {
22541                 obj: "ExtendedAddressOwrAoaRangingMeasurement",
22542                 wanted: 1,
22543                 got: bytes.get().remaining(),
22544             });
22545         }
22546         let aoa_azimuth_fom = bytes.get_mut().get_u8();
22547         if bytes.get().remaining() < 2 {
22548             return Err(DecodeError::InvalidLengthError {
22549                 obj: "ExtendedAddressOwrAoaRangingMeasurement",
22550                 wanted: 2,
22551                 got: bytes.get().remaining(),
22552             });
22553         }
22554         let aoa_elevation = bytes.get_mut().get_u16_le();
22555         if bytes.get().remaining() < 1 {
22556             return Err(DecodeError::InvalidLengthError {
22557                 obj: "ExtendedAddressOwrAoaRangingMeasurement",
22558                 wanted: 1,
22559                 got: bytes.get().remaining(),
22560             });
22561         }
22562         let aoa_elevation_fom = bytes.get_mut().get_u8();
22563         Ok(Self {
22564             mac_address,
22565             status,
22566             nlos,
22567             frame_sequence_number,
22568             block_index,
22569             aoa_azimuth,
22570             aoa_azimuth_fom,
22571             aoa_elevation,
22572             aoa_elevation_fom,
22573         })
22574     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>22575     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
22576         buffer.put_u64_le(self.mac_address);
22577         buffer.put_u8(u8::from(self.status));
22578         buffer.put_u8(self.nlos);
22579         buffer.put_u8(self.frame_sequence_number);
22580         buffer.put_u16_le(self.block_index);
22581         buffer.put_u16_le(self.aoa_azimuth);
22582         buffer.put_u8(self.aoa_azimuth_fom);
22583         buffer.put_u16_le(self.aoa_elevation);
22584         buffer.put_u8(self.aoa_elevation_fom);
22585         Ok(())
22586     }
get_total_size(&self) -> usize22587     fn get_total_size(&self) -> usize {
22588         self.get_size()
22589     }
get_size(&self) -> usize22590     fn get_size(&self) -> usize {
22591         19
22592     }
22593 }
22594 #[repr(u64)]
22595 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
22596 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
22597 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
22598 pub enum RangingMeasurementType {
22599     OneWay = 0x0,
22600     TwoWay = 0x1,
22601     DlTdoa = 0x2,
22602     OwrAoa = 0x3,
22603 }
22604 impl TryFrom<u8> for RangingMeasurementType {
22605     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>22606     fn try_from(value: u8) -> Result<Self, Self::Error> {
22607         match value {
22608             0x0 => Ok(RangingMeasurementType::OneWay),
22609             0x1 => Ok(RangingMeasurementType::TwoWay),
22610             0x2 => Ok(RangingMeasurementType::DlTdoa),
22611             0x3 => Ok(RangingMeasurementType::OwrAoa),
22612             _ => Err(value),
22613         }
22614     }
22615 }
22616 impl From<&RangingMeasurementType> for u8 {
from(value: &RangingMeasurementType) -> Self22617     fn from(value: &RangingMeasurementType) -> Self {
22618         match value {
22619             RangingMeasurementType::OneWay => 0x0,
22620             RangingMeasurementType::TwoWay => 0x1,
22621             RangingMeasurementType::DlTdoa => 0x2,
22622             RangingMeasurementType::OwrAoa => 0x3,
22623         }
22624     }
22625 }
22626 impl From<RangingMeasurementType> for u8 {
from(value: RangingMeasurementType) -> Self22627     fn from(value: RangingMeasurementType) -> Self {
22628         (&value).into()
22629     }
22630 }
22631 impl From<RangingMeasurementType> for i16 {
from(value: RangingMeasurementType) -> Self22632     fn from(value: RangingMeasurementType) -> Self {
22633         u8::from(value) as Self
22634     }
22635 }
22636 impl From<RangingMeasurementType> for i32 {
from(value: RangingMeasurementType) -> Self22637     fn from(value: RangingMeasurementType) -> Self {
22638         u8::from(value) as Self
22639     }
22640 }
22641 impl From<RangingMeasurementType> for i64 {
from(value: RangingMeasurementType) -> Self22642     fn from(value: RangingMeasurementType) -> Self {
22643         u8::from(value) as Self
22644     }
22645 }
22646 impl From<RangingMeasurementType> for u16 {
from(value: RangingMeasurementType) -> Self22647     fn from(value: RangingMeasurementType) -> Self {
22648         u8::from(value) as Self
22649     }
22650 }
22651 impl From<RangingMeasurementType> for u32 {
from(value: RangingMeasurementType) -> Self22652     fn from(value: RangingMeasurementType) -> Self {
22653         u8::from(value) as Self
22654     }
22655 }
22656 impl From<RangingMeasurementType> for u64 {
from(value: RangingMeasurementType) -> Self22657     fn from(value: RangingMeasurementType) -> Self {
22658         u8::from(value) as Self
22659     }
22660 }
22661 #[derive(Debug, Clone, PartialEq, Eq)]
22662 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
22663 pub enum SessionInfoNtfDataChild {
22664     ShortMacTwoWaySessionInfoNtf(ShortMacTwoWaySessionInfoNtfData),
22665     ExtendedMacTwoWaySessionInfoNtf(ExtendedMacTwoWaySessionInfoNtfData),
22666     ShortMacDlTDoASessionInfoNtf(ShortMacDlTDoASessionInfoNtfData),
22667     ExtendedMacDlTDoASessionInfoNtf(ExtendedMacDlTDoASessionInfoNtfData),
22668     ShortMacOwrAoaSessionInfoNtf(ShortMacOwrAoaSessionInfoNtfData),
22669     ExtendedMacOwrAoaSessionInfoNtf(ExtendedMacOwrAoaSessionInfoNtfData),
22670     Payload(Bytes),
22671     None,
22672 }
22673 impl SessionInfoNtfDataChild {
get_total_size(&self) -> usize22674     fn get_total_size(&self) -> usize {
22675         match self {
22676             SessionInfoNtfDataChild::ShortMacTwoWaySessionInfoNtf(value) => {
22677                 value.get_total_size()
22678             }
22679             SessionInfoNtfDataChild::ExtendedMacTwoWaySessionInfoNtf(value) => {
22680                 value.get_total_size()
22681             }
22682             SessionInfoNtfDataChild::ShortMacDlTDoASessionInfoNtf(value) => {
22683                 value.get_total_size()
22684             }
22685             SessionInfoNtfDataChild::ExtendedMacDlTDoASessionInfoNtf(value) => {
22686                 value.get_total_size()
22687             }
22688             SessionInfoNtfDataChild::ShortMacOwrAoaSessionInfoNtf(value) => {
22689                 value.get_total_size()
22690             }
22691             SessionInfoNtfDataChild::ExtendedMacOwrAoaSessionInfoNtf(value) => {
22692                 value.get_total_size()
22693             }
22694             SessionInfoNtfDataChild::Payload(bytes) => bytes.len(),
22695             SessionInfoNtfDataChild::None => 0,
22696         }
22697     }
22698 }
22699 #[derive(Debug, Clone, PartialEq, Eq)]
22700 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
22701 pub enum SessionInfoNtfChild {
22702     ShortMacTwoWaySessionInfoNtf(ShortMacTwoWaySessionInfoNtf),
22703     ExtendedMacTwoWaySessionInfoNtf(ExtendedMacTwoWaySessionInfoNtf),
22704     ShortMacDlTDoASessionInfoNtf(ShortMacDlTDoASessionInfoNtf),
22705     ExtendedMacDlTDoASessionInfoNtf(ExtendedMacDlTDoASessionInfoNtf),
22706     ShortMacOwrAoaSessionInfoNtf(ShortMacOwrAoaSessionInfoNtf),
22707     ExtendedMacOwrAoaSessionInfoNtf(ExtendedMacOwrAoaSessionInfoNtf),
22708     Payload(Bytes),
22709     None,
22710 }
22711 #[derive(Debug, Clone, PartialEq, Eq)]
22712 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
22713 pub struct SessionInfoNtfData {
22714     sequence_number: u32,
22715     session_token: u32,
22716     rcr_indicator: u8,
22717     current_ranging_interval: u32,
22718     ranging_measurement_type: RangingMeasurementType,
22719     mac_address_indicator: MacAddressIndicator,
22720     child: SessionInfoNtfDataChild,
22721 }
22722 #[derive(Debug, Clone, PartialEq, Eq)]
22723 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
22724 pub struct SessionInfoNtf {
22725     #[cfg_attr(feature = "serde", serde(flatten))]
22726     ucicontrolpacket: UciControlPacketData,
22727     #[cfg_attr(feature = "serde", serde(flatten))]
22728     ucinotification: UciNotificationData,
22729     #[cfg_attr(feature = "serde", serde(flatten))]
22730     sessioncontrolnotification: SessionControlNotificationData,
22731     #[cfg_attr(feature = "serde", serde(flatten))]
22732     sessioninfontf: SessionInfoNtfData,
22733 }
22734 #[derive(Debug)]
22735 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
22736 pub struct SessionInfoNtfBuilder {
22737     pub current_ranging_interval: u32,
22738     pub mac_address_indicator: MacAddressIndicator,
22739     pub ranging_measurement_type: RangingMeasurementType,
22740     pub rcr_indicator: u8,
22741     pub sequence_number: u32,
22742     pub session_token: u32,
22743     pub payload: Option<Bytes>,
22744 }
22745 impl SessionInfoNtfData {
conforms(bytes: &[u8]) -> bool22746     fn conforms(bytes: &[u8]) -> bool {
22747         bytes.len() >= 24
22748     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>22749     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
22750         let mut cell = Cell::new(bytes);
22751         let packet = Self::parse_inner(&mut cell)?;
22752         Ok(packet)
22753     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>22754     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
22755         if bytes.get().remaining() < 4 {
22756             return Err(DecodeError::InvalidLengthError {
22757                 obj: "SessionInfoNtf",
22758                 wanted: 4,
22759                 got: bytes.get().remaining(),
22760             });
22761         }
22762         let sequence_number = bytes.get_mut().get_u32_le();
22763         if bytes.get().remaining() < 4 {
22764             return Err(DecodeError::InvalidLengthError {
22765                 obj: "SessionInfoNtf",
22766                 wanted: 4,
22767                 got: bytes.get().remaining(),
22768             });
22769         }
22770         let session_token = bytes.get_mut().get_u32_le();
22771         if bytes.get().remaining() < 1 {
22772             return Err(DecodeError::InvalidLengthError {
22773                 obj: "SessionInfoNtf",
22774                 wanted: 1,
22775                 got: bytes.get().remaining(),
22776             });
22777         }
22778         let rcr_indicator = bytes.get_mut().get_u8();
22779         if bytes.get().remaining() < 4 {
22780             return Err(DecodeError::InvalidLengthError {
22781                 obj: "SessionInfoNtf",
22782                 wanted: 4,
22783                 got: bytes.get().remaining(),
22784             });
22785         }
22786         let current_ranging_interval = bytes.get_mut().get_u32_le();
22787         if bytes.get().remaining() < 1 {
22788             return Err(DecodeError::InvalidLengthError {
22789                 obj: "SessionInfoNtf",
22790                 wanted: 1,
22791                 got: bytes.get().remaining(),
22792             });
22793         }
22794         let ranging_measurement_type = RangingMeasurementType::try_from(
22795                 bytes.get_mut().get_u8(),
22796             )
22797             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
22798                 obj: "SessionInfoNtf",
22799                 field: "ranging_measurement_type",
22800                 value: unknown_val as u64,
22801                 type_: "RangingMeasurementType",
22802             })?;
22803         if bytes.get().remaining() < 1 {
22804             return Err(DecodeError::InvalidLengthError {
22805                 obj: "SessionInfoNtf",
22806                 wanted: 1,
22807                 got: bytes.get().remaining(),
22808             });
22809         }
22810         bytes.get_mut().advance(1);
22811         if bytes.get().remaining() < 1 {
22812             return Err(DecodeError::InvalidLengthError {
22813                 obj: "SessionInfoNtf",
22814                 wanted: 1,
22815                 got: bytes.get().remaining(),
22816             });
22817         }
22818         let mac_address_indicator = MacAddressIndicator::try_from(
22819                 bytes.get_mut().get_u8(),
22820             )
22821             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
22822                 obj: "SessionInfoNtf",
22823                 field: "mac_address_indicator",
22824                 value: unknown_val as u64,
22825                 type_: "MacAddressIndicator",
22826             })?;
22827         if bytes.get().remaining() < 8 {
22828             return Err(DecodeError::InvalidLengthError {
22829                 obj: "SessionInfoNtf",
22830                 wanted: 8,
22831                 got: bytes.get().remaining(),
22832             });
22833         }
22834         bytes.get_mut().advance(8);
22835         let payload = bytes.get();
22836         bytes.get_mut().advance(payload.len());
22837         let child = match (mac_address_indicator, ranging_measurement_type) {
22838             (
22839                 MacAddressIndicator::ShortAddress,
22840                 RangingMeasurementType::TwoWay,
22841             ) if ShortMacTwoWaySessionInfoNtfData::conforms(&payload) => {
22842                 let mut cell = Cell::new(payload);
22843                 let child_data = ShortMacTwoWaySessionInfoNtfData::parse_inner(
22844                     &mut cell,
22845                 )?;
22846                 SessionInfoNtfDataChild::ShortMacTwoWaySessionInfoNtf(child_data)
22847             }
22848             (
22849                 MacAddressIndicator::ExtendedAddress,
22850                 RangingMeasurementType::TwoWay,
22851             ) if ExtendedMacTwoWaySessionInfoNtfData::conforms(&payload) => {
22852                 let mut cell = Cell::new(payload);
22853                 let child_data = ExtendedMacTwoWaySessionInfoNtfData::parse_inner(
22854                     &mut cell,
22855                 )?;
22856                 SessionInfoNtfDataChild::ExtendedMacTwoWaySessionInfoNtf(child_data)
22857             }
22858             (
22859                 MacAddressIndicator::ShortAddress,
22860                 RangingMeasurementType::DlTdoa,
22861             ) if ShortMacDlTDoASessionInfoNtfData::conforms(&payload) => {
22862                 let mut cell = Cell::new(payload);
22863                 let child_data = ShortMacDlTDoASessionInfoNtfData::parse_inner(
22864                     &mut cell,
22865                 )?;
22866                 SessionInfoNtfDataChild::ShortMacDlTDoASessionInfoNtf(child_data)
22867             }
22868             (
22869                 MacAddressIndicator::ExtendedAddress,
22870                 RangingMeasurementType::DlTdoa,
22871             ) if ExtendedMacDlTDoASessionInfoNtfData::conforms(&payload) => {
22872                 let mut cell = Cell::new(payload);
22873                 let child_data = ExtendedMacDlTDoASessionInfoNtfData::parse_inner(
22874                     &mut cell,
22875                 )?;
22876                 SessionInfoNtfDataChild::ExtendedMacDlTDoASessionInfoNtf(child_data)
22877             }
22878             (
22879                 MacAddressIndicator::ShortAddress,
22880                 RangingMeasurementType::OwrAoa,
22881             ) if ShortMacOwrAoaSessionInfoNtfData::conforms(&payload) => {
22882                 let mut cell = Cell::new(payload);
22883                 let child_data = ShortMacOwrAoaSessionInfoNtfData::parse_inner(
22884                     &mut cell,
22885                 )?;
22886                 SessionInfoNtfDataChild::ShortMacOwrAoaSessionInfoNtf(child_data)
22887             }
22888             (
22889                 MacAddressIndicator::ExtendedAddress,
22890                 RangingMeasurementType::OwrAoa,
22891             ) if ExtendedMacOwrAoaSessionInfoNtfData::conforms(&payload) => {
22892                 let mut cell = Cell::new(payload);
22893                 let child_data = ExtendedMacOwrAoaSessionInfoNtfData::parse_inner(
22894                     &mut cell,
22895                 )?;
22896                 SessionInfoNtfDataChild::ExtendedMacOwrAoaSessionInfoNtf(child_data)
22897             }
22898             _ if !payload.is_empty() => {
22899                 SessionInfoNtfDataChild::Payload(Bytes::copy_from_slice(payload))
22900             }
22901             _ => SessionInfoNtfDataChild::None,
22902         };
22903         Ok(Self {
22904             sequence_number,
22905             session_token,
22906             rcr_indicator,
22907             current_ranging_interval,
22908             ranging_measurement_type,
22909             mac_address_indicator,
22910             child,
22911         })
22912     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>22913     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
22914         buffer.put_u32_le(self.sequence_number);
22915         buffer.put_u32_le(self.session_token);
22916         buffer.put_u8(self.rcr_indicator);
22917         buffer.put_u32_le(self.current_ranging_interval);
22918         buffer.put_u8(u8::from(self.ranging_measurement_type));
22919         buffer.put_bytes(0, 1);
22920         buffer.put_u8(u8::from(self.mac_address_indicator));
22921         buffer.put_bytes(0, 8);
22922         match &self.child {
22923             SessionInfoNtfDataChild::ShortMacTwoWaySessionInfoNtf(child) => {
22924                 child.write_to(buffer)?
22925             }
22926             SessionInfoNtfDataChild::ExtendedMacTwoWaySessionInfoNtf(child) => {
22927                 child.write_to(buffer)?
22928             }
22929             SessionInfoNtfDataChild::ShortMacDlTDoASessionInfoNtf(child) => {
22930                 child.write_to(buffer)?
22931             }
22932             SessionInfoNtfDataChild::ExtendedMacDlTDoASessionInfoNtf(child) => {
22933                 child.write_to(buffer)?
22934             }
22935             SessionInfoNtfDataChild::ShortMacOwrAoaSessionInfoNtf(child) => {
22936                 child.write_to(buffer)?
22937             }
22938             SessionInfoNtfDataChild::ExtendedMacOwrAoaSessionInfoNtf(child) => {
22939                 child.write_to(buffer)?
22940             }
22941             SessionInfoNtfDataChild::Payload(payload) => buffer.put_slice(payload),
22942             SessionInfoNtfDataChild::None => {}
22943         }
22944         Ok(())
22945     }
get_total_size(&self) -> usize22946     fn get_total_size(&self) -> usize {
22947         self.get_size()
22948     }
get_size(&self) -> usize22949     fn get_size(&self) -> usize {
22950         24 + self.child.get_total_size()
22951     }
22952 }
22953 impl Packet for SessionInfoNtf {
encoded_len(&self) -> usize22954     fn encoded_len(&self) -> usize {
22955         self.get_size()
22956     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>22957     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
22958         self.ucicontrolpacket.write_to(buf)
22959     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>22960     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
22961         unimplemented!("Rust legacy does not implement full packet trait")
22962     }
22963 }
22964 impl TryFrom<SessionInfoNtf> for Bytes {
22965     type Error = EncodeError;
try_from(packet: SessionInfoNtf) -> Result<Self, Self::Error>22966     fn try_from(packet: SessionInfoNtf) -> Result<Self, Self::Error> {
22967         packet.encode_to_bytes()
22968     }
22969 }
22970 impl TryFrom<SessionInfoNtf> for Vec<u8> {
22971     type Error = EncodeError;
try_from(packet: SessionInfoNtf) -> Result<Self, Self::Error>22972     fn try_from(packet: SessionInfoNtf) -> Result<Self, Self::Error> {
22973         packet.encode_to_vec()
22974     }
22975 }
22976 impl From<SessionInfoNtf> for UciControlPacket {
from(packet: SessionInfoNtf) -> UciControlPacket22977     fn from(packet: SessionInfoNtf) -> UciControlPacket {
22978         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
22979     }
22980 }
22981 impl From<SessionInfoNtf> for UciNotification {
from(packet: SessionInfoNtf) -> UciNotification22982     fn from(packet: SessionInfoNtf) -> UciNotification {
22983         UciNotification::new(packet.ucicontrolpacket).unwrap()
22984     }
22985 }
22986 impl From<SessionInfoNtf> for SessionControlNotification {
from(packet: SessionInfoNtf) -> SessionControlNotification22987     fn from(packet: SessionInfoNtf) -> SessionControlNotification {
22988         SessionControlNotification::new(packet.ucicontrolpacket).unwrap()
22989     }
22990 }
22991 impl TryFrom<UciControlPacket> for SessionInfoNtf {
22992     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionInfoNtf, Self::Error>22993     fn try_from(packet: UciControlPacket) -> Result<SessionInfoNtf, Self::Error> {
22994         SessionInfoNtf::new(packet.ucicontrolpacket)
22995     }
22996 }
22997 impl SessionInfoNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>22998     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
22999         let mut cell = Cell::new(bytes);
23000         let packet = Self::parse_inner(&mut cell)?;
23001         Ok(packet)
23002     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>23003     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
23004         let data = UciControlPacketData::parse_inner(&mut bytes)?;
23005         Self::new(data)
23006     }
specialize(&self) -> SessionInfoNtfChild23007     pub fn specialize(&self) -> SessionInfoNtfChild {
23008         match &self.sessioninfontf.child {
23009             SessionInfoNtfDataChild::ShortMacTwoWaySessionInfoNtf(_) => {
23010                 SessionInfoNtfChild::ShortMacTwoWaySessionInfoNtf(
23011                     ShortMacTwoWaySessionInfoNtf::new(self.ucicontrolpacket.clone())
23012                         .unwrap(),
23013                 )
23014             }
23015             SessionInfoNtfDataChild::ExtendedMacTwoWaySessionInfoNtf(_) => {
23016                 SessionInfoNtfChild::ExtendedMacTwoWaySessionInfoNtf(
23017                     ExtendedMacTwoWaySessionInfoNtf::new(self.ucicontrolpacket.clone())
23018                         .unwrap(),
23019                 )
23020             }
23021             SessionInfoNtfDataChild::ShortMacDlTDoASessionInfoNtf(_) => {
23022                 SessionInfoNtfChild::ShortMacDlTDoASessionInfoNtf(
23023                     ShortMacDlTDoASessionInfoNtf::new(self.ucicontrolpacket.clone())
23024                         .unwrap(),
23025                 )
23026             }
23027             SessionInfoNtfDataChild::ExtendedMacDlTDoASessionInfoNtf(_) => {
23028                 SessionInfoNtfChild::ExtendedMacDlTDoASessionInfoNtf(
23029                     ExtendedMacDlTDoASessionInfoNtf::new(self.ucicontrolpacket.clone())
23030                         .unwrap(),
23031                 )
23032             }
23033             SessionInfoNtfDataChild::ShortMacOwrAoaSessionInfoNtf(_) => {
23034                 SessionInfoNtfChild::ShortMacOwrAoaSessionInfoNtf(
23035                     ShortMacOwrAoaSessionInfoNtf::new(self.ucicontrolpacket.clone())
23036                         .unwrap(),
23037                 )
23038             }
23039             SessionInfoNtfDataChild::ExtendedMacOwrAoaSessionInfoNtf(_) => {
23040                 SessionInfoNtfChild::ExtendedMacOwrAoaSessionInfoNtf(
23041                     ExtendedMacOwrAoaSessionInfoNtf::new(self.ucicontrolpacket.clone())
23042                         .unwrap(),
23043                 )
23044             }
23045             SessionInfoNtfDataChild::Payload(payload) => {
23046                 SessionInfoNtfChild::Payload(payload.clone())
23047             }
23048             SessionInfoNtfDataChild::None => SessionInfoNtfChild::None,
23049         }
23050     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>23051     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
23052         let ucinotification = match &ucicontrolpacket.child {
23053             UciControlPacketDataChild::UciNotification(value) => value.clone(),
23054             _ => {
23055                 return Err(DecodeError::InvalidChildError {
23056                     expected: stringify!(UciControlPacketDataChild::UciNotification),
23057                     actual: format!("{:?}", & ucicontrolpacket.child),
23058                 });
23059             }
23060         };
23061         let sessioncontrolnotification = match &ucinotification.child {
23062             UciNotificationDataChild::SessionControlNotification(value) => value.clone(),
23063             _ => {
23064                 return Err(DecodeError::InvalidChildError {
23065                     expected: stringify!(
23066                         UciNotificationDataChild::SessionControlNotification
23067                     ),
23068                     actual: format!("{:?}", & ucinotification.child),
23069                 });
23070             }
23071         };
23072         let sessioninfontf = match &sessioncontrolnotification.child {
23073             SessionControlNotificationDataChild::SessionInfoNtf(value) => value.clone(),
23074             _ => {
23075                 return Err(DecodeError::InvalidChildError {
23076                     expected: stringify!(
23077                         SessionControlNotificationDataChild::SessionInfoNtf
23078                     ),
23079                     actual: format!("{:?}", & sessioncontrolnotification.child),
23080                 });
23081             }
23082         };
23083         Ok(Self {
23084             ucicontrolpacket,
23085             ucinotification,
23086             sessioncontrolnotification,
23087             sessioninfontf,
23088         })
23089     }
get_current_ranging_interval(&self) -> u3223090     pub fn get_current_ranging_interval(&self) -> u32 {
23091         self.sessioninfontf.current_ranging_interval
23092     }
get_group_id(&self) -> GroupId23093     pub fn get_group_id(&self) -> GroupId {
23094         self.ucicontrolpacket.group_id
23095     }
get_mac_address_indicator(&self) -> MacAddressIndicator23096     pub fn get_mac_address_indicator(&self) -> MacAddressIndicator {
23097         self.sessioninfontf.mac_address_indicator
23098     }
get_message_type(&self) -> MessageType23099     pub fn get_message_type(&self) -> MessageType {
23100         self.ucicontrolpacket.message_type
23101     }
get_opcode(&self) -> u823102     pub fn get_opcode(&self) -> u8 {
23103         self.ucicontrolpacket.opcode
23104     }
get_ranging_measurement_type(&self) -> RangingMeasurementType23105     pub fn get_ranging_measurement_type(&self) -> RangingMeasurementType {
23106         self.sessioninfontf.ranging_measurement_type
23107     }
get_rcr_indicator(&self) -> u823108     pub fn get_rcr_indicator(&self) -> u8 {
23109         self.sessioninfontf.rcr_indicator
23110     }
get_sequence_number(&self) -> u3223111     pub fn get_sequence_number(&self) -> u32 {
23112         self.sessioninfontf.sequence_number
23113     }
get_session_token(&self) -> u3223114     pub fn get_session_token(&self) -> u32 {
23115         self.sessioninfontf.session_token
23116     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>23117     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
23118         self.sessioninfontf.write_to(buffer)
23119     }
get_size(&self) -> usize23120     pub fn get_size(&self) -> usize {
23121         self.ucicontrolpacket.get_size()
23122     }
23123 }
23124 impl SessionInfoNtfBuilder {
build(self) -> SessionInfoNtf23125     pub fn build(self) -> SessionInfoNtf {
23126         let sessioninfontf = SessionInfoNtfData {
23127             current_ranging_interval: self.current_ranging_interval,
23128             mac_address_indicator: self.mac_address_indicator,
23129             ranging_measurement_type: self.ranging_measurement_type,
23130             rcr_indicator: self.rcr_indicator,
23131             sequence_number: self.sequence_number,
23132             session_token: self.session_token,
23133             child: match self.payload {
23134                 None => SessionInfoNtfDataChild::None,
23135                 Some(bytes) => SessionInfoNtfDataChild::Payload(bytes),
23136             },
23137         };
23138         let sessioncontrolnotification = SessionControlNotificationData {
23139             child: SessionControlNotificationDataChild::SessionInfoNtf(sessioninfontf),
23140         };
23141         let ucinotification = UciNotificationData {
23142             child: UciNotificationDataChild::SessionControlNotification(
23143                 sessioncontrolnotification,
23144             ),
23145         };
23146         let ucicontrolpacket = UciControlPacketData {
23147             group_id: GroupId::SessionControl,
23148             message_type: MessageType::Notification,
23149             opcode: 0,
23150             child: UciControlPacketDataChild::UciNotification(ucinotification),
23151         };
23152         SessionInfoNtf::new(ucicontrolpacket).unwrap()
23153     }
23154 }
23155 impl From<SessionInfoNtfBuilder> for UciControlPacket {
from(builder: SessionInfoNtfBuilder) -> UciControlPacket23156     fn from(builder: SessionInfoNtfBuilder) -> UciControlPacket {
23157         builder.build().into()
23158     }
23159 }
23160 impl From<SessionInfoNtfBuilder> for UciNotification {
from(builder: SessionInfoNtfBuilder) -> UciNotification23161     fn from(builder: SessionInfoNtfBuilder) -> UciNotification {
23162         builder.build().into()
23163     }
23164 }
23165 impl From<SessionInfoNtfBuilder> for SessionControlNotification {
from(builder: SessionInfoNtfBuilder) -> SessionControlNotification23166     fn from(builder: SessionInfoNtfBuilder) -> SessionControlNotification {
23167         builder.build().into()
23168     }
23169 }
23170 impl From<SessionInfoNtfBuilder> for SessionInfoNtf {
from(builder: SessionInfoNtfBuilder) -> SessionInfoNtf23171     fn from(builder: SessionInfoNtfBuilder) -> SessionInfoNtf {
23172         builder.build().into()
23173     }
23174 }
23175 #[derive(Debug, Clone, PartialEq, Eq)]
23176 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
23177 pub struct ShortMacTwoWaySessionInfoNtfData {
23178     two_way_ranging_measurements: Vec<ShortAddressTwoWayRangingMeasurement>,
23179     vendor_data: Vec<u8>,
23180 }
23181 #[derive(Debug, Clone, PartialEq, Eq)]
23182 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
23183 pub struct ShortMacTwoWaySessionInfoNtf {
23184     #[cfg_attr(feature = "serde", serde(flatten))]
23185     ucicontrolpacket: UciControlPacketData,
23186     #[cfg_attr(feature = "serde", serde(flatten))]
23187     ucinotification: UciNotificationData,
23188     #[cfg_attr(feature = "serde", serde(flatten))]
23189     sessioncontrolnotification: SessionControlNotificationData,
23190     #[cfg_attr(feature = "serde", serde(flatten))]
23191     sessioninfontf: SessionInfoNtfData,
23192     #[cfg_attr(feature = "serde", serde(flatten))]
23193     shortmactwowaysessioninfontf: ShortMacTwoWaySessionInfoNtfData,
23194 }
23195 #[derive(Debug)]
23196 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
23197 pub struct ShortMacTwoWaySessionInfoNtfBuilder {
23198     pub current_ranging_interval: u32,
23199     pub rcr_indicator: u8,
23200     pub sequence_number: u32,
23201     pub session_token: u32,
23202     pub two_way_ranging_measurements: Vec<ShortAddressTwoWayRangingMeasurement>,
23203     pub vendor_data: Vec<u8>,
23204 }
23205 impl ShortMacTwoWaySessionInfoNtfData {
conforms(bytes: &[u8]) -> bool23206     fn conforms(bytes: &[u8]) -> bool {
23207         bytes.len() >= 1
23208     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>23209     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
23210         let mut cell = Cell::new(bytes);
23211         let packet = Self::parse_inner(&mut cell)?;
23212         Ok(packet)
23213     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>23214     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
23215         if bytes.get().remaining() < 1 {
23216             return Err(DecodeError::InvalidLengthError {
23217                 obj: "ShortMacTwoWaySessionInfoNtf",
23218                 wanted: 1,
23219                 got: bytes.get().remaining(),
23220             });
23221         }
23222         let two_way_ranging_measurements_count = bytes.get_mut().get_u8() as usize;
23223         if bytes.get().remaining() < two_way_ranging_measurements_count * 31usize {
23224             return Err(DecodeError::InvalidLengthError {
23225                 obj: "ShortMacTwoWaySessionInfoNtf",
23226                 wanted: two_way_ranging_measurements_count * 31usize,
23227                 got: bytes.get().remaining(),
23228             });
23229         }
23230         let two_way_ranging_measurements = (0..two_way_ranging_measurements_count)
23231             .map(|_| ShortAddressTwoWayRangingMeasurement::parse_inner(bytes))
23232             .collect::<Result<Vec<_>, DecodeError>>()?;
23233         let mut vendor_data = Vec::with_capacity(bytes.get().remaining());
23234         for _ in 0..bytes.get().remaining() {
23235             vendor_data.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
23236         }
23237         Ok(Self {
23238             two_way_ranging_measurements,
23239             vendor_data,
23240         })
23241     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>23242     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
23243         buffer.put_u8(self.two_way_ranging_measurements.len() as u8);
23244         for elem in &self.two_way_ranging_measurements {
23245             elem.write_to(buffer)?;
23246         }
23247         for elem in &self.vendor_data {
23248             buffer.put_u8(*elem);
23249         }
23250         Ok(())
23251     }
get_total_size(&self) -> usize23252     fn get_total_size(&self) -> usize {
23253         self.get_size()
23254     }
get_size(&self) -> usize23255     fn get_size(&self) -> usize {
23256         1
23257             + self
23258                 .two_way_ranging_measurements
23259                 .iter()
23260                 .map(|elem| elem.get_size())
23261                 .sum::<usize>() + self.vendor_data.len()
23262     }
23263 }
23264 impl Packet for ShortMacTwoWaySessionInfoNtf {
encoded_len(&self) -> usize23265     fn encoded_len(&self) -> usize {
23266         self.get_size()
23267     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>23268     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
23269         self.ucicontrolpacket.write_to(buf)
23270     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>23271     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
23272         unimplemented!("Rust legacy does not implement full packet trait")
23273     }
23274 }
23275 impl TryFrom<ShortMacTwoWaySessionInfoNtf> for Bytes {
23276     type Error = EncodeError;
try_from(packet: ShortMacTwoWaySessionInfoNtf) -> Result<Self, Self::Error>23277     fn try_from(packet: ShortMacTwoWaySessionInfoNtf) -> Result<Self, Self::Error> {
23278         packet.encode_to_bytes()
23279     }
23280 }
23281 impl TryFrom<ShortMacTwoWaySessionInfoNtf> for Vec<u8> {
23282     type Error = EncodeError;
try_from(packet: ShortMacTwoWaySessionInfoNtf) -> Result<Self, Self::Error>23283     fn try_from(packet: ShortMacTwoWaySessionInfoNtf) -> Result<Self, Self::Error> {
23284         packet.encode_to_vec()
23285     }
23286 }
23287 impl From<ShortMacTwoWaySessionInfoNtf> for UciControlPacket {
from(packet: ShortMacTwoWaySessionInfoNtf) -> UciControlPacket23288     fn from(packet: ShortMacTwoWaySessionInfoNtf) -> UciControlPacket {
23289         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
23290     }
23291 }
23292 impl From<ShortMacTwoWaySessionInfoNtf> for UciNotification {
from(packet: ShortMacTwoWaySessionInfoNtf) -> UciNotification23293     fn from(packet: ShortMacTwoWaySessionInfoNtf) -> UciNotification {
23294         UciNotification::new(packet.ucicontrolpacket).unwrap()
23295     }
23296 }
23297 impl From<ShortMacTwoWaySessionInfoNtf> for SessionControlNotification {
from(packet: ShortMacTwoWaySessionInfoNtf) -> SessionControlNotification23298     fn from(packet: ShortMacTwoWaySessionInfoNtf) -> SessionControlNotification {
23299         SessionControlNotification::new(packet.ucicontrolpacket).unwrap()
23300     }
23301 }
23302 impl From<ShortMacTwoWaySessionInfoNtf> for SessionInfoNtf {
from(packet: ShortMacTwoWaySessionInfoNtf) -> SessionInfoNtf23303     fn from(packet: ShortMacTwoWaySessionInfoNtf) -> SessionInfoNtf {
23304         SessionInfoNtf::new(packet.ucicontrolpacket).unwrap()
23305     }
23306 }
23307 impl TryFrom<UciControlPacket> for ShortMacTwoWaySessionInfoNtf {
23308     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<ShortMacTwoWaySessionInfoNtf, Self::Error>23309     fn try_from(
23310         packet: UciControlPacket,
23311     ) -> Result<ShortMacTwoWaySessionInfoNtf, Self::Error> {
23312         ShortMacTwoWaySessionInfoNtf::new(packet.ucicontrolpacket)
23313     }
23314 }
23315 impl ShortMacTwoWaySessionInfoNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>23316     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
23317         let mut cell = Cell::new(bytes);
23318         let packet = Self::parse_inner(&mut cell)?;
23319         Ok(packet)
23320     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>23321     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
23322         let data = UciControlPacketData::parse_inner(&mut bytes)?;
23323         Self::new(data)
23324     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>23325     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
23326         let ucinotification = match &ucicontrolpacket.child {
23327             UciControlPacketDataChild::UciNotification(value) => value.clone(),
23328             _ => {
23329                 return Err(DecodeError::InvalidChildError {
23330                     expected: stringify!(UciControlPacketDataChild::UciNotification),
23331                     actual: format!("{:?}", & ucicontrolpacket.child),
23332                 });
23333             }
23334         };
23335         let sessioncontrolnotification = match &ucinotification.child {
23336             UciNotificationDataChild::SessionControlNotification(value) => value.clone(),
23337             _ => {
23338                 return Err(DecodeError::InvalidChildError {
23339                     expected: stringify!(
23340                         UciNotificationDataChild::SessionControlNotification
23341                     ),
23342                     actual: format!("{:?}", & ucinotification.child),
23343                 });
23344             }
23345         };
23346         let sessioninfontf = match &sessioncontrolnotification.child {
23347             SessionControlNotificationDataChild::SessionInfoNtf(value) => value.clone(),
23348             _ => {
23349                 return Err(DecodeError::InvalidChildError {
23350                     expected: stringify!(
23351                         SessionControlNotificationDataChild::SessionInfoNtf
23352                     ),
23353                     actual: format!("{:?}", & sessioncontrolnotification.child),
23354                 });
23355             }
23356         };
23357         let shortmactwowaysessioninfontf = match &sessioninfontf.child {
23358             SessionInfoNtfDataChild::ShortMacTwoWaySessionInfoNtf(value) => value.clone(),
23359             _ => {
23360                 return Err(DecodeError::InvalidChildError {
23361                     expected: stringify!(
23362                         SessionInfoNtfDataChild::ShortMacTwoWaySessionInfoNtf
23363                     ),
23364                     actual: format!("{:?}", & sessioninfontf.child),
23365                 });
23366             }
23367         };
23368         Ok(Self {
23369             ucicontrolpacket,
23370             ucinotification,
23371             sessioncontrolnotification,
23372             sessioninfontf,
23373             shortmactwowaysessioninfontf,
23374         })
23375     }
get_current_ranging_interval(&self) -> u3223376     pub fn get_current_ranging_interval(&self) -> u32 {
23377         self.sessioninfontf.current_ranging_interval
23378     }
get_group_id(&self) -> GroupId23379     pub fn get_group_id(&self) -> GroupId {
23380         self.ucicontrolpacket.group_id
23381     }
get_mac_address_indicator(&self) -> MacAddressIndicator23382     pub fn get_mac_address_indicator(&self) -> MacAddressIndicator {
23383         self.sessioninfontf.mac_address_indicator
23384     }
get_message_type(&self) -> MessageType23385     pub fn get_message_type(&self) -> MessageType {
23386         self.ucicontrolpacket.message_type
23387     }
get_opcode(&self) -> u823388     pub fn get_opcode(&self) -> u8 {
23389         self.ucicontrolpacket.opcode
23390     }
get_ranging_measurement_type(&self) -> RangingMeasurementType23391     pub fn get_ranging_measurement_type(&self) -> RangingMeasurementType {
23392         self.sessioninfontf.ranging_measurement_type
23393     }
get_rcr_indicator(&self) -> u823394     pub fn get_rcr_indicator(&self) -> u8 {
23395         self.sessioninfontf.rcr_indicator
23396     }
get_sequence_number(&self) -> u3223397     pub fn get_sequence_number(&self) -> u32 {
23398         self.sessioninfontf.sequence_number
23399     }
get_session_token(&self) -> u3223400     pub fn get_session_token(&self) -> u32 {
23401         self.sessioninfontf.session_token
23402     }
get_two_way_ranging_measurements( &self, ) -> &Vec<ShortAddressTwoWayRangingMeasurement>23403     pub fn get_two_way_ranging_measurements(
23404         &self,
23405     ) -> &Vec<ShortAddressTwoWayRangingMeasurement> {
23406         &self.shortmactwowaysessioninfontf.two_way_ranging_measurements
23407     }
get_vendor_data(&self) -> &Vec<u8>23408     pub fn get_vendor_data(&self) -> &Vec<u8> {
23409         &self.shortmactwowaysessioninfontf.vendor_data
23410     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>23411     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
23412         self.shortmactwowaysessioninfontf.write_to(buffer)
23413     }
get_size(&self) -> usize23414     pub fn get_size(&self) -> usize {
23415         self.ucicontrolpacket.get_size()
23416     }
23417 }
23418 impl ShortMacTwoWaySessionInfoNtfBuilder {
build(self) -> ShortMacTwoWaySessionInfoNtf23419     pub fn build(self) -> ShortMacTwoWaySessionInfoNtf {
23420         let shortmactwowaysessioninfontf = ShortMacTwoWaySessionInfoNtfData {
23421             two_way_ranging_measurements: self.two_way_ranging_measurements,
23422             vendor_data: self.vendor_data,
23423         };
23424         let sessioninfontf = SessionInfoNtfData {
23425             current_ranging_interval: self.current_ranging_interval,
23426             mac_address_indicator: MacAddressIndicator::ShortAddress,
23427             ranging_measurement_type: RangingMeasurementType::TwoWay,
23428             rcr_indicator: self.rcr_indicator,
23429             sequence_number: self.sequence_number,
23430             session_token: self.session_token,
23431             child: SessionInfoNtfDataChild::ShortMacTwoWaySessionInfoNtf(
23432                 shortmactwowaysessioninfontf,
23433             ),
23434         };
23435         let sessioncontrolnotification = SessionControlNotificationData {
23436             child: SessionControlNotificationDataChild::SessionInfoNtf(sessioninfontf),
23437         };
23438         let ucinotification = UciNotificationData {
23439             child: UciNotificationDataChild::SessionControlNotification(
23440                 sessioncontrolnotification,
23441             ),
23442         };
23443         let ucicontrolpacket = UciControlPacketData {
23444             group_id: GroupId::SessionControl,
23445             message_type: MessageType::Notification,
23446             opcode: 0,
23447             child: UciControlPacketDataChild::UciNotification(ucinotification),
23448         };
23449         ShortMacTwoWaySessionInfoNtf::new(ucicontrolpacket).unwrap()
23450     }
23451 }
23452 impl From<ShortMacTwoWaySessionInfoNtfBuilder> for UciControlPacket {
from(builder: ShortMacTwoWaySessionInfoNtfBuilder) -> UciControlPacket23453     fn from(builder: ShortMacTwoWaySessionInfoNtfBuilder) -> UciControlPacket {
23454         builder.build().into()
23455     }
23456 }
23457 impl From<ShortMacTwoWaySessionInfoNtfBuilder> for UciNotification {
from(builder: ShortMacTwoWaySessionInfoNtfBuilder) -> UciNotification23458     fn from(builder: ShortMacTwoWaySessionInfoNtfBuilder) -> UciNotification {
23459         builder.build().into()
23460     }
23461 }
23462 impl From<ShortMacTwoWaySessionInfoNtfBuilder> for SessionControlNotification {
from(builder: ShortMacTwoWaySessionInfoNtfBuilder) -> SessionControlNotification23463     fn from(builder: ShortMacTwoWaySessionInfoNtfBuilder) -> SessionControlNotification {
23464         builder.build().into()
23465     }
23466 }
23467 impl From<ShortMacTwoWaySessionInfoNtfBuilder> for SessionInfoNtf {
from(builder: ShortMacTwoWaySessionInfoNtfBuilder) -> SessionInfoNtf23468     fn from(builder: ShortMacTwoWaySessionInfoNtfBuilder) -> SessionInfoNtf {
23469         builder.build().into()
23470     }
23471 }
23472 impl From<ShortMacTwoWaySessionInfoNtfBuilder> for ShortMacTwoWaySessionInfoNtf {
from( builder: ShortMacTwoWaySessionInfoNtfBuilder, ) -> ShortMacTwoWaySessionInfoNtf23473     fn from(
23474         builder: ShortMacTwoWaySessionInfoNtfBuilder,
23475     ) -> ShortMacTwoWaySessionInfoNtf {
23476         builder.build().into()
23477     }
23478 }
23479 #[derive(Debug, Clone, PartialEq, Eq)]
23480 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
23481 pub struct ExtendedMacTwoWaySessionInfoNtfData {
23482     two_way_ranging_measurements: Vec<ExtendedAddressTwoWayRangingMeasurement>,
23483     vendor_data: Vec<u8>,
23484 }
23485 #[derive(Debug, Clone, PartialEq, Eq)]
23486 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
23487 pub struct ExtendedMacTwoWaySessionInfoNtf {
23488     #[cfg_attr(feature = "serde", serde(flatten))]
23489     ucicontrolpacket: UciControlPacketData,
23490     #[cfg_attr(feature = "serde", serde(flatten))]
23491     ucinotification: UciNotificationData,
23492     #[cfg_attr(feature = "serde", serde(flatten))]
23493     sessioncontrolnotification: SessionControlNotificationData,
23494     #[cfg_attr(feature = "serde", serde(flatten))]
23495     sessioninfontf: SessionInfoNtfData,
23496     #[cfg_attr(feature = "serde", serde(flatten))]
23497     extendedmactwowaysessioninfontf: ExtendedMacTwoWaySessionInfoNtfData,
23498 }
23499 #[derive(Debug)]
23500 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
23501 pub struct ExtendedMacTwoWaySessionInfoNtfBuilder {
23502     pub current_ranging_interval: u32,
23503     pub rcr_indicator: u8,
23504     pub sequence_number: u32,
23505     pub session_token: u32,
23506     pub two_way_ranging_measurements: Vec<ExtendedAddressTwoWayRangingMeasurement>,
23507     pub vendor_data: Vec<u8>,
23508 }
23509 impl ExtendedMacTwoWaySessionInfoNtfData {
conforms(bytes: &[u8]) -> bool23510     fn conforms(bytes: &[u8]) -> bool {
23511         bytes.len() >= 1
23512     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>23513     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
23514         let mut cell = Cell::new(bytes);
23515         let packet = Self::parse_inner(&mut cell)?;
23516         Ok(packet)
23517     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>23518     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
23519         if bytes.get().remaining() < 1 {
23520             return Err(DecodeError::InvalidLengthError {
23521                 obj: "ExtendedMacTwoWaySessionInfoNtf",
23522                 wanted: 1,
23523                 got: bytes.get().remaining(),
23524             });
23525         }
23526         let two_way_ranging_measurements_count = bytes.get_mut().get_u8() as usize;
23527         if bytes.get().remaining() < two_way_ranging_measurements_count * 31usize {
23528             return Err(DecodeError::InvalidLengthError {
23529                 obj: "ExtendedMacTwoWaySessionInfoNtf",
23530                 wanted: two_way_ranging_measurements_count * 31usize,
23531                 got: bytes.get().remaining(),
23532             });
23533         }
23534         let two_way_ranging_measurements = (0..two_way_ranging_measurements_count)
23535             .map(|_| ExtendedAddressTwoWayRangingMeasurement::parse_inner(bytes))
23536             .collect::<Result<Vec<_>, DecodeError>>()?;
23537         let mut vendor_data = Vec::with_capacity(bytes.get().remaining());
23538         for _ in 0..bytes.get().remaining() {
23539             vendor_data.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
23540         }
23541         Ok(Self {
23542             two_way_ranging_measurements,
23543             vendor_data,
23544         })
23545     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>23546     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
23547         buffer.put_u8(self.two_way_ranging_measurements.len() as u8);
23548         for elem in &self.two_way_ranging_measurements {
23549             elem.write_to(buffer)?;
23550         }
23551         for elem in &self.vendor_data {
23552             buffer.put_u8(*elem);
23553         }
23554         Ok(())
23555     }
get_total_size(&self) -> usize23556     fn get_total_size(&self) -> usize {
23557         self.get_size()
23558     }
get_size(&self) -> usize23559     fn get_size(&self) -> usize {
23560         1
23561             + self
23562                 .two_way_ranging_measurements
23563                 .iter()
23564                 .map(|elem| elem.get_size())
23565                 .sum::<usize>() + self.vendor_data.len()
23566     }
23567 }
23568 impl Packet for ExtendedMacTwoWaySessionInfoNtf {
encoded_len(&self) -> usize23569     fn encoded_len(&self) -> usize {
23570         self.get_size()
23571     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>23572     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
23573         self.ucicontrolpacket.write_to(buf)
23574     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>23575     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
23576         unimplemented!("Rust legacy does not implement full packet trait")
23577     }
23578 }
23579 impl TryFrom<ExtendedMacTwoWaySessionInfoNtf> for Bytes {
23580     type Error = EncodeError;
try_from(packet: ExtendedMacTwoWaySessionInfoNtf) -> Result<Self, Self::Error>23581     fn try_from(packet: ExtendedMacTwoWaySessionInfoNtf) -> Result<Self, Self::Error> {
23582         packet.encode_to_bytes()
23583     }
23584 }
23585 impl TryFrom<ExtendedMacTwoWaySessionInfoNtf> for Vec<u8> {
23586     type Error = EncodeError;
try_from(packet: ExtendedMacTwoWaySessionInfoNtf) -> Result<Self, Self::Error>23587     fn try_from(packet: ExtendedMacTwoWaySessionInfoNtf) -> Result<Self, Self::Error> {
23588         packet.encode_to_vec()
23589     }
23590 }
23591 impl From<ExtendedMacTwoWaySessionInfoNtf> for UciControlPacket {
from(packet: ExtendedMacTwoWaySessionInfoNtf) -> UciControlPacket23592     fn from(packet: ExtendedMacTwoWaySessionInfoNtf) -> UciControlPacket {
23593         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
23594     }
23595 }
23596 impl From<ExtendedMacTwoWaySessionInfoNtf> for UciNotification {
from(packet: ExtendedMacTwoWaySessionInfoNtf) -> UciNotification23597     fn from(packet: ExtendedMacTwoWaySessionInfoNtf) -> UciNotification {
23598         UciNotification::new(packet.ucicontrolpacket).unwrap()
23599     }
23600 }
23601 impl From<ExtendedMacTwoWaySessionInfoNtf> for SessionControlNotification {
from(packet: ExtendedMacTwoWaySessionInfoNtf) -> SessionControlNotification23602     fn from(packet: ExtendedMacTwoWaySessionInfoNtf) -> SessionControlNotification {
23603         SessionControlNotification::new(packet.ucicontrolpacket).unwrap()
23604     }
23605 }
23606 impl From<ExtendedMacTwoWaySessionInfoNtf> for SessionInfoNtf {
from(packet: ExtendedMacTwoWaySessionInfoNtf) -> SessionInfoNtf23607     fn from(packet: ExtendedMacTwoWaySessionInfoNtf) -> SessionInfoNtf {
23608         SessionInfoNtf::new(packet.ucicontrolpacket).unwrap()
23609     }
23610 }
23611 impl TryFrom<UciControlPacket> for ExtendedMacTwoWaySessionInfoNtf {
23612     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<ExtendedMacTwoWaySessionInfoNtf, Self::Error>23613     fn try_from(
23614         packet: UciControlPacket,
23615     ) -> Result<ExtendedMacTwoWaySessionInfoNtf, Self::Error> {
23616         ExtendedMacTwoWaySessionInfoNtf::new(packet.ucicontrolpacket)
23617     }
23618 }
23619 impl ExtendedMacTwoWaySessionInfoNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>23620     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
23621         let mut cell = Cell::new(bytes);
23622         let packet = Self::parse_inner(&mut cell)?;
23623         Ok(packet)
23624     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>23625     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
23626         let data = UciControlPacketData::parse_inner(&mut bytes)?;
23627         Self::new(data)
23628     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>23629     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
23630         let ucinotification = match &ucicontrolpacket.child {
23631             UciControlPacketDataChild::UciNotification(value) => value.clone(),
23632             _ => {
23633                 return Err(DecodeError::InvalidChildError {
23634                     expected: stringify!(UciControlPacketDataChild::UciNotification),
23635                     actual: format!("{:?}", & ucicontrolpacket.child),
23636                 });
23637             }
23638         };
23639         let sessioncontrolnotification = match &ucinotification.child {
23640             UciNotificationDataChild::SessionControlNotification(value) => value.clone(),
23641             _ => {
23642                 return Err(DecodeError::InvalidChildError {
23643                     expected: stringify!(
23644                         UciNotificationDataChild::SessionControlNotification
23645                     ),
23646                     actual: format!("{:?}", & ucinotification.child),
23647                 });
23648             }
23649         };
23650         let sessioninfontf = match &sessioncontrolnotification.child {
23651             SessionControlNotificationDataChild::SessionInfoNtf(value) => value.clone(),
23652             _ => {
23653                 return Err(DecodeError::InvalidChildError {
23654                     expected: stringify!(
23655                         SessionControlNotificationDataChild::SessionInfoNtf
23656                     ),
23657                     actual: format!("{:?}", & sessioncontrolnotification.child),
23658                 });
23659             }
23660         };
23661         let extendedmactwowaysessioninfontf = match &sessioninfontf.child {
23662             SessionInfoNtfDataChild::ExtendedMacTwoWaySessionInfoNtf(value) => {
23663                 value.clone()
23664             }
23665             _ => {
23666                 return Err(DecodeError::InvalidChildError {
23667                     expected: stringify!(
23668                         SessionInfoNtfDataChild::ExtendedMacTwoWaySessionInfoNtf
23669                     ),
23670                     actual: format!("{:?}", & sessioninfontf.child),
23671                 });
23672             }
23673         };
23674         Ok(Self {
23675             ucicontrolpacket,
23676             ucinotification,
23677             sessioncontrolnotification,
23678             sessioninfontf,
23679             extendedmactwowaysessioninfontf,
23680         })
23681     }
get_current_ranging_interval(&self) -> u3223682     pub fn get_current_ranging_interval(&self) -> u32 {
23683         self.sessioninfontf.current_ranging_interval
23684     }
get_group_id(&self) -> GroupId23685     pub fn get_group_id(&self) -> GroupId {
23686         self.ucicontrolpacket.group_id
23687     }
get_mac_address_indicator(&self) -> MacAddressIndicator23688     pub fn get_mac_address_indicator(&self) -> MacAddressIndicator {
23689         self.sessioninfontf.mac_address_indicator
23690     }
get_message_type(&self) -> MessageType23691     pub fn get_message_type(&self) -> MessageType {
23692         self.ucicontrolpacket.message_type
23693     }
get_opcode(&self) -> u823694     pub fn get_opcode(&self) -> u8 {
23695         self.ucicontrolpacket.opcode
23696     }
get_ranging_measurement_type(&self) -> RangingMeasurementType23697     pub fn get_ranging_measurement_type(&self) -> RangingMeasurementType {
23698         self.sessioninfontf.ranging_measurement_type
23699     }
get_rcr_indicator(&self) -> u823700     pub fn get_rcr_indicator(&self) -> u8 {
23701         self.sessioninfontf.rcr_indicator
23702     }
get_sequence_number(&self) -> u3223703     pub fn get_sequence_number(&self) -> u32 {
23704         self.sessioninfontf.sequence_number
23705     }
get_session_token(&self) -> u3223706     pub fn get_session_token(&self) -> u32 {
23707         self.sessioninfontf.session_token
23708     }
get_two_way_ranging_measurements( &self, ) -> &Vec<ExtendedAddressTwoWayRangingMeasurement>23709     pub fn get_two_way_ranging_measurements(
23710         &self,
23711     ) -> &Vec<ExtendedAddressTwoWayRangingMeasurement> {
23712         &self.extendedmactwowaysessioninfontf.two_way_ranging_measurements
23713     }
get_vendor_data(&self) -> &Vec<u8>23714     pub fn get_vendor_data(&self) -> &Vec<u8> {
23715         &self.extendedmactwowaysessioninfontf.vendor_data
23716     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>23717     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
23718         self.extendedmactwowaysessioninfontf.write_to(buffer)
23719     }
get_size(&self) -> usize23720     pub fn get_size(&self) -> usize {
23721         self.ucicontrolpacket.get_size()
23722     }
23723 }
23724 impl ExtendedMacTwoWaySessionInfoNtfBuilder {
build(self) -> ExtendedMacTwoWaySessionInfoNtf23725     pub fn build(self) -> ExtendedMacTwoWaySessionInfoNtf {
23726         let extendedmactwowaysessioninfontf = ExtendedMacTwoWaySessionInfoNtfData {
23727             two_way_ranging_measurements: self.two_way_ranging_measurements,
23728             vendor_data: self.vendor_data,
23729         };
23730         let sessioninfontf = SessionInfoNtfData {
23731             current_ranging_interval: self.current_ranging_interval,
23732             mac_address_indicator: MacAddressIndicator::ExtendedAddress,
23733             ranging_measurement_type: RangingMeasurementType::TwoWay,
23734             rcr_indicator: self.rcr_indicator,
23735             sequence_number: self.sequence_number,
23736             session_token: self.session_token,
23737             child: SessionInfoNtfDataChild::ExtendedMacTwoWaySessionInfoNtf(
23738                 extendedmactwowaysessioninfontf,
23739             ),
23740         };
23741         let sessioncontrolnotification = SessionControlNotificationData {
23742             child: SessionControlNotificationDataChild::SessionInfoNtf(sessioninfontf),
23743         };
23744         let ucinotification = UciNotificationData {
23745             child: UciNotificationDataChild::SessionControlNotification(
23746                 sessioncontrolnotification,
23747             ),
23748         };
23749         let ucicontrolpacket = UciControlPacketData {
23750             group_id: GroupId::SessionControl,
23751             message_type: MessageType::Notification,
23752             opcode: 0,
23753             child: UciControlPacketDataChild::UciNotification(ucinotification),
23754         };
23755         ExtendedMacTwoWaySessionInfoNtf::new(ucicontrolpacket).unwrap()
23756     }
23757 }
23758 impl From<ExtendedMacTwoWaySessionInfoNtfBuilder> for UciControlPacket {
from(builder: ExtendedMacTwoWaySessionInfoNtfBuilder) -> UciControlPacket23759     fn from(builder: ExtendedMacTwoWaySessionInfoNtfBuilder) -> UciControlPacket {
23760         builder.build().into()
23761     }
23762 }
23763 impl From<ExtendedMacTwoWaySessionInfoNtfBuilder> for UciNotification {
from(builder: ExtendedMacTwoWaySessionInfoNtfBuilder) -> UciNotification23764     fn from(builder: ExtendedMacTwoWaySessionInfoNtfBuilder) -> UciNotification {
23765         builder.build().into()
23766     }
23767 }
23768 impl From<ExtendedMacTwoWaySessionInfoNtfBuilder> for SessionControlNotification {
from( builder: ExtendedMacTwoWaySessionInfoNtfBuilder, ) -> SessionControlNotification23769     fn from(
23770         builder: ExtendedMacTwoWaySessionInfoNtfBuilder,
23771     ) -> SessionControlNotification {
23772         builder.build().into()
23773     }
23774 }
23775 impl From<ExtendedMacTwoWaySessionInfoNtfBuilder> for SessionInfoNtf {
from(builder: ExtendedMacTwoWaySessionInfoNtfBuilder) -> SessionInfoNtf23776     fn from(builder: ExtendedMacTwoWaySessionInfoNtfBuilder) -> SessionInfoNtf {
23777         builder.build().into()
23778     }
23779 }
23780 impl From<ExtendedMacTwoWaySessionInfoNtfBuilder> for ExtendedMacTwoWaySessionInfoNtf {
from( builder: ExtendedMacTwoWaySessionInfoNtfBuilder, ) -> ExtendedMacTwoWaySessionInfoNtf23781     fn from(
23782         builder: ExtendedMacTwoWaySessionInfoNtfBuilder,
23783     ) -> ExtendedMacTwoWaySessionInfoNtf {
23784         builder.build().into()
23785     }
23786 }
23787 #[derive(Debug, Clone, PartialEq, Eq)]
23788 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
23789 pub struct ShortMacDlTDoASessionInfoNtfData {
23790     no_of_ranging_measurements: u8,
23791     dl_tdoa_measurements: Vec<u8>,
23792 }
23793 #[derive(Debug, Clone, PartialEq, Eq)]
23794 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
23795 pub struct ShortMacDlTDoASessionInfoNtf {
23796     #[cfg_attr(feature = "serde", serde(flatten))]
23797     ucicontrolpacket: UciControlPacketData,
23798     #[cfg_attr(feature = "serde", serde(flatten))]
23799     ucinotification: UciNotificationData,
23800     #[cfg_attr(feature = "serde", serde(flatten))]
23801     sessioncontrolnotification: SessionControlNotificationData,
23802     #[cfg_attr(feature = "serde", serde(flatten))]
23803     sessioninfontf: SessionInfoNtfData,
23804     #[cfg_attr(feature = "serde", serde(flatten))]
23805     shortmacdltdoasessioninfontf: ShortMacDlTDoASessionInfoNtfData,
23806 }
23807 #[derive(Debug)]
23808 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
23809 pub struct ShortMacDlTDoASessionInfoNtfBuilder {
23810     pub current_ranging_interval: u32,
23811     pub dl_tdoa_measurements: Vec<u8>,
23812     pub no_of_ranging_measurements: u8,
23813     pub rcr_indicator: u8,
23814     pub sequence_number: u32,
23815     pub session_token: u32,
23816 }
23817 impl ShortMacDlTDoASessionInfoNtfData {
conforms(bytes: &[u8]) -> bool23818     fn conforms(bytes: &[u8]) -> bool {
23819         bytes.len() >= 1
23820     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>23821     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
23822         let mut cell = Cell::new(bytes);
23823         let packet = Self::parse_inner(&mut cell)?;
23824         Ok(packet)
23825     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>23826     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
23827         if bytes.get().remaining() < 1 {
23828             return Err(DecodeError::InvalidLengthError {
23829                 obj: "ShortMacDlTDoASessionInfoNtf",
23830                 wanted: 1,
23831                 got: bytes.get().remaining(),
23832             });
23833         }
23834         let no_of_ranging_measurements = bytes.get_mut().get_u8();
23835         let mut dl_tdoa_measurements = Vec::with_capacity(bytes.get().remaining());
23836         for _ in 0..bytes.get().remaining() {
23837             dl_tdoa_measurements.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
23838         }
23839         Ok(Self {
23840             no_of_ranging_measurements,
23841             dl_tdoa_measurements,
23842         })
23843     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>23844     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
23845         buffer.put_u8(self.no_of_ranging_measurements);
23846         for elem in &self.dl_tdoa_measurements {
23847             buffer.put_u8(*elem);
23848         }
23849         Ok(())
23850     }
get_total_size(&self) -> usize23851     fn get_total_size(&self) -> usize {
23852         self.get_size()
23853     }
get_size(&self) -> usize23854     fn get_size(&self) -> usize {
23855         1 + self.dl_tdoa_measurements.len()
23856     }
23857 }
23858 impl Packet for ShortMacDlTDoASessionInfoNtf {
encoded_len(&self) -> usize23859     fn encoded_len(&self) -> usize {
23860         self.get_size()
23861     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>23862     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
23863         self.ucicontrolpacket.write_to(buf)
23864     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>23865     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
23866         unimplemented!("Rust legacy does not implement full packet trait")
23867     }
23868 }
23869 impl TryFrom<ShortMacDlTDoASessionInfoNtf> for Bytes {
23870     type Error = EncodeError;
try_from(packet: ShortMacDlTDoASessionInfoNtf) -> Result<Self, Self::Error>23871     fn try_from(packet: ShortMacDlTDoASessionInfoNtf) -> Result<Self, Self::Error> {
23872         packet.encode_to_bytes()
23873     }
23874 }
23875 impl TryFrom<ShortMacDlTDoASessionInfoNtf> for Vec<u8> {
23876     type Error = EncodeError;
try_from(packet: ShortMacDlTDoASessionInfoNtf) -> Result<Self, Self::Error>23877     fn try_from(packet: ShortMacDlTDoASessionInfoNtf) -> Result<Self, Self::Error> {
23878         packet.encode_to_vec()
23879     }
23880 }
23881 impl From<ShortMacDlTDoASessionInfoNtf> for UciControlPacket {
from(packet: ShortMacDlTDoASessionInfoNtf) -> UciControlPacket23882     fn from(packet: ShortMacDlTDoASessionInfoNtf) -> UciControlPacket {
23883         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
23884     }
23885 }
23886 impl From<ShortMacDlTDoASessionInfoNtf> for UciNotification {
from(packet: ShortMacDlTDoASessionInfoNtf) -> UciNotification23887     fn from(packet: ShortMacDlTDoASessionInfoNtf) -> UciNotification {
23888         UciNotification::new(packet.ucicontrolpacket).unwrap()
23889     }
23890 }
23891 impl From<ShortMacDlTDoASessionInfoNtf> for SessionControlNotification {
from(packet: ShortMacDlTDoASessionInfoNtf) -> SessionControlNotification23892     fn from(packet: ShortMacDlTDoASessionInfoNtf) -> SessionControlNotification {
23893         SessionControlNotification::new(packet.ucicontrolpacket).unwrap()
23894     }
23895 }
23896 impl From<ShortMacDlTDoASessionInfoNtf> for SessionInfoNtf {
from(packet: ShortMacDlTDoASessionInfoNtf) -> SessionInfoNtf23897     fn from(packet: ShortMacDlTDoASessionInfoNtf) -> SessionInfoNtf {
23898         SessionInfoNtf::new(packet.ucicontrolpacket).unwrap()
23899     }
23900 }
23901 impl TryFrom<UciControlPacket> for ShortMacDlTDoASessionInfoNtf {
23902     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<ShortMacDlTDoASessionInfoNtf, Self::Error>23903     fn try_from(
23904         packet: UciControlPacket,
23905     ) -> Result<ShortMacDlTDoASessionInfoNtf, Self::Error> {
23906         ShortMacDlTDoASessionInfoNtf::new(packet.ucicontrolpacket)
23907     }
23908 }
23909 impl ShortMacDlTDoASessionInfoNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>23910     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
23911         let mut cell = Cell::new(bytes);
23912         let packet = Self::parse_inner(&mut cell)?;
23913         Ok(packet)
23914     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>23915     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
23916         let data = UciControlPacketData::parse_inner(&mut bytes)?;
23917         Self::new(data)
23918     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>23919     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
23920         let ucinotification = match &ucicontrolpacket.child {
23921             UciControlPacketDataChild::UciNotification(value) => value.clone(),
23922             _ => {
23923                 return Err(DecodeError::InvalidChildError {
23924                     expected: stringify!(UciControlPacketDataChild::UciNotification),
23925                     actual: format!("{:?}", & ucicontrolpacket.child),
23926                 });
23927             }
23928         };
23929         let sessioncontrolnotification = match &ucinotification.child {
23930             UciNotificationDataChild::SessionControlNotification(value) => value.clone(),
23931             _ => {
23932                 return Err(DecodeError::InvalidChildError {
23933                     expected: stringify!(
23934                         UciNotificationDataChild::SessionControlNotification
23935                     ),
23936                     actual: format!("{:?}", & ucinotification.child),
23937                 });
23938             }
23939         };
23940         let sessioninfontf = match &sessioncontrolnotification.child {
23941             SessionControlNotificationDataChild::SessionInfoNtf(value) => value.clone(),
23942             _ => {
23943                 return Err(DecodeError::InvalidChildError {
23944                     expected: stringify!(
23945                         SessionControlNotificationDataChild::SessionInfoNtf
23946                     ),
23947                     actual: format!("{:?}", & sessioncontrolnotification.child),
23948                 });
23949             }
23950         };
23951         let shortmacdltdoasessioninfontf = match &sessioninfontf.child {
23952             SessionInfoNtfDataChild::ShortMacDlTDoASessionInfoNtf(value) => value.clone(),
23953             _ => {
23954                 return Err(DecodeError::InvalidChildError {
23955                     expected: stringify!(
23956                         SessionInfoNtfDataChild::ShortMacDlTDoASessionInfoNtf
23957                     ),
23958                     actual: format!("{:?}", & sessioninfontf.child),
23959                 });
23960             }
23961         };
23962         Ok(Self {
23963             ucicontrolpacket,
23964             ucinotification,
23965             sessioncontrolnotification,
23966             sessioninfontf,
23967             shortmacdltdoasessioninfontf,
23968         })
23969     }
get_current_ranging_interval(&self) -> u3223970     pub fn get_current_ranging_interval(&self) -> u32 {
23971         self.sessioninfontf.current_ranging_interval
23972     }
get_dl_tdoa_measurements(&self) -> &Vec<u8>23973     pub fn get_dl_tdoa_measurements(&self) -> &Vec<u8> {
23974         &self.shortmacdltdoasessioninfontf.dl_tdoa_measurements
23975     }
get_group_id(&self) -> GroupId23976     pub fn get_group_id(&self) -> GroupId {
23977         self.ucicontrolpacket.group_id
23978     }
get_mac_address_indicator(&self) -> MacAddressIndicator23979     pub fn get_mac_address_indicator(&self) -> MacAddressIndicator {
23980         self.sessioninfontf.mac_address_indicator
23981     }
get_message_type(&self) -> MessageType23982     pub fn get_message_type(&self) -> MessageType {
23983         self.ucicontrolpacket.message_type
23984     }
get_no_of_ranging_measurements(&self) -> u823985     pub fn get_no_of_ranging_measurements(&self) -> u8 {
23986         self.shortmacdltdoasessioninfontf.no_of_ranging_measurements
23987     }
get_opcode(&self) -> u823988     pub fn get_opcode(&self) -> u8 {
23989         self.ucicontrolpacket.opcode
23990     }
get_ranging_measurement_type(&self) -> RangingMeasurementType23991     pub fn get_ranging_measurement_type(&self) -> RangingMeasurementType {
23992         self.sessioninfontf.ranging_measurement_type
23993     }
get_rcr_indicator(&self) -> u823994     pub fn get_rcr_indicator(&self) -> u8 {
23995         self.sessioninfontf.rcr_indicator
23996     }
get_sequence_number(&self) -> u3223997     pub fn get_sequence_number(&self) -> u32 {
23998         self.sessioninfontf.sequence_number
23999     }
get_session_token(&self) -> u3224000     pub fn get_session_token(&self) -> u32 {
24001         self.sessioninfontf.session_token
24002     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>24003     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
24004         self.shortmacdltdoasessioninfontf.write_to(buffer)
24005     }
get_size(&self) -> usize24006     pub fn get_size(&self) -> usize {
24007         self.ucicontrolpacket.get_size()
24008     }
24009 }
24010 impl ShortMacDlTDoASessionInfoNtfBuilder {
build(self) -> ShortMacDlTDoASessionInfoNtf24011     pub fn build(self) -> ShortMacDlTDoASessionInfoNtf {
24012         let shortmacdltdoasessioninfontf = ShortMacDlTDoASessionInfoNtfData {
24013             dl_tdoa_measurements: self.dl_tdoa_measurements,
24014             no_of_ranging_measurements: self.no_of_ranging_measurements,
24015         };
24016         let sessioninfontf = SessionInfoNtfData {
24017             current_ranging_interval: self.current_ranging_interval,
24018             mac_address_indicator: MacAddressIndicator::ShortAddress,
24019             ranging_measurement_type: RangingMeasurementType::DlTdoa,
24020             rcr_indicator: self.rcr_indicator,
24021             sequence_number: self.sequence_number,
24022             session_token: self.session_token,
24023             child: SessionInfoNtfDataChild::ShortMacDlTDoASessionInfoNtf(
24024                 shortmacdltdoasessioninfontf,
24025             ),
24026         };
24027         let sessioncontrolnotification = SessionControlNotificationData {
24028             child: SessionControlNotificationDataChild::SessionInfoNtf(sessioninfontf),
24029         };
24030         let ucinotification = UciNotificationData {
24031             child: UciNotificationDataChild::SessionControlNotification(
24032                 sessioncontrolnotification,
24033             ),
24034         };
24035         let ucicontrolpacket = UciControlPacketData {
24036             group_id: GroupId::SessionControl,
24037             message_type: MessageType::Notification,
24038             opcode: 0,
24039             child: UciControlPacketDataChild::UciNotification(ucinotification),
24040         };
24041         ShortMacDlTDoASessionInfoNtf::new(ucicontrolpacket).unwrap()
24042     }
24043 }
24044 impl From<ShortMacDlTDoASessionInfoNtfBuilder> for UciControlPacket {
from(builder: ShortMacDlTDoASessionInfoNtfBuilder) -> UciControlPacket24045     fn from(builder: ShortMacDlTDoASessionInfoNtfBuilder) -> UciControlPacket {
24046         builder.build().into()
24047     }
24048 }
24049 impl From<ShortMacDlTDoASessionInfoNtfBuilder> for UciNotification {
from(builder: ShortMacDlTDoASessionInfoNtfBuilder) -> UciNotification24050     fn from(builder: ShortMacDlTDoASessionInfoNtfBuilder) -> UciNotification {
24051         builder.build().into()
24052     }
24053 }
24054 impl From<ShortMacDlTDoASessionInfoNtfBuilder> for SessionControlNotification {
from(builder: ShortMacDlTDoASessionInfoNtfBuilder) -> SessionControlNotification24055     fn from(builder: ShortMacDlTDoASessionInfoNtfBuilder) -> SessionControlNotification {
24056         builder.build().into()
24057     }
24058 }
24059 impl From<ShortMacDlTDoASessionInfoNtfBuilder> for SessionInfoNtf {
from(builder: ShortMacDlTDoASessionInfoNtfBuilder) -> SessionInfoNtf24060     fn from(builder: ShortMacDlTDoASessionInfoNtfBuilder) -> SessionInfoNtf {
24061         builder.build().into()
24062     }
24063 }
24064 impl From<ShortMacDlTDoASessionInfoNtfBuilder> for ShortMacDlTDoASessionInfoNtf {
from( builder: ShortMacDlTDoASessionInfoNtfBuilder, ) -> ShortMacDlTDoASessionInfoNtf24065     fn from(
24066         builder: ShortMacDlTDoASessionInfoNtfBuilder,
24067     ) -> ShortMacDlTDoASessionInfoNtf {
24068         builder.build().into()
24069     }
24070 }
24071 #[derive(Debug, Clone, PartialEq, Eq)]
24072 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24073 pub struct ExtendedMacDlTDoASessionInfoNtfData {
24074     no_of_ranging_measurements: u8,
24075     dl_tdoa_measurements: Vec<u8>,
24076 }
24077 #[derive(Debug, Clone, PartialEq, Eq)]
24078 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24079 pub struct ExtendedMacDlTDoASessionInfoNtf {
24080     #[cfg_attr(feature = "serde", serde(flatten))]
24081     ucicontrolpacket: UciControlPacketData,
24082     #[cfg_attr(feature = "serde", serde(flatten))]
24083     ucinotification: UciNotificationData,
24084     #[cfg_attr(feature = "serde", serde(flatten))]
24085     sessioncontrolnotification: SessionControlNotificationData,
24086     #[cfg_attr(feature = "serde", serde(flatten))]
24087     sessioninfontf: SessionInfoNtfData,
24088     #[cfg_attr(feature = "serde", serde(flatten))]
24089     extendedmacdltdoasessioninfontf: ExtendedMacDlTDoASessionInfoNtfData,
24090 }
24091 #[derive(Debug)]
24092 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24093 pub struct ExtendedMacDlTDoASessionInfoNtfBuilder {
24094     pub current_ranging_interval: u32,
24095     pub dl_tdoa_measurements: Vec<u8>,
24096     pub no_of_ranging_measurements: u8,
24097     pub rcr_indicator: u8,
24098     pub sequence_number: u32,
24099     pub session_token: u32,
24100 }
24101 impl ExtendedMacDlTDoASessionInfoNtfData {
conforms(bytes: &[u8]) -> bool24102     fn conforms(bytes: &[u8]) -> bool {
24103         bytes.len() >= 1
24104     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>24105     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
24106         let mut cell = Cell::new(bytes);
24107         let packet = Self::parse_inner(&mut cell)?;
24108         Ok(packet)
24109     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>24110     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
24111         if bytes.get().remaining() < 1 {
24112             return Err(DecodeError::InvalidLengthError {
24113                 obj: "ExtendedMacDlTDoASessionInfoNtf",
24114                 wanted: 1,
24115                 got: bytes.get().remaining(),
24116             });
24117         }
24118         let no_of_ranging_measurements = bytes.get_mut().get_u8();
24119         let mut dl_tdoa_measurements = Vec::with_capacity(bytes.get().remaining());
24120         for _ in 0..bytes.get().remaining() {
24121             dl_tdoa_measurements.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
24122         }
24123         Ok(Self {
24124             no_of_ranging_measurements,
24125             dl_tdoa_measurements,
24126         })
24127     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>24128     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
24129         buffer.put_u8(self.no_of_ranging_measurements);
24130         for elem in &self.dl_tdoa_measurements {
24131             buffer.put_u8(*elem);
24132         }
24133         Ok(())
24134     }
get_total_size(&self) -> usize24135     fn get_total_size(&self) -> usize {
24136         self.get_size()
24137     }
get_size(&self) -> usize24138     fn get_size(&self) -> usize {
24139         1 + self.dl_tdoa_measurements.len()
24140     }
24141 }
24142 impl Packet for ExtendedMacDlTDoASessionInfoNtf {
encoded_len(&self) -> usize24143     fn encoded_len(&self) -> usize {
24144         self.get_size()
24145     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>24146     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
24147         self.ucicontrolpacket.write_to(buf)
24148     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>24149     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
24150         unimplemented!("Rust legacy does not implement full packet trait")
24151     }
24152 }
24153 impl TryFrom<ExtendedMacDlTDoASessionInfoNtf> for Bytes {
24154     type Error = EncodeError;
try_from(packet: ExtendedMacDlTDoASessionInfoNtf) -> Result<Self, Self::Error>24155     fn try_from(packet: ExtendedMacDlTDoASessionInfoNtf) -> Result<Self, Self::Error> {
24156         packet.encode_to_bytes()
24157     }
24158 }
24159 impl TryFrom<ExtendedMacDlTDoASessionInfoNtf> for Vec<u8> {
24160     type Error = EncodeError;
try_from(packet: ExtendedMacDlTDoASessionInfoNtf) -> Result<Self, Self::Error>24161     fn try_from(packet: ExtendedMacDlTDoASessionInfoNtf) -> Result<Self, Self::Error> {
24162         packet.encode_to_vec()
24163     }
24164 }
24165 impl From<ExtendedMacDlTDoASessionInfoNtf> for UciControlPacket {
from(packet: ExtendedMacDlTDoASessionInfoNtf) -> UciControlPacket24166     fn from(packet: ExtendedMacDlTDoASessionInfoNtf) -> UciControlPacket {
24167         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
24168     }
24169 }
24170 impl From<ExtendedMacDlTDoASessionInfoNtf> for UciNotification {
from(packet: ExtendedMacDlTDoASessionInfoNtf) -> UciNotification24171     fn from(packet: ExtendedMacDlTDoASessionInfoNtf) -> UciNotification {
24172         UciNotification::new(packet.ucicontrolpacket).unwrap()
24173     }
24174 }
24175 impl From<ExtendedMacDlTDoASessionInfoNtf> for SessionControlNotification {
from(packet: ExtendedMacDlTDoASessionInfoNtf) -> SessionControlNotification24176     fn from(packet: ExtendedMacDlTDoASessionInfoNtf) -> SessionControlNotification {
24177         SessionControlNotification::new(packet.ucicontrolpacket).unwrap()
24178     }
24179 }
24180 impl From<ExtendedMacDlTDoASessionInfoNtf> for SessionInfoNtf {
from(packet: ExtendedMacDlTDoASessionInfoNtf) -> SessionInfoNtf24181     fn from(packet: ExtendedMacDlTDoASessionInfoNtf) -> SessionInfoNtf {
24182         SessionInfoNtf::new(packet.ucicontrolpacket).unwrap()
24183     }
24184 }
24185 impl TryFrom<UciControlPacket> for ExtendedMacDlTDoASessionInfoNtf {
24186     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<ExtendedMacDlTDoASessionInfoNtf, Self::Error>24187     fn try_from(
24188         packet: UciControlPacket,
24189     ) -> Result<ExtendedMacDlTDoASessionInfoNtf, Self::Error> {
24190         ExtendedMacDlTDoASessionInfoNtf::new(packet.ucicontrolpacket)
24191     }
24192 }
24193 impl ExtendedMacDlTDoASessionInfoNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>24194     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
24195         let mut cell = Cell::new(bytes);
24196         let packet = Self::parse_inner(&mut cell)?;
24197         Ok(packet)
24198     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>24199     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
24200         let data = UciControlPacketData::parse_inner(&mut bytes)?;
24201         Self::new(data)
24202     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>24203     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
24204         let ucinotification = match &ucicontrolpacket.child {
24205             UciControlPacketDataChild::UciNotification(value) => value.clone(),
24206             _ => {
24207                 return Err(DecodeError::InvalidChildError {
24208                     expected: stringify!(UciControlPacketDataChild::UciNotification),
24209                     actual: format!("{:?}", & ucicontrolpacket.child),
24210                 });
24211             }
24212         };
24213         let sessioncontrolnotification = match &ucinotification.child {
24214             UciNotificationDataChild::SessionControlNotification(value) => value.clone(),
24215             _ => {
24216                 return Err(DecodeError::InvalidChildError {
24217                     expected: stringify!(
24218                         UciNotificationDataChild::SessionControlNotification
24219                     ),
24220                     actual: format!("{:?}", & ucinotification.child),
24221                 });
24222             }
24223         };
24224         let sessioninfontf = match &sessioncontrolnotification.child {
24225             SessionControlNotificationDataChild::SessionInfoNtf(value) => value.clone(),
24226             _ => {
24227                 return Err(DecodeError::InvalidChildError {
24228                     expected: stringify!(
24229                         SessionControlNotificationDataChild::SessionInfoNtf
24230                     ),
24231                     actual: format!("{:?}", & sessioncontrolnotification.child),
24232                 });
24233             }
24234         };
24235         let extendedmacdltdoasessioninfontf = match &sessioninfontf.child {
24236             SessionInfoNtfDataChild::ExtendedMacDlTDoASessionInfoNtf(value) => {
24237                 value.clone()
24238             }
24239             _ => {
24240                 return Err(DecodeError::InvalidChildError {
24241                     expected: stringify!(
24242                         SessionInfoNtfDataChild::ExtendedMacDlTDoASessionInfoNtf
24243                     ),
24244                     actual: format!("{:?}", & sessioninfontf.child),
24245                 });
24246             }
24247         };
24248         Ok(Self {
24249             ucicontrolpacket,
24250             ucinotification,
24251             sessioncontrolnotification,
24252             sessioninfontf,
24253             extendedmacdltdoasessioninfontf,
24254         })
24255     }
get_current_ranging_interval(&self) -> u3224256     pub fn get_current_ranging_interval(&self) -> u32 {
24257         self.sessioninfontf.current_ranging_interval
24258     }
get_dl_tdoa_measurements(&self) -> &Vec<u8>24259     pub fn get_dl_tdoa_measurements(&self) -> &Vec<u8> {
24260         &self.extendedmacdltdoasessioninfontf.dl_tdoa_measurements
24261     }
get_group_id(&self) -> GroupId24262     pub fn get_group_id(&self) -> GroupId {
24263         self.ucicontrolpacket.group_id
24264     }
get_mac_address_indicator(&self) -> MacAddressIndicator24265     pub fn get_mac_address_indicator(&self) -> MacAddressIndicator {
24266         self.sessioninfontf.mac_address_indicator
24267     }
get_message_type(&self) -> MessageType24268     pub fn get_message_type(&self) -> MessageType {
24269         self.ucicontrolpacket.message_type
24270     }
get_no_of_ranging_measurements(&self) -> u824271     pub fn get_no_of_ranging_measurements(&self) -> u8 {
24272         self.extendedmacdltdoasessioninfontf.no_of_ranging_measurements
24273     }
get_opcode(&self) -> u824274     pub fn get_opcode(&self) -> u8 {
24275         self.ucicontrolpacket.opcode
24276     }
get_ranging_measurement_type(&self) -> RangingMeasurementType24277     pub fn get_ranging_measurement_type(&self) -> RangingMeasurementType {
24278         self.sessioninfontf.ranging_measurement_type
24279     }
get_rcr_indicator(&self) -> u824280     pub fn get_rcr_indicator(&self) -> u8 {
24281         self.sessioninfontf.rcr_indicator
24282     }
get_sequence_number(&self) -> u3224283     pub fn get_sequence_number(&self) -> u32 {
24284         self.sessioninfontf.sequence_number
24285     }
get_session_token(&self) -> u3224286     pub fn get_session_token(&self) -> u32 {
24287         self.sessioninfontf.session_token
24288     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>24289     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
24290         self.extendedmacdltdoasessioninfontf.write_to(buffer)
24291     }
get_size(&self) -> usize24292     pub fn get_size(&self) -> usize {
24293         self.ucicontrolpacket.get_size()
24294     }
24295 }
24296 impl ExtendedMacDlTDoASessionInfoNtfBuilder {
build(self) -> ExtendedMacDlTDoASessionInfoNtf24297     pub fn build(self) -> ExtendedMacDlTDoASessionInfoNtf {
24298         let extendedmacdltdoasessioninfontf = ExtendedMacDlTDoASessionInfoNtfData {
24299             dl_tdoa_measurements: self.dl_tdoa_measurements,
24300             no_of_ranging_measurements: self.no_of_ranging_measurements,
24301         };
24302         let sessioninfontf = SessionInfoNtfData {
24303             current_ranging_interval: self.current_ranging_interval,
24304             mac_address_indicator: MacAddressIndicator::ExtendedAddress,
24305             ranging_measurement_type: RangingMeasurementType::DlTdoa,
24306             rcr_indicator: self.rcr_indicator,
24307             sequence_number: self.sequence_number,
24308             session_token: self.session_token,
24309             child: SessionInfoNtfDataChild::ExtendedMacDlTDoASessionInfoNtf(
24310                 extendedmacdltdoasessioninfontf,
24311             ),
24312         };
24313         let sessioncontrolnotification = SessionControlNotificationData {
24314             child: SessionControlNotificationDataChild::SessionInfoNtf(sessioninfontf),
24315         };
24316         let ucinotification = UciNotificationData {
24317             child: UciNotificationDataChild::SessionControlNotification(
24318                 sessioncontrolnotification,
24319             ),
24320         };
24321         let ucicontrolpacket = UciControlPacketData {
24322             group_id: GroupId::SessionControl,
24323             message_type: MessageType::Notification,
24324             opcode: 0,
24325             child: UciControlPacketDataChild::UciNotification(ucinotification),
24326         };
24327         ExtendedMacDlTDoASessionInfoNtf::new(ucicontrolpacket).unwrap()
24328     }
24329 }
24330 impl From<ExtendedMacDlTDoASessionInfoNtfBuilder> for UciControlPacket {
from(builder: ExtendedMacDlTDoASessionInfoNtfBuilder) -> UciControlPacket24331     fn from(builder: ExtendedMacDlTDoASessionInfoNtfBuilder) -> UciControlPacket {
24332         builder.build().into()
24333     }
24334 }
24335 impl From<ExtendedMacDlTDoASessionInfoNtfBuilder> for UciNotification {
from(builder: ExtendedMacDlTDoASessionInfoNtfBuilder) -> UciNotification24336     fn from(builder: ExtendedMacDlTDoASessionInfoNtfBuilder) -> UciNotification {
24337         builder.build().into()
24338     }
24339 }
24340 impl From<ExtendedMacDlTDoASessionInfoNtfBuilder> for SessionControlNotification {
from( builder: ExtendedMacDlTDoASessionInfoNtfBuilder, ) -> SessionControlNotification24341     fn from(
24342         builder: ExtendedMacDlTDoASessionInfoNtfBuilder,
24343     ) -> SessionControlNotification {
24344         builder.build().into()
24345     }
24346 }
24347 impl From<ExtendedMacDlTDoASessionInfoNtfBuilder> for SessionInfoNtf {
from(builder: ExtendedMacDlTDoASessionInfoNtfBuilder) -> SessionInfoNtf24348     fn from(builder: ExtendedMacDlTDoASessionInfoNtfBuilder) -> SessionInfoNtf {
24349         builder.build().into()
24350     }
24351 }
24352 impl From<ExtendedMacDlTDoASessionInfoNtfBuilder> for ExtendedMacDlTDoASessionInfoNtf {
from( builder: ExtendedMacDlTDoASessionInfoNtfBuilder, ) -> ExtendedMacDlTDoASessionInfoNtf24353     fn from(
24354         builder: ExtendedMacDlTDoASessionInfoNtfBuilder,
24355     ) -> ExtendedMacDlTDoASessionInfoNtf {
24356         builder.build().into()
24357     }
24358 }
24359 #[derive(Debug, Clone, PartialEq, Eq)]
24360 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24361 pub struct ShortMacOwrAoaSessionInfoNtfData {
24362     owr_aoa_ranging_measurements: Vec<ShortAddressOwrAoaRangingMeasurement>,
24363     vendor_data: Vec<u8>,
24364 }
24365 #[derive(Debug, Clone, PartialEq, Eq)]
24366 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24367 pub struct ShortMacOwrAoaSessionInfoNtf {
24368     #[cfg_attr(feature = "serde", serde(flatten))]
24369     ucicontrolpacket: UciControlPacketData,
24370     #[cfg_attr(feature = "serde", serde(flatten))]
24371     ucinotification: UciNotificationData,
24372     #[cfg_attr(feature = "serde", serde(flatten))]
24373     sessioncontrolnotification: SessionControlNotificationData,
24374     #[cfg_attr(feature = "serde", serde(flatten))]
24375     sessioninfontf: SessionInfoNtfData,
24376     #[cfg_attr(feature = "serde", serde(flatten))]
24377     shortmacowraoasessioninfontf: ShortMacOwrAoaSessionInfoNtfData,
24378 }
24379 #[derive(Debug)]
24380 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24381 pub struct ShortMacOwrAoaSessionInfoNtfBuilder {
24382     pub current_ranging_interval: u32,
24383     pub owr_aoa_ranging_measurements: Vec<ShortAddressOwrAoaRangingMeasurement>,
24384     pub rcr_indicator: u8,
24385     pub sequence_number: u32,
24386     pub session_token: u32,
24387     pub vendor_data: Vec<u8>,
24388 }
24389 impl ShortMacOwrAoaSessionInfoNtfData {
conforms(bytes: &[u8]) -> bool24390     fn conforms(bytes: &[u8]) -> bool {
24391         bytes.len() >= 1
24392     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>24393     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
24394         let mut cell = Cell::new(bytes);
24395         let packet = Self::parse_inner(&mut cell)?;
24396         Ok(packet)
24397     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>24398     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
24399         if bytes.get().remaining() < 1 {
24400             return Err(DecodeError::InvalidLengthError {
24401                 obj: "ShortMacOwrAoaSessionInfoNtf",
24402                 wanted: 1,
24403                 got: bytes.get().remaining(),
24404             });
24405         }
24406         let owr_aoa_ranging_measurements_count = bytes.get_mut().get_u8() as usize;
24407         if bytes.get().remaining() < owr_aoa_ranging_measurements_count * 13usize {
24408             return Err(DecodeError::InvalidLengthError {
24409                 obj: "ShortMacOwrAoaSessionInfoNtf",
24410                 wanted: owr_aoa_ranging_measurements_count * 13usize,
24411                 got: bytes.get().remaining(),
24412             });
24413         }
24414         let owr_aoa_ranging_measurements = (0..owr_aoa_ranging_measurements_count)
24415             .map(|_| ShortAddressOwrAoaRangingMeasurement::parse_inner(bytes))
24416             .collect::<Result<Vec<_>, DecodeError>>()?;
24417         let mut vendor_data = Vec::with_capacity(bytes.get().remaining());
24418         for _ in 0..bytes.get().remaining() {
24419             vendor_data.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
24420         }
24421         Ok(Self {
24422             owr_aoa_ranging_measurements,
24423             vendor_data,
24424         })
24425     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>24426     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
24427         buffer.put_u8(self.owr_aoa_ranging_measurements.len() as u8);
24428         for elem in &self.owr_aoa_ranging_measurements {
24429             elem.write_to(buffer)?;
24430         }
24431         for elem in &self.vendor_data {
24432             buffer.put_u8(*elem);
24433         }
24434         Ok(())
24435     }
get_total_size(&self) -> usize24436     fn get_total_size(&self) -> usize {
24437         self.get_size()
24438     }
get_size(&self) -> usize24439     fn get_size(&self) -> usize {
24440         1
24441             + self
24442                 .owr_aoa_ranging_measurements
24443                 .iter()
24444                 .map(|elem| elem.get_size())
24445                 .sum::<usize>() + self.vendor_data.len()
24446     }
24447 }
24448 impl Packet for ShortMacOwrAoaSessionInfoNtf {
encoded_len(&self) -> usize24449     fn encoded_len(&self) -> usize {
24450         self.get_size()
24451     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>24452     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
24453         self.ucicontrolpacket.write_to(buf)
24454     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>24455     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
24456         unimplemented!("Rust legacy does not implement full packet trait")
24457     }
24458 }
24459 impl TryFrom<ShortMacOwrAoaSessionInfoNtf> for Bytes {
24460     type Error = EncodeError;
try_from(packet: ShortMacOwrAoaSessionInfoNtf) -> Result<Self, Self::Error>24461     fn try_from(packet: ShortMacOwrAoaSessionInfoNtf) -> Result<Self, Self::Error> {
24462         packet.encode_to_bytes()
24463     }
24464 }
24465 impl TryFrom<ShortMacOwrAoaSessionInfoNtf> for Vec<u8> {
24466     type Error = EncodeError;
try_from(packet: ShortMacOwrAoaSessionInfoNtf) -> Result<Self, Self::Error>24467     fn try_from(packet: ShortMacOwrAoaSessionInfoNtf) -> Result<Self, Self::Error> {
24468         packet.encode_to_vec()
24469     }
24470 }
24471 impl From<ShortMacOwrAoaSessionInfoNtf> for UciControlPacket {
from(packet: ShortMacOwrAoaSessionInfoNtf) -> UciControlPacket24472     fn from(packet: ShortMacOwrAoaSessionInfoNtf) -> UciControlPacket {
24473         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
24474     }
24475 }
24476 impl From<ShortMacOwrAoaSessionInfoNtf> for UciNotification {
from(packet: ShortMacOwrAoaSessionInfoNtf) -> UciNotification24477     fn from(packet: ShortMacOwrAoaSessionInfoNtf) -> UciNotification {
24478         UciNotification::new(packet.ucicontrolpacket).unwrap()
24479     }
24480 }
24481 impl From<ShortMacOwrAoaSessionInfoNtf> for SessionControlNotification {
from(packet: ShortMacOwrAoaSessionInfoNtf) -> SessionControlNotification24482     fn from(packet: ShortMacOwrAoaSessionInfoNtf) -> SessionControlNotification {
24483         SessionControlNotification::new(packet.ucicontrolpacket).unwrap()
24484     }
24485 }
24486 impl From<ShortMacOwrAoaSessionInfoNtf> for SessionInfoNtf {
from(packet: ShortMacOwrAoaSessionInfoNtf) -> SessionInfoNtf24487     fn from(packet: ShortMacOwrAoaSessionInfoNtf) -> SessionInfoNtf {
24488         SessionInfoNtf::new(packet.ucicontrolpacket).unwrap()
24489     }
24490 }
24491 impl TryFrom<UciControlPacket> for ShortMacOwrAoaSessionInfoNtf {
24492     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<ShortMacOwrAoaSessionInfoNtf, Self::Error>24493     fn try_from(
24494         packet: UciControlPacket,
24495     ) -> Result<ShortMacOwrAoaSessionInfoNtf, Self::Error> {
24496         ShortMacOwrAoaSessionInfoNtf::new(packet.ucicontrolpacket)
24497     }
24498 }
24499 impl ShortMacOwrAoaSessionInfoNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>24500     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
24501         let mut cell = Cell::new(bytes);
24502         let packet = Self::parse_inner(&mut cell)?;
24503         Ok(packet)
24504     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>24505     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
24506         let data = UciControlPacketData::parse_inner(&mut bytes)?;
24507         Self::new(data)
24508     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>24509     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
24510         let ucinotification = match &ucicontrolpacket.child {
24511             UciControlPacketDataChild::UciNotification(value) => value.clone(),
24512             _ => {
24513                 return Err(DecodeError::InvalidChildError {
24514                     expected: stringify!(UciControlPacketDataChild::UciNotification),
24515                     actual: format!("{:?}", & ucicontrolpacket.child),
24516                 });
24517             }
24518         };
24519         let sessioncontrolnotification = match &ucinotification.child {
24520             UciNotificationDataChild::SessionControlNotification(value) => value.clone(),
24521             _ => {
24522                 return Err(DecodeError::InvalidChildError {
24523                     expected: stringify!(
24524                         UciNotificationDataChild::SessionControlNotification
24525                     ),
24526                     actual: format!("{:?}", & ucinotification.child),
24527                 });
24528             }
24529         };
24530         let sessioninfontf = match &sessioncontrolnotification.child {
24531             SessionControlNotificationDataChild::SessionInfoNtf(value) => value.clone(),
24532             _ => {
24533                 return Err(DecodeError::InvalidChildError {
24534                     expected: stringify!(
24535                         SessionControlNotificationDataChild::SessionInfoNtf
24536                     ),
24537                     actual: format!("{:?}", & sessioncontrolnotification.child),
24538                 });
24539             }
24540         };
24541         let shortmacowraoasessioninfontf = match &sessioninfontf.child {
24542             SessionInfoNtfDataChild::ShortMacOwrAoaSessionInfoNtf(value) => value.clone(),
24543             _ => {
24544                 return Err(DecodeError::InvalidChildError {
24545                     expected: stringify!(
24546                         SessionInfoNtfDataChild::ShortMacOwrAoaSessionInfoNtf
24547                     ),
24548                     actual: format!("{:?}", & sessioninfontf.child),
24549                 });
24550             }
24551         };
24552         Ok(Self {
24553             ucicontrolpacket,
24554             ucinotification,
24555             sessioncontrolnotification,
24556             sessioninfontf,
24557             shortmacowraoasessioninfontf,
24558         })
24559     }
get_current_ranging_interval(&self) -> u3224560     pub fn get_current_ranging_interval(&self) -> u32 {
24561         self.sessioninfontf.current_ranging_interval
24562     }
get_group_id(&self) -> GroupId24563     pub fn get_group_id(&self) -> GroupId {
24564         self.ucicontrolpacket.group_id
24565     }
get_mac_address_indicator(&self) -> MacAddressIndicator24566     pub fn get_mac_address_indicator(&self) -> MacAddressIndicator {
24567         self.sessioninfontf.mac_address_indicator
24568     }
get_message_type(&self) -> MessageType24569     pub fn get_message_type(&self) -> MessageType {
24570         self.ucicontrolpacket.message_type
24571     }
get_opcode(&self) -> u824572     pub fn get_opcode(&self) -> u8 {
24573         self.ucicontrolpacket.opcode
24574     }
get_owr_aoa_ranging_measurements( &self, ) -> &Vec<ShortAddressOwrAoaRangingMeasurement>24575     pub fn get_owr_aoa_ranging_measurements(
24576         &self,
24577     ) -> &Vec<ShortAddressOwrAoaRangingMeasurement> {
24578         &self.shortmacowraoasessioninfontf.owr_aoa_ranging_measurements
24579     }
get_ranging_measurement_type(&self) -> RangingMeasurementType24580     pub fn get_ranging_measurement_type(&self) -> RangingMeasurementType {
24581         self.sessioninfontf.ranging_measurement_type
24582     }
get_rcr_indicator(&self) -> u824583     pub fn get_rcr_indicator(&self) -> u8 {
24584         self.sessioninfontf.rcr_indicator
24585     }
get_sequence_number(&self) -> u3224586     pub fn get_sequence_number(&self) -> u32 {
24587         self.sessioninfontf.sequence_number
24588     }
get_session_token(&self) -> u3224589     pub fn get_session_token(&self) -> u32 {
24590         self.sessioninfontf.session_token
24591     }
get_vendor_data(&self) -> &Vec<u8>24592     pub fn get_vendor_data(&self) -> &Vec<u8> {
24593         &self.shortmacowraoasessioninfontf.vendor_data
24594     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>24595     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
24596         self.shortmacowraoasessioninfontf.write_to(buffer)
24597     }
get_size(&self) -> usize24598     pub fn get_size(&self) -> usize {
24599         self.ucicontrolpacket.get_size()
24600     }
24601 }
24602 impl ShortMacOwrAoaSessionInfoNtfBuilder {
build(self) -> ShortMacOwrAoaSessionInfoNtf24603     pub fn build(self) -> ShortMacOwrAoaSessionInfoNtf {
24604         let shortmacowraoasessioninfontf = ShortMacOwrAoaSessionInfoNtfData {
24605             owr_aoa_ranging_measurements: self.owr_aoa_ranging_measurements,
24606             vendor_data: self.vendor_data,
24607         };
24608         let sessioninfontf = SessionInfoNtfData {
24609             current_ranging_interval: self.current_ranging_interval,
24610             mac_address_indicator: MacAddressIndicator::ShortAddress,
24611             ranging_measurement_type: RangingMeasurementType::OwrAoa,
24612             rcr_indicator: self.rcr_indicator,
24613             sequence_number: self.sequence_number,
24614             session_token: self.session_token,
24615             child: SessionInfoNtfDataChild::ShortMacOwrAoaSessionInfoNtf(
24616                 shortmacowraoasessioninfontf,
24617             ),
24618         };
24619         let sessioncontrolnotification = SessionControlNotificationData {
24620             child: SessionControlNotificationDataChild::SessionInfoNtf(sessioninfontf),
24621         };
24622         let ucinotification = UciNotificationData {
24623             child: UciNotificationDataChild::SessionControlNotification(
24624                 sessioncontrolnotification,
24625             ),
24626         };
24627         let ucicontrolpacket = UciControlPacketData {
24628             group_id: GroupId::SessionControl,
24629             message_type: MessageType::Notification,
24630             opcode: 0,
24631             child: UciControlPacketDataChild::UciNotification(ucinotification),
24632         };
24633         ShortMacOwrAoaSessionInfoNtf::new(ucicontrolpacket).unwrap()
24634     }
24635 }
24636 impl From<ShortMacOwrAoaSessionInfoNtfBuilder> for UciControlPacket {
from(builder: ShortMacOwrAoaSessionInfoNtfBuilder) -> UciControlPacket24637     fn from(builder: ShortMacOwrAoaSessionInfoNtfBuilder) -> UciControlPacket {
24638         builder.build().into()
24639     }
24640 }
24641 impl From<ShortMacOwrAoaSessionInfoNtfBuilder> for UciNotification {
from(builder: ShortMacOwrAoaSessionInfoNtfBuilder) -> UciNotification24642     fn from(builder: ShortMacOwrAoaSessionInfoNtfBuilder) -> UciNotification {
24643         builder.build().into()
24644     }
24645 }
24646 impl From<ShortMacOwrAoaSessionInfoNtfBuilder> for SessionControlNotification {
from(builder: ShortMacOwrAoaSessionInfoNtfBuilder) -> SessionControlNotification24647     fn from(builder: ShortMacOwrAoaSessionInfoNtfBuilder) -> SessionControlNotification {
24648         builder.build().into()
24649     }
24650 }
24651 impl From<ShortMacOwrAoaSessionInfoNtfBuilder> for SessionInfoNtf {
from(builder: ShortMacOwrAoaSessionInfoNtfBuilder) -> SessionInfoNtf24652     fn from(builder: ShortMacOwrAoaSessionInfoNtfBuilder) -> SessionInfoNtf {
24653         builder.build().into()
24654     }
24655 }
24656 impl From<ShortMacOwrAoaSessionInfoNtfBuilder> for ShortMacOwrAoaSessionInfoNtf {
from( builder: ShortMacOwrAoaSessionInfoNtfBuilder, ) -> ShortMacOwrAoaSessionInfoNtf24657     fn from(
24658         builder: ShortMacOwrAoaSessionInfoNtfBuilder,
24659     ) -> ShortMacOwrAoaSessionInfoNtf {
24660         builder.build().into()
24661     }
24662 }
24663 #[derive(Debug, Clone, PartialEq, Eq)]
24664 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24665 pub struct ExtendedMacOwrAoaSessionInfoNtfData {
24666     owr_aoa_ranging_measurements: Vec<ExtendedAddressOwrAoaRangingMeasurement>,
24667     vendor_data: Vec<u8>,
24668 }
24669 #[derive(Debug, Clone, PartialEq, Eq)]
24670 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24671 pub struct ExtendedMacOwrAoaSessionInfoNtf {
24672     #[cfg_attr(feature = "serde", serde(flatten))]
24673     ucicontrolpacket: UciControlPacketData,
24674     #[cfg_attr(feature = "serde", serde(flatten))]
24675     ucinotification: UciNotificationData,
24676     #[cfg_attr(feature = "serde", serde(flatten))]
24677     sessioncontrolnotification: SessionControlNotificationData,
24678     #[cfg_attr(feature = "serde", serde(flatten))]
24679     sessioninfontf: SessionInfoNtfData,
24680     #[cfg_attr(feature = "serde", serde(flatten))]
24681     extendedmacowraoasessioninfontf: ExtendedMacOwrAoaSessionInfoNtfData,
24682 }
24683 #[derive(Debug)]
24684 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24685 pub struct ExtendedMacOwrAoaSessionInfoNtfBuilder {
24686     pub current_ranging_interval: u32,
24687     pub owr_aoa_ranging_measurements: Vec<ExtendedAddressOwrAoaRangingMeasurement>,
24688     pub rcr_indicator: u8,
24689     pub sequence_number: u32,
24690     pub session_token: u32,
24691     pub vendor_data: Vec<u8>,
24692 }
24693 impl ExtendedMacOwrAoaSessionInfoNtfData {
conforms(bytes: &[u8]) -> bool24694     fn conforms(bytes: &[u8]) -> bool {
24695         bytes.len() >= 1
24696     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>24697     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
24698         let mut cell = Cell::new(bytes);
24699         let packet = Self::parse_inner(&mut cell)?;
24700         Ok(packet)
24701     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>24702     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
24703         if bytes.get().remaining() < 1 {
24704             return Err(DecodeError::InvalidLengthError {
24705                 obj: "ExtendedMacOwrAoaSessionInfoNtf",
24706                 wanted: 1,
24707                 got: bytes.get().remaining(),
24708             });
24709         }
24710         let owr_aoa_ranging_measurements_count = bytes.get_mut().get_u8() as usize;
24711         if bytes.get().remaining() < owr_aoa_ranging_measurements_count * 19usize {
24712             return Err(DecodeError::InvalidLengthError {
24713                 obj: "ExtendedMacOwrAoaSessionInfoNtf",
24714                 wanted: owr_aoa_ranging_measurements_count * 19usize,
24715                 got: bytes.get().remaining(),
24716             });
24717         }
24718         let owr_aoa_ranging_measurements = (0..owr_aoa_ranging_measurements_count)
24719             .map(|_| ExtendedAddressOwrAoaRangingMeasurement::parse_inner(bytes))
24720             .collect::<Result<Vec<_>, DecodeError>>()?;
24721         let mut vendor_data = Vec::with_capacity(bytes.get().remaining());
24722         for _ in 0..bytes.get().remaining() {
24723             vendor_data.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
24724         }
24725         Ok(Self {
24726             owr_aoa_ranging_measurements,
24727             vendor_data,
24728         })
24729     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>24730     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
24731         buffer.put_u8(self.owr_aoa_ranging_measurements.len() as u8);
24732         for elem in &self.owr_aoa_ranging_measurements {
24733             elem.write_to(buffer)?;
24734         }
24735         for elem in &self.vendor_data {
24736             buffer.put_u8(*elem);
24737         }
24738         Ok(())
24739     }
get_total_size(&self) -> usize24740     fn get_total_size(&self) -> usize {
24741         self.get_size()
24742     }
get_size(&self) -> usize24743     fn get_size(&self) -> usize {
24744         1
24745             + self
24746                 .owr_aoa_ranging_measurements
24747                 .iter()
24748                 .map(|elem| elem.get_size())
24749                 .sum::<usize>() + self.vendor_data.len()
24750     }
24751 }
24752 impl Packet for ExtendedMacOwrAoaSessionInfoNtf {
encoded_len(&self) -> usize24753     fn encoded_len(&self) -> usize {
24754         self.get_size()
24755     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>24756     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
24757         self.ucicontrolpacket.write_to(buf)
24758     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>24759     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
24760         unimplemented!("Rust legacy does not implement full packet trait")
24761     }
24762 }
24763 impl TryFrom<ExtendedMacOwrAoaSessionInfoNtf> for Bytes {
24764     type Error = EncodeError;
try_from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> Result<Self, Self::Error>24765     fn try_from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> Result<Self, Self::Error> {
24766         packet.encode_to_bytes()
24767     }
24768 }
24769 impl TryFrom<ExtendedMacOwrAoaSessionInfoNtf> for Vec<u8> {
24770     type Error = EncodeError;
try_from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> Result<Self, Self::Error>24771     fn try_from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> Result<Self, Self::Error> {
24772         packet.encode_to_vec()
24773     }
24774 }
24775 impl From<ExtendedMacOwrAoaSessionInfoNtf> for UciControlPacket {
from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> UciControlPacket24776     fn from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> UciControlPacket {
24777         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
24778     }
24779 }
24780 impl From<ExtendedMacOwrAoaSessionInfoNtf> for UciNotification {
from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> UciNotification24781     fn from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> UciNotification {
24782         UciNotification::new(packet.ucicontrolpacket).unwrap()
24783     }
24784 }
24785 impl From<ExtendedMacOwrAoaSessionInfoNtf> for SessionControlNotification {
from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> SessionControlNotification24786     fn from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> SessionControlNotification {
24787         SessionControlNotification::new(packet.ucicontrolpacket).unwrap()
24788     }
24789 }
24790 impl From<ExtendedMacOwrAoaSessionInfoNtf> for SessionInfoNtf {
from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> SessionInfoNtf24791     fn from(packet: ExtendedMacOwrAoaSessionInfoNtf) -> SessionInfoNtf {
24792         SessionInfoNtf::new(packet.ucicontrolpacket).unwrap()
24793     }
24794 }
24795 impl TryFrom<UciControlPacket> for ExtendedMacOwrAoaSessionInfoNtf {
24796     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<ExtendedMacOwrAoaSessionInfoNtf, Self::Error>24797     fn try_from(
24798         packet: UciControlPacket,
24799     ) -> Result<ExtendedMacOwrAoaSessionInfoNtf, Self::Error> {
24800         ExtendedMacOwrAoaSessionInfoNtf::new(packet.ucicontrolpacket)
24801     }
24802 }
24803 impl ExtendedMacOwrAoaSessionInfoNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>24804     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
24805         let mut cell = Cell::new(bytes);
24806         let packet = Self::parse_inner(&mut cell)?;
24807         Ok(packet)
24808     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>24809     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
24810         let data = UciControlPacketData::parse_inner(&mut bytes)?;
24811         Self::new(data)
24812     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>24813     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
24814         let ucinotification = match &ucicontrolpacket.child {
24815             UciControlPacketDataChild::UciNotification(value) => value.clone(),
24816             _ => {
24817                 return Err(DecodeError::InvalidChildError {
24818                     expected: stringify!(UciControlPacketDataChild::UciNotification),
24819                     actual: format!("{:?}", & ucicontrolpacket.child),
24820                 });
24821             }
24822         };
24823         let sessioncontrolnotification = match &ucinotification.child {
24824             UciNotificationDataChild::SessionControlNotification(value) => value.clone(),
24825             _ => {
24826                 return Err(DecodeError::InvalidChildError {
24827                     expected: stringify!(
24828                         UciNotificationDataChild::SessionControlNotification
24829                     ),
24830                     actual: format!("{:?}", & ucinotification.child),
24831                 });
24832             }
24833         };
24834         let sessioninfontf = match &sessioncontrolnotification.child {
24835             SessionControlNotificationDataChild::SessionInfoNtf(value) => value.clone(),
24836             _ => {
24837                 return Err(DecodeError::InvalidChildError {
24838                     expected: stringify!(
24839                         SessionControlNotificationDataChild::SessionInfoNtf
24840                     ),
24841                     actual: format!("{:?}", & sessioncontrolnotification.child),
24842                 });
24843             }
24844         };
24845         let extendedmacowraoasessioninfontf = match &sessioninfontf.child {
24846             SessionInfoNtfDataChild::ExtendedMacOwrAoaSessionInfoNtf(value) => {
24847                 value.clone()
24848             }
24849             _ => {
24850                 return Err(DecodeError::InvalidChildError {
24851                     expected: stringify!(
24852                         SessionInfoNtfDataChild::ExtendedMacOwrAoaSessionInfoNtf
24853                     ),
24854                     actual: format!("{:?}", & sessioninfontf.child),
24855                 });
24856             }
24857         };
24858         Ok(Self {
24859             ucicontrolpacket,
24860             ucinotification,
24861             sessioncontrolnotification,
24862             sessioninfontf,
24863             extendedmacowraoasessioninfontf,
24864         })
24865     }
get_current_ranging_interval(&self) -> u3224866     pub fn get_current_ranging_interval(&self) -> u32 {
24867         self.sessioninfontf.current_ranging_interval
24868     }
get_group_id(&self) -> GroupId24869     pub fn get_group_id(&self) -> GroupId {
24870         self.ucicontrolpacket.group_id
24871     }
get_mac_address_indicator(&self) -> MacAddressIndicator24872     pub fn get_mac_address_indicator(&self) -> MacAddressIndicator {
24873         self.sessioninfontf.mac_address_indicator
24874     }
get_message_type(&self) -> MessageType24875     pub fn get_message_type(&self) -> MessageType {
24876         self.ucicontrolpacket.message_type
24877     }
get_opcode(&self) -> u824878     pub fn get_opcode(&self) -> u8 {
24879         self.ucicontrolpacket.opcode
24880     }
get_owr_aoa_ranging_measurements( &self, ) -> &Vec<ExtendedAddressOwrAoaRangingMeasurement>24881     pub fn get_owr_aoa_ranging_measurements(
24882         &self,
24883     ) -> &Vec<ExtendedAddressOwrAoaRangingMeasurement> {
24884         &self.extendedmacowraoasessioninfontf.owr_aoa_ranging_measurements
24885     }
get_ranging_measurement_type(&self) -> RangingMeasurementType24886     pub fn get_ranging_measurement_type(&self) -> RangingMeasurementType {
24887         self.sessioninfontf.ranging_measurement_type
24888     }
get_rcr_indicator(&self) -> u824889     pub fn get_rcr_indicator(&self) -> u8 {
24890         self.sessioninfontf.rcr_indicator
24891     }
get_sequence_number(&self) -> u3224892     pub fn get_sequence_number(&self) -> u32 {
24893         self.sessioninfontf.sequence_number
24894     }
get_session_token(&self) -> u3224895     pub fn get_session_token(&self) -> u32 {
24896         self.sessioninfontf.session_token
24897     }
get_vendor_data(&self) -> &Vec<u8>24898     pub fn get_vendor_data(&self) -> &Vec<u8> {
24899         &self.extendedmacowraoasessioninfontf.vendor_data
24900     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>24901     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
24902         self.extendedmacowraoasessioninfontf.write_to(buffer)
24903     }
get_size(&self) -> usize24904     pub fn get_size(&self) -> usize {
24905         self.ucicontrolpacket.get_size()
24906     }
24907 }
24908 impl ExtendedMacOwrAoaSessionInfoNtfBuilder {
build(self) -> ExtendedMacOwrAoaSessionInfoNtf24909     pub fn build(self) -> ExtendedMacOwrAoaSessionInfoNtf {
24910         let extendedmacowraoasessioninfontf = ExtendedMacOwrAoaSessionInfoNtfData {
24911             owr_aoa_ranging_measurements: self.owr_aoa_ranging_measurements,
24912             vendor_data: self.vendor_data,
24913         };
24914         let sessioninfontf = SessionInfoNtfData {
24915             current_ranging_interval: self.current_ranging_interval,
24916             mac_address_indicator: MacAddressIndicator::ExtendedAddress,
24917             ranging_measurement_type: RangingMeasurementType::OwrAoa,
24918             rcr_indicator: self.rcr_indicator,
24919             sequence_number: self.sequence_number,
24920             session_token: self.session_token,
24921             child: SessionInfoNtfDataChild::ExtendedMacOwrAoaSessionInfoNtf(
24922                 extendedmacowraoasessioninfontf,
24923             ),
24924         };
24925         let sessioncontrolnotification = SessionControlNotificationData {
24926             child: SessionControlNotificationDataChild::SessionInfoNtf(sessioninfontf),
24927         };
24928         let ucinotification = UciNotificationData {
24929             child: UciNotificationDataChild::SessionControlNotification(
24930                 sessioncontrolnotification,
24931             ),
24932         };
24933         let ucicontrolpacket = UciControlPacketData {
24934             group_id: GroupId::SessionControl,
24935             message_type: MessageType::Notification,
24936             opcode: 0,
24937             child: UciControlPacketDataChild::UciNotification(ucinotification),
24938         };
24939         ExtendedMacOwrAoaSessionInfoNtf::new(ucicontrolpacket).unwrap()
24940     }
24941 }
24942 impl From<ExtendedMacOwrAoaSessionInfoNtfBuilder> for UciControlPacket {
from(builder: ExtendedMacOwrAoaSessionInfoNtfBuilder) -> UciControlPacket24943     fn from(builder: ExtendedMacOwrAoaSessionInfoNtfBuilder) -> UciControlPacket {
24944         builder.build().into()
24945     }
24946 }
24947 impl From<ExtendedMacOwrAoaSessionInfoNtfBuilder> for UciNotification {
from(builder: ExtendedMacOwrAoaSessionInfoNtfBuilder) -> UciNotification24948     fn from(builder: ExtendedMacOwrAoaSessionInfoNtfBuilder) -> UciNotification {
24949         builder.build().into()
24950     }
24951 }
24952 impl From<ExtendedMacOwrAoaSessionInfoNtfBuilder> for SessionControlNotification {
from( builder: ExtendedMacOwrAoaSessionInfoNtfBuilder, ) -> SessionControlNotification24953     fn from(
24954         builder: ExtendedMacOwrAoaSessionInfoNtfBuilder,
24955     ) -> SessionControlNotification {
24956         builder.build().into()
24957     }
24958 }
24959 impl From<ExtendedMacOwrAoaSessionInfoNtfBuilder> for SessionInfoNtf {
from(builder: ExtendedMacOwrAoaSessionInfoNtfBuilder) -> SessionInfoNtf24960     fn from(builder: ExtendedMacOwrAoaSessionInfoNtfBuilder) -> SessionInfoNtf {
24961         builder.build().into()
24962     }
24963 }
24964 impl From<ExtendedMacOwrAoaSessionInfoNtfBuilder> for ExtendedMacOwrAoaSessionInfoNtf {
from( builder: ExtendedMacOwrAoaSessionInfoNtfBuilder, ) -> ExtendedMacOwrAoaSessionInfoNtf24965     fn from(
24966         builder: ExtendedMacOwrAoaSessionInfoNtfBuilder,
24967     ) -> ExtendedMacOwrAoaSessionInfoNtf {
24968         builder.build().into()
24969     }
24970 }
24971 #[derive(Debug, Clone, PartialEq, Eq)]
24972 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24973 pub struct SessionStopCmdData {
24974     session_token: u32,
24975 }
24976 #[derive(Debug, Clone, PartialEq, Eq)]
24977 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24978 pub struct SessionStopCmd {
24979     #[cfg_attr(feature = "serde", serde(flatten))]
24980     ucicontrolpacket: UciControlPacketData,
24981     #[cfg_attr(feature = "serde", serde(flatten))]
24982     ucicommand: UciCommandData,
24983     #[cfg_attr(feature = "serde", serde(flatten))]
24984     sessioncontrolcommand: SessionControlCommandData,
24985     #[cfg_attr(feature = "serde", serde(flatten))]
24986     sessionstopcmd: SessionStopCmdData,
24987 }
24988 #[derive(Debug)]
24989 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
24990 pub struct SessionStopCmdBuilder {
24991     pub session_token: u32,
24992 }
24993 impl SessionStopCmdData {
conforms(bytes: &[u8]) -> bool24994     fn conforms(bytes: &[u8]) -> bool {
24995         bytes.len() >= 4
24996     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>24997     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
24998         let mut cell = Cell::new(bytes);
24999         let packet = Self::parse_inner(&mut cell)?;
25000         Ok(packet)
25001     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>25002     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
25003         if bytes.get().remaining() < 4 {
25004             return Err(DecodeError::InvalidLengthError {
25005                 obj: "SessionStopCmd",
25006                 wanted: 4,
25007                 got: bytes.get().remaining(),
25008             });
25009         }
25010         let session_token = bytes.get_mut().get_u32_le();
25011         Ok(Self { session_token })
25012     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>25013     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
25014         buffer.put_u32_le(self.session_token);
25015         Ok(())
25016     }
get_total_size(&self) -> usize25017     fn get_total_size(&self) -> usize {
25018         self.get_size()
25019     }
get_size(&self) -> usize25020     fn get_size(&self) -> usize {
25021         4
25022     }
25023 }
25024 impl Packet for SessionStopCmd {
encoded_len(&self) -> usize25025     fn encoded_len(&self) -> usize {
25026         self.get_size()
25027     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>25028     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
25029         self.ucicontrolpacket.write_to(buf)
25030     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>25031     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
25032         unimplemented!("Rust legacy does not implement full packet trait")
25033     }
25034 }
25035 impl TryFrom<SessionStopCmd> for Bytes {
25036     type Error = EncodeError;
try_from(packet: SessionStopCmd) -> Result<Self, Self::Error>25037     fn try_from(packet: SessionStopCmd) -> Result<Self, Self::Error> {
25038         packet.encode_to_bytes()
25039     }
25040 }
25041 impl TryFrom<SessionStopCmd> for Vec<u8> {
25042     type Error = EncodeError;
try_from(packet: SessionStopCmd) -> Result<Self, Self::Error>25043     fn try_from(packet: SessionStopCmd) -> Result<Self, Self::Error> {
25044         packet.encode_to_vec()
25045     }
25046 }
25047 impl From<SessionStopCmd> for UciControlPacket {
from(packet: SessionStopCmd) -> UciControlPacket25048     fn from(packet: SessionStopCmd) -> UciControlPacket {
25049         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
25050     }
25051 }
25052 impl From<SessionStopCmd> for UciCommand {
from(packet: SessionStopCmd) -> UciCommand25053     fn from(packet: SessionStopCmd) -> UciCommand {
25054         UciCommand::new(packet.ucicontrolpacket).unwrap()
25055     }
25056 }
25057 impl From<SessionStopCmd> for SessionControlCommand {
from(packet: SessionStopCmd) -> SessionControlCommand25058     fn from(packet: SessionStopCmd) -> SessionControlCommand {
25059         SessionControlCommand::new(packet.ucicontrolpacket).unwrap()
25060     }
25061 }
25062 impl TryFrom<UciControlPacket> for SessionStopCmd {
25063     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionStopCmd, Self::Error>25064     fn try_from(packet: UciControlPacket) -> Result<SessionStopCmd, Self::Error> {
25065         SessionStopCmd::new(packet.ucicontrolpacket)
25066     }
25067 }
25068 impl SessionStopCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>25069     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
25070         let mut cell = Cell::new(bytes);
25071         let packet = Self::parse_inner(&mut cell)?;
25072         Ok(packet)
25073     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>25074     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
25075         let data = UciControlPacketData::parse_inner(&mut bytes)?;
25076         Self::new(data)
25077     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>25078     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
25079         let ucicommand = match &ucicontrolpacket.child {
25080             UciControlPacketDataChild::UciCommand(value) => value.clone(),
25081             _ => {
25082                 return Err(DecodeError::InvalidChildError {
25083                     expected: stringify!(UciControlPacketDataChild::UciCommand),
25084                     actual: format!("{:?}", & ucicontrolpacket.child),
25085                 });
25086             }
25087         };
25088         let sessioncontrolcommand = match &ucicommand.child {
25089             UciCommandDataChild::SessionControlCommand(value) => value.clone(),
25090             _ => {
25091                 return Err(DecodeError::InvalidChildError {
25092                     expected: stringify!(UciCommandDataChild::SessionControlCommand),
25093                     actual: format!("{:?}", & ucicommand.child),
25094                 });
25095             }
25096         };
25097         let sessionstopcmd = match &sessioncontrolcommand.child {
25098             SessionControlCommandDataChild::SessionStopCmd(value) => value.clone(),
25099             _ => {
25100                 return Err(DecodeError::InvalidChildError {
25101                     expected: stringify!(SessionControlCommandDataChild::SessionStopCmd),
25102                     actual: format!("{:?}", & sessioncontrolcommand.child),
25103                 });
25104             }
25105         };
25106         Ok(Self {
25107             ucicontrolpacket,
25108             ucicommand,
25109             sessioncontrolcommand,
25110             sessionstopcmd,
25111         })
25112     }
get_group_id(&self) -> GroupId25113     pub fn get_group_id(&self) -> GroupId {
25114         self.ucicontrolpacket.group_id
25115     }
get_message_type(&self) -> MessageType25116     pub fn get_message_type(&self) -> MessageType {
25117         self.ucicontrolpacket.message_type
25118     }
get_opcode(&self) -> u825119     pub fn get_opcode(&self) -> u8 {
25120         self.ucicontrolpacket.opcode
25121     }
get_session_token(&self) -> u3225122     pub fn get_session_token(&self) -> u32 {
25123         self.sessionstopcmd.session_token
25124     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>25125     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
25126         self.sessionstopcmd.write_to(buffer)
25127     }
get_size(&self) -> usize25128     pub fn get_size(&self) -> usize {
25129         self.ucicontrolpacket.get_size()
25130     }
25131 }
25132 impl SessionStopCmdBuilder {
build(self) -> SessionStopCmd25133     pub fn build(self) -> SessionStopCmd {
25134         let sessionstopcmd = SessionStopCmdData {
25135             session_token: self.session_token,
25136         };
25137         let sessioncontrolcommand = SessionControlCommandData {
25138             child: SessionControlCommandDataChild::SessionStopCmd(sessionstopcmd),
25139         };
25140         let ucicommand = UciCommandData {
25141             child: UciCommandDataChild::SessionControlCommand(sessioncontrolcommand),
25142         };
25143         let ucicontrolpacket = UciControlPacketData {
25144             group_id: GroupId::SessionControl,
25145             message_type: MessageType::Command,
25146             opcode: 1,
25147             child: UciControlPacketDataChild::UciCommand(ucicommand),
25148         };
25149         SessionStopCmd::new(ucicontrolpacket).unwrap()
25150     }
25151 }
25152 impl From<SessionStopCmdBuilder> for UciControlPacket {
from(builder: SessionStopCmdBuilder) -> UciControlPacket25153     fn from(builder: SessionStopCmdBuilder) -> UciControlPacket {
25154         builder.build().into()
25155     }
25156 }
25157 impl From<SessionStopCmdBuilder> for UciCommand {
from(builder: SessionStopCmdBuilder) -> UciCommand25158     fn from(builder: SessionStopCmdBuilder) -> UciCommand {
25159         builder.build().into()
25160     }
25161 }
25162 impl From<SessionStopCmdBuilder> for SessionControlCommand {
from(builder: SessionStopCmdBuilder) -> SessionControlCommand25163     fn from(builder: SessionStopCmdBuilder) -> SessionControlCommand {
25164         builder.build().into()
25165     }
25166 }
25167 impl From<SessionStopCmdBuilder> for SessionStopCmd {
from(builder: SessionStopCmdBuilder) -> SessionStopCmd25168     fn from(builder: SessionStopCmdBuilder) -> SessionStopCmd {
25169         builder.build().into()
25170     }
25171 }
25172 #[derive(Debug, Clone, PartialEq, Eq)]
25173 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25174 pub struct SessionStopRspData {
25175     status: StatusCode,
25176 }
25177 #[derive(Debug, Clone, PartialEq, Eq)]
25178 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25179 pub struct SessionStopRsp {
25180     #[cfg_attr(feature = "serde", serde(flatten))]
25181     ucicontrolpacket: UciControlPacketData,
25182     #[cfg_attr(feature = "serde", serde(flatten))]
25183     uciresponse: UciResponseData,
25184     #[cfg_attr(feature = "serde", serde(flatten))]
25185     sessioncontrolresponse: SessionControlResponseData,
25186     #[cfg_attr(feature = "serde", serde(flatten))]
25187     sessionstoprsp: SessionStopRspData,
25188 }
25189 #[derive(Debug)]
25190 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25191 pub struct SessionStopRspBuilder {
25192     pub status: StatusCode,
25193 }
25194 impl SessionStopRspData {
conforms(bytes: &[u8]) -> bool25195     fn conforms(bytes: &[u8]) -> bool {
25196         bytes.len() >= 1
25197     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>25198     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
25199         let mut cell = Cell::new(bytes);
25200         let packet = Self::parse_inner(&mut cell)?;
25201         Ok(packet)
25202     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>25203     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
25204         if bytes.get().remaining() < 1 {
25205             return Err(DecodeError::InvalidLengthError {
25206                 obj: "SessionStopRsp",
25207                 wanted: 1,
25208                 got: bytes.get().remaining(),
25209             });
25210         }
25211         let status = StatusCode::try_from(bytes.get_mut().get_u8())
25212             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
25213                 obj: "SessionStopRsp",
25214                 field: "status",
25215                 value: unknown_val as u64,
25216                 type_: "StatusCode",
25217             })?;
25218         Ok(Self { status })
25219     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>25220     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
25221         buffer.put_u8(u8::from(self.status));
25222         Ok(())
25223     }
get_total_size(&self) -> usize25224     fn get_total_size(&self) -> usize {
25225         self.get_size()
25226     }
get_size(&self) -> usize25227     fn get_size(&self) -> usize {
25228         1
25229     }
25230 }
25231 impl Packet for SessionStopRsp {
encoded_len(&self) -> usize25232     fn encoded_len(&self) -> usize {
25233         self.get_size()
25234     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>25235     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
25236         self.ucicontrolpacket.write_to(buf)
25237     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>25238     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
25239         unimplemented!("Rust legacy does not implement full packet trait")
25240     }
25241 }
25242 impl TryFrom<SessionStopRsp> for Bytes {
25243     type Error = EncodeError;
try_from(packet: SessionStopRsp) -> Result<Self, Self::Error>25244     fn try_from(packet: SessionStopRsp) -> Result<Self, Self::Error> {
25245         packet.encode_to_bytes()
25246     }
25247 }
25248 impl TryFrom<SessionStopRsp> for Vec<u8> {
25249     type Error = EncodeError;
try_from(packet: SessionStopRsp) -> Result<Self, Self::Error>25250     fn try_from(packet: SessionStopRsp) -> Result<Self, Self::Error> {
25251         packet.encode_to_vec()
25252     }
25253 }
25254 impl From<SessionStopRsp> for UciControlPacket {
from(packet: SessionStopRsp) -> UciControlPacket25255     fn from(packet: SessionStopRsp) -> UciControlPacket {
25256         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
25257     }
25258 }
25259 impl From<SessionStopRsp> for UciResponse {
from(packet: SessionStopRsp) -> UciResponse25260     fn from(packet: SessionStopRsp) -> UciResponse {
25261         UciResponse::new(packet.ucicontrolpacket).unwrap()
25262     }
25263 }
25264 impl From<SessionStopRsp> for SessionControlResponse {
from(packet: SessionStopRsp) -> SessionControlResponse25265     fn from(packet: SessionStopRsp) -> SessionControlResponse {
25266         SessionControlResponse::new(packet.ucicontrolpacket).unwrap()
25267     }
25268 }
25269 impl TryFrom<UciControlPacket> for SessionStopRsp {
25270     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<SessionStopRsp, Self::Error>25271     fn try_from(packet: UciControlPacket) -> Result<SessionStopRsp, Self::Error> {
25272         SessionStopRsp::new(packet.ucicontrolpacket)
25273     }
25274 }
25275 impl SessionStopRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>25276     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
25277         let mut cell = Cell::new(bytes);
25278         let packet = Self::parse_inner(&mut cell)?;
25279         Ok(packet)
25280     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>25281     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
25282         let data = UciControlPacketData::parse_inner(&mut bytes)?;
25283         Self::new(data)
25284     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>25285     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
25286         let uciresponse = match &ucicontrolpacket.child {
25287             UciControlPacketDataChild::UciResponse(value) => value.clone(),
25288             _ => {
25289                 return Err(DecodeError::InvalidChildError {
25290                     expected: stringify!(UciControlPacketDataChild::UciResponse),
25291                     actual: format!("{:?}", & ucicontrolpacket.child),
25292                 });
25293             }
25294         };
25295         let sessioncontrolresponse = match &uciresponse.child {
25296             UciResponseDataChild::SessionControlResponse(value) => value.clone(),
25297             _ => {
25298                 return Err(DecodeError::InvalidChildError {
25299                     expected: stringify!(UciResponseDataChild::SessionControlResponse),
25300                     actual: format!("{:?}", & uciresponse.child),
25301                 });
25302             }
25303         };
25304         let sessionstoprsp = match &sessioncontrolresponse.child {
25305             SessionControlResponseDataChild::SessionStopRsp(value) => value.clone(),
25306             _ => {
25307                 return Err(DecodeError::InvalidChildError {
25308                     expected: stringify!(
25309                         SessionControlResponseDataChild::SessionStopRsp
25310                     ),
25311                     actual: format!("{:?}", & sessioncontrolresponse.child),
25312                 });
25313             }
25314         };
25315         Ok(Self {
25316             ucicontrolpacket,
25317             uciresponse,
25318             sessioncontrolresponse,
25319             sessionstoprsp,
25320         })
25321     }
get_group_id(&self) -> GroupId25322     pub fn get_group_id(&self) -> GroupId {
25323         self.ucicontrolpacket.group_id
25324     }
get_message_type(&self) -> MessageType25325     pub fn get_message_type(&self) -> MessageType {
25326         self.ucicontrolpacket.message_type
25327     }
get_opcode(&self) -> u825328     pub fn get_opcode(&self) -> u8 {
25329         self.ucicontrolpacket.opcode
25330     }
get_status(&self) -> StatusCode25331     pub fn get_status(&self) -> StatusCode {
25332         self.sessionstoprsp.status
25333     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>25334     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
25335         self.sessionstoprsp.write_to(buffer)
25336     }
get_size(&self) -> usize25337     pub fn get_size(&self) -> usize {
25338         self.ucicontrolpacket.get_size()
25339     }
25340 }
25341 impl SessionStopRspBuilder {
build(self) -> SessionStopRsp25342     pub fn build(self) -> SessionStopRsp {
25343         let sessionstoprsp = SessionStopRspData {
25344             status: self.status,
25345         };
25346         let sessioncontrolresponse = SessionControlResponseData {
25347             child: SessionControlResponseDataChild::SessionStopRsp(sessionstoprsp),
25348         };
25349         let uciresponse = UciResponseData {
25350             child: UciResponseDataChild::SessionControlResponse(sessioncontrolresponse),
25351         };
25352         let ucicontrolpacket = UciControlPacketData {
25353             group_id: GroupId::SessionControl,
25354             message_type: MessageType::Response,
25355             opcode: 1,
25356             child: UciControlPacketDataChild::UciResponse(uciresponse),
25357         };
25358         SessionStopRsp::new(ucicontrolpacket).unwrap()
25359     }
25360 }
25361 impl From<SessionStopRspBuilder> for UciControlPacket {
from(builder: SessionStopRspBuilder) -> UciControlPacket25362     fn from(builder: SessionStopRspBuilder) -> UciControlPacket {
25363         builder.build().into()
25364     }
25365 }
25366 impl From<SessionStopRspBuilder> for UciResponse {
from(builder: SessionStopRspBuilder) -> UciResponse25367     fn from(builder: SessionStopRspBuilder) -> UciResponse {
25368         builder.build().into()
25369     }
25370 }
25371 impl From<SessionStopRspBuilder> for SessionControlResponse {
from(builder: SessionStopRspBuilder) -> SessionControlResponse25372     fn from(builder: SessionStopRspBuilder) -> SessionControlResponse {
25373         builder.build().into()
25374     }
25375 }
25376 impl From<SessionStopRspBuilder> for SessionStopRsp {
from(builder: SessionStopRspBuilder) -> SessionStopRsp25377     fn from(builder: SessionStopRspBuilder) -> SessionStopRsp {
25378         builder.build().into()
25379     }
25380 }
25381 #[derive(Debug, Clone, PartialEq, Eq)]
25382 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25383 pub struct SessionGetRangingCountCmdData {
25384     session_token: u32,
25385 }
25386 #[derive(Debug, Clone, PartialEq, Eq)]
25387 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25388 pub struct SessionGetRangingCountCmd {
25389     #[cfg_attr(feature = "serde", serde(flatten))]
25390     ucicontrolpacket: UciControlPacketData,
25391     #[cfg_attr(feature = "serde", serde(flatten))]
25392     ucicommand: UciCommandData,
25393     #[cfg_attr(feature = "serde", serde(flatten))]
25394     sessioncontrolcommand: SessionControlCommandData,
25395     #[cfg_attr(feature = "serde", serde(flatten))]
25396     sessiongetrangingcountcmd: SessionGetRangingCountCmdData,
25397 }
25398 #[derive(Debug)]
25399 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25400 pub struct SessionGetRangingCountCmdBuilder {
25401     pub session_token: u32,
25402 }
25403 impl SessionGetRangingCountCmdData {
conforms(bytes: &[u8]) -> bool25404     fn conforms(bytes: &[u8]) -> bool {
25405         bytes.len() >= 4
25406     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>25407     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
25408         let mut cell = Cell::new(bytes);
25409         let packet = Self::parse_inner(&mut cell)?;
25410         Ok(packet)
25411     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>25412     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
25413         if bytes.get().remaining() < 4 {
25414             return Err(DecodeError::InvalidLengthError {
25415                 obj: "SessionGetRangingCountCmd",
25416                 wanted: 4,
25417                 got: bytes.get().remaining(),
25418             });
25419         }
25420         let session_token = bytes.get_mut().get_u32_le();
25421         Ok(Self { session_token })
25422     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>25423     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
25424         buffer.put_u32_le(self.session_token);
25425         Ok(())
25426     }
get_total_size(&self) -> usize25427     fn get_total_size(&self) -> usize {
25428         self.get_size()
25429     }
get_size(&self) -> usize25430     fn get_size(&self) -> usize {
25431         4
25432     }
25433 }
25434 impl Packet for SessionGetRangingCountCmd {
encoded_len(&self) -> usize25435     fn encoded_len(&self) -> usize {
25436         self.get_size()
25437     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>25438     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
25439         self.ucicontrolpacket.write_to(buf)
25440     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>25441     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
25442         unimplemented!("Rust legacy does not implement full packet trait")
25443     }
25444 }
25445 impl TryFrom<SessionGetRangingCountCmd> for Bytes {
25446     type Error = EncodeError;
try_from(packet: SessionGetRangingCountCmd) -> Result<Self, Self::Error>25447     fn try_from(packet: SessionGetRangingCountCmd) -> Result<Self, Self::Error> {
25448         packet.encode_to_bytes()
25449     }
25450 }
25451 impl TryFrom<SessionGetRangingCountCmd> for Vec<u8> {
25452     type Error = EncodeError;
try_from(packet: SessionGetRangingCountCmd) -> Result<Self, Self::Error>25453     fn try_from(packet: SessionGetRangingCountCmd) -> Result<Self, Self::Error> {
25454         packet.encode_to_vec()
25455     }
25456 }
25457 impl From<SessionGetRangingCountCmd> for UciControlPacket {
from(packet: SessionGetRangingCountCmd) -> UciControlPacket25458     fn from(packet: SessionGetRangingCountCmd) -> UciControlPacket {
25459         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
25460     }
25461 }
25462 impl From<SessionGetRangingCountCmd> for UciCommand {
from(packet: SessionGetRangingCountCmd) -> UciCommand25463     fn from(packet: SessionGetRangingCountCmd) -> UciCommand {
25464         UciCommand::new(packet.ucicontrolpacket).unwrap()
25465     }
25466 }
25467 impl From<SessionGetRangingCountCmd> for SessionControlCommand {
from(packet: SessionGetRangingCountCmd) -> SessionControlCommand25468     fn from(packet: SessionGetRangingCountCmd) -> SessionControlCommand {
25469         SessionControlCommand::new(packet.ucicontrolpacket).unwrap()
25470     }
25471 }
25472 impl TryFrom<UciControlPacket> for SessionGetRangingCountCmd {
25473     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionGetRangingCountCmd, Self::Error>25474     fn try_from(
25475         packet: UciControlPacket,
25476     ) -> Result<SessionGetRangingCountCmd, Self::Error> {
25477         SessionGetRangingCountCmd::new(packet.ucicontrolpacket)
25478     }
25479 }
25480 impl SessionGetRangingCountCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>25481     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
25482         let mut cell = Cell::new(bytes);
25483         let packet = Self::parse_inner(&mut cell)?;
25484         Ok(packet)
25485     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>25486     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
25487         let data = UciControlPacketData::parse_inner(&mut bytes)?;
25488         Self::new(data)
25489     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>25490     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
25491         let ucicommand = match &ucicontrolpacket.child {
25492             UciControlPacketDataChild::UciCommand(value) => value.clone(),
25493             _ => {
25494                 return Err(DecodeError::InvalidChildError {
25495                     expected: stringify!(UciControlPacketDataChild::UciCommand),
25496                     actual: format!("{:?}", & ucicontrolpacket.child),
25497                 });
25498             }
25499         };
25500         let sessioncontrolcommand = match &ucicommand.child {
25501             UciCommandDataChild::SessionControlCommand(value) => value.clone(),
25502             _ => {
25503                 return Err(DecodeError::InvalidChildError {
25504                     expected: stringify!(UciCommandDataChild::SessionControlCommand),
25505                     actual: format!("{:?}", & ucicommand.child),
25506                 });
25507             }
25508         };
25509         let sessiongetrangingcountcmd = match &sessioncontrolcommand.child {
25510             SessionControlCommandDataChild::SessionGetRangingCountCmd(value) => {
25511                 value.clone()
25512             }
25513             _ => {
25514                 return Err(DecodeError::InvalidChildError {
25515                     expected: stringify!(
25516                         SessionControlCommandDataChild::SessionGetRangingCountCmd
25517                     ),
25518                     actual: format!("{:?}", & sessioncontrolcommand.child),
25519                 });
25520             }
25521         };
25522         Ok(Self {
25523             ucicontrolpacket,
25524             ucicommand,
25525             sessioncontrolcommand,
25526             sessiongetrangingcountcmd,
25527         })
25528     }
get_group_id(&self) -> GroupId25529     pub fn get_group_id(&self) -> GroupId {
25530         self.ucicontrolpacket.group_id
25531     }
get_message_type(&self) -> MessageType25532     pub fn get_message_type(&self) -> MessageType {
25533         self.ucicontrolpacket.message_type
25534     }
get_opcode(&self) -> u825535     pub fn get_opcode(&self) -> u8 {
25536         self.ucicontrolpacket.opcode
25537     }
get_session_token(&self) -> u3225538     pub fn get_session_token(&self) -> u32 {
25539         self.sessiongetrangingcountcmd.session_token
25540     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>25541     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
25542         self.sessiongetrangingcountcmd.write_to(buffer)
25543     }
get_size(&self) -> usize25544     pub fn get_size(&self) -> usize {
25545         self.ucicontrolpacket.get_size()
25546     }
25547 }
25548 impl SessionGetRangingCountCmdBuilder {
build(self) -> SessionGetRangingCountCmd25549     pub fn build(self) -> SessionGetRangingCountCmd {
25550         let sessiongetrangingcountcmd = SessionGetRangingCountCmdData {
25551             session_token: self.session_token,
25552         };
25553         let sessioncontrolcommand = SessionControlCommandData {
25554             child: SessionControlCommandDataChild::SessionGetRangingCountCmd(
25555                 sessiongetrangingcountcmd,
25556             ),
25557         };
25558         let ucicommand = UciCommandData {
25559             child: UciCommandDataChild::SessionControlCommand(sessioncontrolcommand),
25560         };
25561         let ucicontrolpacket = UciControlPacketData {
25562             group_id: GroupId::SessionControl,
25563             message_type: MessageType::Command,
25564             opcode: 3,
25565             child: UciControlPacketDataChild::UciCommand(ucicommand),
25566         };
25567         SessionGetRangingCountCmd::new(ucicontrolpacket).unwrap()
25568     }
25569 }
25570 impl From<SessionGetRangingCountCmdBuilder> for UciControlPacket {
from(builder: SessionGetRangingCountCmdBuilder) -> UciControlPacket25571     fn from(builder: SessionGetRangingCountCmdBuilder) -> UciControlPacket {
25572         builder.build().into()
25573     }
25574 }
25575 impl From<SessionGetRangingCountCmdBuilder> for UciCommand {
from(builder: SessionGetRangingCountCmdBuilder) -> UciCommand25576     fn from(builder: SessionGetRangingCountCmdBuilder) -> UciCommand {
25577         builder.build().into()
25578     }
25579 }
25580 impl From<SessionGetRangingCountCmdBuilder> for SessionControlCommand {
from(builder: SessionGetRangingCountCmdBuilder) -> SessionControlCommand25581     fn from(builder: SessionGetRangingCountCmdBuilder) -> SessionControlCommand {
25582         builder.build().into()
25583     }
25584 }
25585 impl From<SessionGetRangingCountCmdBuilder> for SessionGetRangingCountCmd {
from(builder: SessionGetRangingCountCmdBuilder) -> SessionGetRangingCountCmd25586     fn from(builder: SessionGetRangingCountCmdBuilder) -> SessionGetRangingCountCmd {
25587         builder.build().into()
25588     }
25589 }
25590 #[derive(Debug, Clone, PartialEq, Eq)]
25591 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25592 pub struct SessionGetRangingCountRspData {
25593     status: StatusCode,
25594     count: u32,
25595 }
25596 #[derive(Debug, Clone, PartialEq, Eq)]
25597 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25598 pub struct SessionGetRangingCountRsp {
25599     #[cfg_attr(feature = "serde", serde(flatten))]
25600     ucicontrolpacket: UciControlPacketData,
25601     #[cfg_attr(feature = "serde", serde(flatten))]
25602     uciresponse: UciResponseData,
25603     #[cfg_attr(feature = "serde", serde(flatten))]
25604     sessioncontrolresponse: SessionControlResponseData,
25605     #[cfg_attr(feature = "serde", serde(flatten))]
25606     sessiongetrangingcountrsp: SessionGetRangingCountRspData,
25607 }
25608 #[derive(Debug)]
25609 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25610 pub struct SessionGetRangingCountRspBuilder {
25611     pub count: u32,
25612     pub status: StatusCode,
25613 }
25614 impl SessionGetRangingCountRspData {
conforms(bytes: &[u8]) -> bool25615     fn conforms(bytes: &[u8]) -> bool {
25616         bytes.len() >= 5
25617     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>25618     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
25619         let mut cell = Cell::new(bytes);
25620         let packet = Self::parse_inner(&mut cell)?;
25621         Ok(packet)
25622     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>25623     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
25624         if bytes.get().remaining() < 1 {
25625             return Err(DecodeError::InvalidLengthError {
25626                 obj: "SessionGetRangingCountRsp",
25627                 wanted: 1,
25628                 got: bytes.get().remaining(),
25629             });
25630         }
25631         let status = StatusCode::try_from(bytes.get_mut().get_u8())
25632             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
25633                 obj: "SessionGetRangingCountRsp",
25634                 field: "status",
25635                 value: unknown_val as u64,
25636                 type_: "StatusCode",
25637             })?;
25638         if bytes.get().remaining() < 4 {
25639             return Err(DecodeError::InvalidLengthError {
25640                 obj: "SessionGetRangingCountRsp",
25641                 wanted: 4,
25642                 got: bytes.get().remaining(),
25643             });
25644         }
25645         let count = bytes.get_mut().get_u32_le();
25646         Ok(Self { status, count })
25647     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>25648     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
25649         buffer.put_u8(u8::from(self.status));
25650         buffer.put_u32_le(self.count);
25651         Ok(())
25652     }
get_total_size(&self) -> usize25653     fn get_total_size(&self) -> usize {
25654         self.get_size()
25655     }
get_size(&self) -> usize25656     fn get_size(&self) -> usize {
25657         5
25658     }
25659 }
25660 impl Packet for SessionGetRangingCountRsp {
encoded_len(&self) -> usize25661     fn encoded_len(&self) -> usize {
25662         self.get_size()
25663     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>25664     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
25665         self.ucicontrolpacket.write_to(buf)
25666     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>25667     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
25668         unimplemented!("Rust legacy does not implement full packet trait")
25669     }
25670 }
25671 impl TryFrom<SessionGetRangingCountRsp> for Bytes {
25672     type Error = EncodeError;
try_from(packet: SessionGetRangingCountRsp) -> Result<Self, Self::Error>25673     fn try_from(packet: SessionGetRangingCountRsp) -> Result<Self, Self::Error> {
25674         packet.encode_to_bytes()
25675     }
25676 }
25677 impl TryFrom<SessionGetRangingCountRsp> for Vec<u8> {
25678     type Error = EncodeError;
try_from(packet: SessionGetRangingCountRsp) -> Result<Self, Self::Error>25679     fn try_from(packet: SessionGetRangingCountRsp) -> Result<Self, Self::Error> {
25680         packet.encode_to_vec()
25681     }
25682 }
25683 impl From<SessionGetRangingCountRsp> for UciControlPacket {
from(packet: SessionGetRangingCountRsp) -> UciControlPacket25684     fn from(packet: SessionGetRangingCountRsp) -> UciControlPacket {
25685         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
25686     }
25687 }
25688 impl From<SessionGetRangingCountRsp> for UciResponse {
from(packet: SessionGetRangingCountRsp) -> UciResponse25689     fn from(packet: SessionGetRangingCountRsp) -> UciResponse {
25690         UciResponse::new(packet.ucicontrolpacket).unwrap()
25691     }
25692 }
25693 impl From<SessionGetRangingCountRsp> for SessionControlResponse {
from(packet: SessionGetRangingCountRsp) -> SessionControlResponse25694     fn from(packet: SessionGetRangingCountRsp) -> SessionControlResponse {
25695         SessionControlResponse::new(packet.ucicontrolpacket).unwrap()
25696     }
25697 }
25698 impl TryFrom<UciControlPacket> for SessionGetRangingCountRsp {
25699     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionGetRangingCountRsp, Self::Error>25700     fn try_from(
25701         packet: UciControlPacket,
25702     ) -> Result<SessionGetRangingCountRsp, Self::Error> {
25703         SessionGetRangingCountRsp::new(packet.ucicontrolpacket)
25704     }
25705 }
25706 impl SessionGetRangingCountRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>25707     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
25708         let mut cell = Cell::new(bytes);
25709         let packet = Self::parse_inner(&mut cell)?;
25710         Ok(packet)
25711     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>25712     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
25713         let data = UciControlPacketData::parse_inner(&mut bytes)?;
25714         Self::new(data)
25715     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>25716     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
25717         let uciresponse = match &ucicontrolpacket.child {
25718             UciControlPacketDataChild::UciResponse(value) => value.clone(),
25719             _ => {
25720                 return Err(DecodeError::InvalidChildError {
25721                     expected: stringify!(UciControlPacketDataChild::UciResponse),
25722                     actual: format!("{:?}", & ucicontrolpacket.child),
25723                 });
25724             }
25725         };
25726         let sessioncontrolresponse = match &uciresponse.child {
25727             UciResponseDataChild::SessionControlResponse(value) => value.clone(),
25728             _ => {
25729                 return Err(DecodeError::InvalidChildError {
25730                     expected: stringify!(UciResponseDataChild::SessionControlResponse),
25731                     actual: format!("{:?}", & uciresponse.child),
25732                 });
25733             }
25734         };
25735         let sessiongetrangingcountrsp = match &sessioncontrolresponse.child {
25736             SessionControlResponseDataChild::SessionGetRangingCountRsp(value) => {
25737                 value.clone()
25738             }
25739             _ => {
25740                 return Err(DecodeError::InvalidChildError {
25741                     expected: stringify!(
25742                         SessionControlResponseDataChild::SessionGetRangingCountRsp
25743                     ),
25744                     actual: format!("{:?}", & sessioncontrolresponse.child),
25745                 });
25746             }
25747         };
25748         Ok(Self {
25749             ucicontrolpacket,
25750             uciresponse,
25751             sessioncontrolresponse,
25752             sessiongetrangingcountrsp,
25753         })
25754     }
get_count(&self) -> u3225755     pub fn get_count(&self) -> u32 {
25756         self.sessiongetrangingcountrsp.count
25757     }
get_group_id(&self) -> GroupId25758     pub fn get_group_id(&self) -> GroupId {
25759         self.ucicontrolpacket.group_id
25760     }
get_message_type(&self) -> MessageType25761     pub fn get_message_type(&self) -> MessageType {
25762         self.ucicontrolpacket.message_type
25763     }
get_opcode(&self) -> u825764     pub fn get_opcode(&self) -> u8 {
25765         self.ucicontrolpacket.opcode
25766     }
get_status(&self) -> StatusCode25767     pub fn get_status(&self) -> StatusCode {
25768         self.sessiongetrangingcountrsp.status
25769     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>25770     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
25771         self.sessiongetrangingcountrsp.write_to(buffer)
25772     }
get_size(&self) -> usize25773     pub fn get_size(&self) -> usize {
25774         self.ucicontrolpacket.get_size()
25775     }
25776 }
25777 impl SessionGetRangingCountRspBuilder {
build(self) -> SessionGetRangingCountRsp25778     pub fn build(self) -> SessionGetRangingCountRsp {
25779         let sessiongetrangingcountrsp = SessionGetRangingCountRspData {
25780             count: self.count,
25781             status: self.status,
25782         };
25783         let sessioncontrolresponse = SessionControlResponseData {
25784             child: SessionControlResponseDataChild::SessionGetRangingCountRsp(
25785                 sessiongetrangingcountrsp,
25786             ),
25787         };
25788         let uciresponse = UciResponseData {
25789             child: UciResponseDataChild::SessionControlResponse(sessioncontrolresponse),
25790         };
25791         let ucicontrolpacket = UciControlPacketData {
25792             group_id: GroupId::SessionControl,
25793             message_type: MessageType::Response,
25794             opcode: 3,
25795             child: UciControlPacketDataChild::UciResponse(uciresponse),
25796         };
25797         SessionGetRangingCountRsp::new(ucicontrolpacket).unwrap()
25798     }
25799 }
25800 impl From<SessionGetRangingCountRspBuilder> for UciControlPacket {
from(builder: SessionGetRangingCountRspBuilder) -> UciControlPacket25801     fn from(builder: SessionGetRangingCountRspBuilder) -> UciControlPacket {
25802         builder.build().into()
25803     }
25804 }
25805 impl From<SessionGetRangingCountRspBuilder> for UciResponse {
from(builder: SessionGetRangingCountRspBuilder) -> UciResponse25806     fn from(builder: SessionGetRangingCountRspBuilder) -> UciResponse {
25807         builder.build().into()
25808     }
25809 }
25810 impl From<SessionGetRangingCountRspBuilder> for SessionControlResponse {
from(builder: SessionGetRangingCountRspBuilder) -> SessionControlResponse25811     fn from(builder: SessionGetRangingCountRspBuilder) -> SessionControlResponse {
25812         builder.build().into()
25813     }
25814 }
25815 impl From<SessionGetRangingCountRspBuilder> for SessionGetRangingCountRsp {
from(builder: SessionGetRangingCountRspBuilder) -> SessionGetRangingCountRsp25816     fn from(builder: SessionGetRangingCountRspBuilder) -> SessionGetRangingCountRsp {
25817         builder.build().into()
25818     }
25819 }
25820 #[derive(Debug, Clone, PartialEq, Eq)]
25821 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25822 pub struct AndroidGetPowerStatsCmdData {}
25823 #[derive(Debug, Clone, PartialEq, Eq)]
25824 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25825 pub struct AndroidGetPowerStatsCmd {
25826     #[cfg_attr(feature = "serde", serde(flatten))]
25827     ucicontrolpacket: UciControlPacketData,
25828     #[cfg_attr(feature = "serde", serde(flatten))]
25829     ucicommand: UciCommandData,
25830     #[cfg_attr(feature = "serde", serde(flatten))]
25831     androidcommand: AndroidCommandData,
25832     #[cfg_attr(feature = "serde", serde(flatten))]
25833     androidgetpowerstatscmd: AndroidGetPowerStatsCmdData,
25834 }
25835 #[derive(Debug)]
25836 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
25837 pub struct AndroidGetPowerStatsCmdBuilder {}
25838 impl AndroidGetPowerStatsCmdData {
conforms(bytes: &[u8]) -> bool25839     fn conforms(bytes: &[u8]) -> bool {
25840         true
25841     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>25842     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
25843         let mut cell = Cell::new(bytes);
25844         let packet = Self::parse_inner(&mut cell)?;
25845         Ok(packet)
25846     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>25847     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
25848         Ok(Self {})
25849     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>25850     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
25851         Ok(())
25852     }
get_total_size(&self) -> usize25853     fn get_total_size(&self) -> usize {
25854         self.get_size()
25855     }
get_size(&self) -> usize25856     fn get_size(&self) -> usize {
25857         0
25858     }
25859 }
25860 impl Packet for AndroidGetPowerStatsCmd {
encoded_len(&self) -> usize25861     fn encoded_len(&self) -> usize {
25862         self.get_size()
25863     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>25864     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
25865         self.ucicontrolpacket.write_to(buf)
25866     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>25867     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
25868         unimplemented!("Rust legacy does not implement full packet trait")
25869     }
25870 }
25871 impl TryFrom<AndroidGetPowerStatsCmd> for Bytes {
25872     type Error = EncodeError;
try_from(packet: AndroidGetPowerStatsCmd) -> Result<Self, Self::Error>25873     fn try_from(packet: AndroidGetPowerStatsCmd) -> Result<Self, Self::Error> {
25874         packet.encode_to_bytes()
25875     }
25876 }
25877 impl TryFrom<AndroidGetPowerStatsCmd> for Vec<u8> {
25878     type Error = EncodeError;
try_from(packet: AndroidGetPowerStatsCmd) -> Result<Self, Self::Error>25879     fn try_from(packet: AndroidGetPowerStatsCmd) -> Result<Self, Self::Error> {
25880         packet.encode_to_vec()
25881     }
25882 }
25883 impl From<AndroidGetPowerStatsCmd> for UciControlPacket {
from(packet: AndroidGetPowerStatsCmd) -> UciControlPacket25884     fn from(packet: AndroidGetPowerStatsCmd) -> UciControlPacket {
25885         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
25886     }
25887 }
25888 impl From<AndroidGetPowerStatsCmd> for UciCommand {
from(packet: AndroidGetPowerStatsCmd) -> UciCommand25889     fn from(packet: AndroidGetPowerStatsCmd) -> UciCommand {
25890         UciCommand::new(packet.ucicontrolpacket).unwrap()
25891     }
25892 }
25893 impl From<AndroidGetPowerStatsCmd> for AndroidCommand {
from(packet: AndroidGetPowerStatsCmd) -> AndroidCommand25894     fn from(packet: AndroidGetPowerStatsCmd) -> AndroidCommand {
25895         AndroidCommand::new(packet.ucicontrolpacket).unwrap()
25896     }
25897 }
25898 impl TryFrom<UciControlPacket> for AndroidGetPowerStatsCmd {
25899     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<AndroidGetPowerStatsCmd, Self::Error>25900     fn try_from(
25901         packet: UciControlPacket,
25902     ) -> Result<AndroidGetPowerStatsCmd, Self::Error> {
25903         AndroidGetPowerStatsCmd::new(packet.ucicontrolpacket)
25904     }
25905 }
25906 impl AndroidGetPowerStatsCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>25907     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
25908         let mut cell = Cell::new(bytes);
25909         let packet = Self::parse_inner(&mut cell)?;
25910         Ok(packet)
25911     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>25912     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
25913         let data = UciControlPacketData::parse_inner(&mut bytes)?;
25914         Self::new(data)
25915     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>25916     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
25917         let ucicommand = match &ucicontrolpacket.child {
25918             UciControlPacketDataChild::UciCommand(value) => value.clone(),
25919             _ => {
25920                 return Err(DecodeError::InvalidChildError {
25921                     expected: stringify!(UciControlPacketDataChild::UciCommand),
25922                     actual: format!("{:?}", & ucicontrolpacket.child),
25923                 });
25924             }
25925         };
25926         let androidcommand = match &ucicommand.child {
25927             UciCommandDataChild::AndroidCommand(value) => value.clone(),
25928             _ => {
25929                 return Err(DecodeError::InvalidChildError {
25930                     expected: stringify!(UciCommandDataChild::AndroidCommand),
25931                     actual: format!("{:?}", & ucicommand.child),
25932                 });
25933             }
25934         };
25935         let androidgetpowerstatscmd = match &androidcommand.child {
25936             AndroidCommandDataChild::AndroidGetPowerStatsCmd(value) => value.clone(),
25937             _ => {
25938                 return Err(DecodeError::InvalidChildError {
25939                     expected: stringify!(
25940                         AndroidCommandDataChild::AndroidGetPowerStatsCmd
25941                     ),
25942                     actual: format!("{:?}", & androidcommand.child),
25943                 });
25944             }
25945         };
25946         Ok(Self {
25947             ucicontrolpacket,
25948             ucicommand,
25949             androidcommand,
25950             androidgetpowerstatscmd,
25951         })
25952     }
get_group_id(&self) -> GroupId25953     pub fn get_group_id(&self) -> GroupId {
25954         self.ucicontrolpacket.group_id
25955     }
get_message_type(&self) -> MessageType25956     pub fn get_message_type(&self) -> MessageType {
25957         self.ucicontrolpacket.message_type
25958     }
get_opcode(&self) -> u825959     pub fn get_opcode(&self) -> u8 {
25960         self.ucicontrolpacket.opcode
25961     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>25962     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
25963         self.androidgetpowerstatscmd.write_to(buffer)
25964     }
get_size(&self) -> usize25965     pub fn get_size(&self) -> usize {
25966         self.ucicontrolpacket.get_size()
25967     }
25968 }
25969 impl AndroidGetPowerStatsCmdBuilder {
build(self) -> AndroidGetPowerStatsCmd25970     pub fn build(self) -> AndroidGetPowerStatsCmd {
25971         let androidgetpowerstatscmd = AndroidGetPowerStatsCmdData {};
25972         let androidcommand = AndroidCommandData {
25973             child: AndroidCommandDataChild::AndroidGetPowerStatsCmd(
25974                 androidgetpowerstatscmd,
25975             ),
25976         };
25977         let ucicommand = UciCommandData {
25978             child: UciCommandDataChild::AndroidCommand(androidcommand),
25979         };
25980         let ucicontrolpacket = UciControlPacketData {
25981             group_id: GroupId::VendorAndroid,
25982             message_type: MessageType::Command,
25983             opcode: 0,
25984             child: UciControlPacketDataChild::UciCommand(ucicommand),
25985         };
25986         AndroidGetPowerStatsCmd::new(ucicontrolpacket).unwrap()
25987     }
25988 }
25989 impl From<AndroidGetPowerStatsCmdBuilder> for UciControlPacket {
from(builder: AndroidGetPowerStatsCmdBuilder) -> UciControlPacket25990     fn from(builder: AndroidGetPowerStatsCmdBuilder) -> UciControlPacket {
25991         builder.build().into()
25992     }
25993 }
25994 impl From<AndroidGetPowerStatsCmdBuilder> for UciCommand {
from(builder: AndroidGetPowerStatsCmdBuilder) -> UciCommand25995     fn from(builder: AndroidGetPowerStatsCmdBuilder) -> UciCommand {
25996         builder.build().into()
25997     }
25998 }
25999 impl From<AndroidGetPowerStatsCmdBuilder> for AndroidCommand {
from(builder: AndroidGetPowerStatsCmdBuilder) -> AndroidCommand26000     fn from(builder: AndroidGetPowerStatsCmdBuilder) -> AndroidCommand {
26001         builder.build().into()
26002     }
26003 }
26004 impl From<AndroidGetPowerStatsCmdBuilder> for AndroidGetPowerStatsCmd {
from(builder: AndroidGetPowerStatsCmdBuilder) -> AndroidGetPowerStatsCmd26005     fn from(builder: AndroidGetPowerStatsCmdBuilder) -> AndroidGetPowerStatsCmd {
26006         builder.build().into()
26007     }
26008 }
26009 #[derive(Debug, Clone, PartialEq, Eq)]
26010 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26011 pub struct PowerStats {
26012     pub status: StatusCode,
26013     pub idle_time_ms: u32,
26014     pub tx_time_ms: u32,
26015     pub rx_time_ms: u32,
26016     pub total_wake_count: u32,
26017 }
26018 impl PowerStats {
conforms(bytes: &[u8]) -> bool26019     fn conforms(bytes: &[u8]) -> bool {
26020         bytes.len() >= 17
26021     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>26022     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
26023         let mut cell = Cell::new(bytes);
26024         let packet = Self::parse_inner(&mut cell)?;
26025         Ok(packet)
26026     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>26027     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
26028         if bytes.get().remaining() < 1 {
26029             return Err(DecodeError::InvalidLengthError {
26030                 obj: "PowerStats",
26031                 wanted: 1,
26032                 got: bytes.get().remaining(),
26033             });
26034         }
26035         let status = StatusCode::try_from(bytes.get_mut().get_u8())
26036             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
26037                 obj: "PowerStats",
26038                 field: "status",
26039                 value: unknown_val as u64,
26040                 type_: "StatusCode",
26041             })?;
26042         if bytes.get().remaining() < 4 {
26043             return Err(DecodeError::InvalidLengthError {
26044                 obj: "PowerStats",
26045                 wanted: 4,
26046                 got: bytes.get().remaining(),
26047             });
26048         }
26049         let idle_time_ms = bytes.get_mut().get_u32_le();
26050         if bytes.get().remaining() < 4 {
26051             return Err(DecodeError::InvalidLengthError {
26052                 obj: "PowerStats",
26053                 wanted: 4,
26054                 got: bytes.get().remaining(),
26055             });
26056         }
26057         let tx_time_ms = bytes.get_mut().get_u32_le();
26058         if bytes.get().remaining() < 4 {
26059             return Err(DecodeError::InvalidLengthError {
26060                 obj: "PowerStats",
26061                 wanted: 4,
26062                 got: bytes.get().remaining(),
26063             });
26064         }
26065         let rx_time_ms = bytes.get_mut().get_u32_le();
26066         if bytes.get().remaining() < 4 {
26067             return Err(DecodeError::InvalidLengthError {
26068                 obj: "PowerStats",
26069                 wanted: 4,
26070                 got: bytes.get().remaining(),
26071             });
26072         }
26073         let total_wake_count = bytes.get_mut().get_u32_le();
26074         Ok(Self {
26075             status,
26076             idle_time_ms,
26077             tx_time_ms,
26078             rx_time_ms,
26079             total_wake_count,
26080         })
26081     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>26082     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
26083         buffer.put_u8(u8::from(self.status));
26084         buffer.put_u32_le(self.idle_time_ms);
26085         buffer.put_u32_le(self.tx_time_ms);
26086         buffer.put_u32_le(self.rx_time_ms);
26087         buffer.put_u32_le(self.total_wake_count);
26088         Ok(())
26089     }
get_total_size(&self) -> usize26090     fn get_total_size(&self) -> usize {
26091         self.get_size()
26092     }
get_size(&self) -> usize26093     fn get_size(&self) -> usize {
26094         17
26095     }
26096 }
26097 #[derive(Debug, Clone, PartialEq, Eq)]
26098 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26099 pub struct AndroidGetPowerStatsRspData {
26100     stats: PowerStats,
26101 }
26102 #[derive(Debug, Clone, PartialEq, Eq)]
26103 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26104 pub struct AndroidGetPowerStatsRsp {
26105     #[cfg_attr(feature = "serde", serde(flatten))]
26106     ucicontrolpacket: UciControlPacketData,
26107     #[cfg_attr(feature = "serde", serde(flatten))]
26108     uciresponse: UciResponseData,
26109     #[cfg_attr(feature = "serde", serde(flatten))]
26110     androidresponse: AndroidResponseData,
26111     #[cfg_attr(feature = "serde", serde(flatten))]
26112     androidgetpowerstatsrsp: AndroidGetPowerStatsRspData,
26113 }
26114 #[derive(Debug)]
26115 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26116 pub struct AndroidGetPowerStatsRspBuilder {
26117     pub stats: PowerStats,
26118 }
26119 impl AndroidGetPowerStatsRspData {
conforms(bytes: &[u8]) -> bool26120     fn conforms(bytes: &[u8]) -> bool {
26121         bytes.len() >= 17
26122     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>26123     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
26124         let mut cell = Cell::new(bytes);
26125         let packet = Self::parse_inner(&mut cell)?;
26126         Ok(packet)
26127     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>26128     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
26129         let (head, tail) = bytes.get().split_at(17);
26130         bytes.replace(tail);
26131         let stats = PowerStats::parse(head)?;
26132         Ok(Self { stats })
26133     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>26134     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
26135         self.stats.write_to(buffer)?;
26136         Ok(())
26137     }
get_total_size(&self) -> usize26138     fn get_total_size(&self) -> usize {
26139         self.get_size()
26140     }
get_size(&self) -> usize26141     fn get_size(&self) -> usize {
26142         17
26143     }
26144 }
26145 impl Packet for AndroidGetPowerStatsRsp {
encoded_len(&self) -> usize26146     fn encoded_len(&self) -> usize {
26147         self.get_size()
26148     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>26149     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
26150         self.ucicontrolpacket.write_to(buf)
26151     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>26152     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
26153         unimplemented!("Rust legacy does not implement full packet trait")
26154     }
26155 }
26156 impl TryFrom<AndroidGetPowerStatsRsp> for Bytes {
26157     type Error = EncodeError;
try_from(packet: AndroidGetPowerStatsRsp) -> Result<Self, Self::Error>26158     fn try_from(packet: AndroidGetPowerStatsRsp) -> Result<Self, Self::Error> {
26159         packet.encode_to_bytes()
26160     }
26161 }
26162 impl TryFrom<AndroidGetPowerStatsRsp> for Vec<u8> {
26163     type Error = EncodeError;
try_from(packet: AndroidGetPowerStatsRsp) -> Result<Self, Self::Error>26164     fn try_from(packet: AndroidGetPowerStatsRsp) -> Result<Self, Self::Error> {
26165         packet.encode_to_vec()
26166     }
26167 }
26168 impl From<AndroidGetPowerStatsRsp> for UciControlPacket {
from(packet: AndroidGetPowerStatsRsp) -> UciControlPacket26169     fn from(packet: AndroidGetPowerStatsRsp) -> UciControlPacket {
26170         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
26171     }
26172 }
26173 impl From<AndroidGetPowerStatsRsp> for UciResponse {
from(packet: AndroidGetPowerStatsRsp) -> UciResponse26174     fn from(packet: AndroidGetPowerStatsRsp) -> UciResponse {
26175         UciResponse::new(packet.ucicontrolpacket).unwrap()
26176     }
26177 }
26178 impl From<AndroidGetPowerStatsRsp> for AndroidResponse {
from(packet: AndroidGetPowerStatsRsp) -> AndroidResponse26179     fn from(packet: AndroidGetPowerStatsRsp) -> AndroidResponse {
26180         AndroidResponse::new(packet.ucicontrolpacket).unwrap()
26181     }
26182 }
26183 impl TryFrom<UciControlPacket> for AndroidGetPowerStatsRsp {
26184     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<AndroidGetPowerStatsRsp, Self::Error>26185     fn try_from(
26186         packet: UciControlPacket,
26187     ) -> Result<AndroidGetPowerStatsRsp, Self::Error> {
26188         AndroidGetPowerStatsRsp::new(packet.ucicontrolpacket)
26189     }
26190 }
26191 impl AndroidGetPowerStatsRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>26192     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
26193         let mut cell = Cell::new(bytes);
26194         let packet = Self::parse_inner(&mut cell)?;
26195         Ok(packet)
26196     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>26197     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
26198         let data = UciControlPacketData::parse_inner(&mut bytes)?;
26199         Self::new(data)
26200     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>26201     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
26202         let uciresponse = match &ucicontrolpacket.child {
26203             UciControlPacketDataChild::UciResponse(value) => value.clone(),
26204             _ => {
26205                 return Err(DecodeError::InvalidChildError {
26206                     expected: stringify!(UciControlPacketDataChild::UciResponse),
26207                     actual: format!("{:?}", & ucicontrolpacket.child),
26208                 });
26209             }
26210         };
26211         let androidresponse = match &uciresponse.child {
26212             UciResponseDataChild::AndroidResponse(value) => value.clone(),
26213             _ => {
26214                 return Err(DecodeError::InvalidChildError {
26215                     expected: stringify!(UciResponseDataChild::AndroidResponse),
26216                     actual: format!("{:?}", & uciresponse.child),
26217                 });
26218             }
26219         };
26220         let androidgetpowerstatsrsp = match &androidresponse.child {
26221             AndroidResponseDataChild::AndroidGetPowerStatsRsp(value) => value.clone(),
26222             _ => {
26223                 return Err(DecodeError::InvalidChildError {
26224                     expected: stringify!(
26225                         AndroidResponseDataChild::AndroidGetPowerStatsRsp
26226                     ),
26227                     actual: format!("{:?}", & androidresponse.child),
26228                 });
26229             }
26230         };
26231         Ok(Self {
26232             ucicontrolpacket,
26233             uciresponse,
26234             androidresponse,
26235             androidgetpowerstatsrsp,
26236         })
26237     }
get_group_id(&self) -> GroupId26238     pub fn get_group_id(&self) -> GroupId {
26239         self.ucicontrolpacket.group_id
26240     }
get_message_type(&self) -> MessageType26241     pub fn get_message_type(&self) -> MessageType {
26242         self.ucicontrolpacket.message_type
26243     }
get_opcode(&self) -> u826244     pub fn get_opcode(&self) -> u8 {
26245         self.ucicontrolpacket.opcode
26246     }
get_stats(&self) -> &PowerStats26247     pub fn get_stats(&self) -> &PowerStats {
26248         &self.androidgetpowerstatsrsp.stats
26249     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>26250     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
26251         self.androidgetpowerstatsrsp.write_to(buffer)
26252     }
get_size(&self) -> usize26253     pub fn get_size(&self) -> usize {
26254         self.ucicontrolpacket.get_size()
26255     }
26256 }
26257 impl AndroidGetPowerStatsRspBuilder {
build(self) -> AndroidGetPowerStatsRsp26258     pub fn build(self) -> AndroidGetPowerStatsRsp {
26259         let androidgetpowerstatsrsp = AndroidGetPowerStatsRspData {
26260             stats: self.stats,
26261         };
26262         let androidresponse = AndroidResponseData {
26263             child: AndroidResponseDataChild::AndroidGetPowerStatsRsp(
26264                 androidgetpowerstatsrsp,
26265             ),
26266         };
26267         let uciresponse = UciResponseData {
26268             child: UciResponseDataChild::AndroidResponse(androidresponse),
26269         };
26270         let ucicontrolpacket = UciControlPacketData {
26271             group_id: GroupId::VendorAndroid,
26272             message_type: MessageType::Response,
26273             opcode: 0,
26274             child: UciControlPacketDataChild::UciResponse(uciresponse),
26275         };
26276         AndroidGetPowerStatsRsp::new(ucicontrolpacket).unwrap()
26277     }
26278 }
26279 impl From<AndroidGetPowerStatsRspBuilder> for UciControlPacket {
from(builder: AndroidGetPowerStatsRspBuilder) -> UciControlPacket26280     fn from(builder: AndroidGetPowerStatsRspBuilder) -> UciControlPacket {
26281         builder.build().into()
26282     }
26283 }
26284 impl From<AndroidGetPowerStatsRspBuilder> for UciResponse {
from(builder: AndroidGetPowerStatsRspBuilder) -> UciResponse26285     fn from(builder: AndroidGetPowerStatsRspBuilder) -> UciResponse {
26286         builder.build().into()
26287     }
26288 }
26289 impl From<AndroidGetPowerStatsRspBuilder> for AndroidResponse {
from(builder: AndroidGetPowerStatsRspBuilder) -> AndroidResponse26290     fn from(builder: AndroidGetPowerStatsRspBuilder) -> AndroidResponse {
26291         builder.build().into()
26292     }
26293 }
26294 impl From<AndroidGetPowerStatsRspBuilder> for AndroidGetPowerStatsRsp {
from(builder: AndroidGetPowerStatsRspBuilder) -> AndroidGetPowerStatsRsp26295     fn from(builder: AndroidGetPowerStatsRspBuilder) -> AndroidGetPowerStatsRsp {
26296         builder.build().into()
26297     }
26298 }
26299 #[derive(Debug, Clone, PartialEq, Eq)]
26300 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26301 pub struct AndroidSetCountryCodeCmdData {
26302     country_code: [u8; 2],
26303 }
26304 #[derive(Debug, Clone, PartialEq, Eq)]
26305 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26306 pub struct AndroidSetCountryCodeCmd {
26307     #[cfg_attr(feature = "serde", serde(flatten))]
26308     ucicontrolpacket: UciControlPacketData,
26309     #[cfg_attr(feature = "serde", serde(flatten))]
26310     ucicommand: UciCommandData,
26311     #[cfg_attr(feature = "serde", serde(flatten))]
26312     androidcommand: AndroidCommandData,
26313     #[cfg_attr(feature = "serde", serde(flatten))]
26314     androidsetcountrycodecmd: AndroidSetCountryCodeCmdData,
26315 }
26316 #[derive(Debug)]
26317 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26318 pub struct AndroidSetCountryCodeCmdBuilder {
26319     pub country_code: [u8; 2],
26320 }
26321 impl AndroidSetCountryCodeCmdData {
conforms(bytes: &[u8]) -> bool26322     fn conforms(bytes: &[u8]) -> bool {
26323         bytes.len() >= 2
26324     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>26325     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
26326         let mut cell = Cell::new(bytes);
26327         let packet = Self::parse_inner(&mut cell)?;
26328         Ok(packet)
26329     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>26330     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
26331         if bytes.get().remaining() < 2 {
26332             return Err(DecodeError::InvalidLengthError {
26333                 obj: "AndroidSetCountryCodeCmd",
26334                 wanted: 2,
26335                 got: bytes.get().remaining(),
26336             });
26337         }
26338         let country_code = (0..2)
26339             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
26340             .collect::<Result<Vec<_>, DecodeError>>()?
26341             .try_into()
26342             .map_err(|_| DecodeError::InvalidPacketError)?;
26343         Ok(Self { country_code })
26344     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>26345     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
26346         for elem in &self.country_code {
26347             buffer.put_u8(*elem);
26348         }
26349         Ok(())
26350     }
get_total_size(&self) -> usize26351     fn get_total_size(&self) -> usize {
26352         self.get_size()
26353     }
get_size(&self) -> usize26354     fn get_size(&self) -> usize {
26355         2
26356     }
26357 }
26358 impl Packet for AndroidSetCountryCodeCmd {
encoded_len(&self) -> usize26359     fn encoded_len(&self) -> usize {
26360         self.get_size()
26361     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>26362     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
26363         self.ucicontrolpacket.write_to(buf)
26364     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>26365     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
26366         unimplemented!("Rust legacy does not implement full packet trait")
26367     }
26368 }
26369 impl TryFrom<AndroidSetCountryCodeCmd> for Bytes {
26370     type Error = EncodeError;
try_from(packet: AndroidSetCountryCodeCmd) -> Result<Self, Self::Error>26371     fn try_from(packet: AndroidSetCountryCodeCmd) -> Result<Self, Self::Error> {
26372         packet.encode_to_bytes()
26373     }
26374 }
26375 impl TryFrom<AndroidSetCountryCodeCmd> for Vec<u8> {
26376     type Error = EncodeError;
try_from(packet: AndroidSetCountryCodeCmd) -> Result<Self, Self::Error>26377     fn try_from(packet: AndroidSetCountryCodeCmd) -> Result<Self, Self::Error> {
26378         packet.encode_to_vec()
26379     }
26380 }
26381 impl From<AndroidSetCountryCodeCmd> for UciControlPacket {
from(packet: AndroidSetCountryCodeCmd) -> UciControlPacket26382     fn from(packet: AndroidSetCountryCodeCmd) -> UciControlPacket {
26383         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
26384     }
26385 }
26386 impl From<AndroidSetCountryCodeCmd> for UciCommand {
from(packet: AndroidSetCountryCodeCmd) -> UciCommand26387     fn from(packet: AndroidSetCountryCodeCmd) -> UciCommand {
26388         UciCommand::new(packet.ucicontrolpacket).unwrap()
26389     }
26390 }
26391 impl From<AndroidSetCountryCodeCmd> for AndroidCommand {
from(packet: AndroidSetCountryCodeCmd) -> AndroidCommand26392     fn from(packet: AndroidSetCountryCodeCmd) -> AndroidCommand {
26393         AndroidCommand::new(packet.ucicontrolpacket).unwrap()
26394     }
26395 }
26396 impl TryFrom<UciControlPacket> for AndroidSetCountryCodeCmd {
26397     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<AndroidSetCountryCodeCmd, Self::Error>26398     fn try_from(
26399         packet: UciControlPacket,
26400     ) -> Result<AndroidSetCountryCodeCmd, Self::Error> {
26401         AndroidSetCountryCodeCmd::new(packet.ucicontrolpacket)
26402     }
26403 }
26404 impl AndroidSetCountryCodeCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>26405     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
26406         let mut cell = Cell::new(bytes);
26407         let packet = Self::parse_inner(&mut cell)?;
26408         Ok(packet)
26409     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>26410     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
26411         let data = UciControlPacketData::parse_inner(&mut bytes)?;
26412         Self::new(data)
26413     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>26414     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
26415         let ucicommand = match &ucicontrolpacket.child {
26416             UciControlPacketDataChild::UciCommand(value) => value.clone(),
26417             _ => {
26418                 return Err(DecodeError::InvalidChildError {
26419                     expected: stringify!(UciControlPacketDataChild::UciCommand),
26420                     actual: format!("{:?}", & ucicontrolpacket.child),
26421                 });
26422             }
26423         };
26424         let androidcommand = match &ucicommand.child {
26425             UciCommandDataChild::AndroidCommand(value) => value.clone(),
26426             _ => {
26427                 return Err(DecodeError::InvalidChildError {
26428                     expected: stringify!(UciCommandDataChild::AndroidCommand),
26429                     actual: format!("{:?}", & ucicommand.child),
26430                 });
26431             }
26432         };
26433         let androidsetcountrycodecmd = match &androidcommand.child {
26434             AndroidCommandDataChild::AndroidSetCountryCodeCmd(value) => value.clone(),
26435             _ => {
26436                 return Err(DecodeError::InvalidChildError {
26437                     expected: stringify!(
26438                         AndroidCommandDataChild::AndroidSetCountryCodeCmd
26439                     ),
26440                     actual: format!("{:?}", & androidcommand.child),
26441                 });
26442             }
26443         };
26444         Ok(Self {
26445             ucicontrolpacket,
26446             ucicommand,
26447             androidcommand,
26448             androidsetcountrycodecmd,
26449         })
26450     }
get_country_code(&self) -> &[u8; 2]26451     pub fn get_country_code(&self) -> &[u8; 2] {
26452         &self.androidsetcountrycodecmd.country_code
26453     }
get_group_id(&self) -> GroupId26454     pub fn get_group_id(&self) -> GroupId {
26455         self.ucicontrolpacket.group_id
26456     }
get_message_type(&self) -> MessageType26457     pub fn get_message_type(&self) -> MessageType {
26458         self.ucicontrolpacket.message_type
26459     }
get_opcode(&self) -> u826460     pub fn get_opcode(&self) -> u8 {
26461         self.ucicontrolpacket.opcode
26462     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>26463     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
26464         self.androidsetcountrycodecmd.write_to(buffer)
26465     }
get_size(&self) -> usize26466     pub fn get_size(&self) -> usize {
26467         self.ucicontrolpacket.get_size()
26468     }
26469 }
26470 impl AndroidSetCountryCodeCmdBuilder {
build(self) -> AndroidSetCountryCodeCmd26471     pub fn build(self) -> AndroidSetCountryCodeCmd {
26472         let androidsetcountrycodecmd = AndroidSetCountryCodeCmdData {
26473             country_code: self.country_code,
26474         };
26475         let androidcommand = AndroidCommandData {
26476             child: AndroidCommandDataChild::AndroidSetCountryCodeCmd(
26477                 androidsetcountrycodecmd,
26478             ),
26479         };
26480         let ucicommand = UciCommandData {
26481             child: UciCommandDataChild::AndroidCommand(androidcommand),
26482         };
26483         let ucicontrolpacket = UciControlPacketData {
26484             group_id: GroupId::VendorAndroid,
26485             message_type: MessageType::Command,
26486             opcode: 1,
26487             child: UciControlPacketDataChild::UciCommand(ucicommand),
26488         };
26489         AndroidSetCountryCodeCmd::new(ucicontrolpacket).unwrap()
26490     }
26491 }
26492 impl From<AndroidSetCountryCodeCmdBuilder> for UciControlPacket {
from(builder: AndroidSetCountryCodeCmdBuilder) -> UciControlPacket26493     fn from(builder: AndroidSetCountryCodeCmdBuilder) -> UciControlPacket {
26494         builder.build().into()
26495     }
26496 }
26497 impl From<AndroidSetCountryCodeCmdBuilder> for UciCommand {
from(builder: AndroidSetCountryCodeCmdBuilder) -> UciCommand26498     fn from(builder: AndroidSetCountryCodeCmdBuilder) -> UciCommand {
26499         builder.build().into()
26500     }
26501 }
26502 impl From<AndroidSetCountryCodeCmdBuilder> for AndroidCommand {
from(builder: AndroidSetCountryCodeCmdBuilder) -> AndroidCommand26503     fn from(builder: AndroidSetCountryCodeCmdBuilder) -> AndroidCommand {
26504         builder.build().into()
26505     }
26506 }
26507 impl From<AndroidSetCountryCodeCmdBuilder> for AndroidSetCountryCodeCmd {
from(builder: AndroidSetCountryCodeCmdBuilder) -> AndroidSetCountryCodeCmd26508     fn from(builder: AndroidSetCountryCodeCmdBuilder) -> AndroidSetCountryCodeCmd {
26509         builder.build().into()
26510     }
26511 }
26512 #[derive(Debug, Clone, PartialEq, Eq)]
26513 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26514 pub struct AndroidSetCountryCodeRspData {
26515     status: StatusCode,
26516 }
26517 #[derive(Debug, Clone, PartialEq, Eq)]
26518 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26519 pub struct AndroidSetCountryCodeRsp {
26520     #[cfg_attr(feature = "serde", serde(flatten))]
26521     ucicontrolpacket: UciControlPacketData,
26522     #[cfg_attr(feature = "serde", serde(flatten))]
26523     uciresponse: UciResponseData,
26524     #[cfg_attr(feature = "serde", serde(flatten))]
26525     androidresponse: AndroidResponseData,
26526     #[cfg_attr(feature = "serde", serde(flatten))]
26527     androidsetcountrycodersp: AndroidSetCountryCodeRspData,
26528 }
26529 #[derive(Debug)]
26530 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26531 pub struct AndroidSetCountryCodeRspBuilder {
26532     pub status: StatusCode,
26533 }
26534 impl AndroidSetCountryCodeRspData {
conforms(bytes: &[u8]) -> bool26535     fn conforms(bytes: &[u8]) -> bool {
26536         bytes.len() >= 1
26537     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>26538     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
26539         let mut cell = Cell::new(bytes);
26540         let packet = Self::parse_inner(&mut cell)?;
26541         Ok(packet)
26542     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>26543     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
26544         if bytes.get().remaining() < 1 {
26545             return Err(DecodeError::InvalidLengthError {
26546                 obj: "AndroidSetCountryCodeRsp",
26547                 wanted: 1,
26548                 got: bytes.get().remaining(),
26549             });
26550         }
26551         let status = StatusCode::try_from(bytes.get_mut().get_u8())
26552             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
26553                 obj: "AndroidSetCountryCodeRsp",
26554                 field: "status",
26555                 value: unknown_val as u64,
26556                 type_: "StatusCode",
26557             })?;
26558         Ok(Self { status })
26559     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>26560     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
26561         buffer.put_u8(u8::from(self.status));
26562         Ok(())
26563     }
get_total_size(&self) -> usize26564     fn get_total_size(&self) -> usize {
26565         self.get_size()
26566     }
get_size(&self) -> usize26567     fn get_size(&self) -> usize {
26568         1
26569     }
26570 }
26571 impl Packet for AndroidSetCountryCodeRsp {
encoded_len(&self) -> usize26572     fn encoded_len(&self) -> usize {
26573         self.get_size()
26574     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>26575     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
26576         self.ucicontrolpacket.write_to(buf)
26577     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>26578     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
26579         unimplemented!("Rust legacy does not implement full packet trait")
26580     }
26581 }
26582 impl TryFrom<AndroidSetCountryCodeRsp> for Bytes {
26583     type Error = EncodeError;
try_from(packet: AndroidSetCountryCodeRsp) -> Result<Self, Self::Error>26584     fn try_from(packet: AndroidSetCountryCodeRsp) -> Result<Self, Self::Error> {
26585         packet.encode_to_bytes()
26586     }
26587 }
26588 impl TryFrom<AndroidSetCountryCodeRsp> for Vec<u8> {
26589     type Error = EncodeError;
try_from(packet: AndroidSetCountryCodeRsp) -> Result<Self, Self::Error>26590     fn try_from(packet: AndroidSetCountryCodeRsp) -> Result<Self, Self::Error> {
26591         packet.encode_to_vec()
26592     }
26593 }
26594 impl From<AndroidSetCountryCodeRsp> for UciControlPacket {
from(packet: AndroidSetCountryCodeRsp) -> UciControlPacket26595     fn from(packet: AndroidSetCountryCodeRsp) -> UciControlPacket {
26596         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
26597     }
26598 }
26599 impl From<AndroidSetCountryCodeRsp> for UciResponse {
from(packet: AndroidSetCountryCodeRsp) -> UciResponse26600     fn from(packet: AndroidSetCountryCodeRsp) -> UciResponse {
26601         UciResponse::new(packet.ucicontrolpacket).unwrap()
26602     }
26603 }
26604 impl From<AndroidSetCountryCodeRsp> for AndroidResponse {
from(packet: AndroidSetCountryCodeRsp) -> AndroidResponse26605     fn from(packet: AndroidSetCountryCodeRsp) -> AndroidResponse {
26606         AndroidResponse::new(packet.ucicontrolpacket).unwrap()
26607     }
26608 }
26609 impl TryFrom<UciControlPacket> for AndroidSetCountryCodeRsp {
26610     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<AndroidSetCountryCodeRsp, Self::Error>26611     fn try_from(
26612         packet: UciControlPacket,
26613     ) -> Result<AndroidSetCountryCodeRsp, Self::Error> {
26614         AndroidSetCountryCodeRsp::new(packet.ucicontrolpacket)
26615     }
26616 }
26617 impl AndroidSetCountryCodeRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>26618     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
26619         let mut cell = Cell::new(bytes);
26620         let packet = Self::parse_inner(&mut cell)?;
26621         Ok(packet)
26622     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>26623     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
26624         let data = UciControlPacketData::parse_inner(&mut bytes)?;
26625         Self::new(data)
26626     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>26627     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
26628         let uciresponse = match &ucicontrolpacket.child {
26629             UciControlPacketDataChild::UciResponse(value) => value.clone(),
26630             _ => {
26631                 return Err(DecodeError::InvalidChildError {
26632                     expected: stringify!(UciControlPacketDataChild::UciResponse),
26633                     actual: format!("{:?}", & ucicontrolpacket.child),
26634                 });
26635             }
26636         };
26637         let androidresponse = match &uciresponse.child {
26638             UciResponseDataChild::AndroidResponse(value) => value.clone(),
26639             _ => {
26640                 return Err(DecodeError::InvalidChildError {
26641                     expected: stringify!(UciResponseDataChild::AndroidResponse),
26642                     actual: format!("{:?}", & uciresponse.child),
26643                 });
26644             }
26645         };
26646         let androidsetcountrycodersp = match &androidresponse.child {
26647             AndroidResponseDataChild::AndroidSetCountryCodeRsp(value) => value.clone(),
26648             _ => {
26649                 return Err(DecodeError::InvalidChildError {
26650                     expected: stringify!(
26651                         AndroidResponseDataChild::AndroidSetCountryCodeRsp
26652                     ),
26653                     actual: format!("{:?}", & androidresponse.child),
26654                 });
26655             }
26656         };
26657         Ok(Self {
26658             ucicontrolpacket,
26659             uciresponse,
26660             androidresponse,
26661             androidsetcountrycodersp,
26662         })
26663     }
get_group_id(&self) -> GroupId26664     pub fn get_group_id(&self) -> GroupId {
26665         self.ucicontrolpacket.group_id
26666     }
get_message_type(&self) -> MessageType26667     pub fn get_message_type(&self) -> MessageType {
26668         self.ucicontrolpacket.message_type
26669     }
get_opcode(&self) -> u826670     pub fn get_opcode(&self) -> u8 {
26671         self.ucicontrolpacket.opcode
26672     }
get_status(&self) -> StatusCode26673     pub fn get_status(&self) -> StatusCode {
26674         self.androidsetcountrycodersp.status
26675     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>26676     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
26677         self.androidsetcountrycodersp.write_to(buffer)
26678     }
get_size(&self) -> usize26679     pub fn get_size(&self) -> usize {
26680         self.ucicontrolpacket.get_size()
26681     }
26682 }
26683 impl AndroidSetCountryCodeRspBuilder {
build(self) -> AndroidSetCountryCodeRsp26684     pub fn build(self) -> AndroidSetCountryCodeRsp {
26685         let androidsetcountrycodersp = AndroidSetCountryCodeRspData {
26686             status: self.status,
26687         };
26688         let androidresponse = AndroidResponseData {
26689             child: AndroidResponseDataChild::AndroidSetCountryCodeRsp(
26690                 androidsetcountrycodersp,
26691             ),
26692         };
26693         let uciresponse = UciResponseData {
26694             child: UciResponseDataChild::AndroidResponse(androidresponse),
26695         };
26696         let ucicontrolpacket = UciControlPacketData {
26697             group_id: GroupId::VendorAndroid,
26698             message_type: MessageType::Response,
26699             opcode: 1,
26700             child: UciControlPacketDataChild::UciResponse(uciresponse),
26701         };
26702         AndroidSetCountryCodeRsp::new(ucicontrolpacket).unwrap()
26703     }
26704 }
26705 impl From<AndroidSetCountryCodeRspBuilder> for UciControlPacket {
from(builder: AndroidSetCountryCodeRspBuilder) -> UciControlPacket26706     fn from(builder: AndroidSetCountryCodeRspBuilder) -> UciControlPacket {
26707         builder.build().into()
26708     }
26709 }
26710 impl From<AndroidSetCountryCodeRspBuilder> for UciResponse {
from(builder: AndroidSetCountryCodeRspBuilder) -> UciResponse26711     fn from(builder: AndroidSetCountryCodeRspBuilder) -> UciResponse {
26712         builder.build().into()
26713     }
26714 }
26715 impl From<AndroidSetCountryCodeRspBuilder> for AndroidResponse {
from(builder: AndroidSetCountryCodeRspBuilder) -> AndroidResponse26716     fn from(builder: AndroidSetCountryCodeRspBuilder) -> AndroidResponse {
26717         builder.build().into()
26718     }
26719 }
26720 impl From<AndroidSetCountryCodeRspBuilder> for AndroidSetCountryCodeRsp {
from(builder: AndroidSetCountryCodeRspBuilder) -> AndroidSetCountryCodeRsp26721     fn from(builder: AndroidSetCountryCodeRspBuilder) -> AndroidSetCountryCodeRsp {
26722         builder.build().into()
26723     }
26724 }
26725 #[derive(Debug, Clone, PartialEq, Eq)]
26726 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26727 pub struct FrameReportTlv {
26728     pub t: FrameReportTlvType,
26729     pub v: Vec<u8>,
26730 }
26731 impl FrameReportTlv {
conforms(bytes: &[u8]) -> bool26732     fn conforms(bytes: &[u8]) -> bool {
26733         bytes.len() >= 3
26734     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>26735     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
26736         let mut cell = Cell::new(bytes);
26737         let packet = Self::parse_inner(&mut cell)?;
26738         Ok(packet)
26739     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>26740     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
26741         if bytes.get().remaining() < 1 {
26742             return Err(DecodeError::InvalidLengthError {
26743                 obj: "FrameReportTlv",
26744                 wanted: 1,
26745                 got: bytes.get().remaining(),
26746             });
26747         }
26748         let t = FrameReportTlvType::try_from(bytes.get_mut().get_u8())
26749             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
26750                 obj: "FrameReportTlv",
26751                 field: "t",
26752                 value: unknown_val as u64,
26753                 type_: "FrameReportTlvType",
26754             })?;
26755         if bytes.get().remaining() < 2 {
26756             return Err(DecodeError::InvalidLengthError {
26757                 obj: "FrameReportTlv",
26758                 wanted: 2,
26759                 got: bytes.get().remaining(),
26760             });
26761         }
26762         let v_size = bytes.get_mut().get_u16_le() as usize;
26763         if bytes.get().remaining() < v_size {
26764             return Err(DecodeError::InvalidLengthError {
26765                 obj: "FrameReportTlv",
26766                 wanted: v_size,
26767                 got: bytes.get().remaining(),
26768             });
26769         }
26770         let mut v = Vec::with_capacity(v_size);
26771         for _ in 0..v_size {
26772             v.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
26773         }
26774         Ok(Self { t, v })
26775     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>26776     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
26777         buffer.put_u8(u8::from(self.t));
26778         if self.v.len() > 0xffff {
26779             return Err(EncodeError::SizeOverflow {
26780                 packet: "FrameReportTlv",
26781                 field: "v",
26782                 size: self.v.len(),
26783                 maximum_size: 0xffff,
26784             });
26785         }
26786         buffer.put_u16_le(self.v.len() as u16);
26787         for elem in &self.v {
26788             buffer.put_u8(*elem);
26789         }
26790         Ok(())
26791     }
get_total_size(&self) -> usize26792     fn get_total_size(&self) -> usize {
26793         self.get_size()
26794     }
get_size(&self) -> usize26795     fn get_size(&self) -> usize {
26796         3 + self.v.len()
26797     }
26798 }
26799 #[derive(Debug, Clone, PartialEq, Eq)]
26800 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26801 pub enum FrameReportTlvPacketDataChild {
26802     Rssi(RssiData),
26803     Aoa(AoaData),
26804     Cir(CirData),
26805     SegmentMetrics(SegmentMetricsData),
26806     Payload(Bytes),
26807     None,
26808 }
26809 impl FrameReportTlvPacketDataChild {
get_total_size(&self) -> usize26810     fn get_total_size(&self) -> usize {
26811         match self {
26812             FrameReportTlvPacketDataChild::Rssi(value) => value.get_total_size(),
26813             FrameReportTlvPacketDataChild::Aoa(value) => value.get_total_size(),
26814             FrameReportTlvPacketDataChild::Cir(value) => value.get_total_size(),
26815             FrameReportTlvPacketDataChild::SegmentMetrics(value) => {
26816                 value.get_total_size()
26817             }
26818             FrameReportTlvPacketDataChild::Payload(bytes) => bytes.len(),
26819             FrameReportTlvPacketDataChild::None => 0,
26820         }
26821     }
26822 }
26823 #[derive(Debug, Clone, PartialEq, Eq)]
26824 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26825 pub enum FrameReportTlvPacketChild {
26826     Rssi(Rssi),
26827     Aoa(Aoa),
26828     Cir(Cir),
26829     SegmentMetrics(SegmentMetrics),
26830     Payload(Bytes),
26831     None,
26832 }
26833 #[derive(Debug, Clone, PartialEq, Eq)]
26834 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26835 pub struct FrameReportTlvPacketData {
26836     t: FrameReportTlvType,
26837     child: FrameReportTlvPacketDataChild,
26838 }
26839 #[derive(Debug, Clone, PartialEq, Eq)]
26840 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26841 pub struct FrameReportTlvPacket {
26842     #[cfg_attr(feature = "serde", serde(flatten))]
26843     framereporttlvpacket: FrameReportTlvPacketData,
26844 }
26845 #[derive(Debug)]
26846 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
26847 pub struct FrameReportTlvPacketBuilder {
26848     pub t: FrameReportTlvType,
26849     pub payload: Option<Bytes>,
26850 }
26851 impl FrameReportTlvPacketData {
conforms(bytes: &[u8]) -> bool26852     fn conforms(bytes: &[u8]) -> bool {
26853         bytes.len() >= 3
26854     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>26855     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
26856         let mut cell = Cell::new(bytes);
26857         let packet = Self::parse_inner(&mut cell)?;
26858         Ok(packet)
26859     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>26860     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
26861         if bytes.get().remaining() < 1 {
26862             return Err(DecodeError::InvalidLengthError {
26863                 obj: "FrameReportTlvPacket",
26864                 wanted: 1,
26865                 got: bytes.get().remaining(),
26866             });
26867         }
26868         let t = FrameReportTlvType::try_from(bytes.get_mut().get_u8())
26869             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
26870                 obj: "FrameReportTlvPacket",
26871                 field: "t",
26872                 value: unknown_val as u64,
26873                 type_: "FrameReportTlvType",
26874             })?;
26875         if bytes.get().remaining() < 2 {
26876             return Err(DecodeError::InvalidLengthError {
26877                 obj: "FrameReportTlvPacket",
26878                 wanted: 2,
26879                 got: bytes.get().remaining(),
26880             });
26881         }
26882         let body_size = bytes.get_mut().get_u16_le() as usize;
26883         if bytes.get().remaining() < body_size {
26884             return Err(DecodeError::InvalidLengthError {
26885                 obj: "FrameReportTlvPacket",
26886                 wanted: body_size,
26887                 got: bytes.get().remaining(),
26888             });
26889         }
26890         let payload = &bytes.get()[..body_size];
26891         bytes.get_mut().advance(body_size);
26892         let child = match (t) {
26893             (FrameReportTlvType::Rssi) if RssiData::conforms(&payload) => {
26894                 let mut cell = Cell::new(payload);
26895                 let child_data = RssiData::parse_inner(&mut cell)?;
26896                 FrameReportTlvPacketDataChild::Rssi(child_data)
26897             }
26898             (FrameReportTlvType::Aoa) if AoaData::conforms(&payload) => {
26899                 let mut cell = Cell::new(payload);
26900                 let child_data = AoaData::parse_inner(&mut cell)?;
26901                 FrameReportTlvPacketDataChild::Aoa(child_data)
26902             }
26903             (FrameReportTlvType::Cir) if CirData::conforms(&payload) => {
26904                 let mut cell = Cell::new(payload);
26905                 let child_data = CirData::parse_inner(&mut cell)?;
26906                 FrameReportTlvPacketDataChild::Cir(child_data)
26907             }
26908             (FrameReportTlvType::SegmentMetrics) if SegmentMetricsData::conforms(
26909                 &payload,
26910             ) => {
26911                 let mut cell = Cell::new(payload);
26912                 let child_data = SegmentMetricsData::parse_inner(&mut cell)?;
26913                 FrameReportTlvPacketDataChild::SegmentMetrics(child_data)
26914             }
26915             _ if !payload.is_empty() => {
26916                 FrameReportTlvPacketDataChild::Payload(Bytes::copy_from_slice(payload))
26917             }
26918             _ => FrameReportTlvPacketDataChild::None,
26919         };
26920         Ok(Self { t, child })
26921     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>26922     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
26923         buffer.put_u8(u8::from(self.t));
26924         if self.child.get_total_size() > 0xffff {
26925             return Err(EncodeError::SizeOverflow {
26926                 packet: "FrameReportTlvPacket",
26927                 field: "_body_",
26928                 size: self.child.get_total_size(),
26929                 maximum_size: 0xffff,
26930             });
26931         }
26932         buffer.put_u16_le(self.child.get_total_size() as u16);
26933         match &self.child {
26934             FrameReportTlvPacketDataChild::Rssi(child) => child.write_to(buffer)?,
26935             FrameReportTlvPacketDataChild::Aoa(child) => child.write_to(buffer)?,
26936             FrameReportTlvPacketDataChild::Cir(child) => child.write_to(buffer)?,
26937             FrameReportTlvPacketDataChild::SegmentMetrics(child) => {
26938                 child.write_to(buffer)?
26939             }
26940             FrameReportTlvPacketDataChild::Payload(payload) => buffer.put_slice(payload),
26941             FrameReportTlvPacketDataChild::None => {}
26942         }
26943         Ok(())
26944     }
get_total_size(&self) -> usize26945     fn get_total_size(&self) -> usize {
26946         self.get_size()
26947     }
get_size(&self) -> usize26948     fn get_size(&self) -> usize {
26949         3 + self.child.get_total_size()
26950     }
26951 }
26952 impl Packet for FrameReportTlvPacket {
encoded_len(&self) -> usize26953     fn encoded_len(&self) -> usize {
26954         self.get_size()
26955     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>26956     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
26957         self.framereporttlvpacket.write_to(buf)
26958     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>26959     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
26960         unimplemented!("Rust legacy does not implement full packet trait")
26961     }
26962 }
26963 impl TryFrom<FrameReportTlvPacket> for Bytes {
26964     type Error = EncodeError;
try_from(packet: FrameReportTlvPacket) -> Result<Self, Self::Error>26965     fn try_from(packet: FrameReportTlvPacket) -> Result<Self, Self::Error> {
26966         packet.encode_to_bytes()
26967     }
26968 }
26969 impl TryFrom<FrameReportTlvPacket> for Vec<u8> {
26970     type Error = EncodeError;
try_from(packet: FrameReportTlvPacket) -> Result<Self, Self::Error>26971     fn try_from(packet: FrameReportTlvPacket) -> Result<Self, Self::Error> {
26972         packet.encode_to_vec()
26973     }
26974 }
26975 impl FrameReportTlvPacket {
parse(bytes: &[u8]) -> Result<Self, DecodeError>26976     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
26977         let mut cell = Cell::new(bytes);
26978         let packet = Self::parse_inner(&mut cell)?;
26979         Ok(packet)
26980     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>26981     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
26982         let data = FrameReportTlvPacketData::parse_inner(&mut bytes)?;
26983         Self::new(data)
26984     }
specialize(&self) -> FrameReportTlvPacketChild26985     pub fn specialize(&self) -> FrameReportTlvPacketChild {
26986         match &self.framereporttlvpacket.child {
26987             FrameReportTlvPacketDataChild::Rssi(_) => {
26988                 FrameReportTlvPacketChild::Rssi(
26989                     Rssi::new(self.framereporttlvpacket.clone()).unwrap(),
26990                 )
26991             }
26992             FrameReportTlvPacketDataChild::Aoa(_) => {
26993                 FrameReportTlvPacketChild::Aoa(
26994                     Aoa::new(self.framereporttlvpacket.clone()).unwrap(),
26995                 )
26996             }
26997             FrameReportTlvPacketDataChild::Cir(_) => {
26998                 FrameReportTlvPacketChild::Cir(
26999                     Cir::new(self.framereporttlvpacket.clone()).unwrap(),
27000                 )
27001             }
27002             FrameReportTlvPacketDataChild::SegmentMetrics(_) => {
27003                 FrameReportTlvPacketChild::SegmentMetrics(
27004                     SegmentMetrics::new(self.framereporttlvpacket.clone()).unwrap(),
27005                 )
27006             }
27007             FrameReportTlvPacketDataChild::Payload(payload) => {
27008                 FrameReportTlvPacketChild::Payload(payload.clone())
27009             }
27010             FrameReportTlvPacketDataChild::None => FrameReportTlvPacketChild::None,
27011         }
27012     }
new(framereporttlvpacket: FrameReportTlvPacketData) -> Result<Self, DecodeError>27013     fn new(framereporttlvpacket: FrameReportTlvPacketData) -> Result<Self, DecodeError> {
27014         Ok(Self { framereporttlvpacket })
27015     }
get_t(&self) -> FrameReportTlvType27016     pub fn get_t(&self) -> FrameReportTlvType {
27017         self.framereporttlvpacket.t
27018     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>27019     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
27020         self.framereporttlvpacket.write_to(buffer)
27021     }
get_size(&self) -> usize27022     pub fn get_size(&self) -> usize {
27023         self.framereporttlvpacket.get_size()
27024     }
27025 }
27026 impl FrameReportTlvPacketBuilder {
build(self) -> FrameReportTlvPacket27027     pub fn build(self) -> FrameReportTlvPacket {
27028         let framereporttlvpacket = FrameReportTlvPacketData {
27029             t: self.t,
27030             child: match self.payload {
27031                 None => FrameReportTlvPacketDataChild::None,
27032                 Some(bytes) => FrameReportTlvPacketDataChild::Payload(bytes),
27033             },
27034         };
27035         FrameReportTlvPacket::new(framereporttlvpacket).unwrap()
27036     }
27037 }
27038 impl From<FrameReportTlvPacketBuilder> for FrameReportTlvPacket {
from(builder: FrameReportTlvPacketBuilder) -> FrameReportTlvPacket27039     fn from(builder: FrameReportTlvPacketBuilder) -> FrameReportTlvPacket {
27040         builder.build().into()
27041     }
27042 }
27043 #[derive(Debug, Clone, PartialEq, Eq)]
27044 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27045 pub struct RssiData {
27046     rssi: Vec<u8>,
27047 }
27048 #[derive(Debug, Clone, PartialEq, Eq)]
27049 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27050 pub struct Rssi {
27051     #[cfg_attr(feature = "serde", serde(flatten))]
27052     framereporttlvpacket: FrameReportTlvPacketData,
27053     #[cfg_attr(feature = "serde", serde(flatten))]
27054     rssi: RssiData,
27055 }
27056 #[derive(Debug)]
27057 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27058 pub struct RssiBuilder {
27059     pub rssi: Vec<u8>,
27060 }
27061 impl RssiData {
conforms(bytes: &[u8]) -> bool27062     fn conforms(bytes: &[u8]) -> bool {
27063         true
27064     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>27065     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27066         let mut cell = Cell::new(bytes);
27067         let packet = Self::parse_inner(&mut cell)?;
27068         Ok(packet)
27069     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27070     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27071         let mut rssi = Vec::with_capacity(bytes.get().remaining());
27072         for _ in 0..bytes.get().remaining() {
27073             rssi.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
27074         }
27075         Ok(Self { rssi })
27076     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>27077     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
27078         for elem in &self.rssi {
27079             buffer.put_u8(*elem);
27080         }
27081         Ok(())
27082     }
get_total_size(&self) -> usize27083     fn get_total_size(&self) -> usize {
27084         self.get_size()
27085     }
get_size(&self) -> usize27086     fn get_size(&self) -> usize {
27087         self.rssi.len()
27088     }
27089 }
27090 impl Packet for Rssi {
encoded_len(&self) -> usize27091     fn encoded_len(&self) -> usize {
27092         self.get_size()
27093     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>27094     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
27095         self.framereporttlvpacket.write_to(buf)
27096     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>27097     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
27098         unimplemented!("Rust legacy does not implement full packet trait")
27099     }
27100 }
27101 impl TryFrom<Rssi> for Bytes {
27102     type Error = EncodeError;
try_from(packet: Rssi) -> Result<Self, Self::Error>27103     fn try_from(packet: Rssi) -> Result<Self, Self::Error> {
27104         packet.encode_to_bytes()
27105     }
27106 }
27107 impl TryFrom<Rssi> for Vec<u8> {
27108     type Error = EncodeError;
try_from(packet: Rssi) -> Result<Self, Self::Error>27109     fn try_from(packet: Rssi) -> Result<Self, Self::Error> {
27110         packet.encode_to_vec()
27111     }
27112 }
27113 impl From<Rssi> for FrameReportTlvPacket {
from(packet: Rssi) -> FrameReportTlvPacket27114     fn from(packet: Rssi) -> FrameReportTlvPacket {
27115         FrameReportTlvPacket::new(packet.framereporttlvpacket).unwrap()
27116     }
27117 }
27118 impl TryFrom<FrameReportTlvPacket> for Rssi {
27119     type Error = DecodeError;
try_from(packet: FrameReportTlvPacket) -> Result<Rssi, Self::Error>27120     fn try_from(packet: FrameReportTlvPacket) -> Result<Rssi, Self::Error> {
27121         Rssi::new(packet.framereporttlvpacket)
27122     }
27123 }
27124 impl Rssi {
parse(bytes: &[u8]) -> Result<Self, DecodeError>27125     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27126         let mut cell = Cell::new(bytes);
27127         let packet = Self::parse_inner(&mut cell)?;
27128         Ok(packet)
27129     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27130     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27131         let data = FrameReportTlvPacketData::parse_inner(&mut bytes)?;
27132         Self::new(data)
27133     }
new(framereporttlvpacket: FrameReportTlvPacketData) -> Result<Self, DecodeError>27134     fn new(framereporttlvpacket: FrameReportTlvPacketData) -> Result<Self, DecodeError> {
27135         let rssi = match &framereporttlvpacket.child {
27136             FrameReportTlvPacketDataChild::Rssi(value) => value.clone(),
27137             _ => {
27138                 return Err(DecodeError::InvalidChildError {
27139                     expected: stringify!(FrameReportTlvPacketDataChild::Rssi),
27140                     actual: format!("{:?}", & framereporttlvpacket.child),
27141                 });
27142             }
27143         };
27144         Ok(Self { framereporttlvpacket, rssi })
27145     }
get_rssi(&self) -> &Vec<u8>27146     pub fn get_rssi(&self) -> &Vec<u8> {
27147         &self.rssi.rssi
27148     }
get_t(&self) -> FrameReportTlvType27149     pub fn get_t(&self) -> FrameReportTlvType {
27150         self.framereporttlvpacket.t
27151     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>27152     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
27153         self.rssi.write_to(buffer)
27154     }
get_size(&self) -> usize27155     pub fn get_size(&self) -> usize {
27156         self.framereporttlvpacket.get_size()
27157     }
27158 }
27159 impl RssiBuilder {
build(self) -> Rssi27160     pub fn build(self) -> Rssi {
27161         let rssi = RssiData { rssi: self.rssi };
27162         let framereporttlvpacket = FrameReportTlvPacketData {
27163             t: FrameReportTlvType::Rssi,
27164             child: FrameReportTlvPacketDataChild::Rssi(rssi),
27165         };
27166         Rssi::new(framereporttlvpacket).unwrap()
27167     }
27168 }
27169 impl From<RssiBuilder> for FrameReportTlvPacket {
from(builder: RssiBuilder) -> FrameReportTlvPacket27170     fn from(builder: RssiBuilder) -> FrameReportTlvPacket {
27171         builder.build().into()
27172     }
27173 }
27174 impl From<RssiBuilder> for Rssi {
from(builder: RssiBuilder) -> Rssi27175     fn from(builder: RssiBuilder) -> Rssi {
27176         builder.build().into()
27177     }
27178 }
27179 #[derive(Debug, Clone, PartialEq, Eq)]
27180 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27181 pub struct AoaMeasurement {
27182     pub tdoa: u16,
27183     pub pdoa: u16,
27184     pub aoa: u16,
27185     pub fom: u8,
27186     pub t: u8,
27187 }
27188 impl AoaMeasurement {
conforms(bytes: &[u8]) -> bool27189     fn conforms(bytes: &[u8]) -> bool {
27190         bytes.len() >= 8
27191     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>27192     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27193         let mut cell = Cell::new(bytes);
27194         let packet = Self::parse_inner(&mut cell)?;
27195         Ok(packet)
27196     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27197     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27198         if bytes.get().remaining() < 2 {
27199             return Err(DecodeError::InvalidLengthError {
27200                 obj: "AoaMeasurement",
27201                 wanted: 2,
27202                 got: bytes.get().remaining(),
27203             });
27204         }
27205         let tdoa = bytes.get_mut().get_u16_le();
27206         if bytes.get().remaining() < 2 {
27207             return Err(DecodeError::InvalidLengthError {
27208                 obj: "AoaMeasurement",
27209                 wanted: 2,
27210                 got: bytes.get().remaining(),
27211             });
27212         }
27213         let pdoa = bytes.get_mut().get_u16_le();
27214         if bytes.get().remaining() < 2 {
27215             return Err(DecodeError::InvalidLengthError {
27216                 obj: "AoaMeasurement",
27217                 wanted: 2,
27218                 got: bytes.get().remaining(),
27219             });
27220         }
27221         let aoa = bytes.get_mut().get_u16_le();
27222         if bytes.get().remaining() < 1 {
27223             return Err(DecodeError::InvalidLengthError {
27224                 obj: "AoaMeasurement",
27225                 wanted: 1,
27226                 got: bytes.get().remaining(),
27227             });
27228         }
27229         let fom = bytes.get_mut().get_u8();
27230         if bytes.get().remaining() < 1 {
27231             return Err(DecodeError::InvalidLengthError {
27232                 obj: "AoaMeasurement",
27233                 wanted: 1,
27234                 got: bytes.get().remaining(),
27235             });
27236         }
27237         let t = bytes.get_mut().get_u8();
27238         Ok(Self { tdoa, pdoa, aoa, fom, t })
27239     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>27240     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
27241         buffer.put_u16_le(self.tdoa);
27242         buffer.put_u16_le(self.pdoa);
27243         buffer.put_u16_le(self.aoa);
27244         buffer.put_u8(self.fom);
27245         buffer.put_u8(self.t);
27246         Ok(())
27247     }
get_total_size(&self) -> usize27248     fn get_total_size(&self) -> usize {
27249         self.get_size()
27250     }
get_size(&self) -> usize27251     fn get_size(&self) -> usize {
27252         8
27253     }
27254 }
27255 #[derive(Debug, Clone, PartialEq, Eq)]
27256 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27257 pub struct AoaData {
27258     aoa: Vec<AoaMeasurement>,
27259 }
27260 #[derive(Debug, Clone, PartialEq, Eq)]
27261 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27262 pub struct Aoa {
27263     #[cfg_attr(feature = "serde", serde(flatten))]
27264     framereporttlvpacket: FrameReportTlvPacketData,
27265     #[cfg_attr(feature = "serde", serde(flatten))]
27266     aoa: AoaData,
27267 }
27268 #[derive(Debug)]
27269 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27270 pub struct AoaBuilder {
27271     pub aoa: Vec<AoaMeasurement>,
27272 }
27273 impl AoaData {
conforms(bytes: &[u8]) -> bool27274     fn conforms(bytes: &[u8]) -> bool {
27275         true
27276     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>27277     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27278         let mut cell = Cell::new(bytes);
27279         let packet = Self::parse_inner(&mut cell)?;
27280         Ok(packet)
27281     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27282     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27283         if bytes.get().remaining() % 8 != 0 {
27284             return Err(DecodeError::InvalidArraySize {
27285                 array: bytes.get().remaining(),
27286                 element: 8,
27287             });
27288         }
27289         let aoa_count = bytes.get().remaining() / 8;
27290         let mut aoa = Vec::with_capacity(aoa_count);
27291         for _ in 0..aoa_count {
27292             aoa.push(AoaMeasurement::parse_inner(bytes)?);
27293         }
27294         Ok(Self { aoa })
27295     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>27296     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
27297         for elem in &self.aoa {
27298             elem.write_to(buffer)?;
27299         }
27300         Ok(())
27301     }
get_total_size(&self) -> usize27302     fn get_total_size(&self) -> usize {
27303         self.get_size()
27304     }
get_size(&self) -> usize27305     fn get_size(&self) -> usize {
27306         self.aoa.iter().map(|elem| elem.get_size()).sum::<usize>()
27307     }
27308 }
27309 impl Packet for Aoa {
encoded_len(&self) -> usize27310     fn encoded_len(&self) -> usize {
27311         self.get_size()
27312     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>27313     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
27314         self.framereporttlvpacket.write_to(buf)
27315     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>27316     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
27317         unimplemented!("Rust legacy does not implement full packet trait")
27318     }
27319 }
27320 impl TryFrom<Aoa> for Bytes {
27321     type Error = EncodeError;
try_from(packet: Aoa) -> Result<Self, Self::Error>27322     fn try_from(packet: Aoa) -> Result<Self, Self::Error> {
27323         packet.encode_to_bytes()
27324     }
27325 }
27326 impl TryFrom<Aoa> for Vec<u8> {
27327     type Error = EncodeError;
try_from(packet: Aoa) -> Result<Self, Self::Error>27328     fn try_from(packet: Aoa) -> Result<Self, Self::Error> {
27329         packet.encode_to_vec()
27330     }
27331 }
27332 impl From<Aoa> for FrameReportTlvPacket {
from(packet: Aoa) -> FrameReportTlvPacket27333     fn from(packet: Aoa) -> FrameReportTlvPacket {
27334         FrameReportTlvPacket::new(packet.framereporttlvpacket).unwrap()
27335     }
27336 }
27337 impl TryFrom<FrameReportTlvPacket> for Aoa {
27338     type Error = DecodeError;
try_from(packet: FrameReportTlvPacket) -> Result<Aoa, Self::Error>27339     fn try_from(packet: FrameReportTlvPacket) -> Result<Aoa, Self::Error> {
27340         Aoa::new(packet.framereporttlvpacket)
27341     }
27342 }
27343 impl Aoa {
parse(bytes: &[u8]) -> Result<Self, DecodeError>27344     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27345         let mut cell = Cell::new(bytes);
27346         let packet = Self::parse_inner(&mut cell)?;
27347         Ok(packet)
27348     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27349     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27350         let data = FrameReportTlvPacketData::parse_inner(&mut bytes)?;
27351         Self::new(data)
27352     }
new(framereporttlvpacket: FrameReportTlvPacketData) -> Result<Self, DecodeError>27353     fn new(framereporttlvpacket: FrameReportTlvPacketData) -> Result<Self, DecodeError> {
27354         let aoa = match &framereporttlvpacket.child {
27355             FrameReportTlvPacketDataChild::Aoa(value) => value.clone(),
27356             _ => {
27357                 return Err(DecodeError::InvalidChildError {
27358                     expected: stringify!(FrameReportTlvPacketDataChild::Aoa),
27359                     actual: format!("{:?}", & framereporttlvpacket.child),
27360                 });
27361             }
27362         };
27363         Ok(Self { framereporttlvpacket, aoa })
27364     }
get_aoa(&self) -> &Vec<AoaMeasurement>27365     pub fn get_aoa(&self) -> &Vec<AoaMeasurement> {
27366         &self.aoa.aoa
27367     }
get_t(&self) -> FrameReportTlvType27368     pub fn get_t(&self) -> FrameReportTlvType {
27369         self.framereporttlvpacket.t
27370     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>27371     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
27372         self.aoa.write_to(buffer)
27373     }
get_size(&self) -> usize27374     pub fn get_size(&self) -> usize {
27375         self.framereporttlvpacket.get_size()
27376     }
27377 }
27378 impl AoaBuilder {
build(self) -> Aoa27379     pub fn build(self) -> Aoa {
27380         let aoa = AoaData { aoa: self.aoa };
27381         let framereporttlvpacket = FrameReportTlvPacketData {
27382             t: FrameReportTlvType::Aoa,
27383             child: FrameReportTlvPacketDataChild::Aoa(aoa),
27384         };
27385         Aoa::new(framereporttlvpacket).unwrap()
27386     }
27387 }
27388 impl From<AoaBuilder> for FrameReportTlvPacket {
from(builder: AoaBuilder) -> FrameReportTlvPacket27389     fn from(builder: AoaBuilder) -> FrameReportTlvPacket {
27390         builder.build().into()
27391     }
27392 }
27393 impl From<AoaBuilder> for Aoa {
from(builder: AoaBuilder) -> Aoa27394     fn from(builder: AoaBuilder) -> Aoa {
27395         builder.build().into()
27396     }
27397 }
27398 #[derive(Debug, Clone, PartialEq, Eq)]
27399 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27400 pub struct CirValue {
27401     pub first_path_index: u16,
27402     pub first_path_snr: u16,
27403     pub first_path_ns: u16,
27404     pub peak_path_index: u16,
27405     pub peak_path_snr: u16,
27406     pub peak_path_ns: u16,
27407     pub first_path_sample_offset: u8,
27408     pub samples_number: u8,
27409     pub sample_window: Vec<u8>,
27410 }
27411 impl CirValue {
conforms(bytes: &[u8]) -> bool27412     fn conforms(bytes: &[u8]) -> bool {
27413         bytes.len() >= 16
27414     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>27415     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27416         let mut cell = Cell::new(bytes);
27417         let packet = Self::parse_inner(&mut cell)?;
27418         Ok(packet)
27419     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27420     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27421         if bytes.get().remaining() < 2 {
27422             return Err(DecodeError::InvalidLengthError {
27423                 obj: "CirValue",
27424                 wanted: 2,
27425                 got: bytes.get().remaining(),
27426             });
27427         }
27428         let first_path_index = bytes.get_mut().get_u16_le();
27429         if bytes.get().remaining() < 2 {
27430             return Err(DecodeError::InvalidLengthError {
27431                 obj: "CirValue",
27432                 wanted: 2,
27433                 got: bytes.get().remaining(),
27434             });
27435         }
27436         let first_path_snr = bytes.get_mut().get_u16_le();
27437         if bytes.get().remaining() < 2 {
27438             return Err(DecodeError::InvalidLengthError {
27439                 obj: "CirValue",
27440                 wanted: 2,
27441                 got: bytes.get().remaining(),
27442             });
27443         }
27444         let first_path_ns = bytes.get_mut().get_u16_le();
27445         if bytes.get().remaining() < 2 {
27446             return Err(DecodeError::InvalidLengthError {
27447                 obj: "CirValue",
27448                 wanted: 2,
27449                 got: bytes.get().remaining(),
27450             });
27451         }
27452         let peak_path_index = bytes.get_mut().get_u16_le();
27453         if bytes.get().remaining() < 2 {
27454             return Err(DecodeError::InvalidLengthError {
27455                 obj: "CirValue",
27456                 wanted: 2,
27457                 got: bytes.get().remaining(),
27458             });
27459         }
27460         let peak_path_snr = bytes.get_mut().get_u16_le();
27461         if bytes.get().remaining() < 2 {
27462             return Err(DecodeError::InvalidLengthError {
27463                 obj: "CirValue",
27464                 wanted: 2,
27465                 got: bytes.get().remaining(),
27466             });
27467         }
27468         let peak_path_ns = bytes.get_mut().get_u16_le();
27469         if bytes.get().remaining() < 1 {
27470             return Err(DecodeError::InvalidLengthError {
27471                 obj: "CirValue",
27472                 wanted: 1,
27473                 got: bytes.get().remaining(),
27474             });
27475         }
27476         let first_path_sample_offset = bytes.get_mut().get_u8();
27477         if bytes.get().remaining() < 1 {
27478             return Err(DecodeError::InvalidLengthError {
27479                 obj: "CirValue",
27480                 wanted: 1,
27481                 got: bytes.get().remaining(),
27482             });
27483         }
27484         let samples_number = bytes.get_mut().get_u8();
27485         if bytes.get().remaining() < 2 {
27486             return Err(DecodeError::InvalidLengthError {
27487                 obj: "CirValue",
27488                 wanted: 2,
27489                 got: bytes.get().remaining(),
27490             });
27491         }
27492         let sample_window_size = bytes.get_mut().get_u16_le() as usize;
27493         if bytes.get().remaining() < sample_window_size {
27494             return Err(DecodeError::InvalidLengthError {
27495                 obj: "CirValue",
27496                 wanted: sample_window_size,
27497                 got: bytes.get().remaining(),
27498             });
27499         }
27500         let mut sample_window = Vec::with_capacity(sample_window_size);
27501         for _ in 0..sample_window_size {
27502             sample_window.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
27503         }
27504         Ok(Self {
27505             first_path_index,
27506             first_path_snr,
27507             first_path_ns,
27508             peak_path_index,
27509             peak_path_snr,
27510             peak_path_ns,
27511             first_path_sample_offset,
27512             samples_number,
27513             sample_window,
27514         })
27515     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>27516     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
27517         buffer.put_u16_le(self.first_path_index);
27518         buffer.put_u16_le(self.first_path_snr);
27519         buffer.put_u16_le(self.first_path_ns);
27520         buffer.put_u16_le(self.peak_path_index);
27521         buffer.put_u16_le(self.peak_path_snr);
27522         buffer.put_u16_le(self.peak_path_ns);
27523         buffer.put_u8(self.first_path_sample_offset);
27524         buffer.put_u8(self.samples_number);
27525         if self.sample_window.len() > 0xffff {
27526             return Err(EncodeError::SizeOverflow {
27527                 packet: "CirValue",
27528                 field: "sample_window",
27529                 size: self.sample_window.len(),
27530                 maximum_size: 0xffff,
27531             });
27532         }
27533         buffer.put_u16_le(self.sample_window.len() as u16);
27534         for elem in &self.sample_window {
27535             buffer.put_u8(*elem);
27536         }
27537         Ok(())
27538     }
get_total_size(&self) -> usize27539     fn get_total_size(&self) -> usize {
27540         self.get_size()
27541     }
get_size(&self) -> usize27542     fn get_size(&self) -> usize {
27543         16 + self.sample_window.len()
27544     }
27545 }
27546 #[derive(Debug, Clone, PartialEq, Eq)]
27547 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27548 pub struct CirData {
27549     cir_value: Vec<CirValue>,
27550 }
27551 #[derive(Debug, Clone, PartialEq, Eq)]
27552 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27553 pub struct Cir {
27554     #[cfg_attr(feature = "serde", serde(flatten))]
27555     framereporttlvpacket: FrameReportTlvPacketData,
27556     #[cfg_attr(feature = "serde", serde(flatten))]
27557     cir: CirData,
27558 }
27559 #[derive(Debug)]
27560 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27561 pub struct CirBuilder {
27562     pub cir_value: Vec<CirValue>,
27563 }
27564 impl CirData {
conforms(bytes: &[u8]) -> bool27565     fn conforms(bytes: &[u8]) -> bool {
27566         bytes.len() >= 1
27567     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>27568     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27569         let mut cell = Cell::new(bytes);
27570         let packet = Self::parse_inner(&mut cell)?;
27571         Ok(packet)
27572     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27573     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27574         if bytes.get().remaining() < 1 {
27575             return Err(DecodeError::InvalidLengthError {
27576                 obj: "Cir",
27577                 wanted: 1,
27578                 got: bytes.get().remaining(),
27579             });
27580         }
27581         let cir_value_count = bytes.get_mut().get_u8() as usize;
27582         let cir_value = (0..cir_value_count)
27583             .map(|_| CirValue::parse_inner(bytes))
27584             .collect::<Result<Vec<_>, DecodeError>>()?;
27585         Ok(Self { cir_value })
27586     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>27587     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
27588         buffer.put_u8(self.cir_value.len() as u8);
27589         for elem in &self.cir_value {
27590             elem.write_to(buffer)?;
27591         }
27592         Ok(())
27593     }
get_total_size(&self) -> usize27594     fn get_total_size(&self) -> usize {
27595         self.get_size()
27596     }
get_size(&self) -> usize27597     fn get_size(&self) -> usize {
27598         1 + self.cir_value.iter().map(|elem| elem.get_size()).sum::<usize>()
27599     }
27600 }
27601 impl Packet for Cir {
encoded_len(&self) -> usize27602     fn encoded_len(&self) -> usize {
27603         self.get_size()
27604     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>27605     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
27606         self.framereporttlvpacket.write_to(buf)
27607     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>27608     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
27609         unimplemented!("Rust legacy does not implement full packet trait")
27610     }
27611 }
27612 impl TryFrom<Cir> for Bytes {
27613     type Error = EncodeError;
try_from(packet: Cir) -> Result<Self, Self::Error>27614     fn try_from(packet: Cir) -> Result<Self, Self::Error> {
27615         packet.encode_to_bytes()
27616     }
27617 }
27618 impl TryFrom<Cir> for Vec<u8> {
27619     type Error = EncodeError;
try_from(packet: Cir) -> Result<Self, Self::Error>27620     fn try_from(packet: Cir) -> Result<Self, Self::Error> {
27621         packet.encode_to_vec()
27622     }
27623 }
27624 impl From<Cir> for FrameReportTlvPacket {
from(packet: Cir) -> FrameReportTlvPacket27625     fn from(packet: Cir) -> FrameReportTlvPacket {
27626         FrameReportTlvPacket::new(packet.framereporttlvpacket).unwrap()
27627     }
27628 }
27629 impl TryFrom<FrameReportTlvPacket> for Cir {
27630     type Error = DecodeError;
try_from(packet: FrameReportTlvPacket) -> Result<Cir, Self::Error>27631     fn try_from(packet: FrameReportTlvPacket) -> Result<Cir, Self::Error> {
27632         Cir::new(packet.framereporttlvpacket)
27633     }
27634 }
27635 impl Cir {
parse(bytes: &[u8]) -> Result<Self, DecodeError>27636     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27637         let mut cell = Cell::new(bytes);
27638         let packet = Self::parse_inner(&mut cell)?;
27639         Ok(packet)
27640     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27641     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27642         let data = FrameReportTlvPacketData::parse_inner(&mut bytes)?;
27643         Self::new(data)
27644     }
new(framereporttlvpacket: FrameReportTlvPacketData) -> Result<Self, DecodeError>27645     fn new(framereporttlvpacket: FrameReportTlvPacketData) -> Result<Self, DecodeError> {
27646         let cir = match &framereporttlvpacket.child {
27647             FrameReportTlvPacketDataChild::Cir(value) => value.clone(),
27648             _ => {
27649                 return Err(DecodeError::InvalidChildError {
27650                     expected: stringify!(FrameReportTlvPacketDataChild::Cir),
27651                     actual: format!("{:?}", & framereporttlvpacket.child),
27652                 });
27653             }
27654         };
27655         Ok(Self { framereporttlvpacket, cir })
27656     }
get_cir_value(&self) -> &Vec<CirValue>27657     pub fn get_cir_value(&self) -> &Vec<CirValue> {
27658         &self.cir.cir_value
27659     }
get_t(&self) -> FrameReportTlvType27660     pub fn get_t(&self) -> FrameReportTlvType {
27661         self.framereporttlvpacket.t
27662     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>27663     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
27664         self.cir.write_to(buffer)
27665     }
get_size(&self) -> usize27666     pub fn get_size(&self) -> usize {
27667         self.framereporttlvpacket.get_size()
27668     }
27669 }
27670 impl CirBuilder {
build(self) -> Cir27671     pub fn build(self) -> Cir {
27672         let cir = CirData {
27673             cir_value: self.cir_value,
27674         };
27675         let framereporttlvpacket = FrameReportTlvPacketData {
27676             t: FrameReportTlvType::Cir,
27677             child: FrameReportTlvPacketDataChild::Cir(cir),
27678         };
27679         Cir::new(framereporttlvpacket).unwrap()
27680     }
27681 }
27682 impl From<CirBuilder> for FrameReportTlvPacket {
from(builder: CirBuilder) -> FrameReportTlvPacket27683     fn from(builder: CirBuilder) -> FrameReportTlvPacket {
27684         builder.build().into()
27685     }
27686 }
27687 impl From<CirBuilder> for Cir {
from(builder: CirBuilder) -> Cir27688     fn from(builder: CirBuilder) -> Cir {
27689         builder.build().into()
27690     }
27691 }
27692 #[derive(Debug, Clone, PartialEq, Eq)]
27693 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27694 pub struct SegmentMetricsData {
27695     segment_metrics: Vec<SegmentMetricsValue>,
27696 }
27697 #[derive(Debug, Clone, PartialEq, Eq)]
27698 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27699 pub struct SegmentMetrics {
27700     #[cfg_attr(feature = "serde", serde(flatten))]
27701     framereporttlvpacket: FrameReportTlvPacketData,
27702     #[cfg_attr(feature = "serde", serde(flatten))]
27703     segmentmetrics: SegmentMetricsData,
27704 }
27705 #[derive(Debug)]
27706 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27707 pub struct SegmentMetricsBuilder {
27708     pub segment_metrics: Vec<SegmentMetricsValue>,
27709 }
27710 impl SegmentMetricsData {
conforms(bytes: &[u8]) -> bool27711     fn conforms(bytes: &[u8]) -> bool {
27712         true
27713     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>27714     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27715         let mut cell = Cell::new(bytes);
27716         let packet = Self::parse_inner(&mut cell)?;
27717         Ok(packet)
27718     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27719     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27720         if bytes.get().remaining() % 17 != 0 {
27721             return Err(DecodeError::InvalidArraySize {
27722                 array: bytes.get().remaining(),
27723                 element: 17,
27724             });
27725         }
27726         let segment_metrics_count = bytes.get().remaining() / 17;
27727         let mut segment_metrics = Vec::with_capacity(segment_metrics_count);
27728         for _ in 0..segment_metrics_count {
27729             segment_metrics.push(SegmentMetricsValue::parse_inner(bytes)?);
27730         }
27731         Ok(Self { segment_metrics })
27732     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>27733     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
27734         for elem in &self.segment_metrics {
27735             elem.write_to(buffer)?;
27736         }
27737         Ok(())
27738     }
get_total_size(&self) -> usize27739     fn get_total_size(&self) -> usize {
27740         self.get_size()
27741     }
get_size(&self) -> usize27742     fn get_size(&self) -> usize {
27743         self.segment_metrics.iter().map(|elem| elem.get_size()).sum::<usize>()
27744     }
27745 }
27746 impl Packet for SegmentMetrics {
encoded_len(&self) -> usize27747     fn encoded_len(&self) -> usize {
27748         self.get_size()
27749     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>27750     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
27751         self.framereporttlvpacket.write_to(buf)
27752     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>27753     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
27754         unimplemented!("Rust legacy does not implement full packet trait")
27755     }
27756 }
27757 impl TryFrom<SegmentMetrics> for Bytes {
27758     type Error = EncodeError;
try_from(packet: SegmentMetrics) -> Result<Self, Self::Error>27759     fn try_from(packet: SegmentMetrics) -> Result<Self, Self::Error> {
27760         packet.encode_to_bytes()
27761     }
27762 }
27763 impl TryFrom<SegmentMetrics> for Vec<u8> {
27764     type Error = EncodeError;
try_from(packet: SegmentMetrics) -> Result<Self, Self::Error>27765     fn try_from(packet: SegmentMetrics) -> Result<Self, Self::Error> {
27766         packet.encode_to_vec()
27767     }
27768 }
27769 impl From<SegmentMetrics> for FrameReportTlvPacket {
from(packet: SegmentMetrics) -> FrameReportTlvPacket27770     fn from(packet: SegmentMetrics) -> FrameReportTlvPacket {
27771         FrameReportTlvPacket::new(packet.framereporttlvpacket).unwrap()
27772     }
27773 }
27774 impl TryFrom<FrameReportTlvPacket> for SegmentMetrics {
27775     type Error = DecodeError;
try_from(packet: FrameReportTlvPacket) -> Result<SegmentMetrics, Self::Error>27776     fn try_from(packet: FrameReportTlvPacket) -> Result<SegmentMetrics, Self::Error> {
27777         SegmentMetrics::new(packet.framereporttlvpacket)
27778     }
27779 }
27780 impl SegmentMetrics {
parse(bytes: &[u8]) -> Result<Self, DecodeError>27781     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27782         let mut cell = Cell::new(bytes);
27783         let packet = Self::parse_inner(&mut cell)?;
27784         Ok(packet)
27785     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27786     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27787         let data = FrameReportTlvPacketData::parse_inner(&mut bytes)?;
27788         Self::new(data)
27789     }
new(framereporttlvpacket: FrameReportTlvPacketData) -> Result<Self, DecodeError>27790     fn new(framereporttlvpacket: FrameReportTlvPacketData) -> Result<Self, DecodeError> {
27791         let segmentmetrics = match &framereporttlvpacket.child {
27792             FrameReportTlvPacketDataChild::SegmentMetrics(value) => value.clone(),
27793             _ => {
27794                 return Err(DecodeError::InvalidChildError {
27795                     expected: stringify!(FrameReportTlvPacketDataChild::SegmentMetrics),
27796                     actual: format!("{:?}", & framereporttlvpacket.child),
27797                 });
27798             }
27799         };
27800         Ok(Self {
27801             framereporttlvpacket,
27802             segmentmetrics,
27803         })
27804     }
get_segment_metrics(&self) -> &Vec<SegmentMetricsValue>27805     pub fn get_segment_metrics(&self) -> &Vec<SegmentMetricsValue> {
27806         &self.segmentmetrics.segment_metrics
27807     }
get_t(&self) -> FrameReportTlvType27808     pub fn get_t(&self) -> FrameReportTlvType {
27809         self.framereporttlvpacket.t
27810     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>27811     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
27812         self.segmentmetrics.write_to(buffer)
27813     }
get_size(&self) -> usize27814     pub fn get_size(&self) -> usize {
27815         self.framereporttlvpacket.get_size()
27816     }
27817 }
27818 impl SegmentMetricsBuilder {
build(self) -> SegmentMetrics27819     pub fn build(self) -> SegmentMetrics {
27820         let segmentmetrics = SegmentMetricsData {
27821             segment_metrics: self.segment_metrics,
27822         };
27823         let framereporttlvpacket = FrameReportTlvPacketData {
27824             t: FrameReportTlvType::SegmentMetrics,
27825             child: FrameReportTlvPacketDataChild::SegmentMetrics(segmentmetrics),
27826         };
27827         SegmentMetrics::new(framereporttlvpacket).unwrap()
27828     }
27829 }
27830 impl From<SegmentMetricsBuilder> for FrameReportTlvPacket {
from(builder: SegmentMetricsBuilder) -> FrameReportTlvPacket27831     fn from(builder: SegmentMetricsBuilder) -> FrameReportTlvPacket {
27832         builder.build().into()
27833     }
27834 }
27835 impl From<SegmentMetricsBuilder> for SegmentMetrics {
from(builder: SegmentMetricsBuilder) -> SegmentMetrics27836     fn from(builder: SegmentMetricsBuilder) -> SegmentMetrics {
27837         builder.build().into()
27838     }
27839 }
27840 #[repr(u64)]
27841 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
27842 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27843 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
27844 pub enum SegmentIdValue {
27845     Ipatov = 0x0,
27846     Sts0 = 0x1,
27847     Sts1 = 0x2,
27848     Sts2 = 0x3,
27849     Sts3 = 0x4,
27850 }
27851 impl TryFrom<u8> for SegmentIdValue {
27852     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>27853     fn try_from(value: u8) -> Result<Self, Self::Error> {
27854         match value {
27855             0x0 => Ok(SegmentIdValue::Ipatov),
27856             0x1 => Ok(SegmentIdValue::Sts0),
27857             0x2 => Ok(SegmentIdValue::Sts1),
27858             0x3 => Ok(SegmentIdValue::Sts2),
27859             0x4 => Ok(SegmentIdValue::Sts3),
27860             _ => Err(value),
27861         }
27862     }
27863 }
27864 impl From<&SegmentIdValue> for u8 {
from(value: &SegmentIdValue) -> Self27865     fn from(value: &SegmentIdValue) -> Self {
27866         match value {
27867             SegmentIdValue::Ipatov => 0x0,
27868             SegmentIdValue::Sts0 => 0x1,
27869             SegmentIdValue::Sts1 => 0x2,
27870             SegmentIdValue::Sts2 => 0x3,
27871             SegmentIdValue::Sts3 => 0x4,
27872         }
27873     }
27874 }
27875 impl From<SegmentIdValue> for u8 {
from(value: SegmentIdValue) -> Self27876     fn from(value: SegmentIdValue) -> Self {
27877         (&value).into()
27878     }
27879 }
27880 impl From<SegmentIdValue> for i8 {
from(value: SegmentIdValue) -> Self27881     fn from(value: SegmentIdValue) -> Self {
27882         u8::from(value) as Self
27883     }
27884 }
27885 impl From<SegmentIdValue> for i16 {
from(value: SegmentIdValue) -> Self27886     fn from(value: SegmentIdValue) -> Self {
27887         u8::from(value) as Self
27888     }
27889 }
27890 impl From<SegmentIdValue> for i32 {
from(value: SegmentIdValue) -> Self27891     fn from(value: SegmentIdValue) -> Self {
27892         u8::from(value) as Self
27893     }
27894 }
27895 impl From<SegmentIdValue> for i64 {
from(value: SegmentIdValue) -> Self27896     fn from(value: SegmentIdValue) -> Self {
27897         u8::from(value) as Self
27898     }
27899 }
27900 impl From<SegmentIdValue> for u16 {
from(value: SegmentIdValue) -> Self27901     fn from(value: SegmentIdValue) -> Self {
27902         u8::from(value) as Self
27903     }
27904 }
27905 impl From<SegmentIdValue> for u32 {
from(value: SegmentIdValue) -> Self27906     fn from(value: SegmentIdValue) -> Self {
27907         u8::from(value) as Self
27908     }
27909 }
27910 impl From<SegmentIdValue> for u64 {
from(value: SegmentIdValue) -> Self27911     fn from(value: SegmentIdValue) -> Self {
27912         u8::from(value) as Self
27913     }
27914 }
27915 #[derive(Debug, Clone, PartialEq, Eq)]
27916 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27917 pub struct ReceiverAndSegmentValue {
27918     pub segment_id: SegmentIdValue,
27919     pub receiver_is_controller: u8,
27920     pub receiver_id: u8,
27921 }
27922 impl ReceiverAndSegmentValue {
conforms(bytes: &[u8]) -> bool27923     fn conforms(bytes: &[u8]) -> bool {
27924         bytes.len() >= 1
27925     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>27926     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27927         let mut cell = Cell::new(bytes);
27928         let packet = Self::parse_inner(&mut cell)?;
27929         Ok(packet)
27930     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>27931     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
27932         if bytes.get().remaining() < 1 {
27933             return Err(DecodeError::InvalidLengthError {
27934                 obj: "ReceiverAndSegmentValue",
27935                 wanted: 1,
27936                 got: bytes.get().remaining(),
27937             });
27938         }
27939         let chunk = bytes.get_mut().get_u8();
27940         let segment_id = SegmentIdValue::try_from((chunk & 0x7))
27941             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
27942                 obj: "ReceiverAndSegmentValue",
27943                 field: "segment_id",
27944                 value: unknown_val as u64,
27945                 type_: "SegmentIdValue",
27946             })?;
27947         let receiver_is_controller = ((chunk >> 3) & 0x1);
27948         let receiver_id = ((chunk >> 4) & 0xf);
27949         Ok(Self {
27950             segment_id,
27951             receiver_is_controller,
27952             receiver_id,
27953         })
27954     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>27955     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
27956         if self.receiver_is_controller > 0x1 {
27957             return Err(EncodeError::InvalidScalarValue {
27958                 packet: "ReceiverAndSegmentValue",
27959                 field: "receiver_is_controller",
27960                 value: self.receiver_is_controller as u64,
27961                 maximum_value: 0x1,
27962             });
27963         }
27964         if self.receiver_id > 0xf {
27965             return Err(EncodeError::InvalidScalarValue {
27966                 packet: "ReceiverAndSegmentValue",
27967                 field: "receiver_id",
27968                 value: self.receiver_id as u64,
27969                 maximum_value: 0xf,
27970             });
27971         }
27972         let value = u8::from(self.segment_id) | (self.receiver_is_controller << 3)
27973             | (self.receiver_id << 4);
27974         buffer.put_u8(value);
27975         Ok(())
27976     }
get_total_size(&self) -> usize27977     fn get_total_size(&self) -> usize {
27978         self.get_size()
27979     }
get_size(&self) -> usize27980     fn get_size(&self) -> usize {
27981         1
27982     }
27983 }
27984 #[derive(Debug, Clone, PartialEq, Eq)]
27985 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
27986 pub struct PathSample {
27987     pub index: u16,
27988     pub rsl: u16,
27989     pub time_ns: u16,
27990 }
27991 impl PathSample {
conforms(bytes: &[u8]) -> bool27992     fn conforms(bytes: &[u8]) -> bool {
27993         bytes.len() >= 6
27994     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>27995     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
27996         let mut cell = Cell::new(bytes);
27997         let packet = Self::parse_inner(&mut cell)?;
27998         Ok(packet)
27999     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28000     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28001         if bytes.get().remaining() < 2 {
28002             return Err(DecodeError::InvalidLengthError {
28003                 obj: "PathSample",
28004                 wanted: 2,
28005                 got: bytes.get().remaining(),
28006             });
28007         }
28008         let index = bytes.get_mut().get_u16_le();
28009         if bytes.get().remaining() < 2 {
28010             return Err(DecodeError::InvalidLengthError {
28011                 obj: "PathSample",
28012                 wanted: 2,
28013                 got: bytes.get().remaining(),
28014             });
28015         }
28016         let rsl = bytes.get_mut().get_u16_le();
28017         if bytes.get().remaining() < 2 {
28018             return Err(DecodeError::InvalidLengthError {
28019                 obj: "PathSample",
28020                 wanted: 2,
28021                 got: bytes.get().remaining(),
28022             });
28023         }
28024         let time_ns = bytes.get_mut().get_u16_le();
28025         Ok(Self { index, rsl, time_ns })
28026     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>28027     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
28028         buffer.put_u16_le(self.index);
28029         buffer.put_u16_le(self.rsl);
28030         buffer.put_u16_le(self.time_ns);
28031         Ok(())
28032     }
get_total_size(&self) -> usize28033     fn get_total_size(&self) -> usize {
28034         self.get_size()
28035     }
get_size(&self) -> usize28036     fn get_size(&self) -> usize {
28037         6
28038     }
28039 }
28040 #[derive(Debug, Clone, PartialEq, Eq)]
28041 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28042 pub struct SegmentMetricsValue {
28043     pub receiver_and_segment: ReceiverAndSegmentValue,
28044     pub rf_noise_floor: u16,
28045     pub segment_rsl: u16,
28046     pub first_path: PathSample,
28047     pub peak_path: PathSample,
28048 }
28049 impl SegmentMetricsValue {
conforms(bytes: &[u8]) -> bool28050     fn conforms(bytes: &[u8]) -> bool {
28051         bytes.len() >= 17
28052     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>28053     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
28054         let mut cell = Cell::new(bytes);
28055         let packet = Self::parse_inner(&mut cell)?;
28056         Ok(packet)
28057     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28058     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28059         let (head, tail) = bytes.get().split_at(1);
28060         bytes.replace(tail);
28061         let receiver_and_segment = ReceiverAndSegmentValue::parse(head)?;
28062         if bytes.get().remaining() < 2 {
28063             return Err(DecodeError::InvalidLengthError {
28064                 obj: "SegmentMetricsValue",
28065                 wanted: 2,
28066                 got: bytes.get().remaining(),
28067             });
28068         }
28069         let rf_noise_floor = bytes.get_mut().get_u16_le();
28070         if bytes.get().remaining() < 2 {
28071             return Err(DecodeError::InvalidLengthError {
28072                 obj: "SegmentMetricsValue",
28073                 wanted: 2,
28074                 got: bytes.get().remaining(),
28075             });
28076         }
28077         let segment_rsl = bytes.get_mut().get_u16_le();
28078         let (head, tail) = bytes.get().split_at(6);
28079         bytes.replace(tail);
28080         let first_path = PathSample::parse(head)?;
28081         let (head, tail) = bytes.get().split_at(6);
28082         bytes.replace(tail);
28083         let peak_path = PathSample::parse(head)?;
28084         Ok(Self {
28085             receiver_and_segment,
28086             rf_noise_floor,
28087             segment_rsl,
28088             first_path,
28089             peak_path,
28090         })
28091     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>28092     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
28093         self.receiver_and_segment.write_to(buffer)?;
28094         buffer.put_u16_le(self.rf_noise_floor);
28095         buffer.put_u16_le(self.segment_rsl);
28096         self.first_path.write_to(buffer)?;
28097         self.peak_path.write_to(buffer)?;
28098         Ok(())
28099     }
get_total_size(&self) -> usize28100     fn get_total_size(&self) -> usize {
28101         self.get_size()
28102     }
get_size(&self) -> usize28103     fn get_size(&self) -> usize {
28104         17
28105     }
28106 }
28107 #[derive(Debug, Clone, PartialEq, Eq)]
28108 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28109 pub struct FrameReport {
28110     pub uwb_msg_id: u8,
28111     pub action: u8,
28112     pub antenna_set: u8,
28113     pub frame_report_tlvs: Vec<FrameReportTlv>,
28114 }
28115 impl FrameReport {
conforms(bytes: &[u8]) -> bool28116     fn conforms(bytes: &[u8]) -> bool {
28117         bytes.len() >= 4
28118     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>28119     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
28120         let mut cell = Cell::new(bytes);
28121         let packet = Self::parse_inner(&mut cell)?;
28122         Ok(packet)
28123     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28124     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28125         if bytes.get().remaining() < 1 {
28126             return Err(DecodeError::InvalidLengthError {
28127                 obj: "FrameReport",
28128                 wanted: 1,
28129                 got: bytes.get().remaining(),
28130             });
28131         }
28132         let uwb_msg_id = bytes.get_mut().get_u8();
28133         if bytes.get().remaining() < 1 {
28134             return Err(DecodeError::InvalidLengthError {
28135                 obj: "FrameReport",
28136                 wanted: 1,
28137                 got: bytes.get().remaining(),
28138             });
28139         }
28140         let action = bytes.get_mut().get_u8();
28141         if bytes.get().remaining() < 1 {
28142             return Err(DecodeError::InvalidLengthError {
28143                 obj: "FrameReport",
28144                 wanted: 1,
28145                 got: bytes.get().remaining(),
28146             });
28147         }
28148         let antenna_set = bytes.get_mut().get_u8();
28149         if bytes.get().remaining() < 1 {
28150             return Err(DecodeError::InvalidLengthError {
28151                 obj: "FrameReport",
28152                 wanted: 1,
28153                 got: bytes.get().remaining(),
28154             });
28155         }
28156         let frame_report_tlvs_count = bytes.get_mut().get_u8() as usize;
28157         let frame_report_tlvs = (0..frame_report_tlvs_count)
28158             .map(|_| FrameReportTlv::parse_inner(bytes))
28159             .collect::<Result<Vec<_>, DecodeError>>()?;
28160         Ok(Self {
28161             uwb_msg_id,
28162             action,
28163             antenna_set,
28164             frame_report_tlvs,
28165         })
28166     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>28167     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
28168         buffer.put_u8(self.uwb_msg_id);
28169         buffer.put_u8(self.action);
28170         buffer.put_u8(self.antenna_set);
28171         buffer.put_u8(self.frame_report_tlvs.len() as u8);
28172         for elem in &self.frame_report_tlvs {
28173             elem.write_to(buffer)?;
28174         }
28175         Ok(())
28176     }
get_total_size(&self) -> usize28177     fn get_total_size(&self) -> usize {
28178         self.get_size()
28179     }
get_size(&self) -> usize28180     fn get_size(&self) -> usize {
28181         4 + self.frame_report_tlvs.iter().map(|elem| elem.get_size()).sum::<usize>()
28182     }
28183 }
28184 #[derive(Debug, Clone, PartialEq, Eq)]
28185 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28186 pub struct AndroidRangeDiagnosticsNtfData {
28187     session_token: u32,
28188     sequence_number: u32,
28189     frame_reports: Vec<FrameReport>,
28190 }
28191 #[derive(Debug, Clone, PartialEq, Eq)]
28192 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28193 pub struct AndroidRangeDiagnosticsNtf {
28194     #[cfg_attr(feature = "serde", serde(flatten))]
28195     ucicontrolpacket: UciControlPacketData,
28196     #[cfg_attr(feature = "serde", serde(flatten))]
28197     ucinotification: UciNotificationData,
28198     #[cfg_attr(feature = "serde", serde(flatten))]
28199     androidnotification: AndroidNotificationData,
28200     #[cfg_attr(feature = "serde", serde(flatten))]
28201     androidrangediagnosticsntf: AndroidRangeDiagnosticsNtfData,
28202 }
28203 #[derive(Debug)]
28204 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28205 pub struct AndroidRangeDiagnosticsNtfBuilder {
28206     pub frame_reports: Vec<FrameReport>,
28207     pub sequence_number: u32,
28208     pub session_token: u32,
28209 }
28210 impl AndroidRangeDiagnosticsNtfData {
conforms(bytes: &[u8]) -> bool28211     fn conforms(bytes: &[u8]) -> bool {
28212         bytes.len() >= 9
28213     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>28214     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
28215         let mut cell = Cell::new(bytes);
28216         let packet = Self::parse_inner(&mut cell)?;
28217         Ok(packet)
28218     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28219     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28220         if bytes.get().remaining() < 4 {
28221             return Err(DecodeError::InvalidLengthError {
28222                 obj: "AndroidRangeDiagnosticsNtf",
28223                 wanted: 4,
28224                 got: bytes.get().remaining(),
28225             });
28226         }
28227         let session_token = bytes.get_mut().get_u32_le();
28228         if bytes.get().remaining() < 4 {
28229             return Err(DecodeError::InvalidLengthError {
28230                 obj: "AndroidRangeDiagnosticsNtf",
28231                 wanted: 4,
28232                 got: bytes.get().remaining(),
28233             });
28234         }
28235         let sequence_number = bytes.get_mut().get_u32_le();
28236         if bytes.get().remaining() < 1 {
28237             return Err(DecodeError::InvalidLengthError {
28238                 obj: "AndroidRangeDiagnosticsNtf",
28239                 wanted: 1,
28240                 got: bytes.get().remaining(),
28241             });
28242         }
28243         let frame_reports_count = bytes.get_mut().get_u8() as usize;
28244         let frame_reports = (0..frame_reports_count)
28245             .map(|_| FrameReport::parse_inner(bytes))
28246             .collect::<Result<Vec<_>, DecodeError>>()?;
28247         Ok(Self {
28248             session_token,
28249             sequence_number,
28250             frame_reports,
28251         })
28252     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>28253     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
28254         buffer.put_u32_le(self.session_token);
28255         buffer.put_u32_le(self.sequence_number);
28256         buffer.put_u8(self.frame_reports.len() as u8);
28257         for elem in &self.frame_reports {
28258             elem.write_to(buffer)?;
28259         }
28260         Ok(())
28261     }
get_total_size(&self) -> usize28262     fn get_total_size(&self) -> usize {
28263         self.get_size()
28264     }
get_size(&self) -> usize28265     fn get_size(&self) -> usize {
28266         9 + self.frame_reports.iter().map(|elem| elem.get_size()).sum::<usize>()
28267     }
28268 }
28269 impl Packet for AndroidRangeDiagnosticsNtf {
encoded_len(&self) -> usize28270     fn encoded_len(&self) -> usize {
28271         self.get_size()
28272     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>28273     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
28274         self.ucicontrolpacket.write_to(buf)
28275     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>28276     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
28277         unimplemented!("Rust legacy does not implement full packet trait")
28278     }
28279 }
28280 impl TryFrom<AndroidRangeDiagnosticsNtf> for Bytes {
28281     type Error = EncodeError;
try_from(packet: AndroidRangeDiagnosticsNtf) -> Result<Self, Self::Error>28282     fn try_from(packet: AndroidRangeDiagnosticsNtf) -> Result<Self, Self::Error> {
28283         packet.encode_to_bytes()
28284     }
28285 }
28286 impl TryFrom<AndroidRangeDiagnosticsNtf> for Vec<u8> {
28287     type Error = EncodeError;
try_from(packet: AndroidRangeDiagnosticsNtf) -> Result<Self, Self::Error>28288     fn try_from(packet: AndroidRangeDiagnosticsNtf) -> Result<Self, Self::Error> {
28289         packet.encode_to_vec()
28290     }
28291 }
28292 impl From<AndroidRangeDiagnosticsNtf> for UciControlPacket {
from(packet: AndroidRangeDiagnosticsNtf) -> UciControlPacket28293     fn from(packet: AndroidRangeDiagnosticsNtf) -> UciControlPacket {
28294         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
28295     }
28296 }
28297 impl From<AndroidRangeDiagnosticsNtf> for UciNotification {
from(packet: AndroidRangeDiagnosticsNtf) -> UciNotification28298     fn from(packet: AndroidRangeDiagnosticsNtf) -> UciNotification {
28299         UciNotification::new(packet.ucicontrolpacket).unwrap()
28300     }
28301 }
28302 impl From<AndroidRangeDiagnosticsNtf> for AndroidNotification {
from(packet: AndroidRangeDiagnosticsNtf) -> AndroidNotification28303     fn from(packet: AndroidRangeDiagnosticsNtf) -> AndroidNotification {
28304         AndroidNotification::new(packet.ucicontrolpacket).unwrap()
28305     }
28306 }
28307 impl TryFrom<UciControlPacket> for AndroidRangeDiagnosticsNtf {
28308     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<AndroidRangeDiagnosticsNtf, Self::Error>28309     fn try_from(
28310         packet: UciControlPacket,
28311     ) -> Result<AndroidRangeDiagnosticsNtf, Self::Error> {
28312         AndroidRangeDiagnosticsNtf::new(packet.ucicontrolpacket)
28313     }
28314 }
28315 impl AndroidRangeDiagnosticsNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>28316     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
28317         let mut cell = Cell::new(bytes);
28318         let packet = Self::parse_inner(&mut cell)?;
28319         Ok(packet)
28320     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28321     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28322         let data = UciControlPacketData::parse_inner(&mut bytes)?;
28323         Self::new(data)
28324     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>28325     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
28326         let ucinotification = match &ucicontrolpacket.child {
28327             UciControlPacketDataChild::UciNotification(value) => value.clone(),
28328             _ => {
28329                 return Err(DecodeError::InvalidChildError {
28330                     expected: stringify!(UciControlPacketDataChild::UciNotification),
28331                     actual: format!("{:?}", & ucicontrolpacket.child),
28332                 });
28333             }
28334         };
28335         let androidnotification = match &ucinotification.child {
28336             UciNotificationDataChild::AndroidNotification(value) => value.clone(),
28337             _ => {
28338                 return Err(DecodeError::InvalidChildError {
28339                     expected: stringify!(UciNotificationDataChild::AndroidNotification),
28340                     actual: format!("{:?}", & ucinotification.child),
28341                 });
28342             }
28343         };
28344         let androidrangediagnosticsntf = match &androidnotification.child {
28345             AndroidNotificationDataChild::AndroidRangeDiagnosticsNtf(value) => {
28346                 value.clone()
28347             }
28348             _ => {
28349                 return Err(DecodeError::InvalidChildError {
28350                     expected: stringify!(
28351                         AndroidNotificationDataChild::AndroidRangeDiagnosticsNtf
28352                     ),
28353                     actual: format!("{:?}", & androidnotification.child),
28354                 });
28355             }
28356         };
28357         Ok(Self {
28358             ucicontrolpacket,
28359             ucinotification,
28360             androidnotification,
28361             androidrangediagnosticsntf,
28362         })
28363     }
get_frame_reports(&self) -> &Vec<FrameReport>28364     pub fn get_frame_reports(&self) -> &Vec<FrameReport> {
28365         &self.androidrangediagnosticsntf.frame_reports
28366     }
get_group_id(&self) -> GroupId28367     pub fn get_group_id(&self) -> GroupId {
28368         self.ucicontrolpacket.group_id
28369     }
get_message_type(&self) -> MessageType28370     pub fn get_message_type(&self) -> MessageType {
28371         self.ucicontrolpacket.message_type
28372     }
get_opcode(&self) -> u828373     pub fn get_opcode(&self) -> u8 {
28374         self.ucicontrolpacket.opcode
28375     }
get_sequence_number(&self) -> u3228376     pub fn get_sequence_number(&self) -> u32 {
28377         self.androidrangediagnosticsntf.sequence_number
28378     }
get_session_token(&self) -> u3228379     pub fn get_session_token(&self) -> u32 {
28380         self.androidrangediagnosticsntf.session_token
28381     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>28382     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
28383         self.androidrangediagnosticsntf.write_to(buffer)
28384     }
get_size(&self) -> usize28385     pub fn get_size(&self) -> usize {
28386         self.ucicontrolpacket.get_size()
28387     }
28388 }
28389 impl AndroidRangeDiagnosticsNtfBuilder {
build(self) -> AndroidRangeDiagnosticsNtf28390     pub fn build(self) -> AndroidRangeDiagnosticsNtf {
28391         let androidrangediagnosticsntf = AndroidRangeDiagnosticsNtfData {
28392             frame_reports: self.frame_reports,
28393             sequence_number: self.sequence_number,
28394             session_token: self.session_token,
28395         };
28396         let androidnotification = AndroidNotificationData {
28397             child: AndroidNotificationDataChild::AndroidRangeDiagnosticsNtf(
28398                 androidrangediagnosticsntf,
28399             ),
28400         };
28401         let ucinotification = UciNotificationData {
28402             child: UciNotificationDataChild::AndroidNotification(androidnotification),
28403         };
28404         let ucicontrolpacket = UciControlPacketData {
28405             group_id: GroupId::VendorAndroid,
28406             message_type: MessageType::Notification,
28407             opcode: 2,
28408             child: UciControlPacketDataChild::UciNotification(ucinotification),
28409         };
28410         AndroidRangeDiagnosticsNtf::new(ucicontrolpacket).unwrap()
28411     }
28412 }
28413 impl From<AndroidRangeDiagnosticsNtfBuilder> for UciControlPacket {
from(builder: AndroidRangeDiagnosticsNtfBuilder) -> UciControlPacket28414     fn from(builder: AndroidRangeDiagnosticsNtfBuilder) -> UciControlPacket {
28415         builder.build().into()
28416     }
28417 }
28418 impl From<AndroidRangeDiagnosticsNtfBuilder> for UciNotification {
from(builder: AndroidRangeDiagnosticsNtfBuilder) -> UciNotification28419     fn from(builder: AndroidRangeDiagnosticsNtfBuilder) -> UciNotification {
28420         builder.build().into()
28421     }
28422 }
28423 impl From<AndroidRangeDiagnosticsNtfBuilder> for AndroidNotification {
from(builder: AndroidRangeDiagnosticsNtfBuilder) -> AndroidNotification28424     fn from(builder: AndroidRangeDiagnosticsNtfBuilder) -> AndroidNotification {
28425         builder.build().into()
28426     }
28427 }
28428 impl From<AndroidRangeDiagnosticsNtfBuilder> for AndroidRangeDiagnosticsNtf {
from(builder: AndroidRangeDiagnosticsNtfBuilder) -> AndroidRangeDiagnosticsNtf28429     fn from(builder: AndroidRangeDiagnosticsNtfBuilder) -> AndroidRangeDiagnosticsNtf {
28430         builder.build().into()
28431     }
28432 }
28433 #[derive(Debug, Clone, PartialEq, Eq)]
28434 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28435 pub enum UciVendor_9_ResponseDataChild {
28436     Payload(Bytes),
28437     None,
28438 }
28439 impl UciVendor_9_ResponseDataChild {
get_total_size(&self) -> usize28440     fn get_total_size(&self) -> usize {
28441         match self {
28442             UciVendor_9_ResponseDataChild::Payload(bytes) => bytes.len(),
28443             UciVendor_9_ResponseDataChild::None => 0,
28444         }
28445     }
28446 }
28447 #[derive(Debug, Clone, PartialEq, Eq)]
28448 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28449 pub enum UciVendor_9_ResponseChild {
28450     Payload(Bytes),
28451     None,
28452 }
28453 #[derive(Debug, Clone, PartialEq, Eq)]
28454 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28455 pub struct UciVendor_9_ResponseData {
28456     child: UciVendor_9_ResponseDataChild,
28457 }
28458 #[derive(Debug, Clone, PartialEq, Eq)]
28459 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28460 pub struct UciVendor_9_Response {
28461     #[cfg_attr(feature = "serde", serde(flatten))]
28462     ucicontrolpacket: UciControlPacketData,
28463     #[cfg_attr(feature = "serde", serde(flatten))]
28464     uciresponse: UciResponseData,
28465     #[cfg_attr(feature = "serde", serde(flatten))]
28466     ucivendor_9_response: UciVendor_9_ResponseData,
28467 }
28468 #[derive(Debug)]
28469 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28470 pub struct UciVendor_9_ResponseBuilder {
28471     pub opcode: u8,
28472     pub payload: Option<Bytes>,
28473 }
28474 impl UciVendor_9_ResponseData {
conforms(bytes: &[u8]) -> bool28475     fn conforms(bytes: &[u8]) -> bool {
28476         true
28477     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>28478     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
28479         let mut cell = Cell::new(bytes);
28480         let packet = Self::parse_inner(&mut cell)?;
28481         Ok(packet)
28482     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28483     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28484         let payload = bytes.get();
28485         bytes.get_mut().advance(payload.len());
28486         let child = match () {
28487             _ if !payload.is_empty() => {
28488                 UciVendor_9_ResponseDataChild::Payload(Bytes::copy_from_slice(payload))
28489             }
28490             _ => UciVendor_9_ResponseDataChild::None,
28491         };
28492         Ok(Self { child })
28493     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>28494     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
28495         match &self.child {
28496             UciVendor_9_ResponseDataChild::Payload(payload) => buffer.put_slice(payload),
28497             UciVendor_9_ResponseDataChild::None => {}
28498         }
28499         Ok(())
28500     }
get_total_size(&self) -> usize28501     fn get_total_size(&self) -> usize {
28502         self.get_size()
28503     }
get_size(&self) -> usize28504     fn get_size(&self) -> usize {
28505         self.child.get_total_size()
28506     }
28507 }
28508 impl Packet for UciVendor_9_Response {
encoded_len(&self) -> usize28509     fn encoded_len(&self) -> usize {
28510         self.get_size()
28511     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>28512     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
28513         self.ucicontrolpacket.write_to(buf)
28514     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>28515     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
28516         unimplemented!("Rust legacy does not implement full packet trait")
28517     }
28518 }
28519 impl TryFrom<UciVendor_9_Response> for Bytes {
28520     type Error = EncodeError;
try_from(packet: UciVendor_9_Response) -> Result<Self, Self::Error>28521     fn try_from(packet: UciVendor_9_Response) -> Result<Self, Self::Error> {
28522         packet.encode_to_bytes()
28523     }
28524 }
28525 impl TryFrom<UciVendor_9_Response> for Vec<u8> {
28526     type Error = EncodeError;
try_from(packet: UciVendor_9_Response) -> Result<Self, Self::Error>28527     fn try_from(packet: UciVendor_9_Response) -> Result<Self, Self::Error> {
28528         packet.encode_to_vec()
28529     }
28530 }
28531 impl From<UciVendor_9_Response> for UciControlPacket {
from(packet: UciVendor_9_Response) -> UciControlPacket28532     fn from(packet: UciVendor_9_Response) -> UciControlPacket {
28533         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
28534     }
28535 }
28536 impl From<UciVendor_9_Response> for UciResponse {
from(packet: UciVendor_9_Response) -> UciResponse28537     fn from(packet: UciVendor_9_Response) -> UciResponse {
28538         UciResponse::new(packet.ucicontrolpacket).unwrap()
28539     }
28540 }
28541 impl TryFrom<UciControlPacket> for UciVendor_9_Response {
28542     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<UciVendor_9_Response, Self::Error>28543     fn try_from(packet: UciControlPacket) -> Result<UciVendor_9_Response, Self::Error> {
28544         UciVendor_9_Response::new(packet.ucicontrolpacket)
28545     }
28546 }
28547 impl UciVendor_9_Response {
parse(bytes: &[u8]) -> Result<Self, DecodeError>28548     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
28549         let mut cell = Cell::new(bytes);
28550         let packet = Self::parse_inner(&mut cell)?;
28551         Ok(packet)
28552     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28553     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28554         let data = UciControlPacketData::parse_inner(&mut bytes)?;
28555         Self::new(data)
28556     }
specialize(&self) -> UciVendor_9_ResponseChild28557     pub fn specialize(&self) -> UciVendor_9_ResponseChild {
28558         match &self.ucivendor_9_response.child {
28559             UciVendor_9_ResponseDataChild::Payload(payload) => {
28560                 UciVendor_9_ResponseChild::Payload(payload.clone())
28561             }
28562             UciVendor_9_ResponseDataChild::None => UciVendor_9_ResponseChild::None,
28563         }
28564     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>28565     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
28566         let uciresponse = match &ucicontrolpacket.child {
28567             UciControlPacketDataChild::UciResponse(value) => value.clone(),
28568             _ => {
28569                 return Err(DecodeError::InvalidChildError {
28570                     expected: stringify!(UciControlPacketDataChild::UciResponse),
28571                     actual: format!("{:?}", & ucicontrolpacket.child),
28572                 });
28573             }
28574         };
28575         let ucivendor_9_response = match &uciresponse.child {
28576             UciResponseDataChild::UciVendor_9_Response(value) => value.clone(),
28577             _ => {
28578                 return Err(DecodeError::InvalidChildError {
28579                     expected: stringify!(UciResponseDataChild::UciVendor_9_Response),
28580                     actual: format!("{:?}", & uciresponse.child),
28581                 });
28582             }
28583         };
28584         Ok(Self {
28585             ucicontrolpacket,
28586             uciresponse,
28587             ucivendor_9_response,
28588         })
28589     }
get_group_id(&self) -> GroupId28590     pub fn get_group_id(&self) -> GroupId {
28591         self.ucicontrolpacket.group_id
28592     }
get_message_type(&self) -> MessageType28593     pub fn get_message_type(&self) -> MessageType {
28594         self.ucicontrolpacket.message_type
28595     }
get_opcode(&self) -> u828596     pub fn get_opcode(&self) -> u8 {
28597         self.ucicontrolpacket.opcode
28598     }
get_payload(&self) -> &[u8]28599     pub fn get_payload(&self) -> &[u8] {
28600         match &self.ucivendor_9_response.child {
28601             UciVendor_9_ResponseDataChild::Payload(bytes) => &bytes,
28602             UciVendor_9_ResponseDataChild::None => &[],
28603         }
28604     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>28605     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
28606         self.ucivendor_9_response.write_to(buffer)
28607     }
get_size(&self) -> usize28608     pub fn get_size(&self) -> usize {
28609         self.ucicontrolpacket.get_size()
28610     }
28611 }
28612 impl UciVendor_9_ResponseBuilder {
build(self) -> UciVendor_9_Response28613     pub fn build(self) -> UciVendor_9_Response {
28614         let ucivendor_9_response = UciVendor_9_ResponseData {
28615             child: match self.payload {
28616                 None => UciVendor_9_ResponseDataChild::None,
28617                 Some(bytes) => UciVendor_9_ResponseDataChild::Payload(bytes),
28618             },
28619         };
28620         let uciresponse = UciResponseData {
28621             child: UciResponseDataChild::UciVendor_9_Response(ucivendor_9_response),
28622         };
28623         let ucicontrolpacket = UciControlPacketData {
28624             group_id: GroupId::VendorReserved9,
28625             message_type: MessageType::Response,
28626             opcode: self.opcode,
28627             child: UciControlPacketDataChild::UciResponse(uciresponse),
28628         };
28629         UciVendor_9_Response::new(ucicontrolpacket).unwrap()
28630     }
28631 }
28632 impl From<UciVendor_9_ResponseBuilder> for UciControlPacket {
from(builder: UciVendor_9_ResponseBuilder) -> UciControlPacket28633     fn from(builder: UciVendor_9_ResponseBuilder) -> UciControlPacket {
28634         builder.build().into()
28635     }
28636 }
28637 impl From<UciVendor_9_ResponseBuilder> for UciResponse {
from(builder: UciVendor_9_ResponseBuilder) -> UciResponse28638     fn from(builder: UciVendor_9_ResponseBuilder) -> UciResponse {
28639         builder.build().into()
28640     }
28641 }
28642 impl From<UciVendor_9_ResponseBuilder> for UciVendor_9_Response {
from(builder: UciVendor_9_ResponseBuilder) -> UciVendor_9_Response28643     fn from(builder: UciVendor_9_ResponseBuilder) -> UciVendor_9_Response {
28644         builder.build().into()
28645     }
28646 }
28647 #[derive(Debug, Clone, PartialEq, Eq)]
28648 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28649 pub enum UciVendor_A_ResponseDataChild {
28650     Payload(Bytes),
28651     None,
28652 }
28653 impl UciVendor_A_ResponseDataChild {
get_total_size(&self) -> usize28654     fn get_total_size(&self) -> usize {
28655         match self {
28656             UciVendor_A_ResponseDataChild::Payload(bytes) => bytes.len(),
28657             UciVendor_A_ResponseDataChild::None => 0,
28658         }
28659     }
28660 }
28661 #[derive(Debug, Clone, PartialEq, Eq)]
28662 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28663 pub enum UciVendor_A_ResponseChild {
28664     Payload(Bytes),
28665     None,
28666 }
28667 #[derive(Debug, Clone, PartialEq, Eq)]
28668 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28669 pub struct UciVendor_A_ResponseData {
28670     child: UciVendor_A_ResponseDataChild,
28671 }
28672 #[derive(Debug, Clone, PartialEq, Eq)]
28673 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28674 pub struct UciVendor_A_Response {
28675     #[cfg_attr(feature = "serde", serde(flatten))]
28676     ucicontrolpacket: UciControlPacketData,
28677     #[cfg_attr(feature = "serde", serde(flatten))]
28678     uciresponse: UciResponseData,
28679     #[cfg_attr(feature = "serde", serde(flatten))]
28680     ucivendor_a_response: UciVendor_A_ResponseData,
28681 }
28682 #[derive(Debug)]
28683 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28684 pub struct UciVendor_A_ResponseBuilder {
28685     pub opcode: u8,
28686     pub payload: Option<Bytes>,
28687 }
28688 impl UciVendor_A_ResponseData {
conforms(bytes: &[u8]) -> bool28689     fn conforms(bytes: &[u8]) -> bool {
28690         true
28691     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>28692     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
28693         let mut cell = Cell::new(bytes);
28694         let packet = Self::parse_inner(&mut cell)?;
28695         Ok(packet)
28696     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28697     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28698         let payload = bytes.get();
28699         bytes.get_mut().advance(payload.len());
28700         let child = match () {
28701             _ if !payload.is_empty() => {
28702                 UciVendor_A_ResponseDataChild::Payload(Bytes::copy_from_slice(payload))
28703             }
28704             _ => UciVendor_A_ResponseDataChild::None,
28705         };
28706         Ok(Self { child })
28707     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>28708     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
28709         match &self.child {
28710             UciVendor_A_ResponseDataChild::Payload(payload) => buffer.put_slice(payload),
28711             UciVendor_A_ResponseDataChild::None => {}
28712         }
28713         Ok(())
28714     }
get_total_size(&self) -> usize28715     fn get_total_size(&self) -> usize {
28716         self.get_size()
28717     }
get_size(&self) -> usize28718     fn get_size(&self) -> usize {
28719         self.child.get_total_size()
28720     }
28721 }
28722 impl Packet for UciVendor_A_Response {
encoded_len(&self) -> usize28723     fn encoded_len(&self) -> usize {
28724         self.get_size()
28725     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>28726     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
28727         self.ucicontrolpacket.write_to(buf)
28728     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>28729     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
28730         unimplemented!("Rust legacy does not implement full packet trait")
28731     }
28732 }
28733 impl TryFrom<UciVendor_A_Response> for Bytes {
28734     type Error = EncodeError;
try_from(packet: UciVendor_A_Response) -> Result<Self, Self::Error>28735     fn try_from(packet: UciVendor_A_Response) -> Result<Self, Self::Error> {
28736         packet.encode_to_bytes()
28737     }
28738 }
28739 impl TryFrom<UciVendor_A_Response> for Vec<u8> {
28740     type Error = EncodeError;
try_from(packet: UciVendor_A_Response) -> Result<Self, Self::Error>28741     fn try_from(packet: UciVendor_A_Response) -> Result<Self, Self::Error> {
28742         packet.encode_to_vec()
28743     }
28744 }
28745 impl From<UciVendor_A_Response> for UciControlPacket {
from(packet: UciVendor_A_Response) -> UciControlPacket28746     fn from(packet: UciVendor_A_Response) -> UciControlPacket {
28747         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
28748     }
28749 }
28750 impl From<UciVendor_A_Response> for UciResponse {
from(packet: UciVendor_A_Response) -> UciResponse28751     fn from(packet: UciVendor_A_Response) -> UciResponse {
28752         UciResponse::new(packet.ucicontrolpacket).unwrap()
28753     }
28754 }
28755 impl TryFrom<UciControlPacket> for UciVendor_A_Response {
28756     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<UciVendor_A_Response, Self::Error>28757     fn try_from(packet: UciControlPacket) -> Result<UciVendor_A_Response, Self::Error> {
28758         UciVendor_A_Response::new(packet.ucicontrolpacket)
28759     }
28760 }
28761 impl UciVendor_A_Response {
parse(bytes: &[u8]) -> Result<Self, DecodeError>28762     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
28763         let mut cell = Cell::new(bytes);
28764         let packet = Self::parse_inner(&mut cell)?;
28765         Ok(packet)
28766     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28767     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28768         let data = UciControlPacketData::parse_inner(&mut bytes)?;
28769         Self::new(data)
28770     }
specialize(&self) -> UciVendor_A_ResponseChild28771     pub fn specialize(&self) -> UciVendor_A_ResponseChild {
28772         match &self.ucivendor_a_response.child {
28773             UciVendor_A_ResponseDataChild::Payload(payload) => {
28774                 UciVendor_A_ResponseChild::Payload(payload.clone())
28775             }
28776             UciVendor_A_ResponseDataChild::None => UciVendor_A_ResponseChild::None,
28777         }
28778     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>28779     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
28780         let uciresponse = match &ucicontrolpacket.child {
28781             UciControlPacketDataChild::UciResponse(value) => value.clone(),
28782             _ => {
28783                 return Err(DecodeError::InvalidChildError {
28784                     expected: stringify!(UciControlPacketDataChild::UciResponse),
28785                     actual: format!("{:?}", & ucicontrolpacket.child),
28786                 });
28787             }
28788         };
28789         let ucivendor_a_response = match &uciresponse.child {
28790             UciResponseDataChild::UciVendor_A_Response(value) => value.clone(),
28791             _ => {
28792                 return Err(DecodeError::InvalidChildError {
28793                     expected: stringify!(UciResponseDataChild::UciVendor_A_Response),
28794                     actual: format!("{:?}", & uciresponse.child),
28795                 });
28796             }
28797         };
28798         Ok(Self {
28799             ucicontrolpacket,
28800             uciresponse,
28801             ucivendor_a_response,
28802         })
28803     }
get_group_id(&self) -> GroupId28804     pub fn get_group_id(&self) -> GroupId {
28805         self.ucicontrolpacket.group_id
28806     }
get_message_type(&self) -> MessageType28807     pub fn get_message_type(&self) -> MessageType {
28808         self.ucicontrolpacket.message_type
28809     }
get_opcode(&self) -> u828810     pub fn get_opcode(&self) -> u8 {
28811         self.ucicontrolpacket.opcode
28812     }
get_payload(&self) -> &[u8]28813     pub fn get_payload(&self) -> &[u8] {
28814         match &self.ucivendor_a_response.child {
28815             UciVendor_A_ResponseDataChild::Payload(bytes) => &bytes,
28816             UciVendor_A_ResponseDataChild::None => &[],
28817         }
28818     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>28819     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
28820         self.ucivendor_a_response.write_to(buffer)
28821     }
get_size(&self) -> usize28822     pub fn get_size(&self) -> usize {
28823         self.ucicontrolpacket.get_size()
28824     }
28825 }
28826 impl UciVendor_A_ResponseBuilder {
build(self) -> UciVendor_A_Response28827     pub fn build(self) -> UciVendor_A_Response {
28828         let ucivendor_a_response = UciVendor_A_ResponseData {
28829             child: match self.payload {
28830                 None => UciVendor_A_ResponseDataChild::None,
28831                 Some(bytes) => UciVendor_A_ResponseDataChild::Payload(bytes),
28832             },
28833         };
28834         let uciresponse = UciResponseData {
28835             child: UciResponseDataChild::UciVendor_A_Response(ucivendor_a_response),
28836         };
28837         let ucicontrolpacket = UciControlPacketData {
28838             group_id: GroupId::VendorReservedA,
28839             message_type: MessageType::Response,
28840             opcode: self.opcode,
28841             child: UciControlPacketDataChild::UciResponse(uciresponse),
28842         };
28843         UciVendor_A_Response::new(ucicontrolpacket).unwrap()
28844     }
28845 }
28846 impl From<UciVendor_A_ResponseBuilder> for UciControlPacket {
from(builder: UciVendor_A_ResponseBuilder) -> UciControlPacket28847     fn from(builder: UciVendor_A_ResponseBuilder) -> UciControlPacket {
28848         builder.build().into()
28849     }
28850 }
28851 impl From<UciVendor_A_ResponseBuilder> for UciResponse {
from(builder: UciVendor_A_ResponseBuilder) -> UciResponse28852     fn from(builder: UciVendor_A_ResponseBuilder) -> UciResponse {
28853         builder.build().into()
28854     }
28855 }
28856 impl From<UciVendor_A_ResponseBuilder> for UciVendor_A_Response {
from(builder: UciVendor_A_ResponseBuilder) -> UciVendor_A_Response28857     fn from(builder: UciVendor_A_ResponseBuilder) -> UciVendor_A_Response {
28858         builder.build().into()
28859     }
28860 }
28861 #[derive(Debug, Clone, PartialEq, Eq)]
28862 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28863 pub enum UciVendor_B_ResponseDataChild {
28864     Payload(Bytes),
28865     None,
28866 }
28867 impl UciVendor_B_ResponseDataChild {
get_total_size(&self) -> usize28868     fn get_total_size(&self) -> usize {
28869         match self {
28870             UciVendor_B_ResponseDataChild::Payload(bytes) => bytes.len(),
28871             UciVendor_B_ResponseDataChild::None => 0,
28872         }
28873     }
28874 }
28875 #[derive(Debug, Clone, PartialEq, Eq)]
28876 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28877 pub enum UciVendor_B_ResponseChild {
28878     Payload(Bytes),
28879     None,
28880 }
28881 #[derive(Debug, Clone, PartialEq, Eq)]
28882 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28883 pub struct UciVendor_B_ResponseData {
28884     child: UciVendor_B_ResponseDataChild,
28885 }
28886 #[derive(Debug, Clone, PartialEq, Eq)]
28887 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28888 pub struct UciVendor_B_Response {
28889     #[cfg_attr(feature = "serde", serde(flatten))]
28890     ucicontrolpacket: UciControlPacketData,
28891     #[cfg_attr(feature = "serde", serde(flatten))]
28892     uciresponse: UciResponseData,
28893     #[cfg_attr(feature = "serde", serde(flatten))]
28894     ucivendor_b_response: UciVendor_B_ResponseData,
28895 }
28896 #[derive(Debug)]
28897 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28898 pub struct UciVendor_B_ResponseBuilder {
28899     pub opcode: u8,
28900     pub payload: Option<Bytes>,
28901 }
28902 impl UciVendor_B_ResponseData {
conforms(bytes: &[u8]) -> bool28903     fn conforms(bytes: &[u8]) -> bool {
28904         true
28905     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>28906     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
28907         let mut cell = Cell::new(bytes);
28908         let packet = Self::parse_inner(&mut cell)?;
28909         Ok(packet)
28910     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28911     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28912         let payload = bytes.get();
28913         bytes.get_mut().advance(payload.len());
28914         let child = match () {
28915             _ if !payload.is_empty() => {
28916                 UciVendor_B_ResponseDataChild::Payload(Bytes::copy_from_slice(payload))
28917             }
28918             _ => UciVendor_B_ResponseDataChild::None,
28919         };
28920         Ok(Self { child })
28921     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>28922     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
28923         match &self.child {
28924             UciVendor_B_ResponseDataChild::Payload(payload) => buffer.put_slice(payload),
28925             UciVendor_B_ResponseDataChild::None => {}
28926         }
28927         Ok(())
28928     }
get_total_size(&self) -> usize28929     fn get_total_size(&self) -> usize {
28930         self.get_size()
28931     }
get_size(&self) -> usize28932     fn get_size(&self) -> usize {
28933         self.child.get_total_size()
28934     }
28935 }
28936 impl Packet for UciVendor_B_Response {
encoded_len(&self) -> usize28937     fn encoded_len(&self) -> usize {
28938         self.get_size()
28939     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>28940     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
28941         self.ucicontrolpacket.write_to(buf)
28942     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>28943     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
28944         unimplemented!("Rust legacy does not implement full packet trait")
28945     }
28946 }
28947 impl TryFrom<UciVendor_B_Response> for Bytes {
28948     type Error = EncodeError;
try_from(packet: UciVendor_B_Response) -> Result<Self, Self::Error>28949     fn try_from(packet: UciVendor_B_Response) -> Result<Self, Self::Error> {
28950         packet.encode_to_bytes()
28951     }
28952 }
28953 impl TryFrom<UciVendor_B_Response> for Vec<u8> {
28954     type Error = EncodeError;
try_from(packet: UciVendor_B_Response) -> Result<Self, Self::Error>28955     fn try_from(packet: UciVendor_B_Response) -> Result<Self, Self::Error> {
28956         packet.encode_to_vec()
28957     }
28958 }
28959 impl From<UciVendor_B_Response> for UciControlPacket {
from(packet: UciVendor_B_Response) -> UciControlPacket28960     fn from(packet: UciVendor_B_Response) -> UciControlPacket {
28961         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
28962     }
28963 }
28964 impl From<UciVendor_B_Response> for UciResponse {
from(packet: UciVendor_B_Response) -> UciResponse28965     fn from(packet: UciVendor_B_Response) -> UciResponse {
28966         UciResponse::new(packet.ucicontrolpacket).unwrap()
28967     }
28968 }
28969 impl TryFrom<UciControlPacket> for UciVendor_B_Response {
28970     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<UciVendor_B_Response, Self::Error>28971     fn try_from(packet: UciControlPacket) -> Result<UciVendor_B_Response, Self::Error> {
28972         UciVendor_B_Response::new(packet.ucicontrolpacket)
28973     }
28974 }
28975 impl UciVendor_B_Response {
parse(bytes: &[u8]) -> Result<Self, DecodeError>28976     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
28977         let mut cell = Cell::new(bytes);
28978         let packet = Self::parse_inner(&mut cell)?;
28979         Ok(packet)
28980     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>28981     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
28982         let data = UciControlPacketData::parse_inner(&mut bytes)?;
28983         Self::new(data)
28984     }
specialize(&self) -> UciVendor_B_ResponseChild28985     pub fn specialize(&self) -> UciVendor_B_ResponseChild {
28986         match &self.ucivendor_b_response.child {
28987             UciVendor_B_ResponseDataChild::Payload(payload) => {
28988                 UciVendor_B_ResponseChild::Payload(payload.clone())
28989             }
28990             UciVendor_B_ResponseDataChild::None => UciVendor_B_ResponseChild::None,
28991         }
28992     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>28993     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
28994         let uciresponse = match &ucicontrolpacket.child {
28995             UciControlPacketDataChild::UciResponse(value) => value.clone(),
28996             _ => {
28997                 return Err(DecodeError::InvalidChildError {
28998                     expected: stringify!(UciControlPacketDataChild::UciResponse),
28999                     actual: format!("{:?}", & ucicontrolpacket.child),
29000                 });
29001             }
29002         };
29003         let ucivendor_b_response = match &uciresponse.child {
29004             UciResponseDataChild::UciVendor_B_Response(value) => value.clone(),
29005             _ => {
29006                 return Err(DecodeError::InvalidChildError {
29007                     expected: stringify!(UciResponseDataChild::UciVendor_B_Response),
29008                     actual: format!("{:?}", & uciresponse.child),
29009                 });
29010             }
29011         };
29012         Ok(Self {
29013             ucicontrolpacket,
29014             uciresponse,
29015             ucivendor_b_response,
29016         })
29017     }
get_group_id(&self) -> GroupId29018     pub fn get_group_id(&self) -> GroupId {
29019         self.ucicontrolpacket.group_id
29020     }
get_message_type(&self) -> MessageType29021     pub fn get_message_type(&self) -> MessageType {
29022         self.ucicontrolpacket.message_type
29023     }
get_opcode(&self) -> u829024     pub fn get_opcode(&self) -> u8 {
29025         self.ucicontrolpacket.opcode
29026     }
get_payload(&self) -> &[u8]29027     pub fn get_payload(&self) -> &[u8] {
29028         match &self.ucivendor_b_response.child {
29029             UciVendor_B_ResponseDataChild::Payload(bytes) => &bytes,
29030             UciVendor_B_ResponseDataChild::None => &[],
29031         }
29032     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>29033     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
29034         self.ucivendor_b_response.write_to(buffer)
29035     }
get_size(&self) -> usize29036     pub fn get_size(&self) -> usize {
29037         self.ucicontrolpacket.get_size()
29038     }
29039 }
29040 impl UciVendor_B_ResponseBuilder {
build(self) -> UciVendor_B_Response29041     pub fn build(self) -> UciVendor_B_Response {
29042         let ucivendor_b_response = UciVendor_B_ResponseData {
29043             child: match self.payload {
29044                 None => UciVendor_B_ResponseDataChild::None,
29045                 Some(bytes) => UciVendor_B_ResponseDataChild::Payload(bytes),
29046             },
29047         };
29048         let uciresponse = UciResponseData {
29049             child: UciResponseDataChild::UciVendor_B_Response(ucivendor_b_response),
29050         };
29051         let ucicontrolpacket = UciControlPacketData {
29052             group_id: GroupId::VendorReservedB,
29053             message_type: MessageType::Response,
29054             opcode: self.opcode,
29055             child: UciControlPacketDataChild::UciResponse(uciresponse),
29056         };
29057         UciVendor_B_Response::new(ucicontrolpacket).unwrap()
29058     }
29059 }
29060 impl From<UciVendor_B_ResponseBuilder> for UciControlPacket {
from(builder: UciVendor_B_ResponseBuilder) -> UciControlPacket29061     fn from(builder: UciVendor_B_ResponseBuilder) -> UciControlPacket {
29062         builder.build().into()
29063     }
29064 }
29065 impl From<UciVendor_B_ResponseBuilder> for UciResponse {
from(builder: UciVendor_B_ResponseBuilder) -> UciResponse29066     fn from(builder: UciVendor_B_ResponseBuilder) -> UciResponse {
29067         builder.build().into()
29068     }
29069 }
29070 impl From<UciVendor_B_ResponseBuilder> for UciVendor_B_Response {
from(builder: UciVendor_B_ResponseBuilder) -> UciVendor_B_Response29071     fn from(builder: UciVendor_B_ResponseBuilder) -> UciVendor_B_Response {
29072         builder.build().into()
29073     }
29074 }
29075 #[derive(Debug, Clone, PartialEq, Eq)]
29076 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29077 pub enum UciVendor_E_ResponseDataChild {
29078     Payload(Bytes),
29079     None,
29080 }
29081 impl UciVendor_E_ResponseDataChild {
get_total_size(&self) -> usize29082     fn get_total_size(&self) -> usize {
29083         match self {
29084             UciVendor_E_ResponseDataChild::Payload(bytes) => bytes.len(),
29085             UciVendor_E_ResponseDataChild::None => 0,
29086         }
29087     }
29088 }
29089 #[derive(Debug, Clone, PartialEq, Eq)]
29090 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29091 pub enum UciVendor_E_ResponseChild {
29092     Payload(Bytes),
29093     None,
29094 }
29095 #[derive(Debug, Clone, PartialEq, Eq)]
29096 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29097 pub struct UciVendor_E_ResponseData {
29098     child: UciVendor_E_ResponseDataChild,
29099 }
29100 #[derive(Debug, Clone, PartialEq, Eq)]
29101 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29102 pub struct UciVendor_E_Response {
29103     #[cfg_attr(feature = "serde", serde(flatten))]
29104     ucicontrolpacket: UciControlPacketData,
29105     #[cfg_attr(feature = "serde", serde(flatten))]
29106     uciresponse: UciResponseData,
29107     #[cfg_attr(feature = "serde", serde(flatten))]
29108     ucivendor_e_response: UciVendor_E_ResponseData,
29109 }
29110 #[derive(Debug)]
29111 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29112 pub struct UciVendor_E_ResponseBuilder {
29113     pub opcode: u8,
29114     pub payload: Option<Bytes>,
29115 }
29116 impl UciVendor_E_ResponseData {
conforms(bytes: &[u8]) -> bool29117     fn conforms(bytes: &[u8]) -> bool {
29118         true
29119     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>29120     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
29121         let mut cell = Cell::new(bytes);
29122         let packet = Self::parse_inner(&mut cell)?;
29123         Ok(packet)
29124     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>29125     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
29126         let payload = bytes.get();
29127         bytes.get_mut().advance(payload.len());
29128         let child = match () {
29129             _ if !payload.is_empty() => {
29130                 UciVendor_E_ResponseDataChild::Payload(Bytes::copy_from_slice(payload))
29131             }
29132             _ => UciVendor_E_ResponseDataChild::None,
29133         };
29134         Ok(Self { child })
29135     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>29136     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
29137         match &self.child {
29138             UciVendor_E_ResponseDataChild::Payload(payload) => buffer.put_slice(payload),
29139             UciVendor_E_ResponseDataChild::None => {}
29140         }
29141         Ok(())
29142     }
get_total_size(&self) -> usize29143     fn get_total_size(&self) -> usize {
29144         self.get_size()
29145     }
get_size(&self) -> usize29146     fn get_size(&self) -> usize {
29147         self.child.get_total_size()
29148     }
29149 }
29150 impl Packet for UciVendor_E_Response {
encoded_len(&self) -> usize29151     fn encoded_len(&self) -> usize {
29152         self.get_size()
29153     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>29154     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
29155         self.ucicontrolpacket.write_to(buf)
29156     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>29157     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
29158         unimplemented!("Rust legacy does not implement full packet trait")
29159     }
29160 }
29161 impl TryFrom<UciVendor_E_Response> for Bytes {
29162     type Error = EncodeError;
try_from(packet: UciVendor_E_Response) -> Result<Self, Self::Error>29163     fn try_from(packet: UciVendor_E_Response) -> Result<Self, Self::Error> {
29164         packet.encode_to_bytes()
29165     }
29166 }
29167 impl TryFrom<UciVendor_E_Response> for Vec<u8> {
29168     type Error = EncodeError;
try_from(packet: UciVendor_E_Response) -> Result<Self, Self::Error>29169     fn try_from(packet: UciVendor_E_Response) -> Result<Self, Self::Error> {
29170         packet.encode_to_vec()
29171     }
29172 }
29173 impl From<UciVendor_E_Response> for UciControlPacket {
from(packet: UciVendor_E_Response) -> UciControlPacket29174     fn from(packet: UciVendor_E_Response) -> UciControlPacket {
29175         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
29176     }
29177 }
29178 impl From<UciVendor_E_Response> for UciResponse {
from(packet: UciVendor_E_Response) -> UciResponse29179     fn from(packet: UciVendor_E_Response) -> UciResponse {
29180         UciResponse::new(packet.ucicontrolpacket).unwrap()
29181     }
29182 }
29183 impl TryFrom<UciControlPacket> for UciVendor_E_Response {
29184     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<UciVendor_E_Response, Self::Error>29185     fn try_from(packet: UciControlPacket) -> Result<UciVendor_E_Response, Self::Error> {
29186         UciVendor_E_Response::new(packet.ucicontrolpacket)
29187     }
29188 }
29189 impl UciVendor_E_Response {
parse(bytes: &[u8]) -> Result<Self, DecodeError>29190     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
29191         let mut cell = Cell::new(bytes);
29192         let packet = Self::parse_inner(&mut cell)?;
29193         Ok(packet)
29194     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>29195     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
29196         let data = UciControlPacketData::parse_inner(&mut bytes)?;
29197         Self::new(data)
29198     }
specialize(&self) -> UciVendor_E_ResponseChild29199     pub fn specialize(&self) -> UciVendor_E_ResponseChild {
29200         match &self.ucivendor_e_response.child {
29201             UciVendor_E_ResponseDataChild::Payload(payload) => {
29202                 UciVendor_E_ResponseChild::Payload(payload.clone())
29203             }
29204             UciVendor_E_ResponseDataChild::None => UciVendor_E_ResponseChild::None,
29205         }
29206     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>29207     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
29208         let uciresponse = match &ucicontrolpacket.child {
29209             UciControlPacketDataChild::UciResponse(value) => value.clone(),
29210             _ => {
29211                 return Err(DecodeError::InvalidChildError {
29212                     expected: stringify!(UciControlPacketDataChild::UciResponse),
29213                     actual: format!("{:?}", & ucicontrolpacket.child),
29214                 });
29215             }
29216         };
29217         let ucivendor_e_response = match &uciresponse.child {
29218             UciResponseDataChild::UciVendor_E_Response(value) => value.clone(),
29219             _ => {
29220                 return Err(DecodeError::InvalidChildError {
29221                     expected: stringify!(UciResponseDataChild::UciVendor_E_Response),
29222                     actual: format!("{:?}", & uciresponse.child),
29223                 });
29224             }
29225         };
29226         Ok(Self {
29227             ucicontrolpacket,
29228             uciresponse,
29229             ucivendor_e_response,
29230         })
29231     }
get_group_id(&self) -> GroupId29232     pub fn get_group_id(&self) -> GroupId {
29233         self.ucicontrolpacket.group_id
29234     }
get_message_type(&self) -> MessageType29235     pub fn get_message_type(&self) -> MessageType {
29236         self.ucicontrolpacket.message_type
29237     }
get_opcode(&self) -> u829238     pub fn get_opcode(&self) -> u8 {
29239         self.ucicontrolpacket.opcode
29240     }
get_payload(&self) -> &[u8]29241     pub fn get_payload(&self) -> &[u8] {
29242         match &self.ucivendor_e_response.child {
29243             UciVendor_E_ResponseDataChild::Payload(bytes) => &bytes,
29244             UciVendor_E_ResponseDataChild::None => &[],
29245         }
29246     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>29247     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
29248         self.ucivendor_e_response.write_to(buffer)
29249     }
get_size(&self) -> usize29250     pub fn get_size(&self) -> usize {
29251         self.ucicontrolpacket.get_size()
29252     }
29253 }
29254 impl UciVendor_E_ResponseBuilder {
build(self) -> UciVendor_E_Response29255     pub fn build(self) -> UciVendor_E_Response {
29256         let ucivendor_e_response = UciVendor_E_ResponseData {
29257             child: match self.payload {
29258                 None => UciVendor_E_ResponseDataChild::None,
29259                 Some(bytes) => UciVendor_E_ResponseDataChild::Payload(bytes),
29260             },
29261         };
29262         let uciresponse = UciResponseData {
29263             child: UciResponseDataChild::UciVendor_E_Response(ucivendor_e_response),
29264         };
29265         let ucicontrolpacket = UciControlPacketData {
29266             group_id: GroupId::VendorReservedE,
29267             message_type: MessageType::Response,
29268             opcode: self.opcode,
29269             child: UciControlPacketDataChild::UciResponse(uciresponse),
29270         };
29271         UciVendor_E_Response::new(ucicontrolpacket).unwrap()
29272     }
29273 }
29274 impl From<UciVendor_E_ResponseBuilder> for UciControlPacket {
from(builder: UciVendor_E_ResponseBuilder) -> UciControlPacket29275     fn from(builder: UciVendor_E_ResponseBuilder) -> UciControlPacket {
29276         builder.build().into()
29277     }
29278 }
29279 impl From<UciVendor_E_ResponseBuilder> for UciResponse {
from(builder: UciVendor_E_ResponseBuilder) -> UciResponse29280     fn from(builder: UciVendor_E_ResponseBuilder) -> UciResponse {
29281         builder.build().into()
29282     }
29283 }
29284 impl From<UciVendor_E_ResponseBuilder> for UciVendor_E_Response {
from(builder: UciVendor_E_ResponseBuilder) -> UciVendor_E_Response29285     fn from(builder: UciVendor_E_ResponseBuilder) -> UciVendor_E_Response {
29286         builder.build().into()
29287     }
29288 }
29289 #[derive(Debug, Clone, PartialEq, Eq)]
29290 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29291 pub enum UciVendor_F_ResponseDataChild {
29292     Payload(Bytes),
29293     None,
29294 }
29295 impl UciVendor_F_ResponseDataChild {
get_total_size(&self) -> usize29296     fn get_total_size(&self) -> usize {
29297         match self {
29298             UciVendor_F_ResponseDataChild::Payload(bytes) => bytes.len(),
29299             UciVendor_F_ResponseDataChild::None => 0,
29300         }
29301     }
29302 }
29303 #[derive(Debug, Clone, PartialEq, Eq)]
29304 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29305 pub enum UciVendor_F_ResponseChild {
29306     Payload(Bytes),
29307     None,
29308 }
29309 #[derive(Debug, Clone, PartialEq, Eq)]
29310 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29311 pub struct UciVendor_F_ResponseData {
29312     child: UciVendor_F_ResponseDataChild,
29313 }
29314 #[derive(Debug, Clone, PartialEq, Eq)]
29315 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29316 pub struct UciVendor_F_Response {
29317     #[cfg_attr(feature = "serde", serde(flatten))]
29318     ucicontrolpacket: UciControlPacketData,
29319     #[cfg_attr(feature = "serde", serde(flatten))]
29320     uciresponse: UciResponseData,
29321     #[cfg_attr(feature = "serde", serde(flatten))]
29322     ucivendor_f_response: UciVendor_F_ResponseData,
29323 }
29324 #[derive(Debug)]
29325 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29326 pub struct UciVendor_F_ResponseBuilder {
29327     pub opcode: u8,
29328     pub payload: Option<Bytes>,
29329 }
29330 impl UciVendor_F_ResponseData {
conforms(bytes: &[u8]) -> bool29331     fn conforms(bytes: &[u8]) -> bool {
29332         true
29333     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>29334     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
29335         let mut cell = Cell::new(bytes);
29336         let packet = Self::parse_inner(&mut cell)?;
29337         Ok(packet)
29338     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>29339     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
29340         let payload = bytes.get();
29341         bytes.get_mut().advance(payload.len());
29342         let child = match () {
29343             _ if !payload.is_empty() => {
29344                 UciVendor_F_ResponseDataChild::Payload(Bytes::copy_from_slice(payload))
29345             }
29346             _ => UciVendor_F_ResponseDataChild::None,
29347         };
29348         Ok(Self { child })
29349     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>29350     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
29351         match &self.child {
29352             UciVendor_F_ResponseDataChild::Payload(payload) => buffer.put_slice(payload),
29353             UciVendor_F_ResponseDataChild::None => {}
29354         }
29355         Ok(())
29356     }
get_total_size(&self) -> usize29357     fn get_total_size(&self) -> usize {
29358         self.get_size()
29359     }
get_size(&self) -> usize29360     fn get_size(&self) -> usize {
29361         self.child.get_total_size()
29362     }
29363 }
29364 impl Packet for UciVendor_F_Response {
encoded_len(&self) -> usize29365     fn encoded_len(&self) -> usize {
29366         self.get_size()
29367     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>29368     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
29369         self.ucicontrolpacket.write_to(buf)
29370     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>29371     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
29372         unimplemented!("Rust legacy does not implement full packet trait")
29373     }
29374 }
29375 impl TryFrom<UciVendor_F_Response> for Bytes {
29376     type Error = EncodeError;
try_from(packet: UciVendor_F_Response) -> Result<Self, Self::Error>29377     fn try_from(packet: UciVendor_F_Response) -> Result<Self, Self::Error> {
29378         packet.encode_to_bytes()
29379     }
29380 }
29381 impl TryFrom<UciVendor_F_Response> for Vec<u8> {
29382     type Error = EncodeError;
try_from(packet: UciVendor_F_Response) -> Result<Self, Self::Error>29383     fn try_from(packet: UciVendor_F_Response) -> Result<Self, Self::Error> {
29384         packet.encode_to_vec()
29385     }
29386 }
29387 impl From<UciVendor_F_Response> for UciControlPacket {
from(packet: UciVendor_F_Response) -> UciControlPacket29388     fn from(packet: UciVendor_F_Response) -> UciControlPacket {
29389         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
29390     }
29391 }
29392 impl From<UciVendor_F_Response> for UciResponse {
from(packet: UciVendor_F_Response) -> UciResponse29393     fn from(packet: UciVendor_F_Response) -> UciResponse {
29394         UciResponse::new(packet.ucicontrolpacket).unwrap()
29395     }
29396 }
29397 impl TryFrom<UciControlPacket> for UciVendor_F_Response {
29398     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<UciVendor_F_Response, Self::Error>29399     fn try_from(packet: UciControlPacket) -> Result<UciVendor_F_Response, Self::Error> {
29400         UciVendor_F_Response::new(packet.ucicontrolpacket)
29401     }
29402 }
29403 impl UciVendor_F_Response {
parse(bytes: &[u8]) -> Result<Self, DecodeError>29404     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
29405         let mut cell = Cell::new(bytes);
29406         let packet = Self::parse_inner(&mut cell)?;
29407         Ok(packet)
29408     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>29409     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
29410         let data = UciControlPacketData::parse_inner(&mut bytes)?;
29411         Self::new(data)
29412     }
specialize(&self) -> UciVendor_F_ResponseChild29413     pub fn specialize(&self) -> UciVendor_F_ResponseChild {
29414         match &self.ucivendor_f_response.child {
29415             UciVendor_F_ResponseDataChild::Payload(payload) => {
29416                 UciVendor_F_ResponseChild::Payload(payload.clone())
29417             }
29418             UciVendor_F_ResponseDataChild::None => UciVendor_F_ResponseChild::None,
29419         }
29420     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>29421     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
29422         let uciresponse = match &ucicontrolpacket.child {
29423             UciControlPacketDataChild::UciResponse(value) => value.clone(),
29424             _ => {
29425                 return Err(DecodeError::InvalidChildError {
29426                     expected: stringify!(UciControlPacketDataChild::UciResponse),
29427                     actual: format!("{:?}", & ucicontrolpacket.child),
29428                 });
29429             }
29430         };
29431         let ucivendor_f_response = match &uciresponse.child {
29432             UciResponseDataChild::UciVendor_F_Response(value) => value.clone(),
29433             _ => {
29434                 return Err(DecodeError::InvalidChildError {
29435                     expected: stringify!(UciResponseDataChild::UciVendor_F_Response),
29436                     actual: format!("{:?}", & uciresponse.child),
29437                 });
29438             }
29439         };
29440         Ok(Self {
29441             ucicontrolpacket,
29442             uciresponse,
29443             ucivendor_f_response,
29444         })
29445     }
get_group_id(&self) -> GroupId29446     pub fn get_group_id(&self) -> GroupId {
29447         self.ucicontrolpacket.group_id
29448     }
get_message_type(&self) -> MessageType29449     pub fn get_message_type(&self) -> MessageType {
29450         self.ucicontrolpacket.message_type
29451     }
get_opcode(&self) -> u829452     pub fn get_opcode(&self) -> u8 {
29453         self.ucicontrolpacket.opcode
29454     }
get_payload(&self) -> &[u8]29455     pub fn get_payload(&self) -> &[u8] {
29456         match &self.ucivendor_f_response.child {
29457             UciVendor_F_ResponseDataChild::Payload(bytes) => &bytes,
29458             UciVendor_F_ResponseDataChild::None => &[],
29459         }
29460     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>29461     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
29462         self.ucivendor_f_response.write_to(buffer)
29463     }
get_size(&self) -> usize29464     pub fn get_size(&self) -> usize {
29465         self.ucicontrolpacket.get_size()
29466     }
29467 }
29468 impl UciVendor_F_ResponseBuilder {
build(self) -> UciVendor_F_Response29469     pub fn build(self) -> UciVendor_F_Response {
29470         let ucivendor_f_response = UciVendor_F_ResponseData {
29471             child: match self.payload {
29472                 None => UciVendor_F_ResponseDataChild::None,
29473                 Some(bytes) => UciVendor_F_ResponseDataChild::Payload(bytes),
29474             },
29475         };
29476         let uciresponse = UciResponseData {
29477             child: UciResponseDataChild::UciVendor_F_Response(ucivendor_f_response),
29478         };
29479         let ucicontrolpacket = UciControlPacketData {
29480             group_id: GroupId::VendorReservedF,
29481             message_type: MessageType::Response,
29482             opcode: self.opcode,
29483             child: UciControlPacketDataChild::UciResponse(uciresponse),
29484         };
29485         UciVendor_F_Response::new(ucicontrolpacket).unwrap()
29486     }
29487 }
29488 impl From<UciVendor_F_ResponseBuilder> for UciControlPacket {
from(builder: UciVendor_F_ResponseBuilder) -> UciControlPacket29489     fn from(builder: UciVendor_F_ResponseBuilder) -> UciControlPacket {
29490         builder.build().into()
29491     }
29492 }
29493 impl From<UciVendor_F_ResponseBuilder> for UciResponse {
from(builder: UciVendor_F_ResponseBuilder) -> UciResponse29494     fn from(builder: UciVendor_F_ResponseBuilder) -> UciResponse {
29495         builder.build().into()
29496     }
29497 }
29498 impl From<UciVendor_F_ResponseBuilder> for UciVendor_F_Response {
from(builder: UciVendor_F_ResponseBuilder) -> UciVendor_F_Response29499     fn from(builder: UciVendor_F_ResponseBuilder) -> UciVendor_F_Response {
29500         builder.build().into()
29501     }
29502 }
29503 #[derive(Debug, Clone, PartialEq, Eq)]
29504 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29505 pub enum UciVendor_9_NotificationDataChild {
29506     Payload(Bytes),
29507     None,
29508 }
29509 impl UciVendor_9_NotificationDataChild {
get_total_size(&self) -> usize29510     fn get_total_size(&self) -> usize {
29511         match self {
29512             UciVendor_9_NotificationDataChild::Payload(bytes) => bytes.len(),
29513             UciVendor_9_NotificationDataChild::None => 0,
29514         }
29515     }
29516 }
29517 #[derive(Debug, Clone, PartialEq, Eq)]
29518 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29519 pub enum UciVendor_9_NotificationChild {
29520     Payload(Bytes),
29521     None,
29522 }
29523 #[derive(Debug, Clone, PartialEq, Eq)]
29524 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29525 pub struct UciVendor_9_NotificationData {
29526     child: UciVendor_9_NotificationDataChild,
29527 }
29528 #[derive(Debug, Clone, PartialEq, Eq)]
29529 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29530 pub struct UciVendor_9_Notification {
29531     #[cfg_attr(feature = "serde", serde(flatten))]
29532     ucicontrolpacket: UciControlPacketData,
29533     #[cfg_attr(feature = "serde", serde(flatten))]
29534     ucinotification: UciNotificationData,
29535     #[cfg_attr(feature = "serde", serde(flatten))]
29536     ucivendor_9_notification: UciVendor_9_NotificationData,
29537 }
29538 #[derive(Debug)]
29539 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29540 pub struct UciVendor_9_NotificationBuilder {
29541     pub opcode: u8,
29542     pub payload: Option<Bytes>,
29543 }
29544 impl UciVendor_9_NotificationData {
conforms(bytes: &[u8]) -> bool29545     fn conforms(bytes: &[u8]) -> bool {
29546         true
29547     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>29548     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
29549         let mut cell = Cell::new(bytes);
29550         let packet = Self::parse_inner(&mut cell)?;
29551         Ok(packet)
29552     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>29553     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
29554         let payload = bytes.get();
29555         bytes.get_mut().advance(payload.len());
29556         let child = match () {
29557             _ if !payload.is_empty() => {
29558                 UciVendor_9_NotificationDataChild::Payload(
29559                     Bytes::copy_from_slice(payload),
29560                 )
29561             }
29562             _ => UciVendor_9_NotificationDataChild::None,
29563         };
29564         Ok(Self { child })
29565     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>29566     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
29567         match &self.child {
29568             UciVendor_9_NotificationDataChild::Payload(payload) => {
29569                 buffer.put_slice(payload)
29570             }
29571             UciVendor_9_NotificationDataChild::None => {}
29572         }
29573         Ok(())
29574     }
get_total_size(&self) -> usize29575     fn get_total_size(&self) -> usize {
29576         self.get_size()
29577     }
get_size(&self) -> usize29578     fn get_size(&self) -> usize {
29579         self.child.get_total_size()
29580     }
29581 }
29582 impl Packet for UciVendor_9_Notification {
encoded_len(&self) -> usize29583     fn encoded_len(&self) -> usize {
29584         self.get_size()
29585     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>29586     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
29587         self.ucicontrolpacket.write_to(buf)
29588     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>29589     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
29590         unimplemented!("Rust legacy does not implement full packet trait")
29591     }
29592 }
29593 impl TryFrom<UciVendor_9_Notification> for Bytes {
29594     type Error = EncodeError;
try_from(packet: UciVendor_9_Notification) -> Result<Self, Self::Error>29595     fn try_from(packet: UciVendor_9_Notification) -> Result<Self, Self::Error> {
29596         packet.encode_to_bytes()
29597     }
29598 }
29599 impl TryFrom<UciVendor_9_Notification> for Vec<u8> {
29600     type Error = EncodeError;
try_from(packet: UciVendor_9_Notification) -> Result<Self, Self::Error>29601     fn try_from(packet: UciVendor_9_Notification) -> Result<Self, Self::Error> {
29602         packet.encode_to_vec()
29603     }
29604 }
29605 impl From<UciVendor_9_Notification> for UciControlPacket {
from(packet: UciVendor_9_Notification) -> UciControlPacket29606     fn from(packet: UciVendor_9_Notification) -> UciControlPacket {
29607         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
29608     }
29609 }
29610 impl From<UciVendor_9_Notification> for UciNotification {
from(packet: UciVendor_9_Notification) -> UciNotification29611     fn from(packet: UciVendor_9_Notification) -> UciNotification {
29612         UciNotification::new(packet.ucicontrolpacket).unwrap()
29613     }
29614 }
29615 impl TryFrom<UciControlPacket> for UciVendor_9_Notification {
29616     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<UciVendor_9_Notification, Self::Error>29617     fn try_from(
29618         packet: UciControlPacket,
29619     ) -> Result<UciVendor_9_Notification, Self::Error> {
29620         UciVendor_9_Notification::new(packet.ucicontrolpacket)
29621     }
29622 }
29623 impl UciVendor_9_Notification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>29624     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
29625         let mut cell = Cell::new(bytes);
29626         let packet = Self::parse_inner(&mut cell)?;
29627         Ok(packet)
29628     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>29629     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
29630         let data = UciControlPacketData::parse_inner(&mut bytes)?;
29631         Self::new(data)
29632     }
specialize(&self) -> UciVendor_9_NotificationChild29633     pub fn specialize(&self) -> UciVendor_9_NotificationChild {
29634         match &self.ucivendor_9_notification.child {
29635             UciVendor_9_NotificationDataChild::Payload(payload) => {
29636                 UciVendor_9_NotificationChild::Payload(payload.clone())
29637             }
29638             UciVendor_9_NotificationDataChild::None => {
29639                 UciVendor_9_NotificationChild::None
29640             }
29641         }
29642     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>29643     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
29644         let ucinotification = match &ucicontrolpacket.child {
29645             UciControlPacketDataChild::UciNotification(value) => value.clone(),
29646             _ => {
29647                 return Err(DecodeError::InvalidChildError {
29648                     expected: stringify!(UciControlPacketDataChild::UciNotification),
29649                     actual: format!("{:?}", & ucicontrolpacket.child),
29650                 });
29651             }
29652         };
29653         let ucivendor_9_notification = match &ucinotification.child {
29654             UciNotificationDataChild::UciVendor_9_Notification(value) => value.clone(),
29655             _ => {
29656                 return Err(DecodeError::InvalidChildError {
29657                     expected: stringify!(
29658                         UciNotificationDataChild::UciVendor_9_Notification
29659                     ),
29660                     actual: format!("{:?}", & ucinotification.child),
29661                 });
29662             }
29663         };
29664         Ok(Self {
29665             ucicontrolpacket,
29666             ucinotification,
29667             ucivendor_9_notification,
29668         })
29669     }
get_group_id(&self) -> GroupId29670     pub fn get_group_id(&self) -> GroupId {
29671         self.ucicontrolpacket.group_id
29672     }
get_message_type(&self) -> MessageType29673     pub fn get_message_type(&self) -> MessageType {
29674         self.ucicontrolpacket.message_type
29675     }
get_opcode(&self) -> u829676     pub fn get_opcode(&self) -> u8 {
29677         self.ucicontrolpacket.opcode
29678     }
get_payload(&self) -> &[u8]29679     pub fn get_payload(&self) -> &[u8] {
29680         match &self.ucivendor_9_notification.child {
29681             UciVendor_9_NotificationDataChild::Payload(bytes) => &bytes,
29682             UciVendor_9_NotificationDataChild::None => &[],
29683         }
29684     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>29685     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
29686         self.ucivendor_9_notification.write_to(buffer)
29687     }
get_size(&self) -> usize29688     pub fn get_size(&self) -> usize {
29689         self.ucicontrolpacket.get_size()
29690     }
29691 }
29692 impl UciVendor_9_NotificationBuilder {
build(self) -> UciVendor_9_Notification29693     pub fn build(self) -> UciVendor_9_Notification {
29694         let ucivendor_9_notification = UciVendor_9_NotificationData {
29695             child: match self.payload {
29696                 None => UciVendor_9_NotificationDataChild::None,
29697                 Some(bytes) => UciVendor_9_NotificationDataChild::Payload(bytes),
29698             },
29699         };
29700         let ucinotification = UciNotificationData {
29701             child: UciNotificationDataChild::UciVendor_9_Notification(
29702                 ucivendor_9_notification,
29703             ),
29704         };
29705         let ucicontrolpacket = UciControlPacketData {
29706             group_id: GroupId::VendorReserved9,
29707             message_type: MessageType::Notification,
29708             opcode: self.opcode,
29709             child: UciControlPacketDataChild::UciNotification(ucinotification),
29710         };
29711         UciVendor_9_Notification::new(ucicontrolpacket).unwrap()
29712     }
29713 }
29714 impl From<UciVendor_9_NotificationBuilder> for UciControlPacket {
from(builder: UciVendor_9_NotificationBuilder) -> UciControlPacket29715     fn from(builder: UciVendor_9_NotificationBuilder) -> UciControlPacket {
29716         builder.build().into()
29717     }
29718 }
29719 impl From<UciVendor_9_NotificationBuilder> for UciNotification {
from(builder: UciVendor_9_NotificationBuilder) -> UciNotification29720     fn from(builder: UciVendor_9_NotificationBuilder) -> UciNotification {
29721         builder.build().into()
29722     }
29723 }
29724 impl From<UciVendor_9_NotificationBuilder> for UciVendor_9_Notification {
from(builder: UciVendor_9_NotificationBuilder) -> UciVendor_9_Notification29725     fn from(builder: UciVendor_9_NotificationBuilder) -> UciVendor_9_Notification {
29726         builder.build().into()
29727     }
29728 }
29729 #[derive(Debug, Clone, PartialEq, Eq)]
29730 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29731 pub enum UciVendor_A_NotificationDataChild {
29732     Payload(Bytes),
29733     None,
29734 }
29735 impl UciVendor_A_NotificationDataChild {
get_total_size(&self) -> usize29736     fn get_total_size(&self) -> usize {
29737         match self {
29738             UciVendor_A_NotificationDataChild::Payload(bytes) => bytes.len(),
29739             UciVendor_A_NotificationDataChild::None => 0,
29740         }
29741     }
29742 }
29743 #[derive(Debug, Clone, PartialEq, Eq)]
29744 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29745 pub enum UciVendor_A_NotificationChild {
29746     Payload(Bytes),
29747     None,
29748 }
29749 #[derive(Debug, Clone, PartialEq, Eq)]
29750 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29751 pub struct UciVendor_A_NotificationData {
29752     child: UciVendor_A_NotificationDataChild,
29753 }
29754 #[derive(Debug, Clone, PartialEq, Eq)]
29755 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29756 pub struct UciVendor_A_Notification {
29757     #[cfg_attr(feature = "serde", serde(flatten))]
29758     ucicontrolpacket: UciControlPacketData,
29759     #[cfg_attr(feature = "serde", serde(flatten))]
29760     ucinotification: UciNotificationData,
29761     #[cfg_attr(feature = "serde", serde(flatten))]
29762     ucivendor_a_notification: UciVendor_A_NotificationData,
29763 }
29764 #[derive(Debug)]
29765 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29766 pub struct UciVendor_A_NotificationBuilder {
29767     pub opcode: u8,
29768     pub payload: Option<Bytes>,
29769 }
29770 impl UciVendor_A_NotificationData {
conforms(bytes: &[u8]) -> bool29771     fn conforms(bytes: &[u8]) -> bool {
29772         true
29773     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>29774     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
29775         let mut cell = Cell::new(bytes);
29776         let packet = Self::parse_inner(&mut cell)?;
29777         Ok(packet)
29778     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>29779     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
29780         let payload = bytes.get();
29781         bytes.get_mut().advance(payload.len());
29782         let child = match () {
29783             _ if !payload.is_empty() => {
29784                 UciVendor_A_NotificationDataChild::Payload(
29785                     Bytes::copy_from_slice(payload),
29786                 )
29787             }
29788             _ => UciVendor_A_NotificationDataChild::None,
29789         };
29790         Ok(Self { child })
29791     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>29792     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
29793         match &self.child {
29794             UciVendor_A_NotificationDataChild::Payload(payload) => {
29795                 buffer.put_slice(payload)
29796             }
29797             UciVendor_A_NotificationDataChild::None => {}
29798         }
29799         Ok(())
29800     }
get_total_size(&self) -> usize29801     fn get_total_size(&self) -> usize {
29802         self.get_size()
29803     }
get_size(&self) -> usize29804     fn get_size(&self) -> usize {
29805         self.child.get_total_size()
29806     }
29807 }
29808 impl Packet for UciVendor_A_Notification {
encoded_len(&self) -> usize29809     fn encoded_len(&self) -> usize {
29810         self.get_size()
29811     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>29812     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
29813         self.ucicontrolpacket.write_to(buf)
29814     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>29815     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
29816         unimplemented!("Rust legacy does not implement full packet trait")
29817     }
29818 }
29819 impl TryFrom<UciVendor_A_Notification> for Bytes {
29820     type Error = EncodeError;
try_from(packet: UciVendor_A_Notification) -> Result<Self, Self::Error>29821     fn try_from(packet: UciVendor_A_Notification) -> Result<Self, Self::Error> {
29822         packet.encode_to_bytes()
29823     }
29824 }
29825 impl TryFrom<UciVendor_A_Notification> for Vec<u8> {
29826     type Error = EncodeError;
try_from(packet: UciVendor_A_Notification) -> Result<Self, Self::Error>29827     fn try_from(packet: UciVendor_A_Notification) -> Result<Self, Self::Error> {
29828         packet.encode_to_vec()
29829     }
29830 }
29831 impl From<UciVendor_A_Notification> for UciControlPacket {
from(packet: UciVendor_A_Notification) -> UciControlPacket29832     fn from(packet: UciVendor_A_Notification) -> UciControlPacket {
29833         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
29834     }
29835 }
29836 impl From<UciVendor_A_Notification> for UciNotification {
from(packet: UciVendor_A_Notification) -> UciNotification29837     fn from(packet: UciVendor_A_Notification) -> UciNotification {
29838         UciNotification::new(packet.ucicontrolpacket).unwrap()
29839     }
29840 }
29841 impl TryFrom<UciControlPacket> for UciVendor_A_Notification {
29842     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<UciVendor_A_Notification, Self::Error>29843     fn try_from(
29844         packet: UciControlPacket,
29845     ) -> Result<UciVendor_A_Notification, Self::Error> {
29846         UciVendor_A_Notification::new(packet.ucicontrolpacket)
29847     }
29848 }
29849 impl UciVendor_A_Notification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>29850     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
29851         let mut cell = Cell::new(bytes);
29852         let packet = Self::parse_inner(&mut cell)?;
29853         Ok(packet)
29854     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>29855     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
29856         let data = UciControlPacketData::parse_inner(&mut bytes)?;
29857         Self::new(data)
29858     }
specialize(&self) -> UciVendor_A_NotificationChild29859     pub fn specialize(&self) -> UciVendor_A_NotificationChild {
29860         match &self.ucivendor_a_notification.child {
29861             UciVendor_A_NotificationDataChild::Payload(payload) => {
29862                 UciVendor_A_NotificationChild::Payload(payload.clone())
29863             }
29864             UciVendor_A_NotificationDataChild::None => {
29865                 UciVendor_A_NotificationChild::None
29866             }
29867         }
29868     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>29869     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
29870         let ucinotification = match &ucicontrolpacket.child {
29871             UciControlPacketDataChild::UciNotification(value) => value.clone(),
29872             _ => {
29873                 return Err(DecodeError::InvalidChildError {
29874                     expected: stringify!(UciControlPacketDataChild::UciNotification),
29875                     actual: format!("{:?}", & ucicontrolpacket.child),
29876                 });
29877             }
29878         };
29879         let ucivendor_a_notification = match &ucinotification.child {
29880             UciNotificationDataChild::UciVendor_A_Notification(value) => value.clone(),
29881             _ => {
29882                 return Err(DecodeError::InvalidChildError {
29883                     expected: stringify!(
29884                         UciNotificationDataChild::UciVendor_A_Notification
29885                     ),
29886                     actual: format!("{:?}", & ucinotification.child),
29887                 });
29888             }
29889         };
29890         Ok(Self {
29891             ucicontrolpacket,
29892             ucinotification,
29893             ucivendor_a_notification,
29894         })
29895     }
get_group_id(&self) -> GroupId29896     pub fn get_group_id(&self) -> GroupId {
29897         self.ucicontrolpacket.group_id
29898     }
get_message_type(&self) -> MessageType29899     pub fn get_message_type(&self) -> MessageType {
29900         self.ucicontrolpacket.message_type
29901     }
get_opcode(&self) -> u829902     pub fn get_opcode(&self) -> u8 {
29903         self.ucicontrolpacket.opcode
29904     }
get_payload(&self) -> &[u8]29905     pub fn get_payload(&self) -> &[u8] {
29906         match &self.ucivendor_a_notification.child {
29907             UciVendor_A_NotificationDataChild::Payload(bytes) => &bytes,
29908             UciVendor_A_NotificationDataChild::None => &[],
29909         }
29910     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>29911     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
29912         self.ucivendor_a_notification.write_to(buffer)
29913     }
get_size(&self) -> usize29914     pub fn get_size(&self) -> usize {
29915         self.ucicontrolpacket.get_size()
29916     }
29917 }
29918 impl UciVendor_A_NotificationBuilder {
build(self) -> UciVendor_A_Notification29919     pub fn build(self) -> UciVendor_A_Notification {
29920         let ucivendor_a_notification = UciVendor_A_NotificationData {
29921             child: match self.payload {
29922                 None => UciVendor_A_NotificationDataChild::None,
29923                 Some(bytes) => UciVendor_A_NotificationDataChild::Payload(bytes),
29924             },
29925         };
29926         let ucinotification = UciNotificationData {
29927             child: UciNotificationDataChild::UciVendor_A_Notification(
29928                 ucivendor_a_notification,
29929             ),
29930         };
29931         let ucicontrolpacket = UciControlPacketData {
29932             group_id: GroupId::VendorReservedA,
29933             message_type: MessageType::Notification,
29934             opcode: self.opcode,
29935             child: UciControlPacketDataChild::UciNotification(ucinotification),
29936         };
29937         UciVendor_A_Notification::new(ucicontrolpacket).unwrap()
29938     }
29939 }
29940 impl From<UciVendor_A_NotificationBuilder> for UciControlPacket {
from(builder: UciVendor_A_NotificationBuilder) -> UciControlPacket29941     fn from(builder: UciVendor_A_NotificationBuilder) -> UciControlPacket {
29942         builder.build().into()
29943     }
29944 }
29945 impl From<UciVendor_A_NotificationBuilder> for UciNotification {
from(builder: UciVendor_A_NotificationBuilder) -> UciNotification29946     fn from(builder: UciVendor_A_NotificationBuilder) -> UciNotification {
29947         builder.build().into()
29948     }
29949 }
29950 impl From<UciVendor_A_NotificationBuilder> for UciVendor_A_Notification {
from(builder: UciVendor_A_NotificationBuilder) -> UciVendor_A_Notification29951     fn from(builder: UciVendor_A_NotificationBuilder) -> UciVendor_A_Notification {
29952         builder.build().into()
29953     }
29954 }
29955 #[derive(Debug, Clone, PartialEq, Eq)]
29956 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29957 pub enum UciVendor_B_NotificationDataChild {
29958     Payload(Bytes),
29959     None,
29960 }
29961 impl UciVendor_B_NotificationDataChild {
get_total_size(&self) -> usize29962     fn get_total_size(&self) -> usize {
29963         match self {
29964             UciVendor_B_NotificationDataChild::Payload(bytes) => bytes.len(),
29965             UciVendor_B_NotificationDataChild::None => 0,
29966         }
29967     }
29968 }
29969 #[derive(Debug, Clone, PartialEq, Eq)]
29970 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29971 pub enum UciVendor_B_NotificationChild {
29972     Payload(Bytes),
29973     None,
29974 }
29975 #[derive(Debug, Clone, PartialEq, Eq)]
29976 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29977 pub struct UciVendor_B_NotificationData {
29978     child: UciVendor_B_NotificationDataChild,
29979 }
29980 #[derive(Debug, Clone, PartialEq, Eq)]
29981 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29982 pub struct UciVendor_B_Notification {
29983     #[cfg_attr(feature = "serde", serde(flatten))]
29984     ucicontrolpacket: UciControlPacketData,
29985     #[cfg_attr(feature = "serde", serde(flatten))]
29986     ucinotification: UciNotificationData,
29987     #[cfg_attr(feature = "serde", serde(flatten))]
29988     ucivendor_b_notification: UciVendor_B_NotificationData,
29989 }
29990 #[derive(Debug)]
29991 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29992 pub struct UciVendor_B_NotificationBuilder {
29993     pub opcode: u8,
29994     pub payload: Option<Bytes>,
29995 }
29996 impl UciVendor_B_NotificationData {
conforms(bytes: &[u8]) -> bool29997     fn conforms(bytes: &[u8]) -> bool {
29998         true
29999     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>30000     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
30001         let mut cell = Cell::new(bytes);
30002         let packet = Self::parse_inner(&mut cell)?;
30003         Ok(packet)
30004     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>30005     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
30006         let payload = bytes.get();
30007         bytes.get_mut().advance(payload.len());
30008         let child = match () {
30009             _ if !payload.is_empty() => {
30010                 UciVendor_B_NotificationDataChild::Payload(
30011                     Bytes::copy_from_slice(payload),
30012                 )
30013             }
30014             _ => UciVendor_B_NotificationDataChild::None,
30015         };
30016         Ok(Self { child })
30017     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>30018     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
30019         match &self.child {
30020             UciVendor_B_NotificationDataChild::Payload(payload) => {
30021                 buffer.put_slice(payload)
30022             }
30023             UciVendor_B_NotificationDataChild::None => {}
30024         }
30025         Ok(())
30026     }
get_total_size(&self) -> usize30027     fn get_total_size(&self) -> usize {
30028         self.get_size()
30029     }
get_size(&self) -> usize30030     fn get_size(&self) -> usize {
30031         self.child.get_total_size()
30032     }
30033 }
30034 impl Packet for UciVendor_B_Notification {
encoded_len(&self) -> usize30035     fn encoded_len(&self) -> usize {
30036         self.get_size()
30037     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>30038     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
30039         self.ucicontrolpacket.write_to(buf)
30040     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>30041     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
30042         unimplemented!("Rust legacy does not implement full packet trait")
30043     }
30044 }
30045 impl TryFrom<UciVendor_B_Notification> for Bytes {
30046     type Error = EncodeError;
try_from(packet: UciVendor_B_Notification) -> Result<Self, Self::Error>30047     fn try_from(packet: UciVendor_B_Notification) -> Result<Self, Self::Error> {
30048         packet.encode_to_bytes()
30049     }
30050 }
30051 impl TryFrom<UciVendor_B_Notification> for Vec<u8> {
30052     type Error = EncodeError;
try_from(packet: UciVendor_B_Notification) -> Result<Self, Self::Error>30053     fn try_from(packet: UciVendor_B_Notification) -> Result<Self, Self::Error> {
30054         packet.encode_to_vec()
30055     }
30056 }
30057 impl From<UciVendor_B_Notification> for UciControlPacket {
from(packet: UciVendor_B_Notification) -> UciControlPacket30058     fn from(packet: UciVendor_B_Notification) -> UciControlPacket {
30059         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
30060     }
30061 }
30062 impl From<UciVendor_B_Notification> for UciNotification {
from(packet: UciVendor_B_Notification) -> UciNotification30063     fn from(packet: UciVendor_B_Notification) -> UciNotification {
30064         UciNotification::new(packet.ucicontrolpacket).unwrap()
30065     }
30066 }
30067 impl TryFrom<UciControlPacket> for UciVendor_B_Notification {
30068     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<UciVendor_B_Notification, Self::Error>30069     fn try_from(
30070         packet: UciControlPacket,
30071     ) -> Result<UciVendor_B_Notification, Self::Error> {
30072         UciVendor_B_Notification::new(packet.ucicontrolpacket)
30073     }
30074 }
30075 impl UciVendor_B_Notification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>30076     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
30077         let mut cell = Cell::new(bytes);
30078         let packet = Self::parse_inner(&mut cell)?;
30079         Ok(packet)
30080     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>30081     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
30082         let data = UciControlPacketData::parse_inner(&mut bytes)?;
30083         Self::new(data)
30084     }
specialize(&self) -> UciVendor_B_NotificationChild30085     pub fn specialize(&self) -> UciVendor_B_NotificationChild {
30086         match &self.ucivendor_b_notification.child {
30087             UciVendor_B_NotificationDataChild::Payload(payload) => {
30088                 UciVendor_B_NotificationChild::Payload(payload.clone())
30089             }
30090             UciVendor_B_NotificationDataChild::None => {
30091                 UciVendor_B_NotificationChild::None
30092             }
30093         }
30094     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>30095     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
30096         let ucinotification = match &ucicontrolpacket.child {
30097             UciControlPacketDataChild::UciNotification(value) => value.clone(),
30098             _ => {
30099                 return Err(DecodeError::InvalidChildError {
30100                     expected: stringify!(UciControlPacketDataChild::UciNotification),
30101                     actual: format!("{:?}", & ucicontrolpacket.child),
30102                 });
30103             }
30104         };
30105         let ucivendor_b_notification = match &ucinotification.child {
30106             UciNotificationDataChild::UciVendor_B_Notification(value) => value.clone(),
30107             _ => {
30108                 return Err(DecodeError::InvalidChildError {
30109                     expected: stringify!(
30110                         UciNotificationDataChild::UciVendor_B_Notification
30111                     ),
30112                     actual: format!("{:?}", & ucinotification.child),
30113                 });
30114             }
30115         };
30116         Ok(Self {
30117             ucicontrolpacket,
30118             ucinotification,
30119             ucivendor_b_notification,
30120         })
30121     }
get_group_id(&self) -> GroupId30122     pub fn get_group_id(&self) -> GroupId {
30123         self.ucicontrolpacket.group_id
30124     }
get_message_type(&self) -> MessageType30125     pub fn get_message_type(&self) -> MessageType {
30126         self.ucicontrolpacket.message_type
30127     }
get_opcode(&self) -> u830128     pub fn get_opcode(&self) -> u8 {
30129         self.ucicontrolpacket.opcode
30130     }
get_payload(&self) -> &[u8]30131     pub fn get_payload(&self) -> &[u8] {
30132         match &self.ucivendor_b_notification.child {
30133             UciVendor_B_NotificationDataChild::Payload(bytes) => &bytes,
30134             UciVendor_B_NotificationDataChild::None => &[],
30135         }
30136     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>30137     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
30138         self.ucivendor_b_notification.write_to(buffer)
30139     }
get_size(&self) -> usize30140     pub fn get_size(&self) -> usize {
30141         self.ucicontrolpacket.get_size()
30142     }
30143 }
30144 impl UciVendor_B_NotificationBuilder {
build(self) -> UciVendor_B_Notification30145     pub fn build(self) -> UciVendor_B_Notification {
30146         let ucivendor_b_notification = UciVendor_B_NotificationData {
30147             child: match self.payload {
30148                 None => UciVendor_B_NotificationDataChild::None,
30149                 Some(bytes) => UciVendor_B_NotificationDataChild::Payload(bytes),
30150             },
30151         };
30152         let ucinotification = UciNotificationData {
30153             child: UciNotificationDataChild::UciVendor_B_Notification(
30154                 ucivendor_b_notification,
30155             ),
30156         };
30157         let ucicontrolpacket = UciControlPacketData {
30158             group_id: GroupId::VendorReservedB,
30159             message_type: MessageType::Notification,
30160             opcode: self.opcode,
30161             child: UciControlPacketDataChild::UciNotification(ucinotification),
30162         };
30163         UciVendor_B_Notification::new(ucicontrolpacket).unwrap()
30164     }
30165 }
30166 impl From<UciVendor_B_NotificationBuilder> for UciControlPacket {
from(builder: UciVendor_B_NotificationBuilder) -> UciControlPacket30167     fn from(builder: UciVendor_B_NotificationBuilder) -> UciControlPacket {
30168         builder.build().into()
30169     }
30170 }
30171 impl From<UciVendor_B_NotificationBuilder> for UciNotification {
from(builder: UciVendor_B_NotificationBuilder) -> UciNotification30172     fn from(builder: UciVendor_B_NotificationBuilder) -> UciNotification {
30173         builder.build().into()
30174     }
30175 }
30176 impl From<UciVendor_B_NotificationBuilder> for UciVendor_B_Notification {
from(builder: UciVendor_B_NotificationBuilder) -> UciVendor_B_Notification30177     fn from(builder: UciVendor_B_NotificationBuilder) -> UciVendor_B_Notification {
30178         builder.build().into()
30179     }
30180 }
30181 #[derive(Debug, Clone, PartialEq, Eq)]
30182 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30183 pub enum UciVendor_E_NotificationDataChild {
30184     Payload(Bytes),
30185     None,
30186 }
30187 impl UciVendor_E_NotificationDataChild {
get_total_size(&self) -> usize30188     fn get_total_size(&self) -> usize {
30189         match self {
30190             UciVendor_E_NotificationDataChild::Payload(bytes) => bytes.len(),
30191             UciVendor_E_NotificationDataChild::None => 0,
30192         }
30193     }
30194 }
30195 #[derive(Debug, Clone, PartialEq, Eq)]
30196 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30197 pub enum UciVendor_E_NotificationChild {
30198     Payload(Bytes),
30199     None,
30200 }
30201 #[derive(Debug, Clone, PartialEq, Eq)]
30202 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30203 pub struct UciVendor_E_NotificationData {
30204     child: UciVendor_E_NotificationDataChild,
30205 }
30206 #[derive(Debug, Clone, PartialEq, Eq)]
30207 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30208 pub struct UciVendor_E_Notification {
30209     #[cfg_attr(feature = "serde", serde(flatten))]
30210     ucicontrolpacket: UciControlPacketData,
30211     #[cfg_attr(feature = "serde", serde(flatten))]
30212     ucinotification: UciNotificationData,
30213     #[cfg_attr(feature = "serde", serde(flatten))]
30214     ucivendor_e_notification: UciVendor_E_NotificationData,
30215 }
30216 #[derive(Debug)]
30217 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30218 pub struct UciVendor_E_NotificationBuilder {
30219     pub opcode: u8,
30220     pub payload: Option<Bytes>,
30221 }
30222 impl UciVendor_E_NotificationData {
conforms(bytes: &[u8]) -> bool30223     fn conforms(bytes: &[u8]) -> bool {
30224         true
30225     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>30226     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
30227         let mut cell = Cell::new(bytes);
30228         let packet = Self::parse_inner(&mut cell)?;
30229         Ok(packet)
30230     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>30231     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
30232         let payload = bytes.get();
30233         bytes.get_mut().advance(payload.len());
30234         let child = match () {
30235             _ if !payload.is_empty() => {
30236                 UciVendor_E_NotificationDataChild::Payload(
30237                     Bytes::copy_from_slice(payload),
30238                 )
30239             }
30240             _ => UciVendor_E_NotificationDataChild::None,
30241         };
30242         Ok(Self { child })
30243     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>30244     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
30245         match &self.child {
30246             UciVendor_E_NotificationDataChild::Payload(payload) => {
30247                 buffer.put_slice(payload)
30248             }
30249             UciVendor_E_NotificationDataChild::None => {}
30250         }
30251         Ok(())
30252     }
get_total_size(&self) -> usize30253     fn get_total_size(&self) -> usize {
30254         self.get_size()
30255     }
get_size(&self) -> usize30256     fn get_size(&self) -> usize {
30257         self.child.get_total_size()
30258     }
30259 }
30260 impl Packet for UciVendor_E_Notification {
encoded_len(&self) -> usize30261     fn encoded_len(&self) -> usize {
30262         self.get_size()
30263     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>30264     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
30265         self.ucicontrolpacket.write_to(buf)
30266     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>30267     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
30268         unimplemented!("Rust legacy does not implement full packet trait")
30269     }
30270 }
30271 impl TryFrom<UciVendor_E_Notification> for Bytes {
30272     type Error = EncodeError;
try_from(packet: UciVendor_E_Notification) -> Result<Self, Self::Error>30273     fn try_from(packet: UciVendor_E_Notification) -> Result<Self, Self::Error> {
30274         packet.encode_to_bytes()
30275     }
30276 }
30277 impl TryFrom<UciVendor_E_Notification> for Vec<u8> {
30278     type Error = EncodeError;
try_from(packet: UciVendor_E_Notification) -> Result<Self, Self::Error>30279     fn try_from(packet: UciVendor_E_Notification) -> Result<Self, Self::Error> {
30280         packet.encode_to_vec()
30281     }
30282 }
30283 impl From<UciVendor_E_Notification> for UciControlPacket {
from(packet: UciVendor_E_Notification) -> UciControlPacket30284     fn from(packet: UciVendor_E_Notification) -> UciControlPacket {
30285         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
30286     }
30287 }
30288 impl From<UciVendor_E_Notification> for UciNotification {
from(packet: UciVendor_E_Notification) -> UciNotification30289     fn from(packet: UciVendor_E_Notification) -> UciNotification {
30290         UciNotification::new(packet.ucicontrolpacket).unwrap()
30291     }
30292 }
30293 impl TryFrom<UciControlPacket> for UciVendor_E_Notification {
30294     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<UciVendor_E_Notification, Self::Error>30295     fn try_from(
30296         packet: UciControlPacket,
30297     ) -> Result<UciVendor_E_Notification, Self::Error> {
30298         UciVendor_E_Notification::new(packet.ucicontrolpacket)
30299     }
30300 }
30301 impl UciVendor_E_Notification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>30302     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
30303         let mut cell = Cell::new(bytes);
30304         let packet = Self::parse_inner(&mut cell)?;
30305         Ok(packet)
30306     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>30307     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
30308         let data = UciControlPacketData::parse_inner(&mut bytes)?;
30309         Self::new(data)
30310     }
specialize(&self) -> UciVendor_E_NotificationChild30311     pub fn specialize(&self) -> UciVendor_E_NotificationChild {
30312         match &self.ucivendor_e_notification.child {
30313             UciVendor_E_NotificationDataChild::Payload(payload) => {
30314                 UciVendor_E_NotificationChild::Payload(payload.clone())
30315             }
30316             UciVendor_E_NotificationDataChild::None => {
30317                 UciVendor_E_NotificationChild::None
30318             }
30319         }
30320     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>30321     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
30322         let ucinotification = match &ucicontrolpacket.child {
30323             UciControlPacketDataChild::UciNotification(value) => value.clone(),
30324             _ => {
30325                 return Err(DecodeError::InvalidChildError {
30326                     expected: stringify!(UciControlPacketDataChild::UciNotification),
30327                     actual: format!("{:?}", & ucicontrolpacket.child),
30328                 });
30329             }
30330         };
30331         let ucivendor_e_notification = match &ucinotification.child {
30332             UciNotificationDataChild::UciVendor_E_Notification(value) => value.clone(),
30333             _ => {
30334                 return Err(DecodeError::InvalidChildError {
30335                     expected: stringify!(
30336                         UciNotificationDataChild::UciVendor_E_Notification
30337                     ),
30338                     actual: format!("{:?}", & ucinotification.child),
30339                 });
30340             }
30341         };
30342         Ok(Self {
30343             ucicontrolpacket,
30344             ucinotification,
30345             ucivendor_e_notification,
30346         })
30347     }
get_group_id(&self) -> GroupId30348     pub fn get_group_id(&self) -> GroupId {
30349         self.ucicontrolpacket.group_id
30350     }
get_message_type(&self) -> MessageType30351     pub fn get_message_type(&self) -> MessageType {
30352         self.ucicontrolpacket.message_type
30353     }
get_opcode(&self) -> u830354     pub fn get_opcode(&self) -> u8 {
30355         self.ucicontrolpacket.opcode
30356     }
get_payload(&self) -> &[u8]30357     pub fn get_payload(&self) -> &[u8] {
30358         match &self.ucivendor_e_notification.child {
30359             UciVendor_E_NotificationDataChild::Payload(bytes) => &bytes,
30360             UciVendor_E_NotificationDataChild::None => &[],
30361         }
30362     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>30363     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
30364         self.ucivendor_e_notification.write_to(buffer)
30365     }
get_size(&self) -> usize30366     pub fn get_size(&self) -> usize {
30367         self.ucicontrolpacket.get_size()
30368     }
30369 }
30370 impl UciVendor_E_NotificationBuilder {
build(self) -> UciVendor_E_Notification30371     pub fn build(self) -> UciVendor_E_Notification {
30372         let ucivendor_e_notification = UciVendor_E_NotificationData {
30373             child: match self.payload {
30374                 None => UciVendor_E_NotificationDataChild::None,
30375                 Some(bytes) => UciVendor_E_NotificationDataChild::Payload(bytes),
30376             },
30377         };
30378         let ucinotification = UciNotificationData {
30379             child: UciNotificationDataChild::UciVendor_E_Notification(
30380                 ucivendor_e_notification,
30381             ),
30382         };
30383         let ucicontrolpacket = UciControlPacketData {
30384             group_id: GroupId::VendorReservedE,
30385             message_type: MessageType::Notification,
30386             opcode: self.opcode,
30387             child: UciControlPacketDataChild::UciNotification(ucinotification),
30388         };
30389         UciVendor_E_Notification::new(ucicontrolpacket).unwrap()
30390     }
30391 }
30392 impl From<UciVendor_E_NotificationBuilder> for UciControlPacket {
from(builder: UciVendor_E_NotificationBuilder) -> UciControlPacket30393     fn from(builder: UciVendor_E_NotificationBuilder) -> UciControlPacket {
30394         builder.build().into()
30395     }
30396 }
30397 impl From<UciVendor_E_NotificationBuilder> for UciNotification {
from(builder: UciVendor_E_NotificationBuilder) -> UciNotification30398     fn from(builder: UciVendor_E_NotificationBuilder) -> UciNotification {
30399         builder.build().into()
30400     }
30401 }
30402 impl From<UciVendor_E_NotificationBuilder> for UciVendor_E_Notification {
from(builder: UciVendor_E_NotificationBuilder) -> UciVendor_E_Notification30403     fn from(builder: UciVendor_E_NotificationBuilder) -> UciVendor_E_Notification {
30404         builder.build().into()
30405     }
30406 }
30407 #[derive(Debug, Clone, PartialEq, Eq)]
30408 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30409 pub enum UciVendor_F_NotificationDataChild {
30410     Payload(Bytes),
30411     None,
30412 }
30413 impl UciVendor_F_NotificationDataChild {
get_total_size(&self) -> usize30414     fn get_total_size(&self) -> usize {
30415         match self {
30416             UciVendor_F_NotificationDataChild::Payload(bytes) => bytes.len(),
30417             UciVendor_F_NotificationDataChild::None => 0,
30418         }
30419     }
30420 }
30421 #[derive(Debug, Clone, PartialEq, Eq)]
30422 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30423 pub enum UciVendor_F_NotificationChild {
30424     Payload(Bytes),
30425     None,
30426 }
30427 #[derive(Debug, Clone, PartialEq, Eq)]
30428 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30429 pub struct UciVendor_F_NotificationData {
30430     child: UciVendor_F_NotificationDataChild,
30431 }
30432 #[derive(Debug, Clone, PartialEq, Eq)]
30433 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30434 pub struct UciVendor_F_Notification {
30435     #[cfg_attr(feature = "serde", serde(flatten))]
30436     ucicontrolpacket: UciControlPacketData,
30437     #[cfg_attr(feature = "serde", serde(flatten))]
30438     ucinotification: UciNotificationData,
30439     #[cfg_attr(feature = "serde", serde(flatten))]
30440     ucivendor_f_notification: UciVendor_F_NotificationData,
30441 }
30442 #[derive(Debug)]
30443 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30444 pub struct UciVendor_F_NotificationBuilder {
30445     pub opcode: u8,
30446     pub payload: Option<Bytes>,
30447 }
30448 impl UciVendor_F_NotificationData {
conforms(bytes: &[u8]) -> bool30449     fn conforms(bytes: &[u8]) -> bool {
30450         true
30451     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>30452     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
30453         let mut cell = Cell::new(bytes);
30454         let packet = Self::parse_inner(&mut cell)?;
30455         Ok(packet)
30456     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>30457     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
30458         let payload = bytes.get();
30459         bytes.get_mut().advance(payload.len());
30460         let child = match () {
30461             _ if !payload.is_empty() => {
30462                 UciVendor_F_NotificationDataChild::Payload(
30463                     Bytes::copy_from_slice(payload),
30464                 )
30465             }
30466             _ => UciVendor_F_NotificationDataChild::None,
30467         };
30468         Ok(Self { child })
30469     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>30470     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
30471         match &self.child {
30472             UciVendor_F_NotificationDataChild::Payload(payload) => {
30473                 buffer.put_slice(payload)
30474             }
30475             UciVendor_F_NotificationDataChild::None => {}
30476         }
30477         Ok(())
30478     }
get_total_size(&self) -> usize30479     fn get_total_size(&self) -> usize {
30480         self.get_size()
30481     }
get_size(&self) -> usize30482     fn get_size(&self) -> usize {
30483         self.child.get_total_size()
30484     }
30485 }
30486 impl Packet for UciVendor_F_Notification {
encoded_len(&self) -> usize30487     fn encoded_len(&self) -> usize {
30488         self.get_size()
30489     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>30490     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
30491         self.ucicontrolpacket.write_to(buf)
30492     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>30493     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
30494         unimplemented!("Rust legacy does not implement full packet trait")
30495     }
30496 }
30497 impl TryFrom<UciVendor_F_Notification> for Bytes {
30498     type Error = EncodeError;
try_from(packet: UciVendor_F_Notification) -> Result<Self, Self::Error>30499     fn try_from(packet: UciVendor_F_Notification) -> Result<Self, Self::Error> {
30500         packet.encode_to_bytes()
30501     }
30502 }
30503 impl TryFrom<UciVendor_F_Notification> for Vec<u8> {
30504     type Error = EncodeError;
try_from(packet: UciVendor_F_Notification) -> Result<Self, Self::Error>30505     fn try_from(packet: UciVendor_F_Notification) -> Result<Self, Self::Error> {
30506         packet.encode_to_vec()
30507     }
30508 }
30509 impl From<UciVendor_F_Notification> for UciControlPacket {
from(packet: UciVendor_F_Notification) -> UciControlPacket30510     fn from(packet: UciVendor_F_Notification) -> UciControlPacket {
30511         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
30512     }
30513 }
30514 impl From<UciVendor_F_Notification> for UciNotification {
from(packet: UciVendor_F_Notification) -> UciNotification30515     fn from(packet: UciVendor_F_Notification) -> UciNotification {
30516         UciNotification::new(packet.ucicontrolpacket).unwrap()
30517     }
30518 }
30519 impl TryFrom<UciControlPacket> for UciVendor_F_Notification {
30520     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<UciVendor_F_Notification, Self::Error>30521     fn try_from(
30522         packet: UciControlPacket,
30523     ) -> Result<UciVendor_F_Notification, Self::Error> {
30524         UciVendor_F_Notification::new(packet.ucicontrolpacket)
30525     }
30526 }
30527 impl UciVendor_F_Notification {
parse(bytes: &[u8]) -> Result<Self, DecodeError>30528     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
30529         let mut cell = Cell::new(bytes);
30530         let packet = Self::parse_inner(&mut cell)?;
30531         Ok(packet)
30532     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>30533     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
30534         let data = UciControlPacketData::parse_inner(&mut bytes)?;
30535         Self::new(data)
30536     }
specialize(&self) -> UciVendor_F_NotificationChild30537     pub fn specialize(&self) -> UciVendor_F_NotificationChild {
30538         match &self.ucivendor_f_notification.child {
30539             UciVendor_F_NotificationDataChild::Payload(payload) => {
30540                 UciVendor_F_NotificationChild::Payload(payload.clone())
30541             }
30542             UciVendor_F_NotificationDataChild::None => {
30543                 UciVendor_F_NotificationChild::None
30544             }
30545         }
30546     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>30547     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
30548         let ucinotification = match &ucicontrolpacket.child {
30549             UciControlPacketDataChild::UciNotification(value) => value.clone(),
30550             _ => {
30551                 return Err(DecodeError::InvalidChildError {
30552                     expected: stringify!(UciControlPacketDataChild::UciNotification),
30553                     actual: format!("{:?}", & ucicontrolpacket.child),
30554                 });
30555             }
30556         };
30557         let ucivendor_f_notification = match &ucinotification.child {
30558             UciNotificationDataChild::UciVendor_F_Notification(value) => value.clone(),
30559             _ => {
30560                 return Err(DecodeError::InvalidChildError {
30561                     expected: stringify!(
30562                         UciNotificationDataChild::UciVendor_F_Notification
30563                     ),
30564                     actual: format!("{:?}", & ucinotification.child),
30565                 });
30566             }
30567         };
30568         Ok(Self {
30569             ucicontrolpacket,
30570             ucinotification,
30571             ucivendor_f_notification,
30572         })
30573     }
get_group_id(&self) -> GroupId30574     pub fn get_group_id(&self) -> GroupId {
30575         self.ucicontrolpacket.group_id
30576     }
get_message_type(&self) -> MessageType30577     pub fn get_message_type(&self) -> MessageType {
30578         self.ucicontrolpacket.message_type
30579     }
get_opcode(&self) -> u830580     pub fn get_opcode(&self) -> u8 {
30581         self.ucicontrolpacket.opcode
30582     }
get_payload(&self) -> &[u8]30583     pub fn get_payload(&self) -> &[u8] {
30584         match &self.ucivendor_f_notification.child {
30585             UciVendor_F_NotificationDataChild::Payload(bytes) => &bytes,
30586             UciVendor_F_NotificationDataChild::None => &[],
30587         }
30588     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>30589     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
30590         self.ucivendor_f_notification.write_to(buffer)
30591     }
get_size(&self) -> usize30592     pub fn get_size(&self) -> usize {
30593         self.ucicontrolpacket.get_size()
30594     }
30595 }
30596 impl UciVendor_F_NotificationBuilder {
build(self) -> UciVendor_F_Notification30597     pub fn build(self) -> UciVendor_F_Notification {
30598         let ucivendor_f_notification = UciVendor_F_NotificationData {
30599             child: match self.payload {
30600                 None => UciVendor_F_NotificationDataChild::None,
30601                 Some(bytes) => UciVendor_F_NotificationDataChild::Payload(bytes),
30602             },
30603         };
30604         let ucinotification = UciNotificationData {
30605             child: UciNotificationDataChild::UciVendor_F_Notification(
30606                 ucivendor_f_notification,
30607             ),
30608         };
30609         let ucicontrolpacket = UciControlPacketData {
30610             group_id: GroupId::VendorReservedF,
30611             message_type: MessageType::Notification,
30612             opcode: self.opcode,
30613             child: UciControlPacketDataChild::UciNotification(ucinotification),
30614         };
30615         UciVendor_F_Notification::new(ucicontrolpacket).unwrap()
30616     }
30617 }
30618 impl From<UciVendor_F_NotificationBuilder> for UciControlPacket {
from(builder: UciVendor_F_NotificationBuilder) -> UciControlPacket30619     fn from(builder: UciVendor_F_NotificationBuilder) -> UciControlPacket {
30620         builder.build().into()
30621     }
30622 }
30623 impl From<UciVendor_F_NotificationBuilder> for UciNotification {
from(builder: UciVendor_F_NotificationBuilder) -> UciNotification30624     fn from(builder: UciVendor_F_NotificationBuilder) -> UciNotification {
30625         builder.build().into()
30626     }
30627 }
30628 impl From<UciVendor_F_NotificationBuilder> for UciVendor_F_Notification {
from(builder: UciVendor_F_NotificationBuilder) -> UciVendor_F_Notification30629     fn from(builder: UciVendor_F_NotificationBuilder) -> UciVendor_F_Notification {
30630         builder.build().into()
30631     }
30632 }
30633 #[repr(u64)]
30634 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
30635 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30636 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
30637 pub enum RadarDataType {
30638     RadarSweepSamples = 0x0,
30639 }
30640 impl TryFrom<u8> for RadarDataType {
30641     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>30642     fn try_from(value: u8) -> Result<Self, Self::Error> {
30643         match value {
30644             0x0 => Ok(RadarDataType::RadarSweepSamples),
30645             _ => Err(value),
30646         }
30647     }
30648 }
30649 impl From<&RadarDataType> for u8 {
from(value: &RadarDataType) -> Self30650     fn from(value: &RadarDataType) -> Self {
30651         match value {
30652             RadarDataType::RadarSweepSamples => 0x0,
30653         }
30654     }
30655 }
30656 impl From<RadarDataType> for u8 {
from(value: RadarDataType) -> Self30657     fn from(value: RadarDataType) -> Self {
30658         (&value).into()
30659     }
30660 }
30661 impl From<RadarDataType> for i16 {
from(value: RadarDataType) -> Self30662     fn from(value: RadarDataType) -> Self {
30663         u8::from(value) as Self
30664     }
30665 }
30666 impl From<RadarDataType> for i32 {
from(value: RadarDataType) -> Self30667     fn from(value: RadarDataType) -> Self {
30668         u8::from(value) as Self
30669     }
30670 }
30671 impl From<RadarDataType> for i64 {
from(value: RadarDataType) -> Self30672     fn from(value: RadarDataType) -> Self {
30673         u8::from(value) as Self
30674     }
30675 }
30676 impl From<RadarDataType> for u16 {
from(value: RadarDataType) -> Self30677     fn from(value: RadarDataType) -> Self {
30678         u8::from(value) as Self
30679     }
30680 }
30681 impl From<RadarDataType> for u32 {
from(value: RadarDataType) -> Self30682     fn from(value: RadarDataType) -> Self {
30683         u8::from(value) as Self
30684     }
30685 }
30686 impl From<RadarDataType> for u64 {
from(value: RadarDataType) -> Self30687     fn from(value: RadarDataType) -> Self {
30688         u8::from(value) as Self
30689     }
30690 }
30691 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
30692 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30693 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
30694 pub enum RadarConfigTlvType {
30695     RadarTimingParams,
30696     SamplesPerSweep,
30697     ChannelNumber,
30698     SweepOffset,
30699     RframeConfig,
30700     PreambleDuration,
30701     PreambleCodeIndex,
30702     SessionPriority,
30703     BitsPerSample,
30704     PrfMode,
30705     NumberOfBursts,
30706     RadarDataType,
30707     RfuRadarAppCfgTlvTypeRange(Private<u8>),
30708     VendorSpecificRadarAppCfgTlvTypeRange(Private<u8>),
30709 }
30710 impl TryFrom<u8> for RadarConfigTlvType {
30711     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>30712     fn try_from(value: u8) -> Result<Self, Self::Error> {
30713         match value {
30714             0x0 => Ok(RadarConfigTlvType::RadarTimingParams),
30715             0x1 => Ok(RadarConfigTlvType::SamplesPerSweep),
30716             0x2 => Ok(RadarConfigTlvType::ChannelNumber),
30717             0x3 => Ok(RadarConfigTlvType::SweepOffset),
30718             0x4 => Ok(RadarConfigTlvType::RframeConfig),
30719             0x5 => Ok(RadarConfigTlvType::PreambleDuration),
30720             0x6 => Ok(RadarConfigTlvType::PreambleCodeIndex),
30721             0x7 => Ok(RadarConfigTlvType::SessionPriority),
30722             0x8 => Ok(RadarConfigTlvType::BitsPerSample),
30723             0x9 => Ok(RadarConfigTlvType::PrfMode),
30724             0xa => Ok(RadarConfigTlvType::NumberOfBursts),
30725             0xb => Ok(RadarConfigTlvType::RadarDataType),
30726             0xc..=0x9f => {
30727                 Ok(RadarConfigTlvType::RfuRadarAppCfgTlvTypeRange(Private(value)))
30728             }
30729             0xa0..=0xdf => {
30730                 Ok(
30731                     RadarConfigTlvType::VendorSpecificRadarAppCfgTlvTypeRange(
30732                         Private(value),
30733                     ),
30734                 )
30735             }
30736             _ => Err(value),
30737         }
30738     }
30739 }
30740 impl From<&RadarConfigTlvType> for u8 {
from(value: &RadarConfigTlvType) -> Self30741     fn from(value: &RadarConfigTlvType) -> Self {
30742         match value {
30743             RadarConfigTlvType::RadarTimingParams => 0x0,
30744             RadarConfigTlvType::SamplesPerSweep => 0x1,
30745             RadarConfigTlvType::ChannelNumber => 0x2,
30746             RadarConfigTlvType::SweepOffset => 0x3,
30747             RadarConfigTlvType::RframeConfig => 0x4,
30748             RadarConfigTlvType::PreambleDuration => 0x5,
30749             RadarConfigTlvType::PreambleCodeIndex => 0x6,
30750             RadarConfigTlvType::SessionPriority => 0x7,
30751             RadarConfigTlvType::BitsPerSample => 0x8,
30752             RadarConfigTlvType::PrfMode => 0x9,
30753             RadarConfigTlvType::NumberOfBursts => 0xa,
30754             RadarConfigTlvType::RadarDataType => 0xb,
30755             RadarConfigTlvType::RfuRadarAppCfgTlvTypeRange(Private(value)) => *value,
30756             RadarConfigTlvType::VendorSpecificRadarAppCfgTlvTypeRange(Private(value)) => {
30757                 *value
30758             }
30759         }
30760     }
30761 }
30762 impl From<RadarConfigTlvType> for u8 {
from(value: RadarConfigTlvType) -> Self30763     fn from(value: RadarConfigTlvType) -> Self {
30764         (&value).into()
30765     }
30766 }
30767 impl From<RadarConfigTlvType> for i16 {
from(value: RadarConfigTlvType) -> Self30768     fn from(value: RadarConfigTlvType) -> Self {
30769         u8::from(value) as Self
30770     }
30771 }
30772 impl From<RadarConfigTlvType> for i32 {
from(value: RadarConfigTlvType) -> Self30773     fn from(value: RadarConfigTlvType) -> Self {
30774         u8::from(value) as Self
30775     }
30776 }
30777 impl From<RadarConfigTlvType> for i64 {
from(value: RadarConfigTlvType) -> Self30778     fn from(value: RadarConfigTlvType) -> Self {
30779         u8::from(value) as Self
30780     }
30781 }
30782 impl From<RadarConfigTlvType> for u16 {
from(value: RadarConfigTlvType) -> Self30783     fn from(value: RadarConfigTlvType) -> Self {
30784         u8::from(value) as Self
30785     }
30786 }
30787 impl From<RadarConfigTlvType> for u32 {
from(value: RadarConfigTlvType) -> Self30788     fn from(value: RadarConfigTlvType) -> Self {
30789         u8::from(value) as Self
30790     }
30791 }
30792 impl From<RadarConfigTlvType> for u64 {
from(value: RadarConfigTlvType) -> Self30793     fn from(value: RadarConfigTlvType) -> Self {
30794         u8::from(value) as Self
30795     }
30796 }
30797 #[derive(Debug, Clone, PartialEq, Eq)]
30798 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30799 pub struct RadarConfigTlv {
30800     pub cfg_id: RadarConfigTlvType,
30801     pub v: Vec<u8>,
30802 }
30803 impl RadarConfigTlv {
conforms(bytes: &[u8]) -> bool30804     fn conforms(bytes: &[u8]) -> bool {
30805         bytes.len() >= 2
30806     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>30807     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
30808         let mut cell = Cell::new(bytes);
30809         let packet = Self::parse_inner(&mut cell)?;
30810         Ok(packet)
30811     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>30812     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
30813         if bytes.get().remaining() < 1 {
30814             return Err(DecodeError::InvalidLengthError {
30815                 obj: "RadarConfigTlv",
30816                 wanted: 1,
30817                 got: bytes.get().remaining(),
30818             });
30819         }
30820         let cfg_id = RadarConfigTlvType::try_from(bytes.get_mut().get_u8())
30821             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
30822                 obj: "RadarConfigTlv",
30823                 field: "cfg_id",
30824                 value: unknown_val as u64,
30825                 type_: "RadarConfigTlvType",
30826             })?;
30827         if bytes.get().remaining() < 1 {
30828             return Err(DecodeError::InvalidLengthError {
30829                 obj: "RadarConfigTlv",
30830                 wanted: 1,
30831                 got: bytes.get().remaining(),
30832             });
30833         }
30834         let v_count = bytes.get_mut().get_u8() as usize;
30835         if bytes.get().remaining() < v_count * 1usize {
30836             return Err(DecodeError::InvalidLengthError {
30837                 obj: "RadarConfigTlv",
30838                 wanted: v_count * 1usize,
30839                 got: bytes.get().remaining(),
30840             });
30841         }
30842         let v = (0..v_count)
30843             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
30844             .collect::<Result<Vec<_>, DecodeError>>()?;
30845         Ok(Self { cfg_id, v })
30846     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>30847     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
30848         buffer.put_u8(u8::from(self.cfg_id));
30849         buffer.put_u8(self.v.len() as u8);
30850         for elem in &self.v {
30851             buffer.put_u8(*elem);
30852         }
30853         Ok(())
30854     }
get_total_size(&self) -> usize30855     fn get_total_size(&self) -> usize {
30856         self.get_size()
30857     }
get_size(&self) -> usize30858     fn get_size(&self) -> usize {
30859         2 + self.v.len()
30860     }
30861 }
30862 #[derive(Debug, Clone, PartialEq, Eq)]
30863 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30864 pub struct RadarConfigStatus {
30865     pub cfg_id: RadarConfigTlvType,
30866     pub status: StatusCode,
30867 }
30868 impl RadarConfigStatus {
conforms(bytes: &[u8]) -> bool30869     fn conforms(bytes: &[u8]) -> bool {
30870         bytes.len() >= 2
30871     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>30872     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
30873         let mut cell = Cell::new(bytes);
30874         let packet = Self::parse_inner(&mut cell)?;
30875         Ok(packet)
30876     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>30877     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
30878         if bytes.get().remaining() < 1 {
30879             return Err(DecodeError::InvalidLengthError {
30880                 obj: "RadarConfigStatus",
30881                 wanted: 1,
30882                 got: bytes.get().remaining(),
30883             });
30884         }
30885         let cfg_id = RadarConfigTlvType::try_from(bytes.get_mut().get_u8())
30886             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
30887                 obj: "RadarConfigStatus",
30888                 field: "cfg_id",
30889                 value: unknown_val as u64,
30890                 type_: "RadarConfigTlvType",
30891             })?;
30892         if bytes.get().remaining() < 1 {
30893             return Err(DecodeError::InvalidLengthError {
30894                 obj: "RadarConfigStatus",
30895                 wanted: 1,
30896                 got: bytes.get().remaining(),
30897             });
30898         }
30899         let status = StatusCode::try_from(bytes.get_mut().get_u8())
30900             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
30901                 obj: "RadarConfigStatus",
30902                 field: "status",
30903                 value: unknown_val as u64,
30904                 type_: "StatusCode",
30905             })?;
30906         Ok(Self { cfg_id, status })
30907     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>30908     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
30909         buffer.put_u8(u8::from(self.cfg_id));
30910         buffer.put_u8(u8::from(self.status));
30911         Ok(())
30912     }
get_total_size(&self) -> usize30913     fn get_total_size(&self) -> usize {
30914         self.get_size()
30915     }
get_size(&self) -> usize30916     fn get_size(&self) -> usize {
30917         2
30918     }
30919 }
30920 #[derive(Debug, Clone, PartialEq, Eq)]
30921 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30922 pub struct AndroidSetRadarConfigCmdData {
30923     session_token: u32,
30924     tlvs: Vec<RadarConfigTlv>,
30925 }
30926 #[derive(Debug, Clone, PartialEq, Eq)]
30927 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30928 pub struct AndroidSetRadarConfigCmd {
30929     #[cfg_attr(feature = "serde", serde(flatten))]
30930     ucicontrolpacket: UciControlPacketData,
30931     #[cfg_attr(feature = "serde", serde(flatten))]
30932     ucicommand: UciCommandData,
30933     #[cfg_attr(feature = "serde", serde(flatten))]
30934     androidcommand: AndroidCommandData,
30935     #[cfg_attr(feature = "serde", serde(flatten))]
30936     androidsetradarconfigcmd: AndroidSetRadarConfigCmdData,
30937 }
30938 #[derive(Debug)]
30939 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
30940 pub struct AndroidSetRadarConfigCmdBuilder {
30941     pub session_token: u32,
30942     pub tlvs: Vec<RadarConfigTlv>,
30943 }
30944 impl AndroidSetRadarConfigCmdData {
conforms(bytes: &[u8]) -> bool30945     fn conforms(bytes: &[u8]) -> bool {
30946         bytes.len() >= 5
30947     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>30948     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
30949         let mut cell = Cell::new(bytes);
30950         let packet = Self::parse_inner(&mut cell)?;
30951         Ok(packet)
30952     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>30953     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
30954         if bytes.get().remaining() < 4 {
30955             return Err(DecodeError::InvalidLengthError {
30956                 obj: "AndroidSetRadarConfigCmd",
30957                 wanted: 4,
30958                 got: bytes.get().remaining(),
30959             });
30960         }
30961         let session_token = bytes.get_mut().get_u32_le();
30962         if bytes.get().remaining() < 1 {
30963             return Err(DecodeError::InvalidLengthError {
30964                 obj: "AndroidSetRadarConfigCmd",
30965                 wanted: 1,
30966                 got: bytes.get().remaining(),
30967             });
30968         }
30969         let tlvs_count = bytes.get_mut().get_u8() as usize;
30970         let tlvs = (0..tlvs_count)
30971             .map(|_| RadarConfigTlv::parse_inner(bytes))
30972             .collect::<Result<Vec<_>, DecodeError>>()?;
30973         Ok(Self { session_token, tlvs })
30974     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>30975     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
30976         buffer.put_u32_le(self.session_token);
30977         buffer.put_u8(self.tlvs.len() as u8);
30978         for elem in &self.tlvs {
30979             elem.write_to(buffer)?;
30980         }
30981         Ok(())
30982     }
get_total_size(&self) -> usize30983     fn get_total_size(&self) -> usize {
30984         self.get_size()
30985     }
get_size(&self) -> usize30986     fn get_size(&self) -> usize {
30987         5 + self.tlvs.iter().map(|elem| elem.get_size()).sum::<usize>()
30988     }
30989 }
30990 impl Packet for AndroidSetRadarConfigCmd {
encoded_len(&self) -> usize30991     fn encoded_len(&self) -> usize {
30992         self.get_size()
30993     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>30994     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
30995         self.ucicontrolpacket.write_to(buf)
30996     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>30997     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
30998         unimplemented!("Rust legacy does not implement full packet trait")
30999     }
31000 }
31001 impl TryFrom<AndroidSetRadarConfigCmd> for Bytes {
31002     type Error = EncodeError;
try_from(packet: AndroidSetRadarConfigCmd) -> Result<Self, Self::Error>31003     fn try_from(packet: AndroidSetRadarConfigCmd) -> Result<Self, Self::Error> {
31004         packet.encode_to_bytes()
31005     }
31006 }
31007 impl TryFrom<AndroidSetRadarConfigCmd> for Vec<u8> {
31008     type Error = EncodeError;
try_from(packet: AndroidSetRadarConfigCmd) -> Result<Self, Self::Error>31009     fn try_from(packet: AndroidSetRadarConfigCmd) -> Result<Self, Self::Error> {
31010         packet.encode_to_vec()
31011     }
31012 }
31013 impl From<AndroidSetRadarConfigCmd> for UciControlPacket {
from(packet: AndroidSetRadarConfigCmd) -> UciControlPacket31014     fn from(packet: AndroidSetRadarConfigCmd) -> UciControlPacket {
31015         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
31016     }
31017 }
31018 impl From<AndroidSetRadarConfigCmd> for UciCommand {
from(packet: AndroidSetRadarConfigCmd) -> UciCommand31019     fn from(packet: AndroidSetRadarConfigCmd) -> UciCommand {
31020         UciCommand::new(packet.ucicontrolpacket).unwrap()
31021     }
31022 }
31023 impl From<AndroidSetRadarConfigCmd> for AndroidCommand {
from(packet: AndroidSetRadarConfigCmd) -> AndroidCommand31024     fn from(packet: AndroidSetRadarConfigCmd) -> AndroidCommand {
31025         AndroidCommand::new(packet.ucicontrolpacket).unwrap()
31026     }
31027 }
31028 impl TryFrom<UciControlPacket> for AndroidSetRadarConfigCmd {
31029     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<AndroidSetRadarConfigCmd, Self::Error>31030     fn try_from(
31031         packet: UciControlPacket,
31032     ) -> Result<AndroidSetRadarConfigCmd, Self::Error> {
31033         AndroidSetRadarConfigCmd::new(packet.ucicontrolpacket)
31034     }
31035 }
31036 impl AndroidSetRadarConfigCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>31037     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
31038         let mut cell = Cell::new(bytes);
31039         let packet = Self::parse_inner(&mut cell)?;
31040         Ok(packet)
31041     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>31042     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
31043         let data = UciControlPacketData::parse_inner(&mut bytes)?;
31044         Self::new(data)
31045     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>31046     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
31047         let ucicommand = match &ucicontrolpacket.child {
31048             UciControlPacketDataChild::UciCommand(value) => value.clone(),
31049             _ => {
31050                 return Err(DecodeError::InvalidChildError {
31051                     expected: stringify!(UciControlPacketDataChild::UciCommand),
31052                     actual: format!("{:?}", & ucicontrolpacket.child),
31053                 });
31054             }
31055         };
31056         let androidcommand = match &ucicommand.child {
31057             UciCommandDataChild::AndroidCommand(value) => value.clone(),
31058             _ => {
31059                 return Err(DecodeError::InvalidChildError {
31060                     expected: stringify!(UciCommandDataChild::AndroidCommand),
31061                     actual: format!("{:?}", & ucicommand.child),
31062                 });
31063             }
31064         };
31065         let androidsetradarconfigcmd = match &androidcommand.child {
31066             AndroidCommandDataChild::AndroidSetRadarConfigCmd(value) => value.clone(),
31067             _ => {
31068                 return Err(DecodeError::InvalidChildError {
31069                     expected: stringify!(
31070                         AndroidCommandDataChild::AndroidSetRadarConfigCmd
31071                     ),
31072                     actual: format!("{:?}", & androidcommand.child),
31073                 });
31074             }
31075         };
31076         Ok(Self {
31077             ucicontrolpacket,
31078             ucicommand,
31079             androidcommand,
31080             androidsetradarconfigcmd,
31081         })
31082     }
get_group_id(&self) -> GroupId31083     pub fn get_group_id(&self) -> GroupId {
31084         self.ucicontrolpacket.group_id
31085     }
get_message_type(&self) -> MessageType31086     pub fn get_message_type(&self) -> MessageType {
31087         self.ucicontrolpacket.message_type
31088     }
get_opcode(&self) -> u831089     pub fn get_opcode(&self) -> u8 {
31090         self.ucicontrolpacket.opcode
31091     }
get_session_token(&self) -> u3231092     pub fn get_session_token(&self) -> u32 {
31093         self.androidsetradarconfigcmd.session_token
31094     }
get_tlvs(&self) -> &Vec<RadarConfigTlv>31095     pub fn get_tlvs(&self) -> &Vec<RadarConfigTlv> {
31096         &self.androidsetradarconfigcmd.tlvs
31097     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>31098     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
31099         self.androidsetradarconfigcmd.write_to(buffer)
31100     }
get_size(&self) -> usize31101     pub fn get_size(&self) -> usize {
31102         self.ucicontrolpacket.get_size()
31103     }
31104 }
31105 impl AndroidSetRadarConfigCmdBuilder {
build(self) -> AndroidSetRadarConfigCmd31106     pub fn build(self) -> AndroidSetRadarConfigCmd {
31107         let androidsetradarconfigcmd = AndroidSetRadarConfigCmdData {
31108             session_token: self.session_token,
31109             tlvs: self.tlvs,
31110         };
31111         let androidcommand = AndroidCommandData {
31112             child: AndroidCommandDataChild::AndroidSetRadarConfigCmd(
31113                 androidsetradarconfigcmd,
31114             ),
31115         };
31116         let ucicommand = UciCommandData {
31117             child: UciCommandDataChild::AndroidCommand(androidcommand),
31118         };
31119         let ucicontrolpacket = UciControlPacketData {
31120             group_id: GroupId::VendorAndroid,
31121             message_type: MessageType::Command,
31122             opcode: 17,
31123             child: UciControlPacketDataChild::UciCommand(ucicommand),
31124         };
31125         AndroidSetRadarConfigCmd::new(ucicontrolpacket).unwrap()
31126     }
31127 }
31128 impl From<AndroidSetRadarConfigCmdBuilder> for UciControlPacket {
from(builder: AndroidSetRadarConfigCmdBuilder) -> UciControlPacket31129     fn from(builder: AndroidSetRadarConfigCmdBuilder) -> UciControlPacket {
31130         builder.build().into()
31131     }
31132 }
31133 impl From<AndroidSetRadarConfigCmdBuilder> for UciCommand {
from(builder: AndroidSetRadarConfigCmdBuilder) -> UciCommand31134     fn from(builder: AndroidSetRadarConfigCmdBuilder) -> UciCommand {
31135         builder.build().into()
31136     }
31137 }
31138 impl From<AndroidSetRadarConfigCmdBuilder> for AndroidCommand {
from(builder: AndroidSetRadarConfigCmdBuilder) -> AndroidCommand31139     fn from(builder: AndroidSetRadarConfigCmdBuilder) -> AndroidCommand {
31140         builder.build().into()
31141     }
31142 }
31143 impl From<AndroidSetRadarConfigCmdBuilder> for AndroidSetRadarConfigCmd {
from(builder: AndroidSetRadarConfigCmdBuilder) -> AndroidSetRadarConfigCmd31144     fn from(builder: AndroidSetRadarConfigCmdBuilder) -> AndroidSetRadarConfigCmd {
31145         builder.build().into()
31146     }
31147 }
31148 #[derive(Debug, Clone, PartialEq, Eq)]
31149 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31150 pub struct AndroidSetRadarConfigRspData {
31151     status: StatusCode,
31152     cfg_status: Vec<RadarConfigStatus>,
31153 }
31154 #[derive(Debug, Clone, PartialEq, Eq)]
31155 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31156 pub struct AndroidSetRadarConfigRsp {
31157     #[cfg_attr(feature = "serde", serde(flatten))]
31158     ucicontrolpacket: UciControlPacketData,
31159     #[cfg_attr(feature = "serde", serde(flatten))]
31160     uciresponse: UciResponseData,
31161     #[cfg_attr(feature = "serde", serde(flatten))]
31162     androidresponse: AndroidResponseData,
31163     #[cfg_attr(feature = "serde", serde(flatten))]
31164     androidsetradarconfigrsp: AndroidSetRadarConfigRspData,
31165 }
31166 #[derive(Debug)]
31167 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31168 pub struct AndroidSetRadarConfigRspBuilder {
31169     pub cfg_status: Vec<RadarConfigStatus>,
31170     pub status: StatusCode,
31171 }
31172 impl AndroidSetRadarConfigRspData {
conforms(bytes: &[u8]) -> bool31173     fn conforms(bytes: &[u8]) -> bool {
31174         bytes.len() >= 2
31175     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>31176     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
31177         let mut cell = Cell::new(bytes);
31178         let packet = Self::parse_inner(&mut cell)?;
31179         Ok(packet)
31180     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>31181     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
31182         if bytes.get().remaining() < 1 {
31183             return Err(DecodeError::InvalidLengthError {
31184                 obj: "AndroidSetRadarConfigRsp",
31185                 wanted: 1,
31186                 got: bytes.get().remaining(),
31187             });
31188         }
31189         let status = StatusCode::try_from(bytes.get_mut().get_u8())
31190             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
31191                 obj: "AndroidSetRadarConfigRsp",
31192                 field: "status",
31193                 value: unknown_val as u64,
31194                 type_: "StatusCode",
31195             })?;
31196         if bytes.get().remaining() < 1 {
31197             return Err(DecodeError::InvalidLengthError {
31198                 obj: "AndroidSetRadarConfigRsp",
31199                 wanted: 1,
31200                 got: bytes.get().remaining(),
31201             });
31202         }
31203         let cfg_status_count = bytes.get_mut().get_u8() as usize;
31204         if bytes.get().remaining() < cfg_status_count * 2usize {
31205             return Err(DecodeError::InvalidLengthError {
31206                 obj: "AndroidSetRadarConfigRsp",
31207                 wanted: cfg_status_count * 2usize,
31208                 got: bytes.get().remaining(),
31209             });
31210         }
31211         let cfg_status = (0..cfg_status_count)
31212             .map(|_| RadarConfigStatus::parse_inner(bytes))
31213             .collect::<Result<Vec<_>, DecodeError>>()?;
31214         Ok(Self { status, cfg_status })
31215     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>31216     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
31217         buffer.put_u8(u8::from(self.status));
31218         buffer.put_u8(self.cfg_status.len() as u8);
31219         for elem in &self.cfg_status {
31220             elem.write_to(buffer)?;
31221         }
31222         Ok(())
31223     }
get_total_size(&self) -> usize31224     fn get_total_size(&self) -> usize {
31225         self.get_size()
31226     }
get_size(&self) -> usize31227     fn get_size(&self) -> usize {
31228         2 + self.cfg_status.iter().map(|elem| elem.get_size()).sum::<usize>()
31229     }
31230 }
31231 impl Packet for AndroidSetRadarConfigRsp {
encoded_len(&self) -> usize31232     fn encoded_len(&self) -> usize {
31233         self.get_size()
31234     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>31235     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
31236         self.ucicontrolpacket.write_to(buf)
31237     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>31238     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
31239         unimplemented!("Rust legacy does not implement full packet trait")
31240     }
31241 }
31242 impl TryFrom<AndroidSetRadarConfigRsp> for Bytes {
31243     type Error = EncodeError;
try_from(packet: AndroidSetRadarConfigRsp) -> Result<Self, Self::Error>31244     fn try_from(packet: AndroidSetRadarConfigRsp) -> Result<Self, Self::Error> {
31245         packet.encode_to_bytes()
31246     }
31247 }
31248 impl TryFrom<AndroidSetRadarConfigRsp> for Vec<u8> {
31249     type Error = EncodeError;
try_from(packet: AndroidSetRadarConfigRsp) -> Result<Self, Self::Error>31250     fn try_from(packet: AndroidSetRadarConfigRsp) -> Result<Self, Self::Error> {
31251         packet.encode_to_vec()
31252     }
31253 }
31254 impl From<AndroidSetRadarConfigRsp> for UciControlPacket {
from(packet: AndroidSetRadarConfigRsp) -> UciControlPacket31255     fn from(packet: AndroidSetRadarConfigRsp) -> UciControlPacket {
31256         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
31257     }
31258 }
31259 impl From<AndroidSetRadarConfigRsp> for UciResponse {
from(packet: AndroidSetRadarConfigRsp) -> UciResponse31260     fn from(packet: AndroidSetRadarConfigRsp) -> UciResponse {
31261         UciResponse::new(packet.ucicontrolpacket).unwrap()
31262     }
31263 }
31264 impl From<AndroidSetRadarConfigRsp> for AndroidResponse {
from(packet: AndroidSetRadarConfigRsp) -> AndroidResponse31265     fn from(packet: AndroidSetRadarConfigRsp) -> AndroidResponse {
31266         AndroidResponse::new(packet.ucicontrolpacket).unwrap()
31267     }
31268 }
31269 impl TryFrom<UciControlPacket> for AndroidSetRadarConfigRsp {
31270     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<AndroidSetRadarConfigRsp, Self::Error>31271     fn try_from(
31272         packet: UciControlPacket,
31273     ) -> Result<AndroidSetRadarConfigRsp, Self::Error> {
31274         AndroidSetRadarConfigRsp::new(packet.ucicontrolpacket)
31275     }
31276 }
31277 impl AndroidSetRadarConfigRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>31278     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
31279         let mut cell = Cell::new(bytes);
31280         let packet = Self::parse_inner(&mut cell)?;
31281         Ok(packet)
31282     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>31283     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
31284         let data = UciControlPacketData::parse_inner(&mut bytes)?;
31285         Self::new(data)
31286     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>31287     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
31288         let uciresponse = match &ucicontrolpacket.child {
31289             UciControlPacketDataChild::UciResponse(value) => value.clone(),
31290             _ => {
31291                 return Err(DecodeError::InvalidChildError {
31292                     expected: stringify!(UciControlPacketDataChild::UciResponse),
31293                     actual: format!("{:?}", & ucicontrolpacket.child),
31294                 });
31295             }
31296         };
31297         let androidresponse = match &uciresponse.child {
31298             UciResponseDataChild::AndroidResponse(value) => value.clone(),
31299             _ => {
31300                 return Err(DecodeError::InvalidChildError {
31301                     expected: stringify!(UciResponseDataChild::AndroidResponse),
31302                     actual: format!("{:?}", & uciresponse.child),
31303                 });
31304             }
31305         };
31306         let androidsetradarconfigrsp = match &androidresponse.child {
31307             AndroidResponseDataChild::AndroidSetRadarConfigRsp(value) => value.clone(),
31308             _ => {
31309                 return Err(DecodeError::InvalidChildError {
31310                     expected: stringify!(
31311                         AndroidResponseDataChild::AndroidSetRadarConfigRsp
31312                     ),
31313                     actual: format!("{:?}", & androidresponse.child),
31314                 });
31315             }
31316         };
31317         Ok(Self {
31318             ucicontrolpacket,
31319             uciresponse,
31320             androidresponse,
31321             androidsetradarconfigrsp,
31322         })
31323     }
get_cfg_status(&self) -> &Vec<RadarConfigStatus>31324     pub fn get_cfg_status(&self) -> &Vec<RadarConfigStatus> {
31325         &self.androidsetradarconfigrsp.cfg_status
31326     }
get_group_id(&self) -> GroupId31327     pub fn get_group_id(&self) -> GroupId {
31328         self.ucicontrolpacket.group_id
31329     }
get_message_type(&self) -> MessageType31330     pub fn get_message_type(&self) -> MessageType {
31331         self.ucicontrolpacket.message_type
31332     }
get_opcode(&self) -> u831333     pub fn get_opcode(&self) -> u8 {
31334         self.ucicontrolpacket.opcode
31335     }
get_status(&self) -> StatusCode31336     pub fn get_status(&self) -> StatusCode {
31337         self.androidsetradarconfigrsp.status
31338     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>31339     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
31340         self.androidsetradarconfigrsp.write_to(buffer)
31341     }
get_size(&self) -> usize31342     pub fn get_size(&self) -> usize {
31343         self.ucicontrolpacket.get_size()
31344     }
31345 }
31346 impl AndroidSetRadarConfigRspBuilder {
build(self) -> AndroidSetRadarConfigRsp31347     pub fn build(self) -> AndroidSetRadarConfigRsp {
31348         let androidsetradarconfigrsp = AndroidSetRadarConfigRspData {
31349             cfg_status: self.cfg_status,
31350             status: self.status,
31351         };
31352         let androidresponse = AndroidResponseData {
31353             child: AndroidResponseDataChild::AndroidSetRadarConfigRsp(
31354                 androidsetradarconfigrsp,
31355             ),
31356         };
31357         let uciresponse = UciResponseData {
31358             child: UciResponseDataChild::AndroidResponse(androidresponse),
31359         };
31360         let ucicontrolpacket = UciControlPacketData {
31361             group_id: GroupId::VendorAndroid,
31362             message_type: MessageType::Response,
31363             opcode: 17,
31364             child: UciControlPacketDataChild::UciResponse(uciresponse),
31365         };
31366         AndroidSetRadarConfigRsp::new(ucicontrolpacket).unwrap()
31367     }
31368 }
31369 impl From<AndroidSetRadarConfigRspBuilder> for UciControlPacket {
from(builder: AndroidSetRadarConfigRspBuilder) -> UciControlPacket31370     fn from(builder: AndroidSetRadarConfigRspBuilder) -> UciControlPacket {
31371         builder.build().into()
31372     }
31373 }
31374 impl From<AndroidSetRadarConfigRspBuilder> for UciResponse {
from(builder: AndroidSetRadarConfigRspBuilder) -> UciResponse31375     fn from(builder: AndroidSetRadarConfigRspBuilder) -> UciResponse {
31376         builder.build().into()
31377     }
31378 }
31379 impl From<AndroidSetRadarConfigRspBuilder> for AndroidResponse {
from(builder: AndroidSetRadarConfigRspBuilder) -> AndroidResponse31380     fn from(builder: AndroidSetRadarConfigRspBuilder) -> AndroidResponse {
31381         builder.build().into()
31382     }
31383 }
31384 impl From<AndroidSetRadarConfigRspBuilder> for AndroidSetRadarConfigRsp {
from(builder: AndroidSetRadarConfigRspBuilder) -> AndroidSetRadarConfigRsp31385     fn from(builder: AndroidSetRadarConfigRspBuilder) -> AndroidSetRadarConfigRsp {
31386         builder.build().into()
31387     }
31388 }
31389 #[derive(Debug, Clone, PartialEq, Eq)]
31390 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31391 pub struct AndroidGetRadarConfigCmdData {
31392     session_token: u32,
31393     tlvs: Vec<u8>,
31394 }
31395 #[derive(Debug, Clone, PartialEq, Eq)]
31396 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31397 pub struct AndroidGetRadarConfigCmd {
31398     #[cfg_attr(feature = "serde", serde(flatten))]
31399     ucicontrolpacket: UciControlPacketData,
31400     #[cfg_attr(feature = "serde", serde(flatten))]
31401     ucicommand: UciCommandData,
31402     #[cfg_attr(feature = "serde", serde(flatten))]
31403     androidcommand: AndroidCommandData,
31404     #[cfg_attr(feature = "serde", serde(flatten))]
31405     androidgetradarconfigcmd: AndroidGetRadarConfigCmdData,
31406 }
31407 #[derive(Debug)]
31408 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31409 pub struct AndroidGetRadarConfigCmdBuilder {
31410     pub session_token: u32,
31411     pub tlvs: Vec<u8>,
31412 }
31413 impl AndroidGetRadarConfigCmdData {
conforms(bytes: &[u8]) -> bool31414     fn conforms(bytes: &[u8]) -> bool {
31415         bytes.len() >= 5
31416     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>31417     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
31418         let mut cell = Cell::new(bytes);
31419         let packet = Self::parse_inner(&mut cell)?;
31420         Ok(packet)
31421     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>31422     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
31423         if bytes.get().remaining() < 4 {
31424             return Err(DecodeError::InvalidLengthError {
31425                 obj: "AndroidGetRadarConfigCmd",
31426                 wanted: 4,
31427                 got: bytes.get().remaining(),
31428             });
31429         }
31430         let session_token = bytes.get_mut().get_u32_le();
31431         if bytes.get().remaining() < 1 {
31432             return Err(DecodeError::InvalidLengthError {
31433                 obj: "AndroidGetRadarConfigCmd",
31434                 wanted: 1,
31435                 got: bytes.get().remaining(),
31436             });
31437         }
31438         let tlvs_count = bytes.get_mut().get_u8() as usize;
31439         if bytes.get().remaining() < tlvs_count * 1usize {
31440             return Err(DecodeError::InvalidLengthError {
31441                 obj: "AndroidGetRadarConfigCmd",
31442                 wanted: tlvs_count * 1usize,
31443                 got: bytes.get().remaining(),
31444             });
31445         }
31446         let tlvs = (0..tlvs_count)
31447             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
31448             .collect::<Result<Vec<_>, DecodeError>>()?;
31449         Ok(Self { session_token, tlvs })
31450     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>31451     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
31452         buffer.put_u32_le(self.session_token);
31453         buffer.put_u8(self.tlvs.len() as u8);
31454         for elem in &self.tlvs {
31455             buffer.put_u8(*elem);
31456         }
31457         Ok(())
31458     }
get_total_size(&self) -> usize31459     fn get_total_size(&self) -> usize {
31460         self.get_size()
31461     }
get_size(&self) -> usize31462     fn get_size(&self) -> usize {
31463         5 + self.tlvs.len()
31464     }
31465 }
31466 impl Packet for AndroidGetRadarConfigCmd {
encoded_len(&self) -> usize31467     fn encoded_len(&self) -> usize {
31468         self.get_size()
31469     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>31470     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
31471         self.ucicontrolpacket.write_to(buf)
31472     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>31473     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
31474         unimplemented!("Rust legacy does not implement full packet trait")
31475     }
31476 }
31477 impl TryFrom<AndroidGetRadarConfigCmd> for Bytes {
31478     type Error = EncodeError;
try_from(packet: AndroidGetRadarConfigCmd) -> Result<Self, Self::Error>31479     fn try_from(packet: AndroidGetRadarConfigCmd) -> Result<Self, Self::Error> {
31480         packet.encode_to_bytes()
31481     }
31482 }
31483 impl TryFrom<AndroidGetRadarConfigCmd> for Vec<u8> {
31484     type Error = EncodeError;
try_from(packet: AndroidGetRadarConfigCmd) -> Result<Self, Self::Error>31485     fn try_from(packet: AndroidGetRadarConfigCmd) -> Result<Self, Self::Error> {
31486         packet.encode_to_vec()
31487     }
31488 }
31489 impl From<AndroidGetRadarConfigCmd> for UciControlPacket {
from(packet: AndroidGetRadarConfigCmd) -> UciControlPacket31490     fn from(packet: AndroidGetRadarConfigCmd) -> UciControlPacket {
31491         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
31492     }
31493 }
31494 impl From<AndroidGetRadarConfigCmd> for UciCommand {
from(packet: AndroidGetRadarConfigCmd) -> UciCommand31495     fn from(packet: AndroidGetRadarConfigCmd) -> UciCommand {
31496         UciCommand::new(packet.ucicontrolpacket).unwrap()
31497     }
31498 }
31499 impl From<AndroidGetRadarConfigCmd> for AndroidCommand {
from(packet: AndroidGetRadarConfigCmd) -> AndroidCommand31500     fn from(packet: AndroidGetRadarConfigCmd) -> AndroidCommand {
31501         AndroidCommand::new(packet.ucicontrolpacket).unwrap()
31502     }
31503 }
31504 impl TryFrom<UciControlPacket> for AndroidGetRadarConfigCmd {
31505     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<AndroidGetRadarConfigCmd, Self::Error>31506     fn try_from(
31507         packet: UciControlPacket,
31508     ) -> Result<AndroidGetRadarConfigCmd, Self::Error> {
31509         AndroidGetRadarConfigCmd::new(packet.ucicontrolpacket)
31510     }
31511 }
31512 impl AndroidGetRadarConfigCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>31513     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
31514         let mut cell = Cell::new(bytes);
31515         let packet = Self::parse_inner(&mut cell)?;
31516         Ok(packet)
31517     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>31518     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
31519         let data = UciControlPacketData::parse_inner(&mut bytes)?;
31520         Self::new(data)
31521     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>31522     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
31523         let ucicommand = match &ucicontrolpacket.child {
31524             UciControlPacketDataChild::UciCommand(value) => value.clone(),
31525             _ => {
31526                 return Err(DecodeError::InvalidChildError {
31527                     expected: stringify!(UciControlPacketDataChild::UciCommand),
31528                     actual: format!("{:?}", & ucicontrolpacket.child),
31529                 });
31530             }
31531         };
31532         let androidcommand = match &ucicommand.child {
31533             UciCommandDataChild::AndroidCommand(value) => value.clone(),
31534             _ => {
31535                 return Err(DecodeError::InvalidChildError {
31536                     expected: stringify!(UciCommandDataChild::AndroidCommand),
31537                     actual: format!("{:?}", & ucicommand.child),
31538                 });
31539             }
31540         };
31541         let androidgetradarconfigcmd = match &androidcommand.child {
31542             AndroidCommandDataChild::AndroidGetRadarConfigCmd(value) => value.clone(),
31543             _ => {
31544                 return Err(DecodeError::InvalidChildError {
31545                     expected: stringify!(
31546                         AndroidCommandDataChild::AndroidGetRadarConfigCmd
31547                     ),
31548                     actual: format!("{:?}", & androidcommand.child),
31549                 });
31550             }
31551         };
31552         Ok(Self {
31553             ucicontrolpacket,
31554             ucicommand,
31555             androidcommand,
31556             androidgetradarconfigcmd,
31557         })
31558     }
get_group_id(&self) -> GroupId31559     pub fn get_group_id(&self) -> GroupId {
31560         self.ucicontrolpacket.group_id
31561     }
get_message_type(&self) -> MessageType31562     pub fn get_message_type(&self) -> MessageType {
31563         self.ucicontrolpacket.message_type
31564     }
get_opcode(&self) -> u831565     pub fn get_opcode(&self) -> u8 {
31566         self.ucicontrolpacket.opcode
31567     }
get_session_token(&self) -> u3231568     pub fn get_session_token(&self) -> u32 {
31569         self.androidgetradarconfigcmd.session_token
31570     }
get_tlvs(&self) -> &Vec<u8>31571     pub fn get_tlvs(&self) -> &Vec<u8> {
31572         &self.androidgetradarconfigcmd.tlvs
31573     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>31574     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
31575         self.androidgetradarconfigcmd.write_to(buffer)
31576     }
get_size(&self) -> usize31577     pub fn get_size(&self) -> usize {
31578         self.ucicontrolpacket.get_size()
31579     }
31580 }
31581 impl AndroidGetRadarConfigCmdBuilder {
build(self) -> AndroidGetRadarConfigCmd31582     pub fn build(self) -> AndroidGetRadarConfigCmd {
31583         let androidgetradarconfigcmd = AndroidGetRadarConfigCmdData {
31584             session_token: self.session_token,
31585             tlvs: self.tlvs,
31586         };
31587         let androidcommand = AndroidCommandData {
31588             child: AndroidCommandDataChild::AndroidGetRadarConfigCmd(
31589                 androidgetradarconfigcmd,
31590             ),
31591         };
31592         let ucicommand = UciCommandData {
31593             child: UciCommandDataChild::AndroidCommand(androidcommand),
31594         };
31595         let ucicontrolpacket = UciControlPacketData {
31596             group_id: GroupId::VendorAndroid,
31597             message_type: MessageType::Command,
31598             opcode: 18,
31599             child: UciControlPacketDataChild::UciCommand(ucicommand),
31600         };
31601         AndroidGetRadarConfigCmd::new(ucicontrolpacket).unwrap()
31602     }
31603 }
31604 impl From<AndroidGetRadarConfigCmdBuilder> for UciControlPacket {
from(builder: AndroidGetRadarConfigCmdBuilder) -> UciControlPacket31605     fn from(builder: AndroidGetRadarConfigCmdBuilder) -> UciControlPacket {
31606         builder.build().into()
31607     }
31608 }
31609 impl From<AndroidGetRadarConfigCmdBuilder> for UciCommand {
from(builder: AndroidGetRadarConfigCmdBuilder) -> UciCommand31610     fn from(builder: AndroidGetRadarConfigCmdBuilder) -> UciCommand {
31611         builder.build().into()
31612     }
31613 }
31614 impl From<AndroidGetRadarConfigCmdBuilder> for AndroidCommand {
from(builder: AndroidGetRadarConfigCmdBuilder) -> AndroidCommand31615     fn from(builder: AndroidGetRadarConfigCmdBuilder) -> AndroidCommand {
31616         builder.build().into()
31617     }
31618 }
31619 impl From<AndroidGetRadarConfigCmdBuilder> for AndroidGetRadarConfigCmd {
from(builder: AndroidGetRadarConfigCmdBuilder) -> AndroidGetRadarConfigCmd31620     fn from(builder: AndroidGetRadarConfigCmdBuilder) -> AndroidGetRadarConfigCmd {
31621         builder.build().into()
31622     }
31623 }
31624 #[derive(Debug, Clone, PartialEq, Eq)]
31625 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31626 pub struct AndroidGetRadarConfigRspData {
31627     status: StatusCode,
31628     tlvs: Vec<RadarConfigTlv>,
31629 }
31630 #[derive(Debug, Clone, PartialEq, Eq)]
31631 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31632 pub struct AndroidGetRadarConfigRsp {
31633     #[cfg_attr(feature = "serde", serde(flatten))]
31634     ucicontrolpacket: UciControlPacketData,
31635     #[cfg_attr(feature = "serde", serde(flatten))]
31636     uciresponse: UciResponseData,
31637     #[cfg_attr(feature = "serde", serde(flatten))]
31638     androidresponse: AndroidResponseData,
31639     #[cfg_attr(feature = "serde", serde(flatten))]
31640     androidgetradarconfigrsp: AndroidGetRadarConfigRspData,
31641 }
31642 #[derive(Debug)]
31643 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31644 pub struct AndroidGetRadarConfigRspBuilder {
31645     pub status: StatusCode,
31646     pub tlvs: Vec<RadarConfigTlv>,
31647 }
31648 impl AndroidGetRadarConfigRspData {
conforms(bytes: &[u8]) -> bool31649     fn conforms(bytes: &[u8]) -> bool {
31650         bytes.len() >= 2
31651     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>31652     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
31653         let mut cell = Cell::new(bytes);
31654         let packet = Self::parse_inner(&mut cell)?;
31655         Ok(packet)
31656     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>31657     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
31658         if bytes.get().remaining() < 1 {
31659             return Err(DecodeError::InvalidLengthError {
31660                 obj: "AndroidGetRadarConfigRsp",
31661                 wanted: 1,
31662                 got: bytes.get().remaining(),
31663             });
31664         }
31665         let status = StatusCode::try_from(bytes.get_mut().get_u8())
31666             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
31667                 obj: "AndroidGetRadarConfigRsp",
31668                 field: "status",
31669                 value: unknown_val as u64,
31670                 type_: "StatusCode",
31671             })?;
31672         if bytes.get().remaining() < 1 {
31673             return Err(DecodeError::InvalidLengthError {
31674                 obj: "AndroidGetRadarConfigRsp",
31675                 wanted: 1,
31676                 got: bytes.get().remaining(),
31677             });
31678         }
31679         let tlvs_count = bytes.get_mut().get_u8() as usize;
31680         let tlvs = (0..tlvs_count)
31681             .map(|_| RadarConfigTlv::parse_inner(bytes))
31682             .collect::<Result<Vec<_>, DecodeError>>()?;
31683         Ok(Self { status, tlvs })
31684     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>31685     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
31686         buffer.put_u8(u8::from(self.status));
31687         buffer.put_u8(self.tlvs.len() as u8);
31688         for elem in &self.tlvs {
31689             elem.write_to(buffer)?;
31690         }
31691         Ok(())
31692     }
get_total_size(&self) -> usize31693     fn get_total_size(&self) -> usize {
31694         self.get_size()
31695     }
get_size(&self) -> usize31696     fn get_size(&self) -> usize {
31697         2 + self.tlvs.iter().map(|elem| elem.get_size()).sum::<usize>()
31698     }
31699 }
31700 impl Packet for AndroidGetRadarConfigRsp {
encoded_len(&self) -> usize31701     fn encoded_len(&self) -> usize {
31702         self.get_size()
31703     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>31704     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
31705         self.ucicontrolpacket.write_to(buf)
31706     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>31707     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
31708         unimplemented!("Rust legacy does not implement full packet trait")
31709     }
31710 }
31711 impl TryFrom<AndroidGetRadarConfigRsp> for Bytes {
31712     type Error = EncodeError;
try_from(packet: AndroidGetRadarConfigRsp) -> Result<Self, Self::Error>31713     fn try_from(packet: AndroidGetRadarConfigRsp) -> Result<Self, Self::Error> {
31714         packet.encode_to_bytes()
31715     }
31716 }
31717 impl TryFrom<AndroidGetRadarConfigRsp> for Vec<u8> {
31718     type Error = EncodeError;
try_from(packet: AndroidGetRadarConfigRsp) -> Result<Self, Self::Error>31719     fn try_from(packet: AndroidGetRadarConfigRsp) -> Result<Self, Self::Error> {
31720         packet.encode_to_vec()
31721     }
31722 }
31723 impl From<AndroidGetRadarConfigRsp> for UciControlPacket {
from(packet: AndroidGetRadarConfigRsp) -> UciControlPacket31724     fn from(packet: AndroidGetRadarConfigRsp) -> UciControlPacket {
31725         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
31726     }
31727 }
31728 impl From<AndroidGetRadarConfigRsp> for UciResponse {
from(packet: AndroidGetRadarConfigRsp) -> UciResponse31729     fn from(packet: AndroidGetRadarConfigRsp) -> UciResponse {
31730         UciResponse::new(packet.ucicontrolpacket).unwrap()
31731     }
31732 }
31733 impl From<AndroidGetRadarConfigRsp> for AndroidResponse {
from(packet: AndroidGetRadarConfigRsp) -> AndroidResponse31734     fn from(packet: AndroidGetRadarConfigRsp) -> AndroidResponse {
31735         AndroidResponse::new(packet.ucicontrolpacket).unwrap()
31736     }
31737 }
31738 impl TryFrom<UciControlPacket> for AndroidGetRadarConfigRsp {
31739     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<AndroidGetRadarConfigRsp, Self::Error>31740     fn try_from(
31741         packet: UciControlPacket,
31742     ) -> Result<AndroidGetRadarConfigRsp, Self::Error> {
31743         AndroidGetRadarConfigRsp::new(packet.ucicontrolpacket)
31744     }
31745 }
31746 impl AndroidGetRadarConfigRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>31747     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
31748         let mut cell = Cell::new(bytes);
31749         let packet = Self::parse_inner(&mut cell)?;
31750         Ok(packet)
31751     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>31752     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
31753         let data = UciControlPacketData::parse_inner(&mut bytes)?;
31754         Self::new(data)
31755     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>31756     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
31757         let uciresponse = match &ucicontrolpacket.child {
31758             UciControlPacketDataChild::UciResponse(value) => value.clone(),
31759             _ => {
31760                 return Err(DecodeError::InvalidChildError {
31761                     expected: stringify!(UciControlPacketDataChild::UciResponse),
31762                     actual: format!("{:?}", & ucicontrolpacket.child),
31763                 });
31764             }
31765         };
31766         let androidresponse = match &uciresponse.child {
31767             UciResponseDataChild::AndroidResponse(value) => value.clone(),
31768             _ => {
31769                 return Err(DecodeError::InvalidChildError {
31770                     expected: stringify!(UciResponseDataChild::AndroidResponse),
31771                     actual: format!("{:?}", & uciresponse.child),
31772                 });
31773             }
31774         };
31775         let androidgetradarconfigrsp = match &androidresponse.child {
31776             AndroidResponseDataChild::AndroidGetRadarConfigRsp(value) => value.clone(),
31777             _ => {
31778                 return Err(DecodeError::InvalidChildError {
31779                     expected: stringify!(
31780                         AndroidResponseDataChild::AndroidGetRadarConfigRsp
31781                     ),
31782                     actual: format!("{:?}", & androidresponse.child),
31783                 });
31784             }
31785         };
31786         Ok(Self {
31787             ucicontrolpacket,
31788             uciresponse,
31789             androidresponse,
31790             androidgetradarconfigrsp,
31791         })
31792     }
get_group_id(&self) -> GroupId31793     pub fn get_group_id(&self) -> GroupId {
31794         self.ucicontrolpacket.group_id
31795     }
get_message_type(&self) -> MessageType31796     pub fn get_message_type(&self) -> MessageType {
31797         self.ucicontrolpacket.message_type
31798     }
get_opcode(&self) -> u831799     pub fn get_opcode(&self) -> u8 {
31800         self.ucicontrolpacket.opcode
31801     }
get_status(&self) -> StatusCode31802     pub fn get_status(&self) -> StatusCode {
31803         self.androidgetradarconfigrsp.status
31804     }
get_tlvs(&self) -> &Vec<RadarConfigTlv>31805     pub fn get_tlvs(&self) -> &Vec<RadarConfigTlv> {
31806         &self.androidgetradarconfigrsp.tlvs
31807     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>31808     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
31809         self.androidgetradarconfigrsp.write_to(buffer)
31810     }
get_size(&self) -> usize31811     pub fn get_size(&self) -> usize {
31812         self.ucicontrolpacket.get_size()
31813     }
31814 }
31815 impl AndroidGetRadarConfigRspBuilder {
build(self) -> AndroidGetRadarConfigRsp31816     pub fn build(self) -> AndroidGetRadarConfigRsp {
31817         let androidgetradarconfigrsp = AndroidGetRadarConfigRspData {
31818             status: self.status,
31819             tlvs: self.tlvs,
31820         };
31821         let androidresponse = AndroidResponseData {
31822             child: AndroidResponseDataChild::AndroidGetRadarConfigRsp(
31823                 androidgetradarconfigrsp,
31824             ),
31825         };
31826         let uciresponse = UciResponseData {
31827             child: UciResponseDataChild::AndroidResponse(androidresponse),
31828         };
31829         let ucicontrolpacket = UciControlPacketData {
31830             group_id: GroupId::VendorAndroid,
31831             message_type: MessageType::Response,
31832             opcode: 18,
31833             child: UciControlPacketDataChild::UciResponse(uciresponse),
31834         };
31835         AndroidGetRadarConfigRsp::new(ucicontrolpacket).unwrap()
31836     }
31837 }
31838 impl From<AndroidGetRadarConfigRspBuilder> for UciControlPacket {
from(builder: AndroidGetRadarConfigRspBuilder) -> UciControlPacket31839     fn from(builder: AndroidGetRadarConfigRspBuilder) -> UciControlPacket {
31840         builder.build().into()
31841     }
31842 }
31843 impl From<AndroidGetRadarConfigRspBuilder> for UciResponse {
from(builder: AndroidGetRadarConfigRspBuilder) -> UciResponse31844     fn from(builder: AndroidGetRadarConfigRspBuilder) -> UciResponse {
31845         builder.build().into()
31846     }
31847 }
31848 impl From<AndroidGetRadarConfigRspBuilder> for AndroidResponse {
from(builder: AndroidGetRadarConfigRspBuilder) -> AndroidResponse31849     fn from(builder: AndroidGetRadarConfigRspBuilder) -> AndroidResponse {
31850         builder.build().into()
31851     }
31852 }
31853 impl From<AndroidGetRadarConfigRspBuilder> for AndroidGetRadarConfigRsp {
from(builder: AndroidGetRadarConfigRspBuilder) -> AndroidGetRadarConfigRsp31854     fn from(builder: AndroidGetRadarConfigRspBuilder) -> AndroidGetRadarConfigRsp {
31855         builder.build().into()
31856     }
31857 }
31858 #[repr(u64)]
31859 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
31860 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31861 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
31862 pub enum BitsPerSample {
31863     Value32 = 0x0,
31864     Value48 = 0x1,
31865     Value64 = 0x2,
31866 }
31867 impl TryFrom<u8> for BitsPerSample {
31868     type Error = u8;
try_from(value: u8) -> Result<Self, Self::Error>31869     fn try_from(value: u8) -> Result<Self, Self::Error> {
31870         match value {
31871             0x0 => Ok(BitsPerSample::Value32),
31872             0x1 => Ok(BitsPerSample::Value48),
31873             0x2 => Ok(BitsPerSample::Value64),
31874             _ => Err(value),
31875         }
31876     }
31877 }
31878 impl From<&BitsPerSample> for u8 {
from(value: &BitsPerSample) -> Self31879     fn from(value: &BitsPerSample) -> Self {
31880         match value {
31881             BitsPerSample::Value32 => 0x0,
31882             BitsPerSample::Value48 => 0x1,
31883             BitsPerSample::Value64 => 0x2,
31884         }
31885     }
31886 }
31887 impl From<BitsPerSample> for u8 {
from(value: BitsPerSample) -> Self31888     fn from(value: BitsPerSample) -> Self {
31889         (&value).into()
31890     }
31891 }
31892 impl From<BitsPerSample> for i16 {
from(value: BitsPerSample) -> Self31893     fn from(value: BitsPerSample) -> Self {
31894         u8::from(value) as Self
31895     }
31896 }
31897 impl From<BitsPerSample> for i32 {
from(value: BitsPerSample) -> Self31898     fn from(value: BitsPerSample) -> Self {
31899         u8::from(value) as Self
31900     }
31901 }
31902 impl From<BitsPerSample> for i64 {
from(value: BitsPerSample) -> Self31903     fn from(value: BitsPerSample) -> Self {
31904         u8::from(value) as Self
31905     }
31906 }
31907 impl From<BitsPerSample> for u16 {
from(value: BitsPerSample) -> Self31908     fn from(value: BitsPerSample) -> Self {
31909         u8::from(value) as Self
31910     }
31911 }
31912 impl From<BitsPerSample> for u32 {
from(value: BitsPerSample) -> Self31913     fn from(value: BitsPerSample) -> Self {
31914         u8::from(value) as Self
31915     }
31916 }
31917 impl From<BitsPerSample> for u64 {
from(value: BitsPerSample) -> Self31918     fn from(value: BitsPerSample) -> Self {
31919         u8::from(value) as Self
31920     }
31921 }
31922 #[derive(Debug, Clone, PartialEq, Eq)]
31923 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
31924 pub struct RadarSweepDataRaw {
31925     pub sequence_number: u32,
31926     pub timestamp: u32,
31927     pub vendor_specific_data: Vec<u8>,
31928     pub sample_data: Vec<u8>,
31929 }
31930 impl RadarSweepDataRaw {
conforms(bytes: &[u8]) -> bool31931     fn conforms(bytes: &[u8]) -> bool {
31932         bytes.len() >= 9
31933     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>31934     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
31935         let mut cell = Cell::new(bytes);
31936         let packet = Self::parse_inner(&mut cell)?;
31937         Ok(packet)
31938     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>31939     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
31940         if bytes.get().remaining() < 4 {
31941             return Err(DecodeError::InvalidLengthError {
31942                 obj: "RadarSweepDataRaw",
31943                 wanted: 4,
31944                 got: bytes.get().remaining(),
31945             });
31946         }
31947         let sequence_number = bytes.get_mut().get_u32_le();
31948         if bytes.get().remaining() < 4 {
31949             return Err(DecodeError::InvalidLengthError {
31950                 obj: "RadarSweepDataRaw",
31951                 wanted: 4,
31952                 got: bytes.get().remaining(),
31953             });
31954         }
31955         let timestamp = bytes.get_mut().get_u32_le();
31956         if bytes.get().remaining() < 1 {
31957             return Err(DecodeError::InvalidLengthError {
31958                 obj: "RadarSweepDataRaw",
31959                 wanted: 1,
31960                 got: bytes.get().remaining(),
31961             });
31962         }
31963         let vendor_specific_data_count = bytes.get_mut().get_u8() as usize;
31964         if bytes.get().remaining() < vendor_specific_data_count * 1usize {
31965             return Err(DecodeError::InvalidLengthError {
31966                 obj: "RadarSweepDataRaw",
31967                 wanted: vendor_specific_data_count * 1usize,
31968                 got: bytes.get().remaining(),
31969             });
31970         }
31971         let vendor_specific_data = (0..vendor_specific_data_count)
31972             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
31973             .collect::<Result<Vec<_>, DecodeError>>()?;
31974         let mut sample_data = Vec::with_capacity(bytes.get().remaining());
31975         for _ in 0..bytes.get().remaining() {
31976             sample_data.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
31977         }
31978         Ok(Self {
31979             sequence_number,
31980             timestamp,
31981             vendor_specific_data,
31982             sample_data,
31983         })
31984     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>31985     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
31986         buffer.put_u32_le(self.sequence_number);
31987         buffer.put_u32_le(self.timestamp);
31988         buffer.put_u8(self.vendor_specific_data.len() as u8);
31989         for elem in &self.vendor_specific_data {
31990             buffer.put_u8(*elem);
31991         }
31992         for elem in &self.sample_data {
31993             buffer.put_u8(*elem);
31994         }
31995         Ok(())
31996     }
get_total_size(&self) -> usize31997     fn get_total_size(&self) -> usize {
31998         self.get_size()
31999     }
get_size(&self) -> usize32000     fn get_size(&self) -> usize {
32001         9 + self.vendor_specific_data.len() + self.sample_data.len()
32002     }
32003 }
32004 #[derive(Debug, Clone, PartialEq, Eq)]
32005 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32006 pub struct RadarDataRcvData {
32007     session_handle: u32,
32008     status: DataRcvStatusCode,
32009     radar_data_type: RadarDataType,
32010     number_of_sweeps: u8,
32011     samples_per_sweep: u8,
32012     bits_per_sample: BitsPerSample,
32013     sweep_offset: u16,
32014     sweep_data_size: u16,
32015     sweep_data: Vec<u8>,
32016 }
32017 #[derive(Debug, Clone, PartialEq, Eq)]
32018 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32019 pub struct RadarDataRcv {
32020     #[cfg_attr(feature = "serde", serde(flatten))]
32021     ucidatapacket: UciDataPacketData,
32022     #[cfg_attr(feature = "serde", serde(flatten))]
32023     radardatarcv: RadarDataRcvData,
32024 }
32025 #[derive(Debug)]
32026 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32027 pub struct RadarDataRcvBuilder {
32028     pub bits_per_sample: BitsPerSample,
32029     pub number_of_sweeps: u8,
32030     pub radar_data_type: RadarDataType,
32031     pub samples_per_sweep: u8,
32032     pub session_handle: u32,
32033     pub status: DataRcvStatusCode,
32034     pub sweep_data: Vec<u8>,
32035     pub sweep_data_size: u16,
32036     pub sweep_offset: u16,
32037 }
32038 impl RadarDataRcvData {
conforms(bytes: &[u8]) -> bool32039     fn conforms(bytes: &[u8]) -> bool {
32040         bytes.len() >= 13
32041     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>32042     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
32043         let mut cell = Cell::new(bytes);
32044         let packet = Self::parse_inner(&mut cell)?;
32045         Ok(packet)
32046     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>32047     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
32048         if bytes.get().remaining() < 4 {
32049             return Err(DecodeError::InvalidLengthError {
32050                 obj: "RadarDataRcv",
32051                 wanted: 4,
32052                 got: bytes.get().remaining(),
32053             });
32054         }
32055         let session_handle = bytes.get_mut().get_u32_le();
32056         if bytes.get().remaining() < 1 {
32057             return Err(DecodeError::InvalidLengthError {
32058                 obj: "RadarDataRcv",
32059                 wanted: 1,
32060                 got: bytes.get().remaining(),
32061             });
32062         }
32063         let status = DataRcvStatusCode::try_from(bytes.get_mut().get_u8())
32064             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
32065                 obj: "RadarDataRcv",
32066                 field: "status",
32067                 value: unknown_val as u64,
32068                 type_: "DataRcvStatusCode",
32069             })?;
32070         if bytes.get().remaining() < 1 {
32071             return Err(DecodeError::InvalidLengthError {
32072                 obj: "RadarDataRcv",
32073                 wanted: 1,
32074                 got: bytes.get().remaining(),
32075             });
32076         }
32077         let radar_data_type = RadarDataType::try_from(bytes.get_mut().get_u8())
32078             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
32079                 obj: "RadarDataRcv",
32080                 field: "radar_data_type",
32081                 value: unknown_val as u64,
32082                 type_: "RadarDataType",
32083             })?;
32084         if bytes.get().remaining() < 1 {
32085             return Err(DecodeError::InvalidLengthError {
32086                 obj: "RadarDataRcv",
32087                 wanted: 1,
32088                 got: bytes.get().remaining(),
32089             });
32090         }
32091         let number_of_sweeps = bytes.get_mut().get_u8();
32092         if bytes.get().remaining() < 1 {
32093             return Err(DecodeError::InvalidLengthError {
32094                 obj: "RadarDataRcv",
32095                 wanted: 1,
32096                 got: bytes.get().remaining(),
32097             });
32098         }
32099         let samples_per_sweep = bytes.get_mut().get_u8();
32100         if bytes.get().remaining() < 1 {
32101             return Err(DecodeError::InvalidLengthError {
32102                 obj: "RadarDataRcv",
32103                 wanted: 1,
32104                 got: bytes.get().remaining(),
32105             });
32106         }
32107         let bits_per_sample = BitsPerSample::try_from(bytes.get_mut().get_u8())
32108             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
32109                 obj: "RadarDataRcv",
32110                 field: "bits_per_sample",
32111                 value: unknown_val as u64,
32112                 type_: "BitsPerSample",
32113             })?;
32114         if bytes.get().remaining() < 2 {
32115             return Err(DecodeError::InvalidLengthError {
32116                 obj: "RadarDataRcv",
32117                 wanted: 2,
32118                 got: bytes.get().remaining(),
32119             });
32120         }
32121         let sweep_offset = bytes.get_mut().get_u16_le();
32122         if bytes.get().remaining() < 2 {
32123             return Err(DecodeError::InvalidLengthError {
32124                 obj: "RadarDataRcv",
32125                 wanted: 2,
32126                 got: bytes.get().remaining(),
32127             });
32128         }
32129         let sweep_data_size = bytes.get_mut().get_u16_le();
32130         let mut sweep_data = Vec::with_capacity(bytes.get().remaining());
32131         for _ in 0..bytes.get().remaining() {
32132             sweep_data.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
32133         }
32134         Ok(Self {
32135             session_handle,
32136             status,
32137             radar_data_type,
32138             number_of_sweeps,
32139             samples_per_sweep,
32140             bits_per_sample,
32141             sweep_offset,
32142             sweep_data_size,
32143             sweep_data,
32144         })
32145     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>32146     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
32147         buffer.put_u32_le(self.session_handle);
32148         buffer.put_u8(u8::from(self.status));
32149         buffer.put_u8(u8::from(self.radar_data_type));
32150         buffer.put_u8(self.number_of_sweeps);
32151         buffer.put_u8(self.samples_per_sweep);
32152         buffer.put_u8(u8::from(self.bits_per_sample));
32153         buffer.put_u16_le(self.sweep_offset);
32154         buffer.put_u16_le(self.sweep_data_size);
32155         for elem in &self.sweep_data {
32156             buffer.put_u8(*elem);
32157         }
32158         Ok(())
32159     }
get_total_size(&self) -> usize32160     fn get_total_size(&self) -> usize {
32161         self.get_size()
32162     }
get_size(&self) -> usize32163     fn get_size(&self) -> usize {
32164         13 + self.sweep_data.len()
32165     }
32166 }
32167 impl Packet for RadarDataRcv {
encoded_len(&self) -> usize32168     fn encoded_len(&self) -> usize {
32169         self.get_size()
32170     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>32171     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
32172         self.ucidatapacket.write_to(buf)
32173     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>32174     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
32175         unimplemented!("Rust legacy does not implement full packet trait")
32176     }
32177 }
32178 impl TryFrom<RadarDataRcv> for Bytes {
32179     type Error = EncodeError;
try_from(packet: RadarDataRcv) -> Result<Self, Self::Error>32180     fn try_from(packet: RadarDataRcv) -> Result<Self, Self::Error> {
32181         packet.encode_to_bytes()
32182     }
32183 }
32184 impl TryFrom<RadarDataRcv> for Vec<u8> {
32185     type Error = EncodeError;
try_from(packet: RadarDataRcv) -> Result<Self, Self::Error>32186     fn try_from(packet: RadarDataRcv) -> Result<Self, Self::Error> {
32187         packet.encode_to_vec()
32188     }
32189 }
32190 impl From<RadarDataRcv> for UciDataPacket {
from(packet: RadarDataRcv) -> UciDataPacket32191     fn from(packet: RadarDataRcv) -> UciDataPacket {
32192         UciDataPacket::new(packet.ucidatapacket).unwrap()
32193     }
32194 }
32195 impl TryFrom<UciDataPacket> for RadarDataRcv {
32196     type Error = DecodeError;
try_from(packet: UciDataPacket) -> Result<RadarDataRcv, Self::Error>32197     fn try_from(packet: UciDataPacket) -> Result<RadarDataRcv, Self::Error> {
32198         RadarDataRcv::new(packet.ucidatapacket)
32199     }
32200 }
32201 impl RadarDataRcv {
parse(bytes: &[u8]) -> Result<Self, DecodeError>32202     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
32203         let mut cell = Cell::new(bytes);
32204         let packet = Self::parse_inner(&mut cell)?;
32205         Ok(packet)
32206     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>32207     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
32208         let data = UciDataPacketData::parse_inner(&mut bytes)?;
32209         Self::new(data)
32210     }
new(ucidatapacket: UciDataPacketData) -> Result<Self, DecodeError>32211     fn new(ucidatapacket: UciDataPacketData) -> Result<Self, DecodeError> {
32212         let radardatarcv = match &ucidatapacket.child {
32213             UciDataPacketDataChild::RadarDataRcv(value) => value.clone(),
32214             _ => {
32215                 return Err(DecodeError::InvalidChildError {
32216                     expected: stringify!(UciDataPacketDataChild::RadarDataRcv),
32217                     actual: format!("{:?}", & ucidatapacket.child),
32218                 });
32219             }
32220         };
32221         Ok(Self {
32222             ucidatapacket,
32223             radardatarcv,
32224         })
32225     }
get_bits_per_sample(&self) -> BitsPerSample32226     pub fn get_bits_per_sample(&self) -> BitsPerSample {
32227         self.radardatarcv.bits_per_sample
32228     }
get_data_packet_format(&self) -> DataPacketFormat32229     pub fn get_data_packet_format(&self) -> DataPacketFormat {
32230         self.ucidatapacket.data_packet_format
32231     }
get_message_type(&self) -> MessageType32232     pub fn get_message_type(&self) -> MessageType {
32233         self.ucidatapacket.message_type
32234     }
get_number_of_sweeps(&self) -> u832235     pub fn get_number_of_sweeps(&self) -> u8 {
32236         self.radardatarcv.number_of_sweeps
32237     }
get_radar_data_type(&self) -> RadarDataType32238     pub fn get_radar_data_type(&self) -> RadarDataType {
32239         self.radardatarcv.radar_data_type
32240     }
get_samples_per_sweep(&self) -> u832241     pub fn get_samples_per_sweep(&self) -> u8 {
32242         self.radardatarcv.samples_per_sweep
32243     }
get_session_handle(&self) -> u3232244     pub fn get_session_handle(&self) -> u32 {
32245         self.radardatarcv.session_handle
32246     }
get_status(&self) -> DataRcvStatusCode32247     pub fn get_status(&self) -> DataRcvStatusCode {
32248         self.radardatarcv.status
32249     }
get_sweep_data(&self) -> &Vec<u8>32250     pub fn get_sweep_data(&self) -> &Vec<u8> {
32251         &self.radardatarcv.sweep_data
32252     }
get_sweep_data_size(&self) -> u1632253     pub fn get_sweep_data_size(&self) -> u16 {
32254         self.radardatarcv.sweep_data_size
32255     }
get_sweep_offset(&self) -> u1632256     pub fn get_sweep_offset(&self) -> u16 {
32257         self.radardatarcv.sweep_offset
32258     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>32259     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
32260         self.radardatarcv.write_to(buffer)
32261     }
get_size(&self) -> usize32262     pub fn get_size(&self) -> usize {
32263         self.ucidatapacket.get_size()
32264     }
32265 }
32266 impl RadarDataRcvBuilder {
build(self) -> RadarDataRcv32267     pub fn build(self) -> RadarDataRcv {
32268         let radardatarcv = RadarDataRcvData {
32269             bits_per_sample: self.bits_per_sample,
32270             number_of_sweeps: self.number_of_sweeps,
32271             radar_data_type: self.radar_data_type,
32272             samples_per_sweep: self.samples_per_sweep,
32273             session_handle: self.session_handle,
32274             status: self.status,
32275             sweep_data: self.sweep_data,
32276             sweep_data_size: self.sweep_data_size,
32277             sweep_offset: self.sweep_offset,
32278         };
32279         let ucidatapacket = UciDataPacketData {
32280             data_packet_format: DataPacketFormat::RadarDataMessage,
32281             message_type: MessageType::Data,
32282             child: UciDataPacketDataChild::RadarDataRcv(radardatarcv),
32283         };
32284         RadarDataRcv::new(ucidatapacket).unwrap()
32285     }
32286 }
32287 impl From<RadarDataRcvBuilder> for UciDataPacket {
from(builder: RadarDataRcvBuilder) -> UciDataPacket32288     fn from(builder: RadarDataRcvBuilder) -> UciDataPacket {
32289         builder.build().into()
32290     }
32291 }
32292 impl From<RadarDataRcvBuilder> for RadarDataRcv {
from(builder: RadarDataRcvBuilder) -> RadarDataRcv32293     fn from(builder: RadarDataRcvBuilder) -> RadarDataRcv {
32294         builder.build().into()
32295     }
32296 }
32297 #[derive(Debug, Clone, PartialEq, Eq)]
32298 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32299 pub struct RfTestConfigTlv {
32300     pub cfg_id: RfTestConfigTlvType,
32301     pub v: Vec<u8>,
32302 }
32303 impl RfTestConfigTlv {
conforms(bytes: &[u8]) -> bool32304     fn conforms(bytes: &[u8]) -> bool {
32305         bytes.len() >= 2
32306     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>32307     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
32308         let mut cell = Cell::new(bytes);
32309         let packet = Self::parse_inner(&mut cell)?;
32310         Ok(packet)
32311     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>32312     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
32313         if bytes.get().remaining() < 1 {
32314             return Err(DecodeError::InvalidLengthError {
32315                 obj: "RfTestConfigTlv",
32316                 wanted: 1,
32317                 got: bytes.get().remaining(),
32318             });
32319         }
32320         let cfg_id = RfTestConfigTlvType::try_from(bytes.get_mut().get_u8())
32321             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
32322                 obj: "RfTestConfigTlv",
32323                 field: "cfg_id",
32324                 value: unknown_val as u64,
32325                 type_: "RfTestConfigTlvType",
32326             })?;
32327         if bytes.get().remaining() < 1 {
32328             return Err(DecodeError::InvalidLengthError {
32329                 obj: "RfTestConfigTlv",
32330                 wanted: 1,
32331                 got: bytes.get().remaining(),
32332             });
32333         }
32334         let v_count = bytes.get_mut().get_u8() as usize;
32335         if bytes.get().remaining() < v_count * 1usize {
32336             return Err(DecodeError::InvalidLengthError {
32337                 obj: "RfTestConfigTlv",
32338                 wanted: v_count * 1usize,
32339                 got: bytes.get().remaining(),
32340             });
32341         }
32342         let v = (0..v_count)
32343             .map(|_| Ok::<_, DecodeError>(bytes.get_mut().get_u8()))
32344             .collect::<Result<Vec<_>, DecodeError>>()?;
32345         Ok(Self { cfg_id, v })
32346     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>32347     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
32348         buffer.put_u8(u8::from(self.cfg_id));
32349         buffer.put_u8(self.v.len() as u8);
32350         for elem in &self.v {
32351             buffer.put_u8(*elem);
32352         }
32353         Ok(())
32354     }
get_total_size(&self) -> usize32355     fn get_total_size(&self) -> usize {
32356         self.get_size()
32357     }
get_size(&self) -> usize32358     fn get_size(&self) -> usize {
32359         2 + self.v.len()
32360     }
32361 }
32362 #[derive(Debug, Clone, PartialEq, Eq)]
32363 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32364 pub struct SessionSetRfTestConfigCmdData {
32365     session_token: u32,
32366     tlvs: Vec<RfTestConfigTlv>,
32367 }
32368 #[derive(Debug, Clone, PartialEq, Eq)]
32369 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32370 pub struct SessionSetRfTestConfigCmd {
32371     #[cfg_attr(feature = "serde", serde(flatten))]
32372     ucicontrolpacket: UciControlPacketData,
32373     #[cfg_attr(feature = "serde", serde(flatten))]
32374     ucicommand: UciCommandData,
32375     #[cfg_attr(feature = "serde", serde(flatten))]
32376     testcommand: TestCommandData,
32377     #[cfg_attr(feature = "serde", serde(flatten))]
32378     sessionsetrftestconfigcmd: SessionSetRfTestConfigCmdData,
32379 }
32380 #[derive(Debug)]
32381 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32382 pub struct SessionSetRfTestConfigCmdBuilder {
32383     pub session_token: u32,
32384     pub tlvs: Vec<RfTestConfigTlv>,
32385 }
32386 impl SessionSetRfTestConfigCmdData {
conforms(bytes: &[u8]) -> bool32387     fn conforms(bytes: &[u8]) -> bool {
32388         bytes.len() >= 5
32389     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>32390     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
32391         let mut cell = Cell::new(bytes);
32392         let packet = Self::parse_inner(&mut cell)?;
32393         Ok(packet)
32394     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>32395     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
32396         if bytes.get().remaining() < 4 {
32397             return Err(DecodeError::InvalidLengthError {
32398                 obj: "SessionSetRfTestConfigCmd",
32399                 wanted: 4,
32400                 got: bytes.get().remaining(),
32401             });
32402         }
32403         let session_token = bytes.get_mut().get_u32_le();
32404         if bytes.get().remaining() < 1 {
32405             return Err(DecodeError::InvalidLengthError {
32406                 obj: "SessionSetRfTestConfigCmd",
32407                 wanted: 1,
32408                 got: bytes.get().remaining(),
32409             });
32410         }
32411         let tlvs_count = bytes.get_mut().get_u8() as usize;
32412         let tlvs = (0..tlvs_count)
32413             .map(|_| RfTestConfigTlv::parse_inner(bytes))
32414             .collect::<Result<Vec<_>, DecodeError>>()?;
32415         Ok(Self { session_token, tlvs })
32416     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>32417     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
32418         buffer.put_u32_le(self.session_token);
32419         buffer.put_u8(self.tlvs.len() as u8);
32420         for elem in &self.tlvs {
32421             elem.write_to(buffer)?;
32422         }
32423         Ok(())
32424     }
get_total_size(&self) -> usize32425     fn get_total_size(&self) -> usize {
32426         self.get_size()
32427     }
get_size(&self) -> usize32428     fn get_size(&self) -> usize {
32429         5 + self.tlvs.iter().map(|elem| elem.get_size()).sum::<usize>()
32430     }
32431 }
32432 impl Packet for SessionSetRfTestConfigCmd {
encoded_len(&self) -> usize32433     fn encoded_len(&self) -> usize {
32434         self.get_size()
32435     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>32436     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
32437         self.ucicontrolpacket.write_to(buf)
32438     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>32439     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
32440         unimplemented!("Rust legacy does not implement full packet trait")
32441     }
32442 }
32443 impl TryFrom<SessionSetRfTestConfigCmd> for Bytes {
32444     type Error = EncodeError;
try_from(packet: SessionSetRfTestConfigCmd) -> Result<Self, Self::Error>32445     fn try_from(packet: SessionSetRfTestConfigCmd) -> Result<Self, Self::Error> {
32446         packet.encode_to_bytes()
32447     }
32448 }
32449 impl TryFrom<SessionSetRfTestConfigCmd> for Vec<u8> {
32450     type Error = EncodeError;
try_from(packet: SessionSetRfTestConfigCmd) -> Result<Self, Self::Error>32451     fn try_from(packet: SessionSetRfTestConfigCmd) -> Result<Self, Self::Error> {
32452         packet.encode_to_vec()
32453     }
32454 }
32455 impl From<SessionSetRfTestConfigCmd> for UciControlPacket {
from(packet: SessionSetRfTestConfigCmd) -> UciControlPacket32456     fn from(packet: SessionSetRfTestConfigCmd) -> UciControlPacket {
32457         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
32458     }
32459 }
32460 impl From<SessionSetRfTestConfigCmd> for UciCommand {
from(packet: SessionSetRfTestConfigCmd) -> UciCommand32461     fn from(packet: SessionSetRfTestConfigCmd) -> UciCommand {
32462         UciCommand::new(packet.ucicontrolpacket).unwrap()
32463     }
32464 }
32465 impl From<SessionSetRfTestConfigCmd> for TestCommand {
from(packet: SessionSetRfTestConfigCmd) -> TestCommand32466     fn from(packet: SessionSetRfTestConfigCmd) -> TestCommand {
32467         TestCommand::new(packet.ucicontrolpacket).unwrap()
32468     }
32469 }
32470 impl TryFrom<UciControlPacket> for SessionSetRfTestConfigCmd {
32471     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionSetRfTestConfigCmd, Self::Error>32472     fn try_from(
32473         packet: UciControlPacket,
32474     ) -> Result<SessionSetRfTestConfigCmd, Self::Error> {
32475         SessionSetRfTestConfigCmd::new(packet.ucicontrolpacket)
32476     }
32477 }
32478 impl SessionSetRfTestConfigCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>32479     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
32480         let mut cell = Cell::new(bytes);
32481         let packet = Self::parse_inner(&mut cell)?;
32482         Ok(packet)
32483     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>32484     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
32485         let data = UciControlPacketData::parse_inner(&mut bytes)?;
32486         Self::new(data)
32487     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>32488     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
32489         let ucicommand = match &ucicontrolpacket.child {
32490             UciControlPacketDataChild::UciCommand(value) => value.clone(),
32491             _ => {
32492                 return Err(DecodeError::InvalidChildError {
32493                     expected: stringify!(UciControlPacketDataChild::UciCommand),
32494                     actual: format!("{:?}", & ucicontrolpacket.child),
32495                 });
32496             }
32497         };
32498         let testcommand = match &ucicommand.child {
32499             UciCommandDataChild::TestCommand(value) => value.clone(),
32500             _ => {
32501                 return Err(DecodeError::InvalidChildError {
32502                     expected: stringify!(UciCommandDataChild::TestCommand),
32503                     actual: format!("{:?}", & ucicommand.child),
32504                 });
32505             }
32506         };
32507         let sessionsetrftestconfigcmd = match &testcommand.child {
32508             TestCommandDataChild::SessionSetRfTestConfigCmd(value) => value.clone(),
32509             _ => {
32510                 return Err(DecodeError::InvalidChildError {
32511                     expected: stringify!(
32512                         TestCommandDataChild::SessionSetRfTestConfigCmd
32513                     ),
32514                     actual: format!("{:?}", & testcommand.child),
32515                 });
32516             }
32517         };
32518         Ok(Self {
32519             ucicontrolpacket,
32520             ucicommand,
32521             testcommand,
32522             sessionsetrftestconfigcmd,
32523         })
32524     }
get_group_id(&self) -> GroupId32525     pub fn get_group_id(&self) -> GroupId {
32526         self.ucicontrolpacket.group_id
32527     }
get_message_type(&self) -> MessageType32528     pub fn get_message_type(&self) -> MessageType {
32529         self.ucicontrolpacket.message_type
32530     }
get_opcode(&self) -> u832531     pub fn get_opcode(&self) -> u8 {
32532         self.ucicontrolpacket.opcode
32533     }
get_session_token(&self) -> u3232534     pub fn get_session_token(&self) -> u32 {
32535         self.sessionsetrftestconfigcmd.session_token
32536     }
get_tlvs(&self) -> &Vec<RfTestConfigTlv>32537     pub fn get_tlvs(&self) -> &Vec<RfTestConfigTlv> {
32538         &self.sessionsetrftestconfigcmd.tlvs
32539     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>32540     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
32541         self.sessionsetrftestconfigcmd.write_to(buffer)
32542     }
get_size(&self) -> usize32543     pub fn get_size(&self) -> usize {
32544         self.ucicontrolpacket.get_size()
32545     }
32546 }
32547 impl SessionSetRfTestConfigCmdBuilder {
build(self) -> SessionSetRfTestConfigCmd32548     pub fn build(self) -> SessionSetRfTestConfigCmd {
32549         let sessionsetrftestconfigcmd = SessionSetRfTestConfigCmdData {
32550             session_token: self.session_token,
32551             tlvs: self.tlvs,
32552         };
32553         let testcommand = TestCommandData {
32554             child: TestCommandDataChild::SessionSetRfTestConfigCmd(
32555                 sessionsetrftestconfigcmd,
32556             ),
32557         };
32558         let ucicommand = UciCommandData {
32559             child: UciCommandDataChild::TestCommand(testcommand),
32560         };
32561         let ucicontrolpacket = UciControlPacketData {
32562             group_id: GroupId::Test,
32563             message_type: MessageType::Command,
32564             opcode: 0,
32565             child: UciControlPacketDataChild::UciCommand(ucicommand),
32566         };
32567         SessionSetRfTestConfigCmd::new(ucicontrolpacket).unwrap()
32568     }
32569 }
32570 impl From<SessionSetRfTestConfigCmdBuilder> for UciControlPacket {
from(builder: SessionSetRfTestConfigCmdBuilder) -> UciControlPacket32571     fn from(builder: SessionSetRfTestConfigCmdBuilder) -> UciControlPacket {
32572         builder.build().into()
32573     }
32574 }
32575 impl From<SessionSetRfTestConfigCmdBuilder> for UciCommand {
from(builder: SessionSetRfTestConfigCmdBuilder) -> UciCommand32576     fn from(builder: SessionSetRfTestConfigCmdBuilder) -> UciCommand {
32577         builder.build().into()
32578     }
32579 }
32580 impl From<SessionSetRfTestConfigCmdBuilder> for TestCommand {
from(builder: SessionSetRfTestConfigCmdBuilder) -> TestCommand32581     fn from(builder: SessionSetRfTestConfigCmdBuilder) -> TestCommand {
32582         builder.build().into()
32583     }
32584 }
32585 impl From<SessionSetRfTestConfigCmdBuilder> for SessionSetRfTestConfigCmd {
from(builder: SessionSetRfTestConfigCmdBuilder) -> SessionSetRfTestConfigCmd32586     fn from(builder: SessionSetRfTestConfigCmdBuilder) -> SessionSetRfTestConfigCmd {
32587         builder.build().into()
32588     }
32589 }
32590 #[derive(Debug, Clone, PartialEq, Eq)]
32591 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32592 pub struct RfTestConfigStatus {
32593     pub cfg_id: RfTestConfigTlvType,
32594     pub status: StatusCode,
32595 }
32596 impl RfTestConfigStatus {
conforms(bytes: &[u8]) -> bool32597     fn conforms(bytes: &[u8]) -> bool {
32598         bytes.len() >= 2
32599     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>32600     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
32601         let mut cell = Cell::new(bytes);
32602         let packet = Self::parse_inner(&mut cell)?;
32603         Ok(packet)
32604     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>32605     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
32606         if bytes.get().remaining() < 1 {
32607             return Err(DecodeError::InvalidLengthError {
32608                 obj: "RfTestConfigStatus",
32609                 wanted: 1,
32610                 got: bytes.get().remaining(),
32611             });
32612         }
32613         let cfg_id = RfTestConfigTlvType::try_from(bytes.get_mut().get_u8())
32614             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
32615                 obj: "RfTestConfigStatus",
32616                 field: "cfg_id",
32617                 value: unknown_val as u64,
32618                 type_: "RfTestConfigTlvType",
32619             })?;
32620         if bytes.get().remaining() < 1 {
32621             return Err(DecodeError::InvalidLengthError {
32622                 obj: "RfTestConfigStatus",
32623                 wanted: 1,
32624                 got: bytes.get().remaining(),
32625             });
32626         }
32627         let status = StatusCode::try_from(bytes.get_mut().get_u8())
32628             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
32629                 obj: "RfTestConfigStatus",
32630                 field: "status",
32631                 value: unknown_val as u64,
32632                 type_: "StatusCode",
32633             })?;
32634         Ok(Self { cfg_id, status })
32635     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>32636     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
32637         buffer.put_u8(u8::from(self.cfg_id));
32638         buffer.put_u8(u8::from(self.status));
32639         Ok(())
32640     }
get_total_size(&self) -> usize32641     fn get_total_size(&self) -> usize {
32642         self.get_size()
32643     }
get_size(&self) -> usize32644     fn get_size(&self) -> usize {
32645         2
32646     }
32647 }
32648 #[derive(Debug, Clone, PartialEq, Eq)]
32649 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32650 pub struct SessionSetRfTestConfigRspData {
32651     status: StatusCode,
32652     cfg_status: Vec<RfTestConfigStatus>,
32653 }
32654 #[derive(Debug, Clone, PartialEq, Eq)]
32655 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32656 pub struct SessionSetRfTestConfigRsp {
32657     #[cfg_attr(feature = "serde", serde(flatten))]
32658     ucicontrolpacket: UciControlPacketData,
32659     #[cfg_attr(feature = "serde", serde(flatten))]
32660     uciresponse: UciResponseData,
32661     #[cfg_attr(feature = "serde", serde(flatten))]
32662     testresponse: TestResponseData,
32663     #[cfg_attr(feature = "serde", serde(flatten))]
32664     sessionsetrftestconfigrsp: SessionSetRfTestConfigRspData,
32665 }
32666 #[derive(Debug)]
32667 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32668 pub struct SessionSetRfTestConfigRspBuilder {
32669     pub cfg_status: Vec<RfTestConfigStatus>,
32670     pub status: StatusCode,
32671 }
32672 impl SessionSetRfTestConfigRspData {
conforms(bytes: &[u8]) -> bool32673     fn conforms(bytes: &[u8]) -> bool {
32674         bytes.len() >= 2
32675     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>32676     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
32677         let mut cell = Cell::new(bytes);
32678         let packet = Self::parse_inner(&mut cell)?;
32679         Ok(packet)
32680     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>32681     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
32682         if bytes.get().remaining() < 1 {
32683             return Err(DecodeError::InvalidLengthError {
32684                 obj: "SessionSetRfTestConfigRsp",
32685                 wanted: 1,
32686                 got: bytes.get().remaining(),
32687             });
32688         }
32689         let status = StatusCode::try_from(bytes.get_mut().get_u8())
32690             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
32691                 obj: "SessionSetRfTestConfigRsp",
32692                 field: "status",
32693                 value: unknown_val as u64,
32694                 type_: "StatusCode",
32695             })?;
32696         if bytes.get().remaining() < 1 {
32697             return Err(DecodeError::InvalidLengthError {
32698                 obj: "SessionSetRfTestConfigRsp",
32699                 wanted: 1,
32700                 got: bytes.get().remaining(),
32701             });
32702         }
32703         let cfg_status_count = bytes.get_mut().get_u8() as usize;
32704         if bytes.get().remaining() < cfg_status_count * 2usize {
32705             return Err(DecodeError::InvalidLengthError {
32706                 obj: "SessionSetRfTestConfigRsp",
32707                 wanted: cfg_status_count * 2usize,
32708                 got: bytes.get().remaining(),
32709             });
32710         }
32711         let cfg_status = (0..cfg_status_count)
32712             .map(|_| RfTestConfigStatus::parse_inner(bytes))
32713             .collect::<Result<Vec<_>, DecodeError>>()?;
32714         Ok(Self { status, cfg_status })
32715     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>32716     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
32717         buffer.put_u8(u8::from(self.status));
32718         buffer.put_u8(self.cfg_status.len() as u8);
32719         for elem in &self.cfg_status {
32720             elem.write_to(buffer)?;
32721         }
32722         Ok(())
32723     }
get_total_size(&self) -> usize32724     fn get_total_size(&self) -> usize {
32725         self.get_size()
32726     }
get_size(&self) -> usize32727     fn get_size(&self) -> usize {
32728         2 + self.cfg_status.iter().map(|elem| elem.get_size()).sum::<usize>()
32729     }
32730 }
32731 impl Packet for SessionSetRfTestConfigRsp {
encoded_len(&self) -> usize32732     fn encoded_len(&self) -> usize {
32733         self.get_size()
32734     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>32735     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
32736         self.ucicontrolpacket.write_to(buf)
32737     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>32738     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
32739         unimplemented!("Rust legacy does not implement full packet trait")
32740     }
32741 }
32742 impl TryFrom<SessionSetRfTestConfigRsp> for Bytes {
32743     type Error = EncodeError;
try_from(packet: SessionSetRfTestConfigRsp) -> Result<Self, Self::Error>32744     fn try_from(packet: SessionSetRfTestConfigRsp) -> Result<Self, Self::Error> {
32745         packet.encode_to_bytes()
32746     }
32747 }
32748 impl TryFrom<SessionSetRfTestConfigRsp> for Vec<u8> {
32749     type Error = EncodeError;
try_from(packet: SessionSetRfTestConfigRsp) -> Result<Self, Self::Error>32750     fn try_from(packet: SessionSetRfTestConfigRsp) -> Result<Self, Self::Error> {
32751         packet.encode_to_vec()
32752     }
32753 }
32754 impl From<SessionSetRfTestConfigRsp> for UciControlPacket {
from(packet: SessionSetRfTestConfigRsp) -> UciControlPacket32755     fn from(packet: SessionSetRfTestConfigRsp) -> UciControlPacket {
32756         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
32757     }
32758 }
32759 impl From<SessionSetRfTestConfigRsp> for UciResponse {
from(packet: SessionSetRfTestConfigRsp) -> UciResponse32760     fn from(packet: SessionSetRfTestConfigRsp) -> UciResponse {
32761         UciResponse::new(packet.ucicontrolpacket).unwrap()
32762     }
32763 }
32764 impl From<SessionSetRfTestConfigRsp> for TestResponse {
from(packet: SessionSetRfTestConfigRsp) -> TestResponse32765     fn from(packet: SessionSetRfTestConfigRsp) -> TestResponse {
32766         TestResponse::new(packet.ucicontrolpacket).unwrap()
32767     }
32768 }
32769 impl TryFrom<UciControlPacket> for SessionSetRfTestConfigRsp {
32770     type Error = DecodeError;
try_from( packet: UciControlPacket, ) -> Result<SessionSetRfTestConfigRsp, Self::Error>32771     fn try_from(
32772         packet: UciControlPacket,
32773     ) -> Result<SessionSetRfTestConfigRsp, Self::Error> {
32774         SessionSetRfTestConfigRsp::new(packet.ucicontrolpacket)
32775     }
32776 }
32777 impl SessionSetRfTestConfigRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>32778     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
32779         let mut cell = Cell::new(bytes);
32780         let packet = Self::parse_inner(&mut cell)?;
32781         Ok(packet)
32782     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>32783     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
32784         let data = UciControlPacketData::parse_inner(&mut bytes)?;
32785         Self::new(data)
32786     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>32787     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
32788         let uciresponse = match &ucicontrolpacket.child {
32789             UciControlPacketDataChild::UciResponse(value) => value.clone(),
32790             _ => {
32791                 return Err(DecodeError::InvalidChildError {
32792                     expected: stringify!(UciControlPacketDataChild::UciResponse),
32793                     actual: format!("{:?}", & ucicontrolpacket.child),
32794                 });
32795             }
32796         };
32797         let testresponse = match &uciresponse.child {
32798             UciResponseDataChild::TestResponse(value) => value.clone(),
32799             _ => {
32800                 return Err(DecodeError::InvalidChildError {
32801                     expected: stringify!(UciResponseDataChild::TestResponse),
32802                     actual: format!("{:?}", & uciresponse.child),
32803                 });
32804             }
32805         };
32806         let sessionsetrftestconfigrsp = match &testresponse.child {
32807             TestResponseDataChild::SessionSetRfTestConfigRsp(value) => value.clone(),
32808             _ => {
32809                 return Err(DecodeError::InvalidChildError {
32810                     expected: stringify!(
32811                         TestResponseDataChild::SessionSetRfTestConfigRsp
32812                     ),
32813                     actual: format!("{:?}", & testresponse.child),
32814                 });
32815             }
32816         };
32817         Ok(Self {
32818             ucicontrolpacket,
32819             uciresponse,
32820             testresponse,
32821             sessionsetrftestconfigrsp,
32822         })
32823     }
get_cfg_status(&self) -> &Vec<RfTestConfigStatus>32824     pub fn get_cfg_status(&self) -> &Vec<RfTestConfigStatus> {
32825         &self.sessionsetrftestconfigrsp.cfg_status
32826     }
get_group_id(&self) -> GroupId32827     pub fn get_group_id(&self) -> GroupId {
32828         self.ucicontrolpacket.group_id
32829     }
get_message_type(&self) -> MessageType32830     pub fn get_message_type(&self) -> MessageType {
32831         self.ucicontrolpacket.message_type
32832     }
get_opcode(&self) -> u832833     pub fn get_opcode(&self) -> u8 {
32834         self.ucicontrolpacket.opcode
32835     }
get_status(&self) -> StatusCode32836     pub fn get_status(&self) -> StatusCode {
32837         self.sessionsetrftestconfigrsp.status
32838     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>32839     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
32840         self.sessionsetrftestconfigrsp.write_to(buffer)
32841     }
get_size(&self) -> usize32842     pub fn get_size(&self) -> usize {
32843         self.ucicontrolpacket.get_size()
32844     }
32845 }
32846 impl SessionSetRfTestConfigRspBuilder {
build(self) -> SessionSetRfTestConfigRsp32847     pub fn build(self) -> SessionSetRfTestConfigRsp {
32848         let sessionsetrftestconfigrsp = SessionSetRfTestConfigRspData {
32849             cfg_status: self.cfg_status,
32850             status: self.status,
32851         };
32852         let testresponse = TestResponseData {
32853             child: TestResponseDataChild::SessionSetRfTestConfigRsp(
32854                 sessionsetrftestconfigrsp,
32855             ),
32856         };
32857         let uciresponse = UciResponseData {
32858             child: UciResponseDataChild::TestResponse(testresponse),
32859         };
32860         let ucicontrolpacket = UciControlPacketData {
32861             group_id: GroupId::Test,
32862             message_type: MessageType::Response,
32863             opcode: 0,
32864             child: UciControlPacketDataChild::UciResponse(uciresponse),
32865         };
32866         SessionSetRfTestConfigRsp::new(ucicontrolpacket).unwrap()
32867     }
32868 }
32869 impl From<SessionSetRfTestConfigRspBuilder> for UciControlPacket {
from(builder: SessionSetRfTestConfigRspBuilder) -> UciControlPacket32870     fn from(builder: SessionSetRfTestConfigRspBuilder) -> UciControlPacket {
32871         builder.build().into()
32872     }
32873 }
32874 impl From<SessionSetRfTestConfigRspBuilder> for UciResponse {
from(builder: SessionSetRfTestConfigRspBuilder) -> UciResponse32875     fn from(builder: SessionSetRfTestConfigRspBuilder) -> UciResponse {
32876         builder.build().into()
32877     }
32878 }
32879 impl From<SessionSetRfTestConfigRspBuilder> for TestResponse {
from(builder: SessionSetRfTestConfigRspBuilder) -> TestResponse32880     fn from(builder: SessionSetRfTestConfigRspBuilder) -> TestResponse {
32881         builder.build().into()
32882     }
32883 }
32884 impl From<SessionSetRfTestConfigRspBuilder> for SessionSetRfTestConfigRsp {
from(builder: SessionSetRfTestConfigRspBuilder) -> SessionSetRfTestConfigRsp32885     fn from(builder: SessionSetRfTestConfigRspBuilder) -> SessionSetRfTestConfigRsp {
32886         builder.build().into()
32887     }
32888 }
32889 #[derive(Debug, Clone, PartialEq, Eq)]
32890 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32891 pub struct TestPeriodicTxCmdData {
32892     psdu_data: Vec<u8>,
32893 }
32894 #[derive(Debug, Clone, PartialEq, Eq)]
32895 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32896 pub struct TestPeriodicTxCmd {
32897     #[cfg_attr(feature = "serde", serde(flatten))]
32898     ucicontrolpacket: UciControlPacketData,
32899     #[cfg_attr(feature = "serde", serde(flatten))]
32900     ucicommand: UciCommandData,
32901     #[cfg_attr(feature = "serde", serde(flatten))]
32902     testcommand: TestCommandData,
32903     #[cfg_attr(feature = "serde", serde(flatten))]
32904     testperiodictxcmd: TestPeriodicTxCmdData,
32905 }
32906 #[derive(Debug)]
32907 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32908 pub struct TestPeriodicTxCmdBuilder {
32909     pub psdu_data: Vec<u8>,
32910 }
32911 impl TestPeriodicTxCmdData {
conforms(bytes: &[u8]) -> bool32912     fn conforms(bytes: &[u8]) -> bool {
32913         true
32914     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>32915     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
32916         let mut cell = Cell::new(bytes);
32917         let packet = Self::parse_inner(&mut cell)?;
32918         Ok(packet)
32919     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>32920     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
32921         let mut psdu_data = Vec::with_capacity(bytes.get().remaining());
32922         for _ in 0..bytes.get().remaining() {
32923             psdu_data.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
32924         }
32925         Ok(Self { psdu_data })
32926     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>32927     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
32928         for elem in &self.psdu_data {
32929             buffer.put_u8(*elem);
32930         }
32931         Ok(())
32932     }
get_total_size(&self) -> usize32933     fn get_total_size(&self) -> usize {
32934         self.get_size()
32935     }
get_size(&self) -> usize32936     fn get_size(&self) -> usize {
32937         self.psdu_data.len()
32938     }
32939 }
32940 impl Packet for TestPeriodicTxCmd {
encoded_len(&self) -> usize32941     fn encoded_len(&self) -> usize {
32942         self.get_size()
32943     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>32944     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
32945         self.ucicontrolpacket.write_to(buf)
32946     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>32947     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
32948         unimplemented!("Rust legacy does not implement full packet trait")
32949     }
32950 }
32951 impl TryFrom<TestPeriodicTxCmd> for Bytes {
32952     type Error = EncodeError;
try_from(packet: TestPeriodicTxCmd) -> Result<Self, Self::Error>32953     fn try_from(packet: TestPeriodicTxCmd) -> Result<Self, Self::Error> {
32954         packet.encode_to_bytes()
32955     }
32956 }
32957 impl TryFrom<TestPeriodicTxCmd> for Vec<u8> {
32958     type Error = EncodeError;
try_from(packet: TestPeriodicTxCmd) -> Result<Self, Self::Error>32959     fn try_from(packet: TestPeriodicTxCmd) -> Result<Self, Self::Error> {
32960         packet.encode_to_vec()
32961     }
32962 }
32963 impl From<TestPeriodicTxCmd> for UciControlPacket {
from(packet: TestPeriodicTxCmd) -> UciControlPacket32964     fn from(packet: TestPeriodicTxCmd) -> UciControlPacket {
32965         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
32966     }
32967 }
32968 impl From<TestPeriodicTxCmd> for UciCommand {
from(packet: TestPeriodicTxCmd) -> UciCommand32969     fn from(packet: TestPeriodicTxCmd) -> UciCommand {
32970         UciCommand::new(packet.ucicontrolpacket).unwrap()
32971     }
32972 }
32973 impl From<TestPeriodicTxCmd> for TestCommand {
from(packet: TestPeriodicTxCmd) -> TestCommand32974     fn from(packet: TestPeriodicTxCmd) -> TestCommand {
32975         TestCommand::new(packet.ucicontrolpacket).unwrap()
32976     }
32977 }
32978 impl TryFrom<UciControlPacket> for TestPeriodicTxCmd {
32979     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<TestPeriodicTxCmd, Self::Error>32980     fn try_from(packet: UciControlPacket) -> Result<TestPeriodicTxCmd, Self::Error> {
32981         TestPeriodicTxCmd::new(packet.ucicontrolpacket)
32982     }
32983 }
32984 impl TestPeriodicTxCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>32985     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
32986         let mut cell = Cell::new(bytes);
32987         let packet = Self::parse_inner(&mut cell)?;
32988         Ok(packet)
32989     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>32990     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
32991         let data = UciControlPacketData::parse_inner(&mut bytes)?;
32992         Self::new(data)
32993     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>32994     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
32995         let ucicommand = match &ucicontrolpacket.child {
32996             UciControlPacketDataChild::UciCommand(value) => value.clone(),
32997             _ => {
32998                 return Err(DecodeError::InvalidChildError {
32999                     expected: stringify!(UciControlPacketDataChild::UciCommand),
33000                     actual: format!("{:?}", & ucicontrolpacket.child),
33001                 });
33002             }
33003         };
33004         let testcommand = match &ucicommand.child {
33005             UciCommandDataChild::TestCommand(value) => value.clone(),
33006             _ => {
33007                 return Err(DecodeError::InvalidChildError {
33008                     expected: stringify!(UciCommandDataChild::TestCommand),
33009                     actual: format!("{:?}", & ucicommand.child),
33010                 });
33011             }
33012         };
33013         let testperiodictxcmd = match &testcommand.child {
33014             TestCommandDataChild::TestPeriodicTxCmd(value) => value.clone(),
33015             _ => {
33016                 return Err(DecodeError::InvalidChildError {
33017                     expected: stringify!(TestCommandDataChild::TestPeriodicTxCmd),
33018                     actual: format!("{:?}", & testcommand.child),
33019                 });
33020             }
33021         };
33022         Ok(Self {
33023             ucicontrolpacket,
33024             ucicommand,
33025             testcommand,
33026             testperiodictxcmd,
33027         })
33028     }
get_group_id(&self) -> GroupId33029     pub fn get_group_id(&self) -> GroupId {
33030         self.ucicontrolpacket.group_id
33031     }
get_message_type(&self) -> MessageType33032     pub fn get_message_type(&self) -> MessageType {
33033         self.ucicontrolpacket.message_type
33034     }
get_opcode(&self) -> u833035     pub fn get_opcode(&self) -> u8 {
33036         self.ucicontrolpacket.opcode
33037     }
get_psdu_data(&self) -> &Vec<u8>33038     pub fn get_psdu_data(&self) -> &Vec<u8> {
33039         &self.testperiodictxcmd.psdu_data
33040     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>33041     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
33042         self.testperiodictxcmd.write_to(buffer)
33043     }
get_size(&self) -> usize33044     pub fn get_size(&self) -> usize {
33045         self.ucicontrolpacket.get_size()
33046     }
33047 }
33048 impl TestPeriodicTxCmdBuilder {
build(self) -> TestPeriodicTxCmd33049     pub fn build(self) -> TestPeriodicTxCmd {
33050         let testperiodictxcmd = TestPeriodicTxCmdData {
33051             psdu_data: self.psdu_data,
33052         };
33053         let testcommand = TestCommandData {
33054             child: TestCommandDataChild::TestPeriodicTxCmd(testperiodictxcmd),
33055         };
33056         let ucicommand = UciCommandData {
33057             child: UciCommandDataChild::TestCommand(testcommand),
33058         };
33059         let ucicontrolpacket = UciControlPacketData {
33060             group_id: GroupId::Test,
33061             message_type: MessageType::Command,
33062             opcode: 2,
33063             child: UciControlPacketDataChild::UciCommand(ucicommand),
33064         };
33065         TestPeriodicTxCmd::new(ucicontrolpacket).unwrap()
33066     }
33067 }
33068 impl From<TestPeriodicTxCmdBuilder> for UciControlPacket {
from(builder: TestPeriodicTxCmdBuilder) -> UciControlPacket33069     fn from(builder: TestPeriodicTxCmdBuilder) -> UciControlPacket {
33070         builder.build().into()
33071     }
33072 }
33073 impl From<TestPeriodicTxCmdBuilder> for UciCommand {
from(builder: TestPeriodicTxCmdBuilder) -> UciCommand33074     fn from(builder: TestPeriodicTxCmdBuilder) -> UciCommand {
33075         builder.build().into()
33076     }
33077 }
33078 impl From<TestPeriodicTxCmdBuilder> for TestCommand {
from(builder: TestPeriodicTxCmdBuilder) -> TestCommand33079     fn from(builder: TestPeriodicTxCmdBuilder) -> TestCommand {
33080         builder.build().into()
33081     }
33082 }
33083 impl From<TestPeriodicTxCmdBuilder> for TestPeriodicTxCmd {
from(builder: TestPeriodicTxCmdBuilder) -> TestPeriodicTxCmd33084     fn from(builder: TestPeriodicTxCmdBuilder) -> TestPeriodicTxCmd {
33085         builder.build().into()
33086     }
33087 }
33088 #[derive(Debug, Clone, PartialEq, Eq)]
33089 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33090 pub struct TestPeriodicTxRspData {
33091     status: StatusCode,
33092 }
33093 #[derive(Debug, Clone, PartialEq, Eq)]
33094 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33095 pub struct TestPeriodicTxRsp {
33096     #[cfg_attr(feature = "serde", serde(flatten))]
33097     ucicontrolpacket: UciControlPacketData,
33098     #[cfg_attr(feature = "serde", serde(flatten))]
33099     uciresponse: UciResponseData,
33100     #[cfg_attr(feature = "serde", serde(flatten))]
33101     testresponse: TestResponseData,
33102     #[cfg_attr(feature = "serde", serde(flatten))]
33103     testperiodictxrsp: TestPeriodicTxRspData,
33104 }
33105 #[derive(Debug)]
33106 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33107 pub struct TestPeriodicTxRspBuilder {
33108     pub status: StatusCode,
33109 }
33110 impl TestPeriodicTxRspData {
conforms(bytes: &[u8]) -> bool33111     fn conforms(bytes: &[u8]) -> bool {
33112         bytes.len() >= 1
33113     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>33114     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
33115         let mut cell = Cell::new(bytes);
33116         let packet = Self::parse_inner(&mut cell)?;
33117         Ok(packet)
33118     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>33119     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
33120         if bytes.get().remaining() < 1 {
33121             return Err(DecodeError::InvalidLengthError {
33122                 obj: "TestPeriodicTxRsp",
33123                 wanted: 1,
33124                 got: bytes.get().remaining(),
33125             });
33126         }
33127         let status = StatusCode::try_from(bytes.get_mut().get_u8())
33128             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
33129                 obj: "TestPeriodicTxRsp",
33130                 field: "status",
33131                 value: unknown_val as u64,
33132                 type_: "StatusCode",
33133             })?;
33134         Ok(Self { status })
33135     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>33136     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
33137         buffer.put_u8(u8::from(self.status));
33138         Ok(())
33139     }
get_total_size(&self) -> usize33140     fn get_total_size(&self) -> usize {
33141         self.get_size()
33142     }
get_size(&self) -> usize33143     fn get_size(&self) -> usize {
33144         1
33145     }
33146 }
33147 impl Packet for TestPeriodicTxRsp {
encoded_len(&self) -> usize33148     fn encoded_len(&self) -> usize {
33149         self.get_size()
33150     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>33151     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
33152         self.ucicontrolpacket.write_to(buf)
33153     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>33154     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
33155         unimplemented!("Rust legacy does not implement full packet trait")
33156     }
33157 }
33158 impl TryFrom<TestPeriodicTxRsp> for Bytes {
33159     type Error = EncodeError;
try_from(packet: TestPeriodicTxRsp) -> Result<Self, Self::Error>33160     fn try_from(packet: TestPeriodicTxRsp) -> Result<Self, Self::Error> {
33161         packet.encode_to_bytes()
33162     }
33163 }
33164 impl TryFrom<TestPeriodicTxRsp> for Vec<u8> {
33165     type Error = EncodeError;
try_from(packet: TestPeriodicTxRsp) -> Result<Self, Self::Error>33166     fn try_from(packet: TestPeriodicTxRsp) -> Result<Self, Self::Error> {
33167         packet.encode_to_vec()
33168     }
33169 }
33170 impl From<TestPeriodicTxRsp> for UciControlPacket {
from(packet: TestPeriodicTxRsp) -> UciControlPacket33171     fn from(packet: TestPeriodicTxRsp) -> UciControlPacket {
33172         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
33173     }
33174 }
33175 impl From<TestPeriodicTxRsp> for UciResponse {
from(packet: TestPeriodicTxRsp) -> UciResponse33176     fn from(packet: TestPeriodicTxRsp) -> UciResponse {
33177         UciResponse::new(packet.ucicontrolpacket).unwrap()
33178     }
33179 }
33180 impl From<TestPeriodicTxRsp> for TestResponse {
from(packet: TestPeriodicTxRsp) -> TestResponse33181     fn from(packet: TestPeriodicTxRsp) -> TestResponse {
33182         TestResponse::new(packet.ucicontrolpacket).unwrap()
33183     }
33184 }
33185 impl TryFrom<UciControlPacket> for TestPeriodicTxRsp {
33186     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<TestPeriodicTxRsp, Self::Error>33187     fn try_from(packet: UciControlPacket) -> Result<TestPeriodicTxRsp, Self::Error> {
33188         TestPeriodicTxRsp::new(packet.ucicontrolpacket)
33189     }
33190 }
33191 impl TestPeriodicTxRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>33192     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
33193         let mut cell = Cell::new(bytes);
33194         let packet = Self::parse_inner(&mut cell)?;
33195         Ok(packet)
33196     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>33197     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
33198         let data = UciControlPacketData::parse_inner(&mut bytes)?;
33199         Self::new(data)
33200     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>33201     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
33202         let uciresponse = match &ucicontrolpacket.child {
33203             UciControlPacketDataChild::UciResponse(value) => value.clone(),
33204             _ => {
33205                 return Err(DecodeError::InvalidChildError {
33206                     expected: stringify!(UciControlPacketDataChild::UciResponse),
33207                     actual: format!("{:?}", & ucicontrolpacket.child),
33208                 });
33209             }
33210         };
33211         let testresponse = match &uciresponse.child {
33212             UciResponseDataChild::TestResponse(value) => value.clone(),
33213             _ => {
33214                 return Err(DecodeError::InvalidChildError {
33215                     expected: stringify!(UciResponseDataChild::TestResponse),
33216                     actual: format!("{:?}", & uciresponse.child),
33217                 });
33218             }
33219         };
33220         let testperiodictxrsp = match &testresponse.child {
33221             TestResponseDataChild::TestPeriodicTxRsp(value) => value.clone(),
33222             _ => {
33223                 return Err(DecodeError::InvalidChildError {
33224                     expected: stringify!(TestResponseDataChild::TestPeriodicTxRsp),
33225                     actual: format!("{:?}", & testresponse.child),
33226                 });
33227             }
33228         };
33229         Ok(Self {
33230             ucicontrolpacket,
33231             uciresponse,
33232             testresponse,
33233             testperiodictxrsp,
33234         })
33235     }
get_group_id(&self) -> GroupId33236     pub fn get_group_id(&self) -> GroupId {
33237         self.ucicontrolpacket.group_id
33238     }
get_message_type(&self) -> MessageType33239     pub fn get_message_type(&self) -> MessageType {
33240         self.ucicontrolpacket.message_type
33241     }
get_opcode(&self) -> u833242     pub fn get_opcode(&self) -> u8 {
33243         self.ucicontrolpacket.opcode
33244     }
get_status(&self) -> StatusCode33245     pub fn get_status(&self) -> StatusCode {
33246         self.testperiodictxrsp.status
33247     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>33248     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
33249         self.testperiodictxrsp.write_to(buffer)
33250     }
get_size(&self) -> usize33251     pub fn get_size(&self) -> usize {
33252         self.ucicontrolpacket.get_size()
33253     }
33254 }
33255 impl TestPeriodicTxRspBuilder {
build(self) -> TestPeriodicTxRsp33256     pub fn build(self) -> TestPeriodicTxRsp {
33257         let testperiodictxrsp = TestPeriodicTxRspData {
33258             status: self.status,
33259         };
33260         let testresponse = TestResponseData {
33261             child: TestResponseDataChild::TestPeriodicTxRsp(testperiodictxrsp),
33262         };
33263         let uciresponse = UciResponseData {
33264             child: UciResponseDataChild::TestResponse(testresponse),
33265         };
33266         let ucicontrolpacket = UciControlPacketData {
33267             group_id: GroupId::Test,
33268             message_type: MessageType::Response,
33269             opcode: 2,
33270             child: UciControlPacketDataChild::UciResponse(uciresponse),
33271         };
33272         TestPeriodicTxRsp::new(ucicontrolpacket).unwrap()
33273     }
33274 }
33275 impl From<TestPeriodicTxRspBuilder> for UciControlPacket {
from(builder: TestPeriodicTxRspBuilder) -> UciControlPacket33276     fn from(builder: TestPeriodicTxRspBuilder) -> UciControlPacket {
33277         builder.build().into()
33278     }
33279 }
33280 impl From<TestPeriodicTxRspBuilder> for UciResponse {
from(builder: TestPeriodicTxRspBuilder) -> UciResponse33281     fn from(builder: TestPeriodicTxRspBuilder) -> UciResponse {
33282         builder.build().into()
33283     }
33284 }
33285 impl From<TestPeriodicTxRspBuilder> for TestResponse {
from(builder: TestPeriodicTxRspBuilder) -> TestResponse33286     fn from(builder: TestPeriodicTxRspBuilder) -> TestResponse {
33287         builder.build().into()
33288     }
33289 }
33290 impl From<TestPeriodicTxRspBuilder> for TestPeriodicTxRsp {
from(builder: TestPeriodicTxRspBuilder) -> TestPeriodicTxRsp33291     fn from(builder: TestPeriodicTxRspBuilder) -> TestPeriodicTxRsp {
33292         builder.build().into()
33293     }
33294 }
33295 #[derive(Debug, Clone, PartialEq, Eq)]
33296 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33297 pub struct TestPeriodicTxNtfData {
33298     status: StatusCode,
33299     vendor_data: Vec<u8>,
33300 }
33301 #[derive(Debug, Clone, PartialEq, Eq)]
33302 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33303 pub struct TestPeriodicTxNtf {
33304     #[cfg_attr(feature = "serde", serde(flatten))]
33305     ucicontrolpacket: UciControlPacketData,
33306     #[cfg_attr(feature = "serde", serde(flatten))]
33307     ucinotification: UciNotificationData,
33308     #[cfg_attr(feature = "serde", serde(flatten))]
33309     testnotification: TestNotificationData,
33310     #[cfg_attr(feature = "serde", serde(flatten))]
33311     testperiodictxntf: TestPeriodicTxNtfData,
33312 }
33313 #[derive(Debug)]
33314 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33315 pub struct TestPeriodicTxNtfBuilder {
33316     pub status: StatusCode,
33317     pub vendor_data: Vec<u8>,
33318 }
33319 impl TestPeriodicTxNtfData {
conforms(bytes: &[u8]) -> bool33320     fn conforms(bytes: &[u8]) -> bool {
33321         bytes.len() >= 1
33322     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>33323     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
33324         let mut cell = Cell::new(bytes);
33325         let packet = Self::parse_inner(&mut cell)?;
33326         Ok(packet)
33327     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>33328     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
33329         if bytes.get().remaining() < 1 {
33330             return Err(DecodeError::InvalidLengthError {
33331                 obj: "TestPeriodicTxNtf",
33332                 wanted: 1,
33333                 got: bytes.get().remaining(),
33334             });
33335         }
33336         let status = StatusCode::try_from(bytes.get_mut().get_u8())
33337             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
33338                 obj: "TestPeriodicTxNtf",
33339                 field: "status",
33340                 value: unknown_val as u64,
33341                 type_: "StatusCode",
33342             })?;
33343         let mut vendor_data = Vec::with_capacity(bytes.get().remaining());
33344         for _ in 0..bytes.get().remaining() {
33345             vendor_data.push(Ok::<_, DecodeError>(bytes.get_mut().get_u8())?);
33346         }
33347         Ok(Self { status, vendor_data })
33348     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>33349     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
33350         buffer.put_u8(u8::from(self.status));
33351         for elem in &self.vendor_data {
33352             buffer.put_u8(*elem);
33353         }
33354         Ok(())
33355     }
get_total_size(&self) -> usize33356     fn get_total_size(&self) -> usize {
33357         self.get_size()
33358     }
get_size(&self) -> usize33359     fn get_size(&self) -> usize {
33360         1 + self.vendor_data.len()
33361     }
33362 }
33363 impl Packet for TestPeriodicTxNtf {
encoded_len(&self) -> usize33364     fn encoded_len(&self) -> usize {
33365         self.get_size()
33366     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>33367     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
33368         self.ucicontrolpacket.write_to(buf)
33369     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>33370     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
33371         unimplemented!("Rust legacy does not implement full packet trait")
33372     }
33373 }
33374 impl TryFrom<TestPeriodicTxNtf> for Bytes {
33375     type Error = EncodeError;
try_from(packet: TestPeriodicTxNtf) -> Result<Self, Self::Error>33376     fn try_from(packet: TestPeriodicTxNtf) -> Result<Self, Self::Error> {
33377         packet.encode_to_bytes()
33378     }
33379 }
33380 impl TryFrom<TestPeriodicTxNtf> for Vec<u8> {
33381     type Error = EncodeError;
try_from(packet: TestPeriodicTxNtf) -> Result<Self, Self::Error>33382     fn try_from(packet: TestPeriodicTxNtf) -> Result<Self, Self::Error> {
33383         packet.encode_to_vec()
33384     }
33385 }
33386 impl From<TestPeriodicTxNtf> for UciControlPacket {
from(packet: TestPeriodicTxNtf) -> UciControlPacket33387     fn from(packet: TestPeriodicTxNtf) -> UciControlPacket {
33388         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
33389     }
33390 }
33391 impl From<TestPeriodicTxNtf> for UciNotification {
from(packet: TestPeriodicTxNtf) -> UciNotification33392     fn from(packet: TestPeriodicTxNtf) -> UciNotification {
33393         UciNotification::new(packet.ucicontrolpacket).unwrap()
33394     }
33395 }
33396 impl From<TestPeriodicTxNtf> for TestNotification {
from(packet: TestPeriodicTxNtf) -> TestNotification33397     fn from(packet: TestPeriodicTxNtf) -> TestNotification {
33398         TestNotification::new(packet.ucicontrolpacket).unwrap()
33399     }
33400 }
33401 impl TryFrom<UciControlPacket> for TestPeriodicTxNtf {
33402     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<TestPeriodicTxNtf, Self::Error>33403     fn try_from(packet: UciControlPacket) -> Result<TestPeriodicTxNtf, Self::Error> {
33404         TestPeriodicTxNtf::new(packet.ucicontrolpacket)
33405     }
33406 }
33407 impl TestPeriodicTxNtf {
parse(bytes: &[u8]) -> Result<Self, DecodeError>33408     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
33409         let mut cell = Cell::new(bytes);
33410         let packet = Self::parse_inner(&mut cell)?;
33411         Ok(packet)
33412     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>33413     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
33414         let data = UciControlPacketData::parse_inner(&mut bytes)?;
33415         Self::new(data)
33416     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>33417     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
33418         let ucinotification = match &ucicontrolpacket.child {
33419             UciControlPacketDataChild::UciNotification(value) => value.clone(),
33420             _ => {
33421                 return Err(DecodeError::InvalidChildError {
33422                     expected: stringify!(UciControlPacketDataChild::UciNotification),
33423                     actual: format!("{:?}", & ucicontrolpacket.child),
33424                 });
33425             }
33426         };
33427         let testnotification = match &ucinotification.child {
33428             UciNotificationDataChild::TestNotification(value) => value.clone(),
33429             _ => {
33430                 return Err(DecodeError::InvalidChildError {
33431                     expected: stringify!(UciNotificationDataChild::TestNotification),
33432                     actual: format!("{:?}", & ucinotification.child),
33433                 });
33434             }
33435         };
33436         let testperiodictxntf = match &testnotification.child {
33437             TestNotificationDataChild::TestPeriodicTxNtf(value) => value.clone(),
33438             _ => {
33439                 return Err(DecodeError::InvalidChildError {
33440                     expected: stringify!(TestNotificationDataChild::TestPeriodicTxNtf),
33441                     actual: format!("{:?}", & testnotification.child),
33442                 });
33443             }
33444         };
33445         Ok(Self {
33446             ucicontrolpacket,
33447             ucinotification,
33448             testnotification,
33449             testperiodictxntf,
33450         })
33451     }
get_group_id(&self) -> GroupId33452     pub fn get_group_id(&self) -> GroupId {
33453         self.ucicontrolpacket.group_id
33454     }
get_message_type(&self) -> MessageType33455     pub fn get_message_type(&self) -> MessageType {
33456         self.ucicontrolpacket.message_type
33457     }
get_opcode(&self) -> u833458     pub fn get_opcode(&self) -> u8 {
33459         self.ucicontrolpacket.opcode
33460     }
get_status(&self) -> StatusCode33461     pub fn get_status(&self) -> StatusCode {
33462         self.testperiodictxntf.status
33463     }
get_vendor_data(&self) -> &Vec<u8>33464     pub fn get_vendor_data(&self) -> &Vec<u8> {
33465         &self.testperiodictxntf.vendor_data
33466     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>33467     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
33468         self.testperiodictxntf.write_to(buffer)
33469     }
get_size(&self) -> usize33470     pub fn get_size(&self) -> usize {
33471         self.ucicontrolpacket.get_size()
33472     }
33473 }
33474 impl TestPeriodicTxNtfBuilder {
build(self) -> TestPeriodicTxNtf33475     pub fn build(self) -> TestPeriodicTxNtf {
33476         let testperiodictxntf = TestPeriodicTxNtfData {
33477             status: self.status,
33478             vendor_data: self.vendor_data,
33479         };
33480         let testnotification = TestNotificationData {
33481             child: TestNotificationDataChild::TestPeriodicTxNtf(testperiodictxntf),
33482         };
33483         let ucinotification = UciNotificationData {
33484             child: UciNotificationDataChild::TestNotification(testnotification),
33485         };
33486         let ucicontrolpacket = UciControlPacketData {
33487             group_id: GroupId::Test,
33488             message_type: MessageType::Notification,
33489             opcode: 2,
33490             child: UciControlPacketDataChild::UciNotification(ucinotification),
33491         };
33492         TestPeriodicTxNtf::new(ucicontrolpacket).unwrap()
33493     }
33494 }
33495 impl From<TestPeriodicTxNtfBuilder> for UciControlPacket {
from(builder: TestPeriodicTxNtfBuilder) -> UciControlPacket33496     fn from(builder: TestPeriodicTxNtfBuilder) -> UciControlPacket {
33497         builder.build().into()
33498     }
33499 }
33500 impl From<TestPeriodicTxNtfBuilder> for UciNotification {
from(builder: TestPeriodicTxNtfBuilder) -> UciNotification33501     fn from(builder: TestPeriodicTxNtfBuilder) -> UciNotification {
33502         builder.build().into()
33503     }
33504 }
33505 impl From<TestPeriodicTxNtfBuilder> for TestNotification {
from(builder: TestPeriodicTxNtfBuilder) -> TestNotification33506     fn from(builder: TestPeriodicTxNtfBuilder) -> TestNotification {
33507         builder.build().into()
33508     }
33509 }
33510 impl From<TestPeriodicTxNtfBuilder> for TestPeriodicTxNtf {
from(builder: TestPeriodicTxNtfBuilder) -> TestPeriodicTxNtf33511     fn from(builder: TestPeriodicTxNtfBuilder) -> TestPeriodicTxNtf {
33512         builder.build().into()
33513     }
33514 }
33515 #[derive(Debug, Clone, PartialEq, Eq)]
33516 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33517 pub struct StopRfTestCmdData {}
33518 #[derive(Debug, Clone, PartialEq, Eq)]
33519 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33520 pub struct StopRfTestCmd {
33521     #[cfg_attr(feature = "serde", serde(flatten))]
33522     ucicontrolpacket: UciControlPacketData,
33523     #[cfg_attr(feature = "serde", serde(flatten))]
33524     ucicommand: UciCommandData,
33525     #[cfg_attr(feature = "serde", serde(flatten))]
33526     testcommand: TestCommandData,
33527     #[cfg_attr(feature = "serde", serde(flatten))]
33528     stoprftestcmd: StopRfTestCmdData,
33529 }
33530 #[derive(Debug)]
33531 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33532 pub struct StopRfTestCmdBuilder {}
33533 impl StopRfTestCmdData {
conforms(bytes: &[u8]) -> bool33534     fn conforms(bytes: &[u8]) -> bool {
33535         true
33536     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>33537     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
33538         let mut cell = Cell::new(bytes);
33539         let packet = Self::parse_inner(&mut cell)?;
33540         Ok(packet)
33541     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>33542     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
33543         Ok(Self {})
33544     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>33545     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
33546         Ok(())
33547     }
get_total_size(&self) -> usize33548     fn get_total_size(&self) -> usize {
33549         self.get_size()
33550     }
get_size(&self) -> usize33551     fn get_size(&self) -> usize {
33552         0
33553     }
33554 }
33555 impl Packet for StopRfTestCmd {
encoded_len(&self) -> usize33556     fn encoded_len(&self) -> usize {
33557         self.get_size()
33558     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>33559     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
33560         self.ucicontrolpacket.write_to(buf)
33561     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>33562     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
33563         unimplemented!("Rust legacy does not implement full packet trait")
33564     }
33565 }
33566 impl TryFrom<StopRfTestCmd> for Bytes {
33567     type Error = EncodeError;
try_from(packet: StopRfTestCmd) -> Result<Self, Self::Error>33568     fn try_from(packet: StopRfTestCmd) -> Result<Self, Self::Error> {
33569         packet.encode_to_bytes()
33570     }
33571 }
33572 impl TryFrom<StopRfTestCmd> for Vec<u8> {
33573     type Error = EncodeError;
try_from(packet: StopRfTestCmd) -> Result<Self, Self::Error>33574     fn try_from(packet: StopRfTestCmd) -> Result<Self, Self::Error> {
33575         packet.encode_to_vec()
33576     }
33577 }
33578 impl From<StopRfTestCmd> for UciControlPacket {
from(packet: StopRfTestCmd) -> UciControlPacket33579     fn from(packet: StopRfTestCmd) -> UciControlPacket {
33580         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
33581     }
33582 }
33583 impl From<StopRfTestCmd> for UciCommand {
from(packet: StopRfTestCmd) -> UciCommand33584     fn from(packet: StopRfTestCmd) -> UciCommand {
33585         UciCommand::new(packet.ucicontrolpacket).unwrap()
33586     }
33587 }
33588 impl From<StopRfTestCmd> for TestCommand {
from(packet: StopRfTestCmd) -> TestCommand33589     fn from(packet: StopRfTestCmd) -> TestCommand {
33590         TestCommand::new(packet.ucicontrolpacket).unwrap()
33591     }
33592 }
33593 impl TryFrom<UciControlPacket> for StopRfTestCmd {
33594     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<StopRfTestCmd, Self::Error>33595     fn try_from(packet: UciControlPacket) -> Result<StopRfTestCmd, Self::Error> {
33596         StopRfTestCmd::new(packet.ucicontrolpacket)
33597     }
33598 }
33599 impl StopRfTestCmd {
parse(bytes: &[u8]) -> Result<Self, DecodeError>33600     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
33601         let mut cell = Cell::new(bytes);
33602         let packet = Self::parse_inner(&mut cell)?;
33603         Ok(packet)
33604     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>33605     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
33606         let data = UciControlPacketData::parse_inner(&mut bytes)?;
33607         Self::new(data)
33608     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>33609     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
33610         let ucicommand = match &ucicontrolpacket.child {
33611             UciControlPacketDataChild::UciCommand(value) => value.clone(),
33612             _ => {
33613                 return Err(DecodeError::InvalidChildError {
33614                     expected: stringify!(UciControlPacketDataChild::UciCommand),
33615                     actual: format!("{:?}", & ucicontrolpacket.child),
33616                 });
33617             }
33618         };
33619         let testcommand = match &ucicommand.child {
33620             UciCommandDataChild::TestCommand(value) => value.clone(),
33621             _ => {
33622                 return Err(DecodeError::InvalidChildError {
33623                     expected: stringify!(UciCommandDataChild::TestCommand),
33624                     actual: format!("{:?}", & ucicommand.child),
33625                 });
33626             }
33627         };
33628         let stoprftestcmd = match &testcommand.child {
33629             TestCommandDataChild::StopRfTestCmd(value) => value.clone(),
33630             _ => {
33631                 return Err(DecodeError::InvalidChildError {
33632                     expected: stringify!(TestCommandDataChild::StopRfTestCmd),
33633                     actual: format!("{:?}", & testcommand.child),
33634                 });
33635             }
33636         };
33637         Ok(Self {
33638             ucicontrolpacket,
33639             ucicommand,
33640             testcommand,
33641             stoprftestcmd,
33642         })
33643     }
get_group_id(&self) -> GroupId33644     pub fn get_group_id(&self) -> GroupId {
33645         self.ucicontrolpacket.group_id
33646     }
get_message_type(&self) -> MessageType33647     pub fn get_message_type(&self) -> MessageType {
33648         self.ucicontrolpacket.message_type
33649     }
get_opcode(&self) -> u833650     pub fn get_opcode(&self) -> u8 {
33651         self.ucicontrolpacket.opcode
33652     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>33653     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
33654         self.stoprftestcmd.write_to(buffer)
33655     }
get_size(&self) -> usize33656     pub fn get_size(&self) -> usize {
33657         self.ucicontrolpacket.get_size()
33658     }
33659 }
33660 impl StopRfTestCmdBuilder {
build(self) -> StopRfTestCmd33661     pub fn build(self) -> StopRfTestCmd {
33662         let stoprftestcmd = StopRfTestCmdData {};
33663         let testcommand = TestCommandData {
33664             child: TestCommandDataChild::StopRfTestCmd(stoprftestcmd),
33665         };
33666         let ucicommand = UciCommandData {
33667             child: UciCommandDataChild::TestCommand(testcommand),
33668         };
33669         let ucicontrolpacket = UciControlPacketData {
33670             group_id: GroupId::Test,
33671             message_type: MessageType::Command,
33672             opcode: 7,
33673             child: UciControlPacketDataChild::UciCommand(ucicommand),
33674         };
33675         StopRfTestCmd::new(ucicontrolpacket).unwrap()
33676     }
33677 }
33678 impl From<StopRfTestCmdBuilder> for UciControlPacket {
from(builder: StopRfTestCmdBuilder) -> UciControlPacket33679     fn from(builder: StopRfTestCmdBuilder) -> UciControlPacket {
33680         builder.build().into()
33681     }
33682 }
33683 impl From<StopRfTestCmdBuilder> for UciCommand {
from(builder: StopRfTestCmdBuilder) -> UciCommand33684     fn from(builder: StopRfTestCmdBuilder) -> UciCommand {
33685         builder.build().into()
33686     }
33687 }
33688 impl From<StopRfTestCmdBuilder> for TestCommand {
from(builder: StopRfTestCmdBuilder) -> TestCommand33689     fn from(builder: StopRfTestCmdBuilder) -> TestCommand {
33690         builder.build().into()
33691     }
33692 }
33693 impl From<StopRfTestCmdBuilder> for StopRfTestCmd {
from(builder: StopRfTestCmdBuilder) -> StopRfTestCmd33694     fn from(builder: StopRfTestCmdBuilder) -> StopRfTestCmd {
33695         builder.build().into()
33696     }
33697 }
33698 #[derive(Debug, Clone, PartialEq, Eq)]
33699 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33700 pub struct StopRfTestRspData {
33701     status: StatusCode,
33702 }
33703 #[derive(Debug, Clone, PartialEq, Eq)]
33704 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33705 pub struct StopRfTestRsp {
33706     #[cfg_attr(feature = "serde", serde(flatten))]
33707     ucicontrolpacket: UciControlPacketData,
33708     #[cfg_attr(feature = "serde", serde(flatten))]
33709     uciresponse: UciResponseData,
33710     #[cfg_attr(feature = "serde", serde(flatten))]
33711     testresponse: TestResponseData,
33712     #[cfg_attr(feature = "serde", serde(flatten))]
33713     stoprftestrsp: StopRfTestRspData,
33714 }
33715 #[derive(Debug)]
33716 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
33717 pub struct StopRfTestRspBuilder {
33718     pub status: StatusCode,
33719 }
33720 impl StopRfTestRspData {
conforms(bytes: &[u8]) -> bool33721     fn conforms(bytes: &[u8]) -> bool {
33722         bytes.len() >= 1
33723     }
parse(bytes: &[u8]) -> Result<Self, DecodeError>33724     fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
33725         let mut cell = Cell::new(bytes);
33726         let packet = Self::parse_inner(&mut cell)?;
33727         Ok(packet)
33728     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>33729     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
33730         if bytes.get().remaining() < 1 {
33731             return Err(DecodeError::InvalidLengthError {
33732                 obj: "StopRfTestRsp",
33733                 wanted: 1,
33734                 got: bytes.get().remaining(),
33735             });
33736         }
33737         let status = StatusCode::try_from(bytes.get_mut().get_u8())
33738             .map_err(|unknown_val| DecodeError::InvalidEnumValueError {
33739                 obj: "StopRfTestRsp",
33740                 field: "status",
33741                 value: unknown_val as u64,
33742                 type_: "StatusCode",
33743             })?;
33744         Ok(Self { status })
33745     }
write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError>33746     fn write_to<T: BufMut>(&self, buffer: &mut T) -> Result<(), EncodeError> {
33747         buffer.put_u8(u8::from(self.status));
33748         Ok(())
33749     }
get_total_size(&self) -> usize33750     fn get_total_size(&self) -> usize {
33751         self.get_size()
33752     }
get_size(&self) -> usize33753     fn get_size(&self) -> usize {
33754         1
33755     }
33756 }
33757 impl Packet for StopRfTestRsp {
encoded_len(&self) -> usize33758     fn encoded_len(&self) -> usize {
33759         self.get_size()
33760     }
encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>33761     fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError> {
33762         self.ucicontrolpacket.write_to(buf)
33763     }
decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError>33764     fn decode(_: &[u8]) -> Result<(Self, &[u8]), DecodeError> {
33765         unimplemented!("Rust legacy does not implement full packet trait")
33766     }
33767 }
33768 impl TryFrom<StopRfTestRsp> for Bytes {
33769     type Error = EncodeError;
try_from(packet: StopRfTestRsp) -> Result<Self, Self::Error>33770     fn try_from(packet: StopRfTestRsp) -> Result<Self, Self::Error> {
33771         packet.encode_to_bytes()
33772     }
33773 }
33774 impl TryFrom<StopRfTestRsp> for Vec<u8> {
33775     type Error = EncodeError;
try_from(packet: StopRfTestRsp) -> Result<Self, Self::Error>33776     fn try_from(packet: StopRfTestRsp) -> Result<Self, Self::Error> {
33777         packet.encode_to_vec()
33778     }
33779 }
33780 impl From<StopRfTestRsp> for UciControlPacket {
from(packet: StopRfTestRsp) -> UciControlPacket33781     fn from(packet: StopRfTestRsp) -> UciControlPacket {
33782         UciControlPacket::new(packet.ucicontrolpacket).unwrap()
33783     }
33784 }
33785 impl From<StopRfTestRsp> for UciResponse {
from(packet: StopRfTestRsp) -> UciResponse33786     fn from(packet: StopRfTestRsp) -> UciResponse {
33787         UciResponse::new(packet.ucicontrolpacket).unwrap()
33788     }
33789 }
33790 impl From<StopRfTestRsp> for TestResponse {
from(packet: StopRfTestRsp) -> TestResponse33791     fn from(packet: StopRfTestRsp) -> TestResponse {
33792         TestResponse::new(packet.ucicontrolpacket).unwrap()
33793     }
33794 }
33795 impl TryFrom<UciControlPacket> for StopRfTestRsp {
33796     type Error = DecodeError;
try_from(packet: UciControlPacket) -> Result<StopRfTestRsp, Self::Error>33797     fn try_from(packet: UciControlPacket) -> Result<StopRfTestRsp, Self::Error> {
33798         StopRfTestRsp::new(packet.ucicontrolpacket)
33799     }
33800 }
33801 impl StopRfTestRsp {
parse(bytes: &[u8]) -> Result<Self, DecodeError>33802     pub fn parse(bytes: &[u8]) -> Result<Self, DecodeError> {
33803         let mut cell = Cell::new(bytes);
33804         let packet = Self::parse_inner(&mut cell)?;
33805         Ok(packet)
33806     }
parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError>33807     fn parse_inner(mut bytes: &mut Cell<&[u8]>) -> Result<Self, DecodeError> {
33808         let data = UciControlPacketData::parse_inner(&mut bytes)?;
33809         Self::new(data)
33810     }
new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError>33811     fn new(ucicontrolpacket: UciControlPacketData) -> Result<Self, DecodeError> {
33812         let uciresponse = match &ucicontrolpacket.child {
33813             UciControlPacketDataChild::UciResponse(value) => value.clone(),
33814             _ => {
33815                 return Err(DecodeError::InvalidChildError {
33816                     expected: stringify!(UciControlPacketDataChild::UciResponse),
33817                     actual: format!("{:?}", & ucicontrolpacket.child),
33818                 });
33819             }
33820         };
33821         let testresponse = match &uciresponse.child {
33822             UciResponseDataChild::TestResponse(value) => value.clone(),
33823             _ => {
33824                 return Err(DecodeError::InvalidChildError {
33825                     expected: stringify!(UciResponseDataChild::TestResponse),
33826                     actual: format!("{:?}", & uciresponse.child),
33827                 });
33828             }
33829         };
33830         let stoprftestrsp = match &testresponse.child {
33831             TestResponseDataChild::StopRfTestRsp(value) => value.clone(),
33832             _ => {
33833                 return Err(DecodeError::InvalidChildError {
33834                     expected: stringify!(TestResponseDataChild::StopRfTestRsp),
33835                     actual: format!("{:?}", & testresponse.child),
33836                 });
33837             }
33838         };
33839         Ok(Self {
33840             ucicontrolpacket,
33841             uciresponse,
33842             testresponse,
33843             stoprftestrsp,
33844         })
33845     }
get_group_id(&self) -> GroupId33846     pub fn get_group_id(&self) -> GroupId {
33847         self.ucicontrolpacket.group_id
33848     }
get_message_type(&self) -> MessageType33849     pub fn get_message_type(&self) -> MessageType {
33850         self.ucicontrolpacket.message_type
33851     }
get_opcode(&self) -> u833852     pub fn get_opcode(&self) -> u8 {
33853         self.ucicontrolpacket.opcode
33854     }
get_status(&self) -> StatusCode33855     pub fn get_status(&self) -> StatusCode {
33856         self.stoprftestrsp.status
33857     }
write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError>33858     fn write_to(&self, buffer: &mut impl BufMut) -> Result<(), EncodeError> {
33859         self.stoprftestrsp.write_to(buffer)
33860     }
get_size(&self) -> usize33861     pub fn get_size(&self) -> usize {
33862         self.ucicontrolpacket.get_size()
33863     }
33864 }
33865 impl StopRfTestRspBuilder {
build(self) -> StopRfTestRsp33866     pub fn build(self) -> StopRfTestRsp {
33867         let stoprftestrsp = StopRfTestRspData {
33868             status: self.status,
33869         };
33870         let testresponse = TestResponseData {
33871             child: TestResponseDataChild::StopRfTestRsp(stoprftestrsp),
33872         };
33873         let uciresponse = UciResponseData {
33874             child: UciResponseDataChild::TestResponse(testresponse),
33875         };
33876         let ucicontrolpacket = UciControlPacketData {
33877             group_id: GroupId::Test,
33878             message_type: MessageType::Response,
33879             opcode: 7,
33880             child: UciControlPacketDataChild::UciResponse(uciresponse),
33881         };
33882         StopRfTestRsp::new(ucicontrolpacket).unwrap()
33883     }
33884 }
33885 impl From<StopRfTestRspBuilder> for UciControlPacket {
from(builder: StopRfTestRspBuilder) -> UciControlPacket33886     fn from(builder: StopRfTestRspBuilder) -> UciControlPacket {
33887         builder.build().into()
33888     }
33889 }
33890 impl From<StopRfTestRspBuilder> for UciResponse {
from(builder: StopRfTestRspBuilder) -> UciResponse33891     fn from(builder: StopRfTestRspBuilder) -> UciResponse {
33892         builder.build().into()
33893     }
33894 }
33895 impl From<StopRfTestRspBuilder> for TestResponse {
from(builder: StopRfTestRspBuilder) -> TestResponse33896     fn from(builder: StopRfTestRspBuilder) -> TestResponse {
33897         builder.build().into()
33898     }
33899 }
33900 impl From<StopRfTestRspBuilder> for StopRfTestRsp {
from(builder: StopRfTestRspBuilder) -> StopRfTestRsp33901     fn from(builder: StopRfTestRspBuilder) -> StopRfTestRsp {
33902         builder.build().into()
33903     }
33904 }
33905 
33906