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 FIFO_DEPTH: u16 = 128;
13
14pub const MAX_MTU: u32 = 16384;
16
17pub const MAX_MULTICAST_FILTERS: u32 = 64;
19
20pub const MAX_PENDING_OPERATIONS: u32 = 32;
23
24bitflags! {
25 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
28 pub struct Signals: u32 {
29 const WRITABLE = 16777216;
32 const READABLE = 33554432;
35 }
36}
37
38impl Signals {}
39
40#[derive(Clone, Debug, PartialEq)]
41pub struct DevicePairAddPortRequest {
42 pub config: DevicePairPortConfig,
43}
44
45impl fidl::Persistable for DevicePairAddPortRequest {}
46
47#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
48#[repr(C)]
49pub struct DevicePairRemovePortRequest {
50 pub id: u8,
51}
52
53impl fidl::Persistable for DevicePairRemovePortRequest {}
54
55#[derive(Clone, Debug, PartialEq)]
56pub struct DeviceWriteFrameRequest {
57 pub frame: Frame,
58}
59
60impl fidl::Persistable for DeviceWriteFrameRequest {}
61
62#[derive(Clone, Debug, PartialEq)]
63pub struct DeviceReadFrameResponse {
64 pub frame: Frame,
65}
66
67impl fidl::Persistable for DeviceReadFrameResponse {}
68
69#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
70pub struct FrameMetadata {
71 pub info_type: fidl_fuchsia_hardware_network__common::InfoType,
76 pub info: Vec<u8>,
80 pub flags: u32,
85}
86
87impl fidl::Persistable for FrameMetadata {}
88
89#[derive(Clone, Debug, PartialEq)]
90pub struct PortGetStateResponse {
91 pub state: InternalState,
92}
93
94impl fidl::Persistable for PortGetStateResponse {}
95
96#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
97pub struct PortSetOnlineRequest {
98 pub online: bool,
99}
100
101impl fidl::Persistable for PortSetOnlineRequest {}
102
103#[derive(Clone, Debug, PartialEq)]
104pub struct PortWatchStateResponse {
105 pub state: InternalState,
106}
107
108impl fidl::Persistable for PortWatchStateResponse {}
109
110#[derive(Clone, Debug, Default, PartialEq)]
112pub struct BaseDeviceConfig {
113 pub report_metadata: Option<bool>,
117 pub min_tx_buffer_length: Option<u32>,
121 pub min_rx_buffer_length: Option<u32>,
125 #[doc(hidden)]
126 pub __source_breaking: fidl::marker::SourceBreaking,
127}
128
129impl fidl::Persistable for BaseDeviceConfig {}
130
131#[derive(Clone, Debug, Default, PartialEq)]
133pub struct BasePortConfig {
134 pub id: Option<u8>,
138 pub mtu: Option<u32>,
144 pub rx_types: Option<Vec<fidl_fuchsia_hardware_network__common::FrameType>>,
150 pub tx_types: Option<Vec<fidl_fuchsia_hardware_network__common::FrameTypeSupport>>,
156 pub port_class: Option<fidl_fuchsia_hardware_network__common::PortClass>,
160 #[doc(hidden)]
161 pub __source_breaking: fidl::marker::SourceBreaking,
162}
163
164impl fidl::Persistable for BasePortConfig {}
165
166#[derive(Clone, Debug, Default, PartialEq)]
167pub struct DeviceConfig {
168 pub base: Option<BaseDeviceConfig>,
172 pub blocking: Option<bool>,
178 #[doc(hidden)]
179 pub __source_breaking: fidl::marker::SourceBreaking,
180}
181
182impl fidl::Persistable for DeviceConfig {}
183
184#[derive(Clone, Debug, Default, PartialEq)]
185pub struct DevicePairConfig {
186 pub base: Option<BaseDeviceConfig>,
190 pub fallible_transmit_left: Option<bool>,
197 pub fallible_transmit_right: Option<bool>,
202 #[doc(hidden)]
203 pub __source_breaking: fidl::marker::SourceBreaking,
204}
205
206impl fidl::Persistable for DevicePairConfig {}
207
208#[derive(Clone, Debug, Default, PartialEq)]
209pub struct DevicePairPortConfig {
210 pub base: Option<BasePortConfig>,
214 pub mac_left: Option<fidl_fuchsia_net__common::MacAddress>,
220 pub mac_right: Option<fidl_fuchsia_net__common::MacAddress>,
226 #[doc(hidden)]
227 pub __source_breaking: fidl::marker::SourceBreaking,
228}
229
230impl fidl::Persistable for DevicePairPortConfig {}
231
232#[derive(Clone, Debug, Default, PartialEq)]
233pub struct DevicePortConfig {
234 pub base: Option<BasePortConfig>,
238 pub online: Option<bool>,
242 pub mac: Option<fidl_fuchsia_net__common::MacAddress>,
248 #[doc(hidden)]
249 pub __source_breaking: fidl::marker::SourceBreaking,
250}
251
252impl fidl::Persistable for DevicePortConfig {}
253
254#[derive(Clone, Debug, Default, PartialEq)]
260pub struct Frame {
261 pub frame_type: Option<fidl_fuchsia_hardware_network__common::FrameType>,
265 pub data: Option<Vec<u8>>,
271 pub meta: Option<FrameMetadata>,
278 pub port: Option<u8>,
282 #[doc(hidden)]
283 pub __source_breaking: fidl::marker::SourceBreaking,
284}
285
286impl fidl::Persistable for Frame {}
287
288#[derive(Clone, Debug, Default, PartialEq)]
290pub struct InternalState {
291 pub mac: Option<MacState>,
301 pub has_session: Option<bool>,
305 #[doc(hidden)]
306 pub __source_breaking: fidl::marker::SourceBreaking,
307}
308
309impl fidl::Persistable for InternalState {}
310
311#[derive(Clone, Debug, Default, PartialEq)]
312pub struct MacState {
313 pub mode: Option<fidl_fuchsia_hardware_network__common::MacFilterMode>,
317 pub multicast_filters: Option<Vec<fidl_fuchsia_net__common::MacAddress>>,
321 #[doc(hidden)]
322 pub __source_breaking: fidl::marker::SourceBreaking,
323}
324
325impl fidl::Persistable for MacState {}
326
327mod internal {
328 use super::*;
329 unsafe impl fidl::encoding::TypeMarker for Signals {
330 type Owned = Self;
331
332 #[inline(always)]
333 fn inline_align(_context: fidl::encoding::Context) -> usize {
334 4
335 }
336
337 #[inline(always)]
338 fn inline_size(_context: fidl::encoding::Context) -> usize {
339 4
340 }
341 }
342
343 impl fidl::encoding::ValueTypeMarker for Signals {
344 type Borrowed<'a> = Self;
345 #[inline(always)]
346 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
347 *value
348 }
349 }
350
351 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Signals {
352 #[inline]
353 unsafe fn encode(
354 self,
355 encoder: &mut fidl::encoding::Encoder<'_, D>,
356 offset: usize,
357 _depth: fidl::encoding::Depth,
358 ) -> fidl::Result<()> {
359 encoder.debug_check_bounds::<Self>(offset);
360 if self.bits() & Self::all().bits() != self.bits() {
361 return Err(fidl::Error::InvalidBitsValue);
362 }
363 encoder.write_num(self.bits(), offset);
364 Ok(())
365 }
366 }
367
368 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Signals {
369 #[inline(always)]
370 fn new_empty() -> Self {
371 Self::empty()
372 }
373
374 #[inline]
375 unsafe fn decode(
376 &mut self,
377 decoder: &mut fidl::encoding::Decoder<'_, D>,
378 offset: usize,
379 _depth: fidl::encoding::Depth,
380 ) -> fidl::Result<()> {
381 decoder.debug_check_bounds::<Self>(offset);
382 let prim = decoder.read_num::<u32>(offset);
383 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
384 Ok(())
385 }
386 }
387
388 impl fidl::encoding::ValueTypeMarker for DevicePairAddPortRequest {
389 type Borrowed<'a> = &'a Self;
390 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
391 value
392 }
393 }
394
395 unsafe impl fidl::encoding::TypeMarker for DevicePairAddPortRequest {
396 type Owned = Self;
397
398 #[inline(always)]
399 fn inline_align(_context: fidl::encoding::Context) -> usize {
400 8
401 }
402
403 #[inline(always)]
404 fn inline_size(_context: fidl::encoding::Context) -> usize {
405 16
406 }
407 }
408
409 unsafe impl<D: fidl::encoding::ResourceDialect>
410 fidl::encoding::Encode<DevicePairAddPortRequest, D> for &DevicePairAddPortRequest
411 {
412 #[inline]
413 unsafe fn encode(
414 self,
415 encoder: &mut fidl::encoding::Encoder<'_, D>,
416 offset: usize,
417 _depth: fidl::encoding::Depth,
418 ) -> fidl::Result<()> {
419 encoder.debug_check_bounds::<DevicePairAddPortRequest>(offset);
420 fidl::encoding::Encode::<DevicePairAddPortRequest, D>::encode(
422 (<DevicePairPortConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.config),),
423 encoder,
424 offset,
425 _depth,
426 )
427 }
428 }
429 unsafe impl<
430 D: fidl::encoding::ResourceDialect,
431 T0: fidl::encoding::Encode<DevicePairPortConfig, D>,
432 > fidl::encoding::Encode<DevicePairAddPortRequest, D> for (T0,)
433 {
434 #[inline]
435 unsafe fn encode(
436 self,
437 encoder: &mut fidl::encoding::Encoder<'_, D>,
438 offset: usize,
439 depth: fidl::encoding::Depth,
440 ) -> fidl::Result<()> {
441 encoder.debug_check_bounds::<DevicePairAddPortRequest>(offset);
442 self.0.encode(encoder, offset + 0, depth)?;
446 Ok(())
447 }
448 }
449
450 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
451 for DevicePairAddPortRequest
452 {
453 #[inline(always)]
454 fn new_empty() -> Self {
455 Self { config: fidl::new_empty!(DevicePairPortConfig, D) }
456 }
457
458 #[inline]
459 unsafe fn decode(
460 &mut self,
461 decoder: &mut fidl::encoding::Decoder<'_, D>,
462 offset: usize,
463 _depth: fidl::encoding::Depth,
464 ) -> fidl::Result<()> {
465 decoder.debug_check_bounds::<Self>(offset);
466 fidl::decode!(DevicePairPortConfig, D, &mut self.config, decoder, offset + 0, _depth)?;
468 Ok(())
469 }
470 }
471
472 impl fidl::encoding::ValueTypeMarker for DevicePairRemovePortRequest {
473 type Borrowed<'a> = &'a Self;
474 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
475 value
476 }
477 }
478
479 unsafe impl fidl::encoding::TypeMarker for DevicePairRemovePortRequest {
480 type Owned = Self;
481
482 #[inline(always)]
483 fn inline_align(_context: fidl::encoding::Context) -> usize {
484 1
485 }
486
487 #[inline(always)]
488 fn inline_size(_context: fidl::encoding::Context) -> usize {
489 1
490 }
491 #[inline(always)]
492 fn encode_is_copy() -> bool {
493 true
494 }
495
496 #[inline(always)]
497 fn decode_is_copy() -> bool {
498 true
499 }
500 }
501
502 unsafe impl<D: fidl::encoding::ResourceDialect>
503 fidl::encoding::Encode<DevicePairRemovePortRequest, D> for &DevicePairRemovePortRequest
504 {
505 #[inline]
506 unsafe fn encode(
507 self,
508 encoder: &mut fidl::encoding::Encoder<'_, D>,
509 offset: usize,
510 _depth: fidl::encoding::Depth,
511 ) -> fidl::Result<()> {
512 encoder.debug_check_bounds::<DevicePairRemovePortRequest>(offset);
513 unsafe {
514 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
516 (buf_ptr as *mut DevicePairRemovePortRequest)
517 .write_unaligned((self as *const DevicePairRemovePortRequest).read());
518 }
521 Ok(())
522 }
523 }
524 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
525 fidl::encoding::Encode<DevicePairRemovePortRequest, D> for (T0,)
526 {
527 #[inline]
528 unsafe fn encode(
529 self,
530 encoder: &mut fidl::encoding::Encoder<'_, D>,
531 offset: usize,
532 depth: fidl::encoding::Depth,
533 ) -> fidl::Result<()> {
534 encoder.debug_check_bounds::<DevicePairRemovePortRequest>(offset);
535 self.0.encode(encoder, offset + 0, depth)?;
539 Ok(())
540 }
541 }
542
543 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
544 for DevicePairRemovePortRequest
545 {
546 #[inline(always)]
547 fn new_empty() -> Self {
548 Self { id: fidl::new_empty!(u8, D) }
549 }
550
551 #[inline]
552 unsafe fn decode(
553 &mut self,
554 decoder: &mut fidl::encoding::Decoder<'_, D>,
555 offset: usize,
556 _depth: fidl::encoding::Depth,
557 ) -> fidl::Result<()> {
558 decoder.debug_check_bounds::<Self>(offset);
559 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
560 unsafe {
563 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
564 }
565 Ok(())
566 }
567 }
568
569 impl fidl::encoding::ValueTypeMarker for DeviceWriteFrameRequest {
570 type Borrowed<'a> = &'a Self;
571 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
572 value
573 }
574 }
575
576 unsafe impl fidl::encoding::TypeMarker for DeviceWriteFrameRequest {
577 type Owned = Self;
578
579 #[inline(always)]
580 fn inline_align(_context: fidl::encoding::Context) -> usize {
581 8
582 }
583
584 #[inline(always)]
585 fn inline_size(_context: fidl::encoding::Context) -> usize {
586 16
587 }
588 }
589
590 unsafe impl<D: fidl::encoding::ResourceDialect>
591 fidl::encoding::Encode<DeviceWriteFrameRequest, D> for &DeviceWriteFrameRequest
592 {
593 #[inline]
594 unsafe fn encode(
595 self,
596 encoder: &mut fidl::encoding::Encoder<'_, D>,
597 offset: usize,
598 _depth: fidl::encoding::Depth,
599 ) -> fidl::Result<()> {
600 encoder.debug_check_bounds::<DeviceWriteFrameRequest>(offset);
601 fidl::encoding::Encode::<DeviceWriteFrameRequest, D>::encode(
603 (<Frame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
604 encoder,
605 offset,
606 _depth,
607 )
608 }
609 }
610 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Frame, D>>
611 fidl::encoding::Encode<DeviceWriteFrameRequest, D> for (T0,)
612 {
613 #[inline]
614 unsafe fn encode(
615 self,
616 encoder: &mut fidl::encoding::Encoder<'_, D>,
617 offset: usize,
618 depth: fidl::encoding::Depth,
619 ) -> fidl::Result<()> {
620 encoder.debug_check_bounds::<DeviceWriteFrameRequest>(offset);
621 self.0.encode(encoder, offset + 0, depth)?;
625 Ok(())
626 }
627 }
628
629 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
630 for DeviceWriteFrameRequest
631 {
632 #[inline(always)]
633 fn new_empty() -> Self {
634 Self { frame: fidl::new_empty!(Frame, D) }
635 }
636
637 #[inline]
638 unsafe fn decode(
639 &mut self,
640 decoder: &mut fidl::encoding::Decoder<'_, D>,
641 offset: usize,
642 _depth: fidl::encoding::Depth,
643 ) -> fidl::Result<()> {
644 decoder.debug_check_bounds::<Self>(offset);
645 fidl::decode!(Frame, D, &mut self.frame, decoder, offset + 0, _depth)?;
647 Ok(())
648 }
649 }
650
651 impl fidl::encoding::ValueTypeMarker for DeviceReadFrameResponse {
652 type Borrowed<'a> = &'a Self;
653 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
654 value
655 }
656 }
657
658 unsafe impl fidl::encoding::TypeMarker for DeviceReadFrameResponse {
659 type Owned = Self;
660
661 #[inline(always)]
662 fn inline_align(_context: fidl::encoding::Context) -> usize {
663 8
664 }
665
666 #[inline(always)]
667 fn inline_size(_context: fidl::encoding::Context) -> usize {
668 16
669 }
670 }
671
672 unsafe impl<D: fidl::encoding::ResourceDialect>
673 fidl::encoding::Encode<DeviceReadFrameResponse, D> for &DeviceReadFrameResponse
674 {
675 #[inline]
676 unsafe fn encode(
677 self,
678 encoder: &mut fidl::encoding::Encoder<'_, D>,
679 offset: usize,
680 _depth: fidl::encoding::Depth,
681 ) -> fidl::Result<()> {
682 encoder.debug_check_bounds::<DeviceReadFrameResponse>(offset);
683 fidl::encoding::Encode::<DeviceReadFrameResponse, D>::encode(
685 (<Frame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
686 encoder,
687 offset,
688 _depth,
689 )
690 }
691 }
692 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Frame, D>>
693 fidl::encoding::Encode<DeviceReadFrameResponse, D> for (T0,)
694 {
695 #[inline]
696 unsafe fn encode(
697 self,
698 encoder: &mut fidl::encoding::Encoder<'_, D>,
699 offset: usize,
700 depth: fidl::encoding::Depth,
701 ) -> fidl::Result<()> {
702 encoder.debug_check_bounds::<DeviceReadFrameResponse>(offset);
703 self.0.encode(encoder, offset + 0, depth)?;
707 Ok(())
708 }
709 }
710
711 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
712 for DeviceReadFrameResponse
713 {
714 #[inline(always)]
715 fn new_empty() -> Self {
716 Self { frame: fidl::new_empty!(Frame, D) }
717 }
718
719 #[inline]
720 unsafe fn decode(
721 &mut self,
722 decoder: &mut fidl::encoding::Decoder<'_, D>,
723 offset: usize,
724 _depth: fidl::encoding::Depth,
725 ) -> fidl::Result<()> {
726 decoder.debug_check_bounds::<Self>(offset);
727 fidl::decode!(Frame, D, &mut self.frame, decoder, offset + 0, _depth)?;
729 Ok(())
730 }
731 }
732
733 impl fidl::encoding::ValueTypeMarker for FrameMetadata {
734 type Borrowed<'a> = &'a Self;
735 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
736 value
737 }
738 }
739
740 unsafe impl fidl::encoding::TypeMarker for FrameMetadata {
741 type Owned = Self;
742
743 #[inline(always)]
744 fn inline_align(_context: fidl::encoding::Context) -> usize {
745 8
746 }
747
748 #[inline(always)]
749 fn inline_size(_context: fidl::encoding::Context) -> usize {
750 32
751 }
752 }
753
754 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FrameMetadata, D>
755 for &FrameMetadata
756 {
757 #[inline]
758 unsafe fn encode(
759 self,
760 encoder: &mut fidl::encoding::Encoder<'_, D>,
761 offset: usize,
762 _depth: fidl::encoding::Depth,
763 ) -> fidl::Result<()> {
764 encoder.debug_check_bounds::<FrameMetadata>(offset);
765 fidl::encoding::Encode::<FrameMetadata, D>::encode(
767 (
768 <fidl_fuchsia_hardware_network__common::InfoType as fidl::encoding::ValueTypeMarker>::borrow(&self.info_type),
769 <fidl::encoding::Vector<u8, 4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.info),
770 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
771 ),
772 encoder, offset, _depth
773 )
774 }
775 }
776 unsafe impl<
777 D: fidl::encoding::ResourceDialect,
778 T0: fidl::encoding::Encode<fidl_fuchsia_hardware_network__common::InfoType, D>,
779 T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 4096>, D>,
780 T2: fidl::encoding::Encode<u32, D>,
781 > fidl::encoding::Encode<FrameMetadata, D> for (T0, T1, T2)
782 {
783 #[inline]
784 unsafe fn encode(
785 self,
786 encoder: &mut fidl::encoding::Encoder<'_, D>,
787 offset: usize,
788 depth: fidl::encoding::Depth,
789 ) -> fidl::Result<()> {
790 encoder.debug_check_bounds::<FrameMetadata>(offset);
791 unsafe {
794 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
795 (ptr as *mut u64).write_unaligned(0);
796 }
797 unsafe {
798 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
799 (ptr as *mut u64).write_unaligned(0);
800 }
801 self.0.encode(encoder, offset + 0, depth)?;
803 self.1.encode(encoder, offset + 8, depth)?;
804 self.2.encode(encoder, offset + 24, depth)?;
805 Ok(())
806 }
807 }
808
809 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameMetadata {
810 #[inline(always)]
811 fn new_empty() -> Self {
812 Self {
813 info_type: fidl::new_empty!(fidl_fuchsia_hardware_network__common::InfoType, D),
814 info: fidl::new_empty!(fidl::encoding::Vector<u8, 4096>, D),
815 flags: fidl::new_empty!(u32, D),
816 }
817 }
818
819 #[inline]
820 unsafe fn decode(
821 &mut self,
822 decoder: &mut fidl::encoding::Decoder<'_, D>,
823 offset: usize,
824 _depth: fidl::encoding::Depth,
825 ) -> fidl::Result<()> {
826 decoder.debug_check_bounds::<Self>(offset);
827 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
829 let padval = unsafe { (ptr as *const u64).read_unaligned() };
830 let mask = 0xffffffff00000000u64;
831 let maskedval = padval & mask;
832 if maskedval != 0 {
833 return Err(fidl::Error::NonZeroPadding {
834 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
835 });
836 }
837 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
838 let padval = unsafe { (ptr as *const u64).read_unaligned() };
839 let mask = 0xffffffff00000000u64;
840 let maskedval = padval & mask;
841 if maskedval != 0 {
842 return Err(fidl::Error::NonZeroPadding {
843 padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
844 });
845 }
846 fidl::decode!(
847 fidl_fuchsia_hardware_network__common::InfoType,
848 D,
849 &mut self.info_type,
850 decoder,
851 offset + 0,
852 _depth
853 )?;
854 fidl::decode!(fidl::encoding::Vector<u8, 4096>, D, &mut self.info, decoder, offset + 8, _depth)?;
855 fidl::decode!(u32, D, &mut self.flags, decoder, offset + 24, _depth)?;
856 Ok(())
857 }
858 }
859
860 impl fidl::encoding::ValueTypeMarker for PortGetStateResponse {
861 type Borrowed<'a> = &'a Self;
862 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
863 value
864 }
865 }
866
867 unsafe impl fidl::encoding::TypeMarker for PortGetStateResponse {
868 type Owned = Self;
869
870 #[inline(always)]
871 fn inline_align(_context: fidl::encoding::Context) -> usize {
872 8
873 }
874
875 #[inline(always)]
876 fn inline_size(_context: fidl::encoding::Context) -> usize {
877 16
878 }
879 }
880
881 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PortGetStateResponse, D>
882 for &PortGetStateResponse
883 {
884 #[inline]
885 unsafe fn encode(
886 self,
887 encoder: &mut fidl::encoding::Encoder<'_, D>,
888 offset: usize,
889 _depth: fidl::encoding::Depth,
890 ) -> fidl::Result<()> {
891 encoder.debug_check_bounds::<PortGetStateResponse>(offset);
892 fidl::encoding::Encode::<PortGetStateResponse, D>::encode(
894 (<InternalState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
895 encoder,
896 offset,
897 _depth,
898 )
899 }
900 }
901 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<InternalState, D>>
902 fidl::encoding::Encode<PortGetStateResponse, D> for (T0,)
903 {
904 #[inline]
905 unsafe fn encode(
906 self,
907 encoder: &mut fidl::encoding::Encoder<'_, D>,
908 offset: usize,
909 depth: fidl::encoding::Depth,
910 ) -> fidl::Result<()> {
911 encoder.debug_check_bounds::<PortGetStateResponse>(offset);
912 self.0.encode(encoder, offset + 0, depth)?;
916 Ok(())
917 }
918 }
919
920 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PortGetStateResponse {
921 #[inline(always)]
922 fn new_empty() -> Self {
923 Self { state: fidl::new_empty!(InternalState, D) }
924 }
925
926 #[inline]
927 unsafe fn decode(
928 &mut self,
929 decoder: &mut fidl::encoding::Decoder<'_, D>,
930 offset: usize,
931 _depth: fidl::encoding::Depth,
932 ) -> fidl::Result<()> {
933 decoder.debug_check_bounds::<Self>(offset);
934 fidl::decode!(InternalState, D, &mut self.state, decoder, offset + 0, _depth)?;
936 Ok(())
937 }
938 }
939
940 impl fidl::encoding::ValueTypeMarker for PortSetOnlineRequest {
941 type Borrowed<'a> = &'a Self;
942 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
943 value
944 }
945 }
946
947 unsafe impl fidl::encoding::TypeMarker for PortSetOnlineRequest {
948 type Owned = Self;
949
950 #[inline(always)]
951 fn inline_align(_context: fidl::encoding::Context) -> usize {
952 1
953 }
954
955 #[inline(always)]
956 fn inline_size(_context: fidl::encoding::Context) -> usize {
957 1
958 }
959 }
960
961 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PortSetOnlineRequest, D>
962 for &PortSetOnlineRequest
963 {
964 #[inline]
965 unsafe fn encode(
966 self,
967 encoder: &mut fidl::encoding::Encoder<'_, D>,
968 offset: usize,
969 _depth: fidl::encoding::Depth,
970 ) -> fidl::Result<()> {
971 encoder.debug_check_bounds::<PortSetOnlineRequest>(offset);
972 fidl::encoding::Encode::<PortSetOnlineRequest, D>::encode(
974 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.online),),
975 encoder,
976 offset,
977 _depth,
978 )
979 }
980 }
981 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
982 fidl::encoding::Encode<PortSetOnlineRequest, D> for (T0,)
983 {
984 #[inline]
985 unsafe fn encode(
986 self,
987 encoder: &mut fidl::encoding::Encoder<'_, D>,
988 offset: usize,
989 depth: fidl::encoding::Depth,
990 ) -> fidl::Result<()> {
991 encoder.debug_check_bounds::<PortSetOnlineRequest>(offset);
992 self.0.encode(encoder, offset + 0, depth)?;
996 Ok(())
997 }
998 }
999
1000 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PortSetOnlineRequest {
1001 #[inline(always)]
1002 fn new_empty() -> Self {
1003 Self { online: fidl::new_empty!(bool, D) }
1004 }
1005
1006 #[inline]
1007 unsafe fn decode(
1008 &mut self,
1009 decoder: &mut fidl::encoding::Decoder<'_, D>,
1010 offset: usize,
1011 _depth: fidl::encoding::Depth,
1012 ) -> fidl::Result<()> {
1013 decoder.debug_check_bounds::<Self>(offset);
1014 fidl::decode!(bool, D, &mut self.online, decoder, offset + 0, _depth)?;
1016 Ok(())
1017 }
1018 }
1019
1020 impl fidl::encoding::ValueTypeMarker for PortWatchStateResponse {
1021 type Borrowed<'a> = &'a Self;
1022 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1023 value
1024 }
1025 }
1026
1027 unsafe impl fidl::encoding::TypeMarker for PortWatchStateResponse {
1028 type Owned = Self;
1029
1030 #[inline(always)]
1031 fn inline_align(_context: fidl::encoding::Context) -> usize {
1032 8
1033 }
1034
1035 #[inline(always)]
1036 fn inline_size(_context: fidl::encoding::Context) -> usize {
1037 16
1038 }
1039 }
1040
1041 unsafe impl<D: fidl::encoding::ResourceDialect>
1042 fidl::encoding::Encode<PortWatchStateResponse, D> for &PortWatchStateResponse
1043 {
1044 #[inline]
1045 unsafe fn encode(
1046 self,
1047 encoder: &mut fidl::encoding::Encoder<'_, D>,
1048 offset: usize,
1049 _depth: fidl::encoding::Depth,
1050 ) -> fidl::Result<()> {
1051 encoder.debug_check_bounds::<PortWatchStateResponse>(offset);
1052 fidl::encoding::Encode::<PortWatchStateResponse, D>::encode(
1054 (<InternalState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
1055 encoder,
1056 offset,
1057 _depth,
1058 )
1059 }
1060 }
1061 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<InternalState, D>>
1062 fidl::encoding::Encode<PortWatchStateResponse, D> for (T0,)
1063 {
1064 #[inline]
1065 unsafe fn encode(
1066 self,
1067 encoder: &mut fidl::encoding::Encoder<'_, D>,
1068 offset: usize,
1069 depth: fidl::encoding::Depth,
1070 ) -> fidl::Result<()> {
1071 encoder.debug_check_bounds::<PortWatchStateResponse>(offset);
1072 self.0.encode(encoder, offset + 0, depth)?;
1076 Ok(())
1077 }
1078 }
1079
1080 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1081 for PortWatchStateResponse
1082 {
1083 #[inline(always)]
1084 fn new_empty() -> Self {
1085 Self { state: fidl::new_empty!(InternalState, D) }
1086 }
1087
1088 #[inline]
1089 unsafe fn decode(
1090 &mut self,
1091 decoder: &mut fidl::encoding::Decoder<'_, D>,
1092 offset: usize,
1093 _depth: fidl::encoding::Depth,
1094 ) -> fidl::Result<()> {
1095 decoder.debug_check_bounds::<Self>(offset);
1096 fidl::decode!(InternalState, D, &mut self.state, decoder, offset + 0, _depth)?;
1098 Ok(())
1099 }
1100 }
1101
1102 impl BaseDeviceConfig {
1103 #[inline(always)]
1104 fn max_ordinal_present(&self) -> u64 {
1105 if let Some(_) = self.min_rx_buffer_length {
1106 return 3;
1107 }
1108 if let Some(_) = self.min_tx_buffer_length {
1109 return 2;
1110 }
1111 if let Some(_) = self.report_metadata {
1112 return 1;
1113 }
1114 0
1115 }
1116 }
1117
1118 impl fidl::encoding::ValueTypeMarker for BaseDeviceConfig {
1119 type Borrowed<'a> = &'a Self;
1120 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1121 value
1122 }
1123 }
1124
1125 unsafe impl fidl::encoding::TypeMarker for BaseDeviceConfig {
1126 type Owned = Self;
1127
1128 #[inline(always)]
1129 fn inline_align(_context: fidl::encoding::Context) -> usize {
1130 8
1131 }
1132
1133 #[inline(always)]
1134 fn inline_size(_context: fidl::encoding::Context) -> usize {
1135 16
1136 }
1137 }
1138
1139 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BaseDeviceConfig, D>
1140 for &BaseDeviceConfig
1141 {
1142 unsafe fn encode(
1143 self,
1144 encoder: &mut fidl::encoding::Encoder<'_, D>,
1145 offset: usize,
1146 mut depth: fidl::encoding::Depth,
1147 ) -> fidl::Result<()> {
1148 encoder.debug_check_bounds::<BaseDeviceConfig>(offset);
1149 let max_ordinal: u64 = self.max_ordinal_present();
1151 encoder.write_num(max_ordinal, offset);
1152 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1153 if max_ordinal == 0 {
1155 return Ok(());
1156 }
1157 depth.increment()?;
1158 let envelope_size = 8;
1159 let bytes_len = max_ordinal as usize * envelope_size;
1160 #[allow(unused_variables)]
1161 let offset = encoder.out_of_line_offset(bytes_len);
1162 let mut _prev_end_offset: usize = 0;
1163 if 1 > max_ordinal {
1164 return Ok(());
1165 }
1166
1167 let cur_offset: usize = (1 - 1) * envelope_size;
1170
1171 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1173
1174 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1179 self.report_metadata
1180 .as_ref()
1181 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1182 encoder,
1183 offset + cur_offset,
1184 depth,
1185 )?;
1186
1187 _prev_end_offset = cur_offset + envelope_size;
1188 if 2 > max_ordinal {
1189 return Ok(());
1190 }
1191
1192 let cur_offset: usize = (2 - 1) * envelope_size;
1195
1196 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1198
1199 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1204 self.min_tx_buffer_length
1205 .as_ref()
1206 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1207 encoder,
1208 offset + cur_offset,
1209 depth,
1210 )?;
1211
1212 _prev_end_offset = cur_offset + envelope_size;
1213 if 3 > max_ordinal {
1214 return Ok(());
1215 }
1216
1217 let cur_offset: usize = (3 - 1) * envelope_size;
1220
1221 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1223
1224 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1229 self.min_rx_buffer_length
1230 .as_ref()
1231 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1232 encoder,
1233 offset + cur_offset,
1234 depth,
1235 )?;
1236
1237 _prev_end_offset = cur_offset + envelope_size;
1238
1239 Ok(())
1240 }
1241 }
1242
1243 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BaseDeviceConfig {
1244 #[inline(always)]
1245 fn new_empty() -> Self {
1246 Self::default()
1247 }
1248
1249 unsafe fn decode(
1250 &mut self,
1251 decoder: &mut fidl::encoding::Decoder<'_, D>,
1252 offset: usize,
1253 mut depth: fidl::encoding::Depth,
1254 ) -> fidl::Result<()> {
1255 decoder.debug_check_bounds::<Self>(offset);
1256 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1257 None => return Err(fidl::Error::NotNullable),
1258 Some(len) => len,
1259 };
1260 if len == 0 {
1262 return Ok(());
1263 };
1264 depth.increment()?;
1265 let envelope_size = 8;
1266 let bytes_len = len * envelope_size;
1267 let offset = decoder.out_of_line_offset(bytes_len)?;
1268 let mut _next_ordinal_to_read = 0;
1270 let mut next_offset = offset;
1271 let end_offset = offset + bytes_len;
1272 _next_ordinal_to_read += 1;
1273 if next_offset >= end_offset {
1274 return Ok(());
1275 }
1276
1277 while _next_ordinal_to_read < 1 {
1279 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1280 _next_ordinal_to_read += 1;
1281 next_offset += envelope_size;
1282 }
1283
1284 let next_out_of_line = decoder.next_out_of_line();
1285 let handles_before = decoder.remaining_handles();
1286 if let Some((inlined, num_bytes, num_handles)) =
1287 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1288 {
1289 let member_inline_size =
1290 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1291 if inlined != (member_inline_size <= 4) {
1292 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1293 }
1294 let inner_offset;
1295 let mut inner_depth = depth.clone();
1296 if inlined {
1297 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1298 inner_offset = next_offset;
1299 } else {
1300 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1301 inner_depth.increment()?;
1302 }
1303 let val_ref = self.report_metadata.get_or_insert_with(|| fidl::new_empty!(bool, D));
1304 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1305 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1306 {
1307 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1308 }
1309 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1310 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1311 }
1312 }
1313
1314 next_offset += envelope_size;
1315 _next_ordinal_to_read += 1;
1316 if next_offset >= end_offset {
1317 return Ok(());
1318 }
1319
1320 while _next_ordinal_to_read < 2 {
1322 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1323 _next_ordinal_to_read += 1;
1324 next_offset += envelope_size;
1325 }
1326
1327 let next_out_of_line = decoder.next_out_of_line();
1328 let handles_before = decoder.remaining_handles();
1329 if let Some((inlined, num_bytes, num_handles)) =
1330 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1331 {
1332 let member_inline_size =
1333 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1334 if inlined != (member_inline_size <= 4) {
1335 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1336 }
1337 let inner_offset;
1338 let mut inner_depth = depth.clone();
1339 if inlined {
1340 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1341 inner_offset = next_offset;
1342 } else {
1343 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1344 inner_depth.increment()?;
1345 }
1346 let val_ref =
1347 self.min_tx_buffer_length.get_or_insert_with(|| fidl::new_empty!(u32, D));
1348 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1349 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1350 {
1351 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1352 }
1353 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1354 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1355 }
1356 }
1357
1358 next_offset += envelope_size;
1359 _next_ordinal_to_read += 1;
1360 if next_offset >= end_offset {
1361 return Ok(());
1362 }
1363
1364 while _next_ordinal_to_read < 3 {
1366 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1367 _next_ordinal_to_read += 1;
1368 next_offset += envelope_size;
1369 }
1370
1371 let next_out_of_line = decoder.next_out_of_line();
1372 let handles_before = decoder.remaining_handles();
1373 if let Some((inlined, num_bytes, num_handles)) =
1374 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1375 {
1376 let member_inline_size =
1377 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1378 if inlined != (member_inline_size <= 4) {
1379 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1380 }
1381 let inner_offset;
1382 let mut inner_depth = depth.clone();
1383 if inlined {
1384 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1385 inner_offset = next_offset;
1386 } else {
1387 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1388 inner_depth.increment()?;
1389 }
1390 let val_ref =
1391 self.min_rx_buffer_length.get_or_insert_with(|| fidl::new_empty!(u32, D));
1392 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1393 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1394 {
1395 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1396 }
1397 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1398 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1399 }
1400 }
1401
1402 next_offset += envelope_size;
1403
1404 while next_offset < end_offset {
1406 _next_ordinal_to_read += 1;
1407 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1408 next_offset += envelope_size;
1409 }
1410
1411 Ok(())
1412 }
1413 }
1414
1415 impl BasePortConfig {
1416 #[inline(always)]
1417 fn max_ordinal_present(&self) -> u64 {
1418 if let Some(_) = self.port_class {
1419 return 5;
1420 }
1421 if let Some(_) = self.tx_types {
1422 return 4;
1423 }
1424 if let Some(_) = self.rx_types {
1425 return 3;
1426 }
1427 if let Some(_) = self.mtu {
1428 return 2;
1429 }
1430 if let Some(_) = self.id {
1431 return 1;
1432 }
1433 0
1434 }
1435 }
1436
1437 impl fidl::encoding::ValueTypeMarker for BasePortConfig {
1438 type Borrowed<'a> = &'a Self;
1439 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1440 value
1441 }
1442 }
1443
1444 unsafe impl fidl::encoding::TypeMarker for BasePortConfig {
1445 type Owned = Self;
1446
1447 #[inline(always)]
1448 fn inline_align(_context: fidl::encoding::Context) -> usize {
1449 8
1450 }
1451
1452 #[inline(always)]
1453 fn inline_size(_context: fidl::encoding::Context) -> usize {
1454 16
1455 }
1456 }
1457
1458 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BasePortConfig, D>
1459 for &BasePortConfig
1460 {
1461 unsafe fn encode(
1462 self,
1463 encoder: &mut fidl::encoding::Encoder<'_, D>,
1464 offset: usize,
1465 mut depth: fidl::encoding::Depth,
1466 ) -> fidl::Result<()> {
1467 encoder.debug_check_bounds::<BasePortConfig>(offset);
1468 let max_ordinal: u64 = self.max_ordinal_present();
1470 encoder.write_num(max_ordinal, offset);
1471 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1472 if max_ordinal == 0 {
1474 return Ok(());
1475 }
1476 depth.increment()?;
1477 let envelope_size = 8;
1478 let bytes_len = max_ordinal as usize * envelope_size;
1479 #[allow(unused_variables)]
1480 let offset = encoder.out_of_line_offset(bytes_len);
1481 let mut _prev_end_offset: usize = 0;
1482 if 1 > max_ordinal {
1483 return Ok(());
1484 }
1485
1486 let cur_offset: usize = (1 - 1) * envelope_size;
1489
1490 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1492
1493 fidl::encoding::encode_in_envelope_optional::<u8, D>(
1498 self.id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1499 encoder,
1500 offset + cur_offset,
1501 depth,
1502 )?;
1503
1504 _prev_end_offset = cur_offset + envelope_size;
1505 if 2 > max_ordinal {
1506 return Ok(());
1507 }
1508
1509 let cur_offset: usize = (2 - 1) * envelope_size;
1512
1513 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1515
1516 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1521 self.mtu.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1522 encoder,
1523 offset + cur_offset,
1524 depth,
1525 )?;
1526
1527 _prev_end_offset = cur_offset + envelope_size;
1528 if 3 > max_ordinal {
1529 return Ok(());
1530 }
1531
1532 let cur_offset: usize = (3 - 1) * envelope_size;
1535
1536 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1538
1539 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4>, D>(
1544 self.rx_types.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4> as fidl::encoding::ValueTypeMarker>::borrow),
1545 encoder, offset + cur_offset, depth
1546 )?;
1547
1548 _prev_end_offset = cur_offset + envelope_size;
1549 if 4 > max_ordinal {
1550 return Ok(());
1551 }
1552
1553 let cur_offset: usize = (4 - 1) * envelope_size;
1556
1557 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1559
1560 fidl::encoding::encode_in_envelope_optional::<
1565 fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameTypeSupport, 4>,
1566 D,
1567 >(
1568 self.tx_types.as_ref().map(
1569 <fidl::encoding::Vector<
1570 fidl_fuchsia_hardware_network__common::FrameTypeSupport,
1571 4,
1572 > as fidl::encoding::ValueTypeMarker>::borrow,
1573 ),
1574 encoder,
1575 offset + cur_offset,
1576 depth,
1577 )?;
1578
1579 _prev_end_offset = cur_offset + envelope_size;
1580 if 5 > max_ordinal {
1581 return Ok(());
1582 }
1583
1584 let cur_offset: usize = (5 - 1) * envelope_size;
1587
1588 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1590
1591 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_network__common::PortClass, D>(
1596 self.port_class.as_ref().map(<fidl_fuchsia_hardware_network__common::PortClass as fidl::encoding::ValueTypeMarker>::borrow),
1597 encoder, offset + cur_offset, depth
1598 )?;
1599
1600 _prev_end_offset = cur_offset + envelope_size;
1601
1602 Ok(())
1603 }
1604 }
1605
1606 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BasePortConfig {
1607 #[inline(always)]
1608 fn new_empty() -> Self {
1609 Self::default()
1610 }
1611
1612 unsafe fn decode(
1613 &mut self,
1614 decoder: &mut fidl::encoding::Decoder<'_, D>,
1615 offset: usize,
1616 mut depth: fidl::encoding::Depth,
1617 ) -> fidl::Result<()> {
1618 decoder.debug_check_bounds::<Self>(offset);
1619 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1620 None => return Err(fidl::Error::NotNullable),
1621 Some(len) => len,
1622 };
1623 if len == 0 {
1625 return Ok(());
1626 };
1627 depth.increment()?;
1628 let envelope_size = 8;
1629 let bytes_len = len * envelope_size;
1630 let offset = decoder.out_of_line_offset(bytes_len)?;
1631 let mut _next_ordinal_to_read = 0;
1633 let mut next_offset = offset;
1634 let end_offset = offset + bytes_len;
1635 _next_ordinal_to_read += 1;
1636 if next_offset >= end_offset {
1637 return Ok(());
1638 }
1639
1640 while _next_ordinal_to_read < 1 {
1642 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1643 _next_ordinal_to_read += 1;
1644 next_offset += envelope_size;
1645 }
1646
1647 let next_out_of_line = decoder.next_out_of_line();
1648 let handles_before = decoder.remaining_handles();
1649 if let Some((inlined, num_bytes, num_handles)) =
1650 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1651 {
1652 let member_inline_size =
1653 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1654 if inlined != (member_inline_size <= 4) {
1655 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1656 }
1657 let inner_offset;
1658 let mut inner_depth = depth.clone();
1659 if inlined {
1660 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1661 inner_offset = next_offset;
1662 } else {
1663 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1664 inner_depth.increment()?;
1665 }
1666 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u8, D));
1667 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1668 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1669 {
1670 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1671 }
1672 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1673 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1674 }
1675 }
1676
1677 next_offset += envelope_size;
1678 _next_ordinal_to_read += 1;
1679 if next_offset >= end_offset {
1680 return Ok(());
1681 }
1682
1683 while _next_ordinal_to_read < 2 {
1685 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1686 _next_ordinal_to_read += 1;
1687 next_offset += envelope_size;
1688 }
1689
1690 let next_out_of_line = decoder.next_out_of_line();
1691 let handles_before = decoder.remaining_handles();
1692 if let Some((inlined, num_bytes, num_handles)) =
1693 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1694 {
1695 let member_inline_size =
1696 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1697 if inlined != (member_inline_size <= 4) {
1698 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1699 }
1700 let inner_offset;
1701 let mut inner_depth = depth.clone();
1702 if inlined {
1703 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1704 inner_offset = next_offset;
1705 } else {
1706 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1707 inner_depth.increment()?;
1708 }
1709 let val_ref = self.mtu.get_or_insert_with(|| fidl::new_empty!(u32, D));
1710 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1711 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1712 {
1713 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1714 }
1715 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1716 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1717 }
1718 }
1719
1720 next_offset += envelope_size;
1721 _next_ordinal_to_read += 1;
1722 if next_offset >= end_offset {
1723 return Ok(());
1724 }
1725
1726 while _next_ordinal_to_read < 3 {
1728 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1729 _next_ordinal_to_read += 1;
1730 next_offset += envelope_size;
1731 }
1732
1733 let next_out_of_line = decoder.next_out_of_line();
1734 let handles_before = decoder.remaining_handles();
1735 if let Some((inlined, num_bytes, num_handles)) =
1736 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1737 {
1738 let member_inline_size = <fidl::encoding::Vector<
1739 fidl_fuchsia_hardware_network__common::FrameType,
1740 4,
1741 > as fidl::encoding::TypeMarker>::inline_size(
1742 decoder.context
1743 );
1744 if inlined != (member_inline_size <= 4) {
1745 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1746 }
1747 let inner_offset;
1748 let mut inner_depth = depth.clone();
1749 if inlined {
1750 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1751 inner_offset = next_offset;
1752 } else {
1753 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1754 inner_depth.increment()?;
1755 }
1756 let val_ref =
1757 self.rx_types.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4>, D));
1758 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
1759 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1760 {
1761 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1762 }
1763 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1764 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1765 }
1766 }
1767
1768 next_offset += envelope_size;
1769 _next_ordinal_to_read += 1;
1770 if next_offset >= end_offset {
1771 return Ok(());
1772 }
1773
1774 while _next_ordinal_to_read < 4 {
1776 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1777 _next_ordinal_to_read += 1;
1778 next_offset += envelope_size;
1779 }
1780
1781 let next_out_of_line = decoder.next_out_of_line();
1782 let handles_before = decoder.remaining_handles();
1783 if let Some((inlined, num_bytes, num_handles)) =
1784 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1785 {
1786 let member_inline_size = <fidl::encoding::Vector<
1787 fidl_fuchsia_hardware_network__common::FrameTypeSupport,
1788 4,
1789 > as fidl::encoding::TypeMarker>::inline_size(
1790 decoder.context
1791 );
1792 if inlined != (member_inline_size <= 4) {
1793 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1794 }
1795 let inner_offset;
1796 let mut inner_depth = depth.clone();
1797 if inlined {
1798 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1799 inner_offset = next_offset;
1800 } else {
1801 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1802 inner_depth.increment()?;
1803 }
1804 let val_ref =
1805 self.tx_types.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameTypeSupport, 4>, D));
1806 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameTypeSupport, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
1807 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1808 {
1809 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1810 }
1811 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1812 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1813 }
1814 }
1815
1816 next_offset += envelope_size;
1817 _next_ordinal_to_read += 1;
1818 if next_offset >= end_offset {
1819 return Ok(());
1820 }
1821
1822 while _next_ordinal_to_read < 5 {
1824 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1825 _next_ordinal_to_read += 1;
1826 next_offset += envelope_size;
1827 }
1828
1829 let next_out_of_line = decoder.next_out_of_line();
1830 let handles_before = decoder.remaining_handles();
1831 if let Some((inlined, num_bytes, num_handles)) =
1832 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1833 {
1834 let member_inline_size = <fidl_fuchsia_hardware_network__common::PortClass as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1835 if inlined != (member_inline_size <= 4) {
1836 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1837 }
1838 let inner_offset;
1839 let mut inner_depth = depth.clone();
1840 if inlined {
1841 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1842 inner_offset = next_offset;
1843 } else {
1844 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1845 inner_depth.increment()?;
1846 }
1847 let val_ref = self.port_class.get_or_insert_with(|| {
1848 fidl::new_empty!(fidl_fuchsia_hardware_network__common::PortClass, D)
1849 });
1850 fidl::decode!(
1851 fidl_fuchsia_hardware_network__common::PortClass,
1852 D,
1853 val_ref,
1854 decoder,
1855 inner_offset,
1856 inner_depth
1857 )?;
1858 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1859 {
1860 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1861 }
1862 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1863 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1864 }
1865 }
1866
1867 next_offset += envelope_size;
1868
1869 while next_offset < end_offset {
1871 _next_ordinal_to_read += 1;
1872 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1873 next_offset += envelope_size;
1874 }
1875
1876 Ok(())
1877 }
1878 }
1879
1880 impl DeviceConfig {
1881 #[inline(always)]
1882 fn max_ordinal_present(&self) -> u64 {
1883 if let Some(_) = self.blocking {
1884 return 2;
1885 }
1886 if let Some(_) = self.base {
1887 return 1;
1888 }
1889 0
1890 }
1891 }
1892
1893 impl fidl::encoding::ValueTypeMarker for DeviceConfig {
1894 type Borrowed<'a> = &'a Self;
1895 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1896 value
1897 }
1898 }
1899
1900 unsafe impl fidl::encoding::TypeMarker for DeviceConfig {
1901 type Owned = Self;
1902
1903 #[inline(always)]
1904 fn inline_align(_context: fidl::encoding::Context) -> usize {
1905 8
1906 }
1907
1908 #[inline(always)]
1909 fn inline_size(_context: fidl::encoding::Context) -> usize {
1910 16
1911 }
1912 }
1913
1914 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceConfig, D>
1915 for &DeviceConfig
1916 {
1917 unsafe fn encode(
1918 self,
1919 encoder: &mut fidl::encoding::Encoder<'_, D>,
1920 offset: usize,
1921 mut depth: fidl::encoding::Depth,
1922 ) -> fidl::Result<()> {
1923 encoder.debug_check_bounds::<DeviceConfig>(offset);
1924 let max_ordinal: u64 = self.max_ordinal_present();
1926 encoder.write_num(max_ordinal, offset);
1927 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1928 if max_ordinal == 0 {
1930 return Ok(());
1931 }
1932 depth.increment()?;
1933 let envelope_size = 8;
1934 let bytes_len = max_ordinal as usize * envelope_size;
1935 #[allow(unused_variables)]
1936 let offset = encoder.out_of_line_offset(bytes_len);
1937 let mut _prev_end_offset: usize = 0;
1938 if 1 > max_ordinal {
1939 return Ok(());
1940 }
1941
1942 let cur_offset: usize = (1 - 1) * envelope_size;
1945
1946 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1948
1949 fidl::encoding::encode_in_envelope_optional::<BaseDeviceConfig, D>(
1954 self.base
1955 .as_ref()
1956 .map(<BaseDeviceConfig as fidl::encoding::ValueTypeMarker>::borrow),
1957 encoder,
1958 offset + cur_offset,
1959 depth,
1960 )?;
1961
1962 _prev_end_offset = cur_offset + envelope_size;
1963 if 2 > max_ordinal {
1964 return Ok(());
1965 }
1966
1967 let cur_offset: usize = (2 - 1) * envelope_size;
1970
1971 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1973
1974 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1979 self.blocking.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1980 encoder,
1981 offset + cur_offset,
1982 depth,
1983 )?;
1984
1985 _prev_end_offset = cur_offset + envelope_size;
1986
1987 Ok(())
1988 }
1989 }
1990
1991 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceConfig {
1992 #[inline(always)]
1993 fn new_empty() -> Self {
1994 Self::default()
1995 }
1996
1997 unsafe fn decode(
1998 &mut self,
1999 decoder: &mut fidl::encoding::Decoder<'_, D>,
2000 offset: usize,
2001 mut depth: fidl::encoding::Depth,
2002 ) -> fidl::Result<()> {
2003 decoder.debug_check_bounds::<Self>(offset);
2004 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2005 None => return Err(fidl::Error::NotNullable),
2006 Some(len) => len,
2007 };
2008 if len == 0 {
2010 return Ok(());
2011 };
2012 depth.increment()?;
2013 let envelope_size = 8;
2014 let bytes_len = len * envelope_size;
2015 let offset = decoder.out_of_line_offset(bytes_len)?;
2016 let mut _next_ordinal_to_read = 0;
2018 let mut next_offset = offset;
2019 let end_offset = offset + bytes_len;
2020 _next_ordinal_to_read += 1;
2021 if next_offset >= end_offset {
2022 return Ok(());
2023 }
2024
2025 while _next_ordinal_to_read < 1 {
2027 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2028 _next_ordinal_to_read += 1;
2029 next_offset += envelope_size;
2030 }
2031
2032 let next_out_of_line = decoder.next_out_of_line();
2033 let handles_before = decoder.remaining_handles();
2034 if let Some((inlined, num_bytes, num_handles)) =
2035 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2036 {
2037 let member_inline_size =
2038 <BaseDeviceConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2039 if inlined != (member_inline_size <= 4) {
2040 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2041 }
2042 let inner_offset;
2043 let mut inner_depth = depth.clone();
2044 if inlined {
2045 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2046 inner_offset = next_offset;
2047 } else {
2048 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2049 inner_depth.increment()?;
2050 }
2051 let val_ref =
2052 self.base.get_or_insert_with(|| fidl::new_empty!(BaseDeviceConfig, D));
2053 fidl::decode!(BaseDeviceConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2054 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2055 {
2056 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2057 }
2058 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2059 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2060 }
2061 }
2062
2063 next_offset += envelope_size;
2064 _next_ordinal_to_read += 1;
2065 if next_offset >= end_offset {
2066 return Ok(());
2067 }
2068
2069 while _next_ordinal_to_read < 2 {
2071 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2072 _next_ordinal_to_read += 1;
2073 next_offset += envelope_size;
2074 }
2075
2076 let next_out_of_line = decoder.next_out_of_line();
2077 let handles_before = decoder.remaining_handles();
2078 if let Some((inlined, num_bytes, num_handles)) =
2079 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2080 {
2081 let member_inline_size =
2082 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2083 if inlined != (member_inline_size <= 4) {
2084 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2085 }
2086 let inner_offset;
2087 let mut inner_depth = depth.clone();
2088 if inlined {
2089 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2090 inner_offset = next_offset;
2091 } else {
2092 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2093 inner_depth.increment()?;
2094 }
2095 let val_ref = self.blocking.get_or_insert_with(|| fidl::new_empty!(bool, D));
2096 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2097 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2098 {
2099 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2100 }
2101 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2102 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2103 }
2104 }
2105
2106 next_offset += envelope_size;
2107
2108 while next_offset < end_offset {
2110 _next_ordinal_to_read += 1;
2111 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2112 next_offset += envelope_size;
2113 }
2114
2115 Ok(())
2116 }
2117 }
2118
2119 impl DevicePairConfig {
2120 #[inline(always)]
2121 fn max_ordinal_present(&self) -> u64 {
2122 if let Some(_) = self.fallible_transmit_right {
2123 return 3;
2124 }
2125 if let Some(_) = self.fallible_transmit_left {
2126 return 2;
2127 }
2128 if let Some(_) = self.base {
2129 return 1;
2130 }
2131 0
2132 }
2133 }
2134
2135 impl fidl::encoding::ValueTypeMarker for DevicePairConfig {
2136 type Borrowed<'a> = &'a Self;
2137 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2138 value
2139 }
2140 }
2141
2142 unsafe impl fidl::encoding::TypeMarker for DevicePairConfig {
2143 type Owned = Self;
2144
2145 #[inline(always)]
2146 fn inline_align(_context: fidl::encoding::Context) -> usize {
2147 8
2148 }
2149
2150 #[inline(always)]
2151 fn inline_size(_context: fidl::encoding::Context) -> usize {
2152 16
2153 }
2154 }
2155
2156 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DevicePairConfig, D>
2157 for &DevicePairConfig
2158 {
2159 unsafe fn encode(
2160 self,
2161 encoder: &mut fidl::encoding::Encoder<'_, D>,
2162 offset: usize,
2163 mut depth: fidl::encoding::Depth,
2164 ) -> fidl::Result<()> {
2165 encoder.debug_check_bounds::<DevicePairConfig>(offset);
2166 let max_ordinal: u64 = self.max_ordinal_present();
2168 encoder.write_num(max_ordinal, offset);
2169 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2170 if max_ordinal == 0 {
2172 return Ok(());
2173 }
2174 depth.increment()?;
2175 let envelope_size = 8;
2176 let bytes_len = max_ordinal as usize * envelope_size;
2177 #[allow(unused_variables)]
2178 let offset = encoder.out_of_line_offset(bytes_len);
2179 let mut _prev_end_offset: usize = 0;
2180 if 1 > max_ordinal {
2181 return Ok(());
2182 }
2183
2184 let cur_offset: usize = (1 - 1) * envelope_size;
2187
2188 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2190
2191 fidl::encoding::encode_in_envelope_optional::<BaseDeviceConfig, D>(
2196 self.base
2197 .as_ref()
2198 .map(<BaseDeviceConfig as fidl::encoding::ValueTypeMarker>::borrow),
2199 encoder,
2200 offset + cur_offset,
2201 depth,
2202 )?;
2203
2204 _prev_end_offset = cur_offset + envelope_size;
2205 if 2 > max_ordinal {
2206 return Ok(());
2207 }
2208
2209 let cur_offset: usize = (2 - 1) * envelope_size;
2212
2213 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2215
2216 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2221 self.fallible_transmit_left
2222 .as_ref()
2223 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2224 encoder,
2225 offset + cur_offset,
2226 depth,
2227 )?;
2228
2229 _prev_end_offset = cur_offset + envelope_size;
2230 if 3 > max_ordinal {
2231 return Ok(());
2232 }
2233
2234 let cur_offset: usize = (3 - 1) * envelope_size;
2237
2238 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2240
2241 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2246 self.fallible_transmit_right
2247 .as_ref()
2248 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2249 encoder,
2250 offset + cur_offset,
2251 depth,
2252 )?;
2253
2254 _prev_end_offset = cur_offset + envelope_size;
2255
2256 Ok(())
2257 }
2258 }
2259
2260 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DevicePairConfig {
2261 #[inline(always)]
2262 fn new_empty() -> Self {
2263 Self::default()
2264 }
2265
2266 unsafe fn decode(
2267 &mut self,
2268 decoder: &mut fidl::encoding::Decoder<'_, D>,
2269 offset: usize,
2270 mut depth: fidl::encoding::Depth,
2271 ) -> fidl::Result<()> {
2272 decoder.debug_check_bounds::<Self>(offset);
2273 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2274 None => return Err(fidl::Error::NotNullable),
2275 Some(len) => len,
2276 };
2277 if len == 0 {
2279 return Ok(());
2280 };
2281 depth.increment()?;
2282 let envelope_size = 8;
2283 let bytes_len = len * envelope_size;
2284 let offset = decoder.out_of_line_offset(bytes_len)?;
2285 let mut _next_ordinal_to_read = 0;
2287 let mut next_offset = offset;
2288 let end_offset = offset + bytes_len;
2289 _next_ordinal_to_read += 1;
2290 if next_offset >= end_offset {
2291 return Ok(());
2292 }
2293
2294 while _next_ordinal_to_read < 1 {
2296 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2297 _next_ordinal_to_read += 1;
2298 next_offset += envelope_size;
2299 }
2300
2301 let next_out_of_line = decoder.next_out_of_line();
2302 let handles_before = decoder.remaining_handles();
2303 if let Some((inlined, num_bytes, num_handles)) =
2304 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2305 {
2306 let member_inline_size =
2307 <BaseDeviceConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2308 if inlined != (member_inline_size <= 4) {
2309 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2310 }
2311 let inner_offset;
2312 let mut inner_depth = depth.clone();
2313 if inlined {
2314 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2315 inner_offset = next_offset;
2316 } else {
2317 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2318 inner_depth.increment()?;
2319 }
2320 let val_ref =
2321 self.base.get_or_insert_with(|| fidl::new_empty!(BaseDeviceConfig, D));
2322 fidl::decode!(BaseDeviceConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2323 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2324 {
2325 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2326 }
2327 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2328 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2329 }
2330 }
2331
2332 next_offset += envelope_size;
2333 _next_ordinal_to_read += 1;
2334 if next_offset >= end_offset {
2335 return Ok(());
2336 }
2337
2338 while _next_ordinal_to_read < 2 {
2340 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2341 _next_ordinal_to_read += 1;
2342 next_offset += envelope_size;
2343 }
2344
2345 let next_out_of_line = decoder.next_out_of_line();
2346 let handles_before = decoder.remaining_handles();
2347 if let Some((inlined, num_bytes, num_handles)) =
2348 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2349 {
2350 let member_inline_size =
2351 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2352 if inlined != (member_inline_size <= 4) {
2353 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2354 }
2355 let inner_offset;
2356 let mut inner_depth = depth.clone();
2357 if inlined {
2358 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2359 inner_offset = next_offset;
2360 } else {
2361 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2362 inner_depth.increment()?;
2363 }
2364 let val_ref =
2365 self.fallible_transmit_left.get_or_insert_with(|| fidl::new_empty!(bool, D));
2366 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2367 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2368 {
2369 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2370 }
2371 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2372 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2373 }
2374 }
2375
2376 next_offset += envelope_size;
2377 _next_ordinal_to_read += 1;
2378 if next_offset >= end_offset {
2379 return Ok(());
2380 }
2381
2382 while _next_ordinal_to_read < 3 {
2384 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2385 _next_ordinal_to_read += 1;
2386 next_offset += envelope_size;
2387 }
2388
2389 let next_out_of_line = decoder.next_out_of_line();
2390 let handles_before = decoder.remaining_handles();
2391 if let Some((inlined, num_bytes, num_handles)) =
2392 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2393 {
2394 let member_inline_size =
2395 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2396 if inlined != (member_inline_size <= 4) {
2397 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2398 }
2399 let inner_offset;
2400 let mut inner_depth = depth.clone();
2401 if inlined {
2402 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2403 inner_offset = next_offset;
2404 } else {
2405 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2406 inner_depth.increment()?;
2407 }
2408 let val_ref =
2409 self.fallible_transmit_right.get_or_insert_with(|| fidl::new_empty!(bool, D));
2410 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2411 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2412 {
2413 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2414 }
2415 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2416 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2417 }
2418 }
2419
2420 next_offset += envelope_size;
2421
2422 while next_offset < end_offset {
2424 _next_ordinal_to_read += 1;
2425 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2426 next_offset += envelope_size;
2427 }
2428
2429 Ok(())
2430 }
2431 }
2432
2433 impl DevicePairPortConfig {
2434 #[inline(always)]
2435 fn max_ordinal_present(&self) -> u64 {
2436 if let Some(_) = self.mac_right {
2437 return 3;
2438 }
2439 if let Some(_) = self.mac_left {
2440 return 2;
2441 }
2442 if let Some(_) = self.base {
2443 return 1;
2444 }
2445 0
2446 }
2447 }
2448
2449 impl fidl::encoding::ValueTypeMarker for DevicePairPortConfig {
2450 type Borrowed<'a> = &'a Self;
2451 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2452 value
2453 }
2454 }
2455
2456 unsafe impl fidl::encoding::TypeMarker for DevicePairPortConfig {
2457 type Owned = Self;
2458
2459 #[inline(always)]
2460 fn inline_align(_context: fidl::encoding::Context) -> usize {
2461 8
2462 }
2463
2464 #[inline(always)]
2465 fn inline_size(_context: fidl::encoding::Context) -> usize {
2466 16
2467 }
2468 }
2469
2470 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DevicePairPortConfig, D>
2471 for &DevicePairPortConfig
2472 {
2473 unsafe fn encode(
2474 self,
2475 encoder: &mut fidl::encoding::Encoder<'_, D>,
2476 offset: usize,
2477 mut depth: fidl::encoding::Depth,
2478 ) -> fidl::Result<()> {
2479 encoder.debug_check_bounds::<DevicePairPortConfig>(offset);
2480 let max_ordinal: u64 = self.max_ordinal_present();
2482 encoder.write_num(max_ordinal, offset);
2483 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2484 if max_ordinal == 0 {
2486 return Ok(());
2487 }
2488 depth.increment()?;
2489 let envelope_size = 8;
2490 let bytes_len = max_ordinal as usize * envelope_size;
2491 #[allow(unused_variables)]
2492 let offset = encoder.out_of_line_offset(bytes_len);
2493 let mut _prev_end_offset: usize = 0;
2494 if 1 > max_ordinal {
2495 return Ok(());
2496 }
2497
2498 let cur_offset: usize = (1 - 1) * envelope_size;
2501
2502 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2504
2505 fidl::encoding::encode_in_envelope_optional::<BasePortConfig, D>(
2510 self.base.as_ref().map(<BasePortConfig as fidl::encoding::ValueTypeMarker>::borrow),
2511 encoder,
2512 offset + cur_offset,
2513 depth,
2514 )?;
2515
2516 _prev_end_offset = cur_offset + envelope_size;
2517 if 2 > max_ordinal {
2518 return Ok(());
2519 }
2520
2521 let cur_offset: usize = (2 - 1) * envelope_size;
2524
2525 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2527
2528 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
2533 self.mac_left.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2534 encoder, offset + cur_offset, depth
2535 )?;
2536
2537 _prev_end_offset = cur_offset + envelope_size;
2538 if 3 > max_ordinal {
2539 return Ok(());
2540 }
2541
2542 let cur_offset: usize = (3 - 1) * envelope_size;
2545
2546 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2548
2549 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
2554 self.mac_right.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2555 encoder, offset + cur_offset, depth
2556 )?;
2557
2558 _prev_end_offset = cur_offset + envelope_size;
2559
2560 Ok(())
2561 }
2562 }
2563
2564 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DevicePairPortConfig {
2565 #[inline(always)]
2566 fn new_empty() -> Self {
2567 Self::default()
2568 }
2569
2570 unsafe fn decode(
2571 &mut self,
2572 decoder: &mut fidl::encoding::Decoder<'_, D>,
2573 offset: usize,
2574 mut depth: fidl::encoding::Depth,
2575 ) -> fidl::Result<()> {
2576 decoder.debug_check_bounds::<Self>(offset);
2577 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2578 None => return Err(fidl::Error::NotNullable),
2579 Some(len) => len,
2580 };
2581 if len == 0 {
2583 return Ok(());
2584 };
2585 depth.increment()?;
2586 let envelope_size = 8;
2587 let bytes_len = len * envelope_size;
2588 let offset = decoder.out_of_line_offset(bytes_len)?;
2589 let mut _next_ordinal_to_read = 0;
2591 let mut next_offset = offset;
2592 let end_offset = offset + bytes_len;
2593 _next_ordinal_to_read += 1;
2594 if next_offset >= end_offset {
2595 return Ok(());
2596 }
2597
2598 while _next_ordinal_to_read < 1 {
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 <BasePortConfig 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.base.get_or_insert_with(|| fidl::new_empty!(BasePortConfig, D));
2625 fidl::decode!(BasePortConfig, 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 < 2 {
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 = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2654 if inlined != (member_inline_size <= 4) {
2655 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2656 }
2657 let inner_offset;
2658 let mut inner_depth = depth.clone();
2659 if inlined {
2660 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2661 inner_offset = next_offset;
2662 } else {
2663 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2664 inner_depth.increment()?;
2665 }
2666 let val_ref = self.mac_left.get_or_insert_with(|| {
2667 fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
2668 });
2669 fidl::decode!(
2670 fidl_fuchsia_net__common::MacAddress,
2671 D,
2672 val_ref,
2673 decoder,
2674 inner_offset,
2675 inner_depth
2676 )?;
2677 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2678 {
2679 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2680 }
2681 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2682 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2683 }
2684 }
2685
2686 next_offset += envelope_size;
2687 _next_ordinal_to_read += 1;
2688 if next_offset >= end_offset {
2689 return Ok(());
2690 }
2691
2692 while _next_ordinal_to_read < 3 {
2694 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2695 _next_ordinal_to_read += 1;
2696 next_offset += envelope_size;
2697 }
2698
2699 let next_out_of_line = decoder.next_out_of_line();
2700 let handles_before = decoder.remaining_handles();
2701 if let Some((inlined, num_bytes, num_handles)) =
2702 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2703 {
2704 let member_inline_size = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2705 if inlined != (member_inline_size <= 4) {
2706 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2707 }
2708 let inner_offset;
2709 let mut inner_depth = depth.clone();
2710 if inlined {
2711 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2712 inner_offset = next_offset;
2713 } else {
2714 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2715 inner_depth.increment()?;
2716 }
2717 let val_ref = self.mac_right.get_or_insert_with(|| {
2718 fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
2719 });
2720 fidl::decode!(
2721 fidl_fuchsia_net__common::MacAddress,
2722 D,
2723 val_ref,
2724 decoder,
2725 inner_offset,
2726 inner_depth
2727 )?;
2728 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2729 {
2730 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2731 }
2732 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2733 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2734 }
2735 }
2736
2737 next_offset += envelope_size;
2738
2739 while next_offset < end_offset {
2741 _next_ordinal_to_read += 1;
2742 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2743 next_offset += envelope_size;
2744 }
2745
2746 Ok(())
2747 }
2748 }
2749
2750 impl DevicePortConfig {
2751 #[inline(always)]
2752 fn max_ordinal_present(&self) -> u64 {
2753 if let Some(_) = self.mac {
2754 return 3;
2755 }
2756 if let Some(_) = self.online {
2757 return 2;
2758 }
2759 if let Some(_) = self.base {
2760 return 1;
2761 }
2762 0
2763 }
2764 }
2765
2766 impl fidl::encoding::ValueTypeMarker for DevicePortConfig {
2767 type Borrowed<'a> = &'a Self;
2768 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2769 value
2770 }
2771 }
2772
2773 unsafe impl fidl::encoding::TypeMarker for DevicePortConfig {
2774 type Owned = Self;
2775
2776 #[inline(always)]
2777 fn inline_align(_context: fidl::encoding::Context) -> usize {
2778 8
2779 }
2780
2781 #[inline(always)]
2782 fn inline_size(_context: fidl::encoding::Context) -> usize {
2783 16
2784 }
2785 }
2786
2787 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DevicePortConfig, D>
2788 for &DevicePortConfig
2789 {
2790 unsafe fn encode(
2791 self,
2792 encoder: &mut fidl::encoding::Encoder<'_, D>,
2793 offset: usize,
2794 mut depth: fidl::encoding::Depth,
2795 ) -> fidl::Result<()> {
2796 encoder.debug_check_bounds::<DevicePortConfig>(offset);
2797 let max_ordinal: u64 = self.max_ordinal_present();
2799 encoder.write_num(max_ordinal, offset);
2800 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2801 if max_ordinal == 0 {
2803 return Ok(());
2804 }
2805 depth.increment()?;
2806 let envelope_size = 8;
2807 let bytes_len = max_ordinal as usize * envelope_size;
2808 #[allow(unused_variables)]
2809 let offset = encoder.out_of_line_offset(bytes_len);
2810 let mut _prev_end_offset: usize = 0;
2811 if 1 > max_ordinal {
2812 return Ok(());
2813 }
2814
2815 let cur_offset: usize = (1 - 1) * envelope_size;
2818
2819 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2821
2822 fidl::encoding::encode_in_envelope_optional::<BasePortConfig, D>(
2827 self.base.as_ref().map(<BasePortConfig as fidl::encoding::ValueTypeMarker>::borrow),
2828 encoder,
2829 offset + cur_offset,
2830 depth,
2831 )?;
2832
2833 _prev_end_offset = cur_offset + envelope_size;
2834 if 2 > max_ordinal {
2835 return Ok(());
2836 }
2837
2838 let cur_offset: usize = (2 - 1) * envelope_size;
2841
2842 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2844
2845 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2850 self.online.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2851 encoder,
2852 offset + cur_offset,
2853 depth,
2854 )?;
2855
2856 _prev_end_offset = cur_offset + envelope_size;
2857 if 3 > max_ordinal {
2858 return Ok(());
2859 }
2860
2861 let cur_offset: usize = (3 - 1) * envelope_size;
2864
2865 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2867
2868 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
2873 self.mac.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2874 encoder, offset + cur_offset, depth
2875 )?;
2876
2877 _prev_end_offset = cur_offset + envelope_size;
2878
2879 Ok(())
2880 }
2881 }
2882
2883 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DevicePortConfig {
2884 #[inline(always)]
2885 fn new_empty() -> Self {
2886 Self::default()
2887 }
2888
2889 unsafe fn decode(
2890 &mut self,
2891 decoder: &mut fidl::encoding::Decoder<'_, D>,
2892 offset: usize,
2893 mut depth: fidl::encoding::Depth,
2894 ) -> fidl::Result<()> {
2895 decoder.debug_check_bounds::<Self>(offset);
2896 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2897 None => return Err(fidl::Error::NotNullable),
2898 Some(len) => len,
2899 };
2900 if len == 0 {
2902 return Ok(());
2903 };
2904 depth.increment()?;
2905 let envelope_size = 8;
2906 let bytes_len = len * envelope_size;
2907 let offset = decoder.out_of_line_offset(bytes_len)?;
2908 let mut _next_ordinal_to_read = 0;
2910 let mut next_offset = offset;
2911 let end_offset = offset + bytes_len;
2912 _next_ordinal_to_read += 1;
2913 if next_offset >= end_offset {
2914 return Ok(());
2915 }
2916
2917 while _next_ordinal_to_read < 1 {
2919 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2920 _next_ordinal_to_read += 1;
2921 next_offset += envelope_size;
2922 }
2923
2924 let next_out_of_line = decoder.next_out_of_line();
2925 let handles_before = decoder.remaining_handles();
2926 if let Some((inlined, num_bytes, num_handles)) =
2927 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2928 {
2929 let member_inline_size =
2930 <BasePortConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2931 if inlined != (member_inline_size <= 4) {
2932 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2933 }
2934 let inner_offset;
2935 let mut inner_depth = depth.clone();
2936 if inlined {
2937 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2938 inner_offset = next_offset;
2939 } else {
2940 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2941 inner_depth.increment()?;
2942 }
2943 let val_ref = self.base.get_or_insert_with(|| fidl::new_empty!(BasePortConfig, D));
2944 fidl::decode!(BasePortConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2945 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2946 {
2947 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2948 }
2949 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2950 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2951 }
2952 }
2953
2954 next_offset += envelope_size;
2955 _next_ordinal_to_read += 1;
2956 if next_offset >= end_offset {
2957 return Ok(());
2958 }
2959
2960 while _next_ordinal_to_read < 2 {
2962 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2963 _next_ordinal_to_read += 1;
2964 next_offset += envelope_size;
2965 }
2966
2967 let next_out_of_line = decoder.next_out_of_line();
2968 let handles_before = decoder.remaining_handles();
2969 if let Some((inlined, num_bytes, num_handles)) =
2970 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2971 {
2972 let member_inline_size =
2973 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2974 if inlined != (member_inline_size <= 4) {
2975 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2976 }
2977 let inner_offset;
2978 let mut inner_depth = depth.clone();
2979 if inlined {
2980 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2981 inner_offset = next_offset;
2982 } else {
2983 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2984 inner_depth.increment()?;
2985 }
2986 let val_ref = self.online.get_or_insert_with(|| fidl::new_empty!(bool, D));
2987 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2988 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2989 {
2990 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2991 }
2992 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2993 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2994 }
2995 }
2996
2997 next_offset += envelope_size;
2998 _next_ordinal_to_read += 1;
2999 if next_offset >= end_offset {
3000 return Ok(());
3001 }
3002
3003 while _next_ordinal_to_read < 3 {
3005 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3006 _next_ordinal_to_read += 1;
3007 next_offset += envelope_size;
3008 }
3009
3010 let next_out_of_line = decoder.next_out_of_line();
3011 let handles_before = decoder.remaining_handles();
3012 if let Some((inlined, num_bytes, num_handles)) =
3013 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3014 {
3015 let member_inline_size = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3016 if inlined != (member_inline_size <= 4) {
3017 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3018 }
3019 let inner_offset;
3020 let mut inner_depth = depth.clone();
3021 if inlined {
3022 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3023 inner_offset = next_offset;
3024 } else {
3025 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3026 inner_depth.increment()?;
3027 }
3028 let val_ref = self.mac.get_or_insert_with(|| {
3029 fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
3030 });
3031 fidl::decode!(
3032 fidl_fuchsia_net__common::MacAddress,
3033 D,
3034 val_ref,
3035 decoder,
3036 inner_offset,
3037 inner_depth
3038 )?;
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
3050 while next_offset < end_offset {
3052 _next_ordinal_to_read += 1;
3053 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3054 next_offset += envelope_size;
3055 }
3056
3057 Ok(())
3058 }
3059 }
3060
3061 impl Frame {
3062 #[inline(always)]
3063 fn max_ordinal_present(&self) -> u64 {
3064 if let Some(_) = self.port {
3065 return 4;
3066 }
3067 if let Some(_) = self.meta {
3068 return 3;
3069 }
3070 if let Some(_) = self.data {
3071 return 2;
3072 }
3073 if let Some(_) = self.frame_type {
3074 return 1;
3075 }
3076 0
3077 }
3078 }
3079
3080 impl fidl::encoding::ValueTypeMarker for Frame {
3081 type Borrowed<'a> = &'a Self;
3082 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3083 value
3084 }
3085 }
3086
3087 unsafe impl fidl::encoding::TypeMarker for Frame {
3088 type Owned = Self;
3089
3090 #[inline(always)]
3091 fn inline_align(_context: fidl::encoding::Context) -> usize {
3092 8
3093 }
3094
3095 #[inline(always)]
3096 fn inline_size(_context: fidl::encoding::Context) -> usize {
3097 16
3098 }
3099 }
3100
3101 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Frame, D> for &Frame {
3102 unsafe fn encode(
3103 self,
3104 encoder: &mut fidl::encoding::Encoder<'_, D>,
3105 offset: usize,
3106 mut depth: fidl::encoding::Depth,
3107 ) -> fidl::Result<()> {
3108 encoder.debug_check_bounds::<Frame>(offset);
3109 let max_ordinal: u64 = self.max_ordinal_present();
3111 encoder.write_num(max_ordinal, offset);
3112 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3113 if max_ordinal == 0 {
3115 return Ok(());
3116 }
3117 depth.increment()?;
3118 let envelope_size = 8;
3119 let bytes_len = max_ordinal as usize * envelope_size;
3120 #[allow(unused_variables)]
3121 let offset = encoder.out_of_line_offset(bytes_len);
3122 let mut _prev_end_offset: usize = 0;
3123 if 1 > max_ordinal {
3124 return Ok(());
3125 }
3126
3127 let cur_offset: usize = (1 - 1) * envelope_size;
3130
3131 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3133
3134 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_network__common::FrameType, D>(
3139 self.frame_type.as_ref().map(<fidl_fuchsia_hardware_network__common::FrameType as fidl::encoding::ValueTypeMarker>::borrow),
3140 encoder, offset + cur_offset, depth
3141 )?;
3142
3143 _prev_end_offset = cur_offset + envelope_size;
3144 if 2 > max_ordinal {
3145 return Ok(());
3146 }
3147
3148 let cur_offset: usize = (2 - 1) * envelope_size;
3151
3152 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3154
3155 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 16384>, D>(
3160 self.data.as_ref().map(
3161 <fidl::encoding::Vector<u8, 16384> as fidl::encoding::ValueTypeMarker>::borrow,
3162 ),
3163 encoder,
3164 offset + cur_offset,
3165 depth,
3166 )?;
3167
3168 _prev_end_offset = cur_offset + envelope_size;
3169 if 3 > max_ordinal {
3170 return Ok(());
3171 }
3172
3173 let cur_offset: usize = (3 - 1) * envelope_size;
3176
3177 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3179
3180 fidl::encoding::encode_in_envelope_optional::<FrameMetadata, D>(
3185 self.meta.as_ref().map(<FrameMetadata as fidl::encoding::ValueTypeMarker>::borrow),
3186 encoder,
3187 offset + cur_offset,
3188 depth,
3189 )?;
3190
3191 _prev_end_offset = cur_offset + envelope_size;
3192 if 4 > max_ordinal {
3193 return Ok(());
3194 }
3195
3196 let cur_offset: usize = (4 - 1) * envelope_size;
3199
3200 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3202
3203 fidl::encoding::encode_in_envelope_optional::<u8, D>(
3208 self.port.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
3209 encoder,
3210 offset + cur_offset,
3211 depth,
3212 )?;
3213
3214 _prev_end_offset = cur_offset + envelope_size;
3215
3216 Ok(())
3217 }
3218 }
3219
3220 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Frame {
3221 #[inline(always)]
3222 fn new_empty() -> Self {
3223 Self::default()
3224 }
3225
3226 unsafe fn decode(
3227 &mut self,
3228 decoder: &mut fidl::encoding::Decoder<'_, D>,
3229 offset: usize,
3230 mut depth: fidl::encoding::Depth,
3231 ) -> fidl::Result<()> {
3232 decoder.debug_check_bounds::<Self>(offset);
3233 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3234 None => return Err(fidl::Error::NotNullable),
3235 Some(len) => len,
3236 };
3237 if len == 0 {
3239 return Ok(());
3240 };
3241 depth.increment()?;
3242 let envelope_size = 8;
3243 let bytes_len = len * envelope_size;
3244 let offset = decoder.out_of_line_offset(bytes_len)?;
3245 let mut _next_ordinal_to_read = 0;
3247 let mut next_offset = offset;
3248 let end_offset = offset + bytes_len;
3249 _next_ordinal_to_read += 1;
3250 if next_offset >= end_offset {
3251 return Ok(());
3252 }
3253
3254 while _next_ordinal_to_read < 1 {
3256 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3257 _next_ordinal_to_read += 1;
3258 next_offset += envelope_size;
3259 }
3260
3261 let next_out_of_line = decoder.next_out_of_line();
3262 let handles_before = decoder.remaining_handles();
3263 if let Some((inlined, num_bytes, num_handles)) =
3264 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3265 {
3266 let member_inline_size = <fidl_fuchsia_hardware_network__common::FrameType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3267 if inlined != (member_inline_size <= 4) {
3268 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3269 }
3270 let inner_offset;
3271 let mut inner_depth = depth.clone();
3272 if inlined {
3273 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3274 inner_offset = next_offset;
3275 } else {
3276 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3277 inner_depth.increment()?;
3278 }
3279 let val_ref = self.frame_type.get_or_insert_with(|| {
3280 fidl::new_empty!(fidl_fuchsia_hardware_network__common::FrameType, D)
3281 });
3282 fidl::decode!(
3283 fidl_fuchsia_hardware_network__common::FrameType,
3284 D,
3285 val_ref,
3286 decoder,
3287 inner_offset,
3288 inner_depth
3289 )?;
3290 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3291 {
3292 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3293 }
3294 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3295 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3296 }
3297 }
3298
3299 next_offset += envelope_size;
3300 _next_ordinal_to_read += 1;
3301 if next_offset >= end_offset {
3302 return Ok(());
3303 }
3304
3305 while _next_ordinal_to_read < 2 {
3307 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3308 _next_ordinal_to_read += 1;
3309 next_offset += envelope_size;
3310 }
3311
3312 let next_out_of_line = decoder.next_out_of_line();
3313 let handles_before = decoder.remaining_handles();
3314 if let Some((inlined, num_bytes, num_handles)) =
3315 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3316 {
3317 let member_inline_size =
3318 <fidl::encoding::Vector<u8, 16384> as fidl::encoding::TypeMarker>::inline_size(
3319 decoder.context,
3320 );
3321 if inlined != (member_inline_size <= 4) {
3322 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3323 }
3324 let inner_offset;
3325 let mut inner_depth = depth.clone();
3326 if inlined {
3327 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3328 inner_offset = next_offset;
3329 } else {
3330 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3331 inner_depth.increment()?;
3332 }
3333 let val_ref = self
3334 .data
3335 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 16384>, D));
3336 fidl::decode!(fidl::encoding::Vector<u8, 16384>, D, val_ref, decoder, inner_offset, inner_depth)?;
3337 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3338 {
3339 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3340 }
3341 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3342 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3343 }
3344 }
3345
3346 next_offset += envelope_size;
3347 _next_ordinal_to_read += 1;
3348 if next_offset >= end_offset {
3349 return Ok(());
3350 }
3351
3352 while _next_ordinal_to_read < 3 {
3354 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3355 _next_ordinal_to_read += 1;
3356 next_offset += envelope_size;
3357 }
3358
3359 let next_out_of_line = decoder.next_out_of_line();
3360 let handles_before = decoder.remaining_handles();
3361 if let Some((inlined, num_bytes, num_handles)) =
3362 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3363 {
3364 let member_inline_size =
3365 <FrameMetadata as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3366 if inlined != (member_inline_size <= 4) {
3367 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3368 }
3369 let inner_offset;
3370 let mut inner_depth = depth.clone();
3371 if inlined {
3372 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3373 inner_offset = next_offset;
3374 } else {
3375 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3376 inner_depth.increment()?;
3377 }
3378 let val_ref = self.meta.get_or_insert_with(|| fidl::new_empty!(FrameMetadata, D));
3379 fidl::decode!(FrameMetadata, D, val_ref, decoder, inner_offset, inner_depth)?;
3380 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3381 {
3382 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3383 }
3384 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3385 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3386 }
3387 }
3388
3389 next_offset += envelope_size;
3390 _next_ordinal_to_read += 1;
3391 if next_offset >= end_offset {
3392 return Ok(());
3393 }
3394
3395 while _next_ordinal_to_read < 4 {
3397 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3398 _next_ordinal_to_read += 1;
3399 next_offset += envelope_size;
3400 }
3401
3402 let next_out_of_line = decoder.next_out_of_line();
3403 let handles_before = decoder.remaining_handles();
3404 if let Some((inlined, num_bytes, num_handles)) =
3405 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3406 {
3407 let member_inline_size =
3408 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3409 if inlined != (member_inline_size <= 4) {
3410 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3411 }
3412 let inner_offset;
3413 let mut inner_depth = depth.clone();
3414 if inlined {
3415 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3416 inner_offset = next_offset;
3417 } else {
3418 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3419 inner_depth.increment()?;
3420 }
3421 let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u8, D));
3422 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3423 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3424 {
3425 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3426 }
3427 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3428 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3429 }
3430 }
3431
3432 next_offset += envelope_size;
3433
3434 while next_offset < end_offset {
3436 _next_ordinal_to_read += 1;
3437 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3438 next_offset += envelope_size;
3439 }
3440
3441 Ok(())
3442 }
3443 }
3444
3445 impl InternalState {
3446 #[inline(always)]
3447 fn max_ordinal_present(&self) -> u64 {
3448 if let Some(_) = self.has_session {
3449 return 2;
3450 }
3451 if let Some(_) = self.mac {
3452 return 1;
3453 }
3454 0
3455 }
3456 }
3457
3458 impl fidl::encoding::ValueTypeMarker for InternalState {
3459 type Borrowed<'a> = &'a Self;
3460 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3461 value
3462 }
3463 }
3464
3465 unsafe impl fidl::encoding::TypeMarker for InternalState {
3466 type Owned = Self;
3467
3468 #[inline(always)]
3469 fn inline_align(_context: fidl::encoding::Context) -> usize {
3470 8
3471 }
3472
3473 #[inline(always)]
3474 fn inline_size(_context: fidl::encoding::Context) -> usize {
3475 16
3476 }
3477 }
3478
3479 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InternalState, D>
3480 for &InternalState
3481 {
3482 unsafe fn encode(
3483 self,
3484 encoder: &mut fidl::encoding::Encoder<'_, D>,
3485 offset: usize,
3486 mut depth: fidl::encoding::Depth,
3487 ) -> fidl::Result<()> {
3488 encoder.debug_check_bounds::<InternalState>(offset);
3489 let max_ordinal: u64 = self.max_ordinal_present();
3491 encoder.write_num(max_ordinal, offset);
3492 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3493 if max_ordinal == 0 {
3495 return Ok(());
3496 }
3497 depth.increment()?;
3498 let envelope_size = 8;
3499 let bytes_len = max_ordinal as usize * envelope_size;
3500 #[allow(unused_variables)]
3501 let offset = encoder.out_of_line_offset(bytes_len);
3502 let mut _prev_end_offset: usize = 0;
3503 if 1 > max_ordinal {
3504 return Ok(());
3505 }
3506
3507 let cur_offset: usize = (1 - 1) * envelope_size;
3510
3511 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3513
3514 fidl::encoding::encode_in_envelope_optional::<MacState, D>(
3519 self.mac.as_ref().map(<MacState as fidl::encoding::ValueTypeMarker>::borrow),
3520 encoder,
3521 offset + cur_offset,
3522 depth,
3523 )?;
3524
3525 _prev_end_offset = cur_offset + envelope_size;
3526 if 2 > max_ordinal {
3527 return Ok(());
3528 }
3529
3530 let cur_offset: usize = (2 - 1) * envelope_size;
3533
3534 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3536
3537 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3542 self.has_session.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3543 encoder,
3544 offset + cur_offset,
3545 depth,
3546 )?;
3547
3548 _prev_end_offset = cur_offset + envelope_size;
3549
3550 Ok(())
3551 }
3552 }
3553
3554 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InternalState {
3555 #[inline(always)]
3556 fn new_empty() -> Self {
3557 Self::default()
3558 }
3559
3560 unsafe fn decode(
3561 &mut self,
3562 decoder: &mut fidl::encoding::Decoder<'_, D>,
3563 offset: usize,
3564 mut depth: fidl::encoding::Depth,
3565 ) -> fidl::Result<()> {
3566 decoder.debug_check_bounds::<Self>(offset);
3567 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3568 None => return Err(fidl::Error::NotNullable),
3569 Some(len) => len,
3570 };
3571 if len == 0 {
3573 return Ok(());
3574 };
3575 depth.increment()?;
3576 let envelope_size = 8;
3577 let bytes_len = len * envelope_size;
3578 let offset = decoder.out_of_line_offset(bytes_len)?;
3579 let mut _next_ordinal_to_read = 0;
3581 let mut next_offset = offset;
3582 let end_offset = offset + bytes_len;
3583 _next_ordinal_to_read += 1;
3584 if next_offset >= end_offset {
3585 return Ok(());
3586 }
3587
3588 while _next_ordinal_to_read < 1 {
3590 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3591 _next_ordinal_to_read += 1;
3592 next_offset += envelope_size;
3593 }
3594
3595 let next_out_of_line = decoder.next_out_of_line();
3596 let handles_before = decoder.remaining_handles();
3597 if let Some((inlined, num_bytes, num_handles)) =
3598 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3599 {
3600 let member_inline_size =
3601 <MacState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3602 if inlined != (member_inline_size <= 4) {
3603 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3604 }
3605 let inner_offset;
3606 let mut inner_depth = depth.clone();
3607 if inlined {
3608 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3609 inner_offset = next_offset;
3610 } else {
3611 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3612 inner_depth.increment()?;
3613 }
3614 let val_ref = self.mac.get_or_insert_with(|| fidl::new_empty!(MacState, D));
3615 fidl::decode!(MacState, D, val_ref, decoder, inner_offset, inner_depth)?;
3616 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3617 {
3618 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3619 }
3620 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3621 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3622 }
3623 }
3624
3625 next_offset += envelope_size;
3626 _next_ordinal_to_read += 1;
3627 if next_offset >= end_offset {
3628 return Ok(());
3629 }
3630
3631 while _next_ordinal_to_read < 2 {
3633 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3634 _next_ordinal_to_read += 1;
3635 next_offset += envelope_size;
3636 }
3637
3638 let next_out_of_line = decoder.next_out_of_line();
3639 let handles_before = decoder.remaining_handles();
3640 if let Some((inlined, num_bytes, num_handles)) =
3641 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3642 {
3643 let member_inline_size =
3644 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3645 if inlined != (member_inline_size <= 4) {
3646 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3647 }
3648 let inner_offset;
3649 let mut inner_depth = depth.clone();
3650 if inlined {
3651 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3652 inner_offset = next_offset;
3653 } else {
3654 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3655 inner_depth.increment()?;
3656 }
3657 let val_ref = self.has_session.get_or_insert_with(|| fidl::new_empty!(bool, D));
3658 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3659 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3660 {
3661 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3662 }
3663 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3664 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3665 }
3666 }
3667
3668 next_offset += envelope_size;
3669
3670 while next_offset < end_offset {
3672 _next_ordinal_to_read += 1;
3673 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3674 next_offset += envelope_size;
3675 }
3676
3677 Ok(())
3678 }
3679 }
3680
3681 impl MacState {
3682 #[inline(always)]
3683 fn max_ordinal_present(&self) -> u64 {
3684 if let Some(_) = self.multicast_filters {
3685 return 2;
3686 }
3687 if let Some(_) = self.mode {
3688 return 1;
3689 }
3690 0
3691 }
3692 }
3693
3694 impl fidl::encoding::ValueTypeMarker for MacState {
3695 type Borrowed<'a> = &'a Self;
3696 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3697 value
3698 }
3699 }
3700
3701 unsafe impl fidl::encoding::TypeMarker for MacState {
3702 type Owned = Self;
3703
3704 #[inline(always)]
3705 fn inline_align(_context: fidl::encoding::Context) -> usize {
3706 8
3707 }
3708
3709 #[inline(always)]
3710 fn inline_size(_context: fidl::encoding::Context) -> usize {
3711 16
3712 }
3713 }
3714
3715 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MacState, D> for &MacState {
3716 unsafe fn encode(
3717 self,
3718 encoder: &mut fidl::encoding::Encoder<'_, D>,
3719 offset: usize,
3720 mut depth: fidl::encoding::Depth,
3721 ) -> fidl::Result<()> {
3722 encoder.debug_check_bounds::<MacState>(offset);
3723 let max_ordinal: u64 = self.max_ordinal_present();
3725 encoder.write_num(max_ordinal, offset);
3726 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3727 if max_ordinal == 0 {
3729 return Ok(());
3730 }
3731 depth.increment()?;
3732 let envelope_size = 8;
3733 let bytes_len = max_ordinal as usize * envelope_size;
3734 #[allow(unused_variables)]
3735 let offset = encoder.out_of_line_offset(bytes_len);
3736 let mut _prev_end_offset: usize = 0;
3737 if 1 > max_ordinal {
3738 return Ok(());
3739 }
3740
3741 let cur_offset: usize = (1 - 1) * envelope_size;
3744
3745 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3747
3748 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_network__common::MacFilterMode, D>(
3753 self.mode.as_ref().map(<fidl_fuchsia_hardware_network__common::MacFilterMode as fidl::encoding::ValueTypeMarker>::borrow),
3754 encoder, offset + cur_offset, depth
3755 )?;
3756
3757 _prev_end_offset = cur_offset + envelope_size;
3758 if 2 > max_ordinal {
3759 return Ok(());
3760 }
3761
3762 let cur_offset: usize = (2 - 1) * envelope_size;
3765
3766 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3768
3769 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64>, D>(
3774 self.multicast_filters.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3775 encoder, offset + cur_offset, depth
3776 )?;
3777
3778 _prev_end_offset = cur_offset + envelope_size;
3779
3780 Ok(())
3781 }
3782 }
3783
3784 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacState {
3785 #[inline(always)]
3786 fn new_empty() -> Self {
3787 Self::default()
3788 }
3789
3790 unsafe fn decode(
3791 &mut self,
3792 decoder: &mut fidl::encoding::Decoder<'_, D>,
3793 offset: usize,
3794 mut depth: fidl::encoding::Depth,
3795 ) -> fidl::Result<()> {
3796 decoder.debug_check_bounds::<Self>(offset);
3797 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3798 None => return Err(fidl::Error::NotNullable),
3799 Some(len) => len,
3800 };
3801 if len == 0 {
3803 return Ok(());
3804 };
3805 depth.increment()?;
3806 let envelope_size = 8;
3807 let bytes_len = len * envelope_size;
3808 let offset = decoder.out_of_line_offset(bytes_len)?;
3809 let mut _next_ordinal_to_read = 0;
3811 let mut next_offset = offset;
3812 let end_offset = offset + bytes_len;
3813 _next_ordinal_to_read += 1;
3814 if next_offset >= end_offset {
3815 return Ok(());
3816 }
3817
3818 while _next_ordinal_to_read < 1 {
3820 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3821 _next_ordinal_to_read += 1;
3822 next_offset += envelope_size;
3823 }
3824
3825 let next_out_of_line = decoder.next_out_of_line();
3826 let handles_before = decoder.remaining_handles();
3827 if let Some((inlined, num_bytes, num_handles)) =
3828 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3829 {
3830 let member_inline_size = <fidl_fuchsia_hardware_network__common::MacFilterMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3831 if inlined != (member_inline_size <= 4) {
3832 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3833 }
3834 let inner_offset;
3835 let mut inner_depth = depth.clone();
3836 if inlined {
3837 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3838 inner_offset = next_offset;
3839 } else {
3840 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3841 inner_depth.increment()?;
3842 }
3843 let val_ref = self.mode.get_or_insert_with(|| {
3844 fidl::new_empty!(fidl_fuchsia_hardware_network__common::MacFilterMode, D)
3845 });
3846 fidl::decode!(
3847 fidl_fuchsia_hardware_network__common::MacFilterMode,
3848 D,
3849 val_ref,
3850 decoder,
3851 inner_offset,
3852 inner_depth
3853 )?;
3854 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3855 {
3856 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3857 }
3858 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3859 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3860 }
3861 }
3862
3863 next_offset += envelope_size;
3864 _next_ordinal_to_read += 1;
3865 if next_offset >= end_offset {
3866 return Ok(());
3867 }
3868
3869 while _next_ordinal_to_read < 2 {
3871 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3872 _next_ordinal_to_read += 1;
3873 next_offset += envelope_size;
3874 }
3875
3876 let next_out_of_line = decoder.next_out_of_line();
3877 let handles_before = decoder.remaining_handles();
3878 if let Some((inlined, num_bytes, num_handles)) =
3879 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3880 {
3881 let member_inline_size = <fidl::encoding::Vector<
3882 fidl_fuchsia_net__common::MacAddress,
3883 64,
3884 > as fidl::encoding::TypeMarker>::inline_size(
3885 decoder.context
3886 );
3887 if inlined != (member_inline_size <= 4) {
3888 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3889 }
3890 let inner_offset;
3891 let mut inner_depth = depth.clone();
3892 if inlined {
3893 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3894 inner_offset = next_offset;
3895 } else {
3896 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3897 inner_depth.increment()?;
3898 }
3899 let val_ref =
3900 self.multicast_filters.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64>, D));
3901 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3902 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3903 {
3904 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3905 }
3906 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3907 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3908 }
3909 }
3910
3911 next_offset += envelope_size;
3912
3913 while next_offset < end_offset {
3915 _next_ordinal_to_read += 1;
3916 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3917 next_offset += envelope_size;
3918 }
3919
3920 Ok(())
3921 }
3922 }
3923}