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
327pub mod control_ordinals {
328 pub const CREATE_DEVICE: u64 = 0x2aace38c0c1cd187;
329 pub const CREATE_PAIR: u64 = 0x2c8884060cc29d18;
330}
331
332pub mod device_ordinals {
333 pub const WRITE_FRAME: u64 = 0x2d19e24e149bf6db;
334 pub const READ_FRAME: u64 = 0x6ebc56b8427e1571;
335 pub const GET_SIGNALS: u64 = 0x4d1ca50fc53606b9;
336 pub const ADD_PORT: u64 = 0x6b56b238f04ee3d4;
337 pub const GET_DEVICE: u64 = 0x2e8c81fdcdd99d26;
338 pub const DELEGATE_RX_LEASE: u64 = 0x660137a0e680b4c0;
339}
340
341pub mod device_pair_ordinals {
342 pub const ADD_PORT: u64 = 0x362f4856a075e1f8;
343 pub const REMOVE_PORT: u64 = 0x33bb45cc1d3fbe1e;
344 pub const GET_LEFT: u64 = 0x1357a771a6ccb303;
345 pub const GET_RIGHT: u64 = 0x45ebce063223b60f;
346 pub const GET_LEFT_PORT: u64 = 0x6e3038d75096ab77;
347 pub const GET_RIGHT_PORT: u64 = 0x7fc4716601eb987c;
348}
349
350pub mod port_ordinals {
351 pub const GET_STATE: u64 = 0x5022630816212ed;
352 pub const WATCH_STATE: u64 = 0x74d3c94c96e2b605;
353 pub const SET_ONLINE: u64 = 0x734f83793ce86e6c;
354 pub const GET_PORT: u64 = 0x1998638c1d97eed2;
355 pub const REMOVE: u64 = 0x4f45201ed5719261;
356}
357
358mod internal {
359 use super::*;
360 unsafe impl fidl::encoding::TypeMarker for Signals {
361 type Owned = Self;
362
363 #[inline(always)]
364 fn inline_align(_context: fidl::encoding::Context) -> usize {
365 4
366 }
367
368 #[inline(always)]
369 fn inline_size(_context: fidl::encoding::Context) -> usize {
370 4
371 }
372 }
373
374 impl fidl::encoding::ValueTypeMarker for Signals {
375 type Borrowed<'a> = Self;
376 #[inline(always)]
377 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
378 *value
379 }
380 }
381
382 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Signals {
383 #[inline]
384 unsafe fn encode(
385 self,
386 encoder: &mut fidl::encoding::Encoder<'_, D>,
387 offset: usize,
388 _depth: fidl::encoding::Depth,
389 ) -> fidl::Result<()> {
390 encoder.debug_check_bounds::<Self>(offset);
391 if self.bits() & Self::all().bits() != self.bits() {
392 return Err(fidl::Error::InvalidBitsValue);
393 }
394 encoder.write_num(self.bits(), offset);
395 Ok(())
396 }
397 }
398
399 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Signals {
400 #[inline(always)]
401 fn new_empty() -> Self {
402 Self::empty()
403 }
404
405 #[inline]
406 unsafe fn decode(
407 &mut self,
408 decoder: &mut fidl::encoding::Decoder<'_, D>,
409 offset: usize,
410 _depth: fidl::encoding::Depth,
411 ) -> fidl::Result<()> {
412 decoder.debug_check_bounds::<Self>(offset);
413 let prim = decoder.read_num::<u32>(offset);
414 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
415 Ok(())
416 }
417 }
418
419 impl fidl::encoding::ValueTypeMarker for DevicePairAddPortRequest {
420 type Borrowed<'a> = &'a Self;
421 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
422 value
423 }
424 }
425
426 unsafe impl fidl::encoding::TypeMarker for DevicePairAddPortRequest {
427 type Owned = Self;
428
429 #[inline(always)]
430 fn inline_align(_context: fidl::encoding::Context) -> usize {
431 8
432 }
433
434 #[inline(always)]
435 fn inline_size(_context: fidl::encoding::Context) -> usize {
436 16
437 }
438 }
439
440 unsafe impl<D: fidl::encoding::ResourceDialect>
441 fidl::encoding::Encode<DevicePairAddPortRequest, D> for &DevicePairAddPortRequest
442 {
443 #[inline]
444 unsafe fn encode(
445 self,
446 encoder: &mut fidl::encoding::Encoder<'_, D>,
447 offset: usize,
448 _depth: fidl::encoding::Depth,
449 ) -> fidl::Result<()> {
450 encoder.debug_check_bounds::<DevicePairAddPortRequest>(offset);
451 fidl::encoding::Encode::<DevicePairAddPortRequest, D>::encode(
453 (<DevicePairPortConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.config),),
454 encoder,
455 offset,
456 _depth,
457 )
458 }
459 }
460 unsafe impl<
461 D: fidl::encoding::ResourceDialect,
462 T0: fidl::encoding::Encode<DevicePairPortConfig, D>,
463 > fidl::encoding::Encode<DevicePairAddPortRequest, D> for (T0,)
464 {
465 #[inline]
466 unsafe fn encode(
467 self,
468 encoder: &mut fidl::encoding::Encoder<'_, D>,
469 offset: usize,
470 depth: fidl::encoding::Depth,
471 ) -> fidl::Result<()> {
472 encoder.debug_check_bounds::<DevicePairAddPortRequest>(offset);
473 self.0.encode(encoder, offset + 0, depth)?;
477 Ok(())
478 }
479 }
480
481 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
482 for DevicePairAddPortRequest
483 {
484 #[inline(always)]
485 fn new_empty() -> Self {
486 Self { config: fidl::new_empty!(DevicePairPortConfig, D) }
487 }
488
489 #[inline]
490 unsafe fn decode(
491 &mut self,
492 decoder: &mut fidl::encoding::Decoder<'_, D>,
493 offset: usize,
494 _depth: fidl::encoding::Depth,
495 ) -> fidl::Result<()> {
496 decoder.debug_check_bounds::<Self>(offset);
497 fidl::decode!(DevicePairPortConfig, D, &mut self.config, decoder, offset + 0, _depth)?;
499 Ok(())
500 }
501 }
502
503 impl fidl::encoding::ValueTypeMarker for DevicePairRemovePortRequest {
504 type Borrowed<'a> = &'a Self;
505 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
506 value
507 }
508 }
509
510 unsafe impl fidl::encoding::TypeMarker for DevicePairRemovePortRequest {
511 type Owned = Self;
512
513 #[inline(always)]
514 fn inline_align(_context: fidl::encoding::Context) -> usize {
515 1
516 }
517
518 #[inline(always)]
519 fn inline_size(_context: fidl::encoding::Context) -> usize {
520 1
521 }
522 #[inline(always)]
523 fn encode_is_copy() -> bool {
524 true
525 }
526
527 #[inline(always)]
528 fn decode_is_copy() -> bool {
529 true
530 }
531 }
532
533 unsafe impl<D: fidl::encoding::ResourceDialect>
534 fidl::encoding::Encode<DevicePairRemovePortRequest, D> for &DevicePairRemovePortRequest
535 {
536 #[inline]
537 unsafe fn encode(
538 self,
539 encoder: &mut fidl::encoding::Encoder<'_, D>,
540 offset: usize,
541 _depth: fidl::encoding::Depth,
542 ) -> fidl::Result<()> {
543 encoder.debug_check_bounds::<DevicePairRemovePortRequest>(offset);
544 unsafe {
545 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
547 (buf_ptr as *mut DevicePairRemovePortRequest)
548 .write_unaligned((self as *const DevicePairRemovePortRequest).read());
549 }
552 Ok(())
553 }
554 }
555 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
556 fidl::encoding::Encode<DevicePairRemovePortRequest, D> for (T0,)
557 {
558 #[inline]
559 unsafe fn encode(
560 self,
561 encoder: &mut fidl::encoding::Encoder<'_, D>,
562 offset: usize,
563 depth: fidl::encoding::Depth,
564 ) -> fidl::Result<()> {
565 encoder.debug_check_bounds::<DevicePairRemovePortRequest>(offset);
566 self.0.encode(encoder, offset + 0, depth)?;
570 Ok(())
571 }
572 }
573
574 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
575 for DevicePairRemovePortRequest
576 {
577 #[inline(always)]
578 fn new_empty() -> Self {
579 Self { id: fidl::new_empty!(u8, D) }
580 }
581
582 #[inline]
583 unsafe fn decode(
584 &mut self,
585 decoder: &mut fidl::encoding::Decoder<'_, D>,
586 offset: usize,
587 _depth: fidl::encoding::Depth,
588 ) -> fidl::Result<()> {
589 decoder.debug_check_bounds::<Self>(offset);
590 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
591 unsafe {
594 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
595 }
596 Ok(())
597 }
598 }
599
600 impl fidl::encoding::ValueTypeMarker for DeviceWriteFrameRequest {
601 type Borrowed<'a> = &'a Self;
602 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
603 value
604 }
605 }
606
607 unsafe impl fidl::encoding::TypeMarker for DeviceWriteFrameRequest {
608 type Owned = Self;
609
610 #[inline(always)]
611 fn inline_align(_context: fidl::encoding::Context) -> usize {
612 8
613 }
614
615 #[inline(always)]
616 fn inline_size(_context: fidl::encoding::Context) -> usize {
617 16
618 }
619 }
620
621 unsafe impl<D: fidl::encoding::ResourceDialect>
622 fidl::encoding::Encode<DeviceWriteFrameRequest, D> for &DeviceWriteFrameRequest
623 {
624 #[inline]
625 unsafe fn encode(
626 self,
627 encoder: &mut fidl::encoding::Encoder<'_, D>,
628 offset: usize,
629 _depth: fidl::encoding::Depth,
630 ) -> fidl::Result<()> {
631 encoder.debug_check_bounds::<DeviceWriteFrameRequest>(offset);
632 fidl::encoding::Encode::<DeviceWriteFrameRequest, D>::encode(
634 (<Frame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
635 encoder,
636 offset,
637 _depth,
638 )
639 }
640 }
641 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Frame, D>>
642 fidl::encoding::Encode<DeviceWriteFrameRequest, D> for (T0,)
643 {
644 #[inline]
645 unsafe fn encode(
646 self,
647 encoder: &mut fidl::encoding::Encoder<'_, D>,
648 offset: usize,
649 depth: fidl::encoding::Depth,
650 ) -> fidl::Result<()> {
651 encoder.debug_check_bounds::<DeviceWriteFrameRequest>(offset);
652 self.0.encode(encoder, offset + 0, depth)?;
656 Ok(())
657 }
658 }
659
660 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
661 for DeviceWriteFrameRequest
662 {
663 #[inline(always)]
664 fn new_empty() -> Self {
665 Self { frame: fidl::new_empty!(Frame, D) }
666 }
667
668 #[inline]
669 unsafe fn decode(
670 &mut self,
671 decoder: &mut fidl::encoding::Decoder<'_, D>,
672 offset: usize,
673 _depth: fidl::encoding::Depth,
674 ) -> fidl::Result<()> {
675 decoder.debug_check_bounds::<Self>(offset);
676 fidl::decode!(Frame, D, &mut self.frame, decoder, offset + 0, _depth)?;
678 Ok(())
679 }
680 }
681
682 impl fidl::encoding::ValueTypeMarker for DeviceReadFrameResponse {
683 type Borrowed<'a> = &'a Self;
684 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
685 value
686 }
687 }
688
689 unsafe impl fidl::encoding::TypeMarker for DeviceReadFrameResponse {
690 type Owned = Self;
691
692 #[inline(always)]
693 fn inline_align(_context: fidl::encoding::Context) -> usize {
694 8
695 }
696
697 #[inline(always)]
698 fn inline_size(_context: fidl::encoding::Context) -> usize {
699 16
700 }
701 }
702
703 unsafe impl<D: fidl::encoding::ResourceDialect>
704 fidl::encoding::Encode<DeviceReadFrameResponse, D> for &DeviceReadFrameResponse
705 {
706 #[inline]
707 unsafe fn encode(
708 self,
709 encoder: &mut fidl::encoding::Encoder<'_, D>,
710 offset: usize,
711 _depth: fidl::encoding::Depth,
712 ) -> fidl::Result<()> {
713 encoder.debug_check_bounds::<DeviceReadFrameResponse>(offset);
714 fidl::encoding::Encode::<DeviceReadFrameResponse, D>::encode(
716 (<Frame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
717 encoder,
718 offset,
719 _depth,
720 )
721 }
722 }
723 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Frame, D>>
724 fidl::encoding::Encode<DeviceReadFrameResponse, D> for (T0,)
725 {
726 #[inline]
727 unsafe fn encode(
728 self,
729 encoder: &mut fidl::encoding::Encoder<'_, D>,
730 offset: usize,
731 depth: fidl::encoding::Depth,
732 ) -> fidl::Result<()> {
733 encoder.debug_check_bounds::<DeviceReadFrameResponse>(offset);
734 self.0.encode(encoder, offset + 0, depth)?;
738 Ok(())
739 }
740 }
741
742 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
743 for DeviceReadFrameResponse
744 {
745 #[inline(always)]
746 fn new_empty() -> Self {
747 Self { frame: fidl::new_empty!(Frame, D) }
748 }
749
750 #[inline]
751 unsafe fn decode(
752 &mut self,
753 decoder: &mut fidl::encoding::Decoder<'_, D>,
754 offset: usize,
755 _depth: fidl::encoding::Depth,
756 ) -> fidl::Result<()> {
757 decoder.debug_check_bounds::<Self>(offset);
758 fidl::decode!(Frame, D, &mut self.frame, decoder, offset + 0, _depth)?;
760 Ok(())
761 }
762 }
763
764 impl fidl::encoding::ValueTypeMarker for FrameMetadata {
765 type Borrowed<'a> = &'a Self;
766 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
767 value
768 }
769 }
770
771 unsafe impl fidl::encoding::TypeMarker for FrameMetadata {
772 type Owned = Self;
773
774 #[inline(always)]
775 fn inline_align(_context: fidl::encoding::Context) -> usize {
776 8
777 }
778
779 #[inline(always)]
780 fn inline_size(_context: fidl::encoding::Context) -> usize {
781 32
782 }
783 }
784
785 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FrameMetadata, D>
786 for &FrameMetadata
787 {
788 #[inline]
789 unsafe fn encode(
790 self,
791 encoder: &mut fidl::encoding::Encoder<'_, D>,
792 offset: usize,
793 _depth: fidl::encoding::Depth,
794 ) -> fidl::Result<()> {
795 encoder.debug_check_bounds::<FrameMetadata>(offset);
796 fidl::encoding::Encode::<FrameMetadata, D>::encode(
798 (
799 <fidl_fuchsia_hardware_network__common::InfoType as fidl::encoding::ValueTypeMarker>::borrow(&self.info_type),
800 <fidl::encoding::Vector<u8, 4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.info),
801 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
802 ),
803 encoder, offset, _depth
804 )
805 }
806 }
807 unsafe impl<
808 D: fidl::encoding::ResourceDialect,
809 T0: fidl::encoding::Encode<fidl_fuchsia_hardware_network__common::InfoType, D>,
810 T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 4096>, D>,
811 T2: fidl::encoding::Encode<u32, D>,
812 > fidl::encoding::Encode<FrameMetadata, D> for (T0, T1, T2)
813 {
814 #[inline]
815 unsafe fn encode(
816 self,
817 encoder: &mut fidl::encoding::Encoder<'_, D>,
818 offset: usize,
819 depth: fidl::encoding::Depth,
820 ) -> fidl::Result<()> {
821 encoder.debug_check_bounds::<FrameMetadata>(offset);
822 unsafe {
825 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
826 (ptr as *mut u64).write_unaligned(0);
827 }
828 unsafe {
829 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
830 (ptr as *mut u64).write_unaligned(0);
831 }
832 self.0.encode(encoder, offset + 0, depth)?;
834 self.1.encode(encoder, offset + 8, depth)?;
835 self.2.encode(encoder, offset + 24, depth)?;
836 Ok(())
837 }
838 }
839
840 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameMetadata {
841 #[inline(always)]
842 fn new_empty() -> Self {
843 Self {
844 info_type: fidl::new_empty!(fidl_fuchsia_hardware_network__common::InfoType, D),
845 info: fidl::new_empty!(fidl::encoding::Vector<u8, 4096>, D),
846 flags: fidl::new_empty!(u32, D),
847 }
848 }
849
850 #[inline]
851 unsafe fn decode(
852 &mut self,
853 decoder: &mut fidl::encoding::Decoder<'_, D>,
854 offset: usize,
855 _depth: fidl::encoding::Depth,
856 ) -> fidl::Result<()> {
857 decoder.debug_check_bounds::<Self>(offset);
858 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
860 let padval = unsafe { (ptr as *const u64).read_unaligned() };
861 let mask = 0xffffffff00000000u64;
862 let maskedval = padval & mask;
863 if maskedval != 0 {
864 return Err(fidl::Error::NonZeroPadding {
865 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
866 });
867 }
868 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
869 let padval = unsafe { (ptr as *const u64).read_unaligned() };
870 let mask = 0xffffffff00000000u64;
871 let maskedval = padval & mask;
872 if maskedval != 0 {
873 return Err(fidl::Error::NonZeroPadding {
874 padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
875 });
876 }
877 fidl::decode!(
878 fidl_fuchsia_hardware_network__common::InfoType,
879 D,
880 &mut self.info_type,
881 decoder,
882 offset + 0,
883 _depth
884 )?;
885 fidl::decode!(fidl::encoding::Vector<u8, 4096>, D, &mut self.info, decoder, offset + 8, _depth)?;
886 fidl::decode!(u32, D, &mut self.flags, decoder, offset + 24, _depth)?;
887 Ok(())
888 }
889 }
890
891 impl fidl::encoding::ValueTypeMarker for PortGetStateResponse {
892 type Borrowed<'a> = &'a Self;
893 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
894 value
895 }
896 }
897
898 unsafe impl fidl::encoding::TypeMarker for PortGetStateResponse {
899 type Owned = Self;
900
901 #[inline(always)]
902 fn inline_align(_context: fidl::encoding::Context) -> usize {
903 8
904 }
905
906 #[inline(always)]
907 fn inline_size(_context: fidl::encoding::Context) -> usize {
908 16
909 }
910 }
911
912 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PortGetStateResponse, D>
913 for &PortGetStateResponse
914 {
915 #[inline]
916 unsafe fn encode(
917 self,
918 encoder: &mut fidl::encoding::Encoder<'_, D>,
919 offset: usize,
920 _depth: fidl::encoding::Depth,
921 ) -> fidl::Result<()> {
922 encoder.debug_check_bounds::<PortGetStateResponse>(offset);
923 fidl::encoding::Encode::<PortGetStateResponse, D>::encode(
925 (<InternalState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
926 encoder,
927 offset,
928 _depth,
929 )
930 }
931 }
932 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<InternalState, D>>
933 fidl::encoding::Encode<PortGetStateResponse, D> for (T0,)
934 {
935 #[inline]
936 unsafe fn encode(
937 self,
938 encoder: &mut fidl::encoding::Encoder<'_, D>,
939 offset: usize,
940 depth: fidl::encoding::Depth,
941 ) -> fidl::Result<()> {
942 encoder.debug_check_bounds::<PortGetStateResponse>(offset);
943 self.0.encode(encoder, offset + 0, depth)?;
947 Ok(())
948 }
949 }
950
951 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PortGetStateResponse {
952 #[inline(always)]
953 fn new_empty() -> Self {
954 Self { state: fidl::new_empty!(InternalState, D) }
955 }
956
957 #[inline]
958 unsafe fn decode(
959 &mut self,
960 decoder: &mut fidl::encoding::Decoder<'_, D>,
961 offset: usize,
962 _depth: fidl::encoding::Depth,
963 ) -> fidl::Result<()> {
964 decoder.debug_check_bounds::<Self>(offset);
965 fidl::decode!(InternalState, D, &mut self.state, decoder, offset + 0, _depth)?;
967 Ok(())
968 }
969 }
970
971 impl fidl::encoding::ValueTypeMarker for PortSetOnlineRequest {
972 type Borrowed<'a> = &'a Self;
973 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
974 value
975 }
976 }
977
978 unsafe impl fidl::encoding::TypeMarker for PortSetOnlineRequest {
979 type Owned = Self;
980
981 #[inline(always)]
982 fn inline_align(_context: fidl::encoding::Context) -> usize {
983 1
984 }
985
986 #[inline(always)]
987 fn inline_size(_context: fidl::encoding::Context) -> usize {
988 1
989 }
990 }
991
992 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PortSetOnlineRequest, D>
993 for &PortSetOnlineRequest
994 {
995 #[inline]
996 unsafe fn encode(
997 self,
998 encoder: &mut fidl::encoding::Encoder<'_, D>,
999 offset: usize,
1000 _depth: fidl::encoding::Depth,
1001 ) -> fidl::Result<()> {
1002 encoder.debug_check_bounds::<PortSetOnlineRequest>(offset);
1003 fidl::encoding::Encode::<PortSetOnlineRequest, D>::encode(
1005 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.online),),
1006 encoder,
1007 offset,
1008 _depth,
1009 )
1010 }
1011 }
1012 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1013 fidl::encoding::Encode<PortSetOnlineRequest, D> for (T0,)
1014 {
1015 #[inline]
1016 unsafe fn encode(
1017 self,
1018 encoder: &mut fidl::encoding::Encoder<'_, D>,
1019 offset: usize,
1020 depth: fidl::encoding::Depth,
1021 ) -> fidl::Result<()> {
1022 encoder.debug_check_bounds::<PortSetOnlineRequest>(offset);
1023 self.0.encode(encoder, offset + 0, depth)?;
1027 Ok(())
1028 }
1029 }
1030
1031 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PortSetOnlineRequest {
1032 #[inline(always)]
1033 fn new_empty() -> Self {
1034 Self { online: fidl::new_empty!(bool, D) }
1035 }
1036
1037 #[inline]
1038 unsafe fn decode(
1039 &mut self,
1040 decoder: &mut fidl::encoding::Decoder<'_, D>,
1041 offset: usize,
1042 _depth: fidl::encoding::Depth,
1043 ) -> fidl::Result<()> {
1044 decoder.debug_check_bounds::<Self>(offset);
1045 fidl::decode!(bool, D, &mut self.online, decoder, offset + 0, _depth)?;
1047 Ok(())
1048 }
1049 }
1050
1051 impl fidl::encoding::ValueTypeMarker for PortWatchStateResponse {
1052 type Borrowed<'a> = &'a Self;
1053 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1054 value
1055 }
1056 }
1057
1058 unsafe impl fidl::encoding::TypeMarker for PortWatchStateResponse {
1059 type Owned = Self;
1060
1061 #[inline(always)]
1062 fn inline_align(_context: fidl::encoding::Context) -> usize {
1063 8
1064 }
1065
1066 #[inline(always)]
1067 fn inline_size(_context: fidl::encoding::Context) -> usize {
1068 16
1069 }
1070 }
1071
1072 unsafe impl<D: fidl::encoding::ResourceDialect>
1073 fidl::encoding::Encode<PortWatchStateResponse, D> for &PortWatchStateResponse
1074 {
1075 #[inline]
1076 unsafe fn encode(
1077 self,
1078 encoder: &mut fidl::encoding::Encoder<'_, D>,
1079 offset: usize,
1080 _depth: fidl::encoding::Depth,
1081 ) -> fidl::Result<()> {
1082 encoder.debug_check_bounds::<PortWatchStateResponse>(offset);
1083 fidl::encoding::Encode::<PortWatchStateResponse, D>::encode(
1085 (<InternalState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
1086 encoder,
1087 offset,
1088 _depth,
1089 )
1090 }
1091 }
1092 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<InternalState, D>>
1093 fidl::encoding::Encode<PortWatchStateResponse, D> for (T0,)
1094 {
1095 #[inline]
1096 unsafe fn encode(
1097 self,
1098 encoder: &mut fidl::encoding::Encoder<'_, D>,
1099 offset: usize,
1100 depth: fidl::encoding::Depth,
1101 ) -> fidl::Result<()> {
1102 encoder.debug_check_bounds::<PortWatchStateResponse>(offset);
1103 self.0.encode(encoder, offset + 0, depth)?;
1107 Ok(())
1108 }
1109 }
1110
1111 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1112 for PortWatchStateResponse
1113 {
1114 #[inline(always)]
1115 fn new_empty() -> Self {
1116 Self { state: fidl::new_empty!(InternalState, D) }
1117 }
1118
1119 #[inline]
1120 unsafe fn decode(
1121 &mut self,
1122 decoder: &mut fidl::encoding::Decoder<'_, D>,
1123 offset: usize,
1124 _depth: fidl::encoding::Depth,
1125 ) -> fidl::Result<()> {
1126 decoder.debug_check_bounds::<Self>(offset);
1127 fidl::decode!(InternalState, D, &mut self.state, decoder, offset + 0, _depth)?;
1129 Ok(())
1130 }
1131 }
1132
1133 impl BaseDeviceConfig {
1134 #[inline(always)]
1135 fn max_ordinal_present(&self) -> u64 {
1136 if let Some(_) = self.min_rx_buffer_length {
1137 return 3;
1138 }
1139 if let Some(_) = self.min_tx_buffer_length {
1140 return 2;
1141 }
1142 if let Some(_) = self.report_metadata {
1143 return 1;
1144 }
1145 0
1146 }
1147 }
1148
1149 impl fidl::encoding::ValueTypeMarker for BaseDeviceConfig {
1150 type Borrowed<'a> = &'a Self;
1151 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1152 value
1153 }
1154 }
1155
1156 unsafe impl fidl::encoding::TypeMarker for BaseDeviceConfig {
1157 type Owned = Self;
1158
1159 #[inline(always)]
1160 fn inline_align(_context: fidl::encoding::Context) -> usize {
1161 8
1162 }
1163
1164 #[inline(always)]
1165 fn inline_size(_context: fidl::encoding::Context) -> usize {
1166 16
1167 }
1168 }
1169
1170 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BaseDeviceConfig, D>
1171 for &BaseDeviceConfig
1172 {
1173 unsafe fn encode(
1174 self,
1175 encoder: &mut fidl::encoding::Encoder<'_, D>,
1176 offset: usize,
1177 mut depth: fidl::encoding::Depth,
1178 ) -> fidl::Result<()> {
1179 encoder.debug_check_bounds::<BaseDeviceConfig>(offset);
1180 let max_ordinal: u64 = self.max_ordinal_present();
1182 encoder.write_num(max_ordinal, offset);
1183 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1184 if max_ordinal == 0 {
1186 return Ok(());
1187 }
1188 depth.increment()?;
1189 let envelope_size = 8;
1190 let bytes_len = max_ordinal as usize * envelope_size;
1191 #[allow(unused_variables)]
1192 let offset = encoder.out_of_line_offset(bytes_len);
1193 let mut _prev_end_offset: usize = 0;
1194 if 1 > max_ordinal {
1195 return Ok(());
1196 }
1197
1198 let cur_offset: usize = (1 - 1) * envelope_size;
1201
1202 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1204
1205 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1210 self.report_metadata
1211 .as_ref()
1212 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1213 encoder,
1214 offset + cur_offset,
1215 depth,
1216 )?;
1217
1218 _prev_end_offset = cur_offset + envelope_size;
1219 if 2 > max_ordinal {
1220 return Ok(());
1221 }
1222
1223 let cur_offset: usize = (2 - 1) * envelope_size;
1226
1227 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1229
1230 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1235 self.min_tx_buffer_length
1236 .as_ref()
1237 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1238 encoder,
1239 offset + cur_offset,
1240 depth,
1241 )?;
1242
1243 _prev_end_offset = cur_offset + envelope_size;
1244 if 3 > max_ordinal {
1245 return Ok(());
1246 }
1247
1248 let cur_offset: usize = (3 - 1) * envelope_size;
1251
1252 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1254
1255 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1260 self.min_rx_buffer_length
1261 .as_ref()
1262 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1263 encoder,
1264 offset + cur_offset,
1265 depth,
1266 )?;
1267
1268 _prev_end_offset = cur_offset + envelope_size;
1269
1270 Ok(())
1271 }
1272 }
1273
1274 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BaseDeviceConfig {
1275 #[inline(always)]
1276 fn new_empty() -> Self {
1277 Self::default()
1278 }
1279
1280 unsafe fn decode(
1281 &mut self,
1282 decoder: &mut fidl::encoding::Decoder<'_, D>,
1283 offset: usize,
1284 mut depth: fidl::encoding::Depth,
1285 ) -> fidl::Result<()> {
1286 decoder.debug_check_bounds::<Self>(offset);
1287 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1288 None => return Err(fidl::Error::NotNullable),
1289 Some(len) => len,
1290 };
1291 if len == 0 {
1293 return Ok(());
1294 };
1295 depth.increment()?;
1296 let envelope_size = 8;
1297 let bytes_len = len * envelope_size;
1298 let offset = decoder.out_of_line_offset(bytes_len)?;
1299 let mut _next_ordinal_to_read = 0;
1301 let mut next_offset = offset;
1302 let end_offset = offset + bytes_len;
1303 _next_ordinal_to_read += 1;
1304 if next_offset >= end_offset {
1305 return Ok(());
1306 }
1307
1308 while _next_ordinal_to_read < 1 {
1310 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1311 _next_ordinal_to_read += 1;
1312 next_offset += envelope_size;
1313 }
1314
1315 let next_out_of_line = decoder.next_out_of_line();
1316 let handles_before = decoder.remaining_handles();
1317 if let Some((inlined, num_bytes, num_handles)) =
1318 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1319 {
1320 let member_inline_size =
1321 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1322 if inlined != (member_inline_size <= 4) {
1323 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1324 }
1325 let inner_offset;
1326 let mut inner_depth = depth.clone();
1327 if inlined {
1328 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1329 inner_offset = next_offset;
1330 } else {
1331 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1332 inner_depth.increment()?;
1333 }
1334 let val_ref = self.report_metadata.get_or_insert_with(|| fidl::new_empty!(bool, D));
1335 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1336 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1337 {
1338 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1339 }
1340 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1341 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1342 }
1343 }
1344
1345 next_offset += envelope_size;
1346 _next_ordinal_to_read += 1;
1347 if next_offset >= end_offset {
1348 return Ok(());
1349 }
1350
1351 while _next_ordinal_to_read < 2 {
1353 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1354 _next_ordinal_to_read += 1;
1355 next_offset += envelope_size;
1356 }
1357
1358 let next_out_of_line = decoder.next_out_of_line();
1359 let handles_before = decoder.remaining_handles();
1360 if let Some((inlined, num_bytes, num_handles)) =
1361 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1362 {
1363 let member_inline_size =
1364 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1365 if inlined != (member_inline_size <= 4) {
1366 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1367 }
1368 let inner_offset;
1369 let mut inner_depth = depth.clone();
1370 if inlined {
1371 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1372 inner_offset = next_offset;
1373 } else {
1374 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1375 inner_depth.increment()?;
1376 }
1377 let val_ref =
1378 self.min_tx_buffer_length.get_or_insert_with(|| fidl::new_empty!(u32, D));
1379 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1380 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1381 {
1382 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1383 }
1384 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1385 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1386 }
1387 }
1388
1389 next_offset += envelope_size;
1390 _next_ordinal_to_read += 1;
1391 if next_offset >= end_offset {
1392 return Ok(());
1393 }
1394
1395 while _next_ordinal_to_read < 3 {
1397 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1398 _next_ordinal_to_read += 1;
1399 next_offset += envelope_size;
1400 }
1401
1402 let next_out_of_line = decoder.next_out_of_line();
1403 let handles_before = decoder.remaining_handles();
1404 if let Some((inlined, num_bytes, num_handles)) =
1405 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1406 {
1407 let member_inline_size =
1408 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1409 if inlined != (member_inline_size <= 4) {
1410 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1411 }
1412 let inner_offset;
1413 let mut inner_depth = depth.clone();
1414 if inlined {
1415 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1416 inner_offset = next_offset;
1417 } else {
1418 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1419 inner_depth.increment()?;
1420 }
1421 let val_ref =
1422 self.min_rx_buffer_length.get_or_insert_with(|| fidl::new_empty!(u32, D));
1423 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1424 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1425 {
1426 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1427 }
1428 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1429 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1430 }
1431 }
1432
1433 next_offset += envelope_size;
1434
1435 while next_offset < end_offset {
1437 _next_ordinal_to_read += 1;
1438 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1439 next_offset += envelope_size;
1440 }
1441
1442 Ok(())
1443 }
1444 }
1445
1446 impl BasePortConfig {
1447 #[inline(always)]
1448 fn max_ordinal_present(&self) -> u64 {
1449 if let Some(_) = self.port_class {
1450 return 5;
1451 }
1452 if let Some(_) = self.tx_types {
1453 return 4;
1454 }
1455 if let Some(_) = self.rx_types {
1456 return 3;
1457 }
1458 if let Some(_) = self.mtu {
1459 return 2;
1460 }
1461 if let Some(_) = self.id {
1462 return 1;
1463 }
1464 0
1465 }
1466 }
1467
1468 impl fidl::encoding::ValueTypeMarker for BasePortConfig {
1469 type Borrowed<'a> = &'a Self;
1470 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1471 value
1472 }
1473 }
1474
1475 unsafe impl fidl::encoding::TypeMarker for BasePortConfig {
1476 type Owned = Self;
1477
1478 #[inline(always)]
1479 fn inline_align(_context: fidl::encoding::Context) -> usize {
1480 8
1481 }
1482
1483 #[inline(always)]
1484 fn inline_size(_context: fidl::encoding::Context) -> usize {
1485 16
1486 }
1487 }
1488
1489 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BasePortConfig, D>
1490 for &BasePortConfig
1491 {
1492 unsafe fn encode(
1493 self,
1494 encoder: &mut fidl::encoding::Encoder<'_, D>,
1495 offset: usize,
1496 mut depth: fidl::encoding::Depth,
1497 ) -> fidl::Result<()> {
1498 encoder.debug_check_bounds::<BasePortConfig>(offset);
1499 let max_ordinal: u64 = self.max_ordinal_present();
1501 encoder.write_num(max_ordinal, offset);
1502 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1503 if max_ordinal == 0 {
1505 return Ok(());
1506 }
1507 depth.increment()?;
1508 let envelope_size = 8;
1509 let bytes_len = max_ordinal as usize * envelope_size;
1510 #[allow(unused_variables)]
1511 let offset = encoder.out_of_line_offset(bytes_len);
1512 let mut _prev_end_offset: usize = 0;
1513 if 1 > max_ordinal {
1514 return Ok(());
1515 }
1516
1517 let cur_offset: usize = (1 - 1) * envelope_size;
1520
1521 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1523
1524 fidl::encoding::encode_in_envelope_optional::<u8, D>(
1529 self.id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1530 encoder,
1531 offset + cur_offset,
1532 depth,
1533 )?;
1534
1535 _prev_end_offset = cur_offset + envelope_size;
1536 if 2 > max_ordinal {
1537 return Ok(());
1538 }
1539
1540 let cur_offset: usize = (2 - 1) * envelope_size;
1543
1544 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1546
1547 fidl::encoding::encode_in_envelope_optional::<u32, D>(
1552 self.mtu.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1553 encoder,
1554 offset + cur_offset,
1555 depth,
1556 )?;
1557
1558 _prev_end_offset = cur_offset + envelope_size;
1559 if 3 > max_ordinal {
1560 return Ok(());
1561 }
1562
1563 let cur_offset: usize = (3 - 1) * envelope_size;
1566
1567 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1569
1570 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4>, D>(
1575 self.rx_types.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4> as fidl::encoding::ValueTypeMarker>::borrow),
1576 encoder, offset + cur_offset, depth
1577 )?;
1578
1579 _prev_end_offset = cur_offset + envelope_size;
1580 if 4 > max_ordinal {
1581 return Ok(());
1582 }
1583
1584 let cur_offset: usize = (4 - 1) * envelope_size;
1587
1588 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1590
1591 fidl::encoding::encode_in_envelope_optional::<
1596 fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameTypeSupport, 4>,
1597 D,
1598 >(
1599 self.tx_types.as_ref().map(
1600 <fidl::encoding::Vector<
1601 fidl_fuchsia_hardware_network__common::FrameTypeSupport,
1602 4,
1603 > as fidl::encoding::ValueTypeMarker>::borrow,
1604 ),
1605 encoder,
1606 offset + cur_offset,
1607 depth,
1608 )?;
1609
1610 _prev_end_offset = cur_offset + envelope_size;
1611 if 5 > max_ordinal {
1612 return Ok(());
1613 }
1614
1615 let cur_offset: usize = (5 - 1) * envelope_size;
1618
1619 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1621
1622 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_network__common::PortClass, D>(
1627 self.port_class.as_ref().map(<fidl_fuchsia_hardware_network__common::PortClass as fidl::encoding::ValueTypeMarker>::borrow),
1628 encoder, offset + cur_offset, depth
1629 )?;
1630
1631 _prev_end_offset = cur_offset + envelope_size;
1632
1633 Ok(())
1634 }
1635 }
1636
1637 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BasePortConfig {
1638 #[inline(always)]
1639 fn new_empty() -> Self {
1640 Self::default()
1641 }
1642
1643 unsafe fn decode(
1644 &mut self,
1645 decoder: &mut fidl::encoding::Decoder<'_, D>,
1646 offset: usize,
1647 mut depth: fidl::encoding::Depth,
1648 ) -> fidl::Result<()> {
1649 decoder.debug_check_bounds::<Self>(offset);
1650 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1651 None => return Err(fidl::Error::NotNullable),
1652 Some(len) => len,
1653 };
1654 if len == 0 {
1656 return Ok(());
1657 };
1658 depth.increment()?;
1659 let envelope_size = 8;
1660 let bytes_len = len * envelope_size;
1661 let offset = decoder.out_of_line_offset(bytes_len)?;
1662 let mut _next_ordinal_to_read = 0;
1664 let mut next_offset = offset;
1665 let end_offset = offset + bytes_len;
1666 _next_ordinal_to_read += 1;
1667 if next_offset >= end_offset {
1668 return Ok(());
1669 }
1670
1671 while _next_ordinal_to_read < 1 {
1673 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1674 _next_ordinal_to_read += 1;
1675 next_offset += envelope_size;
1676 }
1677
1678 let next_out_of_line = decoder.next_out_of_line();
1679 let handles_before = decoder.remaining_handles();
1680 if let Some((inlined, num_bytes, num_handles)) =
1681 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1682 {
1683 let member_inline_size =
1684 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1685 if inlined != (member_inline_size <= 4) {
1686 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1687 }
1688 let inner_offset;
1689 let mut inner_depth = depth.clone();
1690 if inlined {
1691 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1692 inner_offset = next_offset;
1693 } else {
1694 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1695 inner_depth.increment()?;
1696 }
1697 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u8, D));
1698 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1699 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1700 {
1701 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1702 }
1703 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1704 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1705 }
1706 }
1707
1708 next_offset += envelope_size;
1709 _next_ordinal_to_read += 1;
1710 if next_offset >= end_offset {
1711 return Ok(());
1712 }
1713
1714 while _next_ordinal_to_read < 2 {
1716 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1717 _next_ordinal_to_read += 1;
1718 next_offset += envelope_size;
1719 }
1720
1721 let next_out_of_line = decoder.next_out_of_line();
1722 let handles_before = decoder.remaining_handles();
1723 if let Some((inlined, num_bytes, num_handles)) =
1724 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1725 {
1726 let member_inline_size =
1727 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1728 if inlined != (member_inline_size <= 4) {
1729 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1730 }
1731 let inner_offset;
1732 let mut inner_depth = depth.clone();
1733 if inlined {
1734 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1735 inner_offset = next_offset;
1736 } else {
1737 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1738 inner_depth.increment()?;
1739 }
1740 let val_ref = self.mtu.get_or_insert_with(|| fidl::new_empty!(u32, D));
1741 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1742 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1743 {
1744 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1745 }
1746 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1747 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1748 }
1749 }
1750
1751 next_offset += envelope_size;
1752 _next_ordinal_to_read += 1;
1753 if next_offset >= end_offset {
1754 return Ok(());
1755 }
1756
1757 while _next_ordinal_to_read < 3 {
1759 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1760 _next_ordinal_to_read += 1;
1761 next_offset += envelope_size;
1762 }
1763
1764 let next_out_of_line = decoder.next_out_of_line();
1765 let handles_before = decoder.remaining_handles();
1766 if let Some((inlined, num_bytes, num_handles)) =
1767 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1768 {
1769 let member_inline_size = <fidl::encoding::Vector<
1770 fidl_fuchsia_hardware_network__common::FrameType,
1771 4,
1772 > as fidl::encoding::TypeMarker>::inline_size(
1773 decoder.context
1774 );
1775 if inlined != (member_inline_size <= 4) {
1776 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1777 }
1778 let inner_offset;
1779 let mut inner_depth = depth.clone();
1780 if inlined {
1781 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1782 inner_offset = next_offset;
1783 } else {
1784 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1785 inner_depth.increment()?;
1786 }
1787 let val_ref =
1788 self.rx_types.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4>, D));
1789 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameType, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
1790 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1791 {
1792 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1793 }
1794 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1795 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1796 }
1797 }
1798
1799 next_offset += envelope_size;
1800 _next_ordinal_to_read += 1;
1801 if next_offset >= end_offset {
1802 return Ok(());
1803 }
1804
1805 while _next_ordinal_to_read < 4 {
1807 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1808 _next_ordinal_to_read += 1;
1809 next_offset += envelope_size;
1810 }
1811
1812 let next_out_of_line = decoder.next_out_of_line();
1813 let handles_before = decoder.remaining_handles();
1814 if let Some((inlined, num_bytes, num_handles)) =
1815 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1816 {
1817 let member_inline_size = <fidl::encoding::Vector<
1818 fidl_fuchsia_hardware_network__common::FrameTypeSupport,
1819 4,
1820 > as fidl::encoding::TypeMarker>::inline_size(
1821 decoder.context
1822 );
1823 if inlined != (member_inline_size <= 4) {
1824 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1825 }
1826 let inner_offset;
1827 let mut inner_depth = depth.clone();
1828 if inlined {
1829 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1830 inner_offset = next_offset;
1831 } else {
1832 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1833 inner_depth.increment()?;
1834 }
1835 let val_ref =
1836 self.tx_types.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameTypeSupport, 4>, D));
1837 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_network__common::FrameTypeSupport, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
1838 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1839 {
1840 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1841 }
1842 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1843 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1844 }
1845 }
1846
1847 next_offset += envelope_size;
1848 _next_ordinal_to_read += 1;
1849 if next_offset >= end_offset {
1850 return Ok(());
1851 }
1852
1853 while _next_ordinal_to_read < 5 {
1855 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1856 _next_ordinal_to_read += 1;
1857 next_offset += envelope_size;
1858 }
1859
1860 let next_out_of_line = decoder.next_out_of_line();
1861 let handles_before = decoder.remaining_handles();
1862 if let Some((inlined, num_bytes, num_handles)) =
1863 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1864 {
1865 let member_inline_size = <fidl_fuchsia_hardware_network__common::PortClass as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1866 if inlined != (member_inline_size <= 4) {
1867 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1868 }
1869 let inner_offset;
1870 let mut inner_depth = depth.clone();
1871 if inlined {
1872 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1873 inner_offset = next_offset;
1874 } else {
1875 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1876 inner_depth.increment()?;
1877 }
1878 let val_ref = self.port_class.get_or_insert_with(|| {
1879 fidl::new_empty!(fidl_fuchsia_hardware_network__common::PortClass, D)
1880 });
1881 fidl::decode!(
1882 fidl_fuchsia_hardware_network__common::PortClass,
1883 D,
1884 val_ref,
1885 decoder,
1886 inner_offset,
1887 inner_depth
1888 )?;
1889 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1890 {
1891 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1892 }
1893 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1894 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1895 }
1896 }
1897
1898 next_offset += envelope_size;
1899
1900 while next_offset < end_offset {
1902 _next_ordinal_to_read += 1;
1903 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1904 next_offset += envelope_size;
1905 }
1906
1907 Ok(())
1908 }
1909 }
1910
1911 impl DeviceConfig {
1912 #[inline(always)]
1913 fn max_ordinal_present(&self) -> u64 {
1914 if let Some(_) = self.blocking {
1915 return 2;
1916 }
1917 if let Some(_) = self.base {
1918 return 1;
1919 }
1920 0
1921 }
1922 }
1923
1924 impl fidl::encoding::ValueTypeMarker for DeviceConfig {
1925 type Borrowed<'a> = &'a Self;
1926 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1927 value
1928 }
1929 }
1930
1931 unsafe impl fidl::encoding::TypeMarker for DeviceConfig {
1932 type Owned = Self;
1933
1934 #[inline(always)]
1935 fn inline_align(_context: fidl::encoding::Context) -> usize {
1936 8
1937 }
1938
1939 #[inline(always)]
1940 fn inline_size(_context: fidl::encoding::Context) -> usize {
1941 16
1942 }
1943 }
1944
1945 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceConfig, D>
1946 for &DeviceConfig
1947 {
1948 unsafe fn encode(
1949 self,
1950 encoder: &mut fidl::encoding::Encoder<'_, D>,
1951 offset: usize,
1952 mut depth: fidl::encoding::Depth,
1953 ) -> fidl::Result<()> {
1954 encoder.debug_check_bounds::<DeviceConfig>(offset);
1955 let max_ordinal: u64 = self.max_ordinal_present();
1957 encoder.write_num(max_ordinal, offset);
1958 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1959 if max_ordinal == 0 {
1961 return Ok(());
1962 }
1963 depth.increment()?;
1964 let envelope_size = 8;
1965 let bytes_len = max_ordinal as usize * envelope_size;
1966 #[allow(unused_variables)]
1967 let offset = encoder.out_of_line_offset(bytes_len);
1968 let mut _prev_end_offset: usize = 0;
1969 if 1 > max_ordinal {
1970 return Ok(());
1971 }
1972
1973 let cur_offset: usize = (1 - 1) * envelope_size;
1976
1977 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1979
1980 fidl::encoding::encode_in_envelope_optional::<BaseDeviceConfig, D>(
1985 self.base
1986 .as_ref()
1987 .map(<BaseDeviceConfig as fidl::encoding::ValueTypeMarker>::borrow),
1988 encoder,
1989 offset + cur_offset,
1990 depth,
1991 )?;
1992
1993 _prev_end_offset = cur_offset + envelope_size;
1994 if 2 > max_ordinal {
1995 return Ok(());
1996 }
1997
1998 let cur_offset: usize = (2 - 1) * envelope_size;
2001
2002 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2004
2005 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2010 self.blocking.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2011 encoder,
2012 offset + cur_offset,
2013 depth,
2014 )?;
2015
2016 _prev_end_offset = cur_offset + envelope_size;
2017
2018 Ok(())
2019 }
2020 }
2021
2022 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceConfig {
2023 #[inline(always)]
2024 fn new_empty() -> Self {
2025 Self::default()
2026 }
2027
2028 unsafe fn decode(
2029 &mut self,
2030 decoder: &mut fidl::encoding::Decoder<'_, D>,
2031 offset: usize,
2032 mut depth: fidl::encoding::Depth,
2033 ) -> fidl::Result<()> {
2034 decoder.debug_check_bounds::<Self>(offset);
2035 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2036 None => return Err(fidl::Error::NotNullable),
2037 Some(len) => len,
2038 };
2039 if len == 0 {
2041 return Ok(());
2042 };
2043 depth.increment()?;
2044 let envelope_size = 8;
2045 let bytes_len = len * envelope_size;
2046 let offset = decoder.out_of_line_offset(bytes_len)?;
2047 let mut _next_ordinal_to_read = 0;
2049 let mut next_offset = offset;
2050 let end_offset = offset + bytes_len;
2051 _next_ordinal_to_read += 1;
2052 if next_offset >= end_offset {
2053 return Ok(());
2054 }
2055
2056 while _next_ordinal_to_read < 1 {
2058 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2059 _next_ordinal_to_read += 1;
2060 next_offset += envelope_size;
2061 }
2062
2063 let next_out_of_line = decoder.next_out_of_line();
2064 let handles_before = decoder.remaining_handles();
2065 if let Some((inlined, num_bytes, num_handles)) =
2066 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2067 {
2068 let member_inline_size =
2069 <BaseDeviceConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2070 if inlined != (member_inline_size <= 4) {
2071 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2072 }
2073 let inner_offset;
2074 let mut inner_depth = depth.clone();
2075 if inlined {
2076 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2077 inner_offset = next_offset;
2078 } else {
2079 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2080 inner_depth.increment()?;
2081 }
2082 let val_ref =
2083 self.base.get_or_insert_with(|| fidl::new_empty!(BaseDeviceConfig, D));
2084 fidl::decode!(BaseDeviceConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2085 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2086 {
2087 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2088 }
2089 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2090 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2091 }
2092 }
2093
2094 next_offset += envelope_size;
2095 _next_ordinal_to_read += 1;
2096 if next_offset >= end_offset {
2097 return Ok(());
2098 }
2099
2100 while _next_ordinal_to_read < 2 {
2102 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2103 _next_ordinal_to_read += 1;
2104 next_offset += envelope_size;
2105 }
2106
2107 let next_out_of_line = decoder.next_out_of_line();
2108 let handles_before = decoder.remaining_handles();
2109 if let Some((inlined, num_bytes, num_handles)) =
2110 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2111 {
2112 let member_inline_size =
2113 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2114 if inlined != (member_inline_size <= 4) {
2115 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2116 }
2117 let inner_offset;
2118 let mut inner_depth = depth.clone();
2119 if inlined {
2120 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2121 inner_offset = next_offset;
2122 } else {
2123 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2124 inner_depth.increment()?;
2125 }
2126 let val_ref = self.blocking.get_or_insert_with(|| fidl::new_empty!(bool, D));
2127 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2128 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2129 {
2130 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2131 }
2132 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2133 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2134 }
2135 }
2136
2137 next_offset += envelope_size;
2138
2139 while next_offset < end_offset {
2141 _next_ordinal_to_read += 1;
2142 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2143 next_offset += envelope_size;
2144 }
2145
2146 Ok(())
2147 }
2148 }
2149
2150 impl DevicePairConfig {
2151 #[inline(always)]
2152 fn max_ordinal_present(&self) -> u64 {
2153 if let Some(_) = self.fallible_transmit_right {
2154 return 3;
2155 }
2156 if let Some(_) = self.fallible_transmit_left {
2157 return 2;
2158 }
2159 if let Some(_) = self.base {
2160 return 1;
2161 }
2162 0
2163 }
2164 }
2165
2166 impl fidl::encoding::ValueTypeMarker for DevicePairConfig {
2167 type Borrowed<'a> = &'a Self;
2168 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2169 value
2170 }
2171 }
2172
2173 unsafe impl fidl::encoding::TypeMarker for DevicePairConfig {
2174 type Owned = Self;
2175
2176 #[inline(always)]
2177 fn inline_align(_context: fidl::encoding::Context) -> usize {
2178 8
2179 }
2180
2181 #[inline(always)]
2182 fn inline_size(_context: fidl::encoding::Context) -> usize {
2183 16
2184 }
2185 }
2186
2187 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DevicePairConfig, D>
2188 for &DevicePairConfig
2189 {
2190 unsafe fn encode(
2191 self,
2192 encoder: &mut fidl::encoding::Encoder<'_, D>,
2193 offset: usize,
2194 mut depth: fidl::encoding::Depth,
2195 ) -> fidl::Result<()> {
2196 encoder.debug_check_bounds::<DevicePairConfig>(offset);
2197 let max_ordinal: u64 = self.max_ordinal_present();
2199 encoder.write_num(max_ordinal, offset);
2200 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2201 if max_ordinal == 0 {
2203 return Ok(());
2204 }
2205 depth.increment()?;
2206 let envelope_size = 8;
2207 let bytes_len = max_ordinal as usize * envelope_size;
2208 #[allow(unused_variables)]
2209 let offset = encoder.out_of_line_offset(bytes_len);
2210 let mut _prev_end_offset: usize = 0;
2211 if 1 > max_ordinal {
2212 return Ok(());
2213 }
2214
2215 let cur_offset: usize = (1 - 1) * envelope_size;
2218
2219 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2221
2222 fidl::encoding::encode_in_envelope_optional::<BaseDeviceConfig, D>(
2227 self.base
2228 .as_ref()
2229 .map(<BaseDeviceConfig as fidl::encoding::ValueTypeMarker>::borrow),
2230 encoder,
2231 offset + cur_offset,
2232 depth,
2233 )?;
2234
2235 _prev_end_offset = cur_offset + envelope_size;
2236 if 2 > max_ordinal {
2237 return Ok(());
2238 }
2239
2240 let cur_offset: usize = (2 - 1) * envelope_size;
2243
2244 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2246
2247 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2252 self.fallible_transmit_left
2253 .as_ref()
2254 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2255 encoder,
2256 offset + cur_offset,
2257 depth,
2258 )?;
2259
2260 _prev_end_offset = cur_offset + envelope_size;
2261 if 3 > max_ordinal {
2262 return Ok(());
2263 }
2264
2265 let cur_offset: usize = (3 - 1) * envelope_size;
2268
2269 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2271
2272 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2277 self.fallible_transmit_right
2278 .as_ref()
2279 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2280 encoder,
2281 offset + cur_offset,
2282 depth,
2283 )?;
2284
2285 _prev_end_offset = cur_offset + envelope_size;
2286
2287 Ok(())
2288 }
2289 }
2290
2291 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DevicePairConfig {
2292 #[inline(always)]
2293 fn new_empty() -> Self {
2294 Self::default()
2295 }
2296
2297 unsafe fn decode(
2298 &mut self,
2299 decoder: &mut fidl::encoding::Decoder<'_, D>,
2300 offset: usize,
2301 mut depth: fidl::encoding::Depth,
2302 ) -> fidl::Result<()> {
2303 decoder.debug_check_bounds::<Self>(offset);
2304 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2305 None => return Err(fidl::Error::NotNullable),
2306 Some(len) => len,
2307 };
2308 if len == 0 {
2310 return Ok(());
2311 };
2312 depth.increment()?;
2313 let envelope_size = 8;
2314 let bytes_len = len * envelope_size;
2315 let offset = decoder.out_of_line_offset(bytes_len)?;
2316 let mut _next_ordinal_to_read = 0;
2318 let mut next_offset = offset;
2319 let end_offset = offset + bytes_len;
2320 _next_ordinal_to_read += 1;
2321 if next_offset >= end_offset {
2322 return Ok(());
2323 }
2324
2325 while _next_ordinal_to_read < 1 {
2327 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2328 _next_ordinal_to_read += 1;
2329 next_offset += envelope_size;
2330 }
2331
2332 let next_out_of_line = decoder.next_out_of_line();
2333 let handles_before = decoder.remaining_handles();
2334 if let Some((inlined, num_bytes, num_handles)) =
2335 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2336 {
2337 let member_inline_size =
2338 <BaseDeviceConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2339 if inlined != (member_inline_size <= 4) {
2340 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2341 }
2342 let inner_offset;
2343 let mut inner_depth = depth.clone();
2344 if inlined {
2345 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2346 inner_offset = next_offset;
2347 } else {
2348 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2349 inner_depth.increment()?;
2350 }
2351 let val_ref =
2352 self.base.get_or_insert_with(|| fidl::new_empty!(BaseDeviceConfig, D));
2353 fidl::decode!(BaseDeviceConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2354 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2355 {
2356 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2357 }
2358 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2359 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2360 }
2361 }
2362
2363 next_offset += envelope_size;
2364 _next_ordinal_to_read += 1;
2365 if next_offset >= end_offset {
2366 return Ok(());
2367 }
2368
2369 while _next_ordinal_to_read < 2 {
2371 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2372 _next_ordinal_to_read += 1;
2373 next_offset += envelope_size;
2374 }
2375
2376 let next_out_of_line = decoder.next_out_of_line();
2377 let handles_before = decoder.remaining_handles();
2378 if let Some((inlined, num_bytes, num_handles)) =
2379 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2380 {
2381 let member_inline_size =
2382 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2383 if inlined != (member_inline_size <= 4) {
2384 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2385 }
2386 let inner_offset;
2387 let mut inner_depth = depth.clone();
2388 if inlined {
2389 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2390 inner_offset = next_offset;
2391 } else {
2392 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2393 inner_depth.increment()?;
2394 }
2395 let val_ref =
2396 self.fallible_transmit_left.get_or_insert_with(|| fidl::new_empty!(bool, D));
2397 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2398 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2399 {
2400 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2401 }
2402 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2403 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2404 }
2405 }
2406
2407 next_offset += envelope_size;
2408 _next_ordinal_to_read += 1;
2409 if next_offset >= end_offset {
2410 return Ok(());
2411 }
2412
2413 while _next_ordinal_to_read < 3 {
2415 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2416 _next_ordinal_to_read += 1;
2417 next_offset += envelope_size;
2418 }
2419
2420 let next_out_of_line = decoder.next_out_of_line();
2421 let handles_before = decoder.remaining_handles();
2422 if let Some((inlined, num_bytes, num_handles)) =
2423 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2424 {
2425 let member_inline_size =
2426 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2427 if inlined != (member_inline_size <= 4) {
2428 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2429 }
2430 let inner_offset;
2431 let mut inner_depth = depth.clone();
2432 if inlined {
2433 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2434 inner_offset = next_offset;
2435 } else {
2436 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2437 inner_depth.increment()?;
2438 }
2439 let val_ref =
2440 self.fallible_transmit_right.get_or_insert_with(|| fidl::new_empty!(bool, D));
2441 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2442 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2443 {
2444 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2445 }
2446 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2447 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2448 }
2449 }
2450
2451 next_offset += envelope_size;
2452
2453 while next_offset < end_offset {
2455 _next_ordinal_to_read += 1;
2456 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2457 next_offset += envelope_size;
2458 }
2459
2460 Ok(())
2461 }
2462 }
2463
2464 impl DevicePairPortConfig {
2465 #[inline(always)]
2466 fn max_ordinal_present(&self) -> u64 {
2467 if let Some(_) = self.mac_right {
2468 return 3;
2469 }
2470 if let Some(_) = self.mac_left {
2471 return 2;
2472 }
2473 if let Some(_) = self.base {
2474 return 1;
2475 }
2476 0
2477 }
2478 }
2479
2480 impl fidl::encoding::ValueTypeMarker for DevicePairPortConfig {
2481 type Borrowed<'a> = &'a Self;
2482 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2483 value
2484 }
2485 }
2486
2487 unsafe impl fidl::encoding::TypeMarker for DevicePairPortConfig {
2488 type Owned = Self;
2489
2490 #[inline(always)]
2491 fn inline_align(_context: fidl::encoding::Context) -> usize {
2492 8
2493 }
2494
2495 #[inline(always)]
2496 fn inline_size(_context: fidl::encoding::Context) -> usize {
2497 16
2498 }
2499 }
2500
2501 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DevicePairPortConfig, D>
2502 for &DevicePairPortConfig
2503 {
2504 unsafe fn encode(
2505 self,
2506 encoder: &mut fidl::encoding::Encoder<'_, D>,
2507 offset: usize,
2508 mut depth: fidl::encoding::Depth,
2509 ) -> fidl::Result<()> {
2510 encoder.debug_check_bounds::<DevicePairPortConfig>(offset);
2511 let max_ordinal: u64 = self.max_ordinal_present();
2513 encoder.write_num(max_ordinal, offset);
2514 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2515 if max_ordinal == 0 {
2517 return Ok(());
2518 }
2519 depth.increment()?;
2520 let envelope_size = 8;
2521 let bytes_len = max_ordinal as usize * envelope_size;
2522 #[allow(unused_variables)]
2523 let offset = encoder.out_of_line_offset(bytes_len);
2524 let mut _prev_end_offset: usize = 0;
2525 if 1 > max_ordinal {
2526 return Ok(());
2527 }
2528
2529 let cur_offset: usize = (1 - 1) * envelope_size;
2532
2533 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2535
2536 fidl::encoding::encode_in_envelope_optional::<BasePortConfig, D>(
2541 self.base.as_ref().map(<BasePortConfig as fidl::encoding::ValueTypeMarker>::borrow),
2542 encoder,
2543 offset + cur_offset,
2544 depth,
2545 )?;
2546
2547 _prev_end_offset = cur_offset + envelope_size;
2548 if 2 > max_ordinal {
2549 return Ok(());
2550 }
2551
2552 let cur_offset: usize = (2 - 1) * envelope_size;
2555
2556 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2558
2559 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
2564 self.mac_left.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2565 encoder, offset + cur_offset, depth
2566 )?;
2567
2568 _prev_end_offset = cur_offset + envelope_size;
2569 if 3 > max_ordinal {
2570 return Ok(());
2571 }
2572
2573 let cur_offset: usize = (3 - 1) * envelope_size;
2576
2577 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2579
2580 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
2585 self.mac_right.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2586 encoder, offset + cur_offset, depth
2587 )?;
2588
2589 _prev_end_offset = cur_offset + envelope_size;
2590
2591 Ok(())
2592 }
2593 }
2594
2595 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DevicePairPortConfig {
2596 #[inline(always)]
2597 fn new_empty() -> Self {
2598 Self::default()
2599 }
2600
2601 unsafe fn decode(
2602 &mut self,
2603 decoder: &mut fidl::encoding::Decoder<'_, D>,
2604 offset: usize,
2605 mut depth: fidl::encoding::Depth,
2606 ) -> fidl::Result<()> {
2607 decoder.debug_check_bounds::<Self>(offset);
2608 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2609 None => return Err(fidl::Error::NotNullable),
2610 Some(len) => len,
2611 };
2612 if len == 0 {
2614 return Ok(());
2615 };
2616 depth.increment()?;
2617 let envelope_size = 8;
2618 let bytes_len = len * envelope_size;
2619 let offset = decoder.out_of_line_offset(bytes_len)?;
2620 let mut _next_ordinal_to_read = 0;
2622 let mut next_offset = offset;
2623 let end_offset = offset + bytes_len;
2624 _next_ordinal_to_read += 1;
2625 if next_offset >= end_offset {
2626 return Ok(());
2627 }
2628
2629 while _next_ordinal_to_read < 1 {
2631 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2632 _next_ordinal_to_read += 1;
2633 next_offset += envelope_size;
2634 }
2635
2636 let next_out_of_line = decoder.next_out_of_line();
2637 let handles_before = decoder.remaining_handles();
2638 if let Some((inlined, num_bytes, num_handles)) =
2639 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2640 {
2641 let member_inline_size =
2642 <BasePortConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2643 if inlined != (member_inline_size <= 4) {
2644 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2645 }
2646 let inner_offset;
2647 let mut inner_depth = depth.clone();
2648 if inlined {
2649 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2650 inner_offset = next_offset;
2651 } else {
2652 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2653 inner_depth.increment()?;
2654 }
2655 let val_ref = self.base.get_or_insert_with(|| fidl::new_empty!(BasePortConfig, D));
2656 fidl::decode!(BasePortConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2657 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2658 {
2659 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2660 }
2661 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2662 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2663 }
2664 }
2665
2666 next_offset += envelope_size;
2667 _next_ordinal_to_read += 1;
2668 if next_offset >= end_offset {
2669 return Ok(());
2670 }
2671
2672 while _next_ordinal_to_read < 2 {
2674 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2675 _next_ordinal_to_read += 1;
2676 next_offset += envelope_size;
2677 }
2678
2679 let next_out_of_line = decoder.next_out_of_line();
2680 let handles_before = decoder.remaining_handles();
2681 if let Some((inlined, num_bytes, num_handles)) =
2682 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2683 {
2684 let member_inline_size = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2685 if inlined != (member_inline_size <= 4) {
2686 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2687 }
2688 let inner_offset;
2689 let mut inner_depth = depth.clone();
2690 if inlined {
2691 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2692 inner_offset = next_offset;
2693 } else {
2694 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2695 inner_depth.increment()?;
2696 }
2697 let val_ref = self.mac_left.get_or_insert_with(|| {
2698 fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
2699 });
2700 fidl::decode!(
2701 fidl_fuchsia_net__common::MacAddress,
2702 D,
2703 val_ref,
2704 decoder,
2705 inner_offset,
2706 inner_depth
2707 )?;
2708 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2709 {
2710 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2711 }
2712 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2713 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2714 }
2715 }
2716
2717 next_offset += envelope_size;
2718 _next_ordinal_to_read += 1;
2719 if next_offset >= end_offset {
2720 return Ok(());
2721 }
2722
2723 while _next_ordinal_to_read < 3 {
2725 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2726 _next_ordinal_to_read += 1;
2727 next_offset += envelope_size;
2728 }
2729
2730 let next_out_of_line = decoder.next_out_of_line();
2731 let handles_before = decoder.remaining_handles();
2732 if let Some((inlined, num_bytes, num_handles)) =
2733 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2734 {
2735 let member_inline_size = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2736 if inlined != (member_inline_size <= 4) {
2737 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2738 }
2739 let inner_offset;
2740 let mut inner_depth = depth.clone();
2741 if inlined {
2742 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2743 inner_offset = next_offset;
2744 } else {
2745 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2746 inner_depth.increment()?;
2747 }
2748 let val_ref = self.mac_right.get_or_insert_with(|| {
2749 fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
2750 });
2751 fidl::decode!(
2752 fidl_fuchsia_net__common::MacAddress,
2753 D,
2754 val_ref,
2755 decoder,
2756 inner_offset,
2757 inner_depth
2758 )?;
2759 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2760 {
2761 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2762 }
2763 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2764 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2765 }
2766 }
2767
2768 next_offset += envelope_size;
2769
2770 while next_offset < end_offset {
2772 _next_ordinal_to_read += 1;
2773 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2774 next_offset += envelope_size;
2775 }
2776
2777 Ok(())
2778 }
2779 }
2780
2781 impl DevicePortConfig {
2782 #[inline(always)]
2783 fn max_ordinal_present(&self) -> u64 {
2784 if let Some(_) = self.mac {
2785 return 3;
2786 }
2787 if let Some(_) = self.online {
2788 return 2;
2789 }
2790 if let Some(_) = self.base {
2791 return 1;
2792 }
2793 0
2794 }
2795 }
2796
2797 impl fidl::encoding::ValueTypeMarker for DevicePortConfig {
2798 type Borrowed<'a> = &'a Self;
2799 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2800 value
2801 }
2802 }
2803
2804 unsafe impl fidl::encoding::TypeMarker for DevicePortConfig {
2805 type Owned = Self;
2806
2807 #[inline(always)]
2808 fn inline_align(_context: fidl::encoding::Context) -> usize {
2809 8
2810 }
2811
2812 #[inline(always)]
2813 fn inline_size(_context: fidl::encoding::Context) -> usize {
2814 16
2815 }
2816 }
2817
2818 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DevicePortConfig, D>
2819 for &DevicePortConfig
2820 {
2821 unsafe fn encode(
2822 self,
2823 encoder: &mut fidl::encoding::Encoder<'_, D>,
2824 offset: usize,
2825 mut depth: fidl::encoding::Depth,
2826 ) -> fidl::Result<()> {
2827 encoder.debug_check_bounds::<DevicePortConfig>(offset);
2828 let max_ordinal: u64 = self.max_ordinal_present();
2830 encoder.write_num(max_ordinal, offset);
2831 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2832 if max_ordinal == 0 {
2834 return Ok(());
2835 }
2836 depth.increment()?;
2837 let envelope_size = 8;
2838 let bytes_len = max_ordinal as usize * envelope_size;
2839 #[allow(unused_variables)]
2840 let offset = encoder.out_of_line_offset(bytes_len);
2841 let mut _prev_end_offset: usize = 0;
2842 if 1 > max_ordinal {
2843 return Ok(());
2844 }
2845
2846 let cur_offset: usize = (1 - 1) * envelope_size;
2849
2850 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2852
2853 fidl::encoding::encode_in_envelope_optional::<BasePortConfig, D>(
2858 self.base.as_ref().map(<BasePortConfig as fidl::encoding::ValueTypeMarker>::borrow),
2859 encoder,
2860 offset + cur_offset,
2861 depth,
2862 )?;
2863
2864 _prev_end_offset = cur_offset + envelope_size;
2865 if 2 > max_ordinal {
2866 return Ok(());
2867 }
2868
2869 let cur_offset: usize = (2 - 1) * envelope_size;
2872
2873 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2875
2876 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2881 self.online.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2882 encoder,
2883 offset + cur_offset,
2884 depth,
2885 )?;
2886
2887 _prev_end_offset = cur_offset + envelope_size;
2888 if 3 > max_ordinal {
2889 return Ok(());
2890 }
2891
2892 let cur_offset: usize = (3 - 1) * envelope_size;
2895
2896 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2898
2899 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
2904 self.mac.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2905 encoder, offset + cur_offset, depth
2906 )?;
2907
2908 _prev_end_offset = cur_offset + envelope_size;
2909
2910 Ok(())
2911 }
2912 }
2913
2914 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DevicePortConfig {
2915 #[inline(always)]
2916 fn new_empty() -> Self {
2917 Self::default()
2918 }
2919
2920 unsafe fn decode(
2921 &mut self,
2922 decoder: &mut fidl::encoding::Decoder<'_, D>,
2923 offset: usize,
2924 mut depth: fidl::encoding::Depth,
2925 ) -> fidl::Result<()> {
2926 decoder.debug_check_bounds::<Self>(offset);
2927 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2928 None => return Err(fidl::Error::NotNullable),
2929 Some(len) => len,
2930 };
2931 if len == 0 {
2933 return Ok(());
2934 };
2935 depth.increment()?;
2936 let envelope_size = 8;
2937 let bytes_len = len * envelope_size;
2938 let offset = decoder.out_of_line_offset(bytes_len)?;
2939 let mut _next_ordinal_to_read = 0;
2941 let mut next_offset = offset;
2942 let end_offset = offset + bytes_len;
2943 _next_ordinal_to_read += 1;
2944 if next_offset >= end_offset {
2945 return Ok(());
2946 }
2947
2948 while _next_ordinal_to_read < 1 {
2950 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2951 _next_ordinal_to_read += 1;
2952 next_offset += envelope_size;
2953 }
2954
2955 let next_out_of_line = decoder.next_out_of_line();
2956 let handles_before = decoder.remaining_handles();
2957 if let Some((inlined, num_bytes, num_handles)) =
2958 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2959 {
2960 let member_inline_size =
2961 <BasePortConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2962 if inlined != (member_inline_size <= 4) {
2963 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2964 }
2965 let inner_offset;
2966 let mut inner_depth = depth.clone();
2967 if inlined {
2968 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2969 inner_offset = next_offset;
2970 } else {
2971 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2972 inner_depth.increment()?;
2973 }
2974 let val_ref = self.base.get_or_insert_with(|| fidl::new_empty!(BasePortConfig, D));
2975 fidl::decode!(BasePortConfig, D, val_ref, decoder, inner_offset, inner_depth)?;
2976 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2977 {
2978 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2979 }
2980 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2981 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2982 }
2983 }
2984
2985 next_offset += envelope_size;
2986 _next_ordinal_to_read += 1;
2987 if next_offset >= end_offset {
2988 return Ok(());
2989 }
2990
2991 while _next_ordinal_to_read < 2 {
2993 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2994 _next_ordinal_to_read += 1;
2995 next_offset += envelope_size;
2996 }
2997
2998 let next_out_of_line = decoder.next_out_of_line();
2999 let handles_before = decoder.remaining_handles();
3000 if let Some((inlined, num_bytes, num_handles)) =
3001 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3002 {
3003 let member_inline_size =
3004 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3005 if inlined != (member_inline_size <= 4) {
3006 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3007 }
3008 let inner_offset;
3009 let mut inner_depth = depth.clone();
3010 if inlined {
3011 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3012 inner_offset = next_offset;
3013 } else {
3014 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3015 inner_depth.increment()?;
3016 }
3017 let val_ref = self.online.get_or_insert_with(|| fidl::new_empty!(bool, D));
3018 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3019 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3020 {
3021 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3022 }
3023 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3024 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3025 }
3026 }
3027
3028 next_offset += envelope_size;
3029 _next_ordinal_to_read += 1;
3030 if next_offset >= end_offset {
3031 return Ok(());
3032 }
3033
3034 while _next_ordinal_to_read < 3 {
3036 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3037 _next_ordinal_to_read += 1;
3038 next_offset += envelope_size;
3039 }
3040
3041 let next_out_of_line = decoder.next_out_of_line();
3042 let handles_before = decoder.remaining_handles();
3043 if let Some((inlined, num_bytes, num_handles)) =
3044 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3045 {
3046 let member_inline_size = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3047 if inlined != (member_inline_size <= 4) {
3048 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3049 }
3050 let inner_offset;
3051 let mut inner_depth = depth.clone();
3052 if inlined {
3053 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3054 inner_offset = next_offset;
3055 } else {
3056 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3057 inner_depth.increment()?;
3058 }
3059 let val_ref = self.mac.get_or_insert_with(|| {
3060 fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
3061 });
3062 fidl::decode!(
3063 fidl_fuchsia_net__common::MacAddress,
3064 D,
3065 val_ref,
3066 decoder,
3067 inner_offset,
3068 inner_depth
3069 )?;
3070 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3071 {
3072 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3073 }
3074 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3075 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3076 }
3077 }
3078
3079 next_offset += envelope_size;
3080
3081 while next_offset < end_offset {
3083 _next_ordinal_to_read += 1;
3084 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3085 next_offset += envelope_size;
3086 }
3087
3088 Ok(())
3089 }
3090 }
3091
3092 impl Frame {
3093 #[inline(always)]
3094 fn max_ordinal_present(&self) -> u64 {
3095 if let Some(_) = self.port {
3096 return 4;
3097 }
3098 if let Some(_) = self.meta {
3099 return 3;
3100 }
3101 if let Some(_) = self.data {
3102 return 2;
3103 }
3104 if let Some(_) = self.frame_type {
3105 return 1;
3106 }
3107 0
3108 }
3109 }
3110
3111 impl fidl::encoding::ValueTypeMarker for Frame {
3112 type Borrowed<'a> = &'a Self;
3113 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3114 value
3115 }
3116 }
3117
3118 unsafe impl fidl::encoding::TypeMarker for Frame {
3119 type Owned = Self;
3120
3121 #[inline(always)]
3122 fn inline_align(_context: fidl::encoding::Context) -> usize {
3123 8
3124 }
3125
3126 #[inline(always)]
3127 fn inline_size(_context: fidl::encoding::Context) -> usize {
3128 16
3129 }
3130 }
3131
3132 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Frame, D> for &Frame {
3133 unsafe fn encode(
3134 self,
3135 encoder: &mut fidl::encoding::Encoder<'_, D>,
3136 offset: usize,
3137 mut depth: fidl::encoding::Depth,
3138 ) -> fidl::Result<()> {
3139 encoder.debug_check_bounds::<Frame>(offset);
3140 let max_ordinal: u64 = self.max_ordinal_present();
3142 encoder.write_num(max_ordinal, offset);
3143 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3144 if max_ordinal == 0 {
3146 return Ok(());
3147 }
3148 depth.increment()?;
3149 let envelope_size = 8;
3150 let bytes_len = max_ordinal as usize * envelope_size;
3151 #[allow(unused_variables)]
3152 let offset = encoder.out_of_line_offset(bytes_len);
3153 let mut _prev_end_offset: usize = 0;
3154 if 1 > max_ordinal {
3155 return Ok(());
3156 }
3157
3158 let cur_offset: usize = (1 - 1) * envelope_size;
3161
3162 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3164
3165 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_network__common::FrameType, D>(
3170 self.frame_type.as_ref().map(<fidl_fuchsia_hardware_network__common::FrameType as fidl::encoding::ValueTypeMarker>::borrow),
3171 encoder, offset + cur_offset, depth
3172 )?;
3173
3174 _prev_end_offset = cur_offset + envelope_size;
3175 if 2 > max_ordinal {
3176 return Ok(());
3177 }
3178
3179 let cur_offset: usize = (2 - 1) * envelope_size;
3182
3183 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3185
3186 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 16384>, D>(
3191 self.data.as_ref().map(
3192 <fidl::encoding::Vector<u8, 16384> as fidl::encoding::ValueTypeMarker>::borrow,
3193 ),
3194 encoder,
3195 offset + cur_offset,
3196 depth,
3197 )?;
3198
3199 _prev_end_offset = cur_offset + envelope_size;
3200 if 3 > max_ordinal {
3201 return Ok(());
3202 }
3203
3204 let cur_offset: usize = (3 - 1) * envelope_size;
3207
3208 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3210
3211 fidl::encoding::encode_in_envelope_optional::<FrameMetadata, D>(
3216 self.meta.as_ref().map(<FrameMetadata as fidl::encoding::ValueTypeMarker>::borrow),
3217 encoder,
3218 offset + cur_offset,
3219 depth,
3220 )?;
3221
3222 _prev_end_offset = cur_offset + envelope_size;
3223 if 4 > max_ordinal {
3224 return Ok(());
3225 }
3226
3227 let cur_offset: usize = (4 - 1) * envelope_size;
3230
3231 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3233
3234 fidl::encoding::encode_in_envelope_optional::<u8, D>(
3239 self.port.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
3240 encoder,
3241 offset + cur_offset,
3242 depth,
3243 )?;
3244
3245 _prev_end_offset = cur_offset + envelope_size;
3246
3247 Ok(())
3248 }
3249 }
3250
3251 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Frame {
3252 #[inline(always)]
3253 fn new_empty() -> Self {
3254 Self::default()
3255 }
3256
3257 unsafe fn decode(
3258 &mut self,
3259 decoder: &mut fidl::encoding::Decoder<'_, D>,
3260 offset: usize,
3261 mut depth: fidl::encoding::Depth,
3262 ) -> fidl::Result<()> {
3263 decoder.debug_check_bounds::<Self>(offset);
3264 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3265 None => return Err(fidl::Error::NotNullable),
3266 Some(len) => len,
3267 };
3268 if len == 0 {
3270 return Ok(());
3271 };
3272 depth.increment()?;
3273 let envelope_size = 8;
3274 let bytes_len = len * envelope_size;
3275 let offset = decoder.out_of_line_offset(bytes_len)?;
3276 let mut _next_ordinal_to_read = 0;
3278 let mut next_offset = offset;
3279 let end_offset = offset + bytes_len;
3280 _next_ordinal_to_read += 1;
3281 if next_offset >= end_offset {
3282 return Ok(());
3283 }
3284
3285 while _next_ordinal_to_read < 1 {
3287 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3288 _next_ordinal_to_read += 1;
3289 next_offset += envelope_size;
3290 }
3291
3292 let next_out_of_line = decoder.next_out_of_line();
3293 let handles_before = decoder.remaining_handles();
3294 if let Some((inlined, num_bytes, num_handles)) =
3295 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3296 {
3297 let member_inline_size = <fidl_fuchsia_hardware_network__common::FrameType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3298 if inlined != (member_inline_size <= 4) {
3299 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3300 }
3301 let inner_offset;
3302 let mut inner_depth = depth.clone();
3303 if inlined {
3304 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3305 inner_offset = next_offset;
3306 } else {
3307 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3308 inner_depth.increment()?;
3309 }
3310 let val_ref = self.frame_type.get_or_insert_with(|| {
3311 fidl::new_empty!(fidl_fuchsia_hardware_network__common::FrameType, D)
3312 });
3313 fidl::decode!(
3314 fidl_fuchsia_hardware_network__common::FrameType,
3315 D,
3316 val_ref,
3317 decoder,
3318 inner_offset,
3319 inner_depth
3320 )?;
3321 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3322 {
3323 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3324 }
3325 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3326 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3327 }
3328 }
3329
3330 next_offset += envelope_size;
3331 _next_ordinal_to_read += 1;
3332 if next_offset >= end_offset {
3333 return Ok(());
3334 }
3335
3336 while _next_ordinal_to_read < 2 {
3338 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3339 _next_ordinal_to_read += 1;
3340 next_offset += envelope_size;
3341 }
3342
3343 let next_out_of_line = decoder.next_out_of_line();
3344 let handles_before = decoder.remaining_handles();
3345 if let Some((inlined, num_bytes, num_handles)) =
3346 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3347 {
3348 let member_inline_size =
3349 <fidl::encoding::Vector<u8, 16384> as fidl::encoding::TypeMarker>::inline_size(
3350 decoder.context,
3351 );
3352 if inlined != (member_inline_size <= 4) {
3353 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3354 }
3355 let inner_offset;
3356 let mut inner_depth = depth.clone();
3357 if inlined {
3358 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3359 inner_offset = next_offset;
3360 } else {
3361 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3362 inner_depth.increment()?;
3363 }
3364 let val_ref = self
3365 .data
3366 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 16384>, D));
3367 fidl::decode!(fidl::encoding::Vector<u8, 16384>, D, val_ref, decoder, inner_offset, inner_depth)?;
3368 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3369 {
3370 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3371 }
3372 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3373 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3374 }
3375 }
3376
3377 next_offset += envelope_size;
3378 _next_ordinal_to_read += 1;
3379 if next_offset >= end_offset {
3380 return Ok(());
3381 }
3382
3383 while _next_ordinal_to_read < 3 {
3385 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3386 _next_ordinal_to_read += 1;
3387 next_offset += envelope_size;
3388 }
3389
3390 let next_out_of_line = decoder.next_out_of_line();
3391 let handles_before = decoder.remaining_handles();
3392 if let Some((inlined, num_bytes, num_handles)) =
3393 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3394 {
3395 let member_inline_size =
3396 <FrameMetadata as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3397 if inlined != (member_inline_size <= 4) {
3398 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3399 }
3400 let inner_offset;
3401 let mut inner_depth = depth.clone();
3402 if inlined {
3403 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3404 inner_offset = next_offset;
3405 } else {
3406 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3407 inner_depth.increment()?;
3408 }
3409 let val_ref = self.meta.get_or_insert_with(|| fidl::new_empty!(FrameMetadata, D));
3410 fidl::decode!(FrameMetadata, D, val_ref, decoder, inner_offset, inner_depth)?;
3411 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3412 {
3413 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3414 }
3415 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3416 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3417 }
3418 }
3419
3420 next_offset += envelope_size;
3421 _next_ordinal_to_read += 1;
3422 if next_offset >= end_offset {
3423 return Ok(());
3424 }
3425
3426 while _next_ordinal_to_read < 4 {
3428 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3429 _next_ordinal_to_read += 1;
3430 next_offset += envelope_size;
3431 }
3432
3433 let next_out_of_line = decoder.next_out_of_line();
3434 let handles_before = decoder.remaining_handles();
3435 if let Some((inlined, num_bytes, num_handles)) =
3436 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3437 {
3438 let member_inline_size =
3439 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3440 if inlined != (member_inline_size <= 4) {
3441 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3442 }
3443 let inner_offset;
3444 let mut inner_depth = depth.clone();
3445 if inlined {
3446 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3447 inner_offset = next_offset;
3448 } else {
3449 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3450 inner_depth.increment()?;
3451 }
3452 let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u8, D));
3453 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3454 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3455 {
3456 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3457 }
3458 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3459 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3460 }
3461 }
3462
3463 next_offset += envelope_size;
3464
3465 while next_offset < end_offset {
3467 _next_ordinal_to_read += 1;
3468 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3469 next_offset += envelope_size;
3470 }
3471
3472 Ok(())
3473 }
3474 }
3475
3476 impl InternalState {
3477 #[inline(always)]
3478 fn max_ordinal_present(&self) -> u64 {
3479 if let Some(_) = self.has_session {
3480 return 2;
3481 }
3482 if let Some(_) = self.mac {
3483 return 1;
3484 }
3485 0
3486 }
3487 }
3488
3489 impl fidl::encoding::ValueTypeMarker for InternalState {
3490 type Borrowed<'a> = &'a Self;
3491 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3492 value
3493 }
3494 }
3495
3496 unsafe impl fidl::encoding::TypeMarker for InternalState {
3497 type Owned = Self;
3498
3499 #[inline(always)]
3500 fn inline_align(_context: fidl::encoding::Context) -> usize {
3501 8
3502 }
3503
3504 #[inline(always)]
3505 fn inline_size(_context: fidl::encoding::Context) -> usize {
3506 16
3507 }
3508 }
3509
3510 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InternalState, D>
3511 for &InternalState
3512 {
3513 unsafe fn encode(
3514 self,
3515 encoder: &mut fidl::encoding::Encoder<'_, D>,
3516 offset: usize,
3517 mut depth: fidl::encoding::Depth,
3518 ) -> fidl::Result<()> {
3519 encoder.debug_check_bounds::<InternalState>(offset);
3520 let max_ordinal: u64 = self.max_ordinal_present();
3522 encoder.write_num(max_ordinal, offset);
3523 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3524 if max_ordinal == 0 {
3526 return Ok(());
3527 }
3528 depth.increment()?;
3529 let envelope_size = 8;
3530 let bytes_len = max_ordinal as usize * envelope_size;
3531 #[allow(unused_variables)]
3532 let offset = encoder.out_of_line_offset(bytes_len);
3533 let mut _prev_end_offset: usize = 0;
3534 if 1 > max_ordinal {
3535 return Ok(());
3536 }
3537
3538 let cur_offset: usize = (1 - 1) * envelope_size;
3541
3542 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3544
3545 fidl::encoding::encode_in_envelope_optional::<MacState, D>(
3550 self.mac.as_ref().map(<MacState as fidl::encoding::ValueTypeMarker>::borrow),
3551 encoder,
3552 offset + cur_offset,
3553 depth,
3554 )?;
3555
3556 _prev_end_offset = cur_offset + envelope_size;
3557 if 2 > max_ordinal {
3558 return Ok(());
3559 }
3560
3561 let cur_offset: usize = (2 - 1) * envelope_size;
3564
3565 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3567
3568 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3573 self.has_session.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3574 encoder,
3575 offset + cur_offset,
3576 depth,
3577 )?;
3578
3579 _prev_end_offset = cur_offset + envelope_size;
3580
3581 Ok(())
3582 }
3583 }
3584
3585 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InternalState {
3586 #[inline(always)]
3587 fn new_empty() -> Self {
3588 Self::default()
3589 }
3590
3591 unsafe fn decode(
3592 &mut self,
3593 decoder: &mut fidl::encoding::Decoder<'_, D>,
3594 offset: usize,
3595 mut depth: fidl::encoding::Depth,
3596 ) -> fidl::Result<()> {
3597 decoder.debug_check_bounds::<Self>(offset);
3598 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3599 None => return Err(fidl::Error::NotNullable),
3600 Some(len) => len,
3601 };
3602 if len == 0 {
3604 return Ok(());
3605 };
3606 depth.increment()?;
3607 let envelope_size = 8;
3608 let bytes_len = len * envelope_size;
3609 let offset = decoder.out_of_line_offset(bytes_len)?;
3610 let mut _next_ordinal_to_read = 0;
3612 let mut next_offset = offset;
3613 let end_offset = offset + bytes_len;
3614 _next_ordinal_to_read += 1;
3615 if next_offset >= end_offset {
3616 return Ok(());
3617 }
3618
3619 while _next_ordinal_to_read < 1 {
3621 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3622 _next_ordinal_to_read += 1;
3623 next_offset += envelope_size;
3624 }
3625
3626 let next_out_of_line = decoder.next_out_of_line();
3627 let handles_before = decoder.remaining_handles();
3628 if let Some((inlined, num_bytes, num_handles)) =
3629 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3630 {
3631 let member_inline_size =
3632 <MacState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3633 if inlined != (member_inline_size <= 4) {
3634 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3635 }
3636 let inner_offset;
3637 let mut inner_depth = depth.clone();
3638 if inlined {
3639 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3640 inner_offset = next_offset;
3641 } else {
3642 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3643 inner_depth.increment()?;
3644 }
3645 let val_ref = self.mac.get_or_insert_with(|| fidl::new_empty!(MacState, D));
3646 fidl::decode!(MacState, D, val_ref, decoder, inner_offset, inner_depth)?;
3647 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3648 {
3649 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3650 }
3651 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3652 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3653 }
3654 }
3655
3656 next_offset += envelope_size;
3657 _next_ordinal_to_read += 1;
3658 if next_offset >= end_offset {
3659 return Ok(());
3660 }
3661
3662 while _next_ordinal_to_read < 2 {
3664 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3665 _next_ordinal_to_read += 1;
3666 next_offset += envelope_size;
3667 }
3668
3669 let next_out_of_line = decoder.next_out_of_line();
3670 let handles_before = decoder.remaining_handles();
3671 if let Some((inlined, num_bytes, num_handles)) =
3672 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3673 {
3674 let member_inline_size =
3675 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3676 if inlined != (member_inline_size <= 4) {
3677 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3678 }
3679 let inner_offset;
3680 let mut inner_depth = depth.clone();
3681 if inlined {
3682 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3683 inner_offset = next_offset;
3684 } else {
3685 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3686 inner_depth.increment()?;
3687 }
3688 let val_ref = self.has_session.get_or_insert_with(|| fidl::new_empty!(bool, D));
3689 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3690 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3691 {
3692 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3693 }
3694 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3695 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3696 }
3697 }
3698
3699 next_offset += envelope_size;
3700
3701 while next_offset < end_offset {
3703 _next_ordinal_to_read += 1;
3704 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3705 next_offset += envelope_size;
3706 }
3707
3708 Ok(())
3709 }
3710 }
3711
3712 impl MacState {
3713 #[inline(always)]
3714 fn max_ordinal_present(&self) -> u64 {
3715 if let Some(_) = self.multicast_filters {
3716 return 2;
3717 }
3718 if let Some(_) = self.mode {
3719 return 1;
3720 }
3721 0
3722 }
3723 }
3724
3725 impl fidl::encoding::ValueTypeMarker for MacState {
3726 type Borrowed<'a> = &'a Self;
3727 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3728 value
3729 }
3730 }
3731
3732 unsafe impl fidl::encoding::TypeMarker for MacState {
3733 type Owned = Self;
3734
3735 #[inline(always)]
3736 fn inline_align(_context: fidl::encoding::Context) -> usize {
3737 8
3738 }
3739
3740 #[inline(always)]
3741 fn inline_size(_context: fidl::encoding::Context) -> usize {
3742 16
3743 }
3744 }
3745
3746 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MacState, D> for &MacState {
3747 unsafe fn encode(
3748 self,
3749 encoder: &mut fidl::encoding::Encoder<'_, D>,
3750 offset: usize,
3751 mut depth: fidl::encoding::Depth,
3752 ) -> fidl::Result<()> {
3753 encoder.debug_check_bounds::<MacState>(offset);
3754 let max_ordinal: u64 = self.max_ordinal_present();
3756 encoder.write_num(max_ordinal, offset);
3757 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3758 if max_ordinal == 0 {
3760 return Ok(());
3761 }
3762 depth.increment()?;
3763 let envelope_size = 8;
3764 let bytes_len = max_ordinal as usize * envelope_size;
3765 #[allow(unused_variables)]
3766 let offset = encoder.out_of_line_offset(bytes_len);
3767 let mut _prev_end_offset: usize = 0;
3768 if 1 > max_ordinal {
3769 return Ok(());
3770 }
3771
3772 let cur_offset: usize = (1 - 1) * envelope_size;
3775
3776 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3778
3779 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_network__common::MacFilterMode, D>(
3784 self.mode.as_ref().map(<fidl_fuchsia_hardware_network__common::MacFilterMode as fidl::encoding::ValueTypeMarker>::borrow),
3785 encoder, offset + cur_offset, depth
3786 )?;
3787
3788 _prev_end_offset = cur_offset + envelope_size;
3789 if 2 > max_ordinal {
3790 return Ok(());
3791 }
3792
3793 let cur_offset: usize = (2 - 1) * envelope_size;
3796
3797 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3799
3800 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64>, D>(
3805 self.multicast_filters.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3806 encoder, offset + cur_offset, depth
3807 )?;
3808
3809 _prev_end_offset = cur_offset + envelope_size;
3810
3811 Ok(())
3812 }
3813 }
3814
3815 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacState {
3816 #[inline(always)]
3817 fn new_empty() -> Self {
3818 Self::default()
3819 }
3820
3821 unsafe fn decode(
3822 &mut self,
3823 decoder: &mut fidl::encoding::Decoder<'_, D>,
3824 offset: usize,
3825 mut depth: fidl::encoding::Depth,
3826 ) -> fidl::Result<()> {
3827 decoder.debug_check_bounds::<Self>(offset);
3828 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3829 None => return Err(fidl::Error::NotNullable),
3830 Some(len) => len,
3831 };
3832 if len == 0 {
3834 return Ok(());
3835 };
3836 depth.increment()?;
3837 let envelope_size = 8;
3838 let bytes_len = len * envelope_size;
3839 let offset = decoder.out_of_line_offset(bytes_len)?;
3840 let mut _next_ordinal_to_read = 0;
3842 let mut next_offset = offset;
3843 let end_offset = offset + bytes_len;
3844 _next_ordinal_to_read += 1;
3845 if next_offset >= end_offset {
3846 return Ok(());
3847 }
3848
3849 while _next_ordinal_to_read < 1 {
3851 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3852 _next_ordinal_to_read += 1;
3853 next_offset += envelope_size;
3854 }
3855
3856 let next_out_of_line = decoder.next_out_of_line();
3857 let handles_before = decoder.remaining_handles();
3858 if let Some((inlined, num_bytes, num_handles)) =
3859 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3860 {
3861 let member_inline_size = <fidl_fuchsia_hardware_network__common::MacFilterMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3862 if inlined != (member_inline_size <= 4) {
3863 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3864 }
3865 let inner_offset;
3866 let mut inner_depth = depth.clone();
3867 if inlined {
3868 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3869 inner_offset = next_offset;
3870 } else {
3871 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3872 inner_depth.increment()?;
3873 }
3874 let val_ref = self.mode.get_or_insert_with(|| {
3875 fidl::new_empty!(fidl_fuchsia_hardware_network__common::MacFilterMode, D)
3876 });
3877 fidl::decode!(
3878 fidl_fuchsia_hardware_network__common::MacFilterMode,
3879 D,
3880 val_ref,
3881 decoder,
3882 inner_offset,
3883 inner_depth
3884 )?;
3885 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3886 {
3887 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3888 }
3889 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3890 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3891 }
3892 }
3893
3894 next_offset += envelope_size;
3895 _next_ordinal_to_read += 1;
3896 if next_offset >= end_offset {
3897 return Ok(());
3898 }
3899
3900 while _next_ordinal_to_read < 2 {
3902 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3903 _next_ordinal_to_read += 1;
3904 next_offset += envelope_size;
3905 }
3906
3907 let next_out_of_line = decoder.next_out_of_line();
3908 let handles_before = decoder.remaining_handles();
3909 if let Some((inlined, num_bytes, num_handles)) =
3910 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3911 {
3912 let member_inline_size = <fidl::encoding::Vector<
3913 fidl_fuchsia_net__common::MacAddress,
3914 64,
3915 > as fidl::encoding::TypeMarker>::inline_size(
3916 decoder.context
3917 );
3918 if inlined != (member_inline_size <= 4) {
3919 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3920 }
3921 let inner_offset;
3922 let mut inner_depth = depth.clone();
3923 if inlined {
3924 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3925 inner_offset = next_offset;
3926 } else {
3927 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3928 inner_depth.increment()?;
3929 }
3930 let val_ref =
3931 self.multicast_filters.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64>, D));
3932 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3933 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3934 {
3935 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3936 }
3937 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3938 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3939 }
3940 }
3941
3942 next_offset += envelope_size;
3943
3944 while next_offset < end_offset {
3946 _next_ordinal_to_read += 1;
3947 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3948 next_offset += envelope_size;
3949 }
3950
3951 Ok(())
3952 }
3953 }
3954}