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 NetworkType = String;
13
14pub const MAX_CHANNELS: u16 = 200;
20
21pub const MAX_NETWORK_TYPES: u16 = 16;
29
30pub const MAX_NET_TYPE_LEN: u16 = 64;
35
36pub const MAX_STREAM_SET_SIZE: u16 = 32;
39
40pub const NET_TYPE_RAW_6_LOWPAN: &str = "fuchsia.lowpan.net_type.6lowpan";
41
42pub const NET_TYPE_THREAD_1_X: &str = "org.threadgroup.std.thread.1";
43
44pub const NET_TYPE_UNKNOWN_802_15_4_PID: &str = "fuchsia.lowpan.net_type.802.15.4.pid";
45
46pub const NET_TYPE_ZIGBEE_IP_1_X: &str = "org.zigbee.std.zigbee-ip.1";
47
48#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
53pub enum ConnectivityState {
54 Inactive,
62 Ready,
73 Offline,
84 Attaching,
103 Attached,
119 Isolated,
135 Commissioning,
142 #[doc(hidden)]
143 __SourceBreaking { unknown_ordinal: i32 },
144}
145
146#[macro_export]
148macro_rules! ConnectivityStateUnknown {
149 () => {
150 _
151 };
152}
153
154impl ConnectivityState {
155 #[inline]
156 pub fn from_primitive(prim: i32) -> Option<Self> {
157 match prim {
158 1 => Some(Self::Inactive),
159 2 => Some(Self::Ready),
160 3 => Some(Self::Offline),
161 4 => Some(Self::Attaching),
162 5 => Some(Self::Attached),
163 6 => Some(Self::Isolated),
164 7 => Some(Self::Commissioning),
165 _ => None,
166 }
167 }
168
169 #[inline]
170 pub fn from_primitive_allow_unknown(prim: i32) -> Self {
171 match prim {
172 1 => Self::Inactive,
173 2 => Self::Ready,
174 3 => Self::Offline,
175 4 => Self::Attaching,
176 5 => Self::Attached,
177 6 => Self::Isolated,
178 7 => Self::Commissioning,
179 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
180 }
181 }
182
183 #[inline]
184 pub fn unknown() -> Self {
185 Self::__SourceBreaking { unknown_ordinal: 0x7fffffff }
186 }
187
188 #[inline]
189 pub const fn into_primitive(self) -> i32 {
190 match self {
191 Self::Inactive => 1,
192 Self::Ready => 2,
193 Self::Offline => 3,
194 Self::Attaching => 4,
195 Self::Attached => 5,
196 Self::Isolated => 6,
197 Self::Commissioning => 7,
198 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
199 }
200 }
201
202 #[inline]
203 pub fn is_unknown(&self) -> bool {
204 match self {
205 Self::__SourceBreaking { unknown_ordinal: _ } => true,
206 _ => false,
207 }
208 }
209}
210
211#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
215pub enum Role {
216 Detached,
220 EndDevice,
223 Router,
231 SleepyEndDevice,
244 SleepyRouter,
252 Leader,
262 Coordinator,
266 #[doc(hidden)]
267 __SourceBreaking { unknown_ordinal: i32 },
268}
269
270#[macro_export]
272macro_rules! RoleUnknown {
273 () => {
274 _
275 };
276}
277
278impl Role {
279 #[inline]
280 pub fn from_primitive(prim: i32) -> Option<Self> {
281 match prim {
282 1 => Some(Self::Detached),
283 2 => Some(Self::EndDevice),
284 3 => Some(Self::Router),
285 4 => Some(Self::SleepyEndDevice),
286 5 => Some(Self::SleepyRouter),
287 6 => Some(Self::Leader),
288 7 => Some(Self::Coordinator),
289 _ => None,
290 }
291 }
292
293 #[inline]
294 pub fn from_primitive_allow_unknown(prim: i32) -> Self {
295 match prim {
296 1 => Self::Detached,
297 2 => Self::EndDevice,
298 3 => Self::Router,
299 4 => Self::SleepyEndDevice,
300 5 => Self::SleepyRouter,
301 6 => Self::Leader,
302 7 => Self::Coordinator,
303 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
304 }
305 }
306
307 #[inline]
308 pub fn unknown() -> Self {
309 Self::__SourceBreaking { unknown_ordinal: 0x7fffffff }
310 }
311
312 #[inline]
313 pub const fn into_primitive(self) -> i32 {
314 match self {
315 Self::Detached => 1,
316 Self::EndDevice => 2,
317 Self::Router => 3,
318 Self::SleepyEndDevice => 4,
319 Self::SleepyRouter => 5,
320 Self::Leader => 6,
321 Self::Coordinator => 7,
322 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
323 }
324 }
325
326 #[inline]
327 pub fn is_unknown(&self) -> bool {
328 match self {
329 Self::__SourceBreaking { unknown_ordinal: _ } => true,
330 _ => false,
331 }
332 }
333}
334
335#[derive(Clone, Debug, PartialEq)]
336pub struct CountersGetResponse {
337 pub counters: AllCounters,
338}
339
340impl fidl::Persistable for CountersGetResponse {}
341
342#[derive(Clone, Debug, PartialEq)]
343pub struct CountersResetResponse {
344 pub counters: AllCounters,
345}
346
347impl fidl::Persistable for CountersResetResponse {}
348
349#[derive(Clone, Debug, PartialEq)]
350pub struct DeviceExtraGetCredentialResponse {
351 pub credential: Option<Box<Credential>>,
352}
353
354impl fidl::Persistable for DeviceExtraGetCredentialResponse {}
355
356#[derive(Clone, Debug, PartialEq)]
357pub struct DeviceExtraGetCurrentMacAddressResponse {
358 pub address: fidl_fuchsia_lowpan__common::MacAddress,
359}
360
361impl fidl::Persistable for DeviceExtraGetCurrentMacAddressResponse {}
362
363#[derive(Clone, Debug, PartialEq)]
364pub struct DeviceExtraWatchIdentityResponse {
365 pub identity: Identity,
366}
367
368impl fidl::Persistable for DeviceExtraWatchIdentityResponse {}
369
370#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
371pub struct DeviceGetSupportedNetworkTypesResponse {
372 pub network_types: Vec<String>,
373}
374
375impl fidl::Persistable for DeviceGetSupportedNetworkTypesResponse {}
376
377#[derive(Clone, Debug, PartialEq)]
378pub struct DeviceProvisionNetworkRequest {
379 pub params: ProvisioningParams,
380}
381
382impl fidl::Persistable for DeviceProvisionNetworkRequest {}
383
384#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
385pub struct DeviceSetActiveRequest {
386 pub active: bool,
387}
388
389impl fidl::Persistable for DeviceSetActiveRequest {}
390
391#[derive(Clone, Debug, PartialEq)]
392pub struct DeviceWatchDeviceStateResponse {
393 pub device_combined_state: DeviceState,
394}
395
396impl fidl::Persistable for DeviceWatchDeviceStateResponse {}
397
398#[derive(Clone, Debug, PartialEq)]
399pub struct EnergyScanResultStreamNextResponse {
400 pub results: Vec<EnergyScanResult>,
401}
402
403impl fidl::Persistable for EnergyScanResultStreamNextResponse {}
404
405#[derive(Clone, Debug, PartialEq)]
406pub struct ProvisioningParams {
407 pub identity: Identity,
409 pub credential: Option<Box<Credential>>,
412}
413
414impl fidl::Persistable for ProvisioningParams {}
415
416#[derive(Clone, Debug, Default, PartialEq)]
420pub struct AllCounters {
421 pub mac_tx: Option<MacCounters>,
423 pub mac_rx: Option<MacCounters>,
425 pub coex_tx: Option<CoexCounters>,
427 pub coex_rx: Option<CoexCounters>,
429 pub coex_saturated: Option<bool>,
433 pub ip_tx: Option<IpCounters>,
435 pub ip_rx: Option<IpCounters>,
437 #[doc(hidden)]
438 pub __source_breaking: fidl::marker::SourceBreaking,
439}
440
441impl fidl::Persistable for AllCounters {}
442
443#[derive(Clone, Debug, Default, PartialEq)]
449pub struct CoexCounters {
450 pub requests: Option<u64>,
452 pub grant_immediate: Option<u64>,
454 pub grant_wait: Option<u64>,
456 pub grant_wait_activated: Option<u64>,
459 pub grant_wait_timeout: Option<u64>,
461 pub grant_deactivated_during_request: Option<u64>,
464 pub delayed_grant: Option<u64>,
466 pub avg_delay_request_to_grant_usec: Option<u32>,
468 pub grant_none: Option<u64>,
472 #[doc(hidden)]
473 pub __source_breaking: fidl::marker::SourceBreaking,
474}
475
476impl fidl::Persistable for CoexCounters {}
477
478#[derive(Clone, Debug, Default, PartialEq)]
487pub struct DeviceState {
488 pub connectivity_state: Option<ConnectivityState>,
493 pub role: Option<Role>,
498 #[doc(hidden)]
499 pub __source_breaking: fidl::marker::SourceBreaking,
500}
501
502impl fidl::Persistable for DeviceState {}
503
504#[derive(Clone, Debug, Default, PartialEq)]
506pub struct EnergyScanParameters {
507 pub channels: Option<Vec<u16>>,
511 pub dwell_time_ms: Option<u32>,
530 #[doc(hidden)]
531 pub __source_breaking: fidl::marker::SourceBreaking,
532}
533
534impl fidl::Persistable for EnergyScanParameters {}
535
536#[derive(Clone, Debug, Default, PartialEq)]
538pub struct EnergyScanResult {
539 pub channel_index: Option<u16>,
541 pub max_rssi: Option<i32>,
543 pub min_rssi: Option<i32>,
545 #[doc(hidden)]
546 pub __source_breaking: fidl::marker::SourceBreaking,
547}
548
549impl fidl::Persistable for EnergyScanResult {}
550
551#[derive(Clone, Debug, Default, PartialEq)]
552pub struct Identity {
553 pub raw_name: Option<Vec<u8>>,
563 pub net_type: Option<String>,
573 pub channel: Option<u16>,
575 pub panid: Option<u16>,
577 pub mesh_local_prefix: Option<fidl_fuchsia_net__common::Ipv6AddressWithPrefix>,
590 pub xpanid: Option<[u8; 8]>,
592 #[doc(hidden)]
593 pub __source_breaking: fidl::marker::SourceBreaking,
594}
595
596impl fidl::Persistable for Identity {}
597
598#[derive(Clone, Debug, Default, PartialEq)]
600pub struct IpCounters {
601 pub success: Option<u32>,
603 pub failure: Option<u32>,
605 #[doc(hidden)]
606 pub __source_breaking: fidl::marker::SourceBreaking,
607}
608
609impl fidl::Persistable for IpCounters {}
610
611#[derive(Clone, Debug, Default, PartialEq)]
615pub struct MacCounters {
616 pub total: Option<u32>,
618 pub unicast: Option<u32>,
620 pub broadcast: Option<u32>,
622 pub ack_requested: Option<u32>,
624 pub acked: Option<u32>,
626 pub no_ack_requested: Option<u32>,
628 pub data: Option<u32>,
630 pub data_poll: Option<u32>,
632 pub beacon: Option<u32>,
634 pub beacon_request: Option<u32>,
636 pub other: Option<u32>,
638 pub address_filtered: Option<u32>,
641 pub retries: Option<u32>,
644 pub direct_max_retry_expiry: Option<u32>,
647 pub indirect_max_retry_expiry: Option<u32>,
650 pub dest_addr_filtered: Option<u32>,
653 pub duplicated: Option<u32>,
656 pub err_no_frame: Option<u32>,
659 pub err_unknown_neighbor: Option<u32>,
662 pub err_invalid_src_addr: Option<u32>,
665 pub err_sec: Option<u32>,
668 pub err_fcs: Option<u32>,
671 pub err_cca: Option<u32>,
674 pub err_abort: Option<u32>,
677 pub err_busy_channel: Option<u32>,
680 pub err_other: Option<u32>,
682 #[doc(hidden)]
683 pub __source_breaking: fidl::marker::SourceBreaking,
684}
685
686impl fidl::Persistable for MacCounters {}
687
688#[derive(Clone, Debug)]
696pub enum Credential {
697 NetworkKey(Vec<u8>),
705 #[doc(hidden)]
706 __SourceBreaking { unknown_ordinal: u64 },
707}
708
709#[macro_export]
711macro_rules! CredentialUnknown {
712 () => {
713 _
714 };
715}
716
717impl PartialEq for Credential {
719 fn eq(&self, other: &Self) -> bool {
720 match (self, other) {
721 (Self::NetworkKey(x), Self::NetworkKey(y)) => *x == *y,
722 _ => false,
723 }
724 }
725}
726
727impl Credential {
728 #[inline]
729 pub fn ordinal(&self) -> u64 {
730 match *self {
731 Self::NetworkKey(_) => 1,
732 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
733 }
734 }
735
736 #[inline]
737 pub fn unknown_variant_for_testing() -> Self {
738 Self::__SourceBreaking { unknown_ordinal: 0 }
739 }
740
741 #[inline]
742 pub fn is_unknown(&self) -> bool {
743 match self {
744 Self::__SourceBreaking { .. } => true,
745 _ => false,
746 }
747 }
748}
749
750impl fidl::Persistable for Credential {}
751
752mod internal {
753 use super::*;
754 unsafe impl fidl::encoding::TypeMarker for ConnectivityState {
755 type Owned = Self;
756
757 #[inline(always)]
758 fn inline_align(_context: fidl::encoding::Context) -> usize {
759 std::mem::align_of::<i32>()
760 }
761
762 #[inline(always)]
763 fn inline_size(_context: fidl::encoding::Context) -> usize {
764 std::mem::size_of::<i32>()
765 }
766
767 #[inline(always)]
768 fn encode_is_copy() -> bool {
769 false
770 }
771
772 #[inline(always)]
773 fn decode_is_copy() -> bool {
774 false
775 }
776 }
777
778 impl fidl::encoding::ValueTypeMarker for ConnectivityState {
779 type Borrowed<'a> = Self;
780 #[inline(always)]
781 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
782 *value
783 }
784 }
785
786 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
787 for ConnectivityState
788 {
789 #[inline]
790 unsafe fn encode(
791 self,
792 encoder: &mut fidl::encoding::Encoder<'_, D>,
793 offset: usize,
794 _depth: fidl::encoding::Depth,
795 ) -> fidl::Result<()> {
796 encoder.debug_check_bounds::<Self>(offset);
797 encoder.write_num(self.into_primitive(), offset);
798 Ok(())
799 }
800 }
801
802 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectivityState {
803 #[inline(always)]
804 fn new_empty() -> Self {
805 Self::unknown()
806 }
807
808 #[inline]
809 unsafe fn decode(
810 &mut self,
811 decoder: &mut fidl::encoding::Decoder<'_, D>,
812 offset: usize,
813 _depth: fidl::encoding::Depth,
814 ) -> fidl::Result<()> {
815 decoder.debug_check_bounds::<Self>(offset);
816 let prim = decoder.read_num::<i32>(offset);
817
818 *self = Self::from_primitive_allow_unknown(prim);
819 Ok(())
820 }
821 }
822 unsafe impl fidl::encoding::TypeMarker for Role {
823 type Owned = Self;
824
825 #[inline(always)]
826 fn inline_align(_context: fidl::encoding::Context) -> usize {
827 std::mem::align_of::<i32>()
828 }
829
830 #[inline(always)]
831 fn inline_size(_context: fidl::encoding::Context) -> usize {
832 std::mem::size_of::<i32>()
833 }
834
835 #[inline(always)]
836 fn encode_is_copy() -> bool {
837 false
838 }
839
840 #[inline(always)]
841 fn decode_is_copy() -> bool {
842 false
843 }
844 }
845
846 impl fidl::encoding::ValueTypeMarker for Role {
847 type Borrowed<'a> = Self;
848 #[inline(always)]
849 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
850 *value
851 }
852 }
853
854 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Role {
855 #[inline]
856 unsafe fn encode(
857 self,
858 encoder: &mut fidl::encoding::Encoder<'_, D>,
859 offset: usize,
860 _depth: fidl::encoding::Depth,
861 ) -> fidl::Result<()> {
862 encoder.debug_check_bounds::<Self>(offset);
863 encoder.write_num(self.into_primitive(), offset);
864 Ok(())
865 }
866 }
867
868 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Role {
869 #[inline(always)]
870 fn new_empty() -> Self {
871 Self::unknown()
872 }
873
874 #[inline]
875 unsafe fn decode(
876 &mut self,
877 decoder: &mut fidl::encoding::Decoder<'_, D>,
878 offset: usize,
879 _depth: fidl::encoding::Depth,
880 ) -> fidl::Result<()> {
881 decoder.debug_check_bounds::<Self>(offset);
882 let prim = decoder.read_num::<i32>(offset);
883
884 *self = Self::from_primitive_allow_unknown(prim);
885 Ok(())
886 }
887 }
888
889 impl fidl::encoding::ValueTypeMarker for CountersGetResponse {
890 type Borrowed<'a> = &'a Self;
891 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
892 value
893 }
894 }
895
896 unsafe impl fidl::encoding::TypeMarker for CountersGetResponse {
897 type Owned = Self;
898
899 #[inline(always)]
900 fn inline_align(_context: fidl::encoding::Context) -> usize {
901 8
902 }
903
904 #[inline(always)]
905 fn inline_size(_context: fidl::encoding::Context) -> usize {
906 16
907 }
908 }
909
910 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CountersGetResponse, D>
911 for &CountersGetResponse
912 {
913 #[inline]
914 unsafe fn encode(
915 self,
916 encoder: &mut fidl::encoding::Encoder<'_, D>,
917 offset: usize,
918 _depth: fidl::encoding::Depth,
919 ) -> fidl::Result<()> {
920 encoder.debug_check_bounds::<CountersGetResponse>(offset);
921 fidl::encoding::Encode::<CountersGetResponse, D>::encode(
923 (<AllCounters as fidl::encoding::ValueTypeMarker>::borrow(&self.counters),),
924 encoder,
925 offset,
926 _depth,
927 )
928 }
929 }
930 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AllCounters, D>>
931 fidl::encoding::Encode<CountersGetResponse, D> for (T0,)
932 {
933 #[inline]
934 unsafe fn encode(
935 self,
936 encoder: &mut fidl::encoding::Encoder<'_, D>,
937 offset: usize,
938 depth: fidl::encoding::Depth,
939 ) -> fidl::Result<()> {
940 encoder.debug_check_bounds::<CountersGetResponse>(offset);
941 self.0.encode(encoder, offset + 0, depth)?;
945 Ok(())
946 }
947 }
948
949 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CountersGetResponse {
950 #[inline(always)]
951 fn new_empty() -> Self {
952 Self { counters: fidl::new_empty!(AllCounters, D) }
953 }
954
955 #[inline]
956 unsafe fn decode(
957 &mut self,
958 decoder: &mut fidl::encoding::Decoder<'_, D>,
959 offset: usize,
960 _depth: fidl::encoding::Depth,
961 ) -> fidl::Result<()> {
962 decoder.debug_check_bounds::<Self>(offset);
963 fidl::decode!(AllCounters, D, &mut self.counters, decoder, offset + 0, _depth)?;
965 Ok(())
966 }
967 }
968
969 impl fidl::encoding::ValueTypeMarker for CountersResetResponse {
970 type Borrowed<'a> = &'a Self;
971 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
972 value
973 }
974 }
975
976 unsafe impl fidl::encoding::TypeMarker for CountersResetResponse {
977 type Owned = Self;
978
979 #[inline(always)]
980 fn inline_align(_context: fidl::encoding::Context) -> usize {
981 8
982 }
983
984 #[inline(always)]
985 fn inline_size(_context: fidl::encoding::Context) -> usize {
986 16
987 }
988 }
989
990 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CountersResetResponse, D>
991 for &CountersResetResponse
992 {
993 #[inline]
994 unsafe fn encode(
995 self,
996 encoder: &mut fidl::encoding::Encoder<'_, D>,
997 offset: usize,
998 _depth: fidl::encoding::Depth,
999 ) -> fidl::Result<()> {
1000 encoder.debug_check_bounds::<CountersResetResponse>(offset);
1001 fidl::encoding::Encode::<CountersResetResponse, D>::encode(
1003 (<AllCounters as fidl::encoding::ValueTypeMarker>::borrow(&self.counters),),
1004 encoder,
1005 offset,
1006 _depth,
1007 )
1008 }
1009 }
1010 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AllCounters, D>>
1011 fidl::encoding::Encode<CountersResetResponse, D> for (T0,)
1012 {
1013 #[inline]
1014 unsafe fn encode(
1015 self,
1016 encoder: &mut fidl::encoding::Encoder<'_, D>,
1017 offset: usize,
1018 depth: fidl::encoding::Depth,
1019 ) -> fidl::Result<()> {
1020 encoder.debug_check_bounds::<CountersResetResponse>(offset);
1021 self.0.encode(encoder, offset + 0, depth)?;
1025 Ok(())
1026 }
1027 }
1028
1029 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CountersResetResponse {
1030 #[inline(always)]
1031 fn new_empty() -> Self {
1032 Self { counters: fidl::new_empty!(AllCounters, D) }
1033 }
1034
1035 #[inline]
1036 unsafe fn decode(
1037 &mut self,
1038 decoder: &mut fidl::encoding::Decoder<'_, D>,
1039 offset: usize,
1040 _depth: fidl::encoding::Depth,
1041 ) -> fidl::Result<()> {
1042 decoder.debug_check_bounds::<Self>(offset);
1043 fidl::decode!(AllCounters, D, &mut self.counters, decoder, offset + 0, _depth)?;
1045 Ok(())
1046 }
1047 }
1048
1049 impl fidl::encoding::ValueTypeMarker for DeviceExtraGetCredentialResponse {
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 DeviceExtraGetCredentialResponse {
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>
1071 fidl::encoding::Encode<DeviceExtraGetCredentialResponse, D>
1072 for &DeviceExtraGetCredentialResponse
1073 {
1074 #[inline]
1075 unsafe fn encode(
1076 self,
1077 encoder: &mut fidl::encoding::Encoder<'_, D>,
1078 offset: usize,
1079 _depth: fidl::encoding::Depth,
1080 ) -> fidl::Result<()> {
1081 encoder.debug_check_bounds::<DeviceExtraGetCredentialResponse>(offset);
1082 fidl::encoding::Encode::<DeviceExtraGetCredentialResponse, D>::encode(
1084 (
1085 <fidl::encoding::OptionalUnion<Credential> as fidl::encoding::ValueTypeMarker>::borrow(&self.credential),
1086 ),
1087 encoder, offset, _depth
1088 )
1089 }
1090 }
1091 unsafe impl<
1092 D: fidl::encoding::ResourceDialect,
1093 T0: fidl::encoding::Encode<fidl::encoding::OptionalUnion<Credential>, D>,
1094 > fidl::encoding::Encode<DeviceExtraGetCredentialResponse, D> for (T0,)
1095 {
1096 #[inline]
1097 unsafe fn encode(
1098 self,
1099 encoder: &mut fidl::encoding::Encoder<'_, D>,
1100 offset: usize,
1101 depth: fidl::encoding::Depth,
1102 ) -> fidl::Result<()> {
1103 encoder.debug_check_bounds::<DeviceExtraGetCredentialResponse>(offset);
1104 self.0.encode(encoder, offset + 0, depth)?;
1108 Ok(())
1109 }
1110 }
1111
1112 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1113 for DeviceExtraGetCredentialResponse
1114 {
1115 #[inline(always)]
1116 fn new_empty() -> Self {
1117 Self { credential: fidl::new_empty!(fidl::encoding::OptionalUnion<Credential>, D) }
1118 }
1119
1120 #[inline]
1121 unsafe fn decode(
1122 &mut self,
1123 decoder: &mut fidl::encoding::Decoder<'_, D>,
1124 offset: usize,
1125 _depth: fidl::encoding::Depth,
1126 ) -> fidl::Result<()> {
1127 decoder.debug_check_bounds::<Self>(offset);
1128 fidl::decode!(
1130 fidl::encoding::OptionalUnion<Credential>,
1131 D,
1132 &mut self.credential,
1133 decoder,
1134 offset + 0,
1135 _depth
1136 )?;
1137 Ok(())
1138 }
1139 }
1140
1141 impl fidl::encoding::ValueTypeMarker for DeviceExtraGetCurrentMacAddressResponse {
1142 type Borrowed<'a> = &'a Self;
1143 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1144 value
1145 }
1146 }
1147
1148 unsafe impl fidl::encoding::TypeMarker for DeviceExtraGetCurrentMacAddressResponse {
1149 type Owned = Self;
1150
1151 #[inline(always)]
1152 fn inline_align(_context: fidl::encoding::Context) -> usize {
1153 1
1154 }
1155
1156 #[inline(always)]
1157 fn inline_size(_context: fidl::encoding::Context) -> usize {
1158 8
1159 }
1160 }
1161
1162 unsafe impl<D: fidl::encoding::ResourceDialect>
1163 fidl::encoding::Encode<DeviceExtraGetCurrentMacAddressResponse, D>
1164 for &DeviceExtraGetCurrentMacAddressResponse
1165 {
1166 #[inline]
1167 unsafe fn encode(
1168 self,
1169 encoder: &mut fidl::encoding::Encoder<'_, D>,
1170 offset: usize,
1171 _depth: fidl::encoding::Depth,
1172 ) -> fidl::Result<()> {
1173 encoder.debug_check_bounds::<DeviceExtraGetCurrentMacAddressResponse>(offset);
1174 fidl::encoding::Encode::<DeviceExtraGetCurrentMacAddressResponse, D>::encode(
1176 (
1177 <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
1178 ),
1179 encoder, offset, _depth
1180 )
1181 }
1182 }
1183 unsafe impl<
1184 D: fidl::encoding::ResourceDialect,
1185 T0: fidl::encoding::Encode<fidl_fuchsia_lowpan__common::MacAddress, D>,
1186 > fidl::encoding::Encode<DeviceExtraGetCurrentMacAddressResponse, D> for (T0,)
1187 {
1188 #[inline]
1189 unsafe fn encode(
1190 self,
1191 encoder: &mut fidl::encoding::Encoder<'_, D>,
1192 offset: usize,
1193 depth: fidl::encoding::Depth,
1194 ) -> fidl::Result<()> {
1195 encoder.debug_check_bounds::<DeviceExtraGetCurrentMacAddressResponse>(offset);
1196 self.0.encode(encoder, offset + 0, depth)?;
1200 Ok(())
1201 }
1202 }
1203
1204 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1205 for DeviceExtraGetCurrentMacAddressResponse
1206 {
1207 #[inline(always)]
1208 fn new_empty() -> Self {
1209 Self { address: fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D) }
1210 }
1211
1212 #[inline]
1213 unsafe fn decode(
1214 &mut self,
1215 decoder: &mut fidl::encoding::Decoder<'_, D>,
1216 offset: usize,
1217 _depth: fidl::encoding::Depth,
1218 ) -> fidl::Result<()> {
1219 decoder.debug_check_bounds::<Self>(offset);
1220 fidl::decode!(
1222 fidl_fuchsia_lowpan__common::MacAddress,
1223 D,
1224 &mut self.address,
1225 decoder,
1226 offset + 0,
1227 _depth
1228 )?;
1229 Ok(())
1230 }
1231 }
1232
1233 impl fidl::encoding::ValueTypeMarker for DeviceExtraWatchIdentityResponse {
1234 type Borrowed<'a> = &'a Self;
1235 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1236 value
1237 }
1238 }
1239
1240 unsafe impl fidl::encoding::TypeMarker for DeviceExtraWatchIdentityResponse {
1241 type Owned = Self;
1242
1243 #[inline(always)]
1244 fn inline_align(_context: fidl::encoding::Context) -> usize {
1245 8
1246 }
1247
1248 #[inline(always)]
1249 fn inline_size(_context: fidl::encoding::Context) -> usize {
1250 16
1251 }
1252 }
1253
1254 unsafe impl<D: fidl::encoding::ResourceDialect>
1255 fidl::encoding::Encode<DeviceExtraWatchIdentityResponse, D>
1256 for &DeviceExtraWatchIdentityResponse
1257 {
1258 #[inline]
1259 unsafe fn encode(
1260 self,
1261 encoder: &mut fidl::encoding::Encoder<'_, D>,
1262 offset: usize,
1263 _depth: fidl::encoding::Depth,
1264 ) -> fidl::Result<()> {
1265 encoder.debug_check_bounds::<DeviceExtraWatchIdentityResponse>(offset);
1266 fidl::encoding::Encode::<DeviceExtraWatchIdentityResponse, D>::encode(
1268 (<Identity as fidl::encoding::ValueTypeMarker>::borrow(&self.identity),),
1269 encoder,
1270 offset,
1271 _depth,
1272 )
1273 }
1274 }
1275 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Identity, D>>
1276 fidl::encoding::Encode<DeviceExtraWatchIdentityResponse, D> for (T0,)
1277 {
1278 #[inline]
1279 unsafe fn encode(
1280 self,
1281 encoder: &mut fidl::encoding::Encoder<'_, D>,
1282 offset: usize,
1283 depth: fidl::encoding::Depth,
1284 ) -> fidl::Result<()> {
1285 encoder.debug_check_bounds::<DeviceExtraWatchIdentityResponse>(offset);
1286 self.0.encode(encoder, offset + 0, depth)?;
1290 Ok(())
1291 }
1292 }
1293
1294 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1295 for DeviceExtraWatchIdentityResponse
1296 {
1297 #[inline(always)]
1298 fn new_empty() -> Self {
1299 Self { identity: fidl::new_empty!(Identity, D) }
1300 }
1301
1302 #[inline]
1303 unsafe fn decode(
1304 &mut self,
1305 decoder: &mut fidl::encoding::Decoder<'_, D>,
1306 offset: usize,
1307 _depth: fidl::encoding::Depth,
1308 ) -> fidl::Result<()> {
1309 decoder.debug_check_bounds::<Self>(offset);
1310 fidl::decode!(Identity, D, &mut self.identity, decoder, offset + 0, _depth)?;
1312 Ok(())
1313 }
1314 }
1315
1316 impl fidl::encoding::ValueTypeMarker for DeviceGetSupportedNetworkTypesResponse {
1317 type Borrowed<'a> = &'a Self;
1318 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1319 value
1320 }
1321 }
1322
1323 unsafe impl fidl::encoding::TypeMarker for DeviceGetSupportedNetworkTypesResponse {
1324 type Owned = Self;
1325
1326 #[inline(always)]
1327 fn inline_align(_context: fidl::encoding::Context) -> usize {
1328 8
1329 }
1330
1331 #[inline(always)]
1332 fn inline_size(_context: fidl::encoding::Context) -> usize {
1333 16
1334 }
1335 }
1336
1337 unsafe impl<D: fidl::encoding::ResourceDialect>
1338 fidl::encoding::Encode<DeviceGetSupportedNetworkTypesResponse, D>
1339 for &DeviceGetSupportedNetworkTypesResponse
1340 {
1341 #[inline]
1342 unsafe fn encode(
1343 self,
1344 encoder: &mut fidl::encoding::Encoder<'_, D>,
1345 offset: usize,
1346 _depth: fidl::encoding::Depth,
1347 ) -> fidl::Result<()> {
1348 encoder.debug_check_bounds::<DeviceGetSupportedNetworkTypesResponse>(offset);
1349 fidl::encoding::Encode::<DeviceGetSupportedNetworkTypesResponse, D>::encode(
1351 (
1352 <fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.network_types),
1353 ),
1354 encoder, offset, _depth
1355 )
1356 }
1357 }
1358 unsafe impl<
1359 D: fidl::encoding::ResourceDialect,
1360 T0: fidl::encoding::Encode<
1361 fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1362 D,
1363 >,
1364 > fidl::encoding::Encode<DeviceGetSupportedNetworkTypesResponse, D> for (T0,)
1365 {
1366 #[inline]
1367 unsafe fn encode(
1368 self,
1369 encoder: &mut fidl::encoding::Encoder<'_, D>,
1370 offset: usize,
1371 depth: fidl::encoding::Depth,
1372 ) -> fidl::Result<()> {
1373 encoder.debug_check_bounds::<DeviceGetSupportedNetworkTypesResponse>(offset);
1374 self.0.encode(encoder, offset + 0, depth)?;
1378 Ok(())
1379 }
1380 }
1381
1382 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1383 for DeviceGetSupportedNetworkTypesResponse
1384 {
1385 #[inline(always)]
1386 fn new_empty() -> Self {
1387 Self {
1388 network_types: fidl::new_empty!(
1389 fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1390 D
1391 ),
1392 }
1393 }
1394
1395 #[inline]
1396 unsafe fn decode(
1397 &mut self,
1398 decoder: &mut fidl::encoding::Decoder<'_, D>,
1399 offset: usize,
1400 _depth: fidl::encoding::Depth,
1401 ) -> fidl::Result<()> {
1402 decoder.debug_check_bounds::<Self>(offset);
1403 fidl::decode!(
1405 fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1406 D,
1407 &mut self.network_types,
1408 decoder,
1409 offset + 0,
1410 _depth
1411 )?;
1412 Ok(())
1413 }
1414 }
1415
1416 impl fidl::encoding::ValueTypeMarker for DeviceProvisionNetworkRequest {
1417 type Borrowed<'a> = &'a Self;
1418 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1419 value
1420 }
1421 }
1422
1423 unsafe impl fidl::encoding::TypeMarker for DeviceProvisionNetworkRequest {
1424 type Owned = Self;
1425
1426 #[inline(always)]
1427 fn inline_align(_context: fidl::encoding::Context) -> usize {
1428 8
1429 }
1430
1431 #[inline(always)]
1432 fn inline_size(_context: fidl::encoding::Context) -> usize {
1433 32
1434 }
1435 }
1436
1437 unsafe impl<D: fidl::encoding::ResourceDialect>
1438 fidl::encoding::Encode<DeviceProvisionNetworkRequest, D>
1439 for &DeviceProvisionNetworkRequest
1440 {
1441 #[inline]
1442 unsafe fn encode(
1443 self,
1444 encoder: &mut fidl::encoding::Encoder<'_, D>,
1445 offset: usize,
1446 _depth: fidl::encoding::Depth,
1447 ) -> fidl::Result<()> {
1448 encoder.debug_check_bounds::<DeviceProvisionNetworkRequest>(offset);
1449 fidl::encoding::Encode::<DeviceProvisionNetworkRequest, D>::encode(
1451 (<ProvisioningParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),),
1452 encoder,
1453 offset,
1454 _depth,
1455 )
1456 }
1457 }
1458 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ProvisioningParams, D>>
1459 fidl::encoding::Encode<DeviceProvisionNetworkRequest, D> for (T0,)
1460 {
1461 #[inline]
1462 unsafe fn encode(
1463 self,
1464 encoder: &mut fidl::encoding::Encoder<'_, D>,
1465 offset: usize,
1466 depth: fidl::encoding::Depth,
1467 ) -> fidl::Result<()> {
1468 encoder.debug_check_bounds::<DeviceProvisionNetworkRequest>(offset);
1469 self.0.encode(encoder, offset + 0, depth)?;
1473 Ok(())
1474 }
1475 }
1476
1477 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1478 for DeviceProvisionNetworkRequest
1479 {
1480 #[inline(always)]
1481 fn new_empty() -> Self {
1482 Self { params: fidl::new_empty!(ProvisioningParams, D) }
1483 }
1484
1485 #[inline]
1486 unsafe fn decode(
1487 &mut self,
1488 decoder: &mut fidl::encoding::Decoder<'_, D>,
1489 offset: usize,
1490 _depth: fidl::encoding::Depth,
1491 ) -> fidl::Result<()> {
1492 decoder.debug_check_bounds::<Self>(offset);
1493 fidl::decode!(ProvisioningParams, D, &mut self.params, decoder, offset + 0, _depth)?;
1495 Ok(())
1496 }
1497 }
1498
1499 impl fidl::encoding::ValueTypeMarker for DeviceSetActiveRequest {
1500 type Borrowed<'a> = &'a Self;
1501 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1502 value
1503 }
1504 }
1505
1506 unsafe impl fidl::encoding::TypeMarker for DeviceSetActiveRequest {
1507 type Owned = Self;
1508
1509 #[inline(always)]
1510 fn inline_align(_context: fidl::encoding::Context) -> usize {
1511 1
1512 }
1513
1514 #[inline(always)]
1515 fn inline_size(_context: fidl::encoding::Context) -> usize {
1516 1
1517 }
1518 }
1519
1520 unsafe impl<D: fidl::encoding::ResourceDialect>
1521 fidl::encoding::Encode<DeviceSetActiveRequest, D> for &DeviceSetActiveRequest
1522 {
1523 #[inline]
1524 unsafe fn encode(
1525 self,
1526 encoder: &mut fidl::encoding::Encoder<'_, D>,
1527 offset: usize,
1528 _depth: fidl::encoding::Depth,
1529 ) -> fidl::Result<()> {
1530 encoder.debug_check_bounds::<DeviceSetActiveRequest>(offset);
1531 fidl::encoding::Encode::<DeviceSetActiveRequest, D>::encode(
1533 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.active),),
1534 encoder,
1535 offset,
1536 _depth,
1537 )
1538 }
1539 }
1540 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1541 fidl::encoding::Encode<DeviceSetActiveRequest, D> for (T0,)
1542 {
1543 #[inline]
1544 unsafe fn encode(
1545 self,
1546 encoder: &mut fidl::encoding::Encoder<'_, D>,
1547 offset: usize,
1548 depth: fidl::encoding::Depth,
1549 ) -> fidl::Result<()> {
1550 encoder.debug_check_bounds::<DeviceSetActiveRequest>(offset);
1551 self.0.encode(encoder, offset + 0, depth)?;
1555 Ok(())
1556 }
1557 }
1558
1559 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1560 for DeviceSetActiveRequest
1561 {
1562 #[inline(always)]
1563 fn new_empty() -> Self {
1564 Self { active: fidl::new_empty!(bool, D) }
1565 }
1566
1567 #[inline]
1568 unsafe fn decode(
1569 &mut self,
1570 decoder: &mut fidl::encoding::Decoder<'_, D>,
1571 offset: usize,
1572 _depth: fidl::encoding::Depth,
1573 ) -> fidl::Result<()> {
1574 decoder.debug_check_bounds::<Self>(offset);
1575 fidl::decode!(bool, D, &mut self.active, decoder, offset + 0, _depth)?;
1577 Ok(())
1578 }
1579 }
1580
1581 impl fidl::encoding::ValueTypeMarker for DeviceWatchDeviceStateResponse {
1582 type Borrowed<'a> = &'a Self;
1583 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1584 value
1585 }
1586 }
1587
1588 unsafe impl fidl::encoding::TypeMarker for DeviceWatchDeviceStateResponse {
1589 type Owned = Self;
1590
1591 #[inline(always)]
1592 fn inline_align(_context: fidl::encoding::Context) -> usize {
1593 8
1594 }
1595
1596 #[inline(always)]
1597 fn inline_size(_context: fidl::encoding::Context) -> usize {
1598 16
1599 }
1600 }
1601
1602 unsafe impl<D: fidl::encoding::ResourceDialect>
1603 fidl::encoding::Encode<DeviceWatchDeviceStateResponse, D>
1604 for &DeviceWatchDeviceStateResponse
1605 {
1606 #[inline]
1607 unsafe fn encode(
1608 self,
1609 encoder: &mut fidl::encoding::Encoder<'_, D>,
1610 offset: usize,
1611 _depth: fidl::encoding::Depth,
1612 ) -> fidl::Result<()> {
1613 encoder.debug_check_bounds::<DeviceWatchDeviceStateResponse>(offset);
1614 fidl::encoding::Encode::<DeviceWatchDeviceStateResponse, D>::encode(
1616 (<DeviceState as fidl::encoding::ValueTypeMarker>::borrow(
1617 &self.device_combined_state,
1618 ),),
1619 encoder,
1620 offset,
1621 _depth,
1622 )
1623 }
1624 }
1625 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<DeviceState, D>>
1626 fidl::encoding::Encode<DeviceWatchDeviceStateResponse, D> for (T0,)
1627 {
1628 #[inline]
1629 unsafe fn encode(
1630 self,
1631 encoder: &mut fidl::encoding::Encoder<'_, D>,
1632 offset: usize,
1633 depth: fidl::encoding::Depth,
1634 ) -> fidl::Result<()> {
1635 encoder.debug_check_bounds::<DeviceWatchDeviceStateResponse>(offset);
1636 self.0.encode(encoder, offset + 0, depth)?;
1640 Ok(())
1641 }
1642 }
1643
1644 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1645 for DeviceWatchDeviceStateResponse
1646 {
1647 #[inline(always)]
1648 fn new_empty() -> Self {
1649 Self { device_combined_state: fidl::new_empty!(DeviceState, D) }
1650 }
1651
1652 #[inline]
1653 unsafe fn decode(
1654 &mut self,
1655 decoder: &mut fidl::encoding::Decoder<'_, D>,
1656 offset: usize,
1657 _depth: fidl::encoding::Depth,
1658 ) -> fidl::Result<()> {
1659 decoder.debug_check_bounds::<Self>(offset);
1660 fidl::decode!(
1662 DeviceState,
1663 D,
1664 &mut self.device_combined_state,
1665 decoder,
1666 offset + 0,
1667 _depth
1668 )?;
1669 Ok(())
1670 }
1671 }
1672
1673 impl fidl::encoding::ValueTypeMarker for EnergyScanResultStreamNextResponse {
1674 type Borrowed<'a> = &'a Self;
1675 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1676 value
1677 }
1678 }
1679
1680 unsafe impl fidl::encoding::TypeMarker for EnergyScanResultStreamNextResponse {
1681 type Owned = Self;
1682
1683 #[inline(always)]
1684 fn inline_align(_context: fidl::encoding::Context) -> usize {
1685 8
1686 }
1687
1688 #[inline(always)]
1689 fn inline_size(_context: fidl::encoding::Context) -> usize {
1690 16
1691 }
1692 }
1693
1694 unsafe impl<D: fidl::encoding::ResourceDialect>
1695 fidl::encoding::Encode<EnergyScanResultStreamNextResponse, D>
1696 for &EnergyScanResultStreamNextResponse
1697 {
1698 #[inline]
1699 unsafe fn encode(
1700 self,
1701 encoder: &mut fidl::encoding::Encoder<'_, D>,
1702 offset: usize,
1703 _depth: fidl::encoding::Depth,
1704 ) -> fidl::Result<()> {
1705 encoder.debug_check_bounds::<EnergyScanResultStreamNextResponse>(offset);
1706 fidl::encoding::Encode::<EnergyScanResultStreamNextResponse, D>::encode(
1708 (
1709 <fidl::encoding::Vector<EnergyScanResult, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.results),
1710 ),
1711 encoder, offset, _depth
1712 )
1713 }
1714 }
1715 unsafe impl<
1716 D: fidl::encoding::ResourceDialect,
1717 T0: fidl::encoding::Encode<fidl::encoding::Vector<EnergyScanResult, 32>, D>,
1718 > fidl::encoding::Encode<EnergyScanResultStreamNextResponse, D> for (T0,)
1719 {
1720 #[inline]
1721 unsafe fn encode(
1722 self,
1723 encoder: &mut fidl::encoding::Encoder<'_, D>,
1724 offset: usize,
1725 depth: fidl::encoding::Depth,
1726 ) -> fidl::Result<()> {
1727 encoder.debug_check_bounds::<EnergyScanResultStreamNextResponse>(offset);
1728 self.0.encode(encoder, offset + 0, depth)?;
1732 Ok(())
1733 }
1734 }
1735
1736 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1737 for EnergyScanResultStreamNextResponse
1738 {
1739 #[inline(always)]
1740 fn new_empty() -> Self {
1741 Self { results: fidl::new_empty!(fidl::encoding::Vector<EnergyScanResult, 32>, D) }
1742 }
1743
1744 #[inline]
1745 unsafe fn decode(
1746 &mut self,
1747 decoder: &mut fidl::encoding::Decoder<'_, D>,
1748 offset: usize,
1749 _depth: fidl::encoding::Depth,
1750 ) -> fidl::Result<()> {
1751 decoder.debug_check_bounds::<Self>(offset);
1752 fidl::decode!(fidl::encoding::Vector<EnergyScanResult, 32>, D, &mut self.results, decoder, offset + 0, _depth)?;
1754 Ok(())
1755 }
1756 }
1757
1758 impl fidl::encoding::ValueTypeMarker for ProvisioningParams {
1759 type Borrowed<'a> = &'a Self;
1760 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1761 value
1762 }
1763 }
1764
1765 unsafe impl fidl::encoding::TypeMarker for ProvisioningParams {
1766 type Owned = Self;
1767
1768 #[inline(always)]
1769 fn inline_align(_context: fidl::encoding::Context) -> usize {
1770 8
1771 }
1772
1773 #[inline(always)]
1774 fn inline_size(_context: fidl::encoding::Context) -> usize {
1775 32
1776 }
1777 }
1778
1779 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProvisioningParams, D>
1780 for &ProvisioningParams
1781 {
1782 #[inline]
1783 unsafe fn encode(
1784 self,
1785 encoder: &mut fidl::encoding::Encoder<'_, D>,
1786 offset: usize,
1787 _depth: fidl::encoding::Depth,
1788 ) -> fidl::Result<()> {
1789 encoder.debug_check_bounds::<ProvisioningParams>(offset);
1790 fidl::encoding::Encode::<ProvisioningParams, D>::encode(
1792 (
1793 <Identity as fidl::encoding::ValueTypeMarker>::borrow(&self.identity),
1794 <fidl::encoding::OptionalUnion<Credential> as fidl::encoding::ValueTypeMarker>::borrow(&self.credential),
1795 ),
1796 encoder, offset, _depth
1797 )
1798 }
1799 }
1800 unsafe impl<
1801 D: fidl::encoding::ResourceDialect,
1802 T0: fidl::encoding::Encode<Identity, D>,
1803 T1: fidl::encoding::Encode<fidl::encoding::OptionalUnion<Credential>, D>,
1804 > fidl::encoding::Encode<ProvisioningParams, D> for (T0, T1)
1805 {
1806 #[inline]
1807 unsafe fn encode(
1808 self,
1809 encoder: &mut fidl::encoding::Encoder<'_, D>,
1810 offset: usize,
1811 depth: fidl::encoding::Depth,
1812 ) -> fidl::Result<()> {
1813 encoder.debug_check_bounds::<ProvisioningParams>(offset);
1814 self.0.encode(encoder, offset + 0, depth)?;
1818 self.1.encode(encoder, offset + 16, depth)?;
1819 Ok(())
1820 }
1821 }
1822
1823 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisioningParams {
1824 #[inline(always)]
1825 fn new_empty() -> Self {
1826 Self {
1827 identity: fidl::new_empty!(Identity, D),
1828 credential: fidl::new_empty!(fidl::encoding::OptionalUnion<Credential>, D),
1829 }
1830 }
1831
1832 #[inline]
1833 unsafe fn decode(
1834 &mut self,
1835 decoder: &mut fidl::encoding::Decoder<'_, D>,
1836 offset: usize,
1837 _depth: fidl::encoding::Depth,
1838 ) -> fidl::Result<()> {
1839 decoder.debug_check_bounds::<Self>(offset);
1840 fidl::decode!(Identity, D, &mut self.identity, decoder, offset + 0, _depth)?;
1842 fidl::decode!(
1843 fidl::encoding::OptionalUnion<Credential>,
1844 D,
1845 &mut self.credential,
1846 decoder,
1847 offset + 16,
1848 _depth
1849 )?;
1850 Ok(())
1851 }
1852 }
1853
1854 impl AllCounters {
1855 #[inline(always)]
1856 fn max_ordinal_present(&self) -> u64 {
1857 if let Some(_) = self.ip_rx {
1858 return 7;
1859 }
1860 if let Some(_) = self.ip_tx {
1861 return 6;
1862 }
1863 if let Some(_) = self.coex_saturated {
1864 return 5;
1865 }
1866 if let Some(_) = self.coex_rx {
1867 return 4;
1868 }
1869 if let Some(_) = self.coex_tx {
1870 return 3;
1871 }
1872 if let Some(_) = self.mac_rx {
1873 return 2;
1874 }
1875 if let Some(_) = self.mac_tx {
1876 return 1;
1877 }
1878 0
1879 }
1880 }
1881
1882 impl fidl::encoding::ValueTypeMarker for AllCounters {
1883 type Borrowed<'a> = &'a Self;
1884 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1885 value
1886 }
1887 }
1888
1889 unsafe impl fidl::encoding::TypeMarker for AllCounters {
1890 type Owned = Self;
1891
1892 #[inline(always)]
1893 fn inline_align(_context: fidl::encoding::Context) -> usize {
1894 8
1895 }
1896
1897 #[inline(always)]
1898 fn inline_size(_context: fidl::encoding::Context) -> usize {
1899 16
1900 }
1901 }
1902
1903 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllCounters, D>
1904 for &AllCounters
1905 {
1906 unsafe fn encode(
1907 self,
1908 encoder: &mut fidl::encoding::Encoder<'_, D>,
1909 offset: usize,
1910 mut depth: fidl::encoding::Depth,
1911 ) -> fidl::Result<()> {
1912 encoder.debug_check_bounds::<AllCounters>(offset);
1913 let max_ordinal: u64 = self.max_ordinal_present();
1915 encoder.write_num(max_ordinal, offset);
1916 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1917 if max_ordinal == 0 {
1919 return Ok(());
1920 }
1921 depth.increment()?;
1922 let envelope_size = 8;
1923 let bytes_len = max_ordinal as usize * envelope_size;
1924 #[allow(unused_variables)]
1925 let offset = encoder.out_of_line_offset(bytes_len);
1926 let mut _prev_end_offset: usize = 0;
1927 if 1 > max_ordinal {
1928 return Ok(());
1929 }
1930
1931 let cur_offset: usize = (1 - 1) * envelope_size;
1934
1935 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1937
1938 fidl::encoding::encode_in_envelope_optional::<MacCounters, D>(
1943 self.mac_tx.as_ref().map(<MacCounters as fidl::encoding::ValueTypeMarker>::borrow),
1944 encoder,
1945 offset + cur_offset,
1946 depth,
1947 )?;
1948
1949 _prev_end_offset = cur_offset + envelope_size;
1950 if 2 > max_ordinal {
1951 return Ok(());
1952 }
1953
1954 let cur_offset: usize = (2 - 1) * envelope_size;
1957
1958 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1960
1961 fidl::encoding::encode_in_envelope_optional::<MacCounters, D>(
1966 self.mac_rx.as_ref().map(<MacCounters as fidl::encoding::ValueTypeMarker>::borrow),
1967 encoder,
1968 offset + cur_offset,
1969 depth,
1970 )?;
1971
1972 _prev_end_offset = cur_offset + envelope_size;
1973 if 3 > max_ordinal {
1974 return Ok(());
1975 }
1976
1977 let cur_offset: usize = (3 - 1) * envelope_size;
1980
1981 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1983
1984 fidl::encoding::encode_in_envelope_optional::<CoexCounters, D>(
1989 self.coex_tx
1990 .as_ref()
1991 .map(<CoexCounters as fidl::encoding::ValueTypeMarker>::borrow),
1992 encoder,
1993 offset + cur_offset,
1994 depth,
1995 )?;
1996
1997 _prev_end_offset = cur_offset + envelope_size;
1998 if 4 > max_ordinal {
1999 return Ok(());
2000 }
2001
2002 let cur_offset: usize = (4 - 1) * envelope_size;
2005
2006 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2008
2009 fidl::encoding::encode_in_envelope_optional::<CoexCounters, D>(
2014 self.coex_rx
2015 .as_ref()
2016 .map(<CoexCounters as fidl::encoding::ValueTypeMarker>::borrow),
2017 encoder,
2018 offset + cur_offset,
2019 depth,
2020 )?;
2021
2022 _prev_end_offset = cur_offset + envelope_size;
2023 if 5 > max_ordinal {
2024 return Ok(());
2025 }
2026
2027 let cur_offset: usize = (5 - 1) * envelope_size;
2030
2031 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2033
2034 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2039 self.coex_saturated.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2040 encoder,
2041 offset + cur_offset,
2042 depth,
2043 )?;
2044
2045 _prev_end_offset = cur_offset + envelope_size;
2046 if 6 > max_ordinal {
2047 return Ok(());
2048 }
2049
2050 let cur_offset: usize = (6 - 1) * envelope_size;
2053
2054 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2056
2057 fidl::encoding::encode_in_envelope_optional::<IpCounters, D>(
2062 self.ip_tx.as_ref().map(<IpCounters as fidl::encoding::ValueTypeMarker>::borrow),
2063 encoder,
2064 offset + cur_offset,
2065 depth,
2066 )?;
2067
2068 _prev_end_offset = cur_offset + envelope_size;
2069 if 7 > max_ordinal {
2070 return Ok(());
2071 }
2072
2073 let cur_offset: usize = (7 - 1) * envelope_size;
2076
2077 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2079
2080 fidl::encoding::encode_in_envelope_optional::<IpCounters, D>(
2085 self.ip_rx.as_ref().map(<IpCounters as fidl::encoding::ValueTypeMarker>::borrow),
2086 encoder,
2087 offset + cur_offset,
2088 depth,
2089 )?;
2090
2091 _prev_end_offset = cur_offset + envelope_size;
2092
2093 Ok(())
2094 }
2095 }
2096
2097 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllCounters {
2098 #[inline(always)]
2099 fn new_empty() -> Self {
2100 Self::default()
2101 }
2102
2103 unsafe fn decode(
2104 &mut self,
2105 decoder: &mut fidl::encoding::Decoder<'_, D>,
2106 offset: usize,
2107 mut depth: fidl::encoding::Depth,
2108 ) -> fidl::Result<()> {
2109 decoder.debug_check_bounds::<Self>(offset);
2110 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2111 None => return Err(fidl::Error::NotNullable),
2112 Some(len) => len,
2113 };
2114 if len == 0 {
2116 return Ok(());
2117 };
2118 depth.increment()?;
2119 let envelope_size = 8;
2120 let bytes_len = len * envelope_size;
2121 let offset = decoder.out_of_line_offset(bytes_len)?;
2122 let mut _next_ordinal_to_read = 0;
2124 let mut next_offset = offset;
2125 let end_offset = offset + bytes_len;
2126 _next_ordinal_to_read += 1;
2127 if next_offset >= end_offset {
2128 return Ok(());
2129 }
2130
2131 while _next_ordinal_to_read < 1 {
2133 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2134 _next_ordinal_to_read += 1;
2135 next_offset += envelope_size;
2136 }
2137
2138 let next_out_of_line = decoder.next_out_of_line();
2139 let handles_before = decoder.remaining_handles();
2140 if let Some((inlined, num_bytes, num_handles)) =
2141 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2142 {
2143 let member_inline_size =
2144 <MacCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2145 if inlined != (member_inline_size <= 4) {
2146 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2147 }
2148 let inner_offset;
2149 let mut inner_depth = depth.clone();
2150 if inlined {
2151 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2152 inner_offset = next_offset;
2153 } else {
2154 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2155 inner_depth.increment()?;
2156 }
2157 let val_ref = self.mac_tx.get_or_insert_with(|| fidl::new_empty!(MacCounters, D));
2158 fidl::decode!(MacCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2159 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2160 {
2161 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2162 }
2163 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2164 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2165 }
2166 }
2167
2168 next_offset += envelope_size;
2169 _next_ordinal_to_read += 1;
2170 if next_offset >= end_offset {
2171 return Ok(());
2172 }
2173
2174 while _next_ordinal_to_read < 2 {
2176 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2177 _next_ordinal_to_read += 1;
2178 next_offset += envelope_size;
2179 }
2180
2181 let next_out_of_line = decoder.next_out_of_line();
2182 let handles_before = decoder.remaining_handles();
2183 if let Some((inlined, num_bytes, num_handles)) =
2184 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2185 {
2186 let member_inline_size =
2187 <MacCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2188 if inlined != (member_inline_size <= 4) {
2189 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2190 }
2191 let inner_offset;
2192 let mut inner_depth = depth.clone();
2193 if inlined {
2194 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2195 inner_offset = next_offset;
2196 } else {
2197 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2198 inner_depth.increment()?;
2199 }
2200 let val_ref = self.mac_rx.get_or_insert_with(|| fidl::new_empty!(MacCounters, D));
2201 fidl::decode!(MacCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2202 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2203 {
2204 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2205 }
2206 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2207 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2208 }
2209 }
2210
2211 next_offset += envelope_size;
2212 _next_ordinal_to_read += 1;
2213 if next_offset >= end_offset {
2214 return Ok(());
2215 }
2216
2217 while _next_ordinal_to_read < 3 {
2219 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2220 _next_ordinal_to_read += 1;
2221 next_offset += envelope_size;
2222 }
2223
2224 let next_out_of_line = decoder.next_out_of_line();
2225 let handles_before = decoder.remaining_handles();
2226 if let Some((inlined, num_bytes, num_handles)) =
2227 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2228 {
2229 let member_inline_size =
2230 <CoexCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2231 if inlined != (member_inline_size <= 4) {
2232 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2233 }
2234 let inner_offset;
2235 let mut inner_depth = depth.clone();
2236 if inlined {
2237 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2238 inner_offset = next_offset;
2239 } else {
2240 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2241 inner_depth.increment()?;
2242 }
2243 let val_ref = self.coex_tx.get_or_insert_with(|| fidl::new_empty!(CoexCounters, D));
2244 fidl::decode!(CoexCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2245 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2246 {
2247 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2248 }
2249 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2250 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2251 }
2252 }
2253
2254 next_offset += envelope_size;
2255 _next_ordinal_to_read += 1;
2256 if next_offset >= end_offset {
2257 return Ok(());
2258 }
2259
2260 while _next_ordinal_to_read < 4 {
2262 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2263 _next_ordinal_to_read += 1;
2264 next_offset += envelope_size;
2265 }
2266
2267 let next_out_of_line = decoder.next_out_of_line();
2268 let handles_before = decoder.remaining_handles();
2269 if let Some((inlined, num_bytes, num_handles)) =
2270 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2271 {
2272 let member_inline_size =
2273 <CoexCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2274 if inlined != (member_inline_size <= 4) {
2275 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2276 }
2277 let inner_offset;
2278 let mut inner_depth = depth.clone();
2279 if inlined {
2280 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2281 inner_offset = next_offset;
2282 } else {
2283 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2284 inner_depth.increment()?;
2285 }
2286 let val_ref = self.coex_rx.get_or_insert_with(|| fidl::new_empty!(CoexCounters, D));
2287 fidl::decode!(CoexCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2288 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2289 {
2290 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2291 }
2292 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2293 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2294 }
2295 }
2296
2297 next_offset += envelope_size;
2298 _next_ordinal_to_read += 1;
2299 if next_offset >= end_offset {
2300 return Ok(());
2301 }
2302
2303 while _next_ordinal_to_read < 5 {
2305 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2306 _next_ordinal_to_read += 1;
2307 next_offset += envelope_size;
2308 }
2309
2310 let next_out_of_line = decoder.next_out_of_line();
2311 let handles_before = decoder.remaining_handles();
2312 if let Some((inlined, num_bytes, num_handles)) =
2313 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2314 {
2315 let member_inline_size =
2316 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2317 if inlined != (member_inline_size <= 4) {
2318 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2319 }
2320 let inner_offset;
2321 let mut inner_depth = depth.clone();
2322 if inlined {
2323 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2324 inner_offset = next_offset;
2325 } else {
2326 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2327 inner_depth.increment()?;
2328 }
2329 let val_ref = self.coex_saturated.get_or_insert_with(|| fidl::new_empty!(bool, D));
2330 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2331 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2332 {
2333 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2334 }
2335 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2336 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2337 }
2338 }
2339
2340 next_offset += envelope_size;
2341 _next_ordinal_to_read += 1;
2342 if next_offset >= end_offset {
2343 return Ok(());
2344 }
2345
2346 while _next_ordinal_to_read < 6 {
2348 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2349 _next_ordinal_to_read += 1;
2350 next_offset += envelope_size;
2351 }
2352
2353 let next_out_of_line = decoder.next_out_of_line();
2354 let handles_before = decoder.remaining_handles();
2355 if let Some((inlined, num_bytes, num_handles)) =
2356 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2357 {
2358 let member_inline_size =
2359 <IpCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2360 if inlined != (member_inline_size <= 4) {
2361 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2362 }
2363 let inner_offset;
2364 let mut inner_depth = depth.clone();
2365 if inlined {
2366 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2367 inner_offset = next_offset;
2368 } else {
2369 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2370 inner_depth.increment()?;
2371 }
2372 let val_ref = self.ip_tx.get_or_insert_with(|| fidl::new_empty!(IpCounters, D));
2373 fidl::decode!(IpCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2374 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2375 {
2376 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2377 }
2378 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2379 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2380 }
2381 }
2382
2383 next_offset += envelope_size;
2384 _next_ordinal_to_read += 1;
2385 if next_offset >= end_offset {
2386 return Ok(());
2387 }
2388
2389 while _next_ordinal_to_read < 7 {
2391 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2392 _next_ordinal_to_read += 1;
2393 next_offset += envelope_size;
2394 }
2395
2396 let next_out_of_line = decoder.next_out_of_line();
2397 let handles_before = decoder.remaining_handles();
2398 if let Some((inlined, num_bytes, num_handles)) =
2399 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2400 {
2401 let member_inline_size =
2402 <IpCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2403 if inlined != (member_inline_size <= 4) {
2404 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2405 }
2406 let inner_offset;
2407 let mut inner_depth = depth.clone();
2408 if inlined {
2409 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2410 inner_offset = next_offset;
2411 } else {
2412 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2413 inner_depth.increment()?;
2414 }
2415 let val_ref = self.ip_rx.get_or_insert_with(|| fidl::new_empty!(IpCounters, D));
2416 fidl::decode!(IpCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2417 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2418 {
2419 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2420 }
2421 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2422 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2423 }
2424 }
2425
2426 next_offset += envelope_size;
2427
2428 while next_offset < end_offset {
2430 _next_ordinal_to_read += 1;
2431 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2432 next_offset += envelope_size;
2433 }
2434
2435 Ok(())
2436 }
2437 }
2438
2439 impl CoexCounters {
2440 #[inline(always)]
2441 fn max_ordinal_present(&self) -> u64 {
2442 if let Some(_) = self.grant_none {
2443 return 9;
2444 }
2445 if let Some(_) = self.avg_delay_request_to_grant_usec {
2446 return 8;
2447 }
2448 if let Some(_) = self.delayed_grant {
2449 return 7;
2450 }
2451 if let Some(_) = self.grant_deactivated_during_request {
2452 return 6;
2453 }
2454 if let Some(_) = self.grant_wait_timeout {
2455 return 5;
2456 }
2457 if let Some(_) = self.grant_wait_activated {
2458 return 4;
2459 }
2460 if let Some(_) = self.grant_wait {
2461 return 3;
2462 }
2463 if let Some(_) = self.grant_immediate {
2464 return 2;
2465 }
2466 if let Some(_) = self.requests {
2467 return 1;
2468 }
2469 0
2470 }
2471 }
2472
2473 impl fidl::encoding::ValueTypeMarker for CoexCounters {
2474 type Borrowed<'a> = &'a Self;
2475 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2476 value
2477 }
2478 }
2479
2480 unsafe impl fidl::encoding::TypeMarker for CoexCounters {
2481 type Owned = Self;
2482
2483 #[inline(always)]
2484 fn inline_align(_context: fidl::encoding::Context) -> usize {
2485 8
2486 }
2487
2488 #[inline(always)]
2489 fn inline_size(_context: fidl::encoding::Context) -> usize {
2490 16
2491 }
2492 }
2493
2494 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CoexCounters, D>
2495 for &CoexCounters
2496 {
2497 unsafe fn encode(
2498 self,
2499 encoder: &mut fidl::encoding::Encoder<'_, D>,
2500 offset: usize,
2501 mut depth: fidl::encoding::Depth,
2502 ) -> fidl::Result<()> {
2503 encoder.debug_check_bounds::<CoexCounters>(offset);
2504 let max_ordinal: u64 = self.max_ordinal_present();
2506 encoder.write_num(max_ordinal, offset);
2507 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2508 if max_ordinal == 0 {
2510 return Ok(());
2511 }
2512 depth.increment()?;
2513 let envelope_size = 8;
2514 let bytes_len = max_ordinal as usize * envelope_size;
2515 #[allow(unused_variables)]
2516 let offset = encoder.out_of_line_offset(bytes_len);
2517 let mut _prev_end_offset: usize = 0;
2518 if 1 > max_ordinal {
2519 return Ok(());
2520 }
2521
2522 let cur_offset: usize = (1 - 1) * envelope_size;
2525
2526 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2528
2529 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2534 self.requests.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2535 encoder,
2536 offset + cur_offset,
2537 depth,
2538 )?;
2539
2540 _prev_end_offset = cur_offset + envelope_size;
2541 if 2 > max_ordinal {
2542 return Ok(());
2543 }
2544
2545 let cur_offset: usize = (2 - 1) * envelope_size;
2548
2549 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2551
2552 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2557 self.grant_immediate.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2558 encoder,
2559 offset + cur_offset,
2560 depth,
2561 )?;
2562
2563 _prev_end_offset = cur_offset + envelope_size;
2564 if 3 > max_ordinal {
2565 return Ok(());
2566 }
2567
2568 let cur_offset: usize = (3 - 1) * envelope_size;
2571
2572 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2574
2575 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2580 self.grant_wait.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2581 encoder,
2582 offset + cur_offset,
2583 depth,
2584 )?;
2585
2586 _prev_end_offset = cur_offset + envelope_size;
2587 if 4 > max_ordinal {
2588 return Ok(());
2589 }
2590
2591 let cur_offset: usize = (4 - 1) * envelope_size;
2594
2595 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2597
2598 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2603 self.grant_wait_activated
2604 .as_ref()
2605 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2606 encoder,
2607 offset + cur_offset,
2608 depth,
2609 )?;
2610
2611 _prev_end_offset = cur_offset + envelope_size;
2612 if 5 > max_ordinal {
2613 return Ok(());
2614 }
2615
2616 let cur_offset: usize = (5 - 1) * envelope_size;
2619
2620 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2622
2623 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2628 self.grant_wait_timeout
2629 .as_ref()
2630 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2631 encoder,
2632 offset + cur_offset,
2633 depth,
2634 )?;
2635
2636 _prev_end_offset = cur_offset + envelope_size;
2637 if 6 > max_ordinal {
2638 return Ok(());
2639 }
2640
2641 let cur_offset: usize = (6 - 1) * envelope_size;
2644
2645 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2647
2648 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2653 self.grant_deactivated_during_request
2654 .as_ref()
2655 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2656 encoder,
2657 offset + cur_offset,
2658 depth,
2659 )?;
2660
2661 _prev_end_offset = cur_offset + envelope_size;
2662 if 7 > max_ordinal {
2663 return Ok(());
2664 }
2665
2666 let cur_offset: usize = (7 - 1) * envelope_size;
2669
2670 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2672
2673 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2678 self.delayed_grant.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2679 encoder,
2680 offset + cur_offset,
2681 depth,
2682 )?;
2683
2684 _prev_end_offset = cur_offset + envelope_size;
2685 if 8 > max_ordinal {
2686 return Ok(());
2687 }
2688
2689 let cur_offset: usize = (8 - 1) * envelope_size;
2692
2693 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2695
2696 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2701 self.avg_delay_request_to_grant_usec
2702 .as_ref()
2703 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2704 encoder,
2705 offset + cur_offset,
2706 depth,
2707 )?;
2708
2709 _prev_end_offset = cur_offset + envelope_size;
2710 if 9 > max_ordinal {
2711 return Ok(());
2712 }
2713
2714 let cur_offset: usize = (9 - 1) * envelope_size;
2717
2718 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2720
2721 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2726 self.grant_none.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2727 encoder,
2728 offset + cur_offset,
2729 depth,
2730 )?;
2731
2732 _prev_end_offset = cur_offset + envelope_size;
2733
2734 Ok(())
2735 }
2736 }
2737
2738 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CoexCounters {
2739 #[inline(always)]
2740 fn new_empty() -> Self {
2741 Self::default()
2742 }
2743
2744 unsafe fn decode(
2745 &mut self,
2746 decoder: &mut fidl::encoding::Decoder<'_, D>,
2747 offset: usize,
2748 mut depth: fidl::encoding::Depth,
2749 ) -> fidl::Result<()> {
2750 decoder.debug_check_bounds::<Self>(offset);
2751 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2752 None => return Err(fidl::Error::NotNullable),
2753 Some(len) => len,
2754 };
2755 if len == 0 {
2757 return Ok(());
2758 };
2759 depth.increment()?;
2760 let envelope_size = 8;
2761 let bytes_len = len * envelope_size;
2762 let offset = decoder.out_of_line_offset(bytes_len)?;
2763 let mut _next_ordinal_to_read = 0;
2765 let mut next_offset = offset;
2766 let end_offset = offset + bytes_len;
2767 _next_ordinal_to_read += 1;
2768 if next_offset >= end_offset {
2769 return Ok(());
2770 }
2771
2772 while _next_ordinal_to_read < 1 {
2774 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2775 _next_ordinal_to_read += 1;
2776 next_offset += envelope_size;
2777 }
2778
2779 let next_out_of_line = decoder.next_out_of_line();
2780 let handles_before = decoder.remaining_handles();
2781 if let Some((inlined, num_bytes, num_handles)) =
2782 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2783 {
2784 let member_inline_size =
2785 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2786 if inlined != (member_inline_size <= 4) {
2787 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2788 }
2789 let inner_offset;
2790 let mut inner_depth = depth.clone();
2791 if inlined {
2792 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2793 inner_offset = next_offset;
2794 } else {
2795 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2796 inner_depth.increment()?;
2797 }
2798 let val_ref = self.requests.get_or_insert_with(|| fidl::new_empty!(u64, D));
2799 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2800 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2801 {
2802 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2803 }
2804 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2805 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2806 }
2807 }
2808
2809 next_offset += envelope_size;
2810 _next_ordinal_to_read += 1;
2811 if next_offset >= end_offset {
2812 return Ok(());
2813 }
2814
2815 while _next_ordinal_to_read < 2 {
2817 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2818 _next_ordinal_to_read += 1;
2819 next_offset += envelope_size;
2820 }
2821
2822 let next_out_of_line = decoder.next_out_of_line();
2823 let handles_before = decoder.remaining_handles();
2824 if let Some((inlined, num_bytes, num_handles)) =
2825 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2826 {
2827 let member_inline_size =
2828 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2829 if inlined != (member_inline_size <= 4) {
2830 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2831 }
2832 let inner_offset;
2833 let mut inner_depth = depth.clone();
2834 if inlined {
2835 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2836 inner_offset = next_offset;
2837 } else {
2838 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2839 inner_depth.increment()?;
2840 }
2841 let val_ref = self.grant_immediate.get_or_insert_with(|| fidl::new_empty!(u64, D));
2842 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2843 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2844 {
2845 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2846 }
2847 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2848 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2849 }
2850 }
2851
2852 next_offset += envelope_size;
2853 _next_ordinal_to_read += 1;
2854 if next_offset >= end_offset {
2855 return Ok(());
2856 }
2857
2858 while _next_ordinal_to_read < 3 {
2860 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2861 _next_ordinal_to_read += 1;
2862 next_offset += envelope_size;
2863 }
2864
2865 let next_out_of_line = decoder.next_out_of_line();
2866 let handles_before = decoder.remaining_handles();
2867 if let Some((inlined, num_bytes, num_handles)) =
2868 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2869 {
2870 let member_inline_size =
2871 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2872 if inlined != (member_inline_size <= 4) {
2873 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2874 }
2875 let inner_offset;
2876 let mut inner_depth = depth.clone();
2877 if inlined {
2878 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2879 inner_offset = next_offset;
2880 } else {
2881 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2882 inner_depth.increment()?;
2883 }
2884 let val_ref = self.grant_wait.get_or_insert_with(|| fidl::new_empty!(u64, D));
2885 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2886 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2887 {
2888 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2889 }
2890 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2891 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2892 }
2893 }
2894
2895 next_offset += envelope_size;
2896 _next_ordinal_to_read += 1;
2897 if next_offset >= end_offset {
2898 return Ok(());
2899 }
2900
2901 while _next_ordinal_to_read < 4 {
2903 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2904 _next_ordinal_to_read += 1;
2905 next_offset += envelope_size;
2906 }
2907
2908 let next_out_of_line = decoder.next_out_of_line();
2909 let handles_before = decoder.remaining_handles();
2910 if let Some((inlined, num_bytes, num_handles)) =
2911 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2912 {
2913 let member_inline_size =
2914 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2915 if inlined != (member_inline_size <= 4) {
2916 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2917 }
2918 let inner_offset;
2919 let mut inner_depth = depth.clone();
2920 if inlined {
2921 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2922 inner_offset = next_offset;
2923 } else {
2924 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2925 inner_depth.increment()?;
2926 }
2927 let val_ref =
2928 self.grant_wait_activated.get_or_insert_with(|| fidl::new_empty!(u64, D));
2929 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2930 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2931 {
2932 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2933 }
2934 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2935 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2936 }
2937 }
2938
2939 next_offset += envelope_size;
2940 _next_ordinal_to_read += 1;
2941 if next_offset >= end_offset {
2942 return Ok(());
2943 }
2944
2945 while _next_ordinal_to_read < 5 {
2947 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2948 _next_ordinal_to_read += 1;
2949 next_offset += envelope_size;
2950 }
2951
2952 let next_out_of_line = decoder.next_out_of_line();
2953 let handles_before = decoder.remaining_handles();
2954 if let Some((inlined, num_bytes, num_handles)) =
2955 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2956 {
2957 let member_inline_size =
2958 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2959 if inlined != (member_inline_size <= 4) {
2960 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2961 }
2962 let inner_offset;
2963 let mut inner_depth = depth.clone();
2964 if inlined {
2965 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2966 inner_offset = next_offset;
2967 } else {
2968 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2969 inner_depth.increment()?;
2970 }
2971 let val_ref =
2972 self.grant_wait_timeout.get_or_insert_with(|| fidl::new_empty!(u64, D));
2973 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2974 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2975 {
2976 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2977 }
2978 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2979 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2980 }
2981 }
2982
2983 next_offset += envelope_size;
2984 _next_ordinal_to_read += 1;
2985 if next_offset >= end_offset {
2986 return Ok(());
2987 }
2988
2989 while _next_ordinal_to_read < 6 {
2991 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2992 _next_ordinal_to_read += 1;
2993 next_offset += envelope_size;
2994 }
2995
2996 let next_out_of_line = decoder.next_out_of_line();
2997 let handles_before = decoder.remaining_handles();
2998 if let Some((inlined, num_bytes, num_handles)) =
2999 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3000 {
3001 let member_inline_size =
3002 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3003 if inlined != (member_inline_size <= 4) {
3004 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3005 }
3006 let inner_offset;
3007 let mut inner_depth = depth.clone();
3008 if inlined {
3009 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3010 inner_offset = next_offset;
3011 } else {
3012 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3013 inner_depth.increment()?;
3014 }
3015 let val_ref = self
3016 .grant_deactivated_during_request
3017 .get_or_insert_with(|| fidl::new_empty!(u64, D));
3018 fidl::decode!(u64, 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 < 7 {
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 =
3047 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3048 if inlined != (member_inline_size <= 4) {
3049 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3050 }
3051 let inner_offset;
3052 let mut inner_depth = depth.clone();
3053 if inlined {
3054 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3055 inner_offset = next_offset;
3056 } else {
3057 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3058 inner_depth.increment()?;
3059 }
3060 let val_ref = self.delayed_grant.get_or_insert_with(|| fidl::new_empty!(u64, D));
3061 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3062 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3063 {
3064 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3065 }
3066 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3067 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3068 }
3069 }
3070
3071 next_offset += envelope_size;
3072 _next_ordinal_to_read += 1;
3073 if next_offset >= end_offset {
3074 return Ok(());
3075 }
3076
3077 while _next_ordinal_to_read < 8 {
3079 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3080 _next_ordinal_to_read += 1;
3081 next_offset += envelope_size;
3082 }
3083
3084 let next_out_of_line = decoder.next_out_of_line();
3085 let handles_before = decoder.remaining_handles();
3086 if let Some((inlined, num_bytes, num_handles)) =
3087 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3088 {
3089 let member_inline_size =
3090 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3091 if inlined != (member_inline_size <= 4) {
3092 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3093 }
3094 let inner_offset;
3095 let mut inner_depth = depth.clone();
3096 if inlined {
3097 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3098 inner_offset = next_offset;
3099 } else {
3100 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3101 inner_depth.increment()?;
3102 }
3103 let val_ref = self
3104 .avg_delay_request_to_grant_usec
3105 .get_or_insert_with(|| fidl::new_empty!(u32, D));
3106 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3107 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3108 {
3109 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3110 }
3111 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3112 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3113 }
3114 }
3115
3116 next_offset += envelope_size;
3117 _next_ordinal_to_read += 1;
3118 if next_offset >= end_offset {
3119 return Ok(());
3120 }
3121
3122 while _next_ordinal_to_read < 9 {
3124 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3125 _next_ordinal_to_read += 1;
3126 next_offset += envelope_size;
3127 }
3128
3129 let next_out_of_line = decoder.next_out_of_line();
3130 let handles_before = decoder.remaining_handles();
3131 if let Some((inlined, num_bytes, num_handles)) =
3132 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3133 {
3134 let member_inline_size =
3135 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3136 if inlined != (member_inline_size <= 4) {
3137 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3138 }
3139 let inner_offset;
3140 let mut inner_depth = depth.clone();
3141 if inlined {
3142 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3143 inner_offset = next_offset;
3144 } else {
3145 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3146 inner_depth.increment()?;
3147 }
3148 let val_ref = self.grant_none.get_or_insert_with(|| fidl::new_empty!(u64, D));
3149 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3150 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3151 {
3152 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3153 }
3154 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3155 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3156 }
3157 }
3158
3159 next_offset += envelope_size;
3160
3161 while next_offset < end_offset {
3163 _next_ordinal_to_read += 1;
3164 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3165 next_offset += envelope_size;
3166 }
3167
3168 Ok(())
3169 }
3170 }
3171
3172 impl DeviceState {
3173 #[inline(always)]
3174 fn max_ordinal_present(&self) -> u64 {
3175 if let Some(_) = self.role {
3176 return 2;
3177 }
3178 if let Some(_) = self.connectivity_state {
3179 return 1;
3180 }
3181 0
3182 }
3183 }
3184
3185 impl fidl::encoding::ValueTypeMarker for DeviceState {
3186 type Borrowed<'a> = &'a Self;
3187 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3188 value
3189 }
3190 }
3191
3192 unsafe impl fidl::encoding::TypeMarker for DeviceState {
3193 type Owned = Self;
3194
3195 #[inline(always)]
3196 fn inline_align(_context: fidl::encoding::Context) -> usize {
3197 8
3198 }
3199
3200 #[inline(always)]
3201 fn inline_size(_context: fidl::encoding::Context) -> usize {
3202 16
3203 }
3204 }
3205
3206 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceState, D>
3207 for &DeviceState
3208 {
3209 unsafe fn encode(
3210 self,
3211 encoder: &mut fidl::encoding::Encoder<'_, D>,
3212 offset: usize,
3213 mut depth: fidl::encoding::Depth,
3214 ) -> fidl::Result<()> {
3215 encoder.debug_check_bounds::<DeviceState>(offset);
3216 let max_ordinal: u64 = self.max_ordinal_present();
3218 encoder.write_num(max_ordinal, offset);
3219 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3220 if max_ordinal == 0 {
3222 return Ok(());
3223 }
3224 depth.increment()?;
3225 let envelope_size = 8;
3226 let bytes_len = max_ordinal as usize * envelope_size;
3227 #[allow(unused_variables)]
3228 let offset = encoder.out_of_line_offset(bytes_len);
3229 let mut _prev_end_offset: usize = 0;
3230 if 1 > max_ordinal {
3231 return Ok(());
3232 }
3233
3234 let cur_offset: usize = (1 - 1) * envelope_size;
3237
3238 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3240
3241 fidl::encoding::encode_in_envelope_optional::<ConnectivityState, D>(
3246 self.connectivity_state
3247 .as_ref()
3248 .map(<ConnectivityState as fidl::encoding::ValueTypeMarker>::borrow),
3249 encoder,
3250 offset + cur_offset,
3251 depth,
3252 )?;
3253
3254 _prev_end_offset = cur_offset + envelope_size;
3255 if 2 > max_ordinal {
3256 return Ok(());
3257 }
3258
3259 let cur_offset: usize = (2 - 1) * envelope_size;
3262
3263 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3265
3266 fidl::encoding::encode_in_envelope_optional::<Role, D>(
3271 self.role.as_ref().map(<Role as fidl::encoding::ValueTypeMarker>::borrow),
3272 encoder,
3273 offset + cur_offset,
3274 depth,
3275 )?;
3276
3277 _prev_end_offset = cur_offset + envelope_size;
3278
3279 Ok(())
3280 }
3281 }
3282
3283 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceState {
3284 #[inline(always)]
3285 fn new_empty() -> Self {
3286 Self::default()
3287 }
3288
3289 unsafe fn decode(
3290 &mut self,
3291 decoder: &mut fidl::encoding::Decoder<'_, D>,
3292 offset: usize,
3293 mut depth: fidl::encoding::Depth,
3294 ) -> fidl::Result<()> {
3295 decoder.debug_check_bounds::<Self>(offset);
3296 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3297 None => return Err(fidl::Error::NotNullable),
3298 Some(len) => len,
3299 };
3300 if len == 0 {
3302 return Ok(());
3303 };
3304 depth.increment()?;
3305 let envelope_size = 8;
3306 let bytes_len = len * envelope_size;
3307 let offset = decoder.out_of_line_offset(bytes_len)?;
3308 let mut _next_ordinal_to_read = 0;
3310 let mut next_offset = offset;
3311 let end_offset = offset + bytes_len;
3312 _next_ordinal_to_read += 1;
3313 if next_offset >= end_offset {
3314 return Ok(());
3315 }
3316
3317 while _next_ordinal_to_read < 1 {
3319 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3320 _next_ordinal_to_read += 1;
3321 next_offset += envelope_size;
3322 }
3323
3324 let next_out_of_line = decoder.next_out_of_line();
3325 let handles_before = decoder.remaining_handles();
3326 if let Some((inlined, num_bytes, num_handles)) =
3327 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3328 {
3329 let member_inline_size =
3330 <ConnectivityState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3331 if inlined != (member_inline_size <= 4) {
3332 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3333 }
3334 let inner_offset;
3335 let mut inner_depth = depth.clone();
3336 if inlined {
3337 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3338 inner_offset = next_offset;
3339 } else {
3340 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3341 inner_depth.increment()?;
3342 }
3343 let val_ref = self
3344 .connectivity_state
3345 .get_or_insert_with(|| fidl::new_empty!(ConnectivityState, D));
3346 fidl::decode!(ConnectivityState, D, val_ref, decoder, inner_offset, inner_depth)?;
3347 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3348 {
3349 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3350 }
3351 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3352 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3353 }
3354 }
3355
3356 next_offset += envelope_size;
3357 _next_ordinal_to_read += 1;
3358 if next_offset >= end_offset {
3359 return Ok(());
3360 }
3361
3362 while _next_ordinal_to_read < 2 {
3364 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3365 _next_ordinal_to_read += 1;
3366 next_offset += envelope_size;
3367 }
3368
3369 let next_out_of_line = decoder.next_out_of_line();
3370 let handles_before = decoder.remaining_handles();
3371 if let Some((inlined, num_bytes, num_handles)) =
3372 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3373 {
3374 let member_inline_size =
3375 <Role as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3376 if inlined != (member_inline_size <= 4) {
3377 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3378 }
3379 let inner_offset;
3380 let mut inner_depth = depth.clone();
3381 if inlined {
3382 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3383 inner_offset = next_offset;
3384 } else {
3385 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3386 inner_depth.increment()?;
3387 }
3388 let val_ref = self.role.get_or_insert_with(|| fidl::new_empty!(Role, D));
3389 fidl::decode!(Role, D, val_ref, decoder, inner_offset, inner_depth)?;
3390 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3391 {
3392 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3393 }
3394 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3395 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3396 }
3397 }
3398
3399 next_offset += envelope_size;
3400
3401 while next_offset < end_offset {
3403 _next_ordinal_to_read += 1;
3404 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3405 next_offset += envelope_size;
3406 }
3407
3408 Ok(())
3409 }
3410 }
3411
3412 impl EnergyScanParameters {
3413 #[inline(always)]
3414 fn max_ordinal_present(&self) -> u64 {
3415 if let Some(_) = self.dwell_time_ms {
3416 return 2;
3417 }
3418 if let Some(_) = self.channels {
3419 return 1;
3420 }
3421 0
3422 }
3423 }
3424
3425 impl fidl::encoding::ValueTypeMarker for EnergyScanParameters {
3426 type Borrowed<'a> = &'a Self;
3427 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3428 value
3429 }
3430 }
3431
3432 unsafe impl fidl::encoding::TypeMarker for EnergyScanParameters {
3433 type Owned = Self;
3434
3435 #[inline(always)]
3436 fn inline_align(_context: fidl::encoding::Context) -> usize {
3437 8
3438 }
3439
3440 #[inline(always)]
3441 fn inline_size(_context: fidl::encoding::Context) -> usize {
3442 16
3443 }
3444 }
3445
3446 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnergyScanParameters, D>
3447 for &EnergyScanParameters
3448 {
3449 unsafe fn encode(
3450 self,
3451 encoder: &mut fidl::encoding::Encoder<'_, D>,
3452 offset: usize,
3453 mut depth: fidl::encoding::Depth,
3454 ) -> fidl::Result<()> {
3455 encoder.debug_check_bounds::<EnergyScanParameters>(offset);
3456 let max_ordinal: u64 = self.max_ordinal_present();
3458 encoder.write_num(max_ordinal, offset);
3459 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3460 if max_ordinal == 0 {
3462 return Ok(());
3463 }
3464 depth.increment()?;
3465 let envelope_size = 8;
3466 let bytes_len = max_ordinal as usize * envelope_size;
3467 #[allow(unused_variables)]
3468 let offset = encoder.out_of_line_offset(bytes_len);
3469 let mut _prev_end_offset: usize = 0;
3470 if 1 > max_ordinal {
3471 return Ok(());
3472 }
3473
3474 let cur_offset: usize = (1 - 1) * envelope_size;
3477
3478 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3480
3481 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u16, 200>, D>(
3486 self.channels.as_ref().map(
3487 <fidl::encoding::Vector<u16, 200> as fidl::encoding::ValueTypeMarker>::borrow,
3488 ),
3489 encoder,
3490 offset + cur_offset,
3491 depth,
3492 )?;
3493
3494 _prev_end_offset = cur_offset + envelope_size;
3495 if 2 > max_ordinal {
3496 return Ok(());
3497 }
3498
3499 let cur_offset: usize = (2 - 1) * envelope_size;
3502
3503 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3505
3506 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3511 self.dwell_time_ms.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3512 encoder,
3513 offset + cur_offset,
3514 depth,
3515 )?;
3516
3517 _prev_end_offset = cur_offset + envelope_size;
3518
3519 Ok(())
3520 }
3521 }
3522
3523 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnergyScanParameters {
3524 #[inline(always)]
3525 fn new_empty() -> Self {
3526 Self::default()
3527 }
3528
3529 unsafe fn decode(
3530 &mut self,
3531 decoder: &mut fidl::encoding::Decoder<'_, D>,
3532 offset: usize,
3533 mut depth: fidl::encoding::Depth,
3534 ) -> fidl::Result<()> {
3535 decoder.debug_check_bounds::<Self>(offset);
3536 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3537 None => return Err(fidl::Error::NotNullable),
3538 Some(len) => len,
3539 };
3540 if len == 0 {
3542 return Ok(());
3543 };
3544 depth.increment()?;
3545 let envelope_size = 8;
3546 let bytes_len = len * envelope_size;
3547 let offset = decoder.out_of_line_offset(bytes_len)?;
3548 let mut _next_ordinal_to_read = 0;
3550 let mut next_offset = offset;
3551 let end_offset = offset + bytes_len;
3552 _next_ordinal_to_read += 1;
3553 if next_offset >= end_offset {
3554 return Ok(());
3555 }
3556
3557 while _next_ordinal_to_read < 1 {
3559 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3560 _next_ordinal_to_read += 1;
3561 next_offset += envelope_size;
3562 }
3563
3564 let next_out_of_line = decoder.next_out_of_line();
3565 let handles_before = decoder.remaining_handles();
3566 if let Some((inlined, num_bytes, num_handles)) =
3567 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3568 {
3569 let member_inline_size =
3570 <fidl::encoding::Vector<u16, 200> as fidl::encoding::TypeMarker>::inline_size(
3571 decoder.context,
3572 );
3573 if inlined != (member_inline_size <= 4) {
3574 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3575 }
3576 let inner_offset;
3577 let mut inner_depth = depth.clone();
3578 if inlined {
3579 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3580 inner_offset = next_offset;
3581 } else {
3582 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3583 inner_depth.increment()?;
3584 }
3585 let val_ref = self
3586 .channels
3587 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u16, 200>, D));
3588 fidl::decode!(fidl::encoding::Vector<u16, 200>, D, val_ref, decoder, inner_offset, inner_depth)?;
3589 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3590 {
3591 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3592 }
3593 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3594 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3595 }
3596 }
3597
3598 next_offset += envelope_size;
3599 _next_ordinal_to_read += 1;
3600 if next_offset >= end_offset {
3601 return Ok(());
3602 }
3603
3604 while _next_ordinal_to_read < 2 {
3606 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3607 _next_ordinal_to_read += 1;
3608 next_offset += envelope_size;
3609 }
3610
3611 let next_out_of_line = decoder.next_out_of_line();
3612 let handles_before = decoder.remaining_handles();
3613 if let Some((inlined, num_bytes, num_handles)) =
3614 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3615 {
3616 let member_inline_size =
3617 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3618 if inlined != (member_inline_size <= 4) {
3619 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3620 }
3621 let inner_offset;
3622 let mut inner_depth = depth.clone();
3623 if inlined {
3624 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3625 inner_offset = next_offset;
3626 } else {
3627 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3628 inner_depth.increment()?;
3629 }
3630 let val_ref = self.dwell_time_ms.get_or_insert_with(|| fidl::new_empty!(u32, D));
3631 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3632 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3633 {
3634 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3635 }
3636 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3637 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3638 }
3639 }
3640
3641 next_offset += envelope_size;
3642
3643 while next_offset < end_offset {
3645 _next_ordinal_to_read += 1;
3646 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3647 next_offset += envelope_size;
3648 }
3649
3650 Ok(())
3651 }
3652 }
3653
3654 impl EnergyScanResult {
3655 #[inline(always)]
3656 fn max_ordinal_present(&self) -> u64 {
3657 if let Some(_) = self.min_rssi {
3658 return 3;
3659 }
3660 if let Some(_) = self.max_rssi {
3661 return 2;
3662 }
3663 if let Some(_) = self.channel_index {
3664 return 1;
3665 }
3666 0
3667 }
3668 }
3669
3670 impl fidl::encoding::ValueTypeMarker for EnergyScanResult {
3671 type Borrowed<'a> = &'a Self;
3672 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3673 value
3674 }
3675 }
3676
3677 unsafe impl fidl::encoding::TypeMarker for EnergyScanResult {
3678 type Owned = Self;
3679
3680 #[inline(always)]
3681 fn inline_align(_context: fidl::encoding::Context) -> usize {
3682 8
3683 }
3684
3685 #[inline(always)]
3686 fn inline_size(_context: fidl::encoding::Context) -> usize {
3687 16
3688 }
3689 }
3690
3691 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnergyScanResult, D>
3692 for &EnergyScanResult
3693 {
3694 unsafe fn encode(
3695 self,
3696 encoder: &mut fidl::encoding::Encoder<'_, D>,
3697 offset: usize,
3698 mut depth: fidl::encoding::Depth,
3699 ) -> fidl::Result<()> {
3700 encoder.debug_check_bounds::<EnergyScanResult>(offset);
3701 let max_ordinal: u64 = self.max_ordinal_present();
3703 encoder.write_num(max_ordinal, offset);
3704 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3705 if max_ordinal == 0 {
3707 return Ok(());
3708 }
3709 depth.increment()?;
3710 let envelope_size = 8;
3711 let bytes_len = max_ordinal as usize * envelope_size;
3712 #[allow(unused_variables)]
3713 let offset = encoder.out_of_line_offset(bytes_len);
3714 let mut _prev_end_offset: usize = 0;
3715 if 1 > max_ordinal {
3716 return Ok(());
3717 }
3718
3719 let cur_offset: usize = (1 - 1) * envelope_size;
3722
3723 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3725
3726 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3731 self.channel_index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3732 encoder,
3733 offset + cur_offset,
3734 depth,
3735 )?;
3736
3737 _prev_end_offset = cur_offset + envelope_size;
3738 if 2 > max_ordinal {
3739 return Ok(());
3740 }
3741
3742 let cur_offset: usize = (2 - 1) * envelope_size;
3745
3746 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3748
3749 fidl::encoding::encode_in_envelope_optional::<i32, D>(
3754 self.max_rssi.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
3755 encoder,
3756 offset + cur_offset,
3757 depth,
3758 )?;
3759
3760 _prev_end_offset = cur_offset + envelope_size;
3761 if 3 > max_ordinal {
3762 return Ok(());
3763 }
3764
3765 let cur_offset: usize = (3 - 1) * envelope_size;
3768
3769 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3771
3772 fidl::encoding::encode_in_envelope_optional::<i32, D>(
3777 self.min_rssi.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
3778 encoder,
3779 offset + cur_offset,
3780 depth,
3781 )?;
3782
3783 _prev_end_offset = cur_offset + envelope_size;
3784
3785 Ok(())
3786 }
3787 }
3788
3789 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnergyScanResult {
3790 #[inline(always)]
3791 fn new_empty() -> Self {
3792 Self::default()
3793 }
3794
3795 unsafe fn decode(
3796 &mut self,
3797 decoder: &mut fidl::encoding::Decoder<'_, D>,
3798 offset: usize,
3799 mut depth: fidl::encoding::Depth,
3800 ) -> fidl::Result<()> {
3801 decoder.debug_check_bounds::<Self>(offset);
3802 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3803 None => return Err(fidl::Error::NotNullable),
3804 Some(len) => len,
3805 };
3806 if len == 0 {
3808 return Ok(());
3809 };
3810 depth.increment()?;
3811 let envelope_size = 8;
3812 let bytes_len = len * envelope_size;
3813 let offset = decoder.out_of_line_offset(bytes_len)?;
3814 let mut _next_ordinal_to_read = 0;
3816 let mut next_offset = offset;
3817 let end_offset = offset + bytes_len;
3818 _next_ordinal_to_read += 1;
3819 if next_offset >= end_offset {
3820 return Ok(());
3821 }
3822
3823 while _next_ordinal_to_read < 1 {
3825 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3826 _next_ordinal_to_read += 1;
3827 next_offset += envelope_size;
3828 }
3829
3830 let next_out_of_line = decoder.next_out_of_line();
3831 let handles_before = decoder.remaining_handles();
3832 if let Some((inlined, num_bytes, num_handles)) =
3833 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3834 {
3835 let member_inline_size =
3836 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3837 if inlined != (member_inline_size <= 4) {
3838 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3839 }
3840 let inner_offset;
3841 let mut inner_depth = depth.clone();
3842 if inlined {
3843 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3844 inner_offset = next_offset;
3845 } else {
3846 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3847 inner_depth.increment()?;
3848 }
3849 let val_ref = self.channel_index.get_or_insert_with(|| fidl::new_empty!(u16, D));
3850 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3851 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3852 {
3853 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3854 }
3855 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3856 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3857 }
3858 }
3859
3860 next_offset += envelope_size;
3861 _next_ordinal_to_read += 1;
3862 if next_offset >= end_offset {
3863 return Ok(());
3864 }
3865
3866 while _next_ordinal_to_read < 2 {
3868 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3869 _next_ordinal_to_read += 1;
3870 next_offset += envelope_size;
3871 }
3872
3873 let next_out_of_line = decoder.next_out_of_line();
3874 let handles_before = decoder.remaining_handles();
3875 if let Some((inlined, num_bytes, num_handles)) =
3876 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3877 {
3878 let member_inline_size =
3879 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3880 if inlined != (member_inline_size <= 4) {
3881 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3882 }
3883 let inner_offset;
3884 let mut inner_depth = depth.clone();
3885 if inlined {
3886 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3887 inner_offset = next_offset;
3888 } else {
3889 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3890 inner_depth.increment()?;
3891 }
3892 let val_ref = self.max_rssi.get_or_insert_with(|| fidl::new_empty!(i32, D));
3893 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3894 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3895 {
3896 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3897 }
3898 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3899 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3900 }
3901 }
3902
3903 next_offset += envelope_size;
3904 _next_ordinal_to_read += 1;
3905 if next_offset >= end_offset {
3906 return Ok(());
3907 }
3908
3909 while _next_ordinal_to_read < 3 {
3911 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3912 _next_ordinal_to_read += 1;
3913 next_offset += envelope_size;
3914 }
3915
3916 let next_out_of_line = decoder.next_out_of_line();
3917 let handles_before = decoder.remaining_handles();
3918 if let Some((inlined, num_bytes, num_handles)) =
3919 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3920 {
3921 let member_inline_size =
3922 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3923 if inlined != (member_inline_size <= 4) {
3924 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3925 }
3926 let inner_offset;
3927 let mut inner_depth = depth.clone();
3928 if inlined {
3929 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3930 inner_offset = next_offset;
3931 } else {
3932 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3933 inner_depth.increment()?;
3934 }
3935 let val_ref = self.min_rssi.get_or_insert_with(|| fidl::new_empty!(i32, D));
3936 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3937 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3938 {
3939 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3940 }
3941 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3942 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3943 }
3944 }
3945
3946 next_offset += envelope_size;
3947
3948 while next_offset < end_offset {
3950 _next_ordinal_to_read += 1;
3951 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3952 next_offset += envelope_size;
3953 }
3954
3955 Ok(())
3956 }
3957 }
3958
3959 impl Identity {
3960 #[inline(always)]
3961 fn max_ordinal_present(&self) -> u64 {
3962 if let Some(_) = self.xpanid {
3963 return 7;
3964 }
3965 if let Some(_) = self.mesh_local_prefix {
3966 return 6;
3967 }
3968 if let Some(_) = self.panid {
3969 return 5;
3970 }
3971 if let Some(_) = self.channel {
3972 return 4;
3973 }
3974 if let Some(_) = self.net_type {
3975 return 3;
3976 }
3977 if let Some(_) = self.raw_name {
3978 return 1;
3979 }
3980 0
3981 }
3982 }
3983
3984 impl fidl::encoding::ValueTypeMarker for Identity {
3985 type Borrowed<'a> = &'a Self;
3986 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3987 value
3988 }
3989 }
3990
3991 unsafe impl fidl::encoding::TypeMarker for Identity {
3992 type Owned = Self;
3993
3994 #[inline(always)]
3995 fn inline_align(_context: fidl::encoding::Context) -> usize {
3996 8
3997 }
3998
3999 #[inline(always)]
4000 fn inline_size(_context: fidl::encoding::Context) -> usize {
4001 16
4002 }
4003 }
4004
4005 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Identity, D> for &Identity {
4006 unsafe fn encode(
4007 self,
4008 encoder: &mut fidl::encoding::Encoder<'_, D>,
4009 offset: usize,
4010 mut depth: fidl::encoding::Depth,
4011 ) -> fidl::Result<()> {
4012 encoder.debug_check_bounds::<Identity>(offset);
4013 let max_ordinal: u64 = self.max_ordinal_present();
4015 encoder.write_num(max_ordinal, offset);
4016 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4017 if max_ordinal == 0 {
4019 return Ok(());
4020 }
4021 depth.increment()?;
4022 let envelope_size = 8;
4023 let bytes_len = max_ordinal as usize * envelope_size;
4024 #[allow(unused_variables)]
4025 let offset = encoder.out_of_line_offset(bytes_len);
4026 let mut _prev_end_offset: usize = 0;
4027 if 1 > max_ordinal {
4028 return Ok(());
4029 }
4030
4031 let cur_offset: usize = (1 - 1) * envelope_size;
4034
4035 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4037
4038 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 63>, D>(
4043 self.raw_name.as_ref().map(
4044 <fidl::encoding::Vector<u8, 63> as fidl::encoding::ValueTypeMarker>::borrow,
4045 ),
4046 encoder,
4047 offset + cur_offset,
4048 depth,
4049 )?;
4050
4051 _prev_end_offset = cur_offset + envelope_size;
4052 if 3 > max_ordinal {
4053 return Ok(());
4054 }
4055
4056 let cur_offset: usize = (3 - 1) * envelope_size;
4059
4060 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4062
4063 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
4068 self.net_type.as_ref().map(
4069 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
4070 ),
4071 encoder,
4072 offset + cur_offset,
4073 depth,
4074 )?;
4075
4076 _prev_end_offset = cur_offset + envelope_size;
4077 if 4 > max_ordinal {
4078 return Ok(());
4079 }
4080
4081 let cur_offset: usize = (4 - 1) * envelope_size;
4084
4085 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4087
4088 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4093 self.channel.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4094 encoder,
4095 offset + cur_offset,
4096 depth,
4097 )?;
4098
4099 _prev_end_offset = cur_offset + envelope_size;
4100 if 5 > max_ordinal {
4101 return Ok(());
4102 }
4103
4104 let cur_offset: usize = (5 - 1) * envelope_size;
4107
4108 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4110
4111 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4116 self.panid.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4117 encoder,
4118 offset + cur_offset,
4119 depth,
4120 )?;
4121
4122 _prev_end_offset = cur_offset + envelope_size;
4123 if 6 > max_ordinal {
4124 return Ok(());
4125 }
4126
4127 let cur_offset: usize = (6 - 1) * envelope_size;
4130
4131 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4133
4134 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
4139 self.mesh_local_prefix.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
4140 encoder, offset + cur_offset, depth
4141 )?;
4142
4143 _prev_end_offset = cur_offset + envelope_size;
4144 if 7 > max_ordinal {
4145 return Ok(());
4146 }
4147
4148 let cur_offset: usize = (7 - 1) * envelope_size;
4151
4152 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4154
4155 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 8>, D>(
4160 self.xpanid
4161 .as_ref()
4162 .map(<fidl::encoding::Array<u8, 8> as fidl::encoding::ValueTypeMarker>::borrow),
4163 encoder,
4164 offset + cur_offset,
4165 depth,
4166 )?;
4167
4168 _prev_end_offset = cur_offset + envelope_size;
4169
4170 Ok(())
4171 }
4172 }
4173
4174 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Identity {
4175 #[inline(always)]
4176 fn new_empty() -> Self {
4177 Self::default()
4178 }
4179
4180 unsafe fn decode(
4181 &mut self,
4182 decoder: &mut fidl::encoding::Decoder<'_, D>,
4183 offset: usize,
4184 mut depth: fidl::encoding::Depth,
4185 ) -> fidl::Result<()> {
4186 decoder.debug_check_bounds::<Self>(offset);
4187 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4188 None => return Err(fidl::Error::NotNullable),
4189 Some(len) => len,
4190 };
4191 if len == 0 {
4193 return Ok(());
4194 };
4195 depth.increment()?;
4196 let envelope_size = 8;
4197 let bytes_len = len * envelope_size;
4198 let offset = decoder.out_of_line_offset(bytes_len)?;
4199 let mut _next_ordinal_to_read = 0;
4201 let mut next_offset = offset;
4202 let end_offset = offset + bytes_len;
4203 _next_ordinal_to_read += 1;
4204 if next_offset >= end_offset {
4205 return Ok(());
4206 }
4207
4208 while _next_ordinal_to_read < 1 {
4210 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4211 _next_ordinal_to_read += 1;
4212 next_offset += envelope_size;
4213 }
4214
4215 let next_out_of_line = decoder.next_out_of_line();
4216 let handles_before = decoder.remaining_handles();
4217 if let Some((inlined, num_bytes, num_handles)) =
4218 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4219 {
4220 let member_inline_size =
4221 <fidl::encoding::Vector<u8, 63> as fidl::encoding::TypeMarker>::inline_size(
4222 decoder.context,
4223 );
4224 if inlined != (member_inline_size <= 4) {
4225 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4226 }
4227 let inner_offset;
4228 let mut inner_depth = depth.clone();
4229 if inlined {
4230 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4231 inner_offset = next_offset;
4232 } else {
4233 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4234 inner_depth.increment()?;
4235 }
4236 let val_ref = self
4237 .raw_name
4238 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 63>, D));
4239 fidl::decode!(fidl::encoding::Vector<u8, 63>, D, val_ref, decoder, inner_offset, inner_depth)?;
4240 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4241 {
4242 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4243 }
4244 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4245 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4246 }
4247 }
4248
4249 next_offset += envelope_size;
4250 _next_ordinal_to_read += 1;
4251 if next_offset >= end_offset {
4252 return Ok(());
4253 }
4254
4255 while _next_ordinal_to_read < 3 {
4257 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4258 _next_ordinal_to_read += 1;
4259 next_offset += envelope_size;
4260 }
4261
4262 let next_out_of_line = decoder.next_out_of_line();
4263 let handles_before = decoder.remaining_handles();
4264 if let Some((inlined, num_bytes, num_handles)) =
4265 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4266 {
4267 let member_inline_size =
4268 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
4269 decoder.context,
4270 );
4271 if inlined != (member_inline_size <= 4) {
4272 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4273 }
4274 let inner_offset;
4275 let mut inner_depth = depth.clone();
4276 if inlined {
4277 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4278 inner_offset = next_offset;
4279 } else {
4280 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4281 inner_depth.increment()?;
4282 }
4283 let val_ref = self
4284 .net_type
4285 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
4286 fidl::decode!(
4287 fidl::encoding::BoundedString<64>,
4288 D,
4289 val_ref,
4290 decoder,
4291 inner_offset,
4292 inner_depth
4293 )?;
4294 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4295 {
4296 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4297 }
4298 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4299 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4300 }
4301 }
4302
4303 next_offset += envelope_size;
4304 _next_ordinal_to_read += 1;
4305 if next_offset >= end_offset {
4306 return Ok(());
4307 }
4308
4309 while _next_ordinal_to_read < 4 {
4311 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4312 _next_ordinal_to_read += 1;
4313 next_offset += envelope_size;
4314 }
4315
4316 let next_out_of_line = decoder.next_out_of_line();
4317 let handles_before = decoder.remaining_handles();
4318 if let Some((inlined, num_bytes, num_handles)) =
4319 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4320 {
4321 let member_inline_size =
4322 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4323 if inlined != (member_inline_size <= 4) {
4324 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4325 }
4326 let inner_offset;
4327 let mut inner_depth = depth.clone();
4328 if inlined {
4329 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4330 inner_offset = next_offset;
4331 } else {
4332 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4333 inner_depth.increment()?;
4334 }
4335 let val_ref = self.channel.get_or_insert_with(|| fidl::new_empty!(u16, D));
4336 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4337 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4338 {
4339 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4340 }
4341 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4342 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4343 }
4344 }
4345
4346 next_offset += envelope_size;
4347 _next_ordinal_to_read += 1;
4348 if next_offset >= end_offset {
4349 return Ok(());
4350 }
4351
4352 while _next_ordinal_to_read < 5 {
4354 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4355 _next_ordinal_to_read += 1;
4356 next_offset += envelope_size;
4357 }
4358
4359 let next_out_of_line = decoder.next_out_of_line();
4360 let handles_before = decoder.remaining_handles();
4361 if let Some((inlined, num_bytes, num_handles)) =
4362 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4363 {
4364 let member_inline_size =
4365 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4366 if inlined != (member_inline_size <= 4) {
4367 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4368 }
4369 let inner_offset;
4370 let mut inner_depth = depth.clone();
4371 if inlined {
4372 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4373 inner_offset = next_offset;
4374 } else {
4375 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4376 inner_depth.increment()?;
4377 }
4378 let val_ref = self.panid.get_or_insert_with(|| fidl::new_empty!(u16, D));
4379 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4380 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4381 {
4382 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4383 }
4384 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4385 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4386 }
4387 }
4388
4389 next_offset += envelope_size;
4390 _next_ordinal_to_read += 1;
4391 if next_offset >= end_offset {
4392 return Ok(());
4393 }
4394
4395 while _next_ordinal_to_read < 6 {
4397 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4398 _next_ordinal_to_read += 1;
4399 next_offset += envelope_size;
4400 }
4401
4402 let next_out_of_line = decoder.next_out_of_line();
4403 let handles_before = decoder.remaining_handles();
4404 if let Some((inlined, num_bytes, num_handles)) =
4405 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4406 {
4407 let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4408 if inlined != (member_inline_size <= 4) {
4409 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4410 }
4411 let inner_offset;
4412 let mut inner_depth = depth.clone();
4413 if inlined {
4414 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4415 inner_offset = next_offset;
4416 } else {
4417 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4418 inner_depth.increment()?;
4419 }
4420 let val_ref = self.mesh_local_prefix.get_or_insert_with(|| {
4421 fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
4422 });
4423 fidl::decode!(
4424 fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
4425 D,
4426 val_ref,
4427 decoder,
4428 inner_offset,
4429 inner_depth
4430 )?;
4431 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4432 {
4433 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4434 }
4435 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4436 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4437 }
4438 }
4439
4440 next_offset += envelope_size;
4441 _next_ordinal_to_read += 1;
4442 if next_offset >= end_offset {
4443 return Ok(());
4444 }
4445
4446 while _next_ordinal_to_read < 7 {
4448 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4449 _next_ordinal_to_read += 1;
4450 next_offset += envelope_size;
4451 }
4452
4453 let next_out_of_line = decoder.next_out_of_line();
4454 let handles_before = decoder.remaining_handles();
4455 if let Some((inlined, num_bytes, num_handles)) =
4456 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4457 {
4458 let member_inline_size =
4459 <fidl::encoding::Array<u8, 8> as fidl::encoding::TypeMarker>::inline_size(
4460 decoder.context,
4461 );
4462 if inlined != (member_inline_size <= 4) {
4463 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4464 }
4465 let inner_offset;
4466 let mut inner_depth = depth.clone();
4467 if inlined {
4468 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4469 inner_offset = next_offset;
4470 } else {
4471 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4472 inner_depth.increment()?;
4473 }
4474 let val_ref = self
4475 .xpanid
4476 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 8>, D));
4477 fidl::decode!(fidl::encoding::Array<u8, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
4478 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4479 {
4480 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4481 }
4482 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4483 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4484 }
4485 }
4486
4487 next_offset += envelope_size;
4488
4489 while next_offset < end_offset {
4491 _next_ordinal_to_read += 1;
4492 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4493 next_offset += envelope_size;
4494 }
4495
4496 Ok(())
4497 }
4498 }
4499
4500 impl IpCounters {
4501 #[inline(always)]
4502 fn max_ordinal_present(&self) -> u64 {
4503 if let Some(_) = self.failure {
4504 return 2;
4505 }
4506 if let Some(_) = self.success {
4507 return 1;
4508 }
4509 0
4510 }
4511 }
4512
4513 impl fidl::encoding::ValueTypeMarker for IpCounters {
4514 type Borrowed<'a> = &'a Self;
4515 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4516 value
4517 }
4518 }
4519
4520 unsafe impl fidl::encoding::TypeMarker for IpCounters {
4521 type Owned = Self;
4522
4523 #[inline(always)]
4524 fn inline_align(_context: fidl::encoding::Context) -> usize {
4525 8
4526 }
4527
4528 #[inline(always)]
4529 fn inline_size(_context: fidl::encoding::Context) -> usize {
4530 16
4531 }
4532 }
4533
4534 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IpCounters, D>
4535 for &IpCounters
4536 {
4537 unsafe fn encode(
4538 self,
4539 encoder: &mut fidl::encoding::Encoder<'_, D>,
4540 offset: usize,
4541 mut depth: fidl::encoding::Depth,
4542 ) -> fidl::Result<()> {
4543 encoder.debug_check_bounds::<IpCounters>(offset);
4544 let max_ordinal: u64 = self.max_ordinal_present();
4546 encoder.write_num(max_ordinal, offset);
4547 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4548 if max_ordinal == 0 {
4550 return Ok(());
4551 }
4552 depth.increment()?;
4553 let envelope_size = 8;
4554 let bytes_len = max_ordinal as usize * envelope_size;
4555 #[allow(unused_variables)]
4556 let offset = encoder.out_of_line_offset(bytes_len);
4557 let mut _prev_end_offset: usize = 0;
4558 if 1 > max_ordinal {
4559 return Ok(());
4560 }
4561
4562 let cur_offset: usize = (1 - 1) * envelope_size;
4565
4566 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4568
4569 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4574 self.success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4575 encoder,
4576 offset + cur_offset,
4577 depth,
4578 )?;
4579
4580 _prev_end_offset = cur_offset + envelope_size;
4581 if 2 > max_ordinal {
4582 return Ok(());
4583 }
4584
4585 let cur_offset: usize = (2 - 1) * envelope_size;
4588
4589 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4591
4592 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4597 self.failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4598 encoder,
4599 offset + cur_offset,
4600 depth,
4601 )?;
4602
4603 _prev_end_offset = cur_offset + envelope_size;
4604
4605 Ok(())
4606 }
4607 }
4608
4609 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IpCounters {
4610 #[inline(always)]
4611 fn new_empty() -> Self {
4612 Self::default()
4613 }
4614
4615 unsafe fn decode(
4616 &mut self,
4617 decoder: &mut fidl::encoding::Decoder<'_, D>,
4618 offset: usize,
4619 mut depth: fidl::encoding::Depth,
4620 ) -> fidl::Result<()> {
4621 decoder.debug_check_bounds::<Self>(offset);
4622 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4623 None => return Err(fidl::Error::NotNullable),
4624 Some(len) => len,
4625 };
4626 if len == 0 {
4628 return Ok(());
4629 };
4630 depth.increment()?;
4631 let envelope_size = 8;
4632 let bytes_len = len * envelope_size;
4633 let offset = decoder.out_of_line_offset(bytes_len)?;
4634 let mut _next_ordinal_to_read = 0;
4636 let mut next_offset = offset;
4637 let end_offset = offset + bytes_len;
4638 _next_ordinal_to_read += 1;
4639 if next_offset >= end_offset {
4640 return Ok(());
4641 }
4642
4643 while _next_ordinal_to_read < 1 {
4645 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4646 _next_ordinal_to_read += 1;
4647 next_offset += envelope_size;
4648 }
4649
4650 let next_out_of_line = decoder.next_out_of_line();
4651 let handles_before = decoder.remaining_handles();
4652 if let Some((inlined, num_bytes, num_handles)) =
4653 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4654 {
4655 let member_inline_size =
4656 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4657 if inlined != (member_inline_size <= 4) {
4658 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4659 }
4660 let inner_offset;
4661 let mut inner_depth = depth.clone();
4662 if inlined {
4663 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4664 inner_offset = next_offset;
4665 } else {
4666 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4667 inner_depth.increment()?;
4668 }
4669 let val_ref = self.success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4670 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4671 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4672 {
4673 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4674 }
4675 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4676 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4677 }
4678 }
4679
4680 next_offset += envelope_size;
4681 _next_ordinal_to_read += 1;
4682 if next_offset >= end_offset {
4683 return Ok(());
4684 }
4685
4686 while _next_ordinal_to_read < 2 {
4688 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4689 _next_ordinal_to_read += 1;
4690 next_offset += envelope_size;
4691 }
4692
4693 let next_out_of_line = decoder.next_out_of_line();
4694 let handles_before = decoder.remaining_handles();
4695 if let Some((inlined, num_bytes, num_handles)) =
4696 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4697 {
4698 let member_inline_size =
4699 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4700 if inlined != (member_inline_size <= 4) {
4701 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4702 }
4703 let inner_offset;
4704 let mut inner_depth = depth.clone();
4705 if inlined {
4706 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4707 inner_offset = next_offset;
4708 } else {
4709 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4710 inner_depth.increment()?;
4711 }
4712 let val_ref = self.failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4713 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4714 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4715 {
4716 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4717 }
4718 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4719 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4720 }
4721 }
4722
4723 next_offset += envelope_size;
4724
4725 while next_offset < end_offset {
4727 _next_ordinal_to_read += 1;
4728 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4729 next_offset += envelope_size;
4730 }
4731
4732 Ok(())
4733 }
4734 }
4735
4736 impl MacCounters {
4737 #[inline(always)]
4738 fn max_ordinal_present(&self) -> u64 {
4739 if let Some(_) = self.err_other {
4740 return 26;
4741 }
4742 if let Some(_) = self.err_busy_channel {
4743 return 25;
4744 }
4745 if let Some(_) = self.err_abort {
4746 return 24;
4747 }
4748 if let Some(_) = self.err_cca {
4749 return 23;
4750 }
4751 if let Some(_) = self.err_fcs {
4752 return 22;
4753 }
4754 if let Some(_) = self.err_sec {
4755 return 21;
4756 }
4757 if let Some(_) = self.err_invalid_src_addr {
4758 return 20;
4759 }
4760 if let Some(_) = self.err_unknown_neighbor {
4761 return 19;
4762 }
4763 if let Some(_) = self.err_no_frame {
4764 return 18;
4765 }
4766 if let Some(_) = self.duplicated {
4767 return 17;
4768 }
4769 if let Some(_) = self.dest_addr_filtered {
4770 return 16;
4771 }
4772 if let Some(_) = self.indirect_max_retry_expiry {
4773 return 15;
4774 }
4775 if let Some(_) = self.direct_max_retry_expiry {
4776 return 14;
4777 }
4778 if let Some(_) = self.retries {
4779 return 13;
4780 }
4781 if let Some(_) = self.address_filtered {
4782 return 12;
4783 }
4784 if let Some(_) = self.other {
4785 return 11;
4786 }
4787 if let Some(_) = self.beacon_request {
4788 return 10;
4789 }
4790 if let Some(_) = self.beacon {
4791 return 9;
4792 }
4793 if let Some(_) = self.data_poll {
4794 return 8;
4795 }
4796 if let Some(_) = self.data {
4797 return 7;
4798 }
4799 if let Some(_) = self.no_ack_requested {
4800 return 6;
4801 }
4802 if let Some(_) = self.acked {
4803 return 5;
4804 }
4805 if let Some(_) = self.ack_requested {
4806 return 4;
4807 }
4808 if let Some(_) = self.broadcast {
4809 return 3;
4810 }
4811 if let Some(_) = self.unicast {
4812 return 2;
4813 }
4814 if let Some(_) = self.total {
4815 return 1;
4816 }
4817 0
4818 }
4819 }
4820
4821 impl fidl::encoding::ValueTypeMarker for MacCounters {
4822 type Borrowed<'a> = &'a Self;
4823 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4824 value
4825 }
4826 }
4827
4828 unsafe impl fidl::encoding::TypeMarker for MacCounters {
4829 type Owned = Self;
4830
4831 #[inline(always)]
4832 fn inline_align(_context: fidl::encoding::Context) -> usize {
4833 8
4834 }
4835
4836 #[inline(always)]
4837 fn inline_size(_context: fidl::encoding::Context) -> usize {
4838 16
4839 }
4840 }
4841
4842 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MacCounters, D>
4843 for &MacCounters
4844 {
4845 unsafe fn encode(
4846 self,
4847 encoder: &mut fidl::encoding::Encoder<'_, D>,
4848 offset: usize,
4849 mut depth: fidl::encoding::Depth,
4850 ) -> fidl::Result<()> {
4851 encoder.debug_check_bounds::<MacCounters>(offset);
4852 let max_ordinal: u64 = self.max_ordinal_present();
4854 encoder.write_num(max_ordinal, offset);
4855 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4856 if max_ordinal == 0 {
4858 return Ok(());
4859 }
4860 depth.increment()?;
4861 let envelope_size = 8;
4862 let bytes_len = max_ordinal as usize * envelope_size;
4863 #[allow(unused_variables)]
4864 let offset = encoder.out_of_line_offset(bytes_len);
4865 let mut _prev_end_offset: usize = 0;
4866 if 1 > max_ordinal {
4867 return Ok(());
4868 }
4869
4870 let cur_offset: usize = (1 - 1) * envelope_size;
4873
4874 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4876
4877 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4882 self.total.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4883 encoder,
4884 offset + cur_offset,
4885 depth,
4886 )?;
4887
4888 _prev_end_offset = cur_offset + envelope_size;
4889 if 2 > max_ordinal {
4890 return Ok(());
4891 }
4892
4893 let cur_offset: usize = (2 - 1) * envelope_size;
4896
4897 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4899
4900 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4905 self.unicast.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4906 encoder,
4907 offset + cur_offset,
4908 depth,
4909 )?;
4910
4911 _prev_end_offset = cur_offset + envelope_size;
4912 if 3 > max_ordinal {
4913 return Ok(());
4914 }
4915
4916 let cur_offset: usize = (3 - 1) * envelope_size;
4919
4920 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4922
4923 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4928 self.broadcast.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4929 encoder,
4930 offset + cur_offset,
4931 depth,
4932 )?;
4933
4934 _prev_end_offset = cur_offset + envelope_size;
4935 if 4 > max_ordinal {
4936 return Ok(());
4937 }
4938
4939 let cur_offset: usize = (4 - 1) * envelope_size;
4942
4943 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4945
4946 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4951 self.ack_requested.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4952 encoder,
4953 offset + cur_offset,
4954 depth,
4955 )?;
4956
4957 _prev_end_offset = cur_offset + envelope_size;
4958 if 5 > max_ordinal {
4959 return Ok(());
4960 }
4961
4962 let cur_offset: usize = (5 - 1) * envelope_size;
4965
4966 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4968
4969 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4974 self.acked.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4975 encoder,
4976 offset + cur_offset,
4977 depth,
4978 )?;
4979
4980 _prev_end_offset = cur_offset + envelope_size;
4981 if 6 > max_ordinal {
4982 return Ok(());
4983 }
4984
4985 let cur_offset: usize = (6 - 1) * envelope_size;
4988
4989 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4991
4992 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4997 self.no_ack_requested
4998 .as_ref()
4999 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5000 encoder,
5001 offset + cur_offset,
5002 depth,
5003 )?;
5004
5005 _prev_end_offset = cur_offset + envelope_size;
5006 if 7 > max_ordinal {
5007 return Ok(());
5008 }
5009
5010 let cur_offset: usize = (7 - 1) * envelope_size;
5013
5014 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5016
5017 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5022 self.data.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5023 encoder,
5024 offset + cur_offset,
5025 depth,
5026 )?;
5027
5028 _prev_end_offset = cur_offset + envelope_size;
5029 if 8 > max_ordinal {
5030 return Ok(());
5031 }
5032
5033 let cur_offset: usize = (8 - 1) * envelope_size;
5036
5037 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5039
5040 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5045 self.data_poll.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5046 encoder,
5047 offset + cur_offset,
5048 depth,
5049 )?;
5050
5051 _prev_end_offset = cur_offset + envelope_size;
5052 if 9 > max_ordinal {
5053 return Ok(());
5054 }
5055
5056 let cur_offset: usize = (9 - 1) * envelope_size;
5059
5060 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5062
5063 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5068 self.beacon.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5069 encoder,
5070 offset + cur_offset,
5071 depth,
5072 )?;
5073
5074 _prev_end_offset = cur_offset + envelope_size;
5075 if 10 > max_ordinal {
5076 return Ok(());
5077 }
5078
5079 let cur_offset: usize = (10 - 1) * envelope_size;
5082
5083 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5085
5086 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5091 self.beacon_request.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5092 encoder,
5093 offset + cur_offset,
5094 depth,
5095 )?;
5096
5097 _prev_end_offset = cur_offset + envelope_size;
5098 if 11 > max_ordinal {
5099 return Ok(());
5100 }
5101
5102 let cur_offset: usize = (11 - 1) * envelope_size;
5105
5106 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5108
5109 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5114 self.other.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5115 encoder,
5116 offset + cur_offset,
5117 depth,
5118 )?;
5119
5120 _prev_end_offset = cur_offset + envelope_size;
5121 if 12 > max_ordinal {
5122 return Ok(());
5123 }
5124
5125 let cur_offset: usize = (12 - 1) * envelope_size;
5128
5129 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5131
5132 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5137 self.address_filtered
5138 .as_ref()
5139 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5140 encoder,
5141 offset + cur_offset,
5142 depth,
5143 )?;
5144
5145 _prev_end_offset = cur_offset + envelope_size;
5146 if 13 > max_ordinal {
5147 return Ok(());
5148 }
5149
5150 let cur_offset: usize = (13 - 1) * envelope_size;
5153
5154 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5156
5157 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5162 self.retries.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5163 encoder,
5164 offset + cur_offset,
5165 depth,
5166 )?;
5167
5168 _prev_end_offset = cur_offset + envelope_size;
5169 if 14 > max_ordinal {
5170 return Ok(());
5171 }
5172
5173 let cur_offset: usize = (14 - 1) * envelope_size;
5176
5177 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5179
5180 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5185 self.direct_max_retry_expiry
5186 .as_ref()
5187 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5188 encoder,
5189 offset + cur_offset,
5190 depth,
5191 )?;
5192
5193 _prev_end_offset = cur_offset + envelope_size;
5194 if 15 > max_ordinal {
5195 return Ok(());
5196 }
5197
5198 let cur_offset: usize = (15 - 1) * envelope_size;
5201
5202 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5204
5205 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5210 self.indirect_max_retry_expiry
5211 .as_ref()
5212 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5213 encoder,
5214 offset + cur_offset,
5215 depth,
5216 )?;
5217
5218 _prev_end_offset = cur_offset + envelope_size;
5219 if 16 > max_ordinal {
5220 return Ok(());
5221 }
5222
5223 let cur_offset: usize = (16 - 1) * envelope_size;
5226
5227 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5229
5230 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5235 self.dest_addr_filtered
5236 .as_ref()
5237 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5238 encoder,
5239 offset + cur_offset,
5240 depth,
5241 )?;
5242
5243 _prev_end_offset = cur_offset + envelope_size;
5244 if 17 > max_ordinal {
5245 return Ok(());
5246 }
5247
5248 let cur_offset: usize = (17 - 1) * envelope_size;
5251
5252 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5254
5255 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5260 self.duplicated.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5261 encoder,
5262 offset + cur_offset,
5263 depth,
5264 )?;
5265
5266 _prev_end_offset = cur_offset + envelope_size;
5267 if 18 > max_ordinal {
5268 return Ok(());
5269 }
5270
5271 let cur_offset: usize = (18 - 1) * envelope_size;
5274
5275 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5277
5278 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5283 self.err_no_frame.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5284 encoder,
5285 offset + cur_offset,
5286 depth,
5287 )?;
5288
5289 _prev_end_offset = cur_offset + envelope_size;
5290 if 19 > max_ordinal {
5291 return Ok(());
5292 }
5293
5294 let cur_offset: usize = (19 - 1) * envelope_size;
5297
5298 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5300
5301 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5306 self.err_unknown_neighbor
5307 .as_ref()
5308 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5309 encoder,
5310 offset + cur_offset,
5311 depth,
5312 )?;
5313
5314 _prev_end_offset = cur_offset + envelope_size;
5315 if 20 > max_ordinal {
5316 return Ok(());
5317 }
5318
5319 let cur_offset: usize = (20 - 1) * envelope_size;
5322
5323 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5325
5326 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5331 self.err_invalid_src_addr
5332 .as_ref()
5333 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5334 encoder,
5335 offset + cur_offset,
5336 depth,
5337 )?;
5338
5339 _prev_end_offset = cur_offset + envelope_size;
5340 if 21 > max_ordinal {
5341 return Ok(());
5342 }
5343
5344 let cur_offset: usize = (21 - 1) * envelope_size;
5347
5348 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5350
5351 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5356 self.err_sec.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5357 encoder,
5358 offset + cur_offset,
5359 depth,
5360 )?;
5361
5362 _prev_end_offset = cur_offset + envelope_size;
5363 if 22 > max_ordinal {
5364 return Ok(());
5365 }
5366
5367 let cur_offset: usize = (22 - 1) * envelope_size;
5370
5371 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5373
5374 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5379 self.err_fcs.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5380 encoder,
5381 offset + cur_offset,
5382 depth,
5383 )?;
5384
5385 _prev_end_offset = cur_offset + envelope_size;
5386 if 23 > max_ordinal {
5387 return Ok(());
5388 }
5389
5390 let cur_offset: usize = (23 - 1) * envelope_size;
5393
5394 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5396
5397 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5402 self.err_cca.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5403 encoder,
5404 offset + cur_offset,
5405 depth,
5406 )?;
5407
5408 _prev_end_offset = cur_offset + envelope_size;
5409 if 24 > max_ordinal {
5410 return Ok(());
5411 }
5412
5413 let cur_offset: usize = (24 - 1) * envelope_size;
5416
5417 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5419
5420 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5425 self.err_abort.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5426 encoder,
5427 offset + cur_offset,
5428 depth,
5429 )?;
5430
5431 _prev_end_offset = cur_offset + envelope_size;
5432 if 25 > max_ordinal {
5433 return Ok(());
5434 }
5435
5436 let cur_offset: usize = (25 - 1) * envelope_size;
5439
5440 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5442
5443 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5448 self.err_busy_channel
5449 .as_ref()
5450 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5451 encoder,
5452 offset + cur_offset,
5453 depth,
5454 )?;
5455
5456 _prev_end_offset = cur_offset + envelope_size;
5457 if 26 > max_ordinal {
5458 return Ok(());
5459 }
5460
5461 let cur_offset: usize = (26 - 1) * envelope_size;
5464
5465 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5467
5468 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5473 self.err_other.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5474 encoder,
5475 offset + cur_offset,
5476 depth,
5477 )?;
5478
5479 _prev_end_offset = cur_offset + envelope_size;
5480
5481 Ok(())
5482 }
5483 }
5484
5485 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacCounters {
5486 #[inline(always)]
5487 fn new_empty() -> Self {
5488 Self::default()
5489 }
5490
5491 unsafe fn decode(
5492 &mut self,
5493 decoder: &mut fidl::encoding::Decoder<'_, D>,
5494 offset: usize,
5495 mut depth: fidl::encoding::Depth,
5496 ) -> fidl::Result<()> {
5497 decoder.debug_check_bounds::<Self>(offset);
5498 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5499 None => return Err(fidl::Error::NotNullable),
5500 Some(len) => len,
5501 };
5502 if len == 0 {
5504 return Ok(());
5505 };
5506 depth.increment()?;
5507 let envelope_size = 8;
5508 let bytes_len = len * envelope_size;
5509 let offset = decoder.out_of_line_offset(bytes_len)?;
5510 let mut _next_ordinal_to_read = 0;
5512 let mut next_offset = offset;
5513 let end_offset = offset + bytes_len;
5514 _next_ordinal_to_read += 1;
5515 if next_offset >= end_offset {
5516 return Ok(());
5517 }
5518
5519 while _next_ordinal_to_read < 1 {
5521 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5522 _next_ordinal_to_read += 1;
5523 next_offset += envelope_size;
5524 }
5525
5526 let next_out_of_line = decoder.next_out_of_line();
5527 let handles_before = decoder.remaining_handles();
5528 if let Some((inlined, num_bytes, num_handles)) =
5529 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5530 {
5531 let member_inline_size =
5532 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5533 if inlined != (member_inline_size <= 4) {
5534 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5535 }
5536 let inner_offset;
5537 let mut inner_depth = depth.clone();
5538 if inlined {
5539 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5540 inner_offset = next_offset;
5541 } else {
5542 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5543 inner_depth.increment()?;
5544 }
5545 let val_ref = self.total.get_or_insert_with(|| fidl::new_empty!(u32, D));
5546 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5547 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5548 {
5549 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5550 }
5551 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5552 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5553 }
5554 }
5555
5556 next_offset += envelope_size;
5557 _next_ordinal_to_read += 1;
5558 if next_offset >= end_offset {
5559 return Ok(());
5560 }
5561
5562 while _next_ordinal_to_read < 2 {
5564 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5565 _next_ordinal_to_read += 1;
5566 next_offset += envelope_size;
5567 }
5568
5569 let next_out_of_line = decoder.next_out_of_line();
5570 let handles_before = decoder.remaining_handles();
5571 if let Some((inlined, num_bytes, num_handles)) =
5572 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5573 {
5574 let member_inline_size =
5575 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5576 if inlined != (member_inline_size <= 4) {
5577 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5578 }
5579 let inner_offset;
5580 let mut inner_depth = depth.clone();
5581 if inlined {
5582 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5583 inner_offset = next_offset;
5584 } else {
5585 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5586 inner_depth.increment()?;
5587 }
5588 let val_ref = self.unicast.get_or_insert_with(|| fidl::new_empty!(u32, D));
5589 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5590 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5591 {
5592 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5593 }
5594 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5595 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5596 }
5597 }
5598
5599 next_offset += envelope_size;
5600 _next_ordinal_to_read += 1;
5601 if next_offset >= end_offset {
5602 return Ok(());
5603 }
5604
5605 while _next_ordinal_to_read < 3 {
5607 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5608 _next_ordinal_to_read += 1;
5609 next_offset += envelope_size;
5610 }
5611
5612 let next_out_of_line = decoder.next_out_of_line();
5613 let handles_before = decoder.remaining_handles();
5614 if let Some((inlined, num_bytes, num_handles)) =
5615 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5616 {
5617 let member_inline_size =
5618 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5619 if inlined != (member_inline_size <= 4) {
5620 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5621 }
5622 let inner_offset;
5623 let mut inner_depth = depth.clone();
5624 if inlined {
5625 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5626 inner_offset = next_offset;
5627 } else {
5628 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5629 inner_depth.increment()?;
5630 }
5631 let val_ref = self.broadcast.get_or_insert_with(|| fidl::new_empty!(u32, D));
5632 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5633 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5634 {
5635 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5636 }
5637 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5638 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5639 }
5640 }
5641
5642 next_offset += envelope_size;
5643 _next_ordinal_to_read += 1;
5644 if next_offset >= end_offset {
5645 return Ok(());
5646 }
5647
5648 while _next_ordinal_to_read < 4 {
5650 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5651 _next_ordinal_to_read += 1;
5652 next_offset += envelope_size;
5653 }
5654
5655 let next_out_of_line = decoder.next_out_of_line();
5656 let handles_before = decoder.remaining_handles();
5657 if let Some((inlined, num_bytes, num_handles)) =
5658 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5659 {
5660 let member_inline_size =
5661 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5662 if inlined != (member_inline_size <= 4) {
5663 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5664 }
5665 let inner_offset;
5666 let mut inner_depth = depth.clone();
5667 if inlined {
5668 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5669 inner_offset = next_offset;
5670 } else {
5671 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5672 inner_depth.increment()?;
5673 }
5674 let val_ref = self.ack_requested.get_or_insert_with(|| fidl::new_empty!(u32, D));
5675 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5676 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5677 {
5678 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5679 }
5680 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5681 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5682 }
5683 }
5684
5685 next_offset += envelope_size;
5686 _next_ordinal_to_read += 1;
5687 if next_offset >= end_offset {
5688 return Ok(());
5689 }
5690
5691 while _next_ordinal_to_read < 5 {
5693 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5694 _next_ordinal_to_read += 1;
5695 next_offset += envelope_size;
5696 }
5697
5698 let next_out_of_line = decoder.next_out_of_line();
5699 let handles_before = decoder.remaining_handles();
5700 if let Some((inlined, num_bytes, num_handles)) =
5701 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5702 {
5703 let member_inline_size =
5704 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5705 if inlined != (member_inline_size <= 4) {
5706 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5707 }
5708 let inner_offset;
5709 let mut inner_depth = depth.clone();
5710 if inlined {
5711 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5712 inner_offset = next_offset;
5713 } else {
5714 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5715 inner_depth.increment()?;
5716 }
5717 let val_ref = self.acked.get_or_insert_with(|| fidl::new_empty!(u32, D));
5718 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5719 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5720 {
5721 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5722 }
5723 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5724 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5725 }
5726 }
5727
5728 next_offset += envelope_size;
5729 _next_ordinal_to_read += 1;
5730 if next_offset >= end_offset {
5731 return Ok(());
5732 }
5733
5734 while _next_ordinal_to_read < 6 {
5736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5737 _next_ordinal_to_read += 1;
5738 next_offset += envelope_size;
5739 }
5740
5741 let next_out_of_line = decoder.next_out_of_line();
5742 let handles_before = decoder.remaining_handles();
5743 if let Some((inlined, num_bytes, num_handles)) =
5744 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5745 {
5746 let member_inline_size =
5747 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5748 if inlined != (member_inline_size <= 4) {
5749 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5750 }
5751 let inner_offset;
5752 let mut inner_depth = depth.clone();
5753 if inlined {
5754 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5755 inner_offset = next_offset;
5756 } else {
5757 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5758 inner_depth.increment()?;
5759 }
5760 let val_ref = self.no_ack_requested.get_or_insert_with(|| fidl::new_empty!(u32, D));
5761 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5762 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5763 {
5764 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5765 }
5766 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5767 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5768 }
5769 }
5770
5771 next_offset += envelope_size;
5772 _next_ordinal_to_read += 1;
5773 if next_offset >= end_offset {
5774 return Ok(());
5775 }
5776
5777 while _next_ordinal_to_read < 7 {
5779 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5780 _next_ordinal_to_read += 1;
5781 next_offset += envelope_size;
5782 }
5783
5784 let next_out_of_line = decoder.next_out_of_line();
5785 let handles_before = decoder.remaining_handles();
5786 if let Some((inlined, num_bytes, num_handles)) =
5787 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5788 {
5789 let member_inline_size =
5790 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5791 if inlined != (member_inline_size <= 4) {
5792 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5793 }
5794 let inner_offset;
5795 let mut inner_depth = depth.clone();
5796 if inlined {
5797 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5798 inner_offset = next_offset;
5799 } else {
5800 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5801 inner_depth.increment()?;
5802 }
5803 let val_ref = self.data.get_or_insert_with(|| fidl::new_empty!(u32, D));
5804 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5805 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5806 {
5807 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5808 }
5809 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5810 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5811 }
5812 }
5813
5814 next_offset += envelope_size;
5815 _next_ordinal_to_read += 1;
5816 if next_offset >= end_offset {
5817 return Ok(());
5818 }
5819
5820 while _next_ordinal_to_read < 8 {
5822 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5823 _next_ordinal_to_read += 1;
5824 next_offset += envelope_size;
5825 }
5826
5827 let next_out_of_line = decoder.next_out_of_line();
5828 let handles_before = decoder.remaining_handles();
5829 if let Some((inlined, num_bytes, num_handles)) =
5830 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5831 {
5832 let member_inline_size =
5833 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5834 if inlined != (member_inline_size <= 4) {
5835 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5836 }
5837 let inner_offset;
5838 let mut inner_depth = depth.clone();
5839 if inlined {
5840 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5841 inner_offset = next_offset;
5842 } else {
5843 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5844 inner_depth.increment()?;
5845 }
5846 let val_ref = self.data_poll.get_or_insert_with(|| fidl::new_empty!(u32, D));
5847 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5848 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5849 {
5850 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5851 }
5852 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5853 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5854 }
5855 }
5856
5857 next_offset += envelope_size;
5858 _next_ordinal_to_read += 1;
5859 if next_offset >= end_offset {
5860 return Ok(());
5861 }
5862
5863 while _next_ordinal_to_read < 9 {
5865 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5866 _next_ordinal_to_read += 1;
5867 next_offset += envelope_size;
5868 }
5869
5870 let next_out_of_line = decoder.next_out_of_line();
5871 let handles_before = decoder.remaining_handles();
5872 if let Some((inlined, num_bytes, num_handles)) =
5873 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5874 {
5875 let member_inline_size =
5876 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5877 if inlined != (member_inline_size <= 4) {
5878 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5879 }
5880 let inner_offset;
5881 let mut inner_depth = depth.clone();
5882 if inlined {
5883 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5884 inner_offset = next_offset;
5885 } else {
5886 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5887 inner_depth.increment()?;
5888 }
5889 let val_ref = self.beacon.get_or_insert_with(|| fidl::new_empty!(u32, D));
5890 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5891 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5892 {
5893 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5894 }
5895 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5896 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5897 }
5898 }
5899
5900 next_offset += envelope_size;
5901 _next_ordinal_to_read += 1;
5902 if next_offset >= end_offset {
5903 return Ok(());
5904 }
5905
5906 while _next_ordinal_to_read < 10 {
5908 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5909 _next_ordinal_to_read += 1;
5910 next_offset += envelope_size;
5911 }
5912
5913 let next_out_of_line = decoder.next_out_of_line();
5914 let handles_before = decoder.remaining_handles();
5915 if let Some((inlined, num_bytes, num_handles)) =
5916 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5917 {
5918 let member_inline_size =
5919 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5920 if inlined != (member_inline_size <= 4) {
5921 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5922 }
5923 let inner_offset;
5924 let mut inner_depth = depth.clone();
5925 if inlined {
5926 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5927 inner_offset = next_offset;
5928 } else {
5929 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5930 inner_depth.increment()?;
5931 }
5932 let val_ref = self.beacon_request.get_or_insert_with(|| fidl::new_empty!(u32, D));
5933 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5934 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5935 {
5936 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5937 }
5938 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5939 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5940 }
5941 }
5942
5943 next_offset += envelope_size;
5944 _next_ordinal_to_read += 1;
5945 if next_offset >= end_offset {
5946 return Ok(());
5947 }
5948
5949 while _next_ordinal_to_read < 11 {
5951 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5952 _next_ordinal_to_read += 1;
5953 next_offset += envelope_size;
5954 }
5955
5956 let next_out_of_line = decoder.next_out_of_line();
5957 let handles_before = decoder.remaining_handles();
5958 if let Some((inlined, num_bytes, num_handles)) =
5959 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5960 {
5961 let member_inline_size =
5962 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5963 if inlined != (member_inline_size <= 4) {
5964 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5965 }
5966 let inner_offset;
5967 let mut inner_depth = depth.clone();
5968 if inlined {
5969 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5970 inner_offset = next_offset;
5971 } else {
5972 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5973 inner_depth.increment()?;
5974 }
5975 let val_ref = self.other.get_or_insert_with(|| fidl::new_empty!(u32, D));
5976 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5977 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5978 {
5979 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5980 }
5981 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5982 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5983 }
5984 }
5985
5986 next_offset += envelope_size;
5987 _next_ordinal_to_read += 1;
5988 if next_offset >= end_offset {
5989 return Ok(());
5990 }
5991
5992 while _next_ordinal_to_read < 12 {
5994 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5995 _next_ordinal_to_read += 1;
5996 next_offset += envelope_size;
5997 }
5998
5999 let next_out_of_line = decoder.next_out_of_line();
6000 let handles_before = decoder.remaining_handles();
6001 if let Some((inlined, num_bytes, num_handles)) =
6002 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6003 {
6004 let member_inline_size =
6005 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6006 if inlined != (member_inline_size <= 4) {
6007 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6008 }
6009 let inner_offset;
6010 let mut inner_depth = depth.clone();
6011 if inlined {
6012 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6013 inner_offset = next_offset;
6014 } else {
6015 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6016 inner_depth.increment()?;
6017 }
6018 let val_ref = self.address_filtered.get_or_insert_with(|| fidl::new_empty!(u32, D));
6019 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6020 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6021 {
6022 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6023 }
6024 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6025 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6026 }
6027 }
6028
6029 next_offset += envelope_size;
6030 _next_ordinal_to_read += 1;
6031 if next_offset >= end_offset {
6032 return Ok(());
6033 }
6034
6035 while _next_ordinal_to_read < 13 {
6037 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6038 _next_ordinal_to_read += 1;
6039 next_offset += envelope_size;
6040 }
6041
6042 let next_out_of_line = decoder.next_out_of_line();
6043 let handles_before = decoder.remaining_handles();
6044 if let Some((inlined, num_bytes, num_handles)) =
6045 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6046 {
6047 let member_inline_size =
6048 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6049 if inlined != (member_inline_size <= 4) {
6050 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6051 }
6052 let inner_offset;
6053 let mut inner_depth = depth.clone();
6054 if inlined {
6055 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6056 inner_offset = next_offset;
6057 } else {
6058 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6059 inner_depth.increment()?;
6060 }
6061 let val_ref = self.retries.get_or_insert_with(|| fidl::new_empty!(u32, D));
6062 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6063 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6064 {
6065 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6066 }
6067 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6068 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6069 }
6070 }
6071
6072 next_offset += envelope_size;
6073 _next_ordinal_to_read += 1;
6074 if next_offset >= end_offset {
6075 return Ok(());
6076 }
6077
6078 while _next_ordinal_to_read < 14 {
6080 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6081 _next_ordinal_to_read += 1;
6082 next_offset += envelope_size;
6083 }
6084
6085 let next_out_of_line = decoder.next_out_of_line();
6086 let handles_before = decoder.remaining_handles();
6087 if let Some((inlined, num_bytes, num_handles)) =
6088 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6089 {
6090 let member_inline_size =
6091 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6092 if inlined != (member_inline_size <= 4) {
6093 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6094 }
6095 let inner_offset;
6096 let mut inner_depth = depth.clone();
6097 if inlined {
6098 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6099 inner_offset = next_offset;
6100 } else {
6101 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6102 inner_depth.increment()?;
6103 }
6104 let val_ref =
6105 self.direct_max_retry_expiry.get_or_insert_with(|| fidl::new_empty!(u32, D));
6106 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6107 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6108 {
6109 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6110 }
6111 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6112 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6113 }
6114 }
6115
6116 next_offset += envelope_size;
6117 _next_ordinal_to_read += 1;
6118 if next_offset >= end_offset {
6119 return Ok(());
6120 }
6121
6122 while _next_ordinal_to_read < 15 {
6124 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6125 _next_ordinal_to_read += 1;
6126 next_offset += envelope_size;
6127 }
6128
6129 let next_out_of_line = decoder.next_out_of_line();
6130 let handles_before = decoder.remaining_handles();
6131 if let Some((inlined, num_bytes, num_handles)) =
6132 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6133 {
6134 let member_inline_size =
6135 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6136 if inlined != (member_inline_size <= 4) {
6137 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6138 }
6139 let inner_offset;
6140 let mut inner_depth = depth.clone();
6141 if inlined {
6142 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6143 inner_offset = next_offset;
6144 } else {
6145 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6146 inner_depth.increment()?;
6147 }
6148 let val_ref =
6149 self.indirect_max_retry_expiry.get_or_insert_with(|| fidl::new_empty!(u32, D));
6150 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6151 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6152 {
6153 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6154 }
6155 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6156 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6157 }
6158 }
6159
6160 next_offset += envelope_size;
6161 _next_ordinal_to_read += 1;
6162 if next_offset >= end_offset {
6163 return Ok(());
6164 }
6165
6166 while _next_ordinal_to_read < 16 {
6168 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6169 _next_ordinal_to_read += 1;
6170 next_offset += envelope_size;
6171 }
6172
6173 let next_out_of_line = decoder.next_out_of_line();
6174 let handles_before = decoder.remaining_handles();
6175 if let Some((inlined, num_bytes, num_handles)) =
6176 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6177 {
6178 let member_inline_size =
6179 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6180 if inlined != (member_inline_size <= 4) {
6181 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6182 }
6183 let inner_offset;
6184 let mut inner_depth = depth.clone();
6185 if inlined {
6186 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6187 inner_offset = next_offset;
6188 } else {
6189 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6190 inner_depth.increment()?;
6191 }
6192 let val_ref =
6193 self.dest_addr_filtered.get_or_insert_with(|| fidl::new_empty!(u32, D));
6194 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6195 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6196 {
6197 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6198 }
6199 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6200 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6201 }
6202 }
6203
6204 next_offset += envelope_size;
6205 _next_ordinal_to_read += 1;
6206 if next_offset >= end_offset {
6207 return Ok(());
6208 }
6209
6210 while _next_ordinal_to_read < 17 {
6212 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6213 _next_ordinal_to_read += 1;
6214 next_offset += envelope_size;
6215 }
6216
6217 let next_out_of_line = decoder.next_out_of_line();
6218 let handles_before = decoder.remaining_handles();
6219 if let Some((inlined, num_bytes, num_handles)) =
6220 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6221 {
6222 let member_inline_size =
6223 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6224 if inlined != (member_inline_size <= 4) {
6225 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6226 }
6227 let inner_offset;
6228 let mut inner_depth = depth.clone();
6229 if inlined {
6230 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6231 inner_offset = next_offset;
6232 } else {
6233 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6234 inner_depth.increment()?;
6235 }
6236 let val_ref = self.duplicated.get_or_insert_with(|| fidl::new_empty!(u32, D));
6237 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6238 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6239 {
6240 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6241 }
6242 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6243 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6244 }
6245 }
6246
6247 next_offset += envelope_size;
6248 _next_ordinal_to_read += 1;
6249 if next_offset >= end_offset {
6250 return Ok(());
6251 }
6252
6253 while _next_ordinal_to_read < 18 {
6255 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6256 _next_ordinal_to_read += 1;
6257 next_offset += envelope_size;
6258 }
6259
6260 let next_out_of_line = decoder.next_out_of_line();
6261 let handles_before = decoder.remaining_handles();
6262 if let Some((inlined, num_bytes, num_handles)) =
6263 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6264 {
6265 let member_inline_size =
6266 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6267 if inlined != (member_inline_size <= 4) {
6268 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6269 }
6270 let inner_offset;
6271 let mut inner_depth = depth.clone();
6272 if inlined {
6273 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6274 inner_offset = next_offset;
6275 } else {
6276 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6277 inner_depth.increment()?;
6278 }
6279 let val_ref = self.err_no_frame.get_or_insert_with(|| fidl::new_empty!(u32, D));
6280 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6281 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6282 {
6283 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6284 }
6285 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6286 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6287 }
6288 }
6289
6290 next_offset += envelope_size;
6291 _next_ordinal_to_read += 1;
6292 if next_offset >= end_offset {
6293 return Ok(());
6294 }
6295
6296 while _next_ordinal_to_read < 19 {
6298 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6299 _next_ordinal_to_read += 1;
6300 next_offset += envelope_size;
6301 }
6302
6303 let next_out_of_line = decoder.next_out_of_line();
6304 let handles_before = decoder.remaining_handles();
6305 if let Some((inlined, num_bytes, num_handles)) =
6306 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6307 {
6308 let member_inline_size =
6309 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6310 if inlined != (member_inline_size <= 4) {
6311 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6312 }
6313 let inner_offset;
6314 let mut inner_depth = depth.clone();
6315 if inlined {
6316 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6317 inner_offset = next_offset;
6318 } else {
6319 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6320 inner_depth.increment()?;
6321 }
6322 let val_ref =
6323 self.err_unknown_neighbor.get_or_insert_with(|| fidl::new_empty!(u32, D));
6324 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6325 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6326 {
6327 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6328 }
6329 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6330 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6331 }
6332 }
6333
6334 next_offset += envelope_size;
6335 _next_ordinal_to_read += 1;
6336 if next_offset >= end_offset {
6337 return Ok(());
6338 }
6339
6340 while _next_ordinal_to_read < 20 {
6342 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6343 _next_ordinal_to_read += 1;
6344 next_offset += envelope_size;
6345 }
6346
6347 let next_out_of_line = decoder.next_out_of_line();
6348 let handles_before = decoder.remaining_handles();
6349 if let Some((inlined, num_bytes, num_handles)) =
6350 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6351 {
6352 let member_inline_size =
6353 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6354 if inlined != (member_inline_size <= 4) {
6355 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6356 }
6357 let inner_offset;
6358 let mut inner_depth = depth.clone();
6359 if inlined {
6360 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6361 inner_offset = next_offset;
6362 } else {
6363 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6364 inner_depth.increment()?;
6365 }
6366 let val_ref =
6367 self.err_invalid_src_addr.get_or_insert_with(|| fidl::new_empty!(u32, D));
6368 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6369 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6370 {
6371 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6372 }
6373 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6374 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6375 }
6376 }
6377
6378 next_offset += envelope_size;
6379 _next_ordinal_to_read += 1;
6380 if next_offset >= end_offset {
6381 return Ok(());
6382 }
6383
6384 while _next_ordinal_to_read < 21 {
6386 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6387 _next_ordinal_to_read += 1;
6388 next_offset += envelope_size;
6389 }
6390
6391 let next_out_of_line = decoder.next_out_of_line();
6392 let handles_before = decoder.remaining_handles();
6393 if let Some((inlined, num_bytes, num_handles)) =
6394 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6395 {
6396 let member_inline_size =
6397 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6398 if inlined != (member_inline_size <= 4) {
6399 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6400 }
6401 let inner_offset;
6402 let mut inner_depth = depth.clone();
6403 if inlined {
6404 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6405 inner_offset = next_offset;
6406 } else {
6407 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6408 inner_depth.increment()?;
6409 }
6410 let val_ref = self.err_sec.get_or_insert_with(|| fidl::new_empty!(u32, D));
6411 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6412 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6413 {
6414 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6415 }
6416 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6417 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6418 }
6419 }
6420
6421 next_offset += envelope_size;
6422 _next_ordinal_to_read += 1;
6423 if next_offset >= end_offset {
6424 return Ok(());
6425 }
6426
6427 while _next_ordinal_to_read < 22 {
6429 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6430 _next_ordinal_to_read += 1;
6431 next_offset += envelope_size;
6432 }
6433
6434 let next_out_of_line = decoder.next_out_of_line();
6435 let handles_before = decoder.remaining_handles();
6436 if let Some((inlined, num_bytes, num_handles)) =
6437 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6438 {
6439 let member_inline_size =
6440 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6441 if inlined != (member_inline_size <= 4) {
6442 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6443 }
6444 let inner_offset;
6445 let mut inner_depth = depth.clone();
6446 if inlined {
6447 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6448 inner_offset = next_offset;
6449 } else {
6450 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6451 inner_depth.increment()?;
6452 }
6453 let val_ref = self.err_fcs.get_or_insert_with(|| fidl::new_empty!(u32, D));
6454 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6455 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6456 {
6457 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6458 }
6459 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6460 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6461 }
6462 }
6463
6464 next_offset += envelope_size;
6465 _next_ordinal_to_read += 1;
6466 if next_offset >= end_offset {
6467 return Ok(());
6468 }
6469
6470 while _next_ordinal_to_read < 23 {
6472 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6473 _next_ordinal_to_read += 1;
6474 next_offset += envelope_size;
6475 }
6476
6477 let next_out_of_line = decoder.next_out_of_line();
6478 let handles_before = decoder.remaining_handles();
6479 if let Some((inlined, num_bytes, num_handles)) =
6480 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6481 {
6482 let member_inline_size =
6483 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6484 if inlined != (member_inline_size <= 4) {
6485 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6486 }
6487 let inner_offset;
6488 let mut inner_depth = depth.clone();
6489 if inlined {
6490 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6491 inner_offset = next_offset;
6492 } else {
6493 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6494 inner_depth.increment()?;
6495 }
6496 let val_ref = self.err_cca.get_or_insert_with(|| fidl::new_empty!(u32, D));
6497 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6498 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6499 {
6500 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6501 }
6502 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6503 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6504 }
6505 }
6506
6507 next_offset += envelope_size;
6508 _next_ordinal_to_read += 1;
6509 if next_offset >= end_offset {
6510 return Ok(());
6511 }
6512
6513 while _next_ordinal_to_read < 24 {
6515 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6516 _next_ordinal_to_read += 1;
6517 next_offset += envelope_size;
6518 }
6519
6520 let next_out_of_line = decoder.next_out_of_line();
6521 let handles_before = decoder.remaining_handles();
6522 if let Some((inlined, num_bytes, num_handles)) =
6523 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6524 {
6525 let member_inline_size =
6526 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6527 if inlined != (member_inline_size <= 4) {
6528 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6529 }
6530 let inner_offset;
6531 let mut inner_depth = depth.clone();
6532 if inlined {
6533 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6534 inner_offset = next_offset;
6535 } else {
6536 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6537 inner_depth.increment()?;
6538 }
6539 let val_ref = self.err_abort.get_or_insert_with(|| fidl::new_empty!(u32, D));
6540 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6541 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6542 {
6543 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6544 }
6545 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6546 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6547 }
6548 }
6549
6550 next_offset += envelope_size;
6551 _next_ordinal_to_read += 1;
6552 if next_offset >= end_offset {
6553 return Ok(());
6554 }
6555
6556 while _next_ordinal_to_read < 25 {
6558 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6559 _next_ordinal_to_read += 1;
6560 next_offset += envelope_size;
6561 }
6562
6563 let next_out_of_line = decoder.next_out_of_line();
6564 let handles_before = decoder.remaining_handles();
6565 if let Some((inlined, num_bytes, num_handles)) =
6566 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6567 {
6568 let member_inline_size =
6569 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6570 if inlined != (member_inline_size <= 4) {
6571 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6572 }
6573 let inner_offset;
6574 let mut inner_depth = depth.clone();
6575 if inlined {
6576 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6577 inner_offset = next_offset;
6578 } else {
6579 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6580 inner_depth.increment()?;
6581 }
6582 let val_ref = self.err_busy_channel.get_or_insert_with(|| fidl::new_empty!(u32, D));
6583 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6584 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6585 {
6586 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6587 }
6588 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6589 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6590 }
6591 }
6592
6593 next_offset += envelope_size;
6594 _next_ordinal_to_read += 1;
6595 if next_offset >= end_offset {
6596 return Ok(());
6597 }
6598
6599 while _next_ordinal_to_read < 26 {
6601 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6602 _next_ordinal_to_read += 1;
6603 next_offset += envelope_size;
6604 }
6605
6606 let next_out_of_line = decoder.next_out_of_line();
6607 let handles_before = decoder.remaining_handles();
6608 if let Some((inlined, num_bytes, num_handles)) =
6609 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6610 {
6611 let member_inline_size =
6612 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6613 if inlined != (member_inline_size <= 4) {
6614 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6615 }
6616 let inner_offset;
6617 let mut inner_depth = depth.clone();
6618 if inlined {
6619 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6620 inner_offset = next_offset;
6621 } else {
6622 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6623 inner_depth.increment()?;
6624 }
6625 let val_ref = self.err_other.get_or_insert_with(|| fidl::new_empty!(u32, D));
6626 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6627 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6628 {
6629 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6630 }
6631 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6632 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6633 }
6634 }
6635
6636 next_offset += envelope_size;
6637
6638 while next_offset < end_offset {
6640 _next_ordinal_to_read += 1;
6641 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6642 next_offset += envelope_size;
6643 }
6644
6645 Ok(())
6646 }
6647 }
6648
6649 impl fidl::encoding::ValueTypeMarker for Credential {
6650 type Borrowed<'a> = &'a Self;
6651 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6652 value
6653 }
6654 }
6655
6656 unsafe impl fidl::encoding::TypeMarker for Credential {
6657 type Owned = Self;
6658
6659 #[inline(always)]
6660 fn inline_align(_context: fidl::encoding::Context) -> usize {
6661 8
6662 }
6663
6664 #[inline(always)]
6665 fn inline_size(_context: fidl::encoding::Context) -> usize {
6666 16
6667 }
6668 }
6669
6670 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Credential, D>
6671 for &Credential
6672 {
6673 #[inline]
6674 unsafe fn encode(
6675 self,
6676 encoder: &mut fidl::encoding::Encoder<'_, D>,
6677 offset: usize,
6678 _depth: fidl::encoding::Depth,
6679 ) -> fidl::Result<()> {
6680 encoder.debug_check_bounds::<Credential>(offset);
6681 encoder.write_num::<u64>(self.ordinal(), offset);
6682 match self {
6683 Credential::NetworkKey(ref val) => {
6684 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 32>, D>(
6685 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(
6686 val,
6687 ),
6688 encoder,
6689 offset + 8,
6690 _depth,
6691 )
6692 }
6693 Credential::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
6694 }
6695 }
6696 }
6697
6698 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Credential {
6699 #[inline(always)]
6700 fn new_empty() -> Self {
6701 Self::__SourceBreaking { unknown_ordinal: 0 }
6702 }
6703
6704 #[inline]
6705 unsafe fn decode(
6706 &mut self,
6707 decoder: &mut fidl::encoding::Decoder<'_, D>,
6708 offset: usize,
6709 mut depth: fidl::encoding::Depth,
6710 ) -> fidl::Result<()> {
6711 decoder.debug_check_bounds::<Self>(offset);
6712 #[allow(unused_variables)]
6713 let next_out_of_line = decoder.next_out_of_line();
6714 let handles_before = decoder.remaining_handles();
6715 let (ordinal, inlined, num_bytes, num_handles) =
6716 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
6717
6718 let member_inline_size = match ordinal {
6719 1 => <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
6720 decoder.context,
6721 ),
6722 0 => return Err(fidl::Error::UnknownUnionTag),
6723 _ => num_bytes as usize,
6724 };
6725
6726 if inlined != (member_inline_size <= 4) {
6727 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6728 }
6729 let _inner_offset;
6730 if inlined {
6731 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
6732 _inner_offset = offset + 8;
6733 } else {
6734 depth.increment()?;
6735 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6736 }
6737 match ordinal {
6738 1 => {
6739 #[allow(irrefutable_let_patterns)]
6740 if let Credential::NetworkKey(_) = self {
6741 } else {
6743 *self = Credential::NetworkKey(
6745 fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D),
6746 );
6747 }
6748 #[allow(irrefutable_let_patterns)]
6749 if let Credential::NetworkKey(ref mut val) = self {
6750 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val, decoder, _inner_offset, depth)?;
6751 } else {
6752 unreachable!()
6753 }
6754 }
6755 #[allow(deprecated)]
6756 ordinal => {
6757 for _ in 0..num_handles {
6758 decoder.drop_next_handle()?;
6759 }
6760 *self = Credential::__SourceBreaking { unknown_ordinal: ordinal };
6761 }
6762 }
6763 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
6764 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6765 }
6766 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6767 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6768 }
6769 Ok(())
6770 }
6771 }
6772}