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