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 type Name = String;
13
14pub const INTERFACE_NAME_LENGTH: u8 = 15;
16
17bitflags! {
18 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
19 pub struct AddressPropertiesInterest: u64 {
20 const VALID_UNTIL = 1;
21 const PREFERRED_LIFETIME_INFO = 2;
22 }
23}
24
25impl AddressPropertiesInterest {
26 #[inline(always)]
27 pub fn from_bits_allow_unknown(bits: u64) -> Self {
28 Self::from_bits_retain(bits)
29 }
30
31 #[inline(always)]
32 pub fn has_unknown_bits(&self) -> bool {
33 self.get_unknown_bits() != 0
34 }
35
36 #[inline(always)]
37 pub fn get_unknown_bits(&self) -> u64 {
38 self.bits() & !Self::all().bits()
39 }
40}
41
42#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
44#[repr(u32)]
45pub enum AddressAssignmentState {
46 Tentative = 1,
53 Assigned = 2,
55 Unavailable = 3,
58}
59
60impl AddressAssignmentState {
61 #[inline]
62 pub fn from_primitive(prim: u32) -> Option<Self> {
63 match prim {
64 1 => Some(Self::Tentative),
65 2 => Some(Self::Assigned),
66 3 => Some(Self::Unavailable),
67 _ => None,
68 }
69 }
70
71 #[inline]
72 pub const fn into_primitive(self) -> u32 {
73 self as u32
74 }
75}
76
77#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
78pub struct Empty;
79
80impl fidl::Persistable for Empty {}
81
82#[derive(Clone, Debug, PartialEq)]
83pub struct WatcherWatchResponse {
84 pub event: Event,
85}
86
87impl fidl::Persistable for WatcherWatchResponse {}
88
89#[derive(Clone, Debug, Default, PartialEq)]
90pub struct Address {
91 pub addr: Option<fidl_fuchsia_net::Subnet>,
95 pub valid_until: Option<i64>,
108 pub preferred_lifetime_info: Option<PreferredLifetimeInfo>,
112 pub assignment_state: Option<AddressAssignmentState>,
116 #[doc(hidden)]
117 pub __source_breaking: fidl::marker::SourceBreaking,
118}
119
120impl fidl::Persistable for Address {}
121
122#[derive(Clone, Debug, Default, PartialEq)]
124pub struct Properties {
125 pub id: Option<u64>,
128 pub addresses: Option<Vec<Address>>,
136 pub online: Option<bool>,
138 pub device_class: Option<DeviceClass>,
144 pub has_default_ipv4_route: Option<bool>,
146 pub has_default_ipv6_route: Option<bool>,
148 pub name: Option<String>,
150 pub port_class: Option<PortClass>,
152 #[doc(hidden)]
153 pub __source_breaking: fidl::marker::SourceBreaking,
154}
155
156impl fidl::Persistable for Properties {}
157
158#[derive(Clone, Debug, Default, PartialEq)]
159pub struct WatcherOptions {
160 pub address_properties_interest: Option<AddressPropertiesInterest>,
164 pub include_non_assigned_addresses: Option<bool>,
170 #[doc(hidden)]
171 pub __source_breaking: fidl::marker::SourceBreaking,
172}
173
174impl fidl::Persistable for WatcherOptions {}
175
176#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
177pub enum DeviceClass {
178 Loopback(Empty),
180 Device(fidl_fuchsia_hardware_network::DeviceClass),
181}
182
183impl DeviceClass {
184 #[inline]
185 pub fn ordinal(&self) -> u64 {
186 match *self {
187 Self::Loopback(_) => 1,
188 Self::Device(_) => 2,
189 }
190 }
191}
192
193impl fidl::Persistable for DeviceClass {}
194
195#[derive(Clone, Debug, PartialEq)]
196pub enum Event {
197 Existing(Properties),
201 Added(Properties),
205 Removed(u64),
207 Changed(Properties),
212 Idle(Empty),
215}
216
217impl Event {
218 #[inline]
219 pub fn ordinal(&self) -> u64 {
220 match *self {
221 Self::Existing(_) => 1,
222 Self::Added(_) => 2,
223 Self::Removed(_) => 3,
224 Self::Changed(_) => 4,
225 Self::Idle(_) => 5,
226 }
227 }
228}
229
230impl fidl::Persistable for Event {}
231
232#[derive(Clone, Debug)]
234pub enum PortClass {
235 Loopback(Empty),
237 Device(fidl_fuchsia_hardware_network::PortClass),
239 Blackhole(Empty),
241 #[doc(hidden)]
242 __SourceBreaking { unknown_ordinal: u64 },
243}
244
245#[macro_export]
247macro_rules! PortClassUnknown {
248 () => {
249 _
250 };
251}
252
253impl PartialEq for PortClass {
255 fn eq(&self, other: &Self) -> bool {
256 match (self, other) {
257 (Self::Loopback(x), Self::Loopback(y)) => *x == *y,
258 (Self::Device(x), Self::Device(y)) => *x == *y,
259 (Self::Blackhole(x), Self::Blackhole(y)) => *x == *y,
260 _ => false,
261 }
262 }
263}
264
265impl PortClass {
266 #[inline]
267 pub fn ordinal(&self) -> u64 {
268 match *self {
269 Self::Loopback(_) => 1,
270 Self::Device(_) => 2,
271 Self::Blackhole(_) => 3,
272 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
273 }
274 }
275
276 #[inline]
277 pub fn unknown_variant_for_testing() -> Self {
278 Self::__SourceBreaking { unknown_ordinal: 0 }
279 }
280
281 #[inline]
282 pub fn is_unknown(&self) -> bool {
283 match self {
284 Self::__SourceBreaking { .. } => true,
285 _ => false,
286 }
287 }
288}
289
290impl fidl::Persistable for PortClass {}
291
292#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
295pub enum PreferredLifetimeInfo {
296 PreferredUntil(i64),
312 Deprecated(Empty),
326}
327
328impl PreferredLifetimeInfo {
329 #[inline]
330 pub fn ordinal(&self) -> u64 {
331 match *self {
332 Self::PreferredUntil(_) => 1,
333 Self::Deprecated(_) => 2,
334 }
335 }
336}
337
338impl fidl::Persistable for PreferredLifetimeInfo {}
339
340mod internal {
341 use super::*;
342 unsafe impl fidl::encoding::TypeMarker for AddressPropertiesInterest {
343 type Owned = Self;
344
345 #[inline(always)]
346 fn inline_align(_context: fidl::encoding::Context) -> usize {
347 8
348 }
349
350 #[inline(always)]
351 fn inline_size(_context: fidl::encoding::Context) -> usize {
352 8
353 }
354 }
355
356 impl fidl::encoding::ValueTypeMarker for AddressPropertiesInterest {
357 type Borrowed<'a> = Self;
358 #[inline(always)]
359 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
360 *value
361 }
362 }
363
364 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
365 for AddressPropertiesInterest
366 {
367 #[inline]
368 unsafe fn encode(
369 self,
370 encoder: &mut fidl::encoding::Encoder<'_, D>,
371 offset: usize,
372 _depth: fidl::encoding::Depth,
373 ) -> fidl::Result<()> {
374 encoder.debug_check_bounds::<Self>(offset);
375 encoder.write_num(self.bits(), offset);
376 Ok(())
377 }
378 }
379
380 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
381 for AddressPropertiesInterest
382 {
383 #[inline(always)]
384 fn new_empty() -> Self {
385 Self::empty()
386 }
387
388 #[inline]
389 unsafe fn decode(
390 &mut self,
391 decoder: &mut fidl::encoding::Decoder<'_, D>,
392 offset: usize,
393 _depth: fidl::encoding::Depth,
394 ) -> fidl::Result<()> {
395 decoder.debug_check_bounds::<Self>(offset);
396 let prim = decoder.read_num::<u64>(offset);
397 *self = Self::from_bits_allow_unknown(prim);
398 Ok(())
399 }
400 }
401 unsafe impl fidl::encoding::TypeMarker for AddressAssignmentState {
402 type Owned = Self;
403
404 #[inline(always)]
405 fn inline_align(_context: fidl::encoding::Context) -> usize {
406 std::mem::align_of::<u32>()
407 }
408
409 #[inline(always)]
410 fn inline_size(_context: fidl::encoding::Context) -> usize {
411 std::mem::size_of::<u32>()
412 }
413
414 #[inline(always)]
415 fn encode_is_copy() -> bool {
416 true
417 }
418
419 #[inline(always)]
420 fn decode_is_copy() -> bool {
421 false
422 }
423 }
424
425 impl fidl::encoding::ValueTypeMarker for AddressAssignmentState {
426 type Borrowed<'a> = Self;
427 #[inline(always)]
428 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
429 *value
430 }
431 }
432
433 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
434 for AddressAssignmentState
435 {
436 #[inline]
437 unsafe fn encode(
438 self,
439 encoder: &mut fidl::encoding::Encoder<'_, D>,
440 offset: usize,
441 _depth: fidl::encoding::Depth,
442 ) -> fidl::Result<()> {
443 encoder.debug_check_bounds::<Self>(offset);
444 encoder.write_num(self.into_primitive(), offset);
445 Ok(())
446 }
447 }
448
449 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
450 for AddressAssignmentState
451 {
452 #[inline(always)]
453 fn new_empty() -> Self {
454 Self::Tentative
455 }
456
457 #[inline]
458 unsafe fn decode(
459 &mut self,
460 decoder: &mut fidl::encoding::Decoder<'_, D>,
461 offset: usize,
462 _depth: fidl::encoding::Depth,
463 ) -> fidl::Result<()> {
464 decoder.debug_check_bounds::<Self>(offset);
465 let prim = decoder.read_num::<u32>(offset);
466
467 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
468 Ok(())
469 }
470 }
471
472 impl fidl::encoding::ValueTypeMarker for Empty {
473 type Borrowed<'a> = &'a Self;
474 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
475 value
476 }
477 }
478
479 unsafe impl fidl::encoding::TypeMarker for Empty {
480 type Owned = Self;
481
482 #[inline(always)]
483 fn inline_align(_context: fidl::encoding::Context) -> usize {
484 1
485 }
486
487 #[inline(always)]
488 fn inline_size(_context: fidl::encoding::Context) -> usize {
489 1
490 }
491 }
492
493 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Empty, D> for &Empty {
494 #[inline]
495 unsafe fn encode(
496 self,
497 encoder: &mut fidl::encoding::Encoder<'_, D>,
498 offset: usize,
499 _depth: fidl::encoding::Depth,
500 ) -> fidl::Result<()> {
501 encoder.debug_check_bounds::<Empty>(offset);
502 encoder.write_num(0u8, offset);
503 Ok(())
504 }
505 }
506
507 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Empty {
508 #[inline(always)]
509 fn new_empty() -> Self {
510 Self
511 }
512
513 #[inline]
514 unsafe fn decode(
515 &mut self,
516 decoder: &mut fidl::encoding::Decoder<'_, D>,
517 offset: usize,
518 _depth: fidl::encoding::Depth,
519 ) -> fidl::Result<()> {
520 decoder.debug_check_bounds::<Self>(offset);
521 match decoder.read_num::<u8>(offset) {
522 0 => Ok(()),
523 _ => Err(fidl::Error::Invalid),
524 }
525 }
526 }
527
528 impl fidl::encoding::ValueTypeMarker for WatcherWatchResponse {
529 type Borrowed<'a> = &'a Self;
530 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
531 value
532 }
533 }
534
535 unsafe impl fidl::encoding::TypeMarker for WatcherWatchResponse {
536 type Owned = Self;
537
538 #[inline(always)]
539 fn inline_align(_context: fidl::encoding::Context) -> usize {
540 8
541 }
542
543 #[inline(always)]
544 fn inline_size(_context: fidl::encoding::Context) -> usize {
545 16
546 }
547 }
548
549 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WatcherWatchResponse, D>
550 for &WatcherWatchResponse
551 {
552 #[inline]
553 unsafe fn encode(
554 self,
555 encoder: &mut fidl::encoding::Encoder<'_, D>,
556 offset: usize,
557 _depth: fidl::encoding::Depth,
558 ) -> fidl::Result<()> {
559 encoder.debug_check_bounds::<WatcherWatchResponse>(offset);
560 fidl::encoding::Encode::<WatcherWatchResponse, D>::encode(
562 (<Event as fidl::encoding::ValueTypeMarker>::borrow(&self.event),),
563 encoder,
564 offset,
565 _depth,
566 )
567 }
568 }
569 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Event, D>>
570 fidl::encoding::Encode<WatcherWatchResponse, D> for (T0,)
571 {
572 #[inline]
573 unsafe fn encode(
574 self,
575 encoder: &mut fidl::encoding::Encoder<'_, D>,
576 offset: usize,
577 depth: fidl::encoding::Depth,
578 ) -> fidl::Result<()> {
579 encoder.debug_check_bounds::<WatcherWatchResponse>(offset);
580 self.0.encode(encoder, offset + 0, depth)?;
584 Ok(())
585 }
586 }
587
588 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WatcherWatchResponse {
589 #[inline(always)]
590 fn new_empty() -> Self {
591 Self { event: fidl::new_empty!(Event, D) }
592 }
593
594 #[inline]
595 unsafe fn decode(
596 &mut self,
597 decoder: &mut fidl::encoding::Decoder<'_, D>,
598 offset: usize,
599 _depth: fidl::encoding::Depth,
600 ) -> fidl::Result<()> {
601 decoder.debug_check_bounds::<Self>(offset);
602 fidl::decode!(Event, D, &mut self.event, decoder, offset + 0, _depth)?;
604 Ok(())
605 }
606 }
607
608 impl Address {
609 #[inline(always)]
610 fn max_ordinal_present(&self) -> u64 {
611 if let Some(_) = self.assignment_state {
612 return 4;
613 }
614 if let Some(_) = self.preferred_lifetime_info {
615 return 3;
616 }
617 if let Some(_) = self.valid_until {
618 return 2;
619 }
620 if let Some(_) = self.addr {
621 return 1;
622 }
623 0
624 }
625 }
626
627 impl fidl::encoding::ValueTypeMarker for Address {
628 type Borrowed<'a> = &'a Self;
629 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
630 value
631 }
632 }
633
634 unsafe impl fidl::encoding::TypeMarker for Address {
635 type Owned = Self;
636
637 #[inline(always)]
638 fn inline_align(_context: fidl::encoding::Context) -> usize {
639 8
640 }
641
642 #[inline(always)]
643 fn inline_size(_context: fidl::encoding::Context) -> usize {
644 16
645 }
646 }
647
648 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Address, D> for &Address {
649 unsafe fn encode(
650 self,
651 encoder: &mut fidl::encoding::Encoder<'_, D>,
652 offset: usize,
653 mut depth: fidl::encoding::Depth,
654 ) -> fidl::Result<()> {
655 encoder.debug_check_bounds::<Address>(offset);
656 let max_ordinal: u64 = self.max_ordinal_present();
658 encoder.write_num(max_ordinal, offset);
659 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
660 if max_ordinal == 0 {
662 return Ok(());
663 }
664 depth.increment()?;
665 let envelope_size = 8;
666 let bytes_len = max_ordinal as usize * envelope_size;
667 #[allow(unused_variables)]
668 let offset = encoder.out_of_line_offset(bytes_len);
669 let mut _prev_end_offset: usize = 0;
670 if 1 > max_ordinal {
671 return Ok(());
672 }
673
674 let cur_offset: usize = (1 - 1) * envelope_size;
677
678 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
680
681 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net::Subnet, D>(
686 self.addr
687 .as_ref()
688 .map(<fidl_fuchsia_net::Subnet as fidl::encoding::ValueTypeMarker>::borrow),
689 encoder,
690 offset + cur_offset,
691 depth,
692 )?;
693
694 _prev_end_offset = cur_offset + envelope_size;
695 if 2 > max_ordinal {
696 return Ok(());
697 }
698
699 let cur_offset: usize = (2 - 1) * envelope_size;
702
703 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
705
706 fidl::encoding::encode_in_envelope_optional::<i64, D>(
711 self.valid_until.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
712 encoder,
713 offset + cur_offset,
714 depth,
715 )?;
716
717 _prev_end_offset = cur_offset + envelope_size;
718 if 3 > max_ordinal {
719 return Ok(());
720 }
721
722 let cur_offset: usize = (3 - 1) * envelope_size;
725
726 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
728
729 fidl::encoding::encode_in_envelope_optional::<PreferredLifetimeInfo, D>(
734 self.preferred_lifetime_info
735 .as_ref()
736 .map(<PreferredLifetimeInfo as fidl::encoding::ValueTypeMarker>::borrow),
737 encoder,
738 offset + cur_offset,
739 depth,
740 )?;
741
742 _prev_end_offset = cur_offset + envelope_size;
743 if 4 > max_ordinal {
744 return Ok(());
745 }
746
747 let cur_offset: usize = (4 - 1) * envelope_size;
750
751 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
753
754 fidl::encoding::encode_in_envelope_optional::<AddressAssignmentState, D>(
759 self.assignment_state
760 .as_ref()
761 .map(<AddressAssignmentState as fidl::encoding::ValueTypeMarker>::borrow),
762 encoder,
763 offset + cur_offset,
764 depth,
765 )?;
766
767 _prev_end_offset = cur_offset + envelope_size;
768
769 Ok(())
770 }
771 }
772
773 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Address {
774 #[inline(always)]
775 fn new_empty() -> Self {
776 Self::default()
777 }
778
779 unsafe fn decode(
780 &mut self,
781 decoder: &mut fidl::encoding::Decoder<'_, D>,
782 offset: usize,
783 mut depth: fidl::encoding::Depth,
784 ) -> fidl::Result<()> {
785 decoder.debug_check_bounds::<Self>(offset);
786 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
787 None => return Err(fidl::Error::NotNullable),
788 Some(len) => len,
789 };
790 if len == 0 {
792 return Ok(());
793 };
794 depth.increment()?;
795 let envelope_size = 8;
796 let bytes_len = len * envelope_size;
797 let offset = decoder.out_of_line_offset(bytes_len)?;
798 let mut _next_ordinal_to_read = 0;
800 let mut next_offset = offset;
801 let end_offset = offset + bytes_len;
802 _next_ordinal_to_read += 1;
803 if next_offset >= end_offset {
804 return Ok(());
805 }
806
807 while _next_ordinal_to_read < 1 {
809 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
810 _next_ordinal_to_read += 1;
811 next_offset += envelope_size;
812 }
813
814 let next_out_of_line = decoder.next_out_of_line();
815 let handles_before = decoder.remaining_handles();
816 if let Some((inlined, num_bytes, num_handles)) =
817 fidl::encoding::decode_envelope_header(decoder, next_offset)?
818 {
819 let member_inline_size =
820 <fidl_fuchsia_net::Subnet as fidl::encoding::TypeMarker>::inline_size(
821 decoder.context,
822 );
823 if inlined != (member_inline_size <= 4) {
824 return Err(fidl::Error::InvalidInlineBitInEnvelope);
825 }
826 let inner_offset;
827 let mut inner_depth = depth.clone();
828 if inlined {
829 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
830 inner_offset = next_offset;
831 } else {
832 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
833 inner_depth.increment()?;
834 }
835 let val_ref =
836 self.addr.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_net::Subnet, D));
837 fidl::decode!(
838 fidl_fuchsia_net::Subnet,
839 D,
840 val_ref,
841 decoder,
842 inner_offset,
843 inner_depth
844 )?;
845 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
846 {
847 return Err(fidl::Error::InvalidNumBytesInEnvelope);
848 }
849 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
850 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
851 }
852 }
853
854 next_offset += envelope_size;
855 _next_ordinal_to_read += 1;
856 if next_offset >= end_offset {
857 return Ok(());
858 }
859
860 while _next_ordinal_to_read < 2 {
862 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
863 _next_ordinal_to_read += 1;
864 next_offset += envelope_size;
865 }
866
867 let next_out_of_line = decoder.next_out_of_line();
868 let handles_before = decoder.remaining_handles();
869 if let Some((inlined, num_bytes, num_handles)) =
870 fidl::encoding::decode_envelope_header(decoder, next_offset)?
871 {
872 let member_inline_size =
873 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
874 if inlined != (member_inline_size <= 4) {
875 return Err(fidl::Error::InvalidInlineBitInEnvelope);
876 }
877 let inner_offset;
878 let mut inner_depth = depth.clone();
879 if inlined {
880 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
881 inner_offset = next_offset;
882 } else {
883 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
884 inner_depth.increment()?;
885 }
886 let val_ref = self.valid_until.get_or_insert_with(|| fidl::new_empty!(i64, D));
887 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
888 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
889 {
890 return Err(fidl::Error::InvalidNumBytesInEnvelope);
891 }
892 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
893 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
894 }
895 }
896
897 next_offset += envelope_size;
898 _next_ordinal_to_read += 1;
899 if next_offset >= end_offset {
900 return Ok(());
901 }
902
903 while _next_ordinal_to_read < 3 {
905 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
906 _next_ordinal_to_read += 1;
907 next_offset += envelope_size;
908 }
909
910 let next_out_of_line = decoder.next_out_of_line();
911 let handles_before = decoder.remaining_handles();
912 if let Some((inlined, num_bytes, num_handles)) =
913 fidl::encoding::decode_envelope_header(decoder, next_offset)?
914 {
915 let member_inline_size =
916 <PreferredLifetimeInfo as fidl::encoding::TypeMarker>::inline_size(
917 decoder.context,
918 );
919 if inlined != (member_inline_size <= 4) {
920 return Err(fidl::Error::InvalidInlineBitInEnvelope);
921 }
922 let inner_offset;
923 let mut inner_depth = depth.clone();
924 if inlined {
925 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
926 inner_offset = next_offset;
927 } else {
928 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
929 inner_depth.increment()?;
930 }
931 let val_ref = self
932 .preferred_lifetime_info
933 .get_or_insert_with(|| fidl::new_empty!(PreferredLifetimeInfo, D));
934 fidl::decode!(
935 PreferredLifetimeInfo,
936 D,
937 val_ref,
938 decoder,
939 inner_offset,
940 inner_depth
941 )?;
942 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
943 {
944 return Err(fidl::Error::InvalidNumBytesInEnvelope);
945 }
946 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
947 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
948 }
949 }
950
951 next_offset += envelope_size;
952 _next_ordinal_to_read += 1;
953 if next_offset >= end_offset {
954 return Ok(());
955 }
956
957 while _next_ordinal_to_read < 4 {
959 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
960 _next_ordinal_to_read += 1;
961 next_offset += envelope_size;
962 }
963
964 let next_out_of_line = decoder.next_out_of_line();
965 let handles_before = decoder.remaining_handles();
966 if let Some((inlined, num_bytes, num_handles)) =
967 fidl::encoding::decode_envelope_header(decoder, next_offset)?
968 {
969 let member_inline_size =
970 <AddressAssignmentState as fidl::encoding::TypeMarker>::inline_size(
971 decoder.context,
972 );
973 if inlined != (member_inline_size <= 4) {
974 return Err(fidl::Error::InvalidInlineBitInEnvelope);
975 }
976 let inner_offset;
977 let mut inner_depth = depth.clone();
978 if inlined {
979 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
980 inner_offset = next_offset;
981 } else {
982 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
983 inner_depth.increment()?;
984 }
985 let val_ref = self
986 .assignment_state
987 .get_or_insert_with(|| fidl::new_empty!(AddressAssignmentState, D));
988 fidl::decode!(
989 AddressAssignmentState,
990 D,
991 val_ref,
992 decoder,
993 inner_offset,
994 inner_depth
995 )?;
996 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
997 {
998 return Err(fidl::Error::InvalidNumBytesInEnvelope);
999 }
1000 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1001 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1002 }
1003 }
1004
1005 next_offset += envelope_size;
1006
1007 while next_offset < end_offset {
1009 _next_ordinal_to_read += 1;
1010 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1011 next_offset += envelope_size;
1012 }
1013
1014 Ok(())
1015 }
1016 }
1017
1018 impl Properties {
1019 #[inline(always)]
1020 fn max_ordinal_present(&self) -> u64 {
1021 if let Some(_) = self.port_class {
1022 return 8;
1023 }
1024 if let Some(_) = self.name {
1025 return 7;
1026 }
1027 if let Some(_) = self.has_default_ipv6_route {
1028 return 6;
1029 }
1030 if let Some(_) = self.has_default_ipv4_route {
1031 return 5;
1032 }
1033 if let Some(_) = self.device_class {
1034 return 4;
1035 }
1036 if let Some(_) = self.online {
1037 return 3;
1038 }
1039 if let Some(_) = self.addresses {
1040 return 2;
1041 }
1042 if let Some(_) = self.id {
1043 return 1;
1044 }
1045 0
1046 }
1047 }
1048
1049 impl fidl::encoding::ValueTypeMarker for Properties {
1050 type Borrowed<'a> = &'a Self;
1051 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1052 value
1053 }
1054 }
1055
1056 unsafe impl fidl::encoding::TypeMarker for Properties {
1057 type Owned = Self;
1058
1059 #[inline(always)]
1060 fn inline_align(_context: fidl::encoding::Context) -> usize {
1061 8
1062 }
1063
1064 #[inline(always)]
1065 fn inline_size(_context: fidl::encoding::Context) -> usize {
1066 16
1067 }
1068 }
1069
1070 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Properties, D>
1071 for &Properties
1072 {
1073 unsafe fn encode(
1074 self,
1075 encoder: &mut fidl::encoding::Encoder<'_, D>,
1076 offset: usize,
1077 mut depth: fidl::encoding::Depth,
1078 ) -> fidl::Result<()> {
1079 encoder.debug_check_bounds::<Properties>(offset);
1080 let max_ordinal: u64 = self.max_ordinal_present();
1082 encoder.write_num(max_ordinal, offset);
1083 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1084 if max_ordinal == 0 {
1086 return Ok(());
1087 }
1088 depth.increment()?;
1089 let envelope_size = 8;
1090 let bytes_len = max_ordinal as usize * envelope_size;
1091 #[allow(unused_variables)]
1092 let offset = encoder.out_of_line_offset(bytes_len);
1093 let mut _prev_end_offset: usize = 0;
1094 if 1 > max_ordinal {
1095 return Ok(());
1096 }
1097
1098 let cur_offset: usize = (1 - 1) * envelope_size;
1101
1102 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1104
1105 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1110 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1111 encoder,
1112 offset + cur_offset,
1113 depth,
1114 )?;
1115
1116 _prev_end_offset = cur_offset + envelope_size;
1117 if 2 > max_ordinal {
1118 return Ok(());
1119 }
1120
1121 let cur_offset: usize = (2 - 1) * envelope_size;
1124
1125 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1127
1128 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Address>, D>(
1133 self.addresses.as_ref().map(<fidl::encoding::UnboundedVector<Address> as fidl::encoding::ValueTypeMarker>::borrow),
1134 encoder, offset + cur_offset, depth
1135 )?;
1136
1137 _prev_end_offset = cur_offset + envelope_size;
1138 if 3 > max_ordinal {
1139 return Ok(());
1140 }
1141
1142 let cur_offset: usize = (3 - 1) * envelope_size;
1145
1146 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1148
1149 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1154 self.online.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1155 encoder,
1156 offset + cur_offset,
1157 depth,
1158 )?;
1159
1160 _prev_end_offset = cur_offset + envelope_size;
1161 if 4 > max_ordinal {
1162 return Ok(());
1163 }
1164
1165 let cur_offset: usize = (4 - 1) * envelope_size;
1168
1169 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1171
1172 fidl::encoding::encode_in_envelope_optional::<DeviceClass, D>(
1177 self.device_class
1178 .as_ref()
1179 .map(<DeviceClass as fidl::encoding::ValueTypeMarker>::borrow),
1180 encoder,
1181 offset + cur_offset,
1182 depth,
1183 )?;
1184
1185 _prev_end_offset = cur_offset + envelope_size;
1186 if 5 > max_ordinal {
1187 return Ok(());
1188 }
1189
1190 let cur_offset: usize = (5 - 1) * envelope_size;
1193
1194 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1196
1197 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1202 self.has_default_ipv4_route
1203 .as_ref()
1204 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1205 encoder,
1206 offset + cur_offset,
1207 depth,
1208 )?;
1209
1210 _prev_end_offset = cur_offset + envelope_size;
1211 if 6 > max_ordinal {
1212 return Ok(());
1213 }
1214
1215 let cur_offset: usize = (6 - 1) * envelope_size;
1218
1219 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1221
1222 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1227 self.has_default_ipv6_route
1228 .as_ref()
1229 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1230 encoder,
1231 offset + cur_offset,
1232 depth,
1233 )?;
1234
1235 _prev_end_offset = cur_offset + envelope_size;
1236 if 7 > max_ordinal {
1237 return Ok(());
1238 }
1239
1240 let cur_offset: usize = (7 - 1) * envelope_size;
1243
1244 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1246
1247 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<15>, D>(
1252 self.name.as_ref().map(
1253 <fidl::encoding::BoundedString<15> as fidl::encoding::ValueTypeMarker>::borrow,
1254 ),
1255 encoder,
1256 offset + cur_offset,
1257 depth,
1258 )?;
1259
1260 _prev_end_offset = cur_offset + envelope_size;
1261 if 8 > max_ordinal {
1262 return Ok(());
1263 }
1264
1265 let cur_offset: usize = (8 - 1) * envelope_size;
1268
1269 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1271
1272 fidl::encoding::encode_in_envelope_optional::<PortClass, D>(
1277 self.port_class
1278 .as_ref()
1279 .map(<PortClass as fidl::encoding::ValueTypeMarker>::borrow),
1280 encoder,
1281 offset + cur_offset,
1282 depth,
1283 )?;
1284
1285 _prev_end_offset = cur_offset + envelope_size;
1286
1287 Ok(())
1288 }
1289 }
1290
1291 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Properties {
1292 #[inline(always)]
1293 fn new_empty() -> Self {
1294 Self::default()
1295 }
1296
1297 unsafe fn decode(
1298 &mut self,
1299 decoder: &mut fidl::encoding::Decoder<'_, D>,
1300 offset: usize,
1301 mut depth: fidl::encoding::Depth,
1302 ) -> fidl::Result<()> {
1303 decoder.debug_check_bounds::<Self>(offset);
1304 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1305 None => return Err(fidl::Error::NotNullable),
1306 Some(len) => len,
1307 };
1308 if len == 0 {
1310 return Ok(());
1311 };
1312 depth.increment()?;
1313 let envelope_size = 8;
1314 let bytes_len = len * envelope_size;
1315 let offset = decoder.out_of_line_offset(bytes_len)?;
1316 let mut _next_ordinal_to_read = 0;
1318 let mut next_offset = offset;
1319 let end_offset = offset + bytes_len;
1320 _next_ordinal_to_read += 1;
1321 if next_offset >= end_offset {
1322 return Ok(());
1323 }
1324
1325 while _next_ordinal_to_read < 1 {
1327 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1328 _next_ordinal_to_read += 1;
1329 next_offset += envelope_size;
1330 }
1331
1332 let next_out_of_line = decoder.next_out_of_line();
1333 let handles_before = decoder.remaining_handles();
1334 if let Some((inlined, num_bytes, num_handles)) =
1335 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1336 {
1337 let member_inline_size =
1338 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1339 if inlined != (member_inline_size <= 4) {
1340 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1341 }
1342 let inner_offset;
1343 let mut inner_depth = depth.clone();
1344 if inlined {
1345 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1346 inner_offset = next_offset;
1347 } else {
1348 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1349 inner_depth.increment()?;
1350 }
1351 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
1352 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1353 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1354 {
1355 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1356 }
1357 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1358 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1359 }
1360 }
1361
1362 next_offset += envelope_size;
1363 _next_ordinal_to_read += 1;
1364 if next_offset >= end_offset {
1365 return Ok(());
1366 }
1367
1368 while _next_ordinal_to_read < 2 {
1370 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1371 _next_ordinal_to_read += 1;
1372 next_offset += envelope_size;
1373 }
1374
1375 let next_out_of_line = decoder.next_out_of_line();
1376 let handles_before = decoder.remaining_handles();
1377 if let Some((inlined, num_bytes, num_handles)) =
1378 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1379 {
1380 let member_inline_size = <fidl::encoding::UnboundedVector<Address> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1381 if inlined != (member_inline_size <= 4) {
1382 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1383 }
1384 let inner_offset;
1385 let mut inner_depth = depth.clone();
1386 if inlined {
1387 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1388 inner_offset = next_offset;
1389 } else {
1390 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1391 inner_depth.increment()?;
1392 }
1393 let val_ref = self.addresses.get_or_insert_with(|| {
1394 fidl::new_empty!(fidl::encoding::UnboundedVector<Address>, D)
1395 });
1396 fidl::decode!(
1397 fidl::encoding::UnboundedVector<Address>,
1398 D,
1399 val_ref,
1400 decoder,
1401 inner_offset,
1402 inner_depth
1403 )?;
1404 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1405 {
1406 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1407 }
1408 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1409 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1410 }
1411 }
1412
1413 next_offset += envelope_size;
1414 _next_ordinal_to_read += 1;
1415 if next_offset >= end_offset {
1416 return Ok(());
1417 }
1418
1419 while _next_ordinal_to_read < 3 {
1421 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1422 _next_ordinal_to_read += 1;
1423 next_offset += envelope_size;
1424 }
1425
1426 let next_out_of_line = decoder.next_out_of_line();
1427 let handles_before = decoder.remaining_handles();
1428 if let Some((inlined, num_bytes, num_handles)) =
1429 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1430 {
1431 let member_inline_size =
1432 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1433 if inlined != (member_inline_size <= 4) {
1434 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1435 }
1436 let inner_offset;
1437 let mut inner_depth = depth.clone();
1438 if inlined {
1439 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1440 inner_offset = next_offset;
1441 } else {
1442 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1443 inner_depth.increment()?;
1444 }
1445 let val_ref = self.online.get_or_insert_with(|| fidl::new_empty!(bool, D));
1446 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1447 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1448 {
1449 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1450 }
1451 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1452 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1453 }
1454 }
1455
1456 next_offset += envelope_size;
1457 _next_ordinal_to_read += 1;
1458 if next_offset >= end_offset {
1459 return Ok(());
1460 }
1461
1462 while _next_ordinal_to_read < 4 {
1464 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1465 _next_ordinal_to_read += 1;
1466 next_offset += envelope_size;
1467 }
1468
1469 let next_out_of_line = decoder.next_out_of_line();
1470 let handles_before = decoder.remaining_handles();
1471 if let Some((inlined, num_bytes, num_handles)) =
1472 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1473 {
1474 let member_inline_size =
1475 <DeviceClass as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1476 if inlined != (member_inline_size <= 4) {
1477 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1478 }
1479 let inner_offset;
1480 let mut inner_depth = depth.clone();
1481 if inlined {
1482 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1483 inner_offset = next_offset;
1484 } else {
1485 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1486 inner_depth.increment()?;
1487 }
1488 let val_ref =
1489 self.device_class.get_or_insert_with(|| fidl::new_empty!(DeviceClass, D));
1490 fidl::decode!(DeviceClass, D, val_ref, decoder, inner_offset, inner_depth)?;
1491 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1492 {
1493 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1494 }
1495 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1496 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1497 }
1498 }
1499
1500 next_offset += envelope_size;
1501 _next_ordinal_to_read += 1;
1502 if next_offset >= end_offset {
1503 return Ok(());
1504 }
1505
1506 while _next_ordinal_to_read < 5 {
1508 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1509 _next_ordinal_to_read += 1;
1510 next_offset += envelope_size;
1511 }
1512
1513 let next_out_of_line = decoder.next_out_of_line();
1514 let handles_before = decoder.remaining_handles();
1515 if let Some((inlined, num_bytes, num_handles)) =
1516 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1517 {
1518 let member_inline_size =
1519 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1520 if inlined != (member_inline_size <= 4) {
1521 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1522 }
1523 let inner_offset;
1524 let mut inner_depth = depth.clone();
1525 if inlined {
1526 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1527 inner_offset = next_offset;
1528 } else {
1529 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1530 inner_depth.increment()?;
1531 }
1532 let val_ref =
1533 self.has_default_ipv4_route.get_or_insert_with(|| fidl::new_empty!(bool, D));
1534 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1535 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1536 {
1537 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1538 }
1539 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1540 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1541 }
1542 }
1543
1544 next_offset += envelope_size;
1545 _next_ordinal_to_read += 1;
1546 if next_offset >= end_offset {
1547 return Ok(());
1548 }
1549
1550 while _next_ordinal_to_read < 6 {
1552 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1553 _next_ordinal_to_read += 1;
1554 next_offset += envelope_size;
1555 }
1556
1557 let next_out_of_line = decoder.next_out_of_line();
1558 let handles_before = decoder.remaining_handles();
1559 if let Some((inlined, num_bytes, num_handles)) =
1560 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1561 {
1562 let member_inline_size =
1563 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1564 if inlined != (member_inline_size <= 4) {
1565 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1566 }
1567 let inner_offset;
1568 let mut inner_depth = depth.clone();
1569 if inlined {
1570 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1571 inner_offset = next_offset;
1572 } else {
1573 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1574 inner_depth.increment()?;
1575 }
1576 let val_ref =
1577 self.has_default_ipv6_route.get_or_insert_with(|| fidl::new_empty!(bool, D));
1578 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1579 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1580 {
1581 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1582 }
1583 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1584 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1585 }
1586 }
1587
1588 next_offset += envelope_size;
1589 _next_ordinal_to_read += 1;
1590 if next_offset >= end_offset {
1591 return Ok(());
1592 }
1593
1594 while _next_ordinal_to_read < 7 {
1596 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1597 _next_ordinal_to_read += 1;
1598 next_offset += envelope_size;
1599 }
1600
1601 let next_out_of_line = decoder.next_out_of_line();
1602 let handles_before = decoder.remaining_handles();
1603 if let Some((inlined, num_bytes, num_handles)) =
1604 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1605 {
1606 let member_inline_size =
1607 <fidl::encoding::BoundedString<15> as fidl::encoding::TypeMarker>::inline_size(
1608 decoder.context,
1609 );
1610 if inlined != (member_inline_size <= 4) {
1611 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1612 }
1613 let inner_offset;
1614 let mut inner_depth = depth.clone();
1615 if inlined {
1616 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1617 inner_offset = next_offset;
1618 } else {
1619 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1620 inner_depth.increment()?;
1621 }
1622 let val_ref = self
1623 .name
1624 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<15>, D));
1625 fidl::decode!(
1626 fidl::encoding::BoundedString<15>,
1627 D,
1628 val_ref,
1629 decoder,
1630 inner_offset,
1631 inner_depth
1632 )?;
1633 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1634 {
1635 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1636 }
1637 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1638 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1639 }
1640 }
1641
1642 next_offset += envelope_size;
1643 _next_ordinal_to_read += 1;
1644 if next_offset >= end_offset {
1645 return Ok(());
1646 }
1647
1648 while _next_ordinal_to_read < 8 {
1650 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1651 _next_ordinal_to_read += 1;
1652 next_offset += envelope_size;
1653 }
1654
1655 let next_out_of_line = decoder.next_out_of_line();
1656 let handles_before = decoder.remaining_handles();
1657 if let Some((inlined, num_bytes, num_handles)) =
1658 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1659 {
1660 let member_inline_size =
1661 <PortClass as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1662 if inlined != (member_inline_size <= 4) {
1663 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1664 }
1665 let inner_offset;
1666 let mut inner_depth = depth.clone();
1667 if inlined {
1668 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1669 inner_offset = next_offset;
1670 } else {
1671 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1672 inner_depth.increment()?;
1673 }
1674 let val_ref = self.port_class.get_or_insert_with(|| fidl::new_empty!(PortClass, D));
1675 fidl::decode!(PortClass, D, val_ref, decoder, inner_offset, inner_depth)?;
1676 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1677 {
1678 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1679 }
1680 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1681 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1682 }
1683 }
1684
1685 next_offset += envelope_size;
1686
1687 while next_offset < end_offset {
1689 _next_ordinal_to_read += 1;
1690 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1691 next_offset += envelope_size;
1692 }
1693
1694 Ok(())
1695 }
1696 }
1697
1698 impl WatcherOptions {
1699 #[inline(always)]
1700 fn max_ordinal_present(&self) -> u64 {
1701 if let Some(_) = self.include_non_assigned_addresses {
1702 return 2;
1703 }
1704 if let Some(_) = self.address_properties_interest {
1705 return 1;
1706 }
1707 0
1708 }
1709 }
1710
1711 impl fidl::encoding::ValueTypeMarker for WatcherOptions {
1712 type Borrowed<'a> = &'a Self;
1713 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1714 value
1715 }
1716 }
1717
1718 unsafe impl fidl::encoding::TypeMarker for WatcherOptions {
1719 type Owned = Self;
1720
1721 #[inline(always)]
1722 fn inline_align(_context: fidl::encoding::Context) -> usize {
1723 8
1724 }
1725
1726 #[inline(always)]
1727 fn inline_size(_context: fidl::encoding::Context) -> usize {
1728 16
1729 }
1730 }
1731
1732 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WatcherOptions, D>
1733 for &WatcherOptions
1734 {
1735 unsafe fn encode(
1736 self,
1737 encoder: &mut fidl::encoding::Encoder<'_, D>,
1738 offset: usize,
1739 mut depth: fidl::encoding::Depth,
1740 ) -> fidl::Result<()> {
1741 encoder.debug_check_bounds::<WatcherOptions>(offset);
1742 let max_ordinal: u64 = self.max_ordinal_present();
1744 encoder.write_num(max_ordinal, offset);
1745 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1746 if max_ordinal == 0 {
1748 return Ok(());
1749 }
1750 depth.increment()?;
1751 let envelope_size = 8;
1752 let bytes_len = max_ordinal as usize * envelope_size;
1753 #[allow(unused_variables)]
1754 let offset = encoder.out_of_line_offset(bytes_len);
1755 let mut _prev_end_offset: usize = 0;
1756 if 1 > max_ordinal {
1757 return Ok(());
1758 }
1759
1760 let cur_offset: usize = (1 - 1) * envelope_size;
1763
1764 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1766
1767 fidl::encoding::encode_in_envelope_optional::<AddressPropertiesInterest, D>(
1772 self.address_properties_interest
1773 .as_ref()
1774 .map(<AddressPropertiesInterest as fidl::encoding::ValueTypeMarker>::borrow),
1775 encoder,
1776 offset + cur_offset,
1777 depth,
1778 )?;
1779
1780 _prev_end_offset = cur_offset + envelope_size;
1781 if 2 > max_ordinal {
1782 return Ok(());
1783 }
1784
1785 let cur_offset: usize = (2 - 1) * envelope_size;
1788
1789 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1791
1792 fidl::encoding::encode_in_envelope_optional::<bool, D>(
1797 self.include_non_assigned_addresses
1798 .as_ref()
1799 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1800 encoder,
1801 offset + cur_offset,
1802 depth,
1803 )?;
1804
1805 _prev_end_offset = cur_offset + envelope_size;
1806
1807 Ok(())
1808 }
1809 }
1810
1811 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WatcherOptions {
1812 #[inline(always)]
1813 fn new_empty() -> Self {
1814 Self::default()
1815 }
1816
1817 unsafe fn decode(
1818 &mut self,
1819 decoder: &mut fidl::encoding::Decoder<'_, D>,
1820 offset: usize,
1821 mut depth: fidl::encoding::Depth,
1822 ) -> fidl::Result<()> {
1823 decoder.debug_check_bounds::<Self>(offset);
1824 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1825 None => return Err(fidl::Error::NotNullable),
1826 Some(len) => len,
1827 };
1828 if len == 0 {
1830 return Ok(());
1831 };
1832 depth.increment()?;
1833 let envelope_size = 8;
1834 let bytes_len = len * envelope_size;
1835 let offset = decoder.out_of_line_offset(bytes_len)?;
1836 let mut _next_ordinal_to_read = 0;
1838 let mut next_offset = offset;
1839 let end_offset = offset + bytes_len;
1840 _next_ordinal_to_read += 1;
1841 if next_offset >= end_offset {
1842 return Ok(());
1843 }
1844
1845 while _next_ordinal_to_read < 1 {
1847 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1848 _next_ordinal_to_read += 1;
1849 next_offset += envelope_size;
1850 }
1851
1852 let next_out_of_line = decoder.next_out_of_line();
1853 let handles_before = decoder.remaining_handles();
1854 if let Some((inlined, num_bytes, num_handles)) =
1855 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1856 {
1857 let member_inline_size =
1858 <AddressPropertiesInterest as fidl::encoding::TypeMarker>::inline_size(
1859 decoder.context,
1860 );
1861 if inlined != (member_inline_size <= 4) {
1862 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1863 }
1864 let inner_offset;
1865 let mut inner_depth = depth.clone();
1866 if inlined {
1867 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1868 inner_offset = next_offset;
1869 } else {
1870 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1871 inner_depth.increment()?;
1872 }
1873 let val_ref = self
1874 .address_properties_interest
1875 .get_or_insert_with(|| fidl::new_empty!(AddressPropertiesInterest, D));
1876 fidl::decode!(
1877 AddressPropertiesInterest,
1878 D,
1879 val_ref,
1880 decoder,
1881 inner_offset,
1882 inner_depth
1883 )?;
1884 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1885 {
1886 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1887 }
1888 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1889 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1890 }
1891 }
1892
1893 next_offset += envelope_size;
1894 _next_ordinal_to_read += 1;
1895 if next_offset >= end_offset {
1896 return Ok(());
1897 }
1898
1899 while _next_ordinal_to_read < 2 {
1901 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1902 _next_ordinal_to_read += 1;
1903 next_offset += envelope_size;
1904 }
1905
1906 let next_out_of_line = decoder.next_out_of_line();
1907 let handles_before = decoder.remaining_handles();
1908 if let Some((inlined, num_bytes, num_handles)) =
1909 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1910 {
1911 let member_inline_size =
1912 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1913 if inlined != (member_inline_size <= 4) {
1914 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1915 }
1916 let inner_offset;
1917 let mut inner_depth = depth.clone();
1918 if inlined {
1919 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1920 inner_offset = next_offset;
1921 } else {
1922 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1923 inner_depth.increment()?;
1924 }
1925 let val_ref = self
1926 .include_non_assigned_addresses
1927 .get_or_insert_with(|| fidl::new_empty!(bool, D));
1928 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1929 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1930 {
1931 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1932 }
1933 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1934 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1935 }
1936 }
1937
1938 next_offset += envelope_size;
1939
1940 while next_offset < end_offset {
1942 _next_ordinal_to_read += 1;
1943 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1944 next_offset += envelope_size;
1945 }
1946
1947 Ok(())
1948 }
1949 }
1950
1951 impl fidl::encoding::ValueTypeMarker for DeviceClass {
1952 type Borrowed<'a> = &'a Self;
1953 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1954 value
1955 }
1956 }
1957
1958 unsafe impl fidl::encoding::TypeMarker for DeviceClass {
1959 type Owned = Self;
1960
1961 #[inline(always)]
1962 fn inline_align(_context: fidl::encoding::Context) -> usize {
1963 8
1964 }
1965
1966 #[inline(always)]
1967 fn inline_size(_context: fidl::encoding::Context) -> usize {
1968 16
1969 }
1970 }
1971
1972 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceClass, D>
1973 for &DeviceClass
1974 {
1975 #[inline]
1976 unsafe fn encode(
1977 self,
1978 encoder: &mut fidl::encoding::Encoder<'_, D>,
1979 offset: usize,
1980 _depth: fidl::encoding::Depth,
1981 ) -> fidl::Result<()> {
1982 encoder.debug_check_bounds::<DeviceClass>(offset);
1983 encoder.write_num::<u64>(self.ordinal(), offset);
1984 match self {
1985 DeviceClass::Loopback(ref val) => {
1986 fidl::encoding::encode_in_envelope::<Empty, D>(
1987 <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
1988 encoder, offset + 8, _depth
1989 )
1990 }
1991 DeviceClass::Device(ref val) => {
1992 fidl::encoding::encode_in_envelope::<fidl_fuchsia_hardware_network::DeviceClass, D>(
1993 <fidl_fuchsia_hardware_network::DeviceClass as fidl::encoding::ValueTypeMarker>::borrow(val),
1994 encoder, offset + 8, _depth
1995 )
1996 }
1997 }
1998 }
1999 }
2000
2001 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceClass {
2002 #[inline(always)]
2003 fn new_empty() -> Self {
2004 Self::Loopback(fidl::new_empty!(Empty, D))
2005 }
2006
2007 #[inline]
2008 unsafe fn decode(
2009 &mut self,
2010 decoder: &mut fidl::encoding::Decoder<'_, D>,
2011 offset: usize,
2012 mut depth: fidl::encoding::Depth,
2013 ) -> fidl::Result<()> {
2014 decoder.debug_check_bounds::<Self>(offset);
2015 #[allow(unused_variables)]
2016 let next_out_of_line = decoder.next_out_of_line();
2017 let handles_before = decoder.remaining_handles();
2018 let (ordinal, inlined, num_bytes, num_handles) =
2019 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2020
2021 let member_inline_size = match ordinal {
2022 1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2023 2 => <fidl_fuchsia_hardware_network::DeviceClass as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2024 _ => return Err(fidl::Error::UnknownUnionTag),
2025 };
2026
2027 if inlined != (member_inline_size <= 4) {
2028 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2029 }
2030 let _inner_offset;
2031 if inlined {
2032 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2033 _inner_offset = offset + 8;
2034 } else {
2035 depth.increment()?;
2036 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2037 }
2038 match ordinal {
2039 1 => {
2040 #[allow(irrefutable_let_patterns)]
2041 if let DeviceClass::Loopback(_) = self {
2042 } else {
2044 *self = DeviceClass::Loopback(fidl::new_empty!(Empty, D));
2046 }
2047 #[allow(irrefutable_let_patterns)]
2048 if let DeviceClass::Loopback(ref mut val) = self {
2049 fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2050 } else {
2051 unreachable!()
2052 }
2053 }
2054 2 => {
2055 #[allow(irrefutable_let_patterns)]
2056 if let DeviceClass::Device(_) = self {
2057 } else {
2059 *self = DeviceClass::Device(fidl::new_empty!(
2061 fidl_fuchsia_hardware_network::DeviceClass,
2062 D
2063 ));
2064 }
2065 #[allow(irrefutable_let_patterns)]
2066 if let DeviceClass::Device(ref mut val) = self {
2067 fidl::decode!(
2068 fidl_fuchsia_hardware_network::DeviceClass,
2069 D,
2070 val,
2071 decoder,
2072 _inner_offset,
2073 depth
2074 )?;
2075 } else {
2076 unreachable!()
2077 }
2078 }
2079 ordinal => panic!("unexpected ordinal {:?}", ordinal),
2080 }
2081 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2082 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2083 }
2084 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2085 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2086 }
2087 Ok(())
2088 }
2089 }
2090
2091 impl fidl::encoding::ValueTypeMarker for Event {
2092 type Borrowed<'a> = &'a Self;
2093 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2094 value
2095 }
2096 }
2097
2098 unsafe impl fidl::encoding::TypeMarker for Event {
2099 type Owned = Self;
2100
2101 #[inline(always)]
2102 fn inline_align(_context: fidl::encoding::Context) -> usize {
2103 8
2104 }
2105
2106 #[inline(always)]
2107 fn inline_size(_context: fidl::encoding::Context) -> usize {
2108 16
2109 }
2110 }
2111
2112 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Event, D> for &Event {
2113 #[inline]
2114 unsafe fn encode(
2115 self,
2116 encoder: &mut fidl::encoding::Encoder<'_, D>,
2117 offset: usize,
2118 _depth: fidl::encoding::Depth,
2119 ) -> fidl::Result<()> {
2120 encoder.debug_check_bounds::<Event>(offset);
2121 encoder.write_num::<u64>(self.ordinal(), offset);
2122 match self {
2123 Event::Existing(ref val) => fidl::encoding::encode_in_envelope::<Properties, D>(
2124 <Properties as fidl::encoding::ValueTypeMarker>::borrow(val),
2125 encoder,
2126 offset + 8,
2127 _depth,
2128 ),
2129 Event::Added(ref val) => fidl::encoding::encode_in_envelope::<Properties, D>(
2130 <Properties as fidl::encoding::ValueTypeMarker>::borrow(val),
2131 encoder,
2132 offset + 8,
2133 _depth,
2134 ),
2135 Event::Removed(ref val) => fidl::encoding::encode_in_envelope::<u64, D>(
2136 <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2137 encoder,
2138 offset + 8,
2139 _depth,
2140 ),
2141 Event::Changed(ref val) => fidl::encoding::encode_in_envelope::<Properties, D>(
2142 <Properties as fidl::encoding::ValueTypeMarker>::borrow(val),
2143 encoder,
2144 offset + 8,
2145 _depth,
2146 ),
2147 Event::Idle(ref val) => fidl::encoding::encode_in_envelope::<Empty, D>(
2148 <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2149 encoder,
2150 offset + 8,
2151 _depth,
2152 ),
2153 }
2154 }
2155 }
2156
2157 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Event {
2158 #[inline(always)]
2159 fn new_empty() -> Self {
2160 Self::Existing(fidl::new_empty!(Properties, D))
2161 }
2162
2163 #[inline]
2164 unsafe fn decode(
2165 &mut self,
2166 decoder: &mut fidl::encoding::Decoder<'_, D>,
2167 offset: usize,
2168 mut depth: fidl::encoding::Depth,
2169 ) -> fidl::Result<()> {
2170 decoder.debug_check_bounds::<Self>(offset);
2171 #[allow(unused_variables)]
2172 let next_out_of_line = decoder.next_out_of_line();
2173 let handles_before = decoder.remaining_handles();
2174 let (ordinal, inlined, num_bytes, num_handles) =
2175 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2176
2177 let member_inline_size = match ordinal {
2178 1 => <Properties as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2179 2 => <Properties as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2180 3 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2181 4 => <Properties as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2182 5 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2183 _ => return Err(fidl::Error::UnknownUnionTag),
2184 };
2185
2186 if inlined != (member_inline_size <= 4) {
2187 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2188 }
2189 let _inner_offset;
2190 if inlined {
2191 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2192 _inner_offset = offset + 8;
2193 } else {
2194 depth.increment()?;
2195 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2196 }
2197 match ordinal {
2198 1 => {
2199 #[allow(irrefutable_let_patterns)]
2200 if let Event::Existing(_) = self {
2201 } else {
2203 *self = Event::Existing(fidl::new_empty!(Properties, D));
2205 }
2206 #[allow(irrefutable_let_patterns)]
2207 if let Event::Existing(ref mut val) = self {
2208 fidl::decode!(Properties, D, val, decoder, _inner_offset, depth)?;
2209 } else {
2210 unreachable!()
2211 }
2212 }
2213 2 => {
2214 #[allow(irrefutable_let_patterns)]
2215 if let Event::Added(_) = self {
2216 } else {
2218 *self = Event::Added(fidl::new_empty!(Properties, D));
2220 }
2221 #[allow(irrefutable_let_patterns)]
2222 if let Event::Added(ref mut val) = self {
2223 fidl::decode!(Properties, D, val, decoder, _inner_offset, depth)?;
2224 } else {
2225 unreachable!()
2226 }
2227 }
2228 3 => {
2229 #[allow(irrefutable_let_patterns)]
2230 if let Event::Removed(_) = self {
2231 } else {
2233 *self = Event::Removed(fidl::new_empty!(u64, D));
2235 }
2236 #[allow(irrefutable_let_patterns)]
2237 if let Event::Removed(ref mut val) = self {
2238 fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
2239 } else {
2240 unreachable!()
2241 }
2242 }
2243 4 => {
2244 #[allow(irrefutable_let_patterns)]
2245 if let Event::Changed(_) = self {
2246 } else {
2248 *self = Event::Changed(fidl::new_empty!(Properties, D));
2250 }
2251 #[allow(irrefutable_let_patterns)]
2252 if let Event::Changed(ref mut val) = self {
2253 fidl::decode!(Properties, D, val, decoder, _inner_offset, depth)?;
2254 } else {
2255 unreachable!()
2256 }
2257 }
2258 5 => {
2259 #[allow(irrefutable_let_patterns)]
2260 if let Event::Idle(_) = self {
2261 } else {
2263 *self = Event::Idle(fidl::new_empty!(Empty, D));
2265 }
2266 #[allow(irrefutable_let_patterns)]
2267 if let Event::Idle(ref mut val) = self {
2268 fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2269 } else {
2270 unreachable!()
2271 }
2272 }
2273 ordinal => panic!("unexpected ordinal {:?}", ordinal),
2274 }
2275 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2276 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2277 }
2278 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2279 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2280 }
2281 Ok(())
2282 }
2283 }
2284
2285 impl fidl::encoding::ValueTypeMarker for PortClass {
2286 type Borrowed<'a> = &'a Self;
2287 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2288 value
2289 }
2290 }
2291
2292 unsafe impl fidl::encoding::TypeMarker for PortClass {
2293 type Owned = Self;
2294
2295 #[inline(always)]
2296 fn inline_align(_context: fidl::encoding::Context) -> usize {
2297 8
2298 }
2299
2300 #[inline(always)]
2301 fn inline_size(_context: fidl::encoding::Context) -> usize {
2302 16
2303 }
2304 }
2305
2306 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PortClass, D>
2307 for &PortClass
2308 {
2309 #[inline]
2310 unsafe fn encode(
2311 self,
2312 encoder: &mut fidl::encoding::Encoder<'_, D>,
2313 offset: usize,
2314 _depth: fidl::encoding::Depth,
2315 ) -> fidl::Result<()> {
2316 encoder.debug_check_bounds::<PortClass>(offset);
2317 encoder.write_num::<u64>(self.ordinal(), offset);
2318 match self {
2319 PortClass::Loopback(ref val) => {
2320 fidl::encoding::encode_in_envelope::<Empty, D>(
2321 <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2322 encoder, offset + 8, _depth
2323 )
2324 }
2325 PortClass::Device(ref val) => {
2326 fidl::encoding::encode_in_envelope::<fidl_fuchsia_hardware_network::PortClass, D>(
2327 <fidl_fuchsia_hardware_network::PortClass as fidl::encoding::ValueTypeMarker>::borrow(val),
2328 encoder, offset + 8, _depth
2329 )
2330 }
2331 PortClass::Blackhole(ref val) => {
2332 fidl::encoding::encode_in_envelope::<Empty, D>(
2333 <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2334 encoder, offset + 8, _depth
2335 )
2336 }
2337 PortClass::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
2338 }
2339 }
2340 }
2341
2342 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PortClass {
2343 #[inline(always)]
2344 fn new_empty() -> Self {
2345 Self::__SourceBreaking { unknown_ordinal: 0 }
2346 }
2347
2348 #[inline]
2349 unsafe fn decode(
2350 &mut self,
2351 decoder: &mut fidl::encoding::Decoder<'_, D>,
2352 offset: usize,
2353 mut depth: fidl::encoding::Depth,
2354 ) -> fidl::Result<()> {
2355 decoder.debug_check_bounds::<Self>(offset);
2356 #[allow(unused_variables)]
2357 let next_out_of_line = decoder.next_out_of_line();
2358 let handles_before = decoder.remaining_handles();
2359 let (ordinal, inlined, num_bytes, num_handles) =
2360 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2361
2362 let member_inline_size = match ordinal {
2363 1 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2364 2 => <fidl_fuchsia_hardware_network::PortClass as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2365 3 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2366 0 => return Err(fidl::Error::UnknownUnionTag),
2367 _ => num_bytes as usize,
2368 };
2369
2370 if inlined != (member_inline_size <= 4) {
2371 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2372 }
2373 let _inner_offset;
2374 if inlined {
2375 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2376 _inner_offset = offset + 8;
2377 } else {
2378 depth.increment()?;
2379 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2380 }
2381 match ordinal {
2382 1 => {
2383 #[allow(irrefutable_let_patterns)]
2384 if let PortClass::Loopback(_) = self {
2385 } else {
2387 *self = PortClass::Loopback(fidl::new_empty!(Empty, D));
2389 }
2390 #[allow(irrefutable_let_patterns)]
2391 if let PortClass::Loopback(ref mut val) = self {
2392 fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2393 } else {
2394 unreachable!()
2395 }
2396 }
2397 2 => {
2398 #[allow(irrefutable_let_patterns)]
2399 if let PortClass::Device(_) = self {
2400 } else {
2402 *self = PortClass::Device(fidl::new_empty!(
2404 fidl_fuchsia_hardware_network::PortClass,
2405 D
2406 ));
2407 }
2408 #[allow(irrefutable_let_patterns)]
2409 if let PortClass::Device(ref mut val) = self {
2410 fidl::decode!(
2411 fidl_fuchsia_hardware_network::PortClass,
2412 D,
2413 val,
2414 decoder,
2415 _inner_offset,
2416 depth
2417 )?;
2418 } else {
2419 unreachable!()
2420 }
2421 }
2422 3 => {
2423 #[allow(irrefutable_let_patterns)]
2424 if let PortClass::Blackhole(_) = self {
2425 } else {
2427 *self = PortClass::Blackhole(fidl::new_empty!(Empty, D));
2429 }
2430 #[allow(irrefutable_let_patterns)]
2431 if let PortClass::Blackhole(ref mut val) = self {
2432 fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2433 } else {
2434 unreachable!()
2435 }
2436 }
2437 #[allow(deprecated)]
2438 ordinal => {
2439 for _ in 0..num_handles {
2440 decoder.drop_next_handle()?;
2441 }
2442 *self = PortClass::__SourceBreaking { unknown_ordinal: ordinal };
2443 }
2444 }
2445 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2446 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2447 }
2448 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2449 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2450 }
2451 Ok(())
2452 }
2453 }
2454
2455 impl fidl::encoding::ValueTypeMarker for PreferredLifetimeInfo {
2456 type Borrowed<'a> = &'a Self;
2457 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2458 value
2459 }
2460 }
2461
2462 unsafe impl fidl::encoding::TypeMarker for PreferredLifetimeInfo {
2463 type Owned = Self;
2464
2465 #[inline(always)]
2466 fn inline_align(_context: fidl::encoding::Context) -> usize {
2467 8
2468 }
2469
2470 #[inline(always)]
2471 fn inline_size(_context: fidl::encoding::Context) -> usize {
2472 16
2473 }
2474 }
2475
2476 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PreferredLifetimeInfo, D>
2477 for &PreferredLifetimeInfo
2478 {
2479 #[inline]
2480 unsafe fn encode(
2481 self,
2482 encoder: &mut fidl::encoding::Encoder<'_, D>,
2483 offset: usize,
2484 _depth: fidl::encoding::Depth,
2485 ) -> fidl::Result<()> {
2486 encoder.debug_check_bounds::<PreferredLifetimeInfo>(offset);
2487 encoder.write_num::<u64>(self.ordinal(), offset);
2488 match self {
2489 PreferredLifetimeInfo::PreferredUntil(ref val) => {
2490 fidl::encoding::encode_in_envelope::<i64, D>(
2491 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
2492 encoder,
2493 offset + 8,
2494 _depth,
2495 )
2496 }
2497 PreferredLifetimeInfo::Deprecated(ref val) => {
2498 fidl::encoding::encode_in_envelope::<Empty, D>(
2499 <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
2500 encoder,
2501 offset + 8,
2502 _depth,
2503 )
2504 }
2505 }
2506 }
2507 }
2508
2509 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PreferredLifetimeInfo {
2510 #[inline(always)]
2511 fn new_empty() -> Self {
2512 Self::PreferredUntil(fidl::new_empty!(i64, D))
2513 }
2514
2515 #[inline]
2516 unsafe fn decode(
2517 &mut self,
2518 decoder: &mut fidl::encoding::Decoder<'_, D>,
2519 offset: usize,
2520 mut depth: fidl::encoding::Depth,
2521 ) -> fidl::Result<()> {
2522 decoder.debug_check_bounds::<Self>(offset);
2523 #[allow(unused_variables)]
2524 let next_out_of_line = decoder.next_out_of_line();
2525 let handles_before = decoder.remaining_handles();
2526 let (ordinal, inlined, num_bytes, num_handles) =
2527 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
2528
2529 let member_inline_size = match ordinal {
2530 1 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2531 2 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
2532 _ => return Err(fidl::Error::UnknownUnionTag),
2533 };
2534
2535 if inlined != (member_inline_size <= 4) {
2536 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2537 }
2538 let _inner_offset;
2539 if inlined {
2540 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
2541 _inner_offset = offset + 8;
2542 } else {
2543 depth.increment()?;
2544 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2545 }
2546 match ordinal {
2547 1 => {
2548 #[allow(irrefutable_let_patterns)]
2549 if let PreferredLifetimeInfo::PreferredUntil(_) = self {
2550 } else {
2552 *self = PreferredLifetimeInfo::PreferredUntil(fidl::new_empty!(i64, D));
2554 }
2555 #[allow(irrefutable_let_patterns)]
2556 if let PreferredLifetimeInfo::PreferredUntil(ref mut val) = self {
2557 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
2558 } else {
2559 unreachable!()
2560 }
2561 }
2562 2 => {
2563 #[allow(irrefutable_let_patterns)]
2564 if let PreferredLifetimeInfo::Deprecated(_) = self {
2565 } else {
2567 *self = PreferredLifetimeInfo::Deprecated(fidl::new_empty!(Empty, D));
2569 }
2570 #[allow(irrefutable_let_patterns)]
2571 if let PreferredLifetimeInfo::Deprecated(ref mut val) = self {
2572 fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
2573 } else {
2574 unreachable!()
2575 }
2576 }
2577 ordinal => panic!("unexpected ordinal {:?}", ordinal),
2578 }
2579 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
2580 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2581 }
2582 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2583 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2584 }
2585 Ok(())
2586 }
2587 }
2588}