1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const MAX_FILTERED: u16 = 100;
13
14pub const MAX_NEIGHBORS: u32 = 1024;
15
16#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
18#[repr(i32)]
19pub enum MacAddressFilterMode {
20 Disabled = 0,
23 Allow = 1,
32 Deny = 2,
35}
36
37impl MacAddressFilterMode {
38 #[inline]
39 pub fn from_primitive(prim: i32) -> Option<Self> {
40 match prim {
41 0 => Some(Self::Disabled),
42 1 => Some(Self::Allow),
43 2 => Some(Self::Deny),
44 _ => None,
45 }
46 }
47
48 #[inline]
49 pub const fn into_primitive(self) -> i32 {
50 self as i32
51 }
52}
53
54#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
55#[repr(C)]
56pub struct DeviceTestGetCurrentChannelResponse {
57 pub channel_index: u16,
58}
59
60impl fidl::Persistable for DeviceTestGetCurrentChannelResponse {}
61
62#[derive(Clone, Debug, PartialEq)]
63pub struct DeviceTestGetCurrentMacAddressResponse {
64 pub address: fidl_fuchsia_lowpan__common::MacAddress,
65}
66
67impl fidl::Persistable for DeviceTestGetCurrentMacAddressResponse {}
68
69#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
70#[repr(C)]
71pub struct DeviceTestGetCurrentRssiResponse {
72 pub rssi: i8,
73}
74
75impl fidl::Persistable for DeviceTestGetCurrentRssiResponse {}
76
77#[derive(Clone, Debug, PartialEq)]
78pub struct DeviceTestGetFactoryMacAddressResponse {
79 pub address: fidl_fuchsia_lowpan__common::MacAddress,
80}
81
82impl fidl::Persistable for DeviceTestGetFactoryMacAddressResponse {}
83
84#[derive(Clone, Debug, PartialEq)]
85pub struct DeviceTestGetMacAddressFilterSettingsResponse {
86 pub settings: MacAddressFilterSettings,
87}
88
89impl fidl::Persistable for DeviceTestGetMacAddressFilterSettingsResponse {}
90
91#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
92pub struct DeviceTestGetNcpVersionResponse {
93 pub version: String,
94}
95
96impl fidl::Persistable for DeviceTestGetNcpVersionResponse {}
97
98#[derive(Clone, Debug, PartialEq)]
99pub struct DeviceTestGetNeighborTableResponse {
100 pub neighbor_table: Vec<NeighborInfo>,
101}
102
103impl fidl::Persistable for DeviceTestGetNeighborTableResponse {}
104
105#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
106#[repr(C)]
107pub struct DeviceTestGetPartitionIdResponse {
108 pub pid: u32,
109}
110
111impl fidl::Persistable for DeviceTestGetPartitionIdResponse {}
112
113#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
114#[repr(C)]
115pub struct DeviceTestGetThreadRloc16Response {
116 pub rloc: u16,
117}
118
119impl fidl::Persistable for DeviceTestGetThreadRloc16Response {}
120
121#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
122#[repr(C)]
123pub struct DeviceTestGetThreadRouterIdResponse {
124 pub router_id: u8,
125}
126
127impl fidl::Persistable for DeviceTestGetThreadRouterIdResponse {}
128
129#[derive(Clone, Debug, PartialEq)]
130pub struct DeviceTestReplaceMacAddressFilterSettingsRequest {
131 pub settings: MacAddressFilterSettings,
132}
133
134impl fidl::Persistable for DeviceTestReplaceMacAddressFilterSettingsRequest {}
135
136#[derive(Clone, Debug, Default, PartialEq)]
138pub struct MacAddressFilterItem {
139 pub mac_address: Option<fidl_fuchsia_lowpan__common::MacAddress>,
141 pub rssi: Option<i8>,
148 #[doc(hidden)]
149 pub __source_breaking: fidl::marker::SourceBreaking,
150}
151
152impl fidl::Persistable for MacAddressFilterItem {}
153
154#[derive(Clone, Debug, Default, PartialEq)]
155pub struct MacAddressFilterSettings {
156 pub mode: Option<MacAddressFilterMode>,
162 pub items: Option<Vec<MacAddressFilterItem>>,
166 #[doc(hidden)]
167 pub __source_breaking: fidl::marker::SourceBreaking,
168}
169
170impl fidl::Persistable for MacAddressFilterSettings {}
171
172#[derive(Clone, Debug, Default, PartialEq)]
181pub struct NeighborInfo {
182 pub mac_address: Option<fidl_fuchsia_lowpan__common::MacAddress>,
186 pub short_address: Option<u16>,
190 pub age: Option<i64>,
195 pub is_child: Option<bool>,
200 pub link_frame_count: Option<u32>,
202 pub mgmt_frame_count: Option<u32>,
204 pub last_rssi_in: Option<i32>,
206 pub avg_rssi_in: Option<i8>,
208 pub lqi_in: Option<u8>,
222 pub thread_mode: Option<u8>,
226 pub frame_error_rate: Option<u16>,
230 pub ipv6_error_rate: Option<u16>,
234 pub child_is_csl_synced: Option<bool>,
239 pub child_is_state_restoring: Option<bool>,
241 pub net_data_version: Option<u8>,
243 pub queued_messages: Option<u16>,
245 pub thread_mle_version: Option<u8>,
247 #[doc(hidden)]
248 pub __source_breaking: fidl::marker::SourceBreaking,
249}
250
251impl fidl::Persistable for NeighborInfo {}
252
253pub mod device_test_ordinals {
254 pub const RESET: u64 = 0x772795fd82e287e;
255 pub const GET_NCP_VERSION: u64 = 0x5006d66ecaa992f2;
256 pub const GET_CURRENT_RSSI: u64 = 0x6ac289cf16a976ab;
257 pub const GET_FACTORY_MAC_ADDRESS: u64 = 0x2a32094f1da3372;
258 pub const GET_CURRENT_MAC_ADDRESS: u64 = 0x39fc2f974a484b62;
259 pub const GET_CURRENT_CHANNEL: u64 = 0x2bd32ba980668d13;
260 pub const GET_PARTITION_ID: u64 = 0x32be448a6dc88b33;
261 pub const GET_THREAD_RLOC16: u64 = 0x4e554e42c1953d31;
262 pub const GET_THREAD_ROUTER_ID: u64 = 0x753df71fce9f3563;
263 pub const REPLACE_MAC_ADDRESS_FILTER_SETTINGS: u64 = 0x66eb4780f869de19;
264 pub const GET_MAC_ADDRESS_FILTER_SETTINGS: u64 = 0x2d727bf2dd3e231c;
265 pub const GET_NEIGHBOR_TABLE: u64 = 0x6f2db4573c413cde;
266}
267
268pub mod device_test_connector_ordinals {
269 pub const CONNECT: u64 = 0x366c1167cee8caa3;
270}
271
272mod internal {
273 use super::*;
274 unsafe impl fidl::encoding::TypeMarker for MacAddressFilterMode {
275 type Owned = Self;
276
277 #[inline(always)]
278 fn inline_align(_context: fidl::encoding::Context) -> usize {
279 std::mem::align_of::<i32>()
280 }
281
282 #[inline(always)]
283 fn inline_size(_context: fidl::encoding::Context) -> usize {
284 std::mem::size_of::<i32>()
285 }
286
287 #[inline(always)]
288 fn encode_is_copy() -> bool {
289 true
290 }
291
292 #[inline(always)]
293 fn decode_is_copy() -> bool {
294 false
295 }
296 }
297
298 impl fidl::encoding::ValueTypeMarker for MacAddressFilterMode {
299 type Borrowed<'a> = Self;
300 #[inline(always)]
301 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
302 *value
303 }
304 }
305
306 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
307 for MacAddressFilterMode
308 {
309 #[inline]
310 unsafe fn encode(
311 self,
312 encoder: &mut fidl::encoding::Encoder<'_, D>,
313 offset: usize,
314 _depth: fidl::encoding::Depth,
315 ) -> fidl::Result<()> {
316 encoder.debug_check_bounds::<Self>(offset);
317 encoder.write_num(self.into_primitive(), offset);
318 Ok(())
319 }
320 }
321
322 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacAddressFilterMode {
323 #[inline(always)]
324 fn new_empty() -> Self {
325 Self::Disabled
326 }
327
328 #[inline]
329 unsafe fn decode(
330 &mut self,
331 decoder: &mut fidl::encoding::Decoder<'_, D>,
332 offset: usize,
333 _depth: fidl::encoding::Depth,
334 ) -> fidl::Result<()> {
335 decoder.debug_check_bounds::<Self>(offset);
336 let prim = decoder.read_num::<i32>(offset);
337
338 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
339 Ok(())
340 }
341 }
342
343 impl fidl::encoding::ValueTypeMarker for DeviceTestGetCurrentChannelResponse {
344 type Borrowed<'a> = &'a Self;
345 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
346 value
347 }
348 }
349
350 unsafe impl fidl::encoding::TypeMarker for DeviceTestGetCurrentChannelResponse {
351 type Owned = Self;
352
353 #[inline(always)]
354 fn inline_align(_context: fidl::encoding::Context) -> usize {
355 2
356 }
357
358 #[inline(always)]
359 fn inline_size(_context: fidl::encoding::Context) -> usize {
360 2
361 }
362 #[inline(always)]
363 fn encode_is_copy() -> bool {
364 true
365 }
366
367 #[inline(always)]
368 fn decode_is_copy() -> bool {
369 true
370 }
371 }
372
373 unsafe impl<D: fidl::encoding::ResourceDialect>
374 fidl::encoding::Encode<DeviceTestGetCurrentChannelResponse, D>
375 for &DeviceTestGetCurrentChannelResponse
376 {
377 #[inline]
378 unsafe fn encode(
379 self,
380 encoder: &mut fidl::encoding::Encoder<'_, D>,
381 offset: usize,
382 _depth: fidl::encoding::Depth,
383 ) -> fidl::Result<()> {
384 encoder.debug_check_bounds::<DeviceTestGetCurrentChannelResponse>(offset);
385 unsafe {
386 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
388 (buf_ptr as *mut DeviceTestGetCurrentChannelResponse)
389 .write_unaligned((self as *const DeviceTestGetCurrentChannelResponse).read());
390 }
393 Ok(())
394 }
395 }
396 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
397 fidl::encoding::Encode<DeviceTestGetCurrentChannelResponse, D> for (T0,)
398 {
399 #[inline]
400 unsafe fn encode(
401 self,
402 encoder: &mut fidl::encoding::Encoder<'_, D>,
403 offset: usize,
404 depth: fidl::encoding::Depth,
405 ) -> fidl::Result<()> {
406 encoder.debug_check_bounds::<DeviceTestGetCurrentChannelResponse>(offset);
407 self.0.encode(encoder, offset + 0, depth)?;
411 Ok(())
412 }
413 }
414
415 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
416 for DeviceTestGetCurrentChannelResponse
417 {
418 #[inline(always)]
419 fn new_empty() -> Self {
420 Self { channel_index: fidl::new_empty!(u16, D) }
421 }
422
423 #[inline]
424 unsafe fn decode(
425 &mut self,
426 decoder: &mut fidl::encoding::Decoder<'_, D>,
427 offset: usize,
428 _depth: fidl::encoding::Depth,
429 ) -> fidl::Result<()> {
430 decoder.debug_check_bounds::<Self>(offset);
431 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
432 unsafe {
435 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
436 }
437 Ok(())
438 }
439 }
440
441 impl fidl::encoding::ValueTypeMarker for DeviceTestGetCurrentMacAddressResponse {
442 type Borrowed<'a> = &'a Self;
443 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
444 value
445 }
446 }
447
448 unsafe impl fidl::encoding::TypeMarker for DeviceTestGetCurrentMacAddressResponse {
449 type Owned = Self;
450
451 #[inline(always)]
452 fn inline_align(_context: fidl::encoding::Context) -> usize {
453 1
454 }
455
456 #[inline(always)]
457 fn inline_size(_context: fidl::encoding::Context) -> usize {
458 8
459 }
460 }
461
462 unsafe impl<D: fidl::encoding::ResourceDialect>
463 fidl::encoding::Encode<DeviceTestGetCurrentMacAddressResponse, D>
464 for &DeviceTestGetCurrentMacAddressResponse
465 {
466 #[inline]
467 unsafe fn encode(
468 self,
469 encoder: &mut fidl::encoding::Encoder<'_, D>,
470 offset: usize,
471 _depth: fidl::encoding::Depth,
472 ) -> fidl::Result<()> {
473 encoder.debug_check_bounds::<DeviceTestGetCurrentMacAddressResponse>(offset);
474 fidl::encoding::Encode::<DeviceTestGetCurrentMacAddressResponse, D>::encode(
476 (
477 <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
478 ),
479 encoder, offset, _depth
480 )
481 }
482 }
483 unsafe impl<
484 D: fidl::encoding::ResourceDialect,
485 T0: fidl::encoding::Encode<fidl_fuchsia_lowpan__common::MacAddress, D>,
486 > fidl::encoding::Encode<DeviceTestGetCurrentMacAddressResponse, D> for (T0,)
487 {
488 #[inline]
489 unsafe fn encode(
490 self,
491 encoder: &mut fidl::encoding::Encoder<'_, D>,
492 offset: usize,
493 depth: fidl::encoding::Depth,
494 ) -> fidl::Result<()> {
495 encoder.debug_check_bounds::<DeviceTestGetCurrentMacAddressResponse>(offset);
496 self.0.encode(encoder, offset + 0, depth)?;
500 Ok(())
501 }
502 }
503
504 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
505 for DeviceTestGetCurrentMacAddressResponse
506 {
507 #[inline(always)]
508 fn new_empty() -> Self {
509 Self { address: fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D) }
510 }
511
512 #[inline]
513 unsafe fn decode(
514 &mut self,
515 decoder: &mut fidl::encoding::Decoder<'_, D>,
516 offset: usize,
517 _depth: fidl::encoding::Depth,
518 ) -> fidl::Result<()> {
519 decoder.debug_check_bounds::<Self>(offset);
520 fidl::decode!(
522 fidl_fuchsia_lowpan__common::MacAddress,
523 D,
524 &mut self.address,
525 decoder,
526 offset + 0,
527 _depth
528 )?;
529 Ok(())
530 }
531 }
532
533 impl fidl::encoding::ValueTypeMarker for DeviceTestGetCurrentRssiResponse {
534 type Borrowed<'a> = &'a Self;
535 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
536 value
537 }
538 }
539
540 unsafe impl fidl::encoding::TypeMarker for DeviceTestGetCurrentRssiResponse {
541 type Owned = Self;
542
543 #[inline(always)]
544 fn inline_align(_context: fidl::encoding::Context) -> usize {
545 1
546 }
547
548 #[inline(always)]
549 fn inline_size(_context: fidl::encoding::Context) -> usize {
550 1
551 }
552 #[inline(always)]
553 fn encode_is_copy() -> bool {
554 true
555 }
556
557 #[inline(always)]
558 fn decode_is_copy() -> bool {
559 true
560 }
561 }
562
563 unsafe impl<D: fidl::encoding::ResourceDialect>
564 fidl::encoding::Encode<DeviceTestGetCurrentRssiResponse, D>
565 for &DeviceTestGetCurrentRssiResponse
566 {
567 #[inline]
568 unsafe fn encode(
569 self,
570 encoder: &mut fidl::encoding::Encoder<'_, D>,
571 offset: usize,
572 _depth: fidl::encoding::Depth,
573 ) -> fidl::Result<()> {
574 encoder.debug_check_bounds::<DeviceTestGetCurrentRssiResponse>(offset);
575 unsafe {
576 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
578 (buf_ptr as *mut DeviceTestGetCurrentRssiResponse)
579 .write_unaligned((self as *const DeviceTestGetCurrentRssiResponse).read());
580 }
583 Ok(())
584 }
585 }
586 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i8, D>>
587 fidl::encoding::Encode<DeviceTestGetCurrentRssiResponse, D> for (T0,)
588 {
589 #[inline]
590 unsafe fn encode(
591 self,
592 encoder: &mut fidl::encoding::Encoder<'_, D>,
593 offset: usize,
594 depth: fidl::encoding::Depth,
595 ) -> fidl::Result<()> {
596 encoder.debug_check_bounds::<DeviceTestGetCurrentRssiResponse>(offset);
597 self.0.encode(encoder, offset + 0, depth)?;
601 Ok(())
602 }
603 }
604
605 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
606 for DeviceTestGetCurrentRssiResponse
607 {
608 #[inline(always)]
609 fn new_empty() -> Self {
610 Self { rssi: fidl::new_empty!(i8, D) }
611 }
612
613 #[inline]
614 unsafe fn decode(
615 &mut self,
616 decoder: &mut fidl::encoding::Decoder<'_, D>,
617 offset: usize,
618 _depth: fidl::encoding::Depth,
619 ) -> fidl::Result<()> {
620 decoder.debug_check_bounds::<Self>(offset);
621 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
622 unsafe {
625 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
626 }
627 Ok(())
628 }
629 }
630
631 impl fidl::encoding::ValueTypeMarker for DeviceTestGetFactoryMacAddressResponse {
632 type Borrowed<'a> = &'a Self;
633 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
634 value
635 }
636 }
637
638 unsafe impl fidl::encoding::TypeMarker for DeviceTestGetFactoryMacAddressResponse {
639 type Owned = Self;
640
641 #[inline(always)]
642 fn inline_align(_context: fidl::encoding::Context) -> usize {
643 1
644 }
645
646 #[inline(always)]
647 fn inline_size(_context: fidl::encoding::Context) -> usize {
648 8
649 }
650 }
651
652 unsafe impl<D: fidl::encoding::ResourceDialect>
653 fidl::encoding::Encode<DeviceTestGetFactoryMacAddressResponse, D>
654 for &DeviceTestGetFactoryMacAddressResponse
655 {
656 #[inline]
657 unsafe fn encode(
658 self,
659 encoder: &mut fidl::encoding::Encoder<'_, D>,
660 offset: usize,
661 _depth: fidl::encoding::Depth,
662 ) -> fidl::Result<()> {
663 encoder.debug_check_bounds::<DeviceTestGetFactoryMacAddressResponse>(offset);
664 fidl::encoding::Encode::<DeviceTestGetFactoryMacAddressResponse, D>::encode(
666 (
667 <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
668 ),
669 encoder, offset, _depth
670 )
671 }
672 }
673 unsafe impl<
674 D: fidl::encoding::ResourceDialect,
675 T0: fidl::encoding::Encode<fidl_fuchsia_lowpan__common::MacAddress, D>,
676 > fidl::encoding::Encode<DeviceTestGetFactoryMacAddressResponse, D> for (T0,)
677 {
678 #[inline]
679 unsafe fn encode(
680 self,
681 encoder: &mut fidl::encoding::Encoder<'_, D>,
682 offset: usize,
683 depth: fidl::encoding::Depth,
684 ) -> fidl::Result<()> {
685 encoder.debug_check_bounds::<DeviceTestGetFactoryMacAddressResponse>(offset);
686 self.0.encode(encoder, offset + 0, depth)?;
690 Ok(())
691 }
692 }
693
694 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
695 for DeviceTestGetFactoryMacAddressResponse
696 {
697 #[inline(always)]
698 fn new_empty() -> Self {
699 Self { address: fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D) }
700 }
701
702 #[inline]
703 unsafe fn decode(
704 &mut self,
705 decoder: &mut fidl::encoding::Decoder<'_, D>,
706 offset: usize,
707 _depth: fidl::encoding::Depth,
708 ) -> fidl::Result<()> {
709 decoder.debug_check_bounds::<Self>(offset);
710 fidl::decode!(
712 fidl_fuchsia_lowpan__common::MacAddress,
713 D,
714 &mut self.address,
715 decoder,
716 offset + 0,
717 _depth
718 )?;
719 Ok(())
720 }
721 }
722
723 impl fidl::encoding::ValueTypeMarker for DeviceTestGetMacAddressFilterSettingsResponse {
724 type Borrowed<'a> = &'a Self;
725 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
726 value
727 }
728 }
729
730 unsafe impl fidl::encoding::TypeMarker for DeviceTestGetMacAddressFilterSettingsResponse {
731 type Owned = Self;
732
733 #[inline(always)]
734 fn inline_align(_context: fidl::encoding::Context) -> usize {
735 8
736 }
737
738 #[inline(always)]
739 fn inline_size(_context: fidl::encoding::Context) -> usize {
740 16
741 }
742 }
743
744 unsafe impl<D: fidl::encoding::ResourceDialect>
745 fidl::encoding::Encode<DeviceTestGetMacAddressFilterSettingsResponse, D>
746 for &DeviceTestGetMacAddressFilterSettingsResponse
747 {
748 #[inline]
749 unsafe fn encode(
750 self,
751 encoder: &mut fidl::encoding::Encoder<'_, D>,
752 offset: usize,
753 _depth: fidl::encoding::Depth,
754 ) -> fidl::Result<()> {
755 encoder.debug_check_bounds::<DeviceTestGetMacAddressFilterSettingsResponse>(offset);
756 fidl::encoding::Encode::<DeviceTestGetMacAddressFilterSettingsResponse, D>::encode(
758 (<MacAddressFilterSettings as fidl::encoding::ValueTypeMarker>::borrow(
759 &self.settings,
760 ),),
761 encoder,
762 offset,
763 _depth,
764 )
765 }
766 }
767 unsafe impl<
768 D: fidl::encoding::ResourceDialect,
769 T0: fidl::encoding::Encode<MacAddressFilterSettings, D>,
770 > fidl::encoding::Encode<DeviceTestGetMacAddressFilterSettingsResponse, D> for (T0,)
771 {
772 #[inline]
773 unsafe fn encode(
774 self,
775 encoder: &mut fidl::encoding::Encoder<'_, D>,
776 offset: usize,
777 depth: fidl::encoding::Depth,
778 ) -> fidl::Result<()> {
779 encoder.debug_check_bounds::<DeviceTestGetMacAddressFilterSettingsResponse>(offset);
780 self.0.encode(encoder, offset + 0, depth)?;
784 Ok(())
785 }
786 }
787
788 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
789 for DeviceTestGetMacAddressFilterSettingsResponse
790 {
791 #[inline(always)]
792 fn new_empty() -> Self {
793 Self { settings: fidl::new_empty!(MacAddressFilterSettings, D) }
794 }
795
796 #[inline]
797 unsafe fn decode(
798 &mut self,
799 decoder: &mut fidl::encoding::Decoder<'_, D>,
800 offset: usize,
801 _depth: fidl::encoding::Depth,
802 ) -> fidl::Result<()> {
803 decoder.debug_check_bounds::<Self>(offset);
804 fidl::decode!(
806 MacAddressFilterSettings,
807 D,
808 &mut self.settings,
809 decoder,
810 offset + 0,
811 _depth
812 )?;
813 Ok(())
814 }
815 }
816
817 impl fidl::encoding::ValueTypeMarker for DeviceTestGetNcpVersionResponse {
818 type Borrowed<'a> = &'a Self;
819 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
820 value
821 }
822 }
823
824 unsafe impl fidl::encoding::TypeMarker for DeviceTestGetNcpVersionResponse {
825 type Owned = Self;
826
827 #[inline(always)]
828 fn inline_align(_context: fidl::encoding::Context) -> usize {
829 8
830 }
831
832 #[inline(always)]
833 fn inline_size(_context: fidl::encoding::Context) -> usize {
834 16
835 }
836 }
837
838 unsafe impl<D: fidl::encoding::ResourceDialect>
839 fidl::encoding::Encode<DeviceTestGetNcpVersionResponse, D>
840 for &DeviceTestGetNcpVersionResponse
841 {
842 #[inline]
843 unsafe fn encode(
844 self,
845 encoder: &mut fidl::encoding::Encoder<'_, D>,
846 offset: usize,
847 _depth: fidl::encoding::Depth,
848 ) -> fidl::Result<()> {
849 encoder.debug_check_bounds::<DeviceTestGetNcpVersionResponse>(offset);
850 fidl::encoding::Encode::<DeviceTestGetNcpVersionResponse, D>::encode(
852 (<fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
853 &self.version,
854 ),),
855 encoder,
856 offset,
857 _depth,
858 )
859 }
860 }
861 unsafe impl<
862 D: fidl::encoding::ResourceDialect,
863 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
864 > fidl::encoding::Encode<DeviceTestGetNcpVersionResponse, D> for (T0,)
865 {
866 #[inline]
867 unsafe fn encode(
868 self,
869 encoder: &mut fidl::encoding::Encoder<'_, D>,
870 offset: usize,
871 depth: fidl::encoding::Depth,
872 ) -> fidl::Result<()> {
873 encoder.debug_check_bounds::<DeviceTestGetNcpVersionResponse>(offset);
874 self.0.encode(encoder, offset + 0, depth)?;
878 Ok(())
879 }
880 }
881
882 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
883 for DeviceTestGetNcpVersionResponse
884 {
885 #[inline(always)]
886 fn new_empty() -> Self {
887 Self { version: fidl::new_empty!(fidl::encoding::BoundedString<256>, D) }
888 }
889
890 #[inline]
891 unsafe fn decode(
892 &mut self,
893 decoder: &mut fidl::encoding::Decoder<'_, D>,
894 offset: usize,
895 _depth: fidl::encoding::Depth,
896 ) -> fidl::Result<()> {
897 decoder.debug_check_bounds::<Self>(offset);
898 fidl::decode!(
900 fidl::encoding::BoundedString<256>,
901 D,
902 &mut self.version,
903 decoder,
904 offset + 0,
905 _depth
906 )?;
907 Ok(())
908 }
909 }
910
911 impl fidl::encoding::ValueTypeMarker for DeviceTestGetNeighborTableResponse {
912 type Borrowed<'a> = &'a Self;
913 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
914 value
915 }
916 }
917
918 unsafe impl fidl::encoding::TypeMarker for DeviceTestGetNeighborTableResponse {
919 type Owned = Self;
920
921 #[inline(always)]
922 fn inline_align(_context: fidl::encoding::Context) -> usize {
923 8
924 }
925
926 #[inline(always)]
927 fn inline_size(_context: fidl::encoding::Context) -> usize {
928 16
929 }
930 }
931
932 unsafe impl<D: fidl::encoding::ResourceDialect>
933 fidl::encoding::Encode<DeviceTestGetNeighborTableResponse, D>
934 for &DeviceTestGetNeighborTableResponse
935 {
936 #[inline]
937 unsafe fn encode(
938 self,
939 encoder: &mut fidl::encoding::Encoder<'_, D>,
940 offset: usize,
941 _depth: fidl::encoding::Depth,
942 ) -> fidl::Result<()> {
943 encoder.debug_check_bounds::<DeviceTestGetNeighborTableResponse>(offset);
944 fidl::encoding::Encode::<DeviceTestGetNeighborTableResponse, D>::encode(
946 (
947 <fidl::encoding::Vector<NeighborInfo, 1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.neighbor_table),
948 ),
949 encoder, offset, _depth
950 )
951 }
952 }
953 unsafe impl<
954 D: fidl::encoding::ResourceDialect,
955 T0: fidl::encoding::Encode<fidl::encoding::Vector<NeighborInfo, 1024>, D>,
956 > fidl::encoding::Encode<DeviceTestGetNeighborTableResponse, D> for (T0,)
957 {
958 #[inline]
959 unsafe fn encode(
960 self,
961 encoder: &mut fidl::encoding::Encoder<'_, D>,
962 offset: usize,
963 depth: fidl::encoding::Depth,
964 ) -> fidl::Result<()> {
965 encoder.debug_check_bounds::<DeviceTestGetNeighborTableResponse>(offset);
966 self.0.encode(encoder, offset + 0, depth)?;
970 Ok(())
971 }
972 }
973
974 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
975 for DeviceTestGetNeighborTableResponse
976 {
977 #[inline(always)]
978 fn new_empty() -> Self {
979 Self { neighbor_table: fidl::new_empty!(fidl::encoding::Vector<NeighborInfo, 1024>, D) }
980 }
981
982 #[inline]
983 unsafe fn decode(
984 &mut self,
985 decoder: &mut fidl::encoding::Decoder<'_, D>,
986 offset: usize,
987 _depth: fidl::encoding::Depth,
988 ) -> fidl::Result<()> {
989 decoder.debug_check_bounds::<Self>(offset);
990 fidl::decode!(fidl::encoding::Vector<NeighborInfo, 1024>, D, &mut self.neighbor_table, decoder, offset + 0, _depth)?;
992 Ok(())
993 }
994 }
995
996 impl fidl::encoding::ValueTypeMarker for DeviceTestGetPartitionIdResponse {
997 type Borrowed<'a> = &'a Self;
998 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
999 value
1000 }
1001 }
1002
1003 unsafe impl fidl::encoding::TypeMarker for DeviceTestGetPartitionIdResponse {
1004 type Owned = Self;
1005
1006 #[inline(always)]
1007 fn inline_align(_context: fidl::encoding::Context) -> usize {
1008 4
1009 }
1010
1011 #[inline(always)]
1012 fn inline_size(_context: fidl::encoding::Context) -> usize {
1013 4
1014 }
1015 #[inline(always)]
1016 fn encode_is_copy() -> bool {
1017 true
1018 }
1019
1020 #[inline(always)]
1021 fn decode_is_copy() -> bool {
1022 true
1023 }
1024 }
1025
1026 unsafe impl<D: fidl::encoding::ResourceDialect>
1027 fidl::encoding::Encode<DeviceTestGetPartitionIdResponse, D>
1028 for &DeviceTestGetPartitionIdResponse
1029 {
1030 #[inline]
1031 unsafe fn encode(
1032 self,
1033 encoder: &mut fidl::encoding::Encoder<'_, D>,
1034 offset: usize,
1035 _depth: fidl::encoding::Depth,
1036 ) -> fidl::Result<()> {
1037 encoder.debug_check_bounds::<DeviceTestGetPartitionIdResponse>(offset);
1038 unsafe {
1039 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1041 (buf_ptr as *mut DeviceTestGetPartitionIdResponse)
1042 .write_unaligned((self as *const DeviceTestGetPartitionIdResponse).read());
1043 }
1046 Ok(())
1047 }
1048 }
1049 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
1050 fidl::encoding::Encode<DeviceTestGetPartitionIdResponse, D> for (T0,)
1051 {
1052 #[inline]
1053 unsafe fn encode(
1054 self,
1055 encoder: &mut fidl::encoding::Encoder<'_, D>,
1056 offset: usize,
1057 depth: fidl::encoding::Depth,
1058 ) -> fidl::Result<()> {
1059 encoder.debug_check_bounds::<DeviceTestGetPartitionIdResponse>(offset);
1060 self.0.encode(encoder, offset + 0, depth)?;
1064 Ok(())
1065 }
1066 }
1067
1068 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1069 for DeviceTestGetPartitionIdResponse
1070 {
1071 #[inline(always)]
1072 fn new_empty() -> Self {
1073 Self { pid: fidl::new_empty!(u32, D) }
1074 }
1075
1076 #[inline]
1077 unsafe fn decode(
1078 &mut self,
1079 decoder: &mut fidl::encoding::Decoder<'_, D>,
1080 offset: usize,
1081 _depth: fidl::encoding::Depth,
1082 ) -> fidl::Result<()> {
1083 decoder.debug_check_bounds::<Self>(offset);
1084 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1085 unsafe {
1088 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1089 }
1090 Ok(())
1091 }
1092 }
1093
1094 impl fidl::encoding::ValueTypeMarker for DeviceTestGetThreadRloc16Response {
1095 type Borrowed<'a> = &'a Self;
1096 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1097 value
1098 }
1099 }
1100
1101 unsafe impl fidl::encoding::TypeMarker for DeviceTestGetThreadRloc16Response {
1102 type Owned = Self;
1103
1104 #[inline(always)]
1105 fn inline_align(_context: fidl::encoding::Context) -> usize {
1106 2
1107 }
1108
1109 #[inline(always)]
1110 fn inline_size(_context: fidl::encoding::Context) -> usize {
1111 2
1112 }
1113 #[inline(always)]
1114 fn encode_is_copy() -> bool {
1115 true
1116 }
1117
1118 #[inline(always)]
1119 fn decode_is_copy() -> bool {
1120 true
1121 }
1122 }
1123
1124 unsafe impl<D: fidl::encoding::ResourceDialect>
1125 fidl::encoding::Encode<DeviceTestGetThreadRloc16Response, D>
1126 for &DeviceTestGetThreadRloc16Response
1127 {
1128 #[inline]
1129 unsafe fn encode(
1130 self,
1131 encoder: &mut fidl::encoding::Encoder<'_, D>,
1132 offset: usize,
1133 _depth: fidl::encoding::Depth,
1134 ) -> fidl::Result<()> {
1135 encoder.debug_check_bounds::<DeviceTestGetThreadRloc16Response>(offset);
1136 unsafe {
1137 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1139 (buf_ptr as *mut DeviceTestGetThreadRloc16Response)
1140 .write_unaligned((self as *const DeviceTestGetThreadRloc16Response).read());
1141 }
1144 Ok(())
1145 }
1146 }
1147 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1148 fidl::encoding::Encode<DeviceTestGetThreadRloc16Response, D> for (T0,)
1149 {
1150 #[inline]
1151 unsafe fn encode(
1152 self,
1153 encoder: &mut fidl::encoding::Encoder<'_, D>,
1154 offset: usize,
1155 depth: fidl::encoding::Depth,
1156 ) -> fidl::Result<()> {
1157 encoder.debug_check_bounds::<DeviceTestGetThreadRloc16Response>(offset);
1158 self.0.encode(encoder, offset + 0, depth)?;
1162 Ok(())
1163 }
1164 }
1165
1166 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1167 for DeviceTestGetThreadRloc16Response
1168 {
1169 #[inline(always)]
1170 fn new_empty() -> Self {
1171 Self { rloc: fidl::new_empty!(u16, D) }
1172 }
1173
1174 #[inline]
1175 unsafe fn decode(
1176 &mut self,
1177 decoder: &mut fidl::encoding::Decoder<'_, D>,
1178 offset: usize,
1179 _depth: fidl::encoding::Depth,
1180 ) -> fidl::Result<()> {
1181 decoder.debug_check_bounds::<Self>(offset);
1182 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1183 unsafe {
1186 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1187 }
1188 Ok(())
1189 }
1190 }
1191
1192 impl fidl::encoding::ValueTypeMarker for DeviceTestGetThreadRouterIdResponse {
1193 type Borrowed<'a> = &'a Self;
1194 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1195 value
1196 }
1197 }
1198
1199 unsafe impl fidl::encoding::TypeMarker for DeviceTestGetThreadRouterIdResponse {
1200 type Owned = Self;
1201
1202 #[inline(always)]
1203 fn inline_align(_context: fidl::encoding::Context) -> usize {
1204 1
1205 }
1206
1207 #[inline(always)]
1208 fn inline_size(_context: fidl::encoding::Context) -> usize {
1209 1
1210 }
1211 #[inline(always)]
1212 fn encode_is_copy() -> bool {
1213 true
1214 }
1215
1216 #[inline(always)]
1217 fn decode_is_copy() -> bool {
1218 true
1219 }
1220 }
1221
1222 unsafe impl<D: fidl::encoding::ResourceDialect>
1223 fidl::encoding::Encode<DeviceTestGetThreadRouterIdResponse, D>
1224 for &DeviceTestGetThreadRouterIdResponse
1225 {
1226 #[inline]
1227 unsafe fn encode(
1228 self,
1229 encoder: &mut fidl::encoding::Encoder<'_, D>,
1230 offset: usize,
1231 _depth: fidl::encoding::Depth,
1232 ) -> fidl::Result<()> {
1233 encoder.debug_check_bounds::<DeviceTestGetThreadRouterIdResponse>(offset);
1234 unsafe {
1235 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1237 (buf_ptr as *mut DeviceTestGetThreadRouterIdResponse)
1238 .write_unaligned((self as *const DeviceTestGetThreadRouterIdResponse).read());
1239 }
1242 Ok(())
1243 }
1244 }
1245 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
1246 fidl::encoding::Encode<DeviceTestGetThreadRouterIdResponse, D> for (T0,)
1247 {
1248 #[inline]
1249 unsafe fn encode(
1250 self,
1251 encoder: &mut fidl::encoding::Encoder<'_, D>,
1252 offset: usize,
1253 depth: fidl::encoding::Depth,
1254 ) -> fidl::Result<()> {
1255 encoder.debug_check_bounds::<DeviceTestGetThreadRouterIdResponse>(offset);
1256 self.0.encode(encoder, offset + 0, depth)?;
1260 Ok(())
1261 }
1262 }
1263
1264 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1265 for DeviceTestGetThreadRouterIdResponse
1266 {
1267 #[inline(always)]
1268 fn new_empty() -> Self {
1269 Self { router_id: fidl::new_empty!(u8, D) }
1270 }
1271
1272 #[inline]
1273 unsafe fn decode(
1274 &mut self,
1275 decoder: &mut fidl::encoding::Decoder<'_, D>,
1276 offset: usize,
1277 _depth: fidl::encoding::Depth,
1278 ) -> fidl::Result<()> {
1279 decoder.debug_check_bounds::<Self>(offset);
1280 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1281 unsafe {
1284 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1285 }
1286 Ok(())
1287 }
1288 }
1289
1290 impl fidl::encoding::ValueTypeMarker for DeviceTestReplaceMacAddressFilterSettingsRequest {
1291 type Borrowed<'a> = &'a Self;
1292 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1293 value
1294 }
1295 }
1296
1297 unsafe impl fidl::encoding::TypeMarker for DeviceTestReplaceMacAddressFilterSettingsRequest {
1298 type Owned = Self;
1299
1300 #[inline(always)]
1301 fn inline_align(_context: fidl::encoding::Context) -> usize {
1302 8
1303 }
1304
1305 #[inline(always)]
1306 fn inline_size(_context: fidl::encoding::Context) -> usize {
1307 16
1308 }
1309 }
1310
1311 unsafe impl<D: fidl::encoding::ResourceDialect>
1312 fidl::encoding::Encode<DeviceTestReplaceMacAddressFilterSettingsRequest, D>
1313 for &DeviceTestReplaceMacAddressFilterSettingsRequest
1314 {
1315 #[inline]
1316 unsafe fn encode(
1317 self,
1318 encoder: &mut fidl::encoding::Encoder<'_, D>,
1319 offset: usize,
1320 _depth: fidl::encoding::Depth,
1321 ) -> fidl::Result<()> {
1322 encoder.debug_check_bounds::<DeviceTestReplaceMacAddressFilterSettingsRequest>(offset);
1323 fidl::encoding::Encode::<DeviceTestReplaceMacAddressFilterSettingsRequest, D>::encode(
1325 (<MacAddressFilterSettings as fidl::encoding::ValueTypeMarker>::borrow(
1326 &self.settings,
1327 ),),
1328 encoder,
1329 offset,
1330 _depth,
1331 )
1332 }
1333 }
1334 unsafe impl<
1335 D: fidl::encoding::ResourceDialect,
1336 T0: fidl::encoding::Encode<MacAddressFilterSettings, D>,
1337 > fidl::encoding::Encode<DeviceTestReplaceMacAddressFilterSettingsRequest, D> for (T0,)
1338 {
1339 #[inline]
1340 unsafe fn encode(
1341 self,
1342 encoder: &mut fidl::encoding::Encoder<'_, D>,
1343 offset: usize,
1344 depth: fidl::encoding::Depth,
1345 ) -> fidl::Result<()> {
1346 encoder.debug_check_bounds::<DeviceTestReplaceMacAddressFilterSettingsRequest>(offset);
1347 self.0.encode(encoder, offset + 0, depth)?;
1351 Ok(())
1352 }
1353 }
1354
1355 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1356 for DeviceTestReplaceMacAddressFilterSettingsRequest
1357 {
1358 #[inline(always)]
1359 fn new_empty() -> Self {
1360 Self { settings: fidl::new_empty!(MacAddressFilterSettings, D) }
1361 }
1362
1363 #[inline]
1364 unsafe fn decode(
1365 &mut self,
1366 decoder: &mut fidl::encoding::Decoder<'_, D>,
1367 offset: usize,
1368 _depth: fidl::encoding::Depth,
1369 ) -> fidl::Result<()> {
1370 decoder.debug_check_bounds::<Self>(offset);
1371 fidl::decode!(
1373 MacAddressFilterSettings,
1374 D,
1375 &mut self.settings,
1376 decoder,
1377 offset + 0,
1378 _depth
1379 )?;
1380 Ok(())
1381 }
1382 }
1383
1384 impl MacAddressFilterItem {
1385 #[inline(always)]
1386 fn max_ordinal_present(&self) -> u64 {
1387 if let Some(_) = self.rssi {
1388 return 2;
1389 }
1390 if let Some(_) = self.mac_address {
1391 return 1;
1392 }
1393 0
1394 }
1395 }
1396
1397 impl fidl::encoding::ValueTypeMarker for MacAddressFilterItem {
1398 type Borrowed<'a> = &'a Self;
1399 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1400 value
1401 }
1402 }
1403
1404 unsafe impl fidl::encoding::TypeMarker for MacAddressFilterItem {
1405 type Owned = Self;
1406
1407 #[inline(always)]
1408 fn inline_align(_context: fidl::encoding::Context) -> usize {
1409 8
1410 }
1411
1412 #[inline(always)]
1413 fn inline_size(_context: fidl::encoding::Context) -> usize {
1414 16
1415 }
1416 }
1417
1418 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MacAddressFilterItem, D>
1419 for &MacAddressFilterItem
1420 {
1421 unsafe fn encode(
1422 self,
1423 encoder: &mut fidl::encoding::Encoder<'_, D>,
1424 offset: usize,
1425 mut depth: fidl::encoding::Depth,
1426 ) -> fidl::Result<()> {
1427 encoder.debug_check_bounds::<MacAddressFilterItem>(offset);
1428 let max_ordinal: u64 = self.max_ordinal_present();
1430 encoder.write_num(max_ordinal, offset);
1431 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1432 if max_ordinal == 0 {
1434 return Ok(());
1435 }
1436 depth.increment()?;
1437 let envelope_size = 8;
1438 let bytes_len = max_ordinal as usize * envelope_size;
1439 #[allow(unused_variables)]
1440 let offset = encoder.out_of_line_offset(bytes_len);
1441 let mut _prev_end_offset: usize = 0;
1442 if 1 > max_ordinal {
1443 return Ok(());
1444 }
1445
1446 let cur_offset: usize = (1 - 1) * envelope_size;
1449
1450 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1452
1453 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan__common::MacAddress, D>(
1458 self.mac_address.as_ref().map(<fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
1459 encoder, offset + cur_offset, depth
1460 )?;
1461
1462 _prev_end_offset = cur_offset + envelope_size;
1463 if 2 > max_ordinal {
1464 return Ok(());
1465 }
1466
1467 let cur_offset: usize = (2 - 1) * envelope_size;
1470
1471 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1473
1474 fidl::encoding::encode_in_envelope_optional::<i8, D>(
1479 self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
1480 encoder,
1481 offset + cur_offset,
1482 depth,
1483 )?;
1484
1485 _prev_end_offset = cur_offset + envelope_size;
1486
1487 Ok(())
1488 }
1489 }
1490
1491 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacAddressFilterItem {
1492 #[inline(always)]
1493 fn new_empty() -> Self {
1494 Self::default()
1495 }
1496
1497 unsafe fn decode(
1498 &mut self,
1499 decoder: &mut fidl::encoding::Decoder<'_, D>,
1500 offset: usize,
1501 mut depth: fidl::encoding::Depth,
1502 ) -> fidl::Result<()> {
1503 decoder.debug_check_bounds::<Self>(offset);
1504 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1505 None => return Err(fidl::Error::NotNullable),
1506 Some(len) => len,
1507 };
1508 if len == 0 {
1510 return Ok(());
1511 };
1512 depth.increment()?;
1513 let envelope_size = 8;
1514 let bytes_len = len * envelope_size;
1515 let offset = decoder.out_of_line_offset(bytes_len)?;
1516 let mut _next_ordinal_to_read = 0;
1518 let mut next_offset = offset;
1519 let end_offset = offset + bytes_len;
1520 _next_ordinal_to_read += 1;
1521 if next_offset >= end_offset {
1522 return Ok(());
1523 }
1524
1525 while _next_ordinal_to_read < 1 {
1527 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1528 _next_ordinal_to_read += 1;
1529 next_offset += envelope_size;
1530 }
1531
1532 let next_out_of_line = decoder.next_out_of_line();
1533 let handles_before = decoder.remaining_handles();
1534 if let Some((inlined, num_bytes, num_handles)) =
1535 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1536 {
1537 let member_inline_size = <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1538 if inlined != (member_inline_size <= 4) {
1539 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1540 }
1541 let inner_offset;
1542 let mut inner_depth = depth.clone();
1543 if inlined {
1544 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1545 inner_offset = next_offset;
1546 } else {
1547 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1548 inner_depth.increment()?;
1549 }
1550 let val_ref = self.mac_address.get_or_insert_with(|| {
1551 fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D)
1552 });
1553 fidl::decode!(
1554 fidl_fuchsia_lowpan__common::MacAddress,
1555 D,
1556 val_ref,
1557 decoder,
1558 inner_offset,
1559 inner_depth
1560 )?;
1561 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1562 {
1563 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1564 }
1565 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1566 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1567 }
1568 }
1569
1570 next_offset += envelope_size;
1571 _next_ordinal_to_read += 1;
1572 if next_offset >= end_offset {
1573 return Ok(());
1574 }
1575
1576 while _next_ordinal_to_read < 2 {
1578 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1579 _next_ordinal_to_read += 1;
1580 next_offset += envelope_size;
1581 }
1582
1583 let next_out_of_line = decoder.next_out_of_line();
1584 let handles_before = decoder.remaining_handles();
1585 if let Some((inlined, num_bytes, num_handles)) =
1586 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1587 {
1588 let member_inline_size =
1589 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1590 if inlined != (member_inline_size <= 4) {
1591 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1592 }
1593 let inner_offset;
1594 let mut inner_depth = depth.clone();
1595 if inlined {
1596 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1597 inner_offset = next_offset;
1598 } else {
1599 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1600 inner_depth.increment()?;
1601 }
1602 let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
1603 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
1604 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1605 {
1606 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1607 }
1608 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1609 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1610 }
1611 }
1612
1613 next_offset += envelope_size;
1614
1615 while next_offset < end_offset {
1617 _next_ordinal_to_read += 1;
1618 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1619 next_offset += envelope_size;
1620 }
1621
1622 Ok(())
1623 }
1624 }
1625
1626 impl MacAddressFilterSettings {
1627 #[inline(always)]
1628 fn max_ordinal_present(&self) -> u64 {
1629 if let Some(_) = self.items {
1630 return 2;
1631 }
1632 if let Some(_) = self.mode {
1633 return 1;
1634 }
1635 0
1636 }
1637 }
1638
1639 impl fidl::encoding::ValueTypeMarker for MacAddressFilterSettings {
1640 type Borrowed<'a> = &'a Self;
1641 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1642 value
1643 }
1644 }
1645
1646 unsafe impl fidl::encoding::TypeMarker for MacAddressFilterSettings {
1647 type Owned = Self;
1648
1649 #[inline(always)]
1650 fn inline_align(_context: fidl::encoding::Context) -> usize {
1651 8
1652 }
1653
1654 #[inline(always)]
1655 fn inline_size(_context: fidl::encoding::Context) -> usize {
1656 16
1657 }
1658 }
1659
1660 unsafe impl<D: fidl::encoding::ResourceDialect>
1661 fidl::encoding::Encode<MacAddressFilterSettings, D> for &MacAddressFilterSettings
1662 {
1663 unsafe fn encode(
1664 self,
1665 encoder: &mut fidl::encoding::Encoder<'_, D>,
1666 offset: usize,
1667 mut depth: fidl::encoding::Depth,
1668 ) -> fidl::Result<()> {
1669 encoder.debug_check_bounds::<MacAddressFilterSettings>(offset);
1670 let max_ordinal: u64 = self.max_ordinal_present();
1672 encoder.write_num(max_ordinal, offset);
1673 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1674 if max_ordinal == 0 {
1676 return Ok(());
1677 }
1678 depth.increment()?;
1679 let envelope_size = 8;
1680 let bytes_len = max_ordinal as usize * envelope_size;
1681 #[allow(unused_variables)]
1682 let offset = encoder.out_of_line_offset(bytes_len);
1683 let mut _prev_end_offset: usize = 0;
1684 if 1 > max_ordinal {
1685 return Ok(());
1686 }
1687
1688 let cur_offset: usize = (1 - 1) * envelope_size;
1691
1692 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1694
1695 fidl::encoding::encode_in_envelope_optional::<MacAddressFilterMode, D>(
1700 self.mode
1701 .as_ref()
1702 .map(<MacAddressFilterMode as fidl::encoding::ValueTypeMarker>::borrow),
1703 encoder,
1704 offset + cur_offset,
1705 depth,
1706 )?;
1707
1708 _prev_end_offset = cur_offset + envelope_size;
1709 if 2 > max_ordinal {
1710 return Ok(());
1711 }
1712
1713 let cur_offset: usize = (2 - 1) * envelope_size;
1716
1717 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1719
1720 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<MacAddressFilterItem, 100>, D>(
1725 self.items.as_ref().map(<fidl::encoding::Vector<MacAddressFilterItem, 100> as fidl::encoding::ValueTypeMarker>::borrow),
1726 encoder, offset + cur_offset, depth
1727 )?;
1728
1729 _prev_end_offset = cur_offset + envelope_size;
1730
1731 Ok(())
1732 }
1733 }
1734
1735 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1736 for MacAddressFilterSettings
1737 {
1738 #[inline(always)]
1739 fn new_empty() -> Self {
1740 Self::default()
1741 }
1742
1743 unsafe fn decode(
1744 &mut self,
1745 decoder: &mut fidl::encoding::Decoder<'_, D>,
1746 offset: usize,
1747 mut depth: fidl::encoding::Depth,
1748 ) -> fidl::Result<()> {
1749 decoder.debug_check_bounds::<Self>(offset);
1750 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1751 None => return Err(fidl::Error::NotNullable),
1752 Some(len) => len,
1753 };
1754 if len == 0 {
1756 return Ok(());
1757 };
1758 depth.increment()?;
1759 let envelope_size = 8;
1760 let bytes_len = len * envelope_size;
1761 let offset = decoder.out_of_line_offset(bytes_len)?;
1762 let mut _next_ordinal_to_read = 0;
1764 let mut next_offset = offset;
1765 let end_offset = offset + bytes_len;
1766 _next_ordinal_to_read += 1;
1767 if next_offset >= end_offset {
1768 return Ok(());
1769 }
1770
1771 while _next_ordinal_to_read < 1 {
1773 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1774 _next_ordinal_to_read += 1;
1775 next_offset += envelope_size;
1776 }
1777
1778 let next_out_of_line = decoder.next_out_of_line();
1779 let handles_before = decoder.remaining_handles();
1780 if let Some((inlined, num_bytes, num_handles)) =
1781 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1782 {
1783 let member_inline_size =
1784 <MacAddressFilterMode as fidl::encoding::TypeMarker>::inline_size(
1785 decoder.context,
1786 );
1787 if inlined != (member_inline_size <= 4) {
1788 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1789 }
1790 let inner_offset;
1791 let mut inner_depth = depth.clone();
1792 if inlined {
1793 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1794 inner_offset = next_offset;
1795 } else {
1796 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1797 inner_depth.increment()?;
1798 }
1799 let val_ref =
1800 self.mode.get_or_insert_with(|| fidl::new_empty!(MacAddressFilterMode, D));
1801 fidl::decode!(
1802 MacAddressFilterMode,
1803 D,
1804 val_ref,
1805 decoder,
1806 inner_offset,
1807 inner_depth
1808 )?;
1809 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1810 {
1811 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1812 }
1813 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1814 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1815 }
1816 }
1817
1818 next_offset += envelope_size;
1819 _next_ordinal_to_read += 1;
1820 if next_offset >= end_offset {
1821 return Ok(());
1822 }
1823
1824 while _next_ordinal_to_read < 2 {
1826 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1827 _next_ordinal_to_read += 1;
1828 next_offset += envelope_size;
1829 }
1830
1831 let next_out_of_line = decoder.next_out_of_line();
1832 let handles_before = decoder.remaining_handles();
1833 if let Some((inlined, num_bytes, num_handles)) =
1834 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1835 {
1836 let member_inline_size = <fidl::encoding::Vector<MacAddressFilterItem, 100> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1837 if inlined != (member_inline_size <= 4) {
1838 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1839 }
1840 let inner_offset;
1841 let mut inner_depth = depth.clone();
1842 if inlined {
1843 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1844 inner_offset = next_offset;
1845 } else {
1846 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1847 inner_depth.increment()?;
1848 }
1849 let val_ref = self.items.get_or_insert_with(
1850 || fidl::new_empty!(fidl::encoding::Vector<MacAddressFilterItem, 100>, D),
1851 );
1852 fidl::decode!(fidl::encoding::Vector<MacAddressFilterItem, 100>, D, val_ref, decoder, inner_offset, inner_depth)?;
1853 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1854 {
1855 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1856 }
1857 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1858 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1859 }
1860 }
1861
1862 next_offset += envelope_size;
1863
1864 while next_offset < end_offset {
1866 _next_ordinal_to_read += 1;
1867 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1868 next_offset += envelope_size;
1869 }
1870
1871 Ok(())
1872 }
1873 }
1874
1875 impl NeighborInfo {
1876 #[inline(always)]
1877 fn max_ordinal_present(&self) -> u64 {
1878 if let Some(_) = self.thread_mle_version {
1879 return 17;
1880 }
1881 if let Some(_) = self.queued_messages {
1882 return 16;
1883 }
1884 if let Some(_) = self.net_data_version {
1885 return 15;
1886 }
1887 if let Some(_) = self.child_is_state_restoring {
1888 return 14;
1889 }
1890 if let Some(_) = self.child_is_csl_synced {
1891 return 13;
1892 }
1893 if let Some(_) = self.ipv6_error_rate {
1894 return 12;
1895 }
1896 if let Some(_) = self.frame_error_rate {
1897 return 11;
1898 }
1899 if let Some(_) = self.thread_mode {
1900 return 10;
1901 }
1902 if let Some(_) = self.lqi_in {
1903 return 9;
1904 }
1905 if let Some(_) = self.avg_rssi_in {
1906 return 8;
1907 }
1908 if let Some(_) = self.last_rssi_in {
1909 return 7;
1910 }
1911 if let Some(_) = self.mgmt_frame_count {
1912 return 6;
1913 }
1914 if let Some(_) = self.link_frame_count {
1915 return 5;
1916 }
1917 if let Some(_) = self.is_child {
1918 return 4;
1919 }
1920 if let Some(_) = self.age {
1921 return 3;
1922 }
1923 if let Some(_) = self.short_address {
1924 return 2;
1925 }
1926 if let Some(_) = self.mac_address {
1927 return 1;
1928 }
1929 0
1930 }
1931 }
1932
1933 impl fidl::encoding::ValueTypeMarker for NeighborInfo {
1934 type Borrowed<'a> = &'a Self;
1935 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1936 value
1937 }
1938 }
1939
1940 unsafe impl fidl::encoding::TypeMarker for NeighborInfo {
1941 type Owned = Self;
1942
1943 #[inline(always)]
1944 fn inline_align(_context: fidl::encoding::Context) -> usize {
1945 8
1946 }
1947
1948 #[inline(always)]
1949 fn inline_size(_context: fidl::encoding::Context) -> usize {
1950 16
1951 }
1952 }
1953
1954 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NeighborInfo, D>
1955 for &NeighborInfo
1956 {
1957 unsafe fn encode(
1958 self,
1959 encoder: &mut fidl::encoding::Encoder<'_, D>,
1960 offset: usize,
1961 mut depth: fidl::encoding::Depth,
1962 ) -> fidl::Result<()> {
1963 encoder.debug_check_bounds::<NeighborInfo>(offset);
1964 let max_ordinal: u64 = self.max_ordinal_present();
1966 encoder.write_num(max_ordinal, offset);
1967 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1968 if max_ordinal == 0 {
1970 return Ok(());
1971 }
1972 depth.increment()?;
1973 let envelope_size = 8;
1974 let bytes_len = max_ordinal as usize * envelope_size;
1975 #[allow(unused_variables)]
1976 let offset = encoder.out_of_line_offset(bytes_len);
1977 let mut _prev_end_offset: usize = 0;
1978 if 1 > max_ordinal {
1979 return Ok(());
1980 }
1981
1982 let cur_offset: usize = (1 - 1) * envelope_size;
1985
1986 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1988
1989 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan__common::MacAddress, D>(
1994 self.mac_address.as_ref().map(<fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
1995 encoder, offset + cur_offset, depth
1996 )?;
1997
1998 _prev_end_offset = cur_offset + envelope_size;
1999 if 2 > max_ordinal {
2000 return Ok(());
2001 }
2002
2003 let cur_offset: usize = (2 - 1) * envelope_size;
2006
2007 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2009
2010 fidl::encoding::encode_in_envelope_optional::<u16, D>(
2015 self.short_address.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2016 encoder,
2017 offset + cur_offset,
2018 depth,
2019 )?;
2020
2021 _prev_end_offset = cur_offset + envelope_size;
2022 if 3 > max_ordinal {
2023 return Ok(());
2024 }
2025
2026 let cur_offset: usize = (3 - 1) * envelope_size;
2029
2030 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2032
2033 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2038 self.age.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2039 encoder,
2040 offset + cur_offset,
2041 depth,
2042 )?;
2043
2044 _prev_end_offset = cur_offset + envelope_size;
2045 if 4 > max_ordinal {
2046 return Ok(());
2047 }
2048
2049 let cur_offset: usize = (4 - 1) * envelope_size;
2052
2053 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2055
2056 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2061 self.is_child.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2062 encoder,
2063 offset + cur_offset,
2064 depth,
2065 )?;
2066
2067 _prev_end_offset = cur_offset + envelope_size;
2068 if 5 > max_ordinal {
2069 return Ok(());
2070 }
2071
2072 let cur_offset: usize = (5 - 1) * envelope_size;
2075
2076 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2078
2079 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2084 self.link_frame_count
2085 .as_ref()
2086 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2087 encoder,
2088 offset + cur_offset,
2089 depth,
2090 )?;
2091
2092 _prev_end_offset = cur_offset + envelope_size;
2093 if 6 > max_ordinal {
2094 return Ok(());
2095 }
2096
2097 let cur_offset: usize = (6 - 1) * envelope_size;
2100
2101 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2103
2104 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2109 self.mgmt_frame_count
2110 .as_ref()
2111 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2112 encoder,
2113 offset + cur_offset,
2114 depth,
2115 )?;
2116
2117 _prev_end_offset = cur_offset + envelope_size;
2118 if 7 > max_ordinal {
2119 return Ok(());
2120 }
2121
2122 let cur_offset: usize = (7 - 1) * envelope_size;
2125
2126 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2128
2129 fidl::encoding::encode_in_envelope_optional::<i32, D>(
2134 self.last_rssi_in.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2135 encoder,
2136 offset + cur_offset,
2137 depth,
2138 )?;
2139
2140 _prev_end_offset = cur_offset + envelope_size;
2141 if 8 > max_ordinal {
2142 return Ok(());
2143 }
2144
2145 let cur_offset: usize = (8 - 1) * envelope_size;
2148
2149 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2151
2152 fidl::encoding::encode_in_envelope_optional::<i8, D>(
2157 self.avg_rssi_in.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
2158 encoder,
2159 offset + cur_offset,
2160 depth,
2161 )?;
2162
2163 _prev_end_offset = cur_offset + envelope_size;
2164 if 9 > max_ordinal {
2165 return Ok(());
2166 }
2167
2168 let cur_offset: usize = (9 - 1) * envelope_size;
2171
2172 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2174
2175 fidl::encoding::encode_in_envelope_optional::<u8, D>(
2180 self.lqi_in.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2181 encoder,
2182 offset + cur_offset,
2183 depth,
2184 )?;
2185
2186 _prev_end_offset = cur_offset + envelope_size;
2187 if 10 > max_ordinal {
2188 return Ok(());
2189 }
2190
2191 let cur_offset: usize = (10 - 1) * envelope_size;
2194
2195 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2197
2198 fidl::encoding::encode_in_envelope_optional::<u8, D>(
2203 self.thread_mode.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2204 encoder,
2205 offset + cur_offset,
2206 depth,
2207 )?;
2208
2209 _prev_end_offset = cur_offset + envelope_size;
2210 if 11 > max_ordinal {
2211 return Ok(());
2212 }
2213
2214 let cur_offset: usize = (11 - 1) * envelope_size;
2217
2218 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2220
2221 fidl::encoding::encode_in_envelope_optional::<u16, D>(
2226 self.frame_error_rate
2227 .as_ref()
2228 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2229 encoder,
2230 offset + cur_offset,
2231 depth,
2232 )?;
2233
2234 _prev_end_offset = cur_offset + envelope_size;
2235 if 12 > max_ordinal {
2236 return Ok(());
2237 }
2238
2239 let cur_offset: usize = (12 - 1) * envelope_size;
2242
2243 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2245
2246 fidl::encoding::encode_in_envelope_optional::<u16, D>(
2251 self.ipv6_error_rate.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2252 encoder,
2253 offset + cur_offset,
2254 depth,
2255 )?;
2256
2257 _prev_end_offset = cur_offset + envelope_size;
2258 if 13 > max_ordinal {
2259 return Ok(());
2260 }
2261
2262 let cur_offset: usize = (13 - 1) * envelope_size;
2265
2266 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2268
2269 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2274 self.child_is_csl_synced
2275 .as_ref()
2276 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2277 encoder,
2278 offset + cur_offset,
2279 depth,
2280 )?;
2281
2282 _prev_end_offset = cur_offset + envelope_size;
2283 if 14 > max_ordinal {
2284 return Ok(());
2285 }
2286
2287 let cur_offset: usize = (14 - 1) * envelope_size;
2290
2291 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2293
2294 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2299 self.child_is_state_restoring
2300 .as_ref()
2301 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2302 encoder,
2303 offset + cur_offset,
2304 depth,
2305 )?;
2306
2307 _prev_end_offset = cur_offset + envelope_size;
2308 if 15 > max_ordinal {
2309 return Ok(());
2310 }
2311
2312 let cur_offset: usize = (15 - 1) * envelope_size;
2315
2316 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2318
2319 fidl::encoding::encode_in_envelope_optional::<u8, D>(
2324 self.net_data_version.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2325 encoder,
2326 offset + cur_offset,
2327 depth,
2328 )?;
2329
2330 _prev_end_offset = cur_offset + envelope_size;
2331 if 16 > max_ordinal {
2332 return Ok(());
2333 }
2334
2335 let cur_offset: usize = (16 - 1) * envelope_size;
2338
2339 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2341
2342 fidl::encoding::encode_in_envelope_optional::<u16, D>(
2347 self.queued_messages.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2348 encoder,
2349 offset + cur_offset,
2350 depth,
2351 )?;
2352
2353 _prev_end_offset = cur_offset + envelope_size;
2354 if 17 > max_ordinal {
2355 return Ok(());
2356 }
2357
2358 let cur_offset: usize = (17 - 1) * envelope_size;
2361
2362 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2364
2365 fidl::encoding::encode_in_envelope_optional::<u8, D>(
2370 self.thread_mle_version
2371 .as_ref()
2372 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2373 encoder,
2374 offset + cur_offset,
2375 depth,
2376 )?;
2377
2378 _prev_end_offset = cur_offset + envelope_size;
2379
2380 Ok(())
2381 }
2382 }
2383
2384 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NeighborInfo {
2385 #[inline(always)]
2386 fn new_empty() -> Self {
2387 Self::default()
2388 }
2389
2390 unsafe fn decode(
2391 &mut self,
2392 decoder: &mut fidl::encoding::Decoder<'_, D>,
2393 offset: usize,
2394 mut depth: fidl::encoding::Depth,
2395 ) -> fidl::Result<()> {
2396 decoder.debug_check_bounds::<Self>(offset);
2397 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2398 None => return Err(fidl::Error::NotNullable),
2399 Some(len) => len,
2400 };
2401 if len == 0 {
2403 return Ok(());
2404 };
2405 depth.increment()?;
2406 let envelope_size = 8;
2407 let bytes_len = len * envelope_size;
2408 let offset = decoder.out_of_line_offset(bytes_len)?;
2409 let mut _next_ordinal_to_read = 0;
2411 let mut next_offset = offset;
2412 let end_offset = offset + bytes_len;
2413 _next_ordinal_to_read += 1;
2414 if next_offset >= end_offset {
2415 return Ok(());
2416 }
2417
2418 while _next_ordinal_to_read < 1 {
2420 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2421 _next_ordinal_to_read += 1;
2422 next_offset += envelope_size;
2423 }
2424
2425 let next_out_of_line = decoder.next_out_of_line();
2426 let handles_before = decoder.remaining_handles();
2427 if let Some((inlined, num_bytes, num_handles)) =
2428 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2429 {
2430 let member_inline_size = <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2431 if inlined != (member_inline_size <= 4) {
2432 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2433 }
2434 let inner_offset;
2435 let mut inner_depth = depth.clone();
2436 if inlined {
2437 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2438 inner_offset = next_offset;
2439 } else {
2440 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2441 inner_depth.increment()?;
2442 }
2443 let val_ref = self.mac_address.get_or_insert_with(|| {
2444 fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D)
2445 });
2446 fidl::decode!(
2447 fidl_fuchsia_lowpan__common::MacAddress,
2448 D,
2449 val_ref,
2450 decoder,
2451 inner_offset,
2452 inner_depth
2453 )?;
2454 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2455 {
2456 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2457 }
2458 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2459 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2460 }
2461 }
2462
2463 next_offset += envelope_size;
2464 _next_ordinal_to_read += 1;
2465 if next_offset >= end_offset {
2466 return Ok(());
2467 }
2468
2469 while _next_ordinal_to_read < 2 {
2471 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2472 _next_ordinal_to_read += 1;
2473 next_offset += envelope_size;
2474 }
2475
2476 let next_out_of_line = decoder.next_out_of_line();
2477 let handles_before = decoder.remaining_handles();
2478 if let Some((inlined, num_bytes, num_handles)) =
2479 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2480 {
2481 let member_inline_size =
2482 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2483 if inlined != (member_inline_size <= 4) {
2484 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2485 }
2486 let inner_offset;
2487 let mut inner_depth = depth.clone();
2488 if inlined {
2489 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2490 inner_offset = next_offset;
2491 } else {
2492 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2493 inner_depth.increment()?;
2494 }
2495 let val_ref = self.short_address.get_or_insert_with(|| fidl::new_empty!(u16, D));
2496 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
2497 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2498 {
2499 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2500 }
2501 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2502 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2503 }
2504 }
2505
2506 next_offset += envelope_size;
2507 _next_ordinal_to_read += 1;
2508 if next_offset >= end_offset {
2509 return Ok(());
2510 }
2511
2512 while _next_ordinal_to_read < 3 {
2514 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2515 _next_ordinal_to_read += 1;
2516 next_offset += envelope_size;
2517 }
2518
2519 let next_out_of_line = decoder.next_out_of_line();
2520 let handles_before = decoder.remaining_handles();
2521 if let Some((inlined, num_bytes, num_handles)) =
2522 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2523 {
2524 let member_inline_size =
2525 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2526 if inlined != (member_inline_size <= 4) {
2527 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2528 }
2529 let inner_offset;
2530 let mut inner_depth = depth.clone();
2531 if inlined {
2532 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2533 inner_offset = next_offset;
2534 } else {
2535 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2536 inner_depth.increment()?;
2537 }
2538 let val_ref = self.age.get_or_insert_with(|| fidl::new_empty!(i64, D));
2539 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2540 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2541 {
2542 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2543 }
2544 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2545 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2546 }
2547 }
2548
2549 next_offset += envelope_size;
2550 _next_ordinal_to_read += 1;
2551 if next_offset >= end_offset {
2552 return Ok(());
2553 }
2554
2555 while _next_ordinal_to_read < 4 {
2557 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2558 _next_ordinal_to_read += 1;
2559 next_offset += envelope_size;
2560 }
2561
2562 let next_out_of_line = decoder.next_out_of_line();
2563 let handles_before = decoder.remaining_handles();
2564 if let Some((inlined, num_bytes, num_handles)) =
2565 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2566 {
2567 let member_inline_size =
2568 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2569 if inlined != (member_inline_size <= 4) {
2570 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2571 }
2572 let inner_offset;
2573 let mut inner_depth = depth.clone();
2574 if inlined {
2575 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2576 inner_offset = next_offset;
2577 } else {
2578 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2579 inner_depth.increment()?;
2580 }
2581 let val_ref = self.is_child.get_or_insert_with(|| fidl::new_empty!(bool, D));
2582 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2583 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2584 {
2585 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2586 }
2587 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2588 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2589 }
2590 }
2591
2592 next_offset += envelope_size;
2593 _next_ordinal_to_read += 1;
2594 if next_offset >= end_offset {
2595 return Ok(());
2596 }
2597
2598 while _next_ordinal_to_read < 5 {
2600 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2601 _next_ordinal_to_read += 1;
2602 next_offset += envelope_size;
2603 }
2604
2605 let next_out_of_line = decoder.next_out_of_line();
2606 let handles_before = decoder.remaining_handles();
2607 if let Some((inlined, num_bytes, num_handles)) =
2608 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2609 {
2610 let member_inline_size =
2611 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2612 if inlined != (member_inline_size <= 4) {
2613 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2614 }
2615 let inner_offset;
2616 let mut inner_depth = depth.clone();
2617 if inlined {
2618 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2619 inner_offset = next_offset;
2620 } else {
2621 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2622 inner_depth.increment()?;
2623 }
2624 let val_ref = self.link_frame_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
2625 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2626 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2627 {
2628 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2629 }
2630 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2631 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2632 }
2633 }
2634
2635 next_offset += envelope_size;
2636 _next_ordinal_to_read += 1;
2637 if next_offset >= end_offset {
2638 return Ok(());
2639 }
2640
2641 while _next_ordinal_to_read < 6 {
2643 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2644 _next_ordinal_to_read += 1;
2645 next_offset += envelope_size;
2646 }
2647
2648 let next_out_of_line = decoder.next_out_of_line();
2649 let handles_before = decoder.remaining_handles();
2650 if let Some((inlined, num_bytes, num_handles)) =
2651 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2652 {
2653 let member_inline_size =
2654 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2655 if inlined != (member_inline_size <= 4) {
2656 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2657 }
2658 let inner_offset;
2659 let mut inner_depth = depth.clone();
2660 if inlined {
2661 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2662 inner_offset = next_offset;
2663 } else {
2664 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2665 inner_depth.increment()?;
2666 }
2667 let val_ref = self.mgmt_frame_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
2668 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2669 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2670 {
2671 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2672 }
2673 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2674 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2675 }
2676 }
2677
2678 next_offset += envelope_size;
2679 _next_ordinal_to_read += 1;
2680 if next_offset >= end_offset {
2681 return Ok(());
2682 }
2683
2684 while _next_ordinal_to_read < 7 {
2686 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2687 _next_ordinal_to_read += 1;
2688 next_offset += envelope_size;
2689 }
2690
2691 let next_out_of_line = decoder.next_out_of_line();
2692 let handles_before = decoder.remaining_handles();
2693 if let Some((inlined, num_bytes, num_handles)) =
2694 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2695 {
2696 let member_inline_size =
2697 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2698 if inlined != (member_inline_size <= 4) {
2699 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2700 }
2701 let inner_offset;
2702 let mut inner_depth = depth.clone();
2703 if inlined {
2704 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2705 inner_offset = next_offset;
2706 } else {
2707 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2708 inner_depth.increment()?;
2709 }
2710 let val_ref = self.last_rssi_in.get_or_insert_with(|| fidl::new_empty!(i32, D));
2711 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
2712 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2713 {
2714 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2715 }
2716 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2717 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2718 }
2719 }
2720
2721 next_offset += envelope_size;
2722 _next_ordinal_to_read += 1;
2723 if next_offset >= end_offset {
2724 return Ok(());
2725 }
2726
2727 while _next_ordinal_to_read < 8 {
2729 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2730 _next_ordinal_to_read += 1;
2731 next_offset += envelope_size;
2732 }
2733
2734 let next_out_of_line = decoder.next_out_of_line();
2735 let handles_before = decoder.remaining_handles();
2736 if let Some((inlined, num_bytes, num_handles)) =
2737 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2738 {
2739 let member_inline_size =
2740 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2741 if inlined != (member_inline_size <= 4) {
2742 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2743 }
2744 let inner_offset;
2745 let mut inner_depth = depth.clone();
2746 if inlined {
2747 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2748 inner_offset = next_offset;
2749 } else {
2750 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2751 inner_depth.increment()?;
2752 }
2753 let val_ref = self.avg_rssi_in.get_or_insert_with(|| fidl::new_empty!(i8, D));
2754 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
2755 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2756 {
2757 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2758 }
2759 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2760 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2761 }
2762 }
2763
2764 next_offset += envelope_size;
2765 _next_ordinal_to_read += 1;
2766 if next_offset >= end_offset {
2767 return Ok(());
2768 }
2769
2770 while _next_ordinal_to_read < 9 {
2772 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2773 _next_ordinal_to_read += 1;
2774 next_offset += envelope_size;
2775 }
2776
2777 let next_out_of_line = decoder.next_out_of_line();
2778 let handles_before = decoder.remaining_handles();
2779 if let Some((inlined, num_bytes, num_handles)) =
2780 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2781 {
2782 let member_inline_size =
2783 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2784 if inlined != (member_inline_size <= 4) {
2785 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2786 }
2787 let inner_offset;
2788 let mut inner_depth = depth.clone();
2789 if inlined {
2790 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2791 inner_offset = next_offset;
2792 } else {
2793 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2794 inner_depth.increment()?;
2795 }
2796 let val_ref = self.lqi_in.get_or_insert_with(|| fidl::new_empty!(u8, D));
2797 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
2798 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2799 {
2800 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2801 }
2802 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2803 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2804 }
2805 }
2806
2807 next_offset += envelope_size;
2808 _next_ordinal_to_read += 1;
2809 if next_offset >= end_offset {
2810 return Ok(());
2811 }
2812
2813 while _next_ordinal_to_read < 10 {
2815 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2816 _next_ordinal_to_read += 1;
2817 next_offset += envelope_size;
2818 }
2819
2820 let next_out_of_line = decoder.next_out_of_line();
2821 let handles_before = decoder.remaining_handles();
2822 if let Some((inlined, num_bytes, num_handles)) =
2823 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2824 {
2825 let member_inline_size =
2826 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2827 if inlined != (member_inline_size <= 4) {
2828 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2829 }
2830 let inner_offset;
2831 let mut inner_depth = depth.clone();
2832 if inlined {
2833 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2834 inner_offset = next_offset;
2835 } else {
2836 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2837 inner_depth.increment()?;
2838 }
2839 let val_ref = self.thread_mode.get_or_insert_with(|| fidl::new_empty!(u8, D));
2840 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
2841 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2842 {
2843 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2844 }
2845 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2846 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2847 }
2848 }
2849
2850 next_offset += envelope_size;
2851 _next_ordinal_to_read += 1;
2852 if next_offset >= end_offset {
2853 return Ok(());
2854 }
2855
2856 while _next_ordinal_to_read < 11 {
2858 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2859 _next_ordinal_to_read += 1;
2860 next_offset += envelope_size;
2861 }
2862
2863 let next_out_of_line = decoder.next_out_of_line();
2864 let handles_before = decoder.remaining_handles();
2865 if let Some((inlined, num_bytes, num_handles)) =
2866 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2867 {
2868 let member_inline_size =
2869 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2870 if inlined != (member_inline_size <= 4) {
2871 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2872 }
2873 let inner_offset;
2874 let mut inner_depth = depth.clone();
2875 if inlined {
2876 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2877 inner_offset = next_offset;
2878 } else {
2879 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2880 inner_depth.increment()?;
2881 }
2882 let val_ref = self.frame_error_rate.get_or_insert_with(|| fidl::new_empty!(u16, D));
2883 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
2884 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2885 {
2886 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2887 }
2888 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2889 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2890 }
2891 }
2892
2893 next_offset += envelope_size;
2894 _next_ordinal_to_read += 1;
2895 if next_offset >= end_offset {
2896 return Ok(());
2897 }
2898
2899 while _next_ordinal_to_read < 12 {
2901 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2902 _next_ordinal_to_read += 1;
2903 next_offset += envelope_size;
2904 }
2905
2906 let next_out_of_line = decoder.next_out_of_line();
2907 let handles_before = decoder.remaining_handles();
2908 if let Some((inlined, num_bytes, num_handles)) =
2909 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2910 {
2911 let member_inline_size =
2912 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2913 if inlined != (member_inline_size <= 4) {
2914 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2915 }
2916 let inner_offset;
2917 let mut inner_depth = depth.clone();
2918 if inlined {
2919 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2920 inner_offset = next_offset;
2921 } else {
2922 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2923 inner_depth.increment()?;
2924 }
2925 let val_ref = self.ipv6_error_rate.get_or_insert_with(|| fidl::new_empty!(u16, D));
2926 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
2927 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2928 {
2929 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2930 }
2931 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2932 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2933 }
2934 }
2935
2936 next_offset += envelope_size;
2937 _next_ordinal_to_read += 1;
2938 if next_offset >= end_offset {
2939 return Ok(());
2940 }
2941
2942 while _next_ordinal_to_read < 13 {
2944 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2945 _next_ordinal_to_read += 1;
2946 next_offset += envelope_size;
2947 }
2948
2949 let next_out_of_line = decoder.next_out_of_line();
2950 let handles_before = decoder.remaining_handles();
2951 if let Some((inlined, num_bytes, num_handles)) =
2952 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2953 {
2954 let member_inline_size =
2955 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2956 if inlined != (member_inline_size <= 4) {
2957 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2958 }
2959 let inner_offset;
2960 let mut inner_depth = depth.clone();
2961 if inlined {
2962 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2963 inner_offset = next_offset;
2964 } else {
2965 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2966 inner_depth.increment()?;
2967 }
2968 let val_ref =
2969 self.child_is_csl_synced.get_or_insert_with(|| fidl::new_empty!(bool, D));
2970 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2971 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2972 {
2973 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2974 }
2975 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2976 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2977 }
2978 }
2979
2980 next_offset += envelope_size;
2981 _next_ordinal_to_read += 1;
2982 if next_offset >= end_offset {
2983 return Ok(());
2984 }
2985
2986 while _next_ordinal_to_read < 14 {
2988 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2989 _next_ordinal_to_read += 1;
2990 next_offset += envelope_size;
2991 }
2992
2993 let next_out_of_line = decoder.next_out_of_line();
2994 let handles_before = decoder.remaining_handles();
2995 if let Some((inlined, num_bytes, num_handles)) =
2996 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2997 {
2998 let member_inline_size =
2999 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3000 if inlined != (member_inline_size <= 4) {
3001 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3002 }
3003 let inner_offset;
3004 let mut inner_depth = depth.clone();
3005 if inlined {
3006 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3007 inner_offset = next_offset;
3008 } else {
3009 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3010 inner_depth.increment()?;
3011 }
3012 let val_ref =
3013 self.child_is_state_restoring.get_or_insert_with(|| fidl::new_empty!(bool, D));
3014 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3015 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3016 {
3017 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3018 }
3019 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3020 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3021 }
3022 }
3023
3024 next_offset += envelope_size;
3025 _next_ordinal_to_read += 1;
3026 if next_offset >= end_offset {
3027 return Ok(());
3028 }
3029
3030 while _next_ordinal_to_read < 15 {
3032 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3033 _next_ordinal_to_read += 1;
3034 next_offset += envelope_size;
3035 }
3036
3037 let next_out_of_line = decoder.next_out_of_line();
3038 let handles_before = decoder.remaining_handles();
3039 if let Some((inlined, num_bytes, num_handles)) =
3040 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3041 {
3042 let member_inline_size =
3043 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3044 if inlined != (member_inline_size <= 4) {
3045 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3046 }
3047 let inner_offset;
3048 let mut inner_depth = depth.clone();
3049 if inlined {
3050 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3051 inner_offset = next_offset;
3052 } else {
3053 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3054 inner_depth.increment()?;
3055 }
3056 let val_ref = self.net_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
3057 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3058 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3059 {
3060 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3061 }
3062 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3063 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3064 }
3065 }
3066
3067 next_offset += envelope_size;
3068 _next_ordinal_to_read += 1;
3069 if next_offset >= end_offset {
3070 return Ok(());
3071 }
3072
3073 while _next_ordinal_to_read < 16 {
3075 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3076 _next_ordinal_to_read += 1;
3077 next_offset += envelope_size;
3078 }
3079
3080 let next_out_of_line = decoder.next_out_of_line();
3081 let handles_before = decoder.remaining_handles();
3082 if let Some((inlined, num_bytes, num_handles)) =
3083 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3084 {
3085 let member_inline_size =
3086 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3087 if inlined != (member_inline_size <= 4) {
3088 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3089 }
3090 let inner_offset;
3091 let mut inner_depth = depth.clone();
3092 if inlined {
3093 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3094 inner_offset = next_offset;
3095 } else {
3096 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3097 inner_depth.increment()?;
3098 }
3099 let val_ref = self.queued_messages.get_or_insert_with(|| fidl::new_empty!(u16, D));
3100 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3101 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3102 {
3103 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3104 }
3105 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3106 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3107 }
3108 }
3109
3110 next_offset += envelope_size;
3111 _next_ordinal_to_read += 1;
3112 if next_offset >= end_offset {
3113 return Ok(());
3114 }
3115
3116 while _next_ordinal_to_read < 17 {
3118 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3119 _next_ordinal_to_read += 1;
3120 next_offset += envelope_size;
3121 }
3122
3123 let next_out_of_line = decoder.next_out_of_line();
3124 let handles_before = decoder.remaining_handles();
3125 if let Some((inlined, num_bytes, num_handles)) =
3126 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3127 {
3128 let member_inline_size =
3129 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3130 if inlined != (member_inline_size <= 4) {
3131 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3132 }
3133 let inner_offset;
3134 let mut inner_depth = depth.clone();
3135 if inlined {
3136 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3137 inner_offset = next_offset;
3138 } else {
3139 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3140 inner_depth.increment()?;
3141 }
3142 let val_ref =
3143 self.thread_mle_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
3144 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3145 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3146 {
3147 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3148 }
3149 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3150 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3151 }
3152 }
3153
3154 next_offset += envelope_size;
3155
3156 while next_offset < end_offset {
3158 _next_ordinal_to_read += 1;
3159 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3160 next_offset += envelope_size;
3161 }
3162
3163 Ok(())
3164 }
3165 }
3166}