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
752pub mod counters_ordinals {
753 pub const GET: u64 = 0xaa28d44c1535a24;
754 pub const RESET: u64 = 0x4cf9a102017cf7ad;
755}
756
757pub mod counters_connector_ordinals {
758 pub const CONNECT: u64 = 0x61ec847f2702d188;
759}
760
761pub mod device_ordinals {
762 pub const PROVISION_NETWORK: u64 = 0x3501046988e17076;
763 pub const LEAVE_NETWORK: u64 = 0x66919e4f9752c53e;
764 pub const SET_ACTIVE: u64 = 0x55a6837f8bbb344b;
765 pub const GET_SUPPORTED_NETWORK_TYPES: u64 = 0x6d8f71a5beb15ebf;
766 pub const WATCH_DEVICE_STATE: u64 = 0x593be5b83e80d249;
767}
768
769pub mod device_connector_ordinals {
770 pub const CONNECT: u64 = 0x63470c4c0c8e678a;
771}
772
773pub mod device_extra_ordinals {
774 pub const GET_CREDENTIAL: u64 = 0x77f75f289c8c4ceb;
775 pub const WATCH_IDENTITY: u64 = 0xb9f5d8963eaebc6;
776 pub const GET_CURRENT_MAC_ADDRESS: u64 = 0x70835954071d94dd;
777}
778
779pub mod device_extra_connector_ordinals {
780 pub const CONNECT: u64 = 0x2959be873ae18ae3;
781}
782
783pub mod energy_scan_ordinals {
784 pub const START_ENERGY_SCAN: u64 = 0x4b2928a05c619b06;
785}
786
787pub mod energy_scan_connector_ordinals {
788 pub const CONNECT: u64 = 0x1076a774e74ab290;
789}
790
791pub mod energy_scan_result_stream_ordinals {
792 pub const NEXT: u64 = 0x7f0139fc06fd6a9e;
793}
794
795mod internal {
796 use super::*;
797 unsafe impl fidl::encoding::TypeMarker for ConnectivityState {
798 type Owned = Self;
799
800 #[inline(always)]
801 fn inline_align(_context: fidl::encoding::Context) -> usize {
802 std::mem::align_of::<i32>()
803 }
804
805 #[inline(always)]
806 fn inline_size(_context: fidl::encoding::Context) -> usize {
807 std::mem::size_of::<i32>()
808 }
809
810 #[inline(always)]
811 fn encode_is_copy() -> bool {
812 false
813 }
814
815 #[inline(always)]
816 fn decode_is_copy() -> bool {
817 false
818 }
819 }
820
821 impl fidl::encoding::ValueTypeMarker for ConnectivityState {
822 type Borrowed<'a> = Self;
823 #[inline(always)]
824 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
825 *value
826 }
827 }
828
829 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
830 for ConnectivityState
831 {
832 #[inline]
833 unsafe fn encode(
834 self,
835 encoder: &mut fidl::encoding::Encoder<'_, D>,
836 offset: usize,
837 _depth: fidl::encoding::Depth,
838 ) -> fidl::Result<()> {
839 encoder.debug_check_bounds::<Self>(offset);
840 encoder.write_num(self.into_primitive(), offset);
841 Ok(())
842 }
843 }
844
845 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectivityState {
846 #[inline(always)]
847 fn new_empty() -> Self {
848 Self::unknown()
849 }
850
851 #[inline]
852 unsafe fn decode(
853 &mut self,
854 decoder: &mut fidl::encoding::Decoder<'_, D>,
855 offset: usize,
856 _depth: fidl::encoding::Depth,
857 ) -> fidl::Result<()> {
858 decoder.debug_check_bounds::<Self>(offset);
859 let prim = decoder.read_num::<i32>(offset);
860
861 *self = Self::from_primitive_allow_unknown(prim);
862 Ok(())
863 }
864 }
865 unsafe impl fidl::encoding::TypeMarker for Role {
866 type Owned = Self;
867
868 #[inline(always)]
869 fn inline_align(_context: fidl::encoding::Context) -> usize {
870 std::mem::align_of::<i32>()
871 }
872
873 #[inline(always)]
874 fn inline_size(_context: fidl::encoding::Context) -> usize {
875 std::mem::size_of::<i32>()
876 }
877
878 #[inline(always)]
879 fn encode_is_copy() -> bool {
880 false
881 }
882
883 #[inline(always)]
884 fn decode_is_copy() -> bool {
885 false
886 }
887 }
888
889 impl fidl::encoding::ValueTypeMarker for Role {
890 type Borrowed<'a> = Self;
891 #[inline(always)]
892 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
893 *value
894 }
895 }
896
897 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Role {
898 #[inline]
899 unsafe fn encode(
900 self,
901 encoder: &mut fidl::encoding::Encoder<'_, D>,
902 offset: usize,
903 _depth: fidl::encoding::Depth,
904 ) -> fidl::Result<()> {
905 encoder.debug_check_bounds::<Self>(offset);
906 encoder.write_num(self.into_primitive(), offset);
907 Ok(())
908 }
909 }
910
911 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Role {
912 #[inline(always)]
913 fn new_empty() -> Self {
914 Self::unknown()
915 }
916
917 #[inline]
918 unsafe fn decode(
919 &mut self,
920 decoder: &mut fidl::encoding::Decoder<'_, D>,
921 offset: usize,
922 _depth: fidl::encoding::Depth,
923 ) -> fidl::Result<()> {
924 decoder.debug_check_bounds::<Self>(offset);
925 let prim = decoder.read_num::<i32>(offset);
926
927 *self = Self::from_primitive_allow_unknown(prim);
928 Ok(())
929 }
930 }
931
932 impl fidl::encoding::ValueTypeMarker for CountersGetResponse {
933 type Borrowed<'a> = &'a Self;
934 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
935 value
936 }
937 }
938
939 unsafe impl fidl::encoding::TypeMarker for CountersGetResponse {
940 type Owned = Self;
941
942 #[inline(always)]
943 fn inline_align(_context: fidl::encoding::Context) -> usize {
944 8
945 }
946
947 #[inline(always)]
948 fn inline_size(_context: fidl::encoding::Context) -> usize {
949 16
950 }
951 }
952
953 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CountersGetResponse, D>
954 for &CountersGetResponse
955 {
956 #[inline]
957 unsafe fn encode(
958 self,
959 encoder: &mut fidl::encoding::Encoder<'_, D>,
960 offset: usize,
961 _depth: fidl::encoding::Depth,
962 ) -> fidl::Result<()> {
963 encoder.debug_check_bounds::<CountersGetResponse>(offset);
964 fidl::encoding::Encode::<CountersGetResponse, D>::encode(
966 (<AllCounters as fidl::encoding::ValueTypeMarker>::borrow(&self.counters),),
967 encoder,
968 offset,
969 _depth,
970 )
971 }
972 }
973 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AllCounters, D>>
974 fidl::encoding::Encode<CountersGetResponse, D> for (T0,)
975 {
976 #[inline]
977 unsafe fn encode(
978 self,
979 encoder: &mut fidl::encoding::Encoder<'_, D>,
980 offset: usize,
981 depth: fidl::encoding::Depth,
982 ) -> fidl::Result<()> {
983 encoder.debug_check_bounds::<CountersGetResponse>(offset);
984 self.0.encode(encoder, offset + 0, depth)?;
988 Ok(())
989 }
990 }
991
992 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CountersGetResponse {
993 #[inline(always)]
994 fn new_empty() -> Self {
995 Self { counters: fidl::new_empty!(AllCounters, D) }
996 }
997
998 #[inline]
999 unsafe fn decode(
1000 &mut self,
1001 decoder: &mut fidl::encoding::Decoder<'_, D>,
1002 offset: usize,
1003 _depth: fidl::encoding::Depth,
1004 ) -> fidl::Result<()> {
1005 decoder.debug_check_bounds::<Self>(offset);
1006 fidl::decode!(AllCounters, D, &mut self.counters, decoder, offset + 0, _depth)?;
1008 Ok(())
1009 }
1010 }
1011
1012 impl fidl::encoding::ValueTypeMarker for CountersResetResponse {
1013 type Borrowed<'a> = &'a Self;
1014 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1015 value
1016 }
1017 }
1018
1019 unsafe impl fidl::encoding::TypeMarker for CountersResetResponse {
1020 type Owned = Self;
1021
1022 #[inline(always)]
1023 fn inline_align(_context: fidl::encoding::Context) -> usize {
1024 8
1025 }
1026
1027 #[inline(always)]
1028 fn inline_size(_context: fidl::encoding::Context) -> usize {
1029 16
1030 }
1031 }
1032
1033 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CountersResetResponse, D>
1034 for &CountersResetResponse
1035 {
1036 #[inline]
1037 unsafe fn encode(
1038 self,
1039 encoder: &mut fidl::encoding::Encoder<'_, D>,
1040 offset: usize,
1041 _depth: fidl::encoding::Depth,
1042 ) -> fidl::Result<()> {
1043 encoder.debug_check_bounds::<CountersResetResponse>(offset);
1044 fidl::encoding::Encode::<CountersResetResponse, D>::encode(
1046 (<AllCounters as fidl::encoding::ValueTypeMarker>::borrow(&self.counters),),
1047 encoder,
1048 offset,
1049 _depth,
1050 )
1051 }
1052 }
1053 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AllCounters, D>>
1054 fidl::encoding::Encode<CountersResetResponse, D> for (T0,)
1055 {
1056 #[inline]
1057 unsafe fn encode(
1058 self,
1059 encoder: &mut fidl::encoding::Encoder<'_, D>,
1060 offset: usize,
1061 depth: fidl::encoding::Depth,
1062 ) -> fidl::Result<()> {
1063 encoder.debug_check_bounds::<CountersResetResponse>(offset);
1064 self.0.encode(encoder, offset + 0, depth)?;
1068 Ok(())
1069 }
1070 }
1071
1072 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CountersResetResponse {
1073 #[inline(always)]
1074 fn new_empty() -> Self {
1075 Self { counters: fidl::new_empty!(AllCounters, D) }
1076 }
1077
1078 #[inline]
1079 unsafe fn decode(
1080 &mut self,
1081 decoder: &mut fidl::encoding::Decoder<'_, D>,
1082 offset: usize,
1083 _depth: fidl::encoding::Depth,
1084 ) -> fidl::Result<()> {
1085 decoder.debug_check_bounds::<Self>(offset);
1086 fidl::decode!(AllCounters, D, &mut self.counters, decoder, offset + 0, _depth)?;
1088 Ok(())
1089 }
1090 }
1091
1092 impl fidl::encoding::ValueTypeMarker for DeviceExtraGetCredentialResponse {
1093 type Borrowed<'a> = &'a Self;
1094 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1095 value
1096 }
1097 }
1098
1099 unsafe impl fidl::encoding::TypeMarker for DeviceExtraGetCredentialResponse {
1100 type Owned = Self;
1101
1102 #[inline(always)]
1103 fn inline_align(_context: fidl::encoding::Context) -> usize {
1104 8
1105 }
1106
1107 #[inline(always)]
1108 fn inline_size(_context: fidl::encoding::Context) -> usize {
1109 16
1110 }
1111 }
1112
1113 unsafe impl<D: fidl::encoding::ResourceDialect>
1114 fidl::encoding::Encode<DeviceExtraGetCredentialResponse, D>
1115 for &DeviceExtraGetCredentialResponse
1116 {
1117 #[inline]
1118 unsafe fn encode(
1119 self,
1120 encoder: &mut fidl::encoding::Encoder<'_, D>,
1121 offset: usize,
1122 _depth: fidl::encoding::Depth,
1123 ) -> fidl::Result<()> {
1124 encoder.debug_check_bounds::<DeviceExtraGetCredentialResponse>(offset);
1125 fidl::encoding::Encode::<DeviceExtraGetCredentialResponse, D>::encode(
1127 (
1128 <fidl::encoding::OptionalUnion<Credential> as fidl::encoding::ValueTypeMarker>::borrow(&self.credential),
1129 ),
1130 encoder, offset, _depth
1131 )
1132 }
1133 }
1134 unsafe impl<
1135 D: fidl::encoding::ResourceDialect,
1136 T0: fidl::encoding::Encode<fidl::encoding::OptionalUnion<Credential>, D>,
1137 > fidl::encoding::Encode<DeviceExtraGetCredentialResponse, D> for (T0,)
1138 {
1139 #[inline]
1140 unsafe fn encode(
1141 self,
1142 encoder: &mut fidl::encoding::Encoder<'_, D>,
1143 offset: usize,
1144 depth: fidl::encoding::Depth,
1145 ) -> fidl::Result<()> {
1146 encoder.debug_check_bounds::<DeviceExtraGetCredentialResponse>(offset);
1147 self.0.encode(encoder, offset + 0, depth)?;
1151 Ok(())
1152 }
1153 }
1154
1155 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1156 for DeviceExtraGetCredentialResponse
1157 {
1158 #[inline(always)]
1159 fn new_empty() -> Self {
1160 Self { credential: fidl::new_empty!(fidl::encoding::OptionalUnion<Credential>, D) }
1161 }
1162
1163 #[inline]
1164 unsafe fn decode(
1165 &mut self,
1166 decoder: &mut fidl::encoding::Decoder<'_, D>,
1167 offset: usize,
1168 _depth: fidl::encoding::Depth,
1169 ) -> fidl::Result<()> {
1170 decoder.debug_check_bounds::<Self>(offset);
1171 fidl::decode!(
1173 fidl::encoding::OptionalUnion<Credential>,
1174 D,
1175 &mut self.credential,
1176 decoder,
1177 offset + 0,
1178 _depth
1179 )?;
1180 Ok(())
1181 }
1182 }
1183
1184 impl fidl::encoding::ValueTypeMarker for DeviceExtraGetCurrentMacAddressResponse {
1185 type Borrowed<'a> = &'a Self;
1186 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1187 value
1188 }
1189 }
1190
1191 unsafe impl fidl::encoding::TypeMarker for DeviceExtraGetCurrentMacAddressResponse {
1192 type Owned = Self;
1193
1194 #[inline(always)]
1195 fn inline_align(_context: fidl::encoding::Context) -> usize {
1196 1
1197 }
1198
1199 #[inline(always)]
1200 fn inline_size(_context: fidl::encoding::Context) -> usize {
1201 8
1202 }
1203 }
1204
1205 unsafe impl<D: fidl::encoding::ResourceDialect>
1206 fidl::encoding::Encode<DeviceExtraGetCurrentMacAddressResponse, D>
1207 for &DeviceExtraGetCurrentMacAddressResponse
1208 {
1209 #[inline]
1210 unsafe fn encode(
1211 self,
1212 encoder: &mut fidl::encoding::Encoder<'_, D>,
1213 offset: usize,
1214 _depth: fidl::encoding::Depth,
1215 ) -> fidl::Result<()> {
1216 encoder.debug_check_bounds::<DeviceExtraGetCurrentMacAddressResponse>(offset);
1217 fidl::encoding::Encode::<DeviceExtraGetCurrentMacAddressResponse, D>::encode(
1219 (
1220 <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
1221 ),
1222 encoder, offset, _depth
1223 )
1224 }
1225 }
1226 unsafe impl<
1227 D: fidl::encoding::ResourceDialect,
1228 T0: fidl::encoding::Encode<fidl_fuchsia_lowpan__common::MacAddress, D>,
1229 > fidl::encoding::Encode<DeviceExtraGetCurrentMacAddressResponse, D> for (T0,)
1230 {
1231 #[inline]
1232 unsafe fn encode(
1233 self,
1234 encoder: &mut fidl::encoding::Encoder<'_, D>,
1235 offset: usize,
1236 depth: fidl::encoding::Depth,
1237 ) -> fidl::Result<()> {
1238 encoder.debug_check_bounds::<DeviceExtraGetCurrentMacAddressResponse>(offset);
1239 self.0.encode(encoder, offset + 0, depth)?;
1243 Ok(())
1244 }
1245 }
1246
1247 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1248 for DeviceExtraGetCurrentMacAddressResponse
1249 {
1250 #[inline(always)]
1251 fn new_empty() -> Self {
1252 Self { address: fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D) }
1253 }
1254
1255 #[inline]
1256 unsafe fn decode(
1257 &mut self,
1258 decoder: &mut fidl::encoding::Decoder<'_, D>,
1259 offset: usize,
1260 _depth: fidl::encoding::Depth,
1261 ) -> fidl::Result<()> {
1262 decoder.debug_check_bounds::<Self>(offset);
1263 fidl::decode!(
1265 fidl_fuchsia_lowpan__common::MacAddress,
1266 D,
1267 &mut self.address,
1268 decoder,
1269 offset + 0,
1270 _depth
1271 )?;
1272 Ok(())
1273 }
1274 }
1275
1276 impl fidl::encoding::ValueTypeMarker for DeviceExtraWatchIdentityResponse {
1277 type Borrowed<'a> = &'a Self;
1278 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1279 value
1280 }
1281 }
1282
1283 unsafe impl fidl::encoding::TypeMarker for DeviceExtraWatchIdentityResponse {
1284 type Owned = Self;
1285
1286 #[inline(always)]
1287 fn inline_align(_context: fidl::encoding::Context) -> usize {
1288 8
1289 }
1290
1291 #[inline(always)]
1292 fn inline_size(_context: fidl::encoding::Context) -> usize {
1293 16
1294 }
1295 }
1296
1297 unsafe impl<D: fidl::encoding::ResourceDialect>
1298 fidl::encoding::Encode<DeviceExtraWatchIdentityResponse, D>
1299 for &DeviceExtraWatchIdentityResponse
1300 {
1301 #[inline]
1302 unsafe fn encode(
1303 self,
1304 encoder: &mut fidl::encoding::Encoder<'_, D>,
1305 offset: usize,
1306 _depth: fidl::encoding::Depth,
1307 ) -> fidl::Result<()> {
1308 encoder.debug_check_bounds::<DeviceExtraWatchIdentityResponse>(offset);
1309 fidl::encoding::Encode::<DeviceExtraWatchIdentityResponse, D>::encode(
1311 (<Identity as fidl::encoding::ValueTypeMarker>::borrow(&self.identity),),
1312 encoder,
1313 offset,
1314 _depth,
1315 )
1316 }
1317 }
1318 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Identity, D>>
1319 fidl::encoding::Encode<DeviceExtraWatchIdentityResponse, D> for (T0,)
1320 {
1321 #[inline]
1322 unsafe fn encode(
1323 self,
1324 encoder: &mut fidl::encoding::Encoder<'_, D>,
1325 offset: usize,
1326 depth: fidl::encoding::Depth,
1327 ) -> fidl::Result<()> {
1328 encoder.debug_check_bounds::<DeviceExtraWatchIdentityResponse>(offset);
1329 self.0.encode(encoder, offset + 0, depth)?;
1333 Ok(())
1334 }
1335 }
1336
1337 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1338 for DeviceExtraWatchIdentityResponse
1339 {
1340 #[inline(always)]
1341 fn new_empty() -> Self {
1342 Self { identity: fidl::new_empty!(Identity, D) }
1343 }
1344
1345 #[inline]
1346 unsafe fn decode(
1347 &mut self,
1348 decoder: &mut fidl::encoding::Decoder<'_, D>,
1349 offset: usize,
1350 _depth: fidl::encoding::Depth,
1351 ) -> fidl::Result<()> {
1352 decoder.debug_check_bounds::<Self>(offset);
1353 fidl::decode!(Identity, D, &mut self.identity, decoder, offset + 0, _depth)?;
1355 Ok(())
1356 }
1357 }
1358
1359 impl fidl::encoding::ValueTypeMarker for DeviceGetSupportedNetworkTypesResponse {
1360 type Borrowed<'a> = &'a Self;
1361 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1362 value
1363 }
1364 }
1365
1366 unsafe impl fidl::encoding::TypeMarker for DeviceGetSupportedNetworkTypesResponse {
1367 type Owned = Self;
1368
1369 #[inline(always)]
1370 fn inline_align(_context: fidl::encoding::Context) -> usize {
1371 8
1372 }
1373
1374 #[inline(always)]
1375 fn inline_size(_context: fidl::encoding::Context) -> usize {
1376 16
1377 }
1378 }
1379
1380 unsafe impl<D: fidl::encoding::ResourceDialect>
1381 fidl::encoding::Encode<DeviceGetSupportedNetworkTypesResponse, D>
1382 for &DeviceGetSupportedNetworkTypesResponse
1383 {
1384 #[inline]
1385 unsafe fn encode(
1386 self,
1387 encoder: &mut fidl::encoding::Encoder<'_, D>,
1388 offset: usize,
1389 _depth: fidl::encoding::Depth,
1390 ) -> fidl::Result<()> {
1391 encoder.debug_check_bounds::<DeviceGetSupportedNetworkTypesResponse>(offset);
1392 fidl::encoding::Encode::<DeviceGetSupportedNetworkTypesResponse, D>::encode(
1394 (
1395 <fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.network_types),
1396 ),
1397 encoder, offset, _depth
1398 )
1399 }
1400 }
1401 unsafe impl<
1402 D: fidl::encoding::ResourceDialect,
1403 T0: fidl::encoding::Encode<
1404 fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1405 D,
1406 >,
1407 > fidl::encoding::Encode<DeviceGetSupportedNetworkTypesResponse, D> for (T0,)
1408 {
1409 #[inline]
1410 unsafe fn encode(
1411 self,
1412 encoder: &mut fidl::encoding::Encoder<'_, D>,
1413 offset: usize,
1414 depth: fidl::encoding::Depth,
1415 ) -> fidl::Result<()> {
1416 encoder.debug_check_bounds::<DeviceGetSupportedNetworkTypesResponse>(offset);
1417 self.0.encode(encoder, offset + 0, depth)?;
1421 Ok(())
1422 }
1423 }
1424
1425 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1426 for DeviceGetSupportedNetworkTypesResponse
1427 {
1428 #[inline(always)]
1429 fn new_empty() -> Self {
1430 Self {
1431 network_types: fidl::new_empty!(
1432 fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1433 D
1434 ),
1435 }
1436 }
1437
1438 #[inline]
1439 unsafe fn decode(
1440 &mut self,
1441 decoder: &mut fidl::encoding::Decoder<'_, D>,
1442 offset: usize,
1443 _depth: fidl::encoding::Depth,
1444 ) -> fidl::Result<()> {
1445 decoder.debug_check_bounds::<Self>(offset);
1446 fidl::decode!(
1448 fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1449 D,
1450 &mut self.network_types,
1451 decoder,
1452 offset + 0,
1453 _depth
1454 )?;
1455 Ok(())
1456 }
1457 }
1458
1459 impl fidl::encoding::ValueTypeMarker for DeviceProvisionNetworkRequest {
1460 type Borrowed<'a> = &'a Self;
1461 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1462 value
1463 }
1464 }
1465
1466 unsafe impl fidl::encoding::TypeMarker for DeviceProvisionNetworkRequest {
1467 type Owned = Self;
1468
1469 #[inline(always)]
1470 fn inline_align(_context: fidl::encoding::Context) -> usize {
1471 8
1472 }
1473
1474 #[inline(always)]
1475 fn inline_size(_context: fidl::encoding::Context) -> usize {
1476 32
1477 }
1478 }
1479
1480 unsafe impl<D: fidl::encoding::ResourceDialect>
1481 fidl::encoding::Encode<DeviceProvisionNetworkRequest, D>
1482 for &DeviceProvisionNetworkRequest
1483 {
1484 #[inline]
1485 unsafe fn encode(
1486 self,
1487 encoder: &mut fidl::encoding::Encoder<'_, D>,
1488 offset: usize,
1489 _depth: fidl::encoding::Depth,
1490 ) -> fidl::Result<()> {
1491 encoder.debug_check_bounds::<DeviceProvisionNetworkRequest>(offset);
1492 fidl::encoding::Encode::<DeviceProvisionNetworkRequest, D>::encode(
1494 (<ProvisioningParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),),
1495 encoder,
1496 offset,
1497 _depth,
1498 )
1499 }
1500 }
1501 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ProvisioningParams, D>>
1502 fidl::encoding::Encode<DeviceProvisionNetworkRequest, D> for (T0,)
1503 {
1504 #[inline]
1505 unsafe fn encode(
1506 self,
1507 encoder: &mut fidl::encoding::Encoder<'_, D>,
1508 offset: usize,
1509 depth: fidl::encoding::Depth,
1510 ) -> fidl::Result<()> {
1511 encoder.debug_check_bounds::<DeviceProvisionNetworkRequest>(offset);
1512 self.0.encode(encoder, offset + 0, depth)?;
1516 Ok(())
1517 }
1518 }
1519
1520 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1521 for DeviceProvisionNetworkRequest
1522 {
1523 #[inline(always)]
1524 fn new_empty() -> Self {
1525 Self { params: fidl::new_empty!(ProvisioningParams, D) }
1526 }
1527
1528 #[inline]
1529 unsafe fn decode(
1530 &mut self,
1531 decoder: &mut fidl::encoding::Decoder<'_, D>,
1532 offset: usize,
1533 _depth: fidl::encoding::Depth,
1534 ) -> fidl::Result<()> {
1535 decoder.debug_check_bounds::<Self>(offset);
1536 fidl::decode!(ProvisioningParams, D, &mut self.params, decoder, offset + 0, _depth)?;
1538 Ok(())
1539 }
1540 }
1541
1542 impl fidl::encoding::ValueTypeMarker for DeviceSetActiveRequest {
1543 type Borrowed<'a> = &'a Self;
1544 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1545 value
1546 }
1547 }
1548
1549 unsafe impl fidl::encoding::TypeMarker for DeviceSetActiveRequest {
1550 type Owned = Self;
1551
1552 #[inline(always)]
1553 fn inline_align(_context: fidl::encoding::Context) -> usize {
1554 1
1555 }
1556
1557 #[inline(always)]
1558 fn inline_size(_context: fidl::encoding::Context) -> usize {
1559 1
1560 }
1561 }
1562
1563 unsafe impl<D: fidl::encoding::ResourceDialect>
1564 fidl::encoding::Encode<DeviceSetActiveRequest, D> for &DeviceSetActiveRequest
1565 {
1566 #[inline]
1567 unsafe fn encode(
1568 self,
1569 encoder: &mut fidl::encoding::Encoder<'_, D>,
1570 offset: usize,
1571 _depth: fidl::encoding::Depth,
1572 ) -> fidl::Result<()> {
1573 encoder.debug_check_bounds::<DeviceSetActiveRequest>(offset);
1574 fidl::encoding::Encode::<DeviceSetActiveRequest, D>::encode(
1576 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.active),),
1577 encoder,
1578 offset,
1579 _depth,
1580 )
1581 }
1582 }
1583 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1584 fidl::encoding::Encode<DeviceSetActiveRequest, D> for (T0,)
1585 {
1586 #[inline]
1587 unsafe fn encode(
1588 self,
1589 encoder: &mut fidl::encoding::Encoder<'_, D>,
1590 offset: usize,
1591 depth: fidl::encoding::Depth,
1592 ) -> fidl::Result<()> {
1593 encoder.debug_check_bounds::<DeviceSetActiveRequest>(offset);
1594 self.0.encode(encoder, offset + 0, depth)?;
1598 Ok(())
1599 }
1600 }
1601
1602 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1603 for DeviceSetActiveRequest
1604 {
1605 #[inline(always)]
1606 fn new_empty() -> Self {
1607 Self { active: fidl::new_empty!(bool, D) }
1608 }
1609
1610 #[inline]
1611 unsafe fn decode(
1612 &mut self,
1613 decoder: &mut fidl::encoding::Decoder<'_, D>,
1614 offset: usize,
1615 _depth: fidl::encoding::Depth,
1616 ) -> fidl::Result<()> {
1617 decoder.debug_check_bounds::<Self>(offset);
1618 fidl::decode!(bool, D, &mut self.active, decoder, offset + 0, _depth)?;
1620 Ok(())
1621 }
1622 }
1623
1624 impl fidl::encoding::ValueTypeMarker for DeviceWatchDeviceStateResponse {
1625 type Borrowed<'a> = &'a Self;
1626 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1627 value
1628 }
1629 }
1630
1631 unsafe impl fidl::encoding::TypeMarker for DeviceWatchDeviceStateResponse {
1632 type Owned = Self;
1633
1634 #[inline(always)]
1635 fn inline_align(_context: fidl::encoding::Context) -> usize {
1636 8
1637 }
1638
1639 #[inline(always)]
1640 fn inline_size(_context: fidl::encoding::Context) -> usize {
1641 16
1642 }
1643 }
1644
1645 unsafe impl<D: fidl::encoding::ResourceDialect>
1646 fidl::encoding::Encode<DeviceWatchDeviceStateResponse, D>
1647 for &DeviceWatchDeviceStateResponse
1648 {
1649 #[inline]
1650 unsafe fn encode(
1651 self,
1652 encoder: &mut fidl::encoding::Encoder<'_, D>,
1653 offset: usize,
1654 _depth: fidl::encoding::Depth,
1655 ) -> fidl::Result<()> {
1656 encoder.debug_check_bounds::<DeviceWatchDeviceStateResponse>(offset);
1657 fidl::encoding::Encode::<DeviceWatchDeviceStateResponse, D>::encode(
1659 (<DeviceState as fidl::encoding::ValueTypeMarker>::borrow(
1660 &self.device_combined_state,
1661 ),),
1662 encoder,
1663 offset,
1664 _depth,
1665 )
1666 }
1667 }
1668 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<DeviceState, D>>
1669 fidl::encoding::Encode<DeviceWatchDeviceStateResponse, D> for (T0,)
1670 {
1671 #[inline]
1672 unsafe fn encode(
1673 self,
1674 encoder: &mut fidl::encoding::Encoder<'_, D>,
1675 offset: usize,
1676 depth: fidl::encoding::Depth,
1677 ) -> fidl::Result<()> {
1678 encoder.debug_check_bounds::<DeviceWatchDeviceStateResponse>(offset);
1679 self.0.encode(encoder, offset + 0, depth)?;
1683 Ok(())
1684 }
1685 }
1686
1687 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1688 for DeviceWatchDeviceStateResponse
1689 {
1690 #[inline(always)]
1691 fn new_empty() -> Self {
1692 Self { device_combined_state: fidl::new_empty!(DeviceState, D) }
1693 }
1694
1695 #[inline]
1696 unsafe fn decode(
1697 &mut self,
1698 decoder: &mut fidl::encoding::Decoder<'_, D>,
1699 offset: usize,
1700 _depth: fidl::encoding::Depth,
1701 ) -> fidl::Result<()> {
1702 decoder.debug_check_bounds::<Self>(offset);
1703 fidl::decode!(
1705 DeviceState,
1706 D,
1707 &mut self.device_combined_state,
1708 decoder,
1709 offset + 0,
1710 _depth
1711 )?;
1712 Ok(())
1713 }
1714 }
1715
1716 impl fidl::encoding::ValueTypeMarker for EnergyScanResultStreamNextResponse {
1717 type Borrowed<'a> = &'a Self;
1718 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1719 value
1720 }
1721 }
1722
1723 unsafe impl fidl::encoding::TypeMarker for EnergyScanResultStreamNextResponse {
1724 type Owned = Self;
1725
1726 #[inline(always)]
1727 fn inline_align(_context: fidl::encoding::Context) -> usize {
1728 8
1729 }
1730
1731 #[inline(always)]
1732 fn inline_size(_context: fidl::encoding::Context) -> usize {
1733 16
1734 }
1735 }
1736
1737 unsafe impl<D: fidl::encoding::ResourceDialect>
1738 fidl::encoding::Encode<EnergyScanResultStreamNextResponse, D>
1739 for &EnergyScanResultStreamNextResponse
1740 {
1741 #[inline]
1742 unsafe fn encode(
1743 self,
1744 encoder: &mut fidl::encoding::Encoder<'_, D>,
1745 offset: usize,
1746 _depth: fidl::encoding::Depth,
1747 ) -> fidl::Result<()> {
1748 encoder.debug_check_bounds::<EnergyScanResultStreamNextResponse>(offset);
1749 fidl::encoding::Encode::<EnergyScanResultStreamNextResponse, D>::encode(
1751 (
1752 <fidl::encoding::Vector<EnergyScanResult, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.results),
1753 ),
1754 encoder, offset, _depth
1755 )
1756 }
1757 }
1758 unsafe impl<
1759 D: fidl::encoding::ResourceDialect,
1760 T0: fidl::encoding::Encode<fidl::encoding::Vector<EnergyScanResult, 32>, D>,
1761 > fidl::encoding::Encode<EnergyScanResultStreamNextResponse, D> for (T0,)
1762 {
1763 #[inline]
1764 unsafe fn encode(
1765 self,
1766 encoder: &mut fidl::encoding::Encoder<'_, D>,
1767 offset: usize,
1768 depth: fidl::encoding::Depth,
1769 ) -> fidl::Result<()> {
1770 encoder.debug_check_bounds::<EnergyScanResultStreamNextResponse>(offset);
1771 self.0.encode(encoder, offset + 0, depth)?;
1775 Ok(())
1776 }
1777 }
1778
1779 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1780 for EnergyScanResultStreamNextResponse
1781 {
1782 #[inline(always)]
1783 fn new_empty() -> Self {
1784 Self { results: fidl::new_empty!(fidl::encoding::Vector<EnergyScanResult, 32>, D) }
1785 }
1786
1787 #[inline]
1788 unsafe fn decode(
1789 &mut self,
1790 decoder: &mut fidl::encoding::Decoder<'_, D>,
1791 offset: usize,
1792 _depth: fidl::encoding::Depth,
1793 ) -> fidl::Result<()> {
1794 decoder.debug_check_bounds::<Self>(offset);
1795 fidl::decode!(fidl::encoding::Vector<EnergyScanResult, 32>, D, &mut self.results, decoder, offset + 0, _depth)?;
1797 Ok(())
1798 }
1799 }
1800
1801 impl fidl::encoding::ValueTypeMarker for ProvisioningParams {
1802 type Borrowed<'a> = &'a Self;
1803 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1804 value
1805 }
1806 }
1807
1808 unsafe impl fidl::encoding::TypeMarker for ProvisioningParams {
1809 type Owned = Self;
1810
1811 #[inline(always)]
1812 fn inline_align(_context: fidl::encoding::Context) -> usize {
1813 8
1814 }
1815
1816 #[inline(always)]
1817 fn inline_size(_context: fidl::encoding::Context) -> usize {
1818 32
1819 }
1820 }
1821
1822 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProvisioningParams, D>
1823 for &ProvisioningParams
1824 {
1825 #[inline]
1826 unsafe fn encode(
1827 self,
1828 encoder: &mut fidl::encoding::Encoder<'_, D>,
1829 offset: usize,
1830 _depth: fidl::encoding::Depth,
1831 ) -> fidl::Result<()> {
1832 encoder.debug_check_bounds::<ProvisioningParams>(offset);
1833 fidl::encoding::Encode::<ProvisioningParams, D>::encode(
1835 (
1836 <Identity as fidl::encoding::ValueTypeMarker>::borrow(&self.identity),
1837 <fidl::encoding::OptionalUnion<Credential> as fidl::encoding::ValueTypeMarker>::borrow(&self.credential),
1838 ),
1839 encoder, offset, _depth
1840 )
1841 }
1842 }
1843 unsafe impl<
1844 D: fidl::encoding::ResourceDialect,
1845 T0: fidl::encoding::Encode<Identity, D>,
1846 T1: fidl::encoding::Encode<fidl::encoding::OptionalUnion<Credential>, D>,
1847 > fidl::encoding::Encode<ProvisioningParams, D> for (T0, T1)
1848 {
1849 #[inline]
1850 unsafe fn encode(
1851 self,
1852 encoder: &mut fidl::encoding::Encoder<'_, D>,
1853 offset: usize,
1854 depth: fidl::encoding::Depth,
1855 ) -> fidl::Result<()> {
1856 encoder.debug_check_bounds::<ProvisioningParams>(offset);
1857 self.0.encode(encoder, offset + 0, depth)?;
1861 self.1.encode(encoder, offset + 16, depth)?;
1862 Ok(())
1863 }
1864 }
1865
1866 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisioningParams {
1867 #[inline(always)]
1868 fn new_empty() -> Self {
1869 Self {
1870 identity: fidl::new_empty!(Identity, D),
1871 credential: fidl::new_empty!(fidl::encoding::OptionalUnion<Credential>, D),
1872 }
1873 }
1874
1875 #[inline]
1876 unsafe fn decode(
1877 &mut self,
1878 decoder: &mut fidl::encoding::Decoder<'_, D>,
1879 offset: usize,
1880 _depth: fidl::encoding::Depth,
1881 ) -> fidl::Result<()> {
1882 decoder.debug_check_bounds::<Self>(offset);
1883 fidl::decode!(Identity, D, &mut self.identity, decoder, offset + 0, _depth)?;
1885 fidl::decode!(
1886 fidl::encoding::OptionalUnion<Credential>,
1887 D,
1888 &mut self.credential,
1889 decoder,
1890 offset + 16,
1891 _depth
1892 )?;
1893 Ok(())
1894 }
1895 }
1896
1897 impl AllCounters {
1898 #[inline(always)]
1899 fn max_ordinal_present(&self) -> u64 {
1900 if let Some(_) = self.ip_rx {
1901 return 7;
1902 }
1903 if let Some(_) = self.ip_tx {
1904 return 6;
1905 }
1906 if let Some(_) = self.coex_saturated {
1907 return 5;
1908 }
1909 if let Some(_) = self.coex_rx {
1910 return 4;
1911 }
1912 if let Some(_) = self.coex_tx {
1913 return 3;
1914 }
1915 if let Some(_) = self.mac_rx {
1916 return 2;
1917 }
1918 if let Some(_) = self.mac_tx {
1919 return 1;
1920 }
1921 0
1922 }
1923 }
1924
1925 impl fidl::encoding::ValueTypeMarker for AllCounters {
1926 type Borrowed<'a> = &'a Self;
1927 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1928 value
1929 }
1930 }
1931
1932 unsafe impl fidl::encoding::TypeMarker for AllCounters {
1933 type Owned = Self;
1934
1935 #[inline(always)]
1936 fn inline_align(_context: fidl::encoding::Context) -> usize {
1937 8
1938 }
1939
1940 #[inline(always)]
1941 fn inline_size(_context: fidl::encoding::Context) -> usize {
1942 16
1943 }
1944 }
1945
1946 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllCounters, D>
1947 for &AllCounters
1948 {
1949 unsafe fn encode(
1950 self,
1951 encoder: &mut fidl::encoding::Encoder<'_, D>,
1952 offset: usize,
1953 mut depth: fidl::encoding::Depth,
1954 ) -> fidl::Result<()> {
1955 encoder.debug_check_bounds::<AllCounters>(offset);
1956 let max_ordinal: u64 = self.max_ordinal_present();
1958 encoder.write_num(max_ordinal, offset);
1959 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1960 if max_ordinal == 0 {
1962 return Ok(());
1963 }
1964 depth.increment()?;
1965 let envelope_size = 8;
1966 let bytes_len = max_ordinal as usize * envelope_size;
1967 #[allow(unused_variables)]
1968 let offset = encoder.out_of_line_offset(bytes_len);
1969 let mut _prev_end_offset: usize = 0;
1970 if 1 > max_ordinal {
1971 return Ok(());
1972 }
1973
1974 let cur_offset: usize = (1 - 1) * envelope_size;
1977
1978 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1980
1981 fidl::encoding::encode_in_envelope_optional::<MacCounters, D>(
1986 self.mac_tx.as_ref().map(<MacCounters as fidl::encoding::ValueTypeMarker>::borrow),
1987 encoder,
1988 offset + cur_offset,
1989 depth,
1990 )?;
1991
1992 _prev_end_offset = cur_offset + envelope_size;
1993 if 2 > max_ordinal {
1994 return Ok(());
1995 }
1996
1997 let cur_offset: usize = (2 - 1) * envelope_size;
2000
2001 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2003
2004 fidl::encoding::encode_in_envelope_optional::<MacCounters, D>(
2009 self.mac_rx.as_ref().map(<MacCounters as fidl::encoding::ValueTypeMarker>::borrow),
2010 encoder,
2011 offset + cur_offset,
2012 depth,
2013 )?;
2014
2015 _prev_end_offset = cur_offset + envelope_size;
2016 if 3 > max_ordinal {
2017 return Ok(());
2018 }
2019
2020 let cur_offset: usize = (3 - 1) * envelope_size;
2023
2024 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2026
2027 fidl::encoding::encode_in_envelope_optional::<CoexCounters, D>(
2032 self.coex_tx
2033 .as_ref()
2034 .map(<CoexCounters as fidl::encoding::ValueTypeMarker>::borrow),
2035 encoder,
2036 offset + cur_offset,
2037 depth,
2038 )?;
2039
2040 _prev_end_offset = cur_offset + envelope_size;
2041 if 4 > max_ordinal {
2042 return Ok(());
2043 }
2044
2045 let cur_offset: usize = (4 - 1) * envelope_size;
2048
2049 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2051
2052 fidl::encoding::encode_in_envelope_optional::<CoexCounters, D>(
2057 self.coex_rx
2058 .as_ref()
2059 .map(<CoexCounters as fidl::encoding::ValueTypeMarker>::borrow),
2060 encoder,
2061 offset + cur_offset,
2062 depth,
2063 )?;
2064
2065 _prev_end_offset = cur_offset + envelope_size;
2066 if 5 > max_ordinal {
2067 return Ok(());
2068 }
2069
2070 let cur_offset: usize = (5 - 1) * envelope_size;
2073
2074 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2076
2077 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2082 self.coex_saturated.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2083 encoder,
2084 offset + cur_offset,
2085 depth,
2086 )?;
2087
2088 _prev_end_offset = cur_offset + envelope_size;
2089 if 6 > max_ordinal {
2090 return Ok(());
2091 }
2092
2093 let cur_offset: usize = (6 - 1) * envelope_size;
2096
2097 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2099
2100 fidl::encoding::encode_in_envelope_optional::<IpCounters, D>(
2105 self.ip_tx.as_ref().map(<IpCounters as fidl::encoding::ValueTypeMarker>::borrow),
2106 encoder,
2107 offset + cur_offset,
2108 depth,
2109 )?;
2110
2111 _prev_end_offset = cur_offset + envelope_size;
2112 if 7 > max_ordinal {
2113 return Ok(());
2114 }
2115
2116 let cur_offset: usize = (7 - 1) * envelope_size;
2119
2120 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2122
2123 fidl::encoding::encode_in_envelope_optional::<IpCounters, D>(
2128 self.ip_rx.as_ref().map(<IpCounters as fidl::encoding::ValueTypeMarker>::borrow),
2129 encoder,
2130 offset + cur_offset,
2131 depth,
2132 )?;
2133
2134 _prev_end_offset = cur_offset + envelope_size;
2135
2136 Ok(())
2137 }
2138 }
2139
2140 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllCounters {
2141 #[inline(always)]
2142 fn new_empty() -> Self {
2143 Self::default()
2144 }
2145
2146 unsafe fn decode(
2147 &mut self,
2148 decoder: &mut fidl::encoding::Decoder<'_, D>,
2149 offset: usize,
2150 mut depth: fidl::encoding::Depth,
2151 ) -> fidl::Result<()> {
2152 decoder.debug_check_bounds::<Self>(offset);
2153 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2154 None => return Err(fidl::Error::NotNullable),
2155 Some(len) => len,
2156 };
2157 if len == 0 {
2159 return Ok(());
2160 };
2161 depth.increment()?;
2162 let envelope_size = 8;
2163 let bytes_len = len * envelope_size;
2164 let offset = decoder.out_of_line_offset(bytes_len)?;
2165 let mut _next_ordinal_to_read = 0;
2167 let mut next_offset = offset;
2168 let end_offset = offset + bytes_len;
2169 _next_ordinal_to_read += 1;
2170 if next_offset >= end_offset {
2171 return Ok(());
2172 }
2173
2174 while _next_ordinal_to_read < 1 {
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_tx.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 < 2 {
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 <MacCounters 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.mac_rx.get_or_insert_with(|| fidl::new_empty!(MacCounters, D));
2244 fidl::decode!(MacCounters, 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 < 3 {
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_tx.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 < 4 {
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 <CoexCounters 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_rx.get_or_insert_with(|| fidl::new_empty!(CoexCounters, D));
2330 fidl::decode!(CoexCounters, 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 < 5 {
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 <bool 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.coex_saturated.get_or_insert_with(|| fidl::new_empty!(bool, D));
2373 fidl::decode!(bool, 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 < 6 {
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_tx.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 _next_ordinal_to_read += 1;
2428 if next_offset >= end_offset {
2429 return Ok(());
2430 }
2431
2432 while _next_ordinal_to_read < 7 {
2434 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2435 _next_ordinal_to_read += 1;
2436 next_offset += envelope_size;
2437 }
2438
2439 let next_out_of_line = decoder.next_out_of_line();
2440 let handles_before = decoder.remaining_handles();
2441 if let Some((inlined, num_bytes, num_handles)) =
2442 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2443 {
2444 let member_inline_size =
2445 <IpCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2446 if inlined != (member_inline_size <= 4) {
2447 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2448 }
2449 let inner_offset;
2450 let mut inner_depth = depth.clone();
2451 if inlined {
2452 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2453 inner_offset = next_offset;
2454 } else {
2455 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2456 inner_depth.increment()?;
2457 }
2458 let val_ref = self.ip_rx.get_or_insert_with(|| fidl::new_empty!(IpCounters, D));
2459 fidl::decode!(IpCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2460 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2461 {
2462 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2463 }
2464 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2465 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2466 }
2467 }
2468
2469 next_offset += envelope_size;
2470
2471 while next_offset < end_offset {
2473 _next_ordinal_to_read += 1;
2474 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2475 next_offset += envelope_size;
2476 }
2477
2478 Ok(())
2479 }
2480 }
2481
2482 impl CoexCounters {
2483 #[inline(always)]
2484 fn max_ordinal_present(&self) -> u64 {
2485 if let Some(_) = self.grant_none {
2486 return 9;
2487 }
2488 if let Some(_) = self.avg_delay_request_to_grant_usec {
2489 return 8;
2490 }
2491 if let Some(_) = self.delayed_grant {
2492 return 7;
2493 }
2494 if let Some(_) = self.grant_deactivated_during_request {
2495 return 6;
2496 }
2497 if let Some(_) = self.grant_wait_timeout {
2498 return 5;
2499 }
2500 if let Some(_) = self.grant_wait_activated {
2501 return 4;
2502 }
2503 if let Some(_) = self.grant_wait {
2504 return 3;
2505 }
2506 if let Some(_) = self.grant_immediate {
2507 return 2;
2508 }
2509 if let Some(_) = self.requests {
2510 return 1;
2511 }
2512 0
2513 }
2514 }
2515
2516 impl fidl::encoding::ValueTypeMarker for CoexCounters {
2517 type Borrowed<'a> = &'a Self;
2518 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2519 value
2520 }
2521 }
2522
2523 unsafe impl fidl::encoding::TypeMarker for CoexCounters {
2524 type Owned = Self;
2525
2526 #[inline(always)]
2527 fn inline_align(_context: fidl::encoding::Context) -> usize {
2528 8
2529 }
2530
2531 #[inline(always)]
2532 fn inline_size(_context: fidl::encoding::Context) -> usize {
2533 16
2534 }
2535 }
2536
2537 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CoexCounters, D>
2538 for &CoexCounters
2539 {
2540 unsafe fn encode(
2541 self,
2542 encoder: &mut fidl::encoding::Encoder<'_, D>,
2543 offset: usize,
2544 mut depth: fidl::encoding::Depth,
2545 ) -> fidl::Result<()> {
2546 encoder.debug_check_bounds::<CoexCounters>(offset);
2547 let max_ordinal: u64 = self.max_ordinal_present();
2549 encoder.write_num(max_ordinal, offset);
2550 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2551 if max_ordinal == 0 {
2553 return Ok(());
2554 }
2555 depth.increment()?;
2556 let envelope_size = 8;
2557 let bytes_len = max_ordinal as usize * envelope_size;
2558 #[allow(unused_variables)]
2559 let offset = encoder.out_of_line_offset(bytes_len);
2560 let mut _prev_end_offset: usize = 0;
2561 if 1 > max_ordinal {
2562 return Ok(());
2563 }
2564
2565 let cur_offset: usize = (1 - 1) * envelope_size;
2568
2569 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2571
2572 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2577 self.requests.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2578 encoder,
2579 offset + cur_offset,
2580 depth,
2581 )?;
2582
2583 _prev_end_offset = cur_offset + envelope_size;
2584 if 2 > max_ordinal {
2585 return Ok(());
2586 }
2587
2588 let cur_offset: usize = (2 - 1) * envelope_size;
2591
2592 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2594
2595 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2600 self.grant_immediate.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2601 encoder,
2602 offset + cur_offset,
2603 depth,
2604 )?;
2605
2606 _prev_end_offset = cur_offset + envelope_size;
2607 if 3 > max_ordinal {
2608 return Ok(());
2609 }
2610
2611 let cur_offset: usize = (3 - 1) * envelope_size;
2614
2615 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2617
2618 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2623 self.grant_wait.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2624 encoder,
2625 offset + cur_offset,
2626 depth,
2627 )?;
2628
2629 _prev_end_offset = cur_offset + envelope_size;
2630 if 4 > max_ordinal {
2631 return Ok(());
2632 }
2633
2634 let cur_offset: usize = (4 - 1) * envelope_size;
2637
2638 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2640
2641 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2646 self.grant_wait_activated
2647 .as_ref()
2648 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2649 encoder,
2650 offset + cur_offset,
2651 depth,
2652 )?;
2653
2654 _prev_end_offset = cur_offset + envelope_size;
2655 if 5 > max_ordinal {
2656 return Ok(());
2657 }
2658
2659 let cur_offset: usize = (5 - 1) * envelope_size;
2662
2663 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2665
2666 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2671 self.grant_wait_timeout
2672 .as_ref()
2673 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2674 encoder,
2675 offset + cur_offset,
2676 depth,
2677 )?;
2678
2679 _prev_end_offset = cur_offset + envelope_size;
2680 if 6 > max_ordinal {
2681 return Ok(());
2682 }
2683
2684 let cur_offset: usize = (6 - 1) * envelope_size;
2687
2688 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2690
2691 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2696 self.grant_deactivated_during_request
2697 .as_ref()
2698 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2699 encoder,
2700 offset + cur_offset,
2701 depth,
2702 )?;
2703
2704 _prev_end_offset = cur_offset + envelope_size;
2705 if 7 > max_ordinal {
2706 return Ok(());
2707 }
2708
2709 let cur_offset: usize = (7 - 1) * envelope_size;
2712
2713 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2715
2716 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2721 self.delayed_grant.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2722 encoder,
2723 offset + cur_offset,
2724 depth,
2725 )?;
2726
2727 _prev_end_offset = cur_offset + envelope_size;
2728 if 8 > max_ordinal {
2729 return Ok(());
2730 }
2731
2732 let cur_offset: usize = (8 - 1) * envelope_size;
2735
2736 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2738
2739 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2744 self.avg_delay_request_to_grant_usec
2745 .as_ref()
2746 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2747 encoder,
2748 offset + cur_offset,
2749 depth,
2750 )?;
2751
2752 _prev_end_offset = cur_offset + envelope_size;
2753 if 9 > max_ordinal {
2754 return Ok(());
2755 }
2756
2757 let cur_offset: usize = (9 - 1) * envelope_size;
2760
2761 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2763
2764 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2769 self.grant_none.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2770 encoder,
2771 offset + cur_offset,
2772 depth,
2773 )?;
2774
2775 _prev_end_offset = cur_offset + envelope_size;
2776
2777 Ok(())
2778 }
2779 }
2780
2781 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CoexCounters {
2782 #[inline(always)]
2783 fn new_empty() -> Self {
2784 Self::default()
2785 }
2786
2787 unsafe fn decode(
2788 &mut self,
2789 decoder: &mut fidl::encoding::Decoder<'_, D>,
2790 offset: usize,
2791 mut depth: fidl::encoding::Depth,
2792 ) -> fidl::Result<()> {
2793 decoder.debug_check_bounds::<Self>(offset);
2794 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2795 None => return Err(fidl::Error::NotNullable),
2796 Some(len) => len,
2797 };
2798 if len == 0 {
2800 return Ok(());
2801 };
2802 depth.increment()?;
2803 let envelope_size = 8;
2804 let bytes_len = len * envelope_size;
2805 let offset = decoder.out_of_line_offset(bytes_len)?;
2806 let mut _next_ordinal_to_read = 0;
2808 let mut next_offset = offset;
2809 let end_offset = offset + bytes_len;
2810 _next_ordinal_to_read += 1;
2811 if next_offset >= end_offset {
2812 return Ok(());
2813 }
2814
2815 while _next_ordinal_to_read < 1 {
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.requests.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 < 2 {
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_immediate.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 < 3 {
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 = self.grant_wait.get_or_insert_with(|| fidl::new_empty!(u64, D));
2928 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2929 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2930 {
2931 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2932 }
2933 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2934 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2935 }
2936 }
2937
2938 next_offset += envelope_size;
2939 _next_ordinal_to_read += 1;
2940 if next_offset >= end_offset {
2941 return Ok(());
2942 }
2943
2944 while _next_ordinal_to_read < 4 {
2946 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2947 _next_ordinal_to_read += 1;
2948 next_offset += envelope_size;
2949 }
2950
2951 let next_out_of_line = decoder.next_out_of_line();
2952 let handles_before = decoder.remaining_handles();
2953 if let Some((inlined, num_bytes, num_handles)) =
2954 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2955 {
2956 let member_inline_size =
2957 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2958 if inlined != (member_inline_size <= 4) {
2959 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2960 }
2961 let inner_offset;
2962 let mut inner_depth = depth.clone();
2963 if inlined {
2964 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2965 inner_offset = next_offset;
2966 } else {
2967 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2968 inner_depth.increment()?;
2969 }
2970 let val_ref =
2971 self.grant_wait_activated.get_or_insert_with(|| fidl::new_empty!(u64, D));
2972 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2973 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2974 {
2975 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2976 }
2977 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2978 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2979 }
2980 }
2981
2982 next_offset += envelope_size;
2983 _next_ordinal_to_read += 1;
2984 if next_offset >= end_offset {
2985 return Ok(());
2986 }
2987
2988 while _next_ordinal_to_read < 5 {
2990 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2991 _next_ordinal_to_read += 1;
2992 next_offset += envelope_size;
2993 }
2994
2995 let next_out_of_line = decoder.next_out_of_line();
2996 let handles_before = decoder.remaining_handles();
2997 if let Some((inlined, num_bytes, num_handles)) =
2998 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2999 {
3000 let member_inline_size =
3001 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3002 if inlined != (member_inline_size <= 4) {
3003 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3004 }
3005 let inner_offset;
3006 let mut inner_depth = depth.clone();
3007 if inlined {
3008 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3009 inner_offset = next_offset;
3010 } else {
3011 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3012 inner_depth.increment()?;
3013 }
3014 let val_ref =
3015 self.grant_wait_timeout.get_or_insert_with(|| fidl::new_empty!(u64, D));
3016 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3017 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3018 {
3019 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3020 }
3021 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3022 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3023 }
3024 }
3025
3026 next_offset += envelope_size;
3027 _next_ordinal_to_read += 1;
3028 if next_offset >= end_offset {
3029 return Ok(());
3030 }
3031
3032 while _next_ordinal_to_read < 6 {
3034 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3035 _next_ordinal_to_read += 1;
3036 next_offset += envelope_size;
3037 }
3038
3039 let next_out_of_line = decoder.next_out_of_line();
3040 let handles_before = decoder.remaining_handles();
3041 if let Some((inlined, num_bytes, num_handles)) =
3042 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3043 {
3044 let member_inline_size =
3045 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3046 if inlined != (member_inline_size <= 4) {
3047 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3048 }
3049 let inner_offset;
3050 let mut inner_depth = depth.clone();
3051 if inlined {
3052 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3053 inner_offset = next_offset;
3054 } else {
3055 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3056 inner_depth.increment()?;
3057 }
3058 let val_ref = self
3059 .grant_deactivated_during_request
3060 .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 < 7 {
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 <u64 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.delayed_grant.get_or_insert_with(|| fidl::new_empty!(u64, D));
3104 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3105 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3106 {
3107 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3108 }
3109 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3110 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3111 }
3112 }
3113
3114 next_offset += envelope_size;
3115 _next_ordinal_to_read += 1;
3116 if next_offset >= end_offset {
3117 return Ok(());
3118 }
3119
3120 while _next_ordinal_to_read < 8 {
3122 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3123 _next_ordinal_to_read += 1;
3124 next_offset += envelope_size;
3125 }
3126
3127 let next_out_of_line = decoder.next_out_of_line();
3128 let handles_before = decoder.remaining_handles();
3129 if let Some((inlined, num_bytes, num_handles)) =
3130 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3131 {
3132 let member_inline_size =
3133 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3134 if inlined != (member_inline_size <= 4) {
3135 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3136 }
3137 let inner_offset;
3138 let mut inner_depth = depth.clone();
3139 if inlined {
3140 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3141 inner_offset = next_offset;
3142 } else {
3143 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3144 inner_depth.increment()?;
3145 }
3146 let val_ref = self
3147 .avg_delay_request_to_grant_usec
3148 .get_or_insert_with(|| fidl::new_empty!(u32, D));
3149 fidl::decode!(u32, 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 _next_ordinal_to_read += 1;
3161 if next_offset >= end_offset {
3162 return Ok(());
3163 }
3164
3165 while _next_ordinal_to_read < 9 {
3167 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3168 _next_ordinal_to_read += 1;
3169 next_offset += envelope_size;
3170 }
3171
3172 let next_out_of_line = decoder.next_out_of_line();
3173 let handles_before = decoder.remaining_handles();
3174 if let Some((inlined, num_bytes, num_handles)) =
3175 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3176 {
3177 let member_inline_size =
3178 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3179 if inlined != (member_inline_size <= 4) {
3180 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3181 }
3182 let inner_offset;
3183 let mut inner_depth = depth.clone();
3184 if inlined {
3185 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3186 inner_offset = next_offset;
3187 } else {
3188 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3189 inner_depth.increment()?;
3190 }
3191 let val_ref = self.grant_none.get_or_insert_with(|| fidl::new_empty!(u64, D));
3192 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3193 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3194 {
3195 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3196 }
3197 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3198 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3199 }
3200 }
3201
3202 next_offset += envelope_size;
3203
3204 while next_offset < end_offset {
3206 _next_ordinal_to_read += 1;
3207 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3208 next_offset += envelope_size;
3209 }
3210
3211 Ok(())
3212 }
3213 }
3214
3215 impl DeviceState {
3216 #[inline(always)]
3217 fn max_ordinal_present(&self) -> u64 {
3218 if let Some(_) = self.role {
3219 return 2;
3220 }
3221 if let Some(_) = self.connectivity_state {
3222 return 1;
3223 }
3224 0
3225 }
3226 }
3227
3228 impl fidl::encoding::ValueTypeMarker for DeviceState {
3229 type Borrowed<'a> = &'a Self;
3230 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3231 value
3232 }
3233 }
3234
3235 unsafe impl fidl::encoding::TypeMarker for DeviceState {
3236 type Owned = Self;
3237
3238 #[inline(always)]
3239 fn inline_align(_context: fidl::encoding::Context) -> usize {
3240 8
3241 }
3242
3243 #[inline(always)]
3244 fn inline_size(_context: fidl::encoding::Context) -> usize {
3245 16
3246 }
3247 }
3248
3249 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceState, D>
3250 for &DeviceState
3251 {
3252 unsafe fn encode(
3253 self,
3254 encoder: &mut fidl::encoding::Encoder<'_, D>,
3255 offset: usize,
3256 mut depth: fidl::encoding::Depth,
3257 ) -> fidl::Result<()> {
3258 encoder.debug_check_bounds::<DeviceState>(offset);
3259 let max_ordinal: u64 = self.max_ordinal_present();
3261 encoder.write_num(max_ordinal, offset);
3262 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3263 if max_ordinal == 0 {
3265 return Ok(());
3266 }
3267 depth.increment()?;
3268 let envelope_size = 8;
3269 let bytes_len = max_ordinal as usize * envelope_size;
3270 #[allow(unused_variables)]
3271 let offset = encoder.out_of_line_offset(bytes_len);
3272 let mut _prev_end_offset: usize = 0;
3273 if 1 > max_ordinal {
3274 return Ok(());
3275 }
3276
3277 let cur_offset: usize = (1 - 1) * envelope_size;
3280
3281 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3283
3284 fidl::encoding::encode_in_envelope_optional::<ConnectivityState, D>(
3289 self.connectivity_state
3290 .as_ref()
3291 .map(<ConnectivityState as fidl::encoding::ValueTypeMarker>::borrow),
3292 encoder,
3293 offset + cur_offset,
3294 depth,
3295 )?;
3296
3297 _prev_end_offset = cur_offset + envelope_size;
3298 if 2 > max_ordinal {
3299 return Ok(());
3300 }
3301
3302 let cur_offset: usize = (2 - 1) * envelope_size;
3305
3306 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3308
3309 fidl::encoding::encode_in_envelope_optional::<Role, D>(
3314 self.role.as_ref().map(<Role as fidl::encoding::ValueTypeMarker>::borrow),
3315 encoder,
3316 offset + cur_offset,
3317 depth,
3318 )?;
3319
3320 _prev_end_offset = cur_offset + envelope_size;
3321
3322 Ok(())
3323 }
3324 }
3325
3326 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceState {
3327 #[inline(always)]
3328 fn new_empty() -> Self {
3329 Self::default()
3330 }
3331
3332 unsafe fn decode(
3333 &mut self,
3334 decoder: &mut fidl::encoding::Decoder<'_, D>,
3335 offset: usize,
3336 mut depth: fidl::encoding::Depth,
3337 ) -> fidl::Result<()> {
3338 decoder.debug_check_bounds::<Self>(offset);
3339 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3340 None => return Err(fidl::Error::NotNullable),
3341 Some(len) => len,
3342 };
3343 if len == 0 {
3345 return Ok(());
3346 };
3347 depth.increment()?;
3348 let envelope_size = 8;
3349 let bytes_len = len * envelope_size;
3350 let offset = decoder.out_of_line_offset(bytes_len)?;
3351 let mut _next_ordinal_to_read = 0;
3353 let mut next_offset = offset;
3354 let end_offset = offset + bytes_len;
3355 _next_ordinal_to_read += 1;
3356 if next_offset >= end_offset {
3357 return Ok(());
3358 }
3359
3360 while _next_ordinal_to_read < 1 {
3362 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3363 _next_ordinal_to_read += 1;
3364 next_offset += envelope_size;
3365 }
3366
3367 let next_out_of_line = decoder.next_out_of_line();
3368 let handles_before = decoder.remaining_handles();
3369 if let Some((inlined, num_bytes, num_handles)) =
3370 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3371 {
3372 let member_inline_size =
3373 <ConnectivityState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3374 if inlined != (member_inline_size <= 4) {
3375 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3376 }
3377 let inner_offset;
3378 let mut inner_depth = depth.clone();
3379 if inlined {
3380 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3381 inner_offset = next_offset;
3382 } else {
3383 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3384 inner_depth.increment()?;
3385 }
3386 let val_ref = self
3387 .connectivity_state
3388 .get_or_insert_with(|| fidl::new_empty!(ConnectivityState, D));
3389 fidl::decode!(ConnectivityState, 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 _next_ordinal_to_read += 1;
3401 if next_offset >= end_offset {
3402 return Ok(());
3403 }
3404
3405 while _next_ordinal_to_read < 2 {
3407 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3408 _next_ordinal_to_read += 1;
3409 next_offset += envelope_size;
3410 }
3411
3412 let next_out_of_line = decoder.next_out_of_line();
3413 let handles_before = decoder.remaining_handles();
3414 if let Some((inlined, num_bytes, num_handles)) =
3415 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3416 {
3417 let member_inline_size =
3418 <Role as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3419 if inlined != (member_inline_size <= 4) {
3420 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3421 }
3422 let inner_offset;
3423 let mut inner_depth = depth.clone();
3424 if inlined {
3425 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3426 inner_offset = next_offset;
3427 } else {
3428 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3429 inner_depth.increment()?;
3430 }
3431 let val_ref = self.role.get_or_insert_with(|| fidl::new_empty!(Role, D));
3432 fidl::decode!(Role, D, val_ref, decoder, inner_offset, inner_depth)?;
3433 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3434 {
3435 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3436 }
3437 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3438 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3439 }
3440 }
3441
3442 next_offset += envelope_size;
3443
3444 while next_offset < end_offset {
3446 _next_ordinal_to_read += 1;
3447 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3448 next_offset += envelope_size;
3449 }
3450
3451 Ok(())
3452 }
3453 }
3454
3455 impl EnergyScanParameters {
3456 #[inline(always)]
3457 fn max_ordinal_present(&self) -> u64 {
3458 if let Some(_) = self.dwell_time_ms {
3459 return 2;
3460 }
3461 if let Some(_) = self.channels {
3462 return 1;
3463 }
3464 0
3465 }
3466 }
3467
3468 impl fidl::encoding::ValueTypeMarker for EnergyScanParameters {
3469 type Borrowed<'a> = &'a Self;
3470 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3471 value
3472 }
3473 }
3474
3475 unsafe impl fidl::encoding::TypeMarker for EnergyScanParameters {
3476 type Owned = Self;
3477
3478 #[inline(always)]
3479 fn inline_align(_context: fidl::encoding::Context) -> usize {
3480 8
3481 }
3482
3483 #[inline(always)]
3484 fn inline_size(_context: fidl::encoding::Context) -> usize {
3485 16
3486 }
3487 }
3488
3489 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnergyScanParameters, D>
3490 for &EnergyScanParameters
3491 {
3492 unsafe fn encode(
3493 self,
3494 encoder: &mut fidl::encoding::Encoder<'_, D>,
3495 offset: usize,
3496 mut depth: fidl::encoding::Depth,
3497 ) -> fidl::Result<()> {
3498 encoder.debug_check_bounds::<EnergyScanParameters>(offset);
3499 let max_ordinal: u64 = self.max_ordinal_present();
3501 encoder.write_num(max_ordinal, offset);
3502 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3503 if max_ordinal == 0 {
3505 return Ok(());
3506 }
3507 depth.increment()?;
3508 let envelope_size = 8;
3509 let bytes_len = max_ordinal as usize * envelope_size;
3510 #[allow(unused_variables)]
3511 let offset = encoder.out_of_line_offset(bytes_len);
3512 let mut _prev_end_offset: usize = 0;
3513 if 1 > max_ordinal {
3514 return Ok(());
3515 }
3516
3517 let cur_offset: usize = (1 - 1) * envelope_size;
3520
3521 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3523
3524 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u16, 200>, D>(
3529 self.channels.as_ref().map(
3530 <fidl::encoding::Vector<u16, 200> as fidl::encoding::ValueTypeMarker>::borrow,
3531 ),
3532 encoder,
3533 offset + cur_offset,
3534 depth,
3535 )?;
3536
3537 _prev_end_offset = cur_offset + envelope_size;
3538 if 2 > max_ordinal {
3539 return Ok(());
3540 }
3541
3542 let cur_offset: usize = (2 - 1) * envelope_size;
3545
3546 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3548
3549 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3554 self.dwell_time_ms.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3555 encoder,
3556 offset + cur_offset,
3557 depth,
3558 )?;
3559
3560 _prev_end_offset = cur_offset + envelope_size;
3561
3562 Ok(())
3563 }
3564 }
3565
3566 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnergyScanParameters {
3567 #[inline(always)]
3568 fn new_empty() -> Self {
3569 Self::default()
3570 }
3571
3572 unsafe fn decode(
3573 &mut self,
3574 decoder: &mut fidl::encoding::Decoder<'_, D>,
3575 offset: usize,
3576 mut depth: fidl::encoding::Depth,
3577 ) -> fidl::Result<()> {
3578 decoder.debug_check_bounds::<Self>(offset);
3579 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3580 None => return Err(fidl::Error::NotNullable),
3581 Some(len) => len,
3582 };
3583 if len == 0 {
3585 return Ok(());
3586 };
3587 depth.increment()?;
3588 let envelope_size = 8;
3589 let bytes_len = len * envelope_size;
3590 let offset = decoder.out_of_line_offset(bytes_len)?;
3591 let mut _next_ordinal_to_read = 0;
3593 let mut next_offset = offset;
3594 let end_offset = offset + bytes_len;
3595 _next_ordinal_to_read += 1;
3596 if next_offset >= end_offset {
3597 return Ok(());
3598 }
3599
3600 while _next_ordinal_to_read < 1 {
3602 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3603 _next_ordinal_to_read += 1;
3604 next_offset += envelope_size;
3605 }
3606
3607 let next_out_of_line = decoder.next_out_of_line();
3608 let handles_before = decoder.remaining_handles();
3609 if let Some((inlined, num_bytes, num_handles)) =
3610 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3611 {
3612 let member_inline_size =
3613 <fidl::encoding::Vector<u16, 200> as fidl::encoding::TypeMarker>::inline_size(
3614 decoder.context,
3615 );
3616 if inlined != (member_inline_size <= 4) {
3617 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3618 }
3619 let inner_offset;
3620 let mut inner_depth = depth.clone();
3621 if inlined {
3622 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3623 inner_offset = next_offset;
3624 } else {
3625 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3626 inner_depth.increment()?;
3627 }
3628 let val_ref = self
3629 .channels
3630 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u16, 200>, D));
3631 fidl::decode!(fidl::encoding::Vector<u16, 200>, 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 _next_ordinal_to_read += 1;
3643 if next_offset >= end_offset {
3644 return Ok(());
3645 }
3646
3647 while _next_ordinal_to_read < 2 {
3649 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3650 _next_ordinal_to_read += 1;
3651 next_offset += envelope_size;
3652 }
3653
3654 let next_out_of_line = decoder.next_out_of_line();
3655 let handles_before = decoder.remaining_handles();
3656 if let Some((inlined, num_bytes, num_handles)) =
3657 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3658 {
3659 let member_inline_size =
3660 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3661 if inlined != (member_inline_size <= 4) {
3662 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3663 }
3664 let inner_offset;
3665 let mut inner_depth = depth.clone();
3666 if inlined {
3667 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3668 inner_offset = next_offset;
3669 } else {
3670 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3671 inner_depth.increment()?;
3672 }
3673 let val_ref = self.dwell_time_ms.get_or_insert_with(|| fidl::new_empty!(u32, D));
3674 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3675 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3676 {
3677 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3678 }
3679 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3680 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3681 }
3682 }
3683
3684 next_offset += envelope_size;
3685
3686 while next_offset < end_offset {
3688 _next_ordinal_to_read += 1;
3689 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3690 next_offset += envelope_size;
3691 }
3692
3693 Ok(())
3694 }
3695 }
3696
3697 impl EnergyScanResult {
3698 #[inline(always)]
3699 fn max_ordinal_present(&self) -> u64 {
3700 if let Some(_) = self.min_rssi {
3701 return 3;
3702 }
3703 if let Some(_) = self.max_rssi {
3704 return 2;
3705 }
3706 if let Some(_) = self.channel_index {
3707 return 1;
3708 }
3709 0
3710 }
3711 }
3712
3713 impl fidl::encoding::ValueTypeMarker for EnergyScanResult {
3714 type Borrowed<'a> = &'a Self;
3715 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3716 value
3717 }
3718 }
3719
3720 unsafe impl fidl::encoding::TypeMarker for EnergyScanResult {
3721 type Owned = Self;
3722
3723 #[inline(always)]
3724 fn inline_align(_context: fidl::encoding::Context) -> usize {
3725 8
3726 }
3727
3728 #[inline(always)]
3729 fn inline_size(_context: fidl::encoding::Context) -> usize {
3730 16
3731 }
3732 }
3733
3734 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnergyScanResult, D>
3735 for &EnergyScanResult
3736 {
3737 unsafe fn encode(
3738 self,
3739 encoder: &mut fidl::encoding::Encoder<'_, D>,
3740 offset: usize,
3741 mut depth: fidl::encoding::Depth,
3742 ) -> fidl::Result<()> {
3743 encoder.debug_check_bounds::<EnergyScanResult>(offset);
3744 let max_ordinal: u64 = self.max_ordinal_present();
3746 encoder.write_num(max_ordinal, offset);
3747 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3748 if max_ordinal == 0 {
3750 return Ok(());
3751 }
3752 depth.increment()?;
3753 let envelope_size = 8;
3754 let bytes_len = max_ordinal as usize * envelope_size;
3755 #[allow(unused_variables)]
3756 let offset = encoder.out_of_line_offset(bytes_len);
3757 let mut _prev_end_offset: usize = 0;
3758 if 1 > max_ordinal {
3759 return Ok(());
3760 }
3761
3762 let cur_offset: usize = (1 - 1) * envelope_size;
3765
3766 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3768
3769 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3774 self.channel_index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3775 encoder,
3776 offset + cur_offset,
3777 depth,
3778 )?;
3779
3780 _prev_end_offset = cur_offset + envelope_size;
3781 if 2 > max_ordinal {
3782 return Ok(());
3783 }
3784
3785 let cur_offset: usize = (2 - 1) * envelope_size;
3788
3789 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3791
3792 fidl::encoding::encode_in_envelope_optional::<i32, D>(
3797 self.max_rssi.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
3798 encoder,
3799 offset + cur_offset,
3800 depth,
3801 )?;
3802
3803 _prev_end_offset = cur_offset + envelope_size;
3804 if 3 > max_ordinal {
3805 return Ok(());
3806 }
3807
3808 let cur_offset: usize = (3 - 1) * envelope_size;
3811
3812 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3814
3815 fidl::encoding::encode_in_envelope_optional::<i32, D>(
3820 self.min_rssi.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
3821 encoder,
3822 offset + cur_offset,
3823 depth,
3824 )?;
3825
3826 _prev_end_offset = cur_offset + envelope_size;
3827
3828 Ok(())
3829 }
3830 }
3831
3832 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnergyScanResult {
3833 #[inline(always)]
3834 fn new_empty() -> Self {
3835 Self::default()
3836 }
3837
3838 unsafe fn decode(
3839 &mut self,
3840 decoder: &mut fidl::encoding::Decoder<'_, D>,
3841 offset: usize,
3842 mut depth: fidl::encoding::Depth,
3843 ) -> fidl::Result<()> {
3844 decoder.debug_check_bounds::<Self>(offset);
3845 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3846 None => return Err(fidl::Error::NotNullable),
3847 Some(len) => len,
3848 };
3849 if len == 0 {
3851 return Ok(());
3852 };
3853 depth.increment()?;
3854 let envelope_size = 8;
3855 let bytes_len = len * envelope_size;
3856 let offset = decoder.out_of_line_offset(bytes_len)?;
3857 let mut _next_ordinal_to_read = 0;
3859 let mut next_offset = offset;
3860 let end_offset = offset + bytes_len;
3861 _next_ordinal_to_read += 1;
3862 if next_offset >= end_offset {
3863 return Ok(());
3864 }
3865
3866 while _next_ordinal_to_read < 1 {
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 <u16 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.channel_index.get_or_insert_with(|| fidl::new_empty!(u16, D));
3893 fidl::decode!(u16, 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 < 2 {
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.max_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 _next_ordinal_to_read += 1;
3948 if next_offset >= end_offset {
3949 return Ok(());
3950 }
3951
3952 while _next_ordinal_to_read < 3 {
3954 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3955 _next_ordinal_to_read += 1;
3956 next_offset += envelope_size;
3957 }
3958
3959 let next_out_of_line = decoder.next_out_of_line();
3960 let handles_before = decoder.remaining_handles();
3961 if let Some((inlined, num_bytes, num_handles)) =
3962 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3963 {
3964 let member_inline_size =
3965 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3966 if inlined != (member_inline_size <= 4) {
3967 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3968 }
3969 let inner_offset;
3970 let mut inner_depth = depth.clone();
3971 if inlined {
3972 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3973 inner_offset = next_offset;
3974 } else {
3975 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3976 inner_depth.increment()?;
3977 }
3978 let val_ref = self.min_rssi.get_or_insert_with(|| fidl::new_empty!(i32, D));
3979 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3980 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3981 {
3982 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3983 }
3984 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3985 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3986 }
3987 }
3988
3989 next_offset += envelope_size;
3990
3991 while next_offset < end_offset {
3993 _next_ordinal_to_read += 1;
3994 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3995 next_offset += envelope_size;
3996 }
3997
3998 Ok(())
3999 }
4000 }
4001
4002 impl Identity {
4003 #[inline(always)]
4004 fn max_ordinal_present(&self) -> u64 {
4005 if let Some(_) = self.xpanid {
4006 return 7;
4007 }
4008 if let Some(_) = self.mesh_local_prefix {
4009 return 6;
4010 }
4011 if let Some(_) = self.panid {
4012 return 5;
4013 }
4014 if let Some(_) = self.channel {
4015 return 4;
4016 }
4017 if let Some(_) = self.net_type {
4018 return 3;
4019 }
4020 if let Some(_) = self.raw_name {
4021 return 1;
4022 }
4023 0
4024 }
4025 }
4026
4027 impl fidl::encoding::ValueTypeMarker for Identity {
4028 type Borrowed<'a> = &'a Self;
4029 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4030 value
4031 }
4032 }
4033
4034 unsafe impl fidl::encoding::TypeMarker for Identity {
4035 type Owned = Self;
4036
4037 #[inline(always)]
4038 fn inline_align(_context: fidl::encoding::Context) -> usize {
4039 8
4040 }
4041
4042 #[inline(always)]
4043 fn inline_size(_context: fidl::encoding::Context) -> usize {
4044 16
4045 }
4046 }
4047
4048 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Identity, D> for &Identity {
4049 unsafe fn encode(
4050 self,
4051 encoder: &mut fidl::encoding::Encoder<'_, D>,
4052 offset: usize,
4053 mut depth: fidl::encoding::Depth,
4054 ) -> fidl::Result<()> {
4055 encoder.debug_check_bounds::<Identity>(offset);
4056 let max_ordinal: u64 = self.max_ordinal_present();
4058 encoder.write_num(max_ordinal, offset);
4059 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4060 if max_ordinal == 0 {
4062 return Ok(());
4063 }
4064 depth.increment()?;
4065 let envelope_size = 8;
4066 let bytes_len = max_ordinal as usize * envelope_size;
4067 #[allow(unused_variables)]
4068 let offset = encoder.out_of_line_offset(bytes_len);
4069 let mut _prev_end_offset: usize = 0;
4070 if 1 > max_ordinal {
4071 return Ok(());
4072 }
4073
4074 let cur_offset: usize = (1 - 1) * envelope_size;
4077
4078 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4080
4081 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 63>, D>(
4086 self.raw_name.as_ref().map(
4087 <fidl::encoding::Vector<u8, 63> as fidl::encoding::ValueTypeMarker>::borrow,
4088 ),
4089 encoder,
4090 offset + cur_offset,
4091 depth,
4092 )?;
4093
4094 _prev_end_offset = cur_offset + envelope_size;
4095 if 3 > max_ordinal {
4096 return Ok(());
4097 }
4098
4099 let cur_offset: usize = (3 - 1) * envelope_size;
4102
4103 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4105
4106 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
4111 self.net_type.as_ref().map(
4112 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
4113 ),
4114 encoder,
4115 offset + cur_offset,
4116 depth,
4117 )?;
4118
4119 _prev_end_offset = cur_offset + envelope_size;
4120 if 4 > max_ordinal {
4121 return Ok(());
4122 }
4123
4124 let cur_offset: usize = (4 - 1) * envelope_size;
4127
4128 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4130
4131 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4136 self.channel.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4137 encoder,
4138 offset + cur_offset,
4139 depth,
4140 )?;
4141
4142 _prev_end_offset = cur_offset + envelope_size;
4143 if 5 > max_ordinal {
4144 return Ok(());
4145 }
4146
4147 let cur_offset: usize = (5 - 1) * envelope_size;
4150
4151 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4153
4154 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4159 self.panid.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4160 encoder,
4161 offset + cur_offset,
4162 depth,
4163 )?;
4164
4165 _prev_end_offset = cur_offset + envelope_size;
4166 if 6 > max_ordinal {
4167 return Ok(());
4168 }
4169
4170 let cur_offset: usize = (6 - 1) * envelope_size;
4173
4174 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4176
4177 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
4182 self.mesh_local_prefix.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
4183 encoder, offset + cur_offset, depth
4184 )?;
4185
4186 _prev_end_offset = cur_offset + envelope_size;
4187 if 7 > max_ordinal {
4188 return Ok(());
4189 }
4190
4191 let cur_offset: usize = (7 - 1) * envelope_size;
4194
4195 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4197
4198 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 8>, D>(
4203 self.xpanid
4204 .as_ref()
4205 .map(<fidl::encoding::Array<u8, 8> as fidl::encoding::ValueTypeMarker>::borrow),
4206 encoder,
4207 offset + cur_offset,
4208 depth,
4209 )?;
4210
4211 _prev_end_offset = cur_offset + envelope_size;
4212
4213 Ok(())
4214 }
4215 }
4216
4217 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Identity {
4218 #[inline(always)]
4219 fn new_empty() -> Self {
4220 Self::default()
4221 }
4222
4223 unsafe fn decode(
4224 &mut self,
4225 decoder: &mut fidl::encoding::Decoder<'_, D>,
4226 offset: usize,
4227 mut depth: fidl::encoding::Depth,
4228 ) -> fidl::Result<()> {
4229 decoder.debug_check_bounds::<Self>(offset);
4230 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4231 None => return Err(fidl::Error::NotNullable),
4232 Some(len) => len,
4233 };
4234 if len == 0 {
4236 return Ok(());
4237 };
4238 depth.increment()?;
4239 let envelope_size = 8;
4240 let bytes_len = len * envelope_size;
4241 let offset = decoder.out_of_line_offset(bytes_len)?;
4242 let mut _next_ordinal_to_read = 0;
4244 let mut next_offset = offset;
4245 let end_offset = offset + bytes_len;
4246 _next_ordinal_to_read += 1;
4247 if next_offset >= end_offset {
4248 return Ok(());
4249 }
4250
4251 while _next_ordinal_to_read < 1 {
4253 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4254 _next_ordinal_to_read += 1;
4255 next_offset += envelope_size;
4256 }
4257
4258 let next_out_of_line = decoder.next_out_of_line();
4259 let handles_before = decoder.remaining_handles();
4260 if let Some((inlined, num_bytes, num_handles)) =
4261 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4262 {
4263 let member_inline_size =
4264 <fidl::encoding::Vector<u8, 63> as fidl::encoding::TypeMarker>::inline_size(
4265 decoder.context,
4266 );
4267 if inlined != (member_inline_size <= 4) {
4268 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4269 }
4270 let inner_offset;
4271 let mut inner_depth = depth.clone();
4272 if inlined {
4273 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4274 inner_offset = next_offset;
4275 } else {
4276 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4277 inner_depth.increment()?;
4278 }
4279 let val_ref = self
4280 .raw_name
4281 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 63>, D));
4282 fidl::decode!(fidl::encoding::Vector<u8, 63>, D, val_ref, decoder, inner_offset, inner_depth)?;
4283 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4284 {
4285 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4286 }
4287 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4288 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4289 }
4290 }
4291
4292 next_offset += envelope_size;
4293 _next_ordinal_to_read += 1;
4294 if next_offset >= end_offset {
4295 return Ok(());
4296 }
4297
4298 while _next_ordinal_to_read < 3 {
4300 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4301 _next_ordinal_to_read += 1;
4302 next_offset += envelope_size;
4303 }
4304
4305 let next_out_of_line = decoder.next_out_of_line();
4306 let handles_before = decoder.remaining_handles();
4307 if let Some((inlined, num_bytes, num_handles)) =
4308 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4309 {
4310 let member_inline_size =
4311 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
4312 decoder.context,
4313 );
4314 if inlined != (member_inline_size <= 4) {
4315 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4316 }
4317 let inner_offset;
4318 let mut inner_depth = depth.clone();
4319 if inlined {
4320 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4321 inner_offset = next_offset;
4322 } else {
4323 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4324 inner_depth.increment()?;
4325 }
4326 let val_ref = self
4327 .net_type
4328 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
4329 fidl::decode!(
4330 fidl::encoding::BoundedString<64>,
4331 D,
4332 val_ref,
4333 decoder,
4334 inner_offset,
4335 inner_depth
4336 )?;
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 < 4 {
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.channel.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 < 5 {
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 =
4408 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4409 if inlined != (member_inline_size <= 4) {
4410 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4411 }
4412 let inner_offset;
4413 let mut inner_depth = depth.clone();
4414 if inlined {
4415 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4416 inner_offset = next_offset;
4417 } else {
4418 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4419 inner_depth.increment()?;
4420 }
4421 let val_ref = self.panid.get_or_insert_with(|| fidl::new_empty!(u16, D));
4422 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4423 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4424 {
4425 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4426 }
4427 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4428 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4429 }
4430 }
4431
4432 next_offset += envelope_size;
4433 _next_ordinal_to_read += 1;
4434 if next_offset >= end_offset {
4435 return Ok(());
4436 }
4437
4438 while _next_ordinal_to_read < 6 {
4440 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4441 _next_ordinal_to_read += 1;
4442 next_offset += envelope_size;
4443 }
4444
4445 let next_out_of_line = decoder.next_out_of_line();
4446 let handles_before = decoder.remaining_handles();
4447 if let Some((inlined, num_bytes, num_handles)) =
4448 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4449 {
4450 let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4451 if inlined != (member_inline_size <= 4) {
4452 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4453 }
4454 let inner_offset;
4455 let mut inner_depth = depth.clone();
4456 if inlined {
4457 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4458 inner_offset = next_offset;
4459 } else {
4460 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4461 inner_depth.increment()?;
4462 }
4463 let val_ref = self.mesh_local_prefix.get_or_insert_with(|| {
4464 fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
4465 });
4466 fidl::decode!(
4467 fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
4468 D,
4469 val_ref,
4470 decoder,
4471 inner_offset,
4472 inner_depth
4473 )?;
4474 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4475 {
4476 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4477 }
4478 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4479 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4480 }
4481 }
4482
4483 next_offset += envelope_size;
4484 _next_ordinal_to_read += 1;
4485 if next_offset >= end_offset {
4486 return Ok(());
4487 }
4488
4489 while _next_ordinal_to_read < 7 {
4491 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4492 _next_ordinal_to_read += 1;
4493 next_offset += envelope_size;
4494 }
4495
4496 let next_out_of_line = decoder.next_out_of_line();
4497 let handles_before = decoder.remaining_handles();
4498 if let Some((inlined, num_bytes, num_handles)) =
4499 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4500 {
4501 let member_inline_size =
4502 <fidl::encoding::Array<u8, 8> as fidl::encoding::TypeMarker>::inline_size(
4503 decoder.context,
4504 );
4505 if inlined != (member_inline_size <= 4) {
4506 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4507 }
4508 let inner_offset;
4509 let mut inner_depth = depth.clone();
4510 if inlined {
4511 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4512 inner_offset = next_offset;
4513 } else {
4514 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4515 inner_depth.increment()?;
4516 }
4517 let val_ref = self
4518 .xpanid
4519 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 8>, D));
4520 fidl::decode!(fidl::encoding::Array<u8, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
4521 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4522 {
4523 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4524 }
4525 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4526 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4527 }
4528 }
4529
4530 next_offset += envelope_size;
4531
4532 while next_offset < end_offset {
4534 _next_ordinal_to_read += 1;
4535 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4536 next_offset += envelope_size;
4537 }
4538
4539 Ok(())
4540 }
4541 }
4542
4543 impl IpCounters {
4544 #[inline(always)]
4545 fn max_ordinal_present(&self) -> u64 {
4546 if let Some(_) = self.failure {
4547 return 2;
4548 }
4549 if let Some(_) = self.success {
4550 return 1;
4551 }
4552 0
4553 }
4554 }
4555
4556 impl fidl::encoding::ValueTypeMarker for IpCounters {
4557 type Borrowed<'a> = &'a Self;
4558 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4559 value
4560 }
4561 }
4562
4563 unsafe impl fidl::encoding::TypeMarker for IpCounters {
4564 type Owned = Self;
4565
4566 #[inline(always)]
4567 fn inline_align(_context: fidl::encoding::Context) -> usize {
4568 8
4569 }
4570
4571 #[inline(always)]
4572 fn inline_size(_context: fidl::encoding::Context) -> usize {
4573 16
4574 }
4575 }
4576
4577 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IpCounters, D>
4578 for &IpCounters
4579 {
4580 unsafe fn encode(
4581 self,
4582 encoder: &mut fidl::encoding::Encoder<'_, D>,
4583 offset: usize,
4584 mut depth: fidl::encoding::Depth,
4585 ) -> fidl::Result<()> {
4586 encoder.debug_check_bounds::<IpCounters>(offset);
4587 let max_ordinal: u64 = self.max_ordinal_present();
4589 encoder.write_num(max_ordinal, offset);
4590 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4591 if max_ordinal == 0 {
4593 return Ok(());
4594 }
4595 depth.increment()?;
4596 let envelope_size = 8;
4597 let bytes_len = max_ordinal as usize * envelope_size;
4598 #[allow(unused_variables)]
4599 let offset = encoder.out_of_line_offset(bytes_len);
4600 let mut _prev_end_offset: usize = 0;
4601 if 1 > max_ordinal {
4602 return Ok(());
4603 }
4604
4605 let cur_offset: usize = (1 - 1) * envelope_size;
4608
4609 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4611
4612 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4617 self.success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4618 encoder,
4619 offset + cur_offset,
4620 depth,
4621 )?;
4622
4623 _prev_end_offset = cur_offset + envelope_size;
4624 if 2 > max_ordinal {
4625 return Ok(());
4626 }
4627
4628 let cur_offset: usize = (2 - 1) * envelope_size;
4631
4632 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4634
4635 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4640 self.failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4641 encoder,
4642 offset + cur_offset,
4643 depth,
4644 )?;
4645
4646 _prev_end_offset = cur_offset + envelope_size;
4647
4648 Ok(())
4649 }
4650 }
4651
4652 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IpCounters {
4653 #[inline(always)]
4654 fn new_empty() -> Self {
4655 Self::default()
4656 }
4657
4658 unsafe fn decode(
4659 &mut self,
4660 decoder: &mut fidl::encoding::Decoder<'_, D>,
4661 offset: usize,
4662 mut depth: fidl::encoding::Depth,
4663 ) -> fidl::Result<()> {
4664 decoder.debug_check_bounds::<Self>(offset);
4665 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4666 None => return Err(fidl::Error::NotNullable),
4667 Some(len) => len,
4668 };
4669 if len == 0 {
4671 return Ok(());
4672 };
4673 depth.increment()?;
4674 let envelope_size = 8;
4675 let bytes_len = len * envelope_size;
4676 let offset = decoder.out_of_line_offset(bytes_len)?;
4677 let mut _next_ordinal_to_read = 0;
4679 let mut next_offset = offset;
4680 let end_offset = offset + bytes_len;
4681 _next_ordinal_to_read += 1;
4682 if next_offset >= end_offset {
4683 return Ok(());
4684 }
4685
4686 while _next_ordinal_to_read < 1 {
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.success.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 _next_ordinal_to_read += 1;
4725 if next_offset >= end_offset {
4726 return Ok(());
4727 }
4728
4729 while _next_ordinal_to_read < 2 {
4731 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4732 _next_ordinal_to_read += 1;
4733 next_offset += envelope_size;
4734 }
4735
4736 let next_out_of_line = decoder.next_out_of_line();
4737 let handles_before = decoder.remaining_handles();
4738 if let Some((inlined, num_bytes, num_handles)) =
4739 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4740 {
4741 let member_inline_size =
4742 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4743 if inlined != (member_inline_size <= 4) {
4744 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4745 }
4746 let inner_offset;
4747 let mut inner_depth = depth.clone();
4748 if inlined {
4749 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4750 inner_offset = next_offset;
4751 } else {
4752 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4753 inner_depth.increment()?;
4754 }
4755 let val_ref = self.failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4756 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4757 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4758 {
4759 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4760 }
4761 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4762 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4763 }
4764 }
4765
4766 next_offset += envelope_size;
4767
4768 while next_offset < end_offset {
4770 _next_ordinal_to_read += 1;
4771 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4772 next_offset += envelope_size;
4773 }
4774
4775 Ok(())
4776 }
4777 }
4778
4779 impl MacCounters {
4780 #[inline(always)]
4781 fn max_ordinal_present(&self) -> u64 {
4782 if let Some(_) = self.err_other {
4783 return 26;
4784 }
4785 if let Some(_) = self.err_busy_channel {
4786 return 25;
4787 }
4788 if let Some(_) = self.err_abort {
4789 return 24;
4790 }
4791 if let Some(_) = self.err_cca {
4792 return 23;
4793 }
4794 if let Some(_) = self.err_fcs {
4795 return 22;
4796 }
4797 if let Some(_) = self.err_sec {
4798 return 21;
4799 }
4800 if let Some(_) = self.err_invalid_src_addr {
4801 return 20;
4802 }
4803 if let Some(_) = self.err_unknown_neighbor {
4804 return 19;
4805 }
4806 if let Some(_) = self.err_no_frame {
4807 return 18;
4808 }
4809 if let Some(_) = self.duplicated {
4810 return 17;
4811 }
4812 if let Some(_) = self.dest_addr_filtered {
4813 return 16;
4814 }
4815 if let Some(_) = self.indirect_max_retry_expiry {
4816 return 15;
4817 }
4818 if let Some(_) = self.direct_max_retry_expiry {
4819 return 14;
4820 }
4821 if let Some(_) = self.retries {
4822 return 13;
4823 }
4824 if let Some(_) = self.address_filtered {
4825 return 12;
4826 }
4827 if let Some(_) = self.other {
4828 return 11;
4829 }
4830 if let Some(_) = self.beacon_request {
4831 return 10;
4832 }
4833 if let Some(_) = self.beacon {
4834 return 9;
4835 }
4836 if let Some(_) = self.data_poll {
4837 return 8;
4838 }
4839 if let Some(_) = self.data {
4840 return 7;
4841 }
4842 if let Some(_) = self.no_ack_requested {
4843 return 6;
4844 }
4845 if let Some(_) = self.acked {
4846 return 5;
4847 }
4848 if let Some(_) = self.ack_requested {
4849 return 4;
4850 }
4851 if let Some(_) = self.broadcast {
4852 return 3;
4853 }
4854 if let Some(_) = self.unicast {
4855 return 2;
4856 }
4857 if let Some(_) = self.total {
4858 return 1;
4859 }
4860 0
4861 }
4862 }
4863
4864 impl fidl::encoding::ValueTypeMarker for MacCounters {
4865 type Borrowed<'a> = &'a Self;
4866 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4867 value
4868 }
4869 }
4870
4871 unsafe impl fidl::encoding::TypeMarker for MacCounters {
4872 type Owned = Self;
4873
4874 #[inline(always)]
4875 fn inline_align(_context: fidl::encoding::Context) -> usize {
4876 8
4877 }
4878
4879 #[inline(always)]
4880 fn inline_size(_context: fidl::encoding::Context) -> usize {
4881 16
4882 }
4883 }
4884
4885 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MacCounters, D>
4886 for &MacCounters
4887 {
4888 unsafe fn encode(
4889 self,
4890 encoder: &mut fidl::encoding::Encoder<'_, D>,
4891 offset: usize,
4892 mut depth: fidl::encoding::Depth,
4893 ) -> fidl::Result<()> {
4894 encoder.debug_check_bounds::<MacCounters>(offset);
4895 let max_ordinal: u64 = self.max_ordinal_present();
4897 encoder.write_num(max_ordinal, offset);
4898 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4899 if max_ordinal == 0 {
4901 return Ok(());
4902 }
4903 depth.increment()?;
4904 let envelope_size = 8;
4905 let bytes_len = max_ordinal as usize * envelope_size;
4906 #[allow(unused_variables)]
4907 let offset = encoder.out_of_line_offset(bytes_len);
4908 let mut _prev_end_offset: usize = 0;
4909 if 1 > max_ordinal {
4910 return Ok(());
4911 }
4912
4913 let cur_offset: usize = (1 - 1) * envelope_size;
4916
4917 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4919
4920 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4925 self.total.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4926 encoder,
4927 offset + cur_offset,
4928 depth,
4929 )?;
4930
4931 _prev_end_offset = cur_offset + envelope_size;
4932 if 2 > max_ordinal {
4933 return Ok(());
4934 }
4935
4936 let cur_offset: usize = (2 - 1) * envelope_size;
4939
4940 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4942
4943 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4948 self.unicast.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4949 encoder,
4950 offset + cur_offset,
4951 depth,
4952 )?;
4953
4954 _prev_end_offset = cur_offset + envelope_size;
4955 if 3 > max_ordinal {
4956 return Ok(());
4957 }
4958
4959 let cur_offset: usize = (3 - 1) * envelope_size;
4962
4963 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4965
4966 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4971 self.broadcast.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4972 encoder,
4973 offset + cur_offset,
4974 depth,
4975 )?;
4976
4977 _prev_end_offset = cur_offset + envelope_size;
4978 if 4 > max_ordinal {
4979 return Ok(());
4980 }
4981
4982 let cur_offset: usize = (4 - 1) * envelope_size;
4985
4986 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4988
4989 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4994 self.ack_requested.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4995 encoder,
4996 offset + cur_offset,
4997 depth,
4998 )?;
4999
5000 _prev_end_offset = cur_offset + envelope_size;
5001 if 5 > max_ordinal {
5002 return Ok(());
5003 }
5004
5005 let cur_offset: usize = (5 - 1) * envelope_size;
5008
5009 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5011
5012 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5017 self.acked.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5018 encoder,
5019 offset + cur_offset,
5020 depth,
5021 )?;
5022
5023 _prev_end_offset = cur_offset + envelope_size;
5024 if 6 > max_ordinal {
5025 return Ok(());
5026 }
5027
5028 let cur_offset: usize = (6 - 1) * envelope_size;
5031
5032 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5034
5035 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5040 self.no_ack_requested
5041 .as_ref()
5042 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5043 encoder,
5044 offset + cur_offset,
5045 depth,
5046 )?;
5047
5048 _prev_end_offset = cur_offset + envelope_size;
5049 if 7 > max_ordinal {
5050 return Ok(());
5051 }
5052
5053 let cur_offset: usize = (7 - 1) * envelope_size;
5056
5057 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5059
5060 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5065 self.data.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5066 encoder,
5067 offset + cur_offset,
5068 depth,
5069 )?;
5070
5071 _prev_end_offset = cur_offset + envelope_size;
5072 if 8 > max_ordinal {
5073 return Ok(());
5074 }
5075
5076 let cur_offset: usize = (8 - 1) * envelope_size;
5079
5080 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5082
5083 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5088 self.data_poll.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5089 encoder,
5090 offset + cur_offset,
5091 depth,
5092 )?;
5093
5094 _prev_end_offset = cur_offset + envelope_size;
5095 if 9 > max_ordinal {
5096 return Ok(());
5097 }
5098
5099 let cur_offset: usize = (9 - 1) * envelope_size;
5102
5103 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5105
5106 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5111 self.beacon.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5112 encoder,
5113 offset + cur_offset,
5114 depth,
5115 )?;
5116
5117 _prev_end_offset = cur_offset + envelope_size;
5118 if 10 > max_ordinal {
5119 return Ok(());
5120 }
5121
5122 let cur_offset: usize = (10 - 1) * envelope_size;
5125
5126 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5128
5129 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5134 self.beacon_request.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5135 encoder,
5136 offset + cur_offset,
5137 depth,
5138 )?;
5139
5140 _prev_end_offset = cur_offset + envelope_size;
5141 if 11 > max_ordinal {
5142 return Ok(());
5143 }
5144
5145 let cur_offset: usize = (11 - 1) * envelope_size;
5148
5149 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5151
5152 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5157 self.other.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5158 encoder,
5159 offset + cur_offset,
5160 depth,
5161 )?;
5162
5163 _prev_end_offset = cur_offset + envelope_size;
5164 if 12 > max_ordinal {
5165 return Ok(());
5166 }
5167
5168 let cur_offset: usize = (12 - 1) * envelope_size;
5171
5172 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5174
5175 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5180 self.address_filtered
5181 .as_ref()
5182 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5183 encoder,
5184 offset + cur_offset,
5185 depth,
5186 )?;
5187
5188 _prev_end_offset = cur_offset + envelope_size;
5189 if 13 > max_ordinal {
5190 return Ok(());
5191 }
5192
5193 let cur_offset: usize = (13 - 1) * envelope_size;
5196
5197 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5199
5200 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5205 self.retries.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5206 encoder,
5207 offset + cur_offset,
5208 depth,
5209 )?;
5210
5211 _prev_end_offset = cur_offset + envelope_size;
5212 if 14 > max_ordinal {
5213 return Ok(());
5214 }
5215
5216 let cur_offset: usize = (14 - 1) * envelope_size;
5219
5220 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5222
5223 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5228 self.direct_max_retry_expiry
5229 .as_ref()
5230 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5231 encoder,
5232 offset + cur_offset,
5233 depth,
5234 )?;
5235
5236 _prev_end_offset = cur_offset + envelope_size;
5237 if 15 > max_ordinal {
5238 return Ok(());
5239 }
5240
5241 let cur_offset: usize = (15 - 1) * envelope_size;
5244
5245 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5247
5248 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5253 self.indirect_max_retry_expiry
5254 .as_ref()
5255 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5256 encoder,
5257 offset + cur_offset,
5258 depth,
5259 )?;
5260
5261 _prev_end_offset = cur_offset + envelope_size;
5262 if 16 > max_ordinal {
5263 return Ok(());
5264 }
5265
5266 let cur_offset: usize = (16 - 1) * envelope_size;
5269
5270 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5272
5273 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5278 self.dest_addr_filtered
5279 .as_ref()
5280 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5281 encoder,
5282 offset + cur_offset,
5283 depth,
5284 )?;
5285
5286 _prev_end_offset = cur_offset + envelope_size;
5287 if 17 > max_ordinal {
5288 return Ok(());
5289 }
5290
5291 let cur_offset: usize = (17 - 1) * envelope_size;
5294
5295 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5297
5298 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5303 self.duplicated.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5304 encoder,
5305 offset + cur_offset,
5306 depth,
5307 )?;
5308
5309 _prev_end_offset = cur_offset + envelope_size;
5310 if 18 > max_ordinal {
5311 return Ok(());
5312 }
5313
5314 let cur_offset: usize = (18 - 1) * envelope_size;
5317
5318 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5320
5321 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5326 self.err_no_frame.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5327 encoder,
5328 offset + cur_offset,
5329 depth,
5330 )?;
5331
5332 _prev_end_offset = cur_offset + envelope_size;
5333 if 19 > max_ordinal {
5334 return Ok(());
5335 }
5336
5337 let cur_offset: usize = (19 - 1) * envelope_size;
5340
5341 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5343
5344 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5349 self.err_unknown_neighbor
5350 .as_ref()
5351 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5352 encoder,
5353 offset + cur_offset,
5354 depth,
5355 )?;
5356
5357 _prev_end_offset = cur_offset + envelope_size;
5358 if 20 > max_ordinal {
5359 return Ok(());
5360 }
5361
5362 let cur_offset: usize = (20 - 1) * envelope_size;
5365
5366 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5368
5369 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5374 self.err_invalid_src_addr
5375 .as_ref()
5376 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5377 encoder,
5378 offset + cur_offset,
5379 depth,
5380 )?;
5381
5382 _prev_end_offset = cur_offset + envelope_size;
5383 if 21 > max_ordinal {
5384 return Ok(());
5385 }
5386
5387 let cur_offset: usize = (21 - 1) * envelope_size;
5390
5391 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5393
5394 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5399 self.err_sec.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5400 encoder,
5401 offset + cur_offset,
5402 depth,
5403 )?;
5404
5405 _prev_end_offset = cur_offset + envelope_size;
5406 if 22 > max_ordinal {
5407 return Ok(());
5408 }
5409
5410 let cur_offset: usize = (22 - 1) * envelope_size;
5413
5414 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5416
5417 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5422 self.err_fcs.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5423 encoder,
5424 offset + cur_offset,
5425 depth,
5426 )?;
5427
5428 _prev_end_offset = cur_offset + envelope_size;
5429 if 23 > max_ordinal {
5430 return Ok(());
5431 }
5432
5433 let cur_offset: usize = (23 - 1) * envelope_size;
5436
5437 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5439
5440 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5445 self.err_cca.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5446 encoder,
5447 offset + cur_offset,
5448 depth,
5449 )?;
5450
5451 _prev_end_offset = cur_offset + envelope_size;
5452 if 24 > max_ordinal {
5453 return Ok(());
5454 }
5455
5456 let cur_offset: usize = (24 - 1) * envelope_size;
5459
5460 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5462
5463 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5468 self.err_abort.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5469 encoder,
5470 offset + cur_offset,
5471 depth,
5472 )?;
5473
5474 _prev_end_offset = cur_offset + envelope_size;
5475 if 25 > max_ordinal {
5476 return Ok(());
5477 }
5478
5479 let cur_offset: usize = (25 - 1) * envelope_size;
5482
5483 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5485
5486 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5491 self.err_busy_channel
5492 .as_ref()
5493 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5494 encoder,
5495 offset + cur_offset,
5496 depth,
5497 )?;
5498
5499 _prev_end_offset = cur_offset + envelope_size;
5500 if 26 > max_ordinal {
5501 return Ok(());
5502 }
5503
5504 let cur_offset: usize = (26 - 1) * envelope_size;
5507
5508 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5510
5511 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5516 self.err_other.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5517 encoder,
5518 offset + cur_offset,
5519 depth,
5520 )?;
5521
5522 _prev_end_offset = cur_offset + envelope_size;
5523
5524 Ok(())
5525 }
5526 }
5527
5528 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacCounters {
5529 #[inline(always)]
5530 fn new_empty() -> Self {
5531 Self::default()
5532 }
5533
5534 unsafe fn decode(
5535 &mut self,
5536 decoder: &mut fidl::encoding::Decoder<'_, D>,
5537 offset: usize,
5538 mut depth: fidl::encoding::Depth,
5539 ) -> fidl::Result<()> {
5540 decoder.debug_check_bounds::<Self>(offset);
5541 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5542 None => return Err(fidl::Error::NotNullable),
5543 Some(len) => len,
5544 };
5545 if len == 0 {
5547 return Ok(());
5548 };
5549 depth.increment()?;
5550 let envelope_size = 8;
5551 let bytes_len = len * envelope_size;
5552 let offset = decoder.out_of_line_offset(bytes_len)?;
5553 let mut _next_ordinal_to_read = 0;
5555 let mut next_offset = offset;
5556 let end_offset = offset + bytes_len;
5557 _next_ordinal_to_read += 1;
5558 if next_offset >= end_offset {
5559 return Ok(());
5560 }
5561
5562 while _next_ordinal_to_read < 1 {
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.total.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 < 2 {
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.unicast.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 < 3 {
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.broadcast.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 < 4 {
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.ack_requested.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 < 5 {
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.acked.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 < 6 {
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.no_ack_requested.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 < 7 {
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.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 < 8 {
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.data_poll.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 < 9 {
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.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 < 10 {
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.beacon_request.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 < 11 {
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.other.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 < 12 {
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.address_filtered.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 < 13 {
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 = self.retries.get_or_insert_with(|| fidl::new_empty!(u32, D));
6105 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6106 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6107 {
6108 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6109 }
6110 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6111 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6112 }
6113 }
6114
6115 next_offset += envelope_size;
6116 _next_ordinal_to_read += 1;
6117 if next_offset >= end_offset {
6118 return Ok(());
6119 }
6120
6121 while _next_ordinal_to_read < 14 {
6123 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6124 _next_ordinal_to_read += 1;
6125 next_offset += envelope_size;
6126 }
6127
6128 let next_out_of_line = decoder.next_out_of_line();
6129 let handles_before = decoder.remaining_handles();
6130 if let Some((inlined, num_bytes, num_handles)) =
6131 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6132 {
6133 let member_inline_size =
6134 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6135 if inlined != (member_inline_size <= 4) {
6136 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6137 }
6138 let inner_offset;
6139 let mut inner_depth = depth.clone();
6140 if inlined {
6141 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6142 inner_offset = next_offset;
6143 } else {
6144 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6145 inner_depth.increment()?;
6146 }
6147 let val_ref =
6148 self.direct_max_retry_expiry.get_or_insert_with(|| fidl::new_empty!(u32, D));
6149 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6150 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6151 {
6152 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6153 }
6154 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6155 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6156 }
6157 }
6158
6159 next_offset += envelope_size;
6160 _next_ordinal_to_read += 1;
6161 if next_offset >= end_offset {
6162 return Ok(());
6163 }
6164
6165 while _next_ordinal_to_read < 15 {
6167 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6168 _next_ordinal_to_read += 1;
6169 next_offset += envelope_size;
6170 }
6171
6172 let next_out_of_line = decoder.next_out_of_line();
6173 let handles_before = decoder.remaining_handles();
6174 if let Some((inlined, num_bytes, num_handles)) =
6175 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6176 {
6177 let member_inline_size =
6178 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6179 if inlined != (member_inline_size <= 4) {
6180 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6181 }
6182 let inner_offset;
6183 let mut inner_depth = depth.clone();
6184 if inlined {
6185 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6186 inner_offset = next_offset;
6187 } else {
6188 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6189 inner_depth.increment()?;
6190 }
6191 let val_ref =
6192 self.indirect_max_retry_expiry.get_or_insert_with(|| fidl::new_empty!(u32, D));
6193 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6194 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6195 {
6196 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6197 }
6198 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6199 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6200 }
6201 }
6202
6203 next_offset += envelope_size;
6204 _next_ordinal_to_read += 1;
6205 if next_offset >= end_offset {
6206 return Ok(());
6207 }
6208
6209 while _next_ordinal_to_read < 16 {
6211 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6212 _next_ordinal_to_read += 1;
6213 next_offset += envelope_size;
6214 }
6215
6216 let next_out_of_line = decoder.next_out_of_line();
6217 let handles_before = decoder.remaining_handles();
6218 if let Some((inlined, num_bytes, num_handles)) =
6219 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6220 {
6221 let member_inline_size =
6222 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6223 if inlined != (member_inline_size <= 4) {
6224 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6225 }
6226 let inner_offset;
6227 let mut inner_depth = depth.clone();
6228 if inlined {
6229 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6230 inner_offset = next_offset;
6231 } else {
6232 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6233 inner_depth.increment()?;
6234 }
6235 let val_ref =
6236 self.dest_addr_filtered.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 < 17 {
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.duplicated.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 < 18 {
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 = self.err_no_frame.get_or_insert_with(|| fidl::new_empty!(u32, D));
6323 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6324 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6325 {
6326 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6327 }
6328 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6329 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6330 }
6331 }
6332
6333 next_offset += envelope_size;
6334 _next_ordinal_to_read += 1;
6335 if next_offset >= end_offset {
6336 return Ok(());
6337 }
6338
6339 while _next_ordinal_to_read < 19 {
6341 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6342 _next_ordinal_to_read += 1;
6343 next_offset += envelope_size;
6344 }
6345
6346 let next_out_of_line = decoder.next_out_of_line();
6347 let handles_before = decoder.remaining_handles();
6348 if let Some((inlined, num_bytes, num_handles)) =
6349 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6350 {
6351 let member_inline_size =
6352 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6353 if inlined != (member_inline_size <= 4) {
6354 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6355 }
6356 let inner_offset;
6357 let mut inner_depth = depth.clone();
6358 if inlined {
6359 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6360 inner_offset = next_offset;
6361 } else {
6362 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6363 inner_depth.increment()?;
6364 }
6365 let val_ref =
6366 self.err_unknown_neighbor.get_or_insert_with(|| fidl::new_empty!(u32, D));
6367 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6368 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6369 {
6370 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6371 }
6372 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6373 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6374 }
6375 }
6376
6377 next_offset += envelope_size;
6378 _next_ordinal_to_read += 1;
6379 if next_offset >= end_offset {
6380 return Ok(());
6381 }
6382
6383 while _next_ordinal_to_read < 20 {
6385 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6386 _next_ordinal_to_read += 1;
6387 next_offset += envelope_size;
6388 }
6389
6390 let next_out_of_line = decoder.next_out_of_line();
6391 let handles_before = decoder.remaining_handles();
6392 if let Some((inlined, num_bytes, num_handles)) =
6393 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6394 {
6395 let member_inline_size =
6396 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6397 if inlined != (member_inline_size <= 4) {
6398 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6399 }
6400 let inner_offset;
6401 let mut inner_depth = depth.clone();
6402 if inlined {
6403 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6404 inner_offset = next_offset;
6405 } else {
6406 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6407 inner_depth.increment()?;
6408 }
6409 let val_ref =
6410 self.err_invalid_src_addr.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 < 21 {
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_sec.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 < 22 {
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_fcs.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 < 23 {
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_cca.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 < 24 {
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_abort.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 < 25 {
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_busy_channel.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 _next_ordinal_to_read += 1;
6638 if next_offset >= end_offset {
6639 return Ok(());
6640 }
6641
6642 while _next_ordinal_to_read < 26 {
6644 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6645 _next_ordinal_to_read += 1;
6646 next_offset += envelope_size;
6647 }
6648
6649 let next_out_of_line = decoder.next_out_of_line();
6650 let handles_before = decoder.remaining_handles();
6651 if let Some((inlined, num_bytes, num_handles)) =
6652 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6653 {
6654 let member_inline_size =
6655 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6656 if inlined != (member_inline_size <= 4) {
6657 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6658 }
6659 let inner_offset;
6660 let mut inner_depth = depth.clone();
6661 if inlined {
6662 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6663 inner_offset = next_offset;
6664 } else {
6665 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6666 inner_depth.increment()?;
6667 }
6668 let val_ref = self.err_other.get_or_insert_with(|| fidl::new_empty!(u32, D));
6669 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6670 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6671 {
6672 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6673 }
6674 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6675 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6676 }
6677 }
6678
6679 next_offset += envelope_size;
6680
6681 while next_offset < end_offset {
6683 _next_ordinal_to_read += 1;
6684 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6685 next_offset += envelope_size;
6686 }
6687
6688 Ok(())
6689 }
6690 }
6691
6692 impl fidl::encoding::ValueTypeMarker for Credential {
6693 type Borrowed<'a> = &'a Self;
6694 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6695 value
6696 }
6697 }
6698
6699 unsafe impl fidl::encoding::TypeMarker for Credential {
6700 type Owned = Self;
6701
6702 #[inline(always)]
6703 fn inline_align(_context: fidl::encoding::Context) -> usize {
6704 8
6705 }
6706
6707 #[inline(always)]
6708 fn inline_size(_context: fidl::encoding::Context) -> usize {
6709 16
6710 }
6711 }
6712
6713 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Credential, D>
6714 for &Credential
6715 {
6716 #[inline]
6717 unsafe fn encode(
6718 self,
6719 encoder: &mut fidl::encoding::Encoder<'_, D>,
6720 offset: usize,
6721 _depth: fidl::encoding::Depth,
6722 ) -> fidl::Result<()> {
6723 encoder.debug_check_bounds::<Credential>(offset);
6724 encoder.write_num::<u64>(self.ordinal(), offset);
6725 match self {
6726 Credential::NetworkKey(ref val) => {
6727 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 32>, D>(
6728 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(
6729 val,
6730 ),
6731 encoder,
6732 offset + 8,
6733 _depth,
6734 )
6735 }
6736 Credential::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
6737 }
6738 }
6739 }
6740
6741 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Credential {
6742 #[inline(always)]
6743 fn new_empty() -> Self {
6744 Self::__SourceBreaking { unknown_ordinal: 0 }
6745 }
6746
6747 #[inline]
6748 unsafe fn decode(
6749 &mut self,
6750 decoder: &mut fidl::encoding::Decoder<'_, D>,
6751 offset: usize,
6752 mut depth: fidl::encoding::Depth,
6753 ) -> fidl::Result<()> {
6754 decoder.debug_check_bounds::<Self>(offset);
6755 #[allow(unused_variables)]
6756 let next_out_of_line = decoder.next_out_of_line();
6757 let handles_before = decoder.remaining_handles();
6758 let (ordinal, inlined, num_bytes, num_handles) =
6759 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
6760
6761 let member_inline_size = match ordinal {
6762 1 => <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
6763 decoder.context,
6764 ),
6765 0 => return Err(fidl::Error::UnknownUnionTag),
6766 _ => num_bytes as usize,
6767 };
6768
6769 if inlined != (member_inline_size <= 4) {
6770 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6771 }
6772 let _inner_offset;
6773 if inlined {
6774 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
6775 _inner_offset = offset + 8;
6776 } else {
6777 depth.increment()?;
6778 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6779 }
6780 match ordinal {
6781 1 => {
6782 #[allow(irrefutable_let_patterns)]
6783 if let Credential::NetworkKey(_) = self {
6784 } else {
6786 *self = Credential::NetworkKey(
6788 fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D),
6789 );
6790 }
6791 #[allow(irrefutable_let_patterns)]
6792 if let Credential::NetworkKey(ref mut val) = self {
6793 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val, decoder, _inner_offset, depth)?;
6794 } else {
6795 unreachable!()
6796 }
6797 }
6798 #[allow(deprecated)]
6799 ordinal => {
6800 for _ in 0..num_handles {
6801 decoder.drop_next_handle()?;
6802 }
6803 *self = Credential::__SourceBreaking { unknown_ordinal: ordinal };
6804 }
6805 }
6806 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
6807 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6808 }
6809 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6810 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6811 }
6812 Ok(())
6813 }
6814 }
6815}