1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const MAX_EXTERNAL_ROUTES: u32 = 32;
12
13pub const MAX_ON_MESH_PREFIXES: u32 = 32;
14
15pub const MAX_PROVISION_URL_LEN: u16 = 64;
16
17pub const MAX_VENDOR_DATA_LEN: u16 = 64;
18
19pub const MAX_VENDOR_MODEL_LEN: u16 = 32;
20
21pub const MAX_VENDOR_NAME_LEN: u16 = 32;
22
23pub const MAX_VENDOR_SW_VER_LEN: u16 = 16;
24
25pub const PSKD_LEN: u16 = 32;
26
27#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
29pub enum Dhcp6PdState {
30 Dhcp6PdStateUnspecified,
31 Dhcp6PdStateDisabled,
33 Dhcp6PdStateStopped,
35 Dhcp6PdStateRunning,
37 Dhcp6PdStateIdle,
39 #[doc(hidden)]
40 __SourceBreaking {
41 unknown_ordinal: u32,
42 },
43}
44
45#[macro_export]
47macro_rules! Dhcp6PdStateUnknown {
48 () => {
49 _
50 };
51}
52
53impl Dhcp6PdState {
54 #[inline]
55 pub fn from_primitive(prim: u32) -> Option<Self> {
56 match prim {
57 0 => Some(Self::Dhcp6PdStateUnspecified),
58 1 => Some(Self::Dhcp6PdStateDisabled),
59 2 => Some(Self::Dhcp6PdStateStopped),
60 3 => Some(Self::Dhcp6PdStateRunning),
61 4 => Some(Self::Dhcp6PdStateIdle),
62 _ => None,
63 }
64 }
65
66 #[inline]
67 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
68 match prim {
69 0 => Self::Dhcp6PdStateUnspecified,
70 1 => Self::Dhcp6PdStateDisabled,
71 2 => Self::Dhcp6PdStateStopped,
72 3 => Self::Dhcp6PdStateRunning,
73 4 => Self::Dhcp6PdStateIdle,
74 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
75 }
76 }
77
78 #[inline]
79 pub fn unknown() -> Self {
80 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
81 }
82
83 #[inline]
84 pub const fn into_primitive(self) -> u32 {
85 match self {
86 Self::Dhcp6PdStateUnspecified => 0,
87 Self::Dhcp6PdStateDisabled => 1,
88 Self::Dhcp6PdStateStopped => 2,
89 Self::Dhcp6PdStateRunning => 3,
90 Self::Dhcp6PdStateIdle => 4,
91 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
92 }
93 }
94
95 #[inline]
96 pub fn is_unknown(&self) -> bool {
97 match self {
98 Self::__SourceBreaking { unknown_ordinal: _ } => true,
99 _ => false,
100 }
101 }
102}
103
104#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
105pub enum Nat64State {
106 Nat64StateUnspecified,
107 Nat64StateDisabled,
108 Nat64StateNotRunning,
109 Nat64StateIdle,
110 Nat64StateActive,
111 #[doc(hidden)]
112 __SourceBreaking {
113 unknown_ordinal: u32,
114 },
115}
116
117#[macro_export]
119macro_rules! Nat64StateUnknown {
120 () => {
121 _
122 };
123}
124
125impl Nat64State {
126 #[inline]
127 pub fn from_primitive(prim: u32) -> Option<Self> {
128 match prim {
129 0 => Some(Self::Nat64StateUnspecified),
130 1 => Some(Self::Nat64StateDisabled),
131 2 => Some(Self::Nat64StateNotRunning),
132 3 => Some(Self::Nat64StateIdle),
133 4 => Some(Self::Nat64StateActive),
134 _ => None,
135 }
136 }
137
138 #[inline]
139 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
140 match prim {
141 0 => Self::Nat64StateUnspecified,
142 1 => Self::Nat64StateDisabled,
143 2 => Self::Nat64StateNotRunning,
144 3 => Self::Nat64StateIdle,
145 4 => Self::Nat64StateActive,
146 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
147 }
148 }
149
150 #[inline]
151 pub fn unknown() -> Self {
152 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
153 }
154
155 #[inline]
156 pub const fn into_primitive(self) -> u32 {
157 match self {
158 Self::Nat64StateUnspecified => 0,
159 Self::Nat64StateDisabled => 1,
160 Self::Nat64StateNotRunning => 2,
161 Self::Nat64StateIdle => 3,
162 Self::Nat64StateActive => 4,
163 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
164 }
165 }
166
167 #[inline]
168 pub fn is_unknown(&self) -> bool {
169 match self {
170 Self::__SourceBreaking { unknown_ordinal: _ } => true,
171 _ => false,
172 }
173 }
174}
175
176#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
180pub enum ProvisionError {
181 CredentialRejected,
186 NetworkNotFound,
189 NetworkAlreadyExists,
192 Canceled,
195 #[doc(hidden)]
196 __SourceBreaking { unknown_ordinal: i32 },
197}
198
199#[macro_export]
201macro_rules! ProvisionErrorUnknown {
202 () => {
203 _
204 };
205}
206
207impl ProvisionError {
208 #[inline]
209 pub fn from_primitive(prim: i32) -> Option<Self> {
210 match prim {
211 1 => Some(Self::CredentialRejected),
212 2 => Some(Self::NetworkNotFound),
213 3 => Some(Self::NetworkAlreadyExists),
214 4 => Some(Self::Canceled),
215 _ => None,
216 }
217 }
218
219 #[inline]
220 pub fn from_primitive_allow_unknown(prim: i32) -> Self {
221 match prim {
222 1 => Self::CredentialRejected,
223 2 => Self::NetworkNotFound,
224 3 => Self::NetworkAlreadyExists,
225 4 => Self::Canceled,
226 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
227 }
228 }
229
230 #[inline]
231 pub fn unknown() -> Self {
232 Self::__SourceBreaking { unknown_ordinal: 0x7fffffff }
233 }
234
235 #[inline]
236 pub const fn into_primitive(self) -> i32 {
237 match self {
238 Self::CredentialRejected => 1,
239 Self::NetworkNotFound => 2,
240 Self::NetworkAlreadyExists => 3,
241 Self::Canceled => 4,
242 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
243 }
244 }
245
246 #[inline]
247 pub fn is_unknown(&self) -> bool {
248 match self {
249 Self::__SourceBreaking { unknown_ordinal: _ } => true,
250 _ => false,
251 }
252 }
253}
254
255#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
257#[repr(i8)]
258pub enum RoutePreference {
259 Low = -1,
261 Medium = 0,
263 High = 1,
265}
266
267impl RoutePreference {
268 #[inline]
269 pub fn from_primitive(prim: i8) -> Option<Self> {
270 match prim {
271 -1 => Some(Self::Low),
272 0 => Some(Self::Medium),
273 1 => Some(Self::High),
274 _ => None,
275 }
276 }
277
278 #[inline]
279 pub const fn into_primitive(self) -> i8 {
280 self as i8
281 }
282}
283
284#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
285#[repr(u32)]
286pub enum SrpServerAddressMode {
287 Unicast = 1,
289 Anycast = 2,
291}
292
293impl SrpServerAddressMode {
294 #[inline]
295 pub fn from_primitive(prim: u32) -> Option<Self> {
296 match prim {
297 1 => Some(Self::Unicast),
298 2 => Some(Self::Anycast),
299 _ => None,
300 }
301 }
302
303 #[inline]
304 pub const fn into_primitive(self) -> u32 {
305 self as u32
306 }
307}
308
309#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
310#[repr(u32)]
311pub enum SrpServerState {
312 Disabled = 1,
314 Running = 2,
316 Stopped = 3,
318}
319
320impl SrpServerState {
321 #[inline]
322 pub fn from_primitive(prim: u32) -> Option<Self> {
323 match prim {
324 1 => Some(Self::Disabled),
325 2 => Some(Self::Running),
326 3 => Some(Self::Stopped),
327 _ => None,
328 }
329 }
330
331 #[inline]
332 pub const fn into_primitive(self) -> u32 {
333 self as u32
334 }
335}
336
337#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
339pub enum UpstreamDnsQueryState {
340 UpstreamdnsQueryStateUnspecified,
341 UpstreamdnsQueryStateEnabled,
342 UpstreamdnsQueryStateDisabled,
343 #[doc(hidden)]
344 __SourceBreaking {
345 unknown_ordinal: u32,
346 },
347}
348
349#[macro_export]
351macro_rules! UpstreamDnsQueryStateUnknown {
352 () => {
353 _
354 };
355}
356
357impl UpstreamDnsQueryState {
358 #[inline]
359 pub fn from_primitive(prim: u32) -> Option<Self> {
360 match prim {
361 0 => Some(Self::UpstreamdnsQueryStateUnspecified),
362 1 => Some(Self::UpstreamdnsQueryStateEnabled),
363 2 => Some(Self::UpstreamdnsQueryStateDisabled),
364 _ => None,
365 }
366 }
367
368 #[inline]
369 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
370 match prim {
371 0 => Self::UpstreamdnsQueryStateUnspecified,
372 1 => Self::UpstreamdnsQueryStateEnabled,
373 2 => Self::UpstreamdnsQueryStateDisabled,
374 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
375 }
376 }
377
378 #[inline]
379 pub fn unknown() -> Self {
380 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
381 }
382
383 #[inline]
384 pub const fn into_primitive(self) -> u32 {
385 match self {
386 Self::UpstreamdnsQueryStateUnspecified => 0,
387 Self::UpstreamdnsQueryStateEnabled => 1,
388 Self::UpstreamdnsQueryStateDisabled => 2,
389 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
390 }
391 }
392
393 #[inline]
394 pub fn is_unknown(&self) -> bool {
395 match self {
396 Self::__SourceBreaking { unknown_ordinal: _ } => true,
397 _ => false,
398 }
399 }
400}
401
402#[derive(Clone, Debug, PartialEq)]
403pub struct BeaconInfoStreamNextResponse {
404 pub beacons: Vec<BeaconInfo>,
405}
406
407impl fidl::Persistable for BeaconInfoStreamNextResponse {}
408
409#[derive(Clone, Debug, PartialEq)]
410pub struct DeviceGetSupportedChannelsResponse {
411 pub channels_info: Vec<ChannelInfo>,
412}
413
414impl fidl::Persistable for DeviceGetSupportedChannelsResponse {}
415
416#[derive(Clone, Debug, PartialEq)]
417pub struct DeviceRouteExtraGetLocalExternalRoutesResponse {
418 pub external_routes: Vec<ExternalRoute>,
419}
420
421impl fidl::Persistable for DeviceRouteExtraGetLocalExternalRoutesResponse {}
422
423#[derive(Clone, Debug, PartialEq)]
424pub struct DeviceRouteExtraGetLocalOnMeshPrefixesResponse {
425 pub prefixes: Vec<OnMeshPrefix>,
426}
427
428impl fidl::Persistable for DeviceRouteExtraGetLocalOnMeshPrefixesResponse {}
429
430#[derive(Clone, Debug, PartialEq)]
431pub struct DeviceRouteRegisterExternalRouteRequest {
432 pub external_route: ExternalRoute,
433}
434
435impl fidl::Persistable for DeviceRouteRegisterExternalRouteRequest {}
436
437#[derive(Clone, Debug, PartialEq)]
438pub struct DeviceRouteRegisterOnMeshPrefixRequest {
439 pub prefix: OnMeshPrefix,
440}
441
442impl fidl::Persistable for DeviceRouteRegisterOnMeshPrefixRequest {}
443
444#[derive(Clone, Debug, PartialEq)]
445pub struct DeviceRouteUnregisterExternalRouteRequest {
446 pub subnet: fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
447}
448
449impl fidl::Persistable for DeviceRouteUnregisterExternalRouteRequest {}
450
451#[derive(Clone, Debug, PartialEq)]
452pub struct DeviceRouteUnregisterOnMeshPrefixRequest {
453 pub subnet: fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
454}
455
456impl fidl::Persistable for DeviceRouteUnregisterOnMeshPrefixRequest {}
457
458#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
459#[repr(C)]
460pub struct LegacyJoiningMakeJoinableRequest {
461 pub duration: i64,
462 pub port: u16,
463}
464
465impl fidl::Persistable for LegacyJoiningMakeJoinableRequest {}
466
467#[derive(Clone, Debug, PartialEq)]
468pub struct ProvisioningMonitorWatchProgressResponse {
469 pub progress: ProvisioningProgress,
470}
471
472impl fidl::Persistable for ProvisioningMonitorWatchProgressResponse {}
473
474#[derive(Clone, Debug, PartialEq)]
475pub struct TelemetryProviderGetTelemetryResponse {
476 pub telemetry: Telemetry,
477}
478
479impl fidl::Persistable for TelemetryProviderGetTelemetryResponse {}
480
481#[derive(Clone, Debug, Default, PartialEq)]
482pub struct BeaconInfo {
483 pub address: Option<fidl_fuchsia_lowpan__common::MacAddress>,
485 pub identity: Option<fidl_fuchsia_lowpan_device__common::Identity>,
488 pub rssi: Option<i8>,
493 pub lqi: Option<u8>,
507 #[doc(hidden)]
508 pub __source_breaking: fidl::marker::SourceBreaking,
509}
510
511impl fidl::Persistable for BeaconInfo {}
512
513#[derive(Clone, Debug, Default, PartialEq)]
515pub struct BorderRoutingCounters {
516 pub inbound_unicast_packets: Option<u64>,
520 pub inbound_unicast_bytes: Option<u64>,
524 pub inbound_multicast_packets: Option<u64>,
528 pub inbound_multicast_bytes: Option<u64>,
532 pub outbound_unicast_packets: Option<u64>,
536 pub outbound_unicast_bytes: Option<u64>,
540 pub outbound_multicast_packets: Option<u64>,
544 pub outbound_multicast_bytes: Option<u64>,
548 pub ra_rx: Option<u32>,
552 pub ra_tx_success: Option<u32>,
556 pub ra_tx_failure: Option<u32>,
560 pub rs_rx: Option<u32>,
564 pub rs_tx_success: Option<u32>,
568 pub rs_tx_failure: Option<u32>,
572 pub inbound_internet_packets: Option<u64>,
576 pub inbound_internet_bytes: Option<u64>,
580 pub outbound_internet_packets: Option<u64>,
584 pub outbound_internet_bytes: Option<u64>,
588 #[doc(hidden)]
589 pub __source_breaking: fidl::marker::SourceBreaking,
590}
591
592impl fidl::Persistable for BorderRoutingCounters {}
593
594#[derive(Clone, Debug, Default, PartialEq)]
596pub struct BorderRoutingNat64State {
597 pub prefix_manager_state: Option<Nat64State>,
599 pub translator_state: Option<Nat64State>,
601 #[doc(hidden)]
602 pub __source_breaking: fidl::marker::SourceBreaking,
603}
604
605impl fidl::Persistable for BorderRoutingNat64State {}
606
607#[derive(Clone, Debug, Default, PartialEq)]
608pub struct ChannelInfo {
609 pub index: Option<u16>,
612 pub id: Option<String>,
628 pub max_transmit_power_dbm: Option<i8>,
631 pub spectrum_center_frequency_hz: Option<u64>,
654 pub spectrum_bandwidth_hz: Option<u64>,
661 pub masked_by_regulatory_domain: Option<bool>,
665 #[doc(hidden)]
666 pub __source_breaking: fidl::marker::SourceBreaking,
667}
668
669impl fidl::Persistable for ChannelInfo {}
670
671#[derive(Clone, Debug, Default, PartialEq)]
673pub struct Dhcp6PdInfo {
674 pub dhcp6pd_state: Option<Dhcp6PdState>,
678 pub pd_processed_ra_info: Option<PdProcessedRaInfo>,
682 pub hashed_pd_prefix: Option<Vec<u8>>,
686 #[doc(hidden)]
687 pub __source_breaking: fidl::marker::SourceBreaking,
688}
689
690impl fidl::Persistable for Dhcp6PdInfo {}
691
692#[derive(Clone, Debug, Default, PartialEq)]
694pub struct DnssdCounters {
695 pub success_response: Option<u32>,
699 pub server_failure_response: Option<u32>,
703 pub format_error_response: Option<u32>,
707 pub name_error_response: Option<u32>,
711 pub not_implemented_response: Option<u32>,
715 pub other_response: Option<u32>,
719 pub resolved_by_srp: Option<u32>,
723 pub upstream_dns_counters: Option<UpstreamDnsCounters>,
727 #[doc(hidden)]
728 pub __source_breaking: fidl::marker::SourceBreaking,
729}
730
731impl fidl::Persistable for DnssdCounters {}
732
733#[derive(Clone, Debug, Default, PartialEq)]
737pub struct ExternalRoute {
738 pub subnet: Option<fidl_fuchsia_net__common::Ipv6AddressWithPrefix>,
740 pub route_preference: Option<RoutePreference>,
747 pub stable: Option<bool>,
756 #[doc(hidden)]
757 pub __source_breaking: fidl::marker::SourceBreaking,
758}
759
760impl fidl::Persistable for ExternalRoute {}
761
762#[derive(Clone, Debug, Default, PartialEq)]
767pub struct JoinerCommissioningParams {
768 pub pskd: Option<String>,
770 pub provisioning_url: Option<String>,
772 pub vendor_name: Option<String>,
774 pub vendor_model: Option<String>,
776 pub vendor_sw_version: Option<String>,
778 pub vendor_data_string: Option<String>,
780 #[doc(hidden)]
781 pub __source_breaking: fidl::marker::SourceBreaking,
782}
783
784impl fidl::Persistable for JoinerCommissioningParams {}
785
786#[derive(Clone, Debug, Default, PartialEq)]
788pub struct LeaderData {
789 pub partition_id: Option<u32>,
793 pub weight: Option<u8>,
797 pub network_data_version: Option<u8>,
801 pub stable_network_data_version: Option<u8>,
805 pub router_id: Option<u8>,
809 #[doc(hidden)]
810 pub __source_breaking: fidl::marker::SourceBreaking,
811}
812
813impl fidl::Persistable for LeaderData {}
814
815#[derive(Clone, Debug, Default, PartialEq)]
817pub struct LinkMetricsEntry {
818 pub link_margin: Option<u8>,
820 pub rssi: Option<i8>,
822 #[doc(hidden)]
823 pub __source_breaking: fidl::marker::SourceBreaking,
824}
825
826impl fidl::Persistable for LinkMetricsEntry {}
827
828#[derive(Clone, Debug, Default, PartialEq)]
829pub struct Nat64ErrorCounters {
830 pub unknown: Option<Nat64PacketCounters>,
832 pub illegal_packet: Option<Nat64PacketCounters>,
834 pub unsupported_protocol: Option<Nat64PacketCounters>,
836 pub no_mapping: Option<Nat64PacketCounters>,
838 #[doc(hidden)]
839 pub __source_breaking: fidl::marker::SourceBreaking,
840}
841
842impl fidl::Persistable for Nat64ErrorCounters {}
843
844#[derive(Clone, Debug, Default, PartialEq)]
845pub struct Nat64Info {
846 pub nat64_state: Option<BorderRoutingNat64State>,
848 pub nat64_mappings: Option<Vec<Nat64Mapping>>,
850 pub nat64_error_counters: Option<Nat64ErrorCounters>,
852 pub nat64_protocol_counters: Option<Nat64ProtocolCounters>,
854 #[doc(hidden)]
855 pub __source_breaking: fidl::marker::SourceBreaking,
856}
857
858impl fidl::Persistable for Nat64Info {}
859
860#[derive(Clone, Debug, Default, PartialEq)]
862pub struct Nat64Mapping {
863 pub mapping_id: Option<u64>,
865 pub ip4_addr: Option<Vec<u8>>,
867 pub ip6_addr: Option<Vec<u8>>,
869 pub remaining_time_ms: Option<u32>,
871 pub counters: Option<Nat64ProtocolCounters>,
873 #[doc(hidden)]
874 pub __source_breaking: fidl::marker::SourceBreaking,
875}
876
877impl fidl::Persistable for Nat64Mapping {}
878
879#[derive(Clone, Debug, Default, PartialEq)]
880pub struct Nat64PacketCounters {
881 pub ipv4_to_ipv6_packets: Option<u64>,
883 pub ipv6_to_ipv4_packets: Option<u64>,
885 #[doc(hidden)]
886 pub __source_breaking: fidl::marker::SourceBreaking,
887}
888
889impl fidl::Persistable for Nat64PacketCounters {}
890
891#[derive(Clone, Debug, Default, PartialEq)]
892pub struct Nat64ProtocolCounters {
893 pub tcp: Option<Nat64TrafficCounters>,
895 pub udp: Option<Nat64TrafficCounters>,
897 pub icmp: Option<Nat64TrafficCounters>,
899 pub total: Option<Nat64TrafficCounters>,
901 #[doc(hidden)]
902 pub __source_breaking: fidl::marker::SourceBreaking,
903}
904
905impl fidl::Persistable for Nat64ProtocolCounters {}
906
907#[derive(Clone, Debug, Default, PartialEq)]
908pub struct Nat64TrafficCounters {
909 pub ipv4_to_ipv6_packets: Option<u64>,
911 pub ipv4_to_ipv6_bytes: Option<u64>,
913 pub ipv6_to_ipv4_packets: Option<u64>,
915 pub ipv6_to_ipv4_bytes: Option<u64>,
917 #[doc(hidden)]
918 pub __source_breaking: fidl::marker::SourceBreaking,
919}
920
921impl fidl::Persistable for Nat64TrafficCounters {}
922
923#[derive(Clone, Debug, Default, PartialEq)]
925pub struct NetworkScanParameters {
926 pub channels: Option<Vec<u16>>,
930 pub tx_power_dbm: Option<i8>,
941 #[doc(hidden)]
942 pub __source_breaking: fidl::marker::SourceBreaking,
943}
944
945impl fidl::Persistable for NetworkScanParameters {}
946
947#[derive(Clone, Debug, Default, PartialEq)]
951pub struct OnMeshPrefix {
952 pub subnet: Option<fidl_fuchsia_net__common::Ipv6AddressWithPrefix>,
954 pub default_route_preference: Option<RoutePreference>,
962 pub stable: Option<bool>,
971 pub slaac_preferred: Option<bool>,
980 pub slaac_valid: Option<bool>,
989 #[doc(hidden)]
990 pub __source_breaking: fidl::marker::SourceBreaking,
991}
992
993impl fidl::Persistable for OnMeshPrefix {}
994
995#[derive(Clone, Debug, Default, PartialEq)]
997pub struct PdProcessedRaInfo {
998 pub num_platform_ra_received: Option<u32>,
1002 pub num_platform_pio_processed: Option<u32>,
1006 pub last_platform_ra_msec: Option<u32>,
1010 #[doc(hidden)]
1011 pub __source_breaking: fidl::marker::SourceBreaking,
1012}
1013
1014impl fidl::Persistable for PdProcessedRaInfo {}
1015
1016#[derive(Clone, Debug, Default, PartialEq)]
1018pub struct SrpServerInfo {
1019 pub state: Option<SrpServerState>,
1023 pub port: Option<u16>,
1027 pub address_mode: Option<SrpServerAddressMode>,
1031 pub response_counters: Option<SrpServerResponseCounters>,
1035 pub hosts_registration: Option<SrpServerRegistration>,
1039 pub services_registration: Option<SrpServerRegistration>,
1043 #[doc(hidden)]
1044 pub __source_breaking: fidl::marker::SourceBreaking,
1045}
1046
1047impl fidl::Persistable for SrpServerInfo {}
1048
1049#[derive(Clone, Debug, Default, PartialEq)]
1051pub struct SrpServerRegistration {
1052 pub fresh_count: Option<u32>,
1056 pub deleted_count: Option<u32>,
1060 pub lease_time_total: Option<i64>,
1064 pub key_lease_time_total: Option<i64>,
1068 pub remaining_lease_time_total: Option<i64>,
1072 pub remaining_key_lease_time_total: Option<i64>,
1076 #[doc(hidden)]
1077 pub __source_breaking: fidl::marker::SourceBreaking,
1078}
1079
1080impl fidl::Persistable for SrpServerRegistration {}
1081
1082#[derive(Clone, Debug, Default, PartialEq)]
1083pub struct SrpServerResponseCounters {
1084 pub success_response: Option<u32>,
1088 pub server_failure_response: Option<u32>,
1092 pub format_error_response: Option<u32>,
1096 pub name_exists_response: Option<u32>,
1100 pub refused_response: Option<u32>,
1104 pub other_response: Option<u32>,
1108 #[doc(hidden)]
1109 pub __source_breaking: fidl::marker::SourceBreaking,
1110}
1111
1112impl fidl::Persistable for SrpServerResponseCounters {}
1113
1114#[derive(Clone, Debug, Default, PartialEq)]
1121pub struct Telemetry {
1122 pub rssi: Option<i8>,
1124 pub tx_power: Option<i8>,
1126 pub channel_index: Option<u16>,
1128 pub partition_id: Option<u32>,
1130 pub stack_version: Option<String>,
1132 pub rcp_version: Option<String>,
1134 pub thread_link_mode: Option<u8>,
1140 pub thread_router_id: Option<u8>,
1144 pub thread_rloc: Option<u16>,
1148 pub thread_network_data_version: Option<u8>,
1152 pub thread_stable_network_data_version: Option<u8>,
1156 pub thread_network_data: Option<Vec<u8>>,
1161 pub thread_stable_network_data: Option<Vec<u8>>,
1166 pub thread_border_routing_counters: Option<BorderRoutingCounters>,
1170 pub srp_server_info: Option<SrpServerInfo>,
1174 pub dnssd_counters: Option<DnssdCounters>,
1178 pub leader_data: Option<LeaderData>,
1182 pub uptime: Option<i64>,
1186 pub nat64_info: Option<Nat64Info>,
1190 pub trel_counters: Option<TrelCounters>,
1194 pub trel_peers_info: Option<TrelPeersInfo>,
1198 pub upstream_dns_info: Option<UpstreamDnsInfo>,
1202 pub dhcp6pd_info: Option<Dhcp6PdInfo>,
1206 pub link_metrics_entries: Option<Vec<LinkMetricsEntry>>,
1210 #[doc(hidden)]
1211 pub __source_breaking: fidl::marker::SourceBreaking,
1212}
1213
1214impl fidl::Persistable for Telemetry {}
1215
1216#[derive(Clone, Debug, Default, PartialEq)]
1220pub struct TrelCounters {
1221 pub rx_bytes: Option<u64>,
1223 pub rx_packets: Option<u64>,
1225 pub tx_bytes: Option<u64>,
1227 pub tx_failure: Option<u64>,
1229 pub tx_packets: Option<u64>,
1231 #[doc(hidden)]
1232 pub __source_breaking: fidl::marker::SourceBreaking,
1233}
1234
1235impl fidl::Persistable for TrelCounters {}
1236
1237#[derive(Clone, Debug, Default, PartialEq)]
1242pub struct TrelPeersInfo {
1243 pub num_trel_peers: Option<u16>,
1247 #[doc(hidden)]
1248 pub __source_breaking: fidl::marker::SourceBreaking,
1249}
1250
1251impl fidl::Persistable for TrelPeersInfo {}
1252
1253#[derive(Clone, Debug, Default, PartialEq)]
1257pub struct UpstreamDnsCounters {
1258 pub queries: Option<u32>,
1262 pub responses: Option<u32>,
1266 pub failures: Option<u32>,
1270 #[doc(hidden)]
1271 pub __source_breaking: fidl::marker::SourceBreaking,
1272}
1273
1274impl fidl::Persistable for UpstreamDnsCounters {}
1275
1276#[derive(Clone, Debug, Default, PartialEq)]
1281pub struct UpstreamDnsInfo {
1282 pub upstream_dns_query_state: Option<UpstreamDnsQueryState>,
1286 #[doc(hidden)]
1287 pub __source_breaking: fidl::marker::SourceBreaking,
1288}
1289
1290impl fidl::Persistable for UpstreamDnsInfo {}
1291
1292#[derive(Clone, Debug)]
1294pub enum JoinParams {
1295 ProvisioningParameter(fidl_fuchsia_lowpan_device__common::ProvisioningParams),
1297 JoinerParameter(JoinerCommissioningParams),
1303 #[doc(hidden)]
1304 __SourceBreaking { unknown_ordinal: u64 },
1305}
1306
1307#[macro_export]
1309macro_rules! JoinParamsUnknown {
1310 () => {
1311 _
1312 };
1313}
1314
1315impl PartialEq for JoinParams {
1317 fn eq(&self, other: &Self) -> bool {
1318 match (self, other) {
1319 (Self::ProvisioningParameter(x), Self::ProvisioningParameter(y)) => *x == *y,
1320 (Self::JoinerParameter(x), Self::JoinerParameter(y)) => *x == *y,
1321 _ => false,
1322 }
1323 }
1324}
1325
1326impl JoinParams {
1327 #[inline]
1328 pub fn ordinal(&self) -> u64 {
1329 match *self {
1330 Self::ProvisioningParameter(_) => 1,
1331 Self::JoinerParameter(_) => 2,
1332 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1333 }
1334 }
1335
1336 #[inline]
1337 pub fn unknown_variant_for_testing() -> Self {
1338 Self::__SourceBreaking { unknown_ordinal: 0 }
1339 }
1340
1341 #[inline]
1342 pub fn is_unknown(&self) -> bool {
1343 match self {
1344 Self::__SourceBreaking { .. } => true,
1345 _ => false,
1346 }
1347 }
1348}
1349
1350impl fidl::Persistable for JoinParams {}
1351
1352#[derive(Clone, Debug)]
1356pub enum ProvisioningProgress {
1357 Progress(f32),
1359 Identity(fidl_fuchsia_lowpan_device__common::Identity),
1361 #[doc(hidden)]
1362 __SourceBreaking { unknown_ordinal: u64 },
1363}
1364
1365#[macro_export]
1367macro_rules! ProvisioningProgressUnknown {
1368 () => {
1369 _
1370 };
1371}
1372
1373impl PartialEq for ProvisioningProgress {
1375 fn eq(&self, other: &Self) -> bool {
1376 match (self, other) {
1377 (Self::Progress(x), Self::Progress(y)) => *x == *y,
1378 (Self::Identity(x), Self::Identity(y)) => *x == *y,
1379 _ => false,
1380 }
1381 }
1382}
1383
1384impl ProvisioningProgress {
1385 #[inline]
1386 pub fn ordinal(&self) -> u64 {
1387 match *self {
1388 Self::Progress(_) => 1,
1389 Self::Identity(_) => 2,
1390 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1391 }
1392 }
1393
1394 #[inline]
1395 pub fn unknown_variant_for_testing() -> Self {
1396 Self::__SourceBreaking { unknown_ordinal: 0 }
1397 }
1398
1399 #[inline]
1400 pub fn is_unknown(&self) -> bool {
1401 match self {
1402 Self::__SourceBreaking { .. } => true,
1403 _ => false,
1404 }
1405 }
1406}
1407
1408impl fidl::Persistable for ProvisioningProgress {}
1409
1410pub mod beacon_info_stream_ordinals {
1411 pub const NEXT: u64 = 0x367a557363a340b6;
1412}
1413
1414pub mod device_ordinals {
1415 pub const GET_SUPPORTED_CHANNELS: u64 = 0x2d8b969a9bd70f23;
1416}
1417
1418pub mod device_connector_ordinals {
1419 pub const CONNECT: u64 = 0x296896c9304836cd;
1420}
1421
1422pub mod device_extra_ordinals {
1423 pub const FORM_NETWORK: u64 = 0x6a8135f84bfc90e;
1424 pub const JOIN_NETWORK: u64 = 0x3ea583bab79f81c0;
1425 pub const START_NETWORK_SCAN: u64 = 0x6288c73b79188b40;
1426}
1427
1428pub mod device_extra_connector_ordinals {
1429 pub const CONNECT: u64 = 0x3fcb37e4226c81e9;
1430}
1431
1432pub mod device_route_ordinals {
1433 pub const REGISTER_ON_MESH_PREFIX: u64 = 0x2c4135231eb97f61;
1434 pub const UNREGISTER_ON_MESH_PREFIX: u64 = 0x82d5184028b797f;
1435 pub const REGISTER_EXTERNAL_ROUTE: u64 = 0x75f70f0fc34a5a73;
1436 pub const UNREGISTER_EXTERNAL_ROUTE: u64 = 0x3769be353b1d7088;
1437}
1438
1439pub mod device_route_connector_ordinals {
1440 pub const CONNECT: u64 = 0x19cd5fdcb971f4ac;
1441}
1442
1443pub mod device_route_extra_ordinals {
1444 pub const GET_LOCAL_ON_MESH_PREFIXES: u64 = 0xf192c43311c811;
1445 pub const GET_LOCAL_EXTERNAL_ROUTES: u64 = 0x5a688c2e62c766a6;
1446}
1447
1448pub mod device_route_extra_connector_ordinals {
1449 pub const CONNECT: u64 = 0x12f72df7b1348fe2;
1450}
1451
1452pub mod legacy_joining_ordinals {
1453 pub const MAKE_JOINABLE: u64 = 0x1739a6ae36d5c5aa;
1454}
1455
1456pub mod legacy_joining_connector_ordinals {
1457 pub const CONNECT: u64 = 0x3c8dfeb943bb8d06;
1458}
1459
1460pub mod provisioning_monitor_ordinals {
1461 pub const WATCH_PROGRESS: u64 = 0xc35336fc43ac0c;
1462}
1463
1464pub mod telemetry_provider_ordinals {
1465 pub const GET_TELEMETRY: u64 = 0xc34f2fff7dacc41;
1466}
1467
1468pub mod telemetry_provider_connector_ordinals {
1469 pub const CONNECT: u64 = 0x24a5bf1be73e2fad;
1470}
1471
1472mod internal {
1473 use super::*;
1474 unsafe impl fidl::encoding::TypeMarker for Dhcp6PdState {
1475 type Owned = Self;
1476
1477 #[inline(always)]
1478 fn inline_align(_context: fidl::encoding::Context) -> usize {
1479 std::mem::align_of::<u32>()
1480 }
1481
1482 #[inline(always)]
1483 fn inline_size(_context: fidl::encoding::Context) -> usize {
1484 std::mem::size_of::<u32>()
1485 }
1486
1487 #[inline(always)]
1488 fn encode_is_copy() -> bool {
1489 false
1490 }
1491
1492 #[inline(always)]
1493 fn decode_is_copy() -> bool {
1494 false
1495 }
1496 }
1497
1498 impl fidl::encoding::ValueTypeMarker for Dhcp6PdState {
1499 type Borrowed<'a> = Self;
1500 #[inline(always)]
1501 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1502 *value
1503 }
1504 }
1505
1506 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Dhcp6PdState {
1507 #[inline]
1508 unsafe fn encode(
1509 self,
1510 encoder: &mut fidl::encoding::Encoder<'_, D>,
1511 offset: usize,
1512 _depth: fidl::encoding::Depth,
1513 ) -> fidl::Result<()> {
1514 encoder.debug_check_bounds::<Self>(offset);
1515 encoder.write_num(self.into_primitive(), offset);
1516 Ok(())
1517 }
1518 }
1519
1520 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dhcp6PdState {
1521 #[inline(always)]
1522 fn new_empty() -> Self {
1523 Self::unknown()
1524 }
1525
1526 #[inline]
1527 unsafe fn decode(
1528 &mut self,
1529 decoder: &mut fidl::encoding::Decoder<'_, D>,
1530 offset: usize,
1531 _depth: fidl::encoding::Depth,
1532 ) -> fidl::Result<()> {
1533 decoder.debug_check_bounds::<Self>(offset);
1534 let prim = decoder.read_num::<u32>(offset);
1535
1536 *self = Self::from_primitive_allow_unknown(prim);
1537 Ok(())
1538 }
1539 }
1540 unsafe impl fidl::encoding::TypeMarker for Nat64State {
1541 type Owned = Self;
1542
1543 #[inline(always)]
1544 fn inline_align(_context: fidl::encoding::Context) -> usize {
1545 std::mem::align_of::<u32>()
1546 }
1547
1548 #[inline(always)]
1549 fn inline_size(_context: fidl::encoding::Context) -> usize {
1550 std::mem::size_of::<u32>()
1551 }
1552
1553 #[inline(always)]
1554 fn encode_is_copy() -> bool {
1555 false
1556 }
1557
1558 #[inline(always)]
1559 fn decode_is_copy() -> bool {
1560 false
1561 }
1562 }
1563
1564 impl fidl::encoding::ValueTypeMarker for Nat64State {
1565 type Borrowed<'a> = Self;
1566 #[inline(always)]
1567 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1568 *value
1569 }
1570 }
1571
1572 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Nat64State {
1573 #[inline]
1574 unsafe fn encode(
1575 self,
1576 encoder: &mut fidl::encoding::Encoder<'_, D>,
1577 offset: usize,
1578 _depth: fidl::encoding::Depth,
1579 ) -> fidl::Result<()> {
1580 encoder.debug_check_bounds::<Self>(offset);
1581 encoder.write_num(self.into_primitive(), offset);
1582 Ok(())
1583 }
1584 }
1585
1586 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64State {
1587 #[inline(always)]
1588 fn new_empty() -> Self {
1589 Self::unknown()
1590 }
1591
1592 #[inline]
1593 unsafe fn decode(
1594 &mut self,
1595 decoder: &mut fidl::encoding::Decoder<'_, D>,
1596 offset: usize,
1597 _depth: fidl::encoding::Depth,
1598 ) -> fidl::Result<()> {
1599 decoder.debug_check_bounds::<Self>(offset);
1600 let prim = decoder.read_num::<u32>(offset);
1601
1602 *self = Self::from_primitive_allow_unknown(prim);
1603 Ok(())
1604 }
1605 }
1606 unsafe impl fidl::encoding::TypeMarker for ProvisionError {
1607 type Owned = Self;
1608
1609 #[inline(always)]
1610 fn inline_align(_context: fidl::encoding::Context) -> usize {
1611 std::mem::align_of::<i32>()
1612 }
1613
1614 #[inline(always)]
1615 fn inline_size(_context: fidl::encoding::Context) -> usize {
1616 std::mem::size_of::<i32>()
1617 }
1618
1619 #[inline(always)]
1620 fn encode_is_copy() -> bool {
1621 false
1622 }
1623
1624 #[inline(always)]
1625 fn decode_is_copy() -> bool {
1626 false
1627 }
1628 }
1629
1630 impl fidl::encoding::ValueTypeMarker for ProvisionError {
1631 type Borrowed<'a> = Self;
1632 #[inline(always)]
1633 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1634 *value
1635 }
1636 }
1637
1638 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ProvisionError {
1639 #[inline]
1640 unsafe fn encode(
1641 self,
1642 encoder: &mut fidl::encoding::Encoder<'_, D>,
1643 offset: usize,
1644 _depth: fidl::encoding::Depth,
1645 ) -> fidl::Result<()> {
1646 encoder.debug_check_bounds::<Self>(offset);
1647 encoder.write_num(self.into_primitive(), offset);
1648 Ok(())
1649 }
1650 }
1651
1652 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisionError {
1653 #[inline(always)]
1654 fn new_empty() -> Self {
1655 Self::unknown()
1656 }
1657
1658 #[inline]
1659 unsafe fn decode(
1660 &mut self,
1661 decoder: &mut fidl::encoding::Decoder<'_, D>,
1662 offset: usize,
1663 _depth: fidl::encoding::Depth,
1664 ) -> fidl::Result<()> {
1665 decoder.debug_check_bounds::<Self>(offset);
1666 let prim = decoder.read_num::<i32>(offset);
1667
1668 *self = Self::from_primitive_allow_unknown(prim);
1669 Ok(())
1670 }
1671 }
1672 unsafe impl fidl::encoding::TypeMarker for RoutePreference {
1673 type Owned = Self;
1674
1675 #[inline(always)]
1676 fn inline_align(_context: fidl::encoding::Context) -> usize {
1677 std::mem::align_of::<i8>()
1678 }
1679
1680 #[inline(always)]
1681 fn inline_size(_context: fidl::encoding::Context) -> usize {
1682 std::mem::size_of::<i8>()
1683 }
1684
1685 #[inline(always)]
1686 fn encode_is_copy() -> bool {
1687 true
1688 }
1689
1690 #[inline(always)]
1691 fn decode_is_copy() -> bool {
1692 false
1693 }
1694 }
1695
1696 impl fidl::encoding::ValueTypeMarker for RoutePreference {
1697 type Borrowed<'a> = Self;
1698 #[inline(always)]
1699 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1700 *value
1701 }
1702 }
1703
1704 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1705 for RoutePreference
1706 {
1707 #[inline]
1708 unsafe fn encode(
1709 self,
1710 encoder: &mut fidl::encoding::Encoder<'_, D>,
1711 offset: usize,
1712 _depth: fidl::encoding::Depth,
1713 ) -> fidl::Result<()> {
1714 encoder.debug_check_bounds::<Self>(offset);
1715 encoder.write_num(self.into_primitive(), offset);
1716 Ok(())
1717 }
1718 }
1719
1720 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoutePreference {
1721 #[inline(always)]
1722 fn new_empty() -> Self {
1723 Self::Low
1724 }
1725
1726 #[inline]
1727 unsafe fn decode(
1728 &mut self,
1729 decoder: &mut fidl::encoding::Decoder<'_, D>,
1730 offset: usize,
1731 _depth: fidl::encoding::Depth,
1732 ) -> fidl::Result<()> {
1733 decoder.debug_check_bounds::<Self>(offset);
1734 let prim = decoder.read_num::<i8>(offset);
1735
1736 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1737 Ok(())
1738 }
1739 }
1740 unsafe impl fidl::encoding::TypeMarker for SrpServerAddressMode {
1741 type Owned = Self;
1742
1743 #[inline(always)]
1744 fn inline_align(_context: fidl::encoding::Context) -> usize {
1745 std::mem::align_of::<u32>()
1746 }
1747
1748 #[inline(always)]
1749 fn inline_size(_context: fidl::encoding::Context) -> usize {
1750 std::mem::size_of::<u32>()
1751 }
1752
1753 #[inline(always)]
1754 fn encode_is_copy() -> bool {
1755 true
1756 }
1757
1758 #[inline(always)]
1759 fn decode_is_copy() -> bool {
1760 false
1761 }
1762 }
1763
1764 impl fidl::encoding::ValueTypeMarker for SrpServerAddressMode {
1765 type Borrowed<'a> = Self;
1766 #[inline(always)]
1767 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1768 *value
1769 }
1770 }
1771
1772 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1773 for SrpServerAddressMode
1774 {
1775 #[inline]
1776 unsafe fn encode(
1777 self,
1778 encoder: &mut fidl::encoding::Encoder<'_, D>,
1779 offset: usize,
1780 _depth: fidl::encoding::Depth,
1781 ) -> fidl::Result<()> {
1782 encoder.debug_check_bounds::<Self>(offset);
1783 encoder.write_num(self.into_primitive(), offset);
1784 Ok(())
1785 }
1786 }
1787
1788 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerAddressMode {
1789 #[inline(always)]
1790 fn new_empty() -> Self {
1791 Self::Unicast
1792 }
1793
1794 #[inline]
1795 unsafe fn decode(
1796 &mut self,
1797 decoder: &mut fidl::encoding::Decoder<'_, D>,
1798 offset: usize,
1799 _depth: fidl::encoding::Depth,
1800 ) -> fidl::Result<()> {
1801 decoder.debug_check_bounds::<Self>(offset);
1802 let prim = decoder.read_num::<u32>(offset);
1803
1804 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1805 Ok(())
1806 }
1807 }
1808 unsafe impl fidl::encoding::TypeMarker for SrpServerState {
1809 type Owned = Self;
1810
1811 #[inline(always)]
1812 fn inline_align(_context: fidl::encoding::Context) -> usize {
1813 std::mem::align_of::<u32>()
1814 }
1815
1816 #[inline(always)]
1817 fn inline_size(_context: fidl::encoding::Context) -> usize {
1818 std::mem::size_of::<u32>()
1819 }
1820
1821 #[inline(always)]
1822 fn encode_is_copy() -> bool {
1823 true
1824 }
1825
1826 #[inline(always)]
1827 fn decode_is_copy() -> bool {
1828 false
1829 }
1830 }
1831
1832 impl fidl::encoding::ValueTypeMarker for SrpServerState {
1833 type Borrowed<'a> = Self;
1834 #[inline(always)]
1835 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1836 *value
1837 }
1838 }
1839
1840 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SrpServerState {
1841 #[inline]
1842 unsafe fn encode(
1843 self,
1844 encoder: &mut fidl::encoding::Encoder<'_, D>,
1845 offset: usize,
1846 _depth: fidl::encoding::Depth,
1847 ) -> fidl::Result<()> {
1848 encoder.debug_check_bounds::<Self>(offset);
1849 encoder.write_num(self.into_primitive(), offset);
1850 Ok(())
1851 }
1852 }
1853
1854 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerState {
1855 #[inline(always)]
1856 fn new_empty() -> Self {
1857 Self::Disabled
1858 }
1859
1860 #[inline]
1861 unsafe fn decode(
1862 &mut self,
1863 decoder: &mut fidl::encoding::Decoder<'_, D>,
1864 offset: usize,
1865 _depth: fidl::encoding::Depth,
1866 ) -> fidl::Result<()> {
1867 decoder.debug_check_bounds::<Self>(offset);
1868 let prim = decoder.read_num::<u32>(offset);
1869
1870 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1871 Ok(())
1872 }
1873 }
1874 unsafe impl fidl::encoding::TypeMarker for UpstreamDnsQueryState {
1875 type Owned = Self;
1876
1877 #[inline(always)]
1878 fn inline_align(_context: fidl::encoding::Context) -> usize {
1879 std::mem::align_of::<u32>()
1880 }
1881
1882 #[inline(always)]
1883 fn inline_size(_context: fidl::encoding::Context) -> usize {
1884 std::mem::size_of::<u32>()
1885 }
1886
1887 #[inline(always)]
1888 fn encode_is_copy() -> bool {
1889 false
1890 }
1891
1892 #[inline(always)]
1893 fn decode_is_copy() -> bool {
1894 false
1895 }
1896 }
1897
1898 impl fidl::encoding::ValueTypeMarker for UpstreamDnsQueryState {
1899 type Borrowed<'a> = Self;
1900 #[inline(always)]
1901 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1902 *value
1903 }
1904 }
1905
1906 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1907 for UpstreamDnsQueryState
1908 {
1909 #[inline]
1910 unsafe fn encode(
1911 self,
1912 encoder: &mut fidl::encoding::Encoder<'_, D>,
1913 offset: usize,
1914 _depth: fidl::encoding::Depth,
1915 ) -> fidl::Result<()> {
1916 encoder.debug_check_bounds::<Self>(offset);
1917 encoder.write_num(self.into_primitive(), offset);
1918 Ok(())
1919 }
1920 }
1921
1922 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsQueryState {
1923 #[inline(always)]
1924 fn new_empty() -> Self {
1925 Self::unknown()
1926 }
1927
1928 #[inline]
1929 unsafe fn decode(
1930 &mut self,
1931 decoder: &mut fidl::encoding::Decoder<'_, D>,
1932 offset: usize,
1933 _depth: fidl::encoding::Depth,
1934 ) -> fidl::Result<()> {
1935 decoder.debug_check_bounds::<Self>(offset);
1936 let prim = decoder.read_num::<u32>(offset);
1937
1938 *self = Self::from_primitive_allow_unknown(prim);
1939 Ok(())
1940 }
1941 }
1942
1943 impl fidl::encoding::ValueTypeMarker for BeaconInfoStreamNextResponse {
1944 type Borrowed<'a> = &'a Self;
1945 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1946 value
1947 }
1948 }
1949
1950 unsafe impl fidl::encoding::TypeMarker for BeaconInfoStreamNextResponse {
1951 type Owned = Self;
1952
1953 #[inline(always)]
1954 fn inline_align(_context: fidl::encoding::Context) -> usize {
1955 8
1956 }
1957
1958 #[inline(always)]
1959 fn inline_size(_context: fidl::encoding::Context) -> usize {
1960 16
1961 }
1962 }
1963
1964 unsafe impl<D: fidl::encoding::ResourceDialect>
1965 fidl::encoding::Encode<BeaconInfoStreamNextResponse, D> for &BeaconInfoStreamNextResponse
1966 {
1967 #[inline]
1968 unsafe fn encode(
1969 self,
1970 encoder: &mut fidl::encoding::Encoder<'_, D>,
1971 offset: usize,
1972 _depth: fidl::encoding::Depth,
1973 ) -> fidl::Result<()> {
1974 encoder.debug_check_bounds::<BeaconInfoStreamNextResponse>(offset);
1975 fidl::encoding::Encode::<BeaconInfoStreamNextResponse, D>::encode(
1977 (
1978 <fidl::encoding::Vector<BeaconInfo, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.beacons),
1979 ),
1980 encoder, offset, _depth
1981 )
1982 }
1983 }
1984 unsafe impl<
1985 D: fidl::encoding::ResourceDialect,
1986 T0: fidl::encoding::Encode<fidl::encoding::Vector<BeaconInfo, 32>, D>,
1987 > fidl::encoding::Encode<BeaconInfoStreamNextResponse, D> for (T0,)
1988 {
1989 #[inline]
1990 unsafe fn encode(
1991 self,
1992 encoder: &mut fidl::encoding::Encoder<'_, D>,
1993 offset: usize,
1994 depth: fidl::encoding::Depth,
1995 ) -> fidl::Result<()> {
1996 encoder.debug_check_bounds::<BeaconInfoStreamNextResponse>(offset);
1997 self.0.encode(encoder, offset + 0, depth)?;
2001 Ok(())
2002 }
2003 }
2004
2005 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2006 for BeaconInfoStreamNextResponse
2007 {
2008 #[inline(always)]
2009 fn new_empty() -> Self {
2010 Self { beacons: fidl::new_empty!(fidl::encoding::Vector<BeaconInfo, 32>, D) }
2011 }
2012
2013 #[inline]
2014 unsafe fn decode(
2015 &mut self,
2016 decoder: &mut fidl::encoding::Decoder<'_, D>,
2017 offset: usize,
2018 _depth: fidl::encoding::Depth,
2019 ) -> fidl::Result<()> {
2020 decoder.debug_check_bounds::<Self>(offset);
2021 fidl::decode!(fidl::encoding::Vector<BeaconInfo, 32>, D, &mut self.beacons, decoder, offset + 0, _depth)?;
2023 Ok(())
2024 }
2025 }
2026
2027 impl fidl::encoding::ValueTypeMarker for DeviceGetSupportedChannelsResponse {
2028 type Borrowed<'a> = &'a Self;
2029 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2030 value
2031 }
2032 }
2033
2034 unsafe impl fidl::encoding::TypeMarker for DeviceGetSupportedChannelsResponse {
2035 type Owned = Self;
2036
2037 #[inline(always)]
2038 fn inline_align(_context: fidl::encoding::Context) -> usize {
2039 8
2040 }
2041
2042 #[inline(always)]
2043 fn inline_size(_context: fidl::encoding::Context) -> usize {
2044 16
2045 }
2046 }
2047
2048 unsafe impl<D: fidl::encoding::ResourceDialect>
2049 fidl::encoding::Encode<DeviceGetSupportedChannelsResponse, D>
2050 for &DeviceGetSupportedChannelsResponse
2051 {
2052 #[inline]
2053 unsafe fn encode(
2054 self,
2055 encoder: &mut fidl::encoding::Encoder<'_, D>,
2056 offset: usize,
2057 _depth: fidl::encoding::Depth,
2058 ) -> fidl::Result<()> {
2059 encoder.debug_check_bounds::<DeviceGetSupportedChannelsResponse>(offset);
2060 fidl::encoding::Encode::<DeviceGetSupportedChannelsResponse, D>::encode(
2062 (
2063 <fidl::encoding::Vector<ChannelInfo, 200> as fidl::encoding::ValueTypeMarker>::borrow(&self.channels_info),
2064 ),
2065 encoder, offset, _depth
2066 )
2067 }
2068 }
2069 unsafe impl<
2070 D: fidl::encoding::ResourceDialect,
2071 T0: fidl::encoding::Encode<fidl::encoding::Vector<ChannelInfo, 200>, D>,
2072 > fidl::encoding::Encode<DeviceGetSupportedChannelsResponse, D> for (T0,)
2073 {
2074 #[inline]
2075 unsafe fn encode(
2076 self,
2077 encoder: &mut fidl::encoding::Encoder<'_, D>,
2078 offset: usize,
2079 depth: fidl::encoding::Depth,
2080 ) -> fidl::Result<()> {
2081 encoder.debug_check_bounds::<DeviceGetSupportedChannelsResponse>(offset);
2082 self.0.encode(encoder, offset + 0, depth)?;
2086 Ok(())
2087 }
2088 }
2089
2090 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2091 for DeviceGetSupportedChannelsResponse
2092 {
2093 #[inline(always)]
2094 fn new_empty() -> Self {
2095 Self { channels_info: fidl::new_empty!(fidl::encoding::Vector<ChannelInfo, 200>, D) }
2096 }
2097
2098 #[inline]
2099 unsafe fn decode(
2100 &mut self,
2101 decoder: &mut fidl::encoding::Decoder<'_, D>,
2102 offset: usize,
2103 _depth: fidl::encoding::Depth,
2104 ) -> fidl::Result<()> {
2105 decoder.debug_check_bounds::<Self>(offset);
2106 fidl::decode!(fidl::encoding::Vector<ChannelInfo, 200>, D, &mut self.channels_info, decoder, offset + 0, _depth)?;
2108 Ok(())
2109 }
2110 }
2111
2112 impl fidl::encoding::ValueTypeMarker for DeviceRouteExtraGetLocalExternalRoutesResponse {
2113 type Borrowed<'a> = &'a Self;
2114 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2115 value
2116 }
2117 }
2118
2119 unsafe impl fidl::encoding::TypeMarker for DeviceRouteExtraGetLocalExternalRoutesResponse {
2120 type Owned = Self;
2121
2122 #[inline(always)]
2123 fn inline_align(_context: fidl::encoding::Context) -> usize {
2124 8
2125 }
2126
2127 #[inline(always)]
2128 fn inline_size(_context: fidl::encoding::Context) -> usize {
2129 16
2130 }
2131 }
2132
2133 unsafe impl<D: fidl::encoding::ResourceDialect>
2134 fidl::encoding::Encode<DeviceRouteExtraGetLocalExternalRoutesResponse, D>
2135 for &DeviceRouteExtraGetLocalExternalRoutesResponse
2136 {
2137 #[inline]
2138 unsafe fn encode(
2139 self,
2140 encoder: &mut fidl::encoding::Encoder<'_, D>,
2141 offset: usize,
2142 _depth: fidl::encoding::Depth,
2143 ) -> fidl::Result<()> {
2144 encoder.debug_check_bounds::<DeviceRouteExtraGetLocalExternalRoutesResponse>(offset);
2145 fidl::encoding::Encode::<DeviceRouteExtraGetLocalExternalRoutesResponse, D>::encode(
2147 (
2148 <fidl::encoding::Vector<ExternalRoute, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.external_routes),
2149 ),
2150 encoder, offset, _depth
2151 )
2152 }
2153 }
2154 unsafe impl<
2155 D: fidl::encoding::ResourceDialect,
2156 T0: fidl::encoding::Encode<fidl::encoding::Vector<ExternalRoute, 32>, D>,
2157 > fidl::encoding::Encode<DeviceRouteExtraGetLocalExternalRoutesResponse, D> for (T0,)
2158 {
2159 #[inline]
2160 unsafe fn encode(
2161 self,
2162 encoder: &mut fidl::encoding::Encoder<'_, D>,
2163 offset: usize,
2164 depth: fidl::encoding::Depth,
2165 ) -> fidl::Result<()> {
2166 encoder.debug_check_bounds::<DeviceRouteExtraGetLocalExternalRoutesResponse>(offset);
2167 self.0.encode(encoder, offset + 0, depth)?;
2171 Ok(())
2172 }
2173 }
2174
2175 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2176 for DeviceRouteExtraGetLocalExternalRoutesResponse
2177 {
2178 #[inline(always)]
2179 fn new_empty() -> Self {
2180 Self { external_routes: fidl::new_empty!(fidl::encoding::Vector<ExternalRoute, 32>, D) }
2181 }
2182
2183 #[inline]
2184 unsafe fn decode(
2185 &mut self,
2186 decoder: &mut fidl::encoding::Decoder<'_, D>,
2187 offset: usize,
2188 _depth: fidl::encoding::Depth,
2189 ) -> fidl::Result<()> {
2190 decoder.debug_check_bounds::<Self>(offset);
2191 fidl::decode!(fidl::encoding::Vector<ExternalRoute, 32>, D, &mut self.external_routes, decoder, offset + 0, _depth)?;
2193 Ok(())
2194 }
2195 }
2196
2197 impl fidl::encoding::ValueTypeMarker for DeviceRouteExtraGetLocalOnMeshPrefixesResponse {
2198 type Borrowed<'a> = &'a Self;
2199 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2200 value
2201 }
2202 }
2203
2204 unsafe impl fidl::encoding::TypeMarker for DeviceRouteExtraGetLocalOnMeshPrefixesResponse {
2205 type Owned = Self;
2206
2207 #[inline(always)]
2208 fn inline_align(_context: fidl::encoding::Context) -> usize {
2209 8
2210 }
2211
2212 #[inline(always)]
2213 fn inline_size(_context: fidl::encoding::Context) -> usize {
2214 16
2215 }
2216 }
2217
2218 unsafe impl<D: fidl::encoding::ResourceDialect>
2219 fidl::encoding::Encode<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D>
2220 for &DeviceRouteExtraGetLocalOnMeshPrefixesResponse
2221 {
2222 #[inline]
2223 unsafe fn encode(
2224 self,
2225 encoder: &mut fidl::encoding::Encoder<'_, D>,
2226 offset: usize,
2227 _depth: fidl::encoding::Depth,
2228 ) -> fidl::Result<()> {
2229 encoder.debug_check_bounds::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse>(offset);
2230 fidl::encoding::Encode::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D>::encode(
2232 (
2233 <fidl::encoding::Vector<OnMeshPrefix, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.prefixes),
2234 ),
2235 encoder, offset, _depth
2236 )
2237 }
2238 }
2239 unsafe impl<
2240 D: fidl::encoding::ResourceDialect,
2241 T0: fidl::encoding::Encode<fidl::encoding::Vector<OnMeshPrefix, 32>, D>,
2242 > fidl::encoding::Encode<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D> for (T0,)
2243 {
2244 #[inline]
2245 unsafe fn encode(
2246 self,
2247 encoder: &mut fidl::encoding::Encoder<'_, D>,
2248 offset: usize,
2249 depth: fidl::encoding::Depth,
2250 ) -> fidl::Result<()> {
2251 encoder.debug_check_bounds::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse>(offset);
2252 self.0.encode(encoder, offset + 0, depth)?;
2256 Ok(())
2257 }
2258 }
2259
2260 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2261 for DeviceRouteExtraGetLocalOnMeshPrefixesResponse
2262 {
2263 #[inline(always)]
2264 fn new_empty() -> Self {
2265 Self { prefixes: fidl::new_empty!(fidl::encoding::Vector<OnMeshPrefix, 32>, D) }
2266 }
2267
2268 #[inline]
2269 unsafe fn decode(
2270 &mut self,
2271 decoder: &mut fidl::encoding::Decoder<'_, D>,
2272 offset: usize,
2273 _depth: fidl::encoding::Depth,
2274 ) -> fidl::Result<()> {
2275 decoder.debug_check_bounds::<Self>(offset);
2276 fidl::decode!(fidl::encoding::Vector<OnMeshPrefix, 32>, D, &mut self.prefixes, decoder, offset + 0, _depth)?;
2278 Ok(())
2279 }
2280 }
2281
2282 impl fidl::encoding::ValueTypeMarker for DeviceRouteRegisterExternalRouteRequest {
2283 type Borrowed<'a> = &'a Self;
2284 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2285 value
2286 }
2287 }
2288
2289 unsafe impl fidl::encoding::TypeMarker for DeviceRouteRegisterExternalRouteRequest {
2290 type Owned = Self;
2291
2292 #[inline(always)]
2293 fn inline_align(_context: fidl::encoding::Context) -> usize {
2294 8
2295 }
2296
2297 #[inline(always)]
2298 fn inline_size(_context: fidl::encoding::Context) -> usize {
2299 16
2300 }
2301 }
2302
2303 unsafe impl<D: fidl::encoding::ResourceDialect>
2304 fidl::encoding::Encode<DeviceRouteRegisterExternalRouteRequest, D>
2305 for &DeviceRouteRegisterExternalRouteRequest
2306 {
2307 #[inline]
2308 unsafe fn encode(
2309 self,
2310 encoder: &mut fidl::encoding::Encoder<'_, D>,
2311 offset: usize,
2312 _depth: fidl::encoding::Depth,
2313 ) -> fidl::Result<()> {
2314 encoder.debug_check_bounds::<DeviceRouteRegisterExternalRouteRequest>(offset);
2315 fidl::encoding::Encode::<DeviceRouteRegisterExternalRouteRequest, D>::encode(
2317 (<ExternalRoute as fidl::encoding::ValueTypeMarker>::borrow(&self.external_route),),
2318 encoder,
2319 offset,
2320 _depth,
2321 )
2322 }
2323 }
2324 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ExternalRoute, D>>
2325 fidl::encoding::Encode<DeviceRouteRegisterExternalRouteRequest, D> for (T0,)
2326 {
2327 #[inline]
2328 unsafe fn encode(
2329 self,
2330 encoder: &mut fidl::encoding::Encoder<'_, D>,
2331 offset: usize,
2332 depth: fidl::encoding::Depth,
2333 ) -> fidl::Result<()> {
2334 encoder.debug_check_bounds::<DeviceRouteRegisterExternalRouteRequest>(offset);
2335 self.0.encode(encoder, offset + 0, depth)?;
2339 Ok(())
2340 }
2341 }
2342
2343 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2344 for DeviceRouteRegisterExternalRouteRequest
2345 {
2346 #[inline(always)]
2347 fn new_empty() -> Self {
2348 Self { external_route: fidl::new_empty!(ExternalRoute, D) }
2349 }
2350
2351 #[inline]
2352 unsafe fn decode(
2353 &mut self,
2354 decoder: &mut fidl::encoding::Decoder<'_, D>,
2355 offset: usize,
2356 _depth: fidl::encoding::Depth,
2357 ) -> fidl::Result<()> {
2358 decoder.debug_check_bounds::<Self>(offset);
2359 fidl::decode!(ExternalRoute, D, &mut self.external_route, decoder, offset + 0, _depth)?;
2361 Ok(())
2362 }
2363 }
2364
2365 impl fidl::encoding::ValueTypeMarker for DeviceRouteRegisterOnMeshPrefixRequest {
2366 type Borrowed<'a> = &'a Self;
2367 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2368 value
2369 }
2370 }
2371
2372 unsafe impl fidl::encoding::TypeMarker for DeviceRouteRegisterOnMeshPrefixRequest {
2373 type Owned = Self;
2374
2375 #[inline(always)]
2376 fn inline_align(_context: fidl::encoding::Context) -> usize {
2377 8
2378 }
2379
2380 #[inline(always)]
2381 fn inline_size(_context: fidl::encoding::Context) -> usize {
2382 16
2383 }
2384 }
2385
2386 unsafe impl<D: fidl::encoding::ResourceDialect>
2387 fidl::encoding::Encode<DeviceRouteRegisterOnMeshPrefixRequest, D>
2388 for &DeviceRouteRegisterOnMeshPrefixRequest
2389 {
2390 #[inline]
2391 unsafe fn encode(
2392 self,
2393 encoder: &mut fidl::encoding::Encoder<'_, D>,
2394 offset: usize,
2395 _depth: fidl::encoding::Depth,
2396 ) -> fidl::Result<()> {
2397 encoder.debug_check_bounds::<DeviceRouteRegisterOnMeshPrefixRequest>(offset);
2398 fidl::encoding::Encode::<DeviceRouteRegisterOnMeshPrefixRequest, D>::encode(
2400 (<OnMeshPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.prefix),),
2401 encoder,
2402 offset,
2403 _depth,
2404 )
2405 }
2406 }
2407 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<OnMeshPrefix, D>>
2408 fidl::encoding::Encode<DeviceRouteRegisterOnMeshPrefixRequest, D> for (T0,)
2409 {
2410 #[inline]
2411 unsafe fn encode(
2412 self,
2413 encoder: &mut fidl::encoding::Encoder<'_, D>,
2414 offset: usize,
2415 depth: fidl::encoding::Depth,
2416 ) -> fidl::Result<()> {
2417 encoder.debug_check_bounds::<DeviceRouteRegisterOnMeshPrefixRequest>(offset);
2418 self.0.encode(encoder, offset + 0, depth)?;
2422 Ok(())
2423 }
2424 }
2425
2426 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2427 for DeviceRouteRegisterOnMeshPrefixRequest
2428 {
2429 #[inline(always)]
2430 fn new_empty() -> Self {
2431 Self { prefix: fidl::new_empty!(OnMeshPrefix, D) }
2432 }
2433
2434 #[inline]
2435 unsafe fn decode(
2436 &mut self,
2437 decoder: &mut fidl::encoding::Decoder<'_, D>,
2438 offset: usize,
2439 _depth: fidl::encoding::Depth,
2440 ) -> fidl::Result<()> {
2441 decoder.debug_check_bounds::<Self>(offset);
2442 fidl::decode!(OnMeshPrefix, D, &mut self.prefix, decoder, offset + 0, _depth)?;
2444 Ok(())
2445 }
2446 }
2447
2448 impl fidl::encoding::ValueTypeMarker for DeviceRouteUnregisterExternalRouteRequest {
2449 type Borrowed<'a> = &'a Self;
2450 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2451 value
2452 }
2453 }
2454
2455 unsafe impl fidl::encoding::TypeMarker for DeviceRouteUnregisterExternalRouteRequest {
2456 type Owned = Self;
2457
2458 #[inline(always)]
2459 fn inline_align(_context: fidl::encoding::Context) -> usize {
2460 1
2461 }
2462
2463 #[inline(always)]
2464 fn inline_size(_context: fidl::encoding::Context) -> usize {
2465 17
2466 }
2467 }
2468
2469 unsafe impl<D: fidl::encoding::ResourceDialect>
2470 fidl::encoding::Encode<DeviceRouteUnregisterExternalRouteRequest, D>
2471 for &DeviceRouteUnregisterExternalRouteRequest
2472 {
2473 #[inline]
2474 unsafe fn encode(
2475 self,
2476 encoder: &mut fidl::encoding::Encoder<'_, D>,
2477 offset: usize,
2478 _depth: fidl::encoding::Depth,
2479 ) -> fidl::Result<()> {
2480 encoder.debug_check_bounds::<DeviceRouteUnregisterExternalRouteRequest>(offset);
2481 fidl::encoding::Encode::<DeviceRouteUnregisterExternalRouteRequest, D>::encode(
2483 (
2484 <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.subnet),
2485 ),
2486 encoder, offset, _depth
2487 )
2488 }
2489 }
2490 unsafe impl<
2491 D: fidl::encoding::ResourceDialect,
2492 T0: fidl::encoding::Encode<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>,
2493 > fidl::encoding::Encode<DeviceRouteUnregisterExternalRouteRequest, D> for (T0,)
2494 {
2495 #[inline]
2496 unsafe fn encode(
2497 self,
2498 encoder: &mut fidl::encoding::Encoder<'_, D>,
2499 offset: usize,
2500 depth: fidl::encoding::Depth,
2501 ) -> fidl::Result<()> {
2502 encoder.debug_check_bounds::<DeviceRouteUnregisterExternalRouteRequest>(offset);
2503 self.0.encode(encoder, offset + 0, depth)?;
2507 Ok(())
2508 }
2509 }
2510
2511 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2512 for DeviceRouteUnregisterExternalRouteRequest
2513 {
2514 #[inline(always)]
2515 fn new_empty() -> Self {
2516 Self { subnet: fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D) }
2517 }
2518
2519 #[inline]
2520 unsafe fn decode(
2521 &mut self,
2522 decoder: &mut fidl::encoding::Decoder<'_, D>,
2523 offset: usize,
2524 _depth: fidl::encoding::Depth,
2525 ) -> fidl::Result<()> {
2526 decoder.debug_check_bounds::<Self>(offset);
2527 fidl::decode!(
2529 fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
2530 D,
2531 &mut self.subnet,
2532 decoder,
2533 offset + 0,
2534 _depth
2535 )?;
2536 Ok(())
2537 }
2538 }
2539
2540 impl fidl::encoding::ValueTypeMarker for DeviceRouteUnregisterOnMeshPrefixRequest {
2541 type Borrowed<'a> = &'a Self;
2542 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2543 value
2544 }
2545 }
2546
2547 unsafe impl fidl::encoding::TypeMarker for DeviceRouteUnregisterOnMeshPrefixRequest {
2548 type Owned = Self;
2549
2550 #[inline(always)]
2551 fn inline_align(_context: fidl::encoding::Context) -> usize {
2552 1
2553 }
2554
2555 #[inline(always)]
2556 fn inline_size(_context: fidl::encoding::Context) -> usize {
2557 17
2558 }
2559 }
2560
2561 unsafe impl<D: fidl::encoding::ResourceDialect>
2562 fidl::encoding::Encode<DeviceRouteUnregisterOnMeshPrefixRequest, D>
2563 for &DeviceRouteUnregisterOnMeshPrefixRequest
2564 {
2565 #[inline]
2566 unsafe fn encode(
2567 self,
2568 encoder: &mut fidl::encoding::Encoder<'_, D>,
2569 offset: usize,
2570 _depth: fidl::encoding::Depth,
2571 ) -> fidl::Result<()> {
2572 encoder.debug_check_bounds::<DeviceRouteUnregisterOnMeshPrefixRequest>(offset);
2573 fidl::encoding::Encode::<DeviceRouteUnregisterOnMeshPrefixRequest, D>::encode(
2575 (
2576 <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.subnet),
2577 ),
2578 encoder, offset, _depth
2579 )
2580 }
2581 }
2582 unsafe impl<
2583 D: fidl::encoding::ResourceDialect,
2584 T0: fidl::encoding::Encode<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>,
2585 > fidl::encoding::Encode<DeviceRouteUnregisterOnMeshPrefixRequest, D> for (T0,)
2586 {
2587 #[inline]
2588 unsafe fn encode(
2589 self,
2590 encoder: &mut fidl::encoding::Encoder<'_, D>,
2591 offset: usize,
2592 depth: fidl::encoding::Depth,
2593 ) -> fidl::Result<()> {
2594 encoder.debug_check_bounds::<DeviceRouteUnregisterOnMeshPrefixRequest>(offset);
2595 self.0.encode(encoder, offset + 0, depth)?;
2599 Ok(())
2600 }
2601 }
2602
2603 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2604 for DeviceRouteUnregisterOnMeshPrefixRequest
2605 {
2606 #[inline(always)]
2607 fn new_empty() -> Self {
2608 Self { subnet: fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D) }
2609 }
2610
2611 #[inline]
2612 unsafe fn decode(
2613 &mut self,
2614 decoder: &mut fidl::encoding::Decoder<'_, D>,
2615 offset: usize,
2616 _depth: fidl::encoding::Depth,
2617 ) -> fidl::Result<()> {
2618 decoder.debug_check_bounds::<Self>(offset);
2619 fidl::decode!(
2621 fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
2622 D,
2623 &mut self.subnet,
2624 decoder,
2625 offset + 0,
2626 _depth
2627 )?;
2628 Ok(())
2629 }
2630 }
2631
2632 impl fidl::encoding::ValueTypeMarker for LegacyJoiningMakeJoinableRequest {
2633 type Borrowed<'a> = &'a Self;
2634 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2635 value
2636 }
2637 }
2638
2639 unsafe impl fidl::encoding::TypeMarker for LegacyJoiningMakeJoinableRequest {
2640 type Owned = Self;
2641
2642 #[inline(always)]
2643 fn inline_align(_context: fidl::encoding::Context) -> usize {
2644 8
2645 }
2646
2647 #[inline(always)]
2648 fn inline_size(_context: fidl::encoding::Context) -> usize {
2649 16
2650 }
2651 }
2652
2653 unsafe impl<D: fidl::encoding::ResourceDialect>
2654 fidl::encoding::Encode<LegacyJoiningMakeJoinableRequest, D>
2655 for &LegacyJoiningMakeJoinableRequest
2656 {
2657 #[inline]
2658 unsafe fn encode(
2659 self,
2660 encoder: &mut fidl::encoding::Encoder<'_, D>,
2661 offset: usize,
2662 _depth: fidl::encoding::Depth,
2663 ) -> fidl::Result<()> {
2664 encoder.debug_check_bounds::<LegacyJoiningMakeJoinableRequest>(offset);
2665 unsafe {
2666 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2668 (buf_ptr as *mut LegacyJoiningMakeJoinableRequest)
2669 .write_unaligned((self as *const LegacyJoiningMakeJoinableRequest).read());
2670 let padding_ptr = buf_ptr.offset(8) as *mut u64;
2673 let padding_mask = 0xffffffffffff0000u64;
2674 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
2675 }
2676 Ok(())
2677 }
2678 }
2679 unsafe impl<
2680 D: fidl::encoding::ResourceDialect,
2681 T0: fidl::encoding::Encode<i64, D>,
2682 T1: fidl::encoding::Encode<u16, D>,
2683 > fidl::encoding::Encode<LegacyJoiningMakeJoinableRequest, D> for (T0, T1)
2684 {
2685 #[inline]
2686 unsafe fn encode(
2687 self,
2688 encoder: &mut fidl::encoding::Encoder<'_, D>,
2689 offset: usize,
2690 depth: fidl::encoding::Depth,
2691 ) -> fidl::Result<()> {
2692 encoder.debug_check_bounds::<LegacyJoiningMakeJoinableRequest>(offset);
2693 unsafe {
2696 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
2697 (ptr as *mut u64).write_unaligned(0);
2698 }
2699 self.0.encode(encoder, offset + 0, depth)?;
2701 self.1.encode(encoder, offset + 8, depth)?;
2702 Ok(())
2703 }
2704 }
2705
2706 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2707 for LegacyJoiningMakeJoinableRequest
2708 {
2709 #[inline(always)]
2710 fn new_empty() -> Self {
2711 Self { duration: fidl::new_empty!(i64, D), port: fidl::new_empty!(u16, D) }
2712 }
2713
2714 #[inline]
2715 unsafe fn decode(
2716 &mut self,
2717 decoder: &mut fidl::encoding::Decoder<'_, D>,
2718 offset: usize,
2719 _depth: fidl::encoding::Depth,
2720 ) -> fidl::Result<()> {
2721 decoder.debug_check_bounds::<Self>(offset);
2722 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2723 let ptr = unsafe { buf_ptr.offset(8) };
2725 let padval = unsafe { (ptr as *const u64).read_unaligned() };
2726 let mask = 0xffffffffffff0000u64;
2727 let maskedval = padval & mask;
2728 if maskedval != 0 {
2729 return Err(fidl::Error::NonZeroPadding {
2730 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
2731 });
2732 }
2733 unsafe {
2735 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
2736 }
2737 Ok(())
2738 }
2739 }
2740
2741 impl fidl::encoding::ValueTypeMarker for ProvisioningMonitorWatchProgressResponse {
2742 type Borrowed<'a> = &'a Self;
2743 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2744 value
2745 }
2746 }
2747
2748 unsafe impl fidl::encoding::TypeMarker for ProvisioningMonitorWatchProgressResponse {
2749 type Owned = Self;
2750
2751 #[inline(always)]
2752 fn inline_align(_context: fidl::encoding::Context) -> usize {
2753 8
2754 }
2755
2756 #[inline(always)]
2757 fn inline_size(_context: fidl::encoding::Context) -> usize {
2758 16
2759 }
2760 }
2761
2762 unsafe impl<D: fidl::encoding::ResourceDialect>
2763 fidl::encoding::Encode<ProvisioningMonitorWatchProgressResponse, D>
2764 for &ProvisioningMonitorWatchProgressResponse
2765 {
2766 #[inline]
2767 unsafe fn encode(
2768 self,
2769 encoder: &mut fidl::encoding::Encoder<'_, D>,
2770 offset: usize,
2771 _depth: fidl::encoding::Depth,
2772 ) -> fidl::Result<()> {
2773 encoder.debug_check_bounds::<ProvisioningMonitorWatchProgressResponse>(offset);
2774 fidl::encoding::Encode::<ProvisioningMonitorWatchProgressResponse, D>::encode(
2776 (<ProvisioningProgress as fidl::encoding::ValueTypeMarker>::borrow(&self.progress),),
2777 encoder,
2778 offset,
2779 _depth,
2780 )
2781 }
2782 }
2783 unsafe impl<
2784 D: fidl::encoding::ResourceDialect,
2785 T0: fidl::encoding::Encode<ProvisioningProgress, D>,
2786 > fidl::encoding::Encode<ProvisioningMonitorWatchProgressResponse, D> for (T0,)
2787 {
2788 #[inline]
2789 unsafe fn encode(
2790 self,
2791 encoder: &mut fidl::encoding::Encoder<'_, D>,
2792 offset: usize,
2793 depth: fidl::encoding::Depth,
2794 ) -> fidl::Result<()> {
2795 encoder.debug_check_bounds::<ProvisioningMonitorWatchProgressResponse>(offset);
2796 self.0.encode(encoder, offset + 0, depth)?;
2800 Ok(())
2801 }
2802 }
2803
2804 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2805 for ProvisioningMonitorWatchProgressResponse
2806 {
2807 #[inline(always)]
2808 fn new_empty() -> Self {
2809 Self { progress: fidl::new_empty!(ProvisioningProgress, D) }
2810 }
2811
2812 #[inline]
2813 unsafe fn decode(
2814 &mut self,
2815 decoder: &mut fidl::encoding::Decoder<'_, D>,
2816 offset: usize,
2817 _depth: fidl::encoding::Depth,
2818 ) -> fidl::Result<()> {
2819 decoder.debug_check_bounds::<Self>(offset);
2820 fidl::decode!(
2822 ProvisioningProgress,
2823 D,
2824 &mut self.progress,
2825 decoder,
2826 offset + 0,
2827 _depth
2828 )?;
2829 Ok(())
2830 }
2831 }
2832
2833 impl fidl::encoding::ValueTypeMarker for TelemetryProviderGetTelemetryResponse {
2834 type Borrowed<'a> = &'a Self;
2835 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2836 value
2837 }
2838 }
2839
2840 unsafe impl fidl::encoding::TypeMarker for TelemetryProviderGetTelemetryResponse {
2841 type Owned = Self;
2842
2843 #[inline(always)]
2844 fn inline_align(_context: fidl::encoding::Context) -> usize {
2845 8
2846 }
2847
2848 #[inline(always)]
2849 fn inline_size(_context: fidl::encoding::Context) -> usize {
2850 16
2851 }
2852 }
2853
2854 unsafe impl<D: fidl::encoding::ResourceDialect>
2855 fidl::encoding::Encode<TelemetryProviderGetTelemetryResponse, D>
2856 for &TelemetryProviderGetTelemetryResponse
2857 {
2858 #[inline]
2859 unsafe fn encode(
2860 self,
2861 encoder: &mut fidl::encoding::Encoder<'_, D>,
2862 offset: usize,
2863 _depth: fidl::encoding::Depth,
2864 ) -> fidl::Result<()> {
2865 encoder.debug_check_bounds::<TelemetryProviderGetTelemetryResponse>(offset);
2866 fidl::encoding::Encode::<TelemetryProviderGetTelemetryResponse, D>::encode(
2868 (<Telemetry as fidl::encoding::ValueTypeMarker>::borrow(&self.telemetry),),
2869 encoder,
2870 offset,
2871 _depth,
2872 )
2873 }
2874 }
2875 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Telemetry, D>>
2876 fidl::encoding::Encode<TelemetryProviderGetTelemetryResponse, D> for (T0,)
2877 {
2878 #[inline]
2879 unsafe fn encode(
2880 self,
2881 encoder: &mut fidl::encoding::Encoder<'_, D>,
2882 offset: usize,
2883 depth: fidl::encoding::Depth,
2884 ) -> fidl::Result<()> {
2885 encoder.debug_check_bounds::<TelemetryProviderGetTelemetryResponse>(offset);
2886 self.0.encode(encoder, offset + 0, depth)?;
2890 Ok(())
2891 }
2892 }
2893
2894 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2895 for TelemetryProviderGetTelemetryResponse
2896 {
2897 #[inline(always)]
2898 fn new_empty() -> Self {
2899 Self { telemetry: fidl::new_empty!(Telemetry, D) }
2900 }
2901
2902 #[inline]
2903 unsafe fn decode(
2904 &mut self,
2905 decoder: &mut fidl::encoding::Decoder<'_, D>,
2906 offset: usize,
2907 _depth: fidl::encoding::Depth,
2908 ) -> fidl::Result<()> {
2909 decoder.debug_check_bounds::<Self>(offset);
2910 fidl::decode!(Telemetry, D, &mut self.telemetry, decoder, offset + 0, _depth)?;
2912 Ok(())
2913 }
2914 }
2915
2916 impl BeaconInfo {
2917 #[inline(always)]
2918 fn max_ordinal_present(&self) -> u64 {
2919 if let Some(_) = self.lqi {
2920 return 4;
2921 }
2922 if let Some(_) = self.rssi {
2923 return 3;
2924 }
2925 if let Some(_) = self.identity {
2926 return 2;
2927 }
2928 if let Some(_) = self.address {
2929 return 1;
2930 }
2931 0
2932 }
2933 }
2934
2935 impl fidl::encoding::ValueTypeMarker for BeaconInfo {
2936 type Borrowed<'a> = &'a Self;
2937 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2938 value
2939 }
2940 }
2941
2942 unsafe impl fidl::encoding::TypeMarker for BeaconInfo {
2943 type Owned = Self;
2944
2945 #[inline(always)]
2946 fn inline_align(_context: fidl::encoding::Context) -> usize {
2947 8
2948 }
2949
2950 #[inline(always)]
2951 fn inline_size(_context: fidl::encoding::Context) -> usize {
2952 16
2953 }
2954 }
2955
2956 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BeaconInfo, D>
2957 for &BeaconInfo
2958 {
2959 unsafe fn encode(
2960 self,
2961 encoder: &mut fidl::encoding::Encoder<'_, D>,
2962 offset: usize,
2963 mut depth: fidl::encoding::Depth,
2964 ) -> fidl::Result<()> {
2965 encoder.debug_check_bounds::<BeaconInfo>(offset);
2966 let max_ordinal: u64 = self.max_ordinal_present();
2968 encoder.write_num(max_ordinal, offset);
2969 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2970 if max_ordinal == 0 {
2972 return Ok(());
2973 }
2974 depth.increment()?;
2975 let envelope_size = 8;
2976 let bytes_len = max_ordinal as usize * envelope_size;
2977 #[allow(unused_variables)]
2978 let offset = encoder.out_of_line_offset(bytes_len);
2979 let mut _prev_end_offset: usize = 0;
2980 if 1 > max_ordinal {
2981 return Ok(());
2982 }
2983
2984 let cur_offset: usize = (1 - 1) * envelope_size;
2987
2988 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2990
2991 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan__common::MacAddress, D>(
2996 self.address.as_ref().map(<fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2997 encoder, offset + cur_offset, depth
2998 )?;
2999
3000 _prev_end_offset = cur_offset + envelope_size;
3001 if 2 > max_ordinal {
3002 return Ok(());
3003 }
3004
3005 let cur_offset: usize = (2 - 1) * envelope_size;
3008
3009 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3011
3012 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan_device__common::Identity, D>(
3017 self.identity.as_ref().map(<fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::ValueTypeMarker>::borrow),
3018 encoder, offset + cur_offset, depth
3019 )?;
3020
3021 _prev_end_offset = cur_offset + envelope_size;
3022 if 3 > max_ordinal {
3023 return Ok(());
3024 }
3025
3026 let cur_offset: usize = (3 - 1) * envelope_size;
3029
3030 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3032
3033 fidl::encoding::encode_in_envelope_optional::<i8, D>(
3038 self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
3039 encoder,
3040 offset + cur_offset,
3041 depth,
3042 )?;
3043
3044 _prev_end_offset = cur_offset + envelope_size;
3045 if 4 > max_ordinal {
3046 return Ok(());
3047 }
3048
3049 let cur_offset: usize = (4 - 1) * envelope_size;
3052
3053 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3055
3056 fidl::encoding::encode_in_envelope_optional::<u8, D>(
3061 self.lqi.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
3062 encoder,
3063 offset + cur_offset,
3064 depth,
3065 )?;
3066
3067 _prev_end_offset = cur_offset + envelope_size;
3068
3069 Ok(())
3070 }
3071 }
3072
3073 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BeaconInfo {
3074 #[inline(always)]
3075 fn new_empty() -> Self {
3076 Self::default()
3077 }
3078
3079 unsafe fn decode(
3080 &mut self,
3081 decoder: &mut fidl::encoding::Decoder<'_, D>,
3082 offset: usize,
3083 mut depth: fidl::encoding::Depth,
3084 ) -> fidl::Result<()> {
3085 decoder.debug_check_bounds::<Self>(offset);
3086 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3087 None => return Err(fidl::Error::NotNullable),
3088 Some(len) => len,
3089 };
3090 if len == 0 {
3092 return Ok(());
3093 };
3094 depth.increment()?;
3095 let envelope_size = 8;
3096 let bytes_len = len * envelope_size;
3097 let offset = decoder.out_of_line_offset(bytes_len)?;
3098 let mut _next_ordinal_to_read = 0;
3100 let mut next_offset = offset;
3101 let end_offset = offset + bytes_len;
3102 _next_ordinal_to_read += 1;
3103 if next_offset >= end_offset {
3104 return Ok(());
3105 }
3106
3107 while _next_ordinal_to_read < 1 {
3109 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3110 _next_ordinal_to_read += 1;
3111 next_offset += envelope_size;
3112 }
3113
3114 let next_out_of_line = decoder.next_out_of_line();
3115 let handles_before = decoder.remaining_handles();
3116 if let Some((inlined, num_bytes, num_handles)) =
3117 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3118 {
3119 let member_inline_size = <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3120 if inlined != (member_inline_size <= 4) {
3121 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3122 }
3123 let inner_offset;
3124 let mut inner_depth = depth.clone();
3125 if inlined {
3126 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3127 inner_offset = next_offset;
3128 } else {
3129 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3130 inner_depth.increment()?;
3131 }
3132 let val_ref = self.address.get_or_insert_with(|| {
3133 fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D)
3134 });
3135 fidl::decode!(
3136 fidl_fuchsia_lowpan__common::MacAddress,
3137 D,
3138 val_ref,
3139 decoder,
3140 inner_offset,
3141 inner_depth
3142 )?;
3143 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3144 {
3145 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3146 }
3147 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3148 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3149 }
3150 }
3151
3152 next_offset += envelope_size;
3153 _next_ordinal_to_read += 1;
3154 if next_offset >= end_offset {
3155 return Ok(());
3156 }
3157
3158 while _next_ordinal_to_read < 2 {
3160 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3161 _next_ordinal_to_read += 1;
3162 next_offset += envelope_size;
3163 }
3164
3165 let next_out_of_line = decoder.next_out_of_line();
3166 let handles_before = decoder.remaining_handles();
3167 if let Some((inlined, num_bytes, num_handles)) =
3168 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3169 {
3170 let member_inline_size = <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3171 if inlined != (member_inline_size <= 4) {
3172 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3173 }
3174 let inner_offset;
3175 let mut inner_depth = depth.clone();
3176 if inlined {
3177 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3178 inner_offset = next_offset;
3179 } else {
3180 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3181 inner_depth.increment()?;
3182 }
3183 let val_ref = self.identity.get_or_insert_with(|| {
3184 fidl::new_empty!(fidl_fuchsia_lowpan_device__common::Identity, D)
3185 });
3186 fidl::decode!(
3187 fidl_fuchsia_lowpan_device__common::Identity,
3188 D,
3189 val_ref,
3190 decoder,
3191 inner_offset,
3192 inner_depth
3193 )?;
3194 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3195 {
3196 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3197 }
3198 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3199 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3200 }
3201 }
3202
3203 next_offset += envelope_size;
3204 _next_ordinal_to_read += 1;
3205 if next_offset >= end_offset {
3206 return Ok(());
3207 }
3208
3209 while _next_ordinal_to_read < 3 {
3211 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3212 _next_ordinal_to_read += 1;
3213 next_offset += envelope_size;
3214 }
3215
3216 let next_out_of_line = decoder.next_out_of_line();
3217 let handles_before = decoder.remaining_handles();
3218 if let Some((inlined, num_bytes, num_handles)) =
3219 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3220 {
3221 let member_inline_size =
3222 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3223 if inlined != (member_inline_size <= 4) {
3224 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3225 }
3226 let inner_offset;
3227 let mut inner_depth = depth.clone();
3228 if inlined {
3229 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3230 inner_offset = next_offset;
3231 } else {
3232 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3233 inner_depth.increment()?;
3234 }
3235 let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
3236 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
3237 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3238 {
3239 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3240 }
3241 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3242 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3243 }
3244 }
3245
3246 next_offset += envelope_size;
3247 _next_ordinal_to_read += 1;
3248 if next_offset >= end_offset {
3249 return Ok(());
3250 }
3251
3252 while _next_ordinal_to_read < 4 {
3254 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3255 _next_ordinal_to_read += 1;
3256 next_offset += envelope_size;
3257 }
3258
3259 let next_out_of_line = decoder.next_out_of_line();
3260 let handles_before = decoder.remaining_handles();
3261 if let Some((inlined, num_bytes, num_handles)) =
3262 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3263 {
3264 let member_inline_size =
3265 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3266 if inlined != (member_inline_size <= 4) {
3267 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3268 }
3269 let inner_offset;
3270 let mut inner_depth = depth.clone();
3271 if inlined {
3272 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3273 inner_offset = next_offset;
3274 } else {
3275 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3276 inner_depth.increment()?;
3277 }
3278 let val_ref = self.lqi.get_or_insert_with(|| fidl::new_empty!(u8, D));
3279 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3280 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3281 {
3282 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3283 }
3284 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3285 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3286 }
3287 }
3288
3289 next_offset += envelope_size;
3290
3291 while next_offset < end_offset {
3293 _next_ordinal_to_read += 1;
3294 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3295 next_offset += envelope_size;
3296 }
3297
3298 Ok(())
3299 }
3300 }
3301
3302 impl BorderRoutingCounters {
3303 #[inline(always)]
3304 fn max_ordinal_present(&self) -> u64 {
3305 if let Some(_) = self.outbound_internet_bytes {
3306 return 18;
3307 }
3308 if let Some(_) = self.outbound_internet_packets {
3309 return 17;
3310 }
3311 if let Some(_) = self.inbound_internet_bytes {
3312 return 16;
3313 }
3314 if let Some(_) = self.inbound_internet_packets {
3315 return 15;
3316 }
3317 if let Some(_) = self.rs_tx_failure {
3318 return 14;
3319 }
3320 if let Some(_) = self.rs_tx_success {
3321 return 13;
3322 }
3323 if let Some(_) = self.rs_rx {
3324 return 12;
3325 }
3326 if let Some(_) = self.ra_tx_failure {
3327 return 11;
3328 }
3329 if let Some(_) = self.ra_tx_success {
3330 return 10;
3331 }
3332 if let Some(_) = self.ra_rx {
3333 return 9;
3334 }
3335 if let Some(_) = self.outbound_multicast_bytes {
3336 return 8;
3337 }
3338 if let Some(_) = self.outbound_multicast_packets {
3339 return 7;
3340 }
3341 if let Some(_) = self.outbound_unicast_bytes {
3342 return 6;
3343 }
3344 if let Some(_) = self.outbound_unicast_packets {
3345 return 5;
3346 }
3347 if let Some(_) = self.inbound_multicast_bytes {
3348 return 4;
3349 }
3350 if let Some(_) = self.inbound_multicast_packets {
3351 return 3;
3352 }
3353 if let Some(_) = self.inbound_unicast_bytes {
3354 return 2;
3355 }
3356 if let Some(_) = self.inbound_unicast_packets {
3357 return 1;
3358 }
3359 0
3360 }
3361 }
3362
3363 impl fidl::encoding::ValueTypeMarker for BorderRoutingCounters {
3364 type Borrowed<'a> = &'a Self;
3365 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3366 value
3367 }
3368 }
3369
3370 unsafe impl fidl::encoding::TypeMarker for BorderRoutingCounters {
3371 type Owned = Self;
3372
3373 #[inline(always)]
3374 fn inline_align(_context: fidl::encoding::Context) -> usize {
3375 8
3376 }
3377
3378 #[inline(always)]
3379 fn inline_size(_context: fidl::encoding::Context) -> usize {
3380 16
3381 }
3382 }
3383
3384 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BorderRoutingCounters, D>
3385 for &BorderRoutingCounters
3386 {
3387 unsafe fn encode(
3388 self,
3389 encoder: &mut fidl::encoding::Encoder<'_, D>,
3390 offset: usize,
3391 mut depth: fidl::encoding::Depth,
3392 ) -> fidl::Result<()> {
3393 encoder.debug_check_bounds::<BorderRoutingCounters>(offset);
3394 let max_ordinal: u64 = self.max_ordinal_present();
3396 encoder.write_num(max_ordinal, offset);
3397 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3398 if max_ordinal == 0 {
3400 return Ok(());
3401 }
3402 depth.increment()?;
3403 let envelope_size = 8;
3404 let bytes_len = max_ordinal as usize * envelope_size;
3405 #[allow(unused_variables)]
3406 let offset = encoder.out_of_line_offset(bytes_len);
3407 let mut _prev_end_offset: usize = 0;
3408 if 1 > max_ordinal {
3409 return Ok(());
3410 }
3411
3412 let cur_offset: usize = (1 - 1) * envelope_size;
3415
3416 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3418
3419 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3424 self.inbound_unicast_packets
3425 .as_ref()
3426 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3427 encoder,
3428 offset + cur_offset,
3429 depth,
3430 )?;
3431
3432 _prev_end_offset = cur_offset + envelope_size;
3433 if 2 > max_ordinal {
3434 return Ok(());
3435 }
3436
3437 let cur_offset: usize = (2 - 1) * envelope_size;
3440
3441 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3443
3444 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3449 self.inbound_unicast_bytes
3450 .as_ref()
3451 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3452 encoder,
3453 offset + cur_offset,
3454 depth,
3455 )?;
3456
3457 _prev_end_offset = cur_offset + envelope_size;
3458 if 3 > max_ordinal {
3459 return Ok(());
3460 }
3461
3462 let cur_offset: usize = (3 - 1) * envelope_size;
3465
3466 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3468
3469 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3474 self.inbound_multicast_packets
3475 .as_ref()
3476 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3477 encoder,
3478 offset + cur_offset,
3479 depth,
3480 )?;
3481
3482 _prev_end_offset = cur_offset + envelope_size;
3483 if 4 > max_ordinal {
3484 return Ok(());
3485 }
3486
3487 let cur_offset: usize = (4 - 1) * envelope_size;
3490
3491 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3493
3494 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3499 self.inbound_multicast_bytes
3500 .as_ref()
3501 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3502 encoder,
3503 offset + cur_offset,
3504 depth,
3505 )?;
3506
3507 _prev_end_offset = cur_offset + envelope_size;
3508 if 5 > max_ordinal {
3509 return Ok(());
3510 }
3511
3512 let cur_offset: usize = (5 - 1) * envelope_size;
3515
3516 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3518
3519 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3524 self.outbound_unicast_packets
3525 .as_ref()
3526 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3527 encoder,
3528 offset + cur_offset,
3529 depth,
3530 )?;
3531
3532 _prev_end_offset = cur_offset + envelope_size;
3533 if 6 > max_ordinal {
3534 return Ok(());
3535 }
3536
3537 let cur_offset: usize = (6 - 1) * envelope_size;
3540
3541 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3543
3544 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3549 self.outbound_unicast_bytes
3550 .as_ref()
3551 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3552 encoder,
3553 offset + cur_offset,
3554 depth,
3555 )?;
3556
3557 _prev_end_offset = cur_offset + envelope_size;
3558 if 7 > max_ordinal {
3559 return Ok(());
3560 }
3561
3562 let cur_offset: usize = (7 - 1) * envelope_size;
3565
3566 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3568
3569 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3574 self.outbound_multicast_packets
3575 .as_ref()
3576 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3577 encoder,
3578 offset + cur_offset,
3579 depth,
3580 )?;
3581
3582 _prev_end_offset = cur_offset + envelope_size;
3583 if 8 > max_ordinal {
3584 return Ok(());
3585 }
3586
3587 let cur_offset: usize = (8 - 1) * envelope_size;
3590
3591 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3593
3594 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3599 self.outbound_multicast_bytes
3600 .as_ref()
3601 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3602 encoder,
3603 offset + cur_offset,
3604 depth,
3605 )?;
3606
3607 _prev_end_offset = cur_offset + envelope_size;
3608 if 9 > max_ordinal {
3609 return Ok(());
3610 }
3611
3612 let cur_offset: usize = (9 - 1) * envelope_size;
3615
3616 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3618
3619 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3624 self.ra_rx.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3625 encoder,
3626 offset + cur_offset,
3627 depth,
3628 )?;
3629
3630 _prev_end_offset = cur_offset + envelope_size;
3631 if 10 > max_ordinal {
3632 return Ok(());
3633 }
3634
3635 let cur_offset: usize = (10 - 1) * envelope_size;
3638
3639 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3641
3642 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3647 self.ra_tx_success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3648 encoder,
3649 offset + cur_offset,
3650 depth,
3651 )?;
3652
3653 _prev_end_offset = cur_offset + envelope_size;
3654 if 11 > max_ordinal {
3655 return Ok(());
3656 }
3657
3658 let cur_offset: usize = (11 - 1) * envelope_size;
3661
3662 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3664
3665 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3670 self.ra_tx_failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3671 encoder,
3672 offset + cur_offset,
3673 depth,
3674 )?;
3675
3676 _prev_end_offset = cur_offset + envelope_size;
3677 if 12 > max_ordinal {
3678 return Ok(());
3679 }
3680
3681 let cur_offset: usize = (12 - 1) * envelope_size;
3684
3685 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3687
3688 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3693 self.rs_rx.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3694 encoder,
3695 offset + cur_offset,
3696 depth,
3697 )?;
3698
3699 _prev_end_offset = cur_offset + envelope_size;
3700 if 13 > max_ordinal {
3701 return Ok(());
3702 }
3703
3704 let cur_offset: usize = (13 - 1) * envelope_size;
3707
3708 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3710
3711 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3716 self.rs_tx_success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3717 encoder,
3718 offset + cur_offset,
3719 depth,
3720 )?;
3721
3722 _prev_end_offset = cur_offset + envelope_size;
3723 if 14 > max_ordinal {
3724 return Ok(());
3725 }
3726
3727 let cur_offset: usize = (14 - 1) * envelope_size;
3730
3731 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3733
3734 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3739 self.rs_tx_failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3740 encoder,
3741 offset + cur_offset,
3742 depth,
3743 )?;
3744
3745 _prev_end_offset = cur_offset + envelope_size;
3746 if 15 > max_ordinal {
3747 return Ok(());
3748 }
3749
3750 let cur_offset: usize = (15 - 1) * envelope_size;
3753
3754 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3756
3757 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3762 self.inbound_internet_packets
3763 .as_ref()
3764 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3765 encoder,
3766 offset + cur_offset,
3767 depth,
3768 )?;
3769
3770 _prev_end_offset = cur_offset + envelope_size;
3771 if 16 > max_ordinal {
3772 return Ok(());
3773 }
3774
3775 let cur_offset: usize = (16 - 1) * envelope_size;
3778
3779 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3781
3782 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3787 self.inbound_internet_bytes
3788 .as_ref()
3789 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3790 encoder,
3791 offset + cur_offset,
3792 depth,
3793 )?;
3794
3795 _prev_end_offset = cur_offset + envelope_size;
3796 if 17 > max_ordinal {
3797 return Ok(());
3798 }
3799
3800 let cur_offset: usize = (17 - 1) * envelope_size;
3803
3804 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3806
3807 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3812 self.outbound_internet_packets
3813 .as_ref()
3814 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3815 encoder,
3816 offset + cur_offset,
3817 depth,
3818 )?;
3819
3820 _prev_end_offset = cur_offset + envelope_size;
3821 if 18 > max_ordinal {
3822 return Ok(());
3823 }
3824
3825 let cur_offset: usize = (18 - 1) * envelope_size;
3828
3829 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3831
3832 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3837 self.outbound_internet_bytes
3838 .as_ref()
3839 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3840 encoder,
3841 offset + cur_offset,
3842 depth,
3843 )?;
3844
3845 _prev_end_offset = cur_offset + envelope_size;
3846
3847 Ok(())
3848 }
3849 }
3850
3851 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BorderRoutingCounters {
3852 #[inline(always)]
3853 fn new_empty() -> Self {
3854 Self::default()
3855 }
3856
3857 unsafe fn decode(
3858 &mut self,
3859 decoder: &mut fidl::encoding::Decoder<'_, D>,
3860 offset: usize,
3861 mut depth: fidl::encoding::Depth,
3862 ) -> fidl::Result<()> {
3863 decoder.debug_check_bounds::<Self>(offset);
3864 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3865 None => return Err(fidl::Error::NotNullable),
3866 Some(len) => len,
3867 };
3868 if len == 0 {
3870 return Ok(());
3871 };
3872 depth.increment()?;
3873 let envelope_size = 8;
3874 let bytes_len = len * envelope_size;
3875 let offset = decoder.out_of_line_offset(bytes_len)?;
3876 let mut _next_ordinal_to_read = 0;
3878 let mut next_offset = offset;
3879 let end_offset = offset + bytes_len;
3880 _next_ordinal_to_read += 1;
3881 if next_offset >= end_offset {
3882 return Ok(());
3883 }
3884
3885 while _next_ordinal_to_read < 1 {
3887 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3888 _next_ordinal_to_read += 1;
3889 next_offset += envelope_size;
3890 }
3891
3892 let next_out_of_line = decoder.next_out_of_line();
3893 let handles_before = decoder.remaining_handles();
3894 if let Some((inlined, num_bytes, num_handles)) =
3895 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3896 {
3897 let member_inline_size =
3898 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3899 if inlined != (member_inline_size <= 4) {
3900 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3901 }
3902 let inner_offset;
3903 let mut inner_depth = depth.clone();
3904 if inlined {
3905 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3906 inner_offset = next_offset;
3907 } else {
3908 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3909 inner_depth.increment()?;
3910 }
3911 let val_ref =
3912 self.inbound_unicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
3913 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3914 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3915 {
3916 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3917 }
3918 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3919 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3920 }
3921 }
3922
3923 next_offset += envelope_size;
3924 _next_ordinal_to_read += 1;
3925 if next_offset >= end_offset {
3926 return Ok(());
3927 }
3928
3929 while _next_ordinal_to_read < 2 {
3931 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3932 _next_ordinal_to_read += 1;
3933 next_offset += envelope_size;
3934 }
3935
3936 let next_out_of_line = decoder.next_out_of_line();
3937 let handles_before = decoder.remaining_handles();
3938 if let Some((inlined, num_bytes, num_handles)) =
3939 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3940 {
3941 let member_inline_size =
3942 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3943 if inlined != (member_inline_size <= 4) {
3944 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3945 }
3946 let inner_offset;
3947 let mut inner_depth = depth.clone();
3948 if inlined {
3949 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3950 inner_offset = next_offset;
3951 } else {
3952 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3953 inner_depth.increment()?;
3954 }
3955 let val_ref =
3956 self.inbound_unicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3957 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3958 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3959 {
3960 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3961 }
3962 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3963 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3964 }
3965 }
3966
3967 next_offset += envelope_size;
3968 _next_ordinal_to_read += 1;
3969 if next_offset >= end_offset {
3970 return Ok(());
3971 }
3972
3973 while _next_ordinal_to_read < 3 {
3975 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3976 _next_ordinal_to_read += 1;
3977 next_offset += envelope_size;
3978 }
3979
3980 let next_out_of_line = decoder.next_out_of_line();
3981 let handles_before = decoder.remaining_handles();
3982 if let Some((inlined, num_bytes, num_handles)) =
3983 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3984 {
3985 let member_inline_size =
3986 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3987 if inlined != (member_inline_size <= 4) {
3988 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3989 }
3990 let inner_offset;
3991 let mut inner_depth = depth.clone();
3992 if inlined {
3993 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3994 inner_offset = next_offset;
3995 } else {
3996 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3997 inner_depth.increment()?;
3998 }
3999 let val_ref =
4000 self.inbound_multicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4001 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4002 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4003 {
4004 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4005 }
4006 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4007 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4008 }
4009 }
4010
4011 next_offset += envelope_size;
4012 _next_ordinal_to_read += 1;
4013 if next_offset >= end_offset {
4014 return Ok(());
4015 }
4016
4017 while _next_ordinal_to_read < 4 {
4019 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4020 _next_ordinal_to_read += 1;
4021 next_offset += envelope_size;
4022 }
4023
4024 let next_out_of_line = decoder.next_out_of_line();
4025 let handles_before = decoder.remaining_handles();
4026 if let Some((inlined, num_bytes, num_handles)) =
4027 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4028 {
4029 let member_inline_size =
4030 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4031 if inlined != (member_inline_size <= 4) {
4032 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4033 }
4034 let inner_offset;
4035 let mut inner_depth = depth.clone();
4036 if inlined {
4037 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4038 inner_offset = next_offset;
4039 } else {
4040 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4041 inner_depth.increment()?;
4042 }
4043 let val_ref =
4044 self.inbound_multicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4045 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4046 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4047 {
4048 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4049 }
4050 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4051 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4052 }
4053 }
4054
4055 next_offset += envelope_size;
4056 _next_ordinal_to_read += 1;
4057 if next_offset >= end_offset {
4058 return Ok(());
4059 }
4060
4061 while _next_ordinal_to_read < 5 {
4063 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4064 _next_ordinal_to_read += 1;
4065 next_offset += envelope_size;
4066 }
4067
4068 let next_out_of_line = decoder.next_out_of_line();
4069 let handles_before = decoder.remaining_handles();
4070 if let Some((inlined, num_bytes, num_handles)) =
4071 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4072 {
4073 let member_inline_size =
4074 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4075 if inlined != (member_inline_size <= 4) {
4076 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4077 }
4078 let inner_offset;
4079 let mut inner_depth = depth.clone();
4080 if inlined {
4081 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4082 inner_offset = next_offset;
4083 } else {
4084 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4085 inner_depth.increment()?;
4086 }
4087 let val_ref =
4088 self.outbound_unicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4089 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4090 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4091 {
4092 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4093 }
4094 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4095 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4096 }
4097 }
4098
4099 next_offset += envelope_size;
4100 _next_ordinal_to_read += 1;
4101 if next_offset >= end_offset {
4102 return Ok(());
4103 }
4104
4105 while _next_ordinal_to_read < 6 {
4107 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4108 _next_ordinal_to_read += 1;
4109 next_offset += envelope_size;
4110 }
4111
4112 let next_out_of_line = decoder.next_out_of_line();
4113 let handles_before = decoder.remaining_handles();
4114 if let Some((inlined, num_bytes, num_handles)) =
4115 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4116 {
4117 let member_inline_size =
4118 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4119 if inlined != (member_inline_size <= 4) {
4120 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4121 }
4122 let inner_offset;
4123 let mut inner_depth = depth.clone();
4124 if inlined {
4125 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4126 inner_offset = next_offset;
4127 } else {
4128 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4129 inner_depth.increment()?;
4130 }
4131 let val_ref =
4132 self.outbound_unicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4133 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4134 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4135 {
4136 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4137 }
4138 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4139 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4140 }
4141 }
4142
4143 next_offset += envelope_size;
4144 _next_ordinal_to_read += 1;
4145 if next_offset >= end_offset {
4146 return Ok(());
4147 }
4148
4149 while _next_ordinal_to_read < 7 {
4151 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4152 _next_ordinal_to_read += 1;
4153 next_offset += envelope_size;
4154 }
4155
4156 let next_out_of_line = decoder.next_out_of_line();
4157 let handles_before = decoder.remaining_handles();
4158 if let Some((inlined, num_bytes, num_handles)) =
4159 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4160 {
4161 let member_inline_size =
4162 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4163 if inlined != (member_inline_size <= 4) {
4164 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4165 }
4166 let inner_offset;
4167 let mut inner_depth = depth.clone();
4168 if inlined {
4169 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4170 inner_offset = next_offset;
4171 } else {
4172 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4173 inner_depth.increment()?;
4174 }
4175 let val_ref =
4176 self.outbound_multicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4177 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4178 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4179 {
4180 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4181 }
4182 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4183 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4184 }
4185 }
4186
4187 next_offset += envelope_size;
4188 _next_ordinal_to_read += 1;
4189 if next_offset >= end_offset {
4190 return Ok(());
4191 }
4192
4193 while _next_ordinal_to_read < 8 {
4195 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4196 _next_ordinal_to_read += 1;
4197 next_offset += envelope_size;
4198 }
4199
4200 let next_out_of_line = decoder.next_out_of_line();
4201 let handles_before = decoder.remaining_handles();
4202 if let Some((inlined, num_bytes, num_handles)) =
4203 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4204 {
4205 let member_inline_size =
4206 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4207 if inlined != (member_inline_size <= 4) {
4208 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4209 }
4210 let inner_offset;
4211 let mut inner_depth = depth.clone();
4212 if inlined {
4213 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4214 inner_offset = next_offset;
4215 } else {
4216 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4217 inner_depth.increment()?;
4218 }
4219 let val_ref =
4220 self.outbound_multicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4221 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4222 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4223 {
4224 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4225 }
4226 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4227 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4228 }
4229 }
4230
4231 next_offset += envelope_size;
4232 _next_ordinal_to_read += 1;
4233 if next_offset >= end_offset {
4234 return Ok(());
4235 }
4236
4237 while _next_ordinal_to_read < 9 {
4239 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4240 _next_ordinal_to_read += 1;
4241 next_offset += envelope_size;
4242 }
4243
4244 let next_out_of_line = decoder.next_out_of_line();
4245 let handles_before = decoder.remaining_handles();
4246 if let Some((inlined, num_bytes, num_handles)) =
4247 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4248 {
4249 let member_inline_size =
4250 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4251 if inlined != (member_inline_size <= 4) {
4252 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4253 }
4254 let inner_offset;
4255 let mut inner_depth = depth.clone();
4256 if inlined {
4257 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4258 inner_offset = next_offset;
4259 } else {
4260 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4261 inner_depth.increment()?;
4262 }
4263 let val_ref = self.ra_rx.get_or_insert_with(|| fidl::new_empty!(u32, D));
4264 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4265 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4266 {
4267 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4268 }
4269 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4270 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4271 }
4272 }
4273
4274 next_offset += envelope_size;
4275 _next_ordinal_to_read += 1;
4276 if next_offset >= end_offset {
4277 return Ok(());
4278 }
4279
4280 while _next_ordinal_to_read < 10 {
4282 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4283 _next_ordinal_to_read += 1;
4284 next_offset += envelope_size;
4285 }
4286
4287 let next_out_of_line = decoder.next_out_of_line();
4288 let handles_before = decoder.remaining_handles();
4289 if let Some((inlined, num_bytes, num_handles)) =
4290 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4291 {
4292 let member_inline_size =
4293 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4294 if inlined != (member_inline_size <= 4) {
4295 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4296 }
4297 let inner_offset;
4298 let mut inner_depth = depth.clone();
4299 if inlined {
4300 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4301 inner_offset = next_offset;
4302 } else {
4303 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4304 inner_depth.increment()?;
4305 }
4306 let val_ref = self.ra_tx_success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4307 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4308 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4309 {
4310 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4311 }
4312 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4313 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4314 }
4315 }
4316
4317 next_offset += envelope_size;
4318 _next_ordinal_to_read += 1;
4319 if next_offset >= end_offset {
4320 return Ok(());
4321 }
4322
4323 while _next_ordinal_to_read < 11 {
4325 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4326 _next_ordinal_to_read += 1;
4327 next_offset += envelope_size;
4328 }
4329
4330 let next_out_of_line = decoder.next_out_of_line();
4331 let handles_before = decoder.remaining_handles();
4332 if let Some((inlined, num_bytes, num_handles)) =
4333 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4334 {
4335 let member_inline_size =
4336 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4337 if inlined != (member_inline_size <= 4) {
4338 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4339 }
4340 let inner_offset;
4341 let mut inner_depth = depth.clone();
4342 if inlined {
4343 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4344 inner_offset = next_offset;
4345 } else {
4346 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4347 inner_depth.increment()?;
4348 }
4349 let val_ref = self.ra_tx_failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4350 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4351 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4352 {
4353 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4354 }
4355 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4356 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4357 }
4358 }
4359
4360 next_offset += envelope_size;
4361 _next_ordinal_to_read += 1;
4362 if next_offset >= end_offset {
4363 return Ok(());
4364 }
4365
4366 while _next_ordinal_to_read < 12 {
4368 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4369 _next_ordinal_to_read += 1;
4370 next_offset += envelope_size;
4371 }
4372
4373 let next_out_of_line = decoder.next_out_of_line();
4374 let handles_before = decoder.remaining_handles();
4375 if let Some((inlined, num_bytes, num_handles)) =
4376 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4377 {
4378 let member_inline_size =
4379 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4380 if inlined != (member_inline_size <= 4) {
4381 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4382 }
4383 let inner_offset;
4384 let mut inner_depth = depth.clone();
4385 if inlined {
4386 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4387 inner_offset = next_offset;
4388 } else {
4389 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4390 inner_depth.increment()?;
4391 }
4392 let val_ref = self.rs_rx.get_or_insert_with(|| fidl::new_empty!(u32, D));
4393 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4394 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4395 {
4396 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4397 }
4398 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4399 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4400 }
4401 }
4402
4403 next_offset += envelope_size;
4404 _next_ordinal_to_read += 1;
4405 if next_offset >= end_offset {
4406 return Ok(());
4407 }
4408
4409 while _next_ordinal_to_read < 13 {
4411 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4412 _next_ordinal_to_read += 1;
4413 next_offset += envelope_size;
4414 }
4415
4416 let next_out_of_line = decoder.next_out_of_line();
4417 let handles_before = decoder.remaining_handles();
4418 if let Some((inlined, num_bytes, num_handles)) =
4419 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4420 {
4421 let member_inline_size =
4422 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4423 if inlined != (member_inline_size <= 4) {
4424 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4425 }
4426 let inner_offset;
4427 let mut inner_depth = depth.clone();
4428 if inlined {
4429 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4430 inner_offset = next_offset;
4431 } else {
4432 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4433 inner_depth.increment()?;
4434 }
4435 let val_ref = self.rs_tx_success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4436 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4437 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4438 {
4439 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4440 }
4441 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4442 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4443 }
4444 }
4445
4446 next_offset += envelope_size;
4447 _next_ordinal_to_read += 1;
4448 if next_offset >= end_offset {
4449 return Ok(());
4450 }
4451
4452 while _next_ordinal_to_read < 14 {
4454 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4455 _next_ordinal_to_read += 1;
4456 next_offset += envelope_size;
4457 }
4458
4459 let next_out_of_line = decoder.next_out_of_line();
4460 let handles_before = decoder.remaining_handles();
4461 if let Some((inlined, num_bytes, num_handles)) =
4462 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4463 {
4464 let member_inline_size =
4465 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4466 if inlined != (member_inline_size <= 4) {
4467 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4468 }
4469 let inner_offset;
4470 let mut inner_depth = depth.clone();
4471 if inlined {
4472 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4473 inner_offset = next_offset;
4474 } else {
4475 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4476 inner_depth.increment()?;
4477 }
4478 let val_ref = self.rs_tx_failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4479 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4480 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4481 {
4482 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4483 }
4484 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4485 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4486 }
4487 }
4488
4489 next_offset += envelope_size;
4490 _next_ordinal_to_read += 1;
4491 if next_offset >= end_offset {
4492 return Ok(());
4493 }
4494
4495 while _next_ordinal_to_read < 15 {
4497 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4498 _next_ordinal_to_read += 1;
4499 next_offset += envelope_size;
4500 }
4501
4502 let next_out_of_line = decoder.next_out_of_line();
4503 let handles_before = decoder.remaining_handles();
4504 if let Some((inlined, num_bytes, num_handles)) =
4505 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4506 {
4507 let member_inline_size =
4508 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4509 if inlined != (member_inline_size <= 4) {
4510 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4511 }
4512 let inner_offset;
4513 let mut inner_depth = depth.clone();
4514 if inlined {
4515 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4516 inner_offset = next_offset;
4517 } else {
4518 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4519 inner_depth.increment()?;
4520 }
4521 let val_ref =
4522 self.inbound_internet_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4523 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4524 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4525 {
4526 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4527 }
4528 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4529 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4530 }
4531 }
4532
4533 next_offset += envelope_size;
4534 _next_ordinal_to_read += 1;
4535 if next_offset >= end_offset {
4536 return Ok(());
4537 }
4538
4539 while _next_ordinal_to_read < 16 {
4541 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4542 _next_ordinal_to_read += 1;
4543 next_offset += envelope_size;
4544 }
4545
4546 let next_out_of_line = decoder.next_out_of_line();
4547 let handles_before = decoder.remaining_handles();
4548 if let Some((inlined, num_bytes, num_handles)) =
4549 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4550 {
4551 let member_inline_size =
4552 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4553 if inlined != (member_inline_size <= 4) {
4554 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4555 }
4556 let inner_offset;
4557 let mut inner_depth = depth.clone();
4558 if inlined {
4559 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4560 inner_offset = next_offset;
4561 } else {
4562 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4563 inner_depth.increment()?;
4564 }
4565 let val_ref =
4566 self.inbound_internet_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4567 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4568 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4569 {
4570 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4571 }
4572 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4573 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4574 }
4575 }
4576
4577 next_offset += envelope_size;
4578 _next_ordinal_to_read += 1;
4579 if next_offset >= end_offset {
4580 return Ok(());
4581 }
4582
4583 while _next_ordinal_to_read < 17 {
4585 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4586 _next_ordinal_to_read += 1;
4587 next_offset += envelope_size;
4588 }
4589
4590 let next_out_of_line = decoder.next_out_of_line();
4591 let handles_before = decoder.remaining_handles();
4592 if let Some((inlined, num_bytes, num_handles)) =
4593 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4594 {
4595 let member_inline_size =
4596 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4597 if inlined != (member_inline_size <= 4) {
4598 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4599 }
4600 let inner_offset;
4601 let mut inner_depth = depth.clone();
4602 if inlined {
4603 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4604 inner_offset = next_offset;
4605 } else {
4606 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4607 inner_depth.increment()?;
4608 }
4609 let val_ref =
4610 self.outbound_internet_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4611 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4612 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4613 {
4614 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4615 }
4616 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4617 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4618 }
4619 }
4620
4621 next_offset += envelope_size;
4622 _next_ordinal_to_read += 1;
4623 if next_offset >= end_offset {
4624 return Ok(());
4625 }
4626
4627 while _next_ordinal_to_read < 18 {
4629 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4630 _next_ordinal_to_read += 1;
4631 next_offset += envelope_size;
4632 }
4633
4634 let next_out_of_line = decoder.next_out_of_line();
4635 let handles_before = decoder.remaining_handles();
4636 if let Some((inlined, num_bytes, num_handles)) =
4637 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4638 {
4639 let member_inline_size =
4640 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4641 if inlined != (member_inline_size <= 4) {
4642 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4643 }
4644 let inner_offset;
4645 let mut inner_depth = depth.clone();
4646 if inlined {
4647 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4648 inner_offset = next_offset;
4649 } else {
4650 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4651 inner_depth.increment()?;
4652 }
4653 let val_ref =
4654 self.outbound_internet_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4655 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4656 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4657 {
4658 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4659 }
4660 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4661 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4662 }
4663 }
4664
4665 next_offset += envelope_size;
4666
4667 while next_offset < end_offset {
4669 _next_ordinal_to_read += 1;
4670 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4671 next_offset += envelope_size;
4672 }
4673
4674 Ok(())
4675 }
4676 }
4677
4678 impl BorderRoutingNat64State {
4679 #[inline(always)]
4680 fn max_ordinal_present(&self) -> u64 {
4681 if let Some(_) = self.translator_state {
4682 return 2;
4683 }
4684 if let Some(_) = self.prefix_manager_state {
4685 return 1;
4686 }
4687 0
4688 }
4689 }
4690
4691 impl fidl::encoding::ValueTypeMarker for BorderRoutingNat64State {
4692 type Borrowed<'a> = &'a Self;
4693 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4694 value
4695 }
4696 }
4697
4698 unsafe impl fidl::encoding::TypeMarker for BorderRoutingNat64State {
4699 type Owned = Self;
4700
4701 #[inline(always)]
4702 fn inline_align(_context: fidl::encoding::Context) -> usize {
4703 8
4704 }
4705
4706 #[inline(always)]
4707 fn inline_size(_context: fidl::encoding::Context) -> usize {
4708 16
4709 }
4710 }
4711
4712 unsafe impl<D: fidl::encoding::ResourceDialect>
4713 fidl::encoding::Encode<BorderRoutingNat64State, D> for &BorderRoutingNat64State
4714 {
4715 unsafe fn encode(
4716 self,
4717 encoder: &mut fidl::encoding::Encoder<'_, D>,
4718 offset: usize,
4719 mut depth: fidl::encoding::Depth,
4720 ) -> fidl::Result<()> {
4721 encoder.debug_check_bounds::<BorderRoutingNat64State>(offset);
4722 let max_ordinal: u64 = self.max_ordinal_present();
4724 encoder.write_num(max_ordinal, offset);
4725 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4726 if max_ordinal == 0 {
4728 return Ok(());
4729 }
4730 depth.increment()?;
4731 let envelope_size = 8;
4732 let bytes_len = max_ordinal as usize * envelope_size;
4733 #[allow(unused_variables)]
4734 let offset = encoder.out_of_line_offset(bytes_len);
4735 let mut _prev_end_offset: usize = 0;
4736 if 1 > max_ordinal {
4737 return Ok(());
4738 }
4739
4740 let cur_offset: usize = (1 - 1) * envelope_size;
4743
4744 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4746
4747 fidl::encoding::encode_in_envelope_optional::<Nat64State, D>(
4752 self.prefix_manager_state
4753 .as_ref()
4754 .map(<Nat64State as fidl::encoding::ValueTypeMarker>::borrow),
4755 encoder,
4756 offset + cur_offset,
4757 depth,
4758 )?;
4759
4760 _prev_end_offset = cur_offset + envelope_size;
4761 if 2 > max_ordinal {
4762 return Ok(());
4763 }
4764
4765 let cur_offset: usize = (2 - 1) * envelope_size;
4768
4769 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4771
4772 fidl::encoding::encode_in_envelope_optional::<Nat64State, D>(
4777 self.translator_state
4778 .as_ref()
4779 .map(<Nat64State as fidl::encoding::ValueTypeMarker>::borrow),
4780 encoder,
4781 offset + cur_offset,
4782 depth,
4783 )?;
4784
4785 _prev_end_offset = cur_offset + envelope_size;
4786
4787 Ok(())
4788 }
4789 }
4790
4791 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4792 for BorderRoutingNat64State
4793 {
4794 #[inline(always)]
4795 fn new_empty() -> Self {
4796 Self::default()
4797 }
4798
4799 unsafe fn decode(
4800 &mut self,
4801 decoder: &mut fidl::encoding::Decoder<'_, D>,
4802 offset: usize,
4803 mut depth: fidl::encoding::Depth,
4804 ) -> fidl::Result<()> {
4805 decoder.debug_check_bounds::<Self>(offset);
4806 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4807 None => return Err(fidl::Error::NotNullable),
4808 Some(len) => len,
4809 };
4810 if len == 0 {
4812 return Ok(());
4813 };
4814 depth.increment()?;
4815 let envelope_size = 8;
4816 let bytes_len = len * envelope_size;
4817 let offset = decoder.out_of_line_offset(bytes_len)?;
4818 let mut _next_ordinal_to_read = 0;
4820 let mut next_offset = offset;
4821 let end_offset = offset + bytes_len;
4822 _next_ordinal_to_read += 1;
4823 if next_offset >= end_offset {
4824 return Ok(());
4825 }
4826
4827 while _next_ordinal_to_read < 1 {
4829 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4830 _next_ordinal_to_read += 1;
4831 next_offset += envelope_size;
4832 }
4833
4834 let next_out_of_line = decoder.next_out_of_line();
4835 let handles_before = decoder.remaining_handles();
4836 if let Some((inlined, num_bytes, num_handles)) =
4837 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4838 {
4839 let member_inline_size =
4840 <Nat64State as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4841 if inlined != (member_inline_size <= 4) {
4842 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4843 }
4844 let inner_offset;
4845 let mut inner_depth = depth.clone();
4846 if inlined {
4847 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4848 inner_offset = next_offset;
4849 } else {
4850 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4851 inner_depth.increment()?;
4852 }
4853 let val_ref = self
4854 .prefix_manager_state
4855 .get_or_insert_with(|| fidl::new_empty!(Nat64State, D));
4856 fidl::decode!(Nat64State, D, val_ref, decoder, inner_offset, inner_depth)?;
4857 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4858 {
4859 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4860 }
4861 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4862 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4863 }
4864 }
4865
4866 next_offset += envelope_size;
4867 _next_ordinal_to_read += 1;
4868 if next_offset >= end_offset {
4869 return Ok(());
4870 }
4871
4872 while _next_ordinal_to_read < 2 {
4874 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4875 _next_ordinal_to_read += 1;
4876 next_offset += envelope_size;
4877 }
4878
4879 let next_out_of_line = decoder.next_out_of_line();
4880 let handles_before = decoder.remaining_handles();
4881 if let Some((inlined, num_bytes, num_handles)) =
4882 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4883 {
4884 let member_inline_size =
4885 <Nat64State as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4886 if inlined != (member_inline_size <= 4) {
4887 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4888 }
4889 let inner_offset;
4890 let mut inner_depth = depth.clone();
4891 if inlined {
4892 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4893 inner_offset = next_offset;
4894 } else {
4895 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4896 inner_depth.increment()?;
4897 }
4898 let val_ref =
4899 self.translator_state.get_or_insert_with(|| fidl::new_empty!(Nat64State, D));
4900 fidl::decode!(Nat64State, D, val_ref, decoder, inner_offset, inner_depth)?;
4901 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4902 {
4903 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4904 }
4905 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4906 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4907 }
4908 }
4909
4910 next_offset += envelope_size;
4911
4912 while next_offset < end_offset {
4914 _next_ordinal_to_read += 1;
4915 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4916 next_offset += envelope_size;
4917 }
4918
4919 Ok(())
4920 }
4921 }
4922
4923 impl ChannelInfo {
4924 #[inline(always)]
4925 fn max_ordinal_present(&self) -> u64 {
4926 if let Some(_) = self.masked_by_regulatory_domain {
4927 return 6;
4928 }
4929 if let Some(_) = self.spectrum_bandwidth_hz {
4930 return 5;
4931 }
4932 if let Some(_) = self.spectrum_center_frequency_hz {
4933 return 4;
4934 }
4935 if let Some(_) = self.max_transmit_power_dbm {
4936 return 3;
4937 }
4938 if let Some(_) = self.id {
4939 return 2;
4940 }
4941 if let Some(_) = self.index {
4942 return 1;
4943 }
4944 0
4945 }
4946 }
4947
4948 impl fidl::encoding::ValueTypeMarker for ChannelInfo {
4949 type Borrowed<'a> = &'a Self;
4950 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4951 value
4952 }
4953 }
4954
4955 unsafe impl fidl::encoding::TypeMarker for ChannelInfo {
4956 type Owned = Self;
4957
4958 #[inline(always)]
4959 fn inline_align(_context: fidl::encoding::Context) -> usize {
4960 8
4961 }
4962
4963 #[inline(always)]
4964 fn inline_size(_context: fidl::encoding::Context) -> usize {
4965 16
4966 }
4967 }
4968
4969 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelInfo, D>
4970 for &ChannelInfo
4971 {
4972 unsafe fn encode(
4973 self,
4974 encoder: &mut fidl::encoding::Encoder<'_, D>,
4975 offset: usize,
4976 mut depth: fidl::encoding::Depth,
4977 ) -> fidl::Result<()> {
4978 encoder.debug_check_bounds::<ChannelInfo>(offset);
4979 let max_ordinal: u64 = self.max_ordinal_present();
4981 encoder.write_num(max_ordinal, offset);
4982 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4983 if max_ordinal == 0 {
4985 return Ok(());
4986 }
4987 depth.increment()?;
4988 let envelope_size = 8;
4989 let bytes_len = max_ordinal as usize * envelope_size;
4990 #[allow(unused_variables)]
4991 let offset = encoder.out_of_line_offset(bytes_len);
4992 let mut _prev_end_offset: usize = 0;
4993 if 1 > max_ordinal {
4994 return Ok(());
4995 }
4996
4997 let cur_offset: usize = (1 - 1) * envelope_size;
5000
5001 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5003
5004 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5009 self.index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5010 encoder,
5011 offset + cur_offset,
5012 depth,
5013 )?;
5014
5015 _prev_end_offset = cur_offset + envelope_size;
5016 if 2 > max_ordinal {
5017 return Ok(());
5018 }
5019
5020 let cur_offset: usize = (2 - 1) * envelope_size;
5023
5024 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5026
5027 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<16>, D>(
5032 self.id.as_ref().map(
5033 <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow,
5034 ),
5035 encoder,
5036 offset + cur_offset,
5037 depth,
5038 )?;
5039
5040 _prev_end_offset = cur_offset + envelope_size;
5041 if 3 > max_ordinal {
5042 return Ok(());
5043 }
5044
5045 let cur_offset: usize = (3 - 1) * envelope_size;
5048
5049 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5051
5052 fidl::encoding::encode_in_envelope_optional::<i8, D>(
5057 self.max_transmit_power_dbm
5058 .as_ref()
5059 .map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
5060 encoder,
5061 offset + cur_offset,
5062 depth,
5063 )?;
5064
5065 _prev_end_offset = cur_offset + envelope_size;
5066 if 4 > max_ordinal {
5067 return Ok(());
5068 }
5069
5070 let cur_offset: usize = (4 - 1) * envelope_size;
5073
5074 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5076
5077 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5082 self.spectrum_center_frequency_hz
5083 .as_ref()
5084 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5085 encoder,
5086 offset + cur_offset,
5087 depth,
5088 )?;
5089
5090 _prev_end_offset = cur_offset + envelope_size;
5091 if 5 > max_ordinal {
5092 return Ok(());
5093 }
5094
5095 let cur_offset: usize = (5 - 1) * envelope_size;
5098
5099 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5101
5102 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5107 self.spectrum_bandwidth_hz
5108 .as_ref()
5109 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5110 encoder,
5111 offset + cur_offset,
5112 depth,
5113 )?;
5114
5115 _prev_end_offset = cur_offset + envelope_size;
5116 if 6 > max_ordinal {
5117 return Ok(());
5118 }
5119
5120 let cur_offset: usize = (6 - 1) * envelope_size;
5123
5124 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5126
5127 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5132 self.masked_by_regulatory_domain
5133 .as_ref()
5134 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5135 encoder,
5136 offset + cur_offset,
5137 depth,
5138 )?;
5139
5140 _prev_end_offset = cur_offset + envelope_size;
5141
5142 Ok(())
5143 }
5144 }
5145
5146 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelInfo {
5147 #[inline(always)]
5148 fn new_empty() -> Self {
5149 Self::default()
5150 }
5151
5152 unsafe fn decode(
5153 &mut self,
5154 decoder: &mut fidl::encoding::Decoder<'_, D>,
5155 offset: usize,
5156 mut depth: fidl::encoding::Depth,
5157 ) -> fidl::Result<()> {
5158 decoder.debug_check_bounds::<Self>(offset);
5159 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5160 None => return Err(fidl::Error::NotNullable),
5161 Some(len) => len,
5162 };
5163 if len == 0 {
5165 return Ok(());
5166 };
5167 depth.increment()?;
5168 let envelope_size = 8;
5169 let bytes_len = len * envelope_size;
5170 let offset = decoder.out_of_line_offset(bytes_len)?;
5171 let mut _next_ordinal_to_read = 0;
5173 let mut next_offset = offset;
5174 let end_offset = offset + bytes_len;
5175 _next_ordinal_to_read += 1;
5176 if next_offset >= end_offset {
5177 return Ok(());
5178 }
5179
5180 while _next_ordinal_to_read < 1 {
5182 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5183 _next_ordinal_to_read += 1;
5184 next_offset += envelope_size;
5185 }
5186
5187 let next_out_of_line = decoder.next_out_of_line();
5188 let handles_before = decoder.remaining_handles();
5189 if let Some((inlined, num_bytes, num_handles)) =
5190 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5191 {
5192 let member_inline_size =
5193 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5194 if inlined != (member_inline_size <= 4) {
5195 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5196 }
5197 let inner_offset;
5198 let mut inner_depth = depth.clone();
5199 if inlined {
5200 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5201 inner_offset = next_offset;
5202 } else {
5203 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5204 inner_depth.increment()?;
5205 }
5206 let val_ref = self.index.get_or_insert_with(|| fidl::new_empty!(u16, D));
5207 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5208 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5209 {
5210 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5211 }
5212 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5213 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5214 }
5215 }
5216
5217 next_offset += envelope_size;
5218 _next_ordinal_to_read += 1;
5219 if next_offset >= end_offset {
5220 return Ok(());
5221 }
5222
5223 while _next_ordinal_to_read < 2 {
5225 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5226 _next_ordinal_to_read += 1;
5227 next_offset += envelope_size;
5228 }
5229
5230 let next_out_of_line = decoder.next_out_of_line();
5231 let handles_before = decoder.remaining_handles();
5232 if let Some((inlined, num_bytes, num_handles)) =
5233 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5234 {
5235 let member_inline_size =
5236 <fidl::encoding::BoundedString<16> as fidl::encoding::TypeMarker>::inline_size(
5237 decoder.context,
5238 );
5239 if inlined != (member_inline_size <= 4) {
5240 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5241 }
5242 let inner_offset;
5243 let mut inner_depth = depth.clone();
5244 if inlined {
5245 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5246 inner_offset = next_offset;
5247 } else {
5248 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5249 inner_depth.increment()?;
5250 }
5251 let val_ref = self
5252 .id
5253 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<16>, D));
5254 fidl::decode!(
5255 fidl::encoding::BoundedString<16>,
5256 D,
5257 val_ref,
5258 decoder,
5259 inner_offset,
5260 inner_depth
5261 )?;
5262 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5263 {
5264 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5265 }
5266 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5267 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5268 }
5269 }
5270
5271 next_offset += envelope_size;
5272 _next_ordinal_to_read += 1;
5273 if next_offset >= end_offset {
5274 return Ok(());
5275 }
5276
5277 while _next_ordinal_to_read < 3 {
5279 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5280 _next_ordinal_to_read += 1;
5281 next_offset += envelope_size;
5282 }
5283
5284 let next_out_of_line = decoder.next_out_of_line();
5285 let handles_before = decoder.remaining_handles();
5286 if let Some((inlined, num_bytes, num_handles)) =
5287 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5288 {
5289 let member_inline_size =
5290 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5291 if inlined != (member_inline_size <= 4) {
5292 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5293 }
5294 let inner_offset;
5295 let mut inner_depth = depth.clone();
5296 if inlined {
5297 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5298 inner_offset = next_offset;
5299 } else {
5300 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5301 inner_depth.increment()?;
5302 }
5303 let val_ref =
5304 self.max_transmit_power_dbm.get_or_insert_with(|| fidl::new_empty!(i8, D));
5305 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
5306 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5307 {
5308 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5309 }
5310 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5311 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5312 }
5313 }
5314
5315 next_offset += envelope_size;
5316 _next_ordinal_to_read += 1;
5317 if next_offset >= end_offset {
5318 return Ok(());
5319 }
5320
5321 while _next_ordinal_to_read < 4 {
5323 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5324 _next_ordinal_to_read += 1;
5325 next_offset += envelope_size;
5326 }
5327
5328 let next_out_of_line = decoder.next_out_of_line();
5329 let handles_before = decoder.remaining_handles();
5330 if let Some((inlined, num_bytes, num_handles)) =
5331 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5332 {
5333 let member_inline_size =
5334 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5335 if inlined != (member_inline_size <= 4) {
5336 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5337 }
5338 let inner_offset;
5339 let mut inner_depth = depth.clone();
5340 if inlined {
5341 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5342 inner_offset = next_offset;
5343 } else {
5344 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5345 inner_depth.increment()?;
5346 }
5347 let val_ref = self
5348 .spectrum_center_frequency_hz
5349 .get_or_insert_with(|| fidl::new_empty!(u64, D));
5350 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5351 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5352 {
5353 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5354 }
5355 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5356 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5357 }
5358 }
5359
5360 next_offset += envelope_size;
5361 _next_ordinal_to_read += 1;
5362 if next_offset >= end_offset {
5363 return Ok(());
5364 }
5365
5366 while _next_ordinal_to_read < 5 {
5368 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5369 _next_ordinal_to_read += 1;
5370 next_offset += envelope_size;
5371 }
5372
5373 let next_out_of_line = decoder.next_out_of_line();
5374 let handles_before = decoder.remaining_handles();
5375 if let Some((inlined, num_bytes, num_handles)) =
5376 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5377 {
5378 let member_inline_size =
5379 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5380 if inlined != (member_inline_size <= 4) {
5381 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5382 }
5383 let inner_offset;
5384 let mut inner_depth = depth.clone();
5385 if inlined {
5386 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5387 inner_offset = next_offset;
5388 } else {
5389 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5390 inner_depth.increment()?;
5391 }
5392 let val_ref =
5393 self.spectrum_bandwidth_hz.get_or_insert_with(|| fidl::new_empty!(u64, D));
5394 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5395 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5396 {
5397 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5398 }
5399 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5400 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5401 }
5402 }
5403
5404 next_offset += envelope_size;
5405 _next_ordinal_to_read += 1;
5406 if next_offset >= end_offset {
5407 return Ok(());
5408 }
5409
5410 while _next_ordinal_to_read < 6 {
5412 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5413 _next_ordinal_to_read += 1;
5414 next_offset += envelope_size;
5415 }
5416
5417 let next_out_of_line = decoder.next_out_of_line();
5418 let handles_before = decoder.remaining_handles();
5419 if let Some((inlined, num_bytes, num_handles)) =
5420 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5421 {
5422 let member_inline_size =
5423 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5424 if inlined != (member_inline_size <= 4) {
5425 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5426 }
5427 let inner_offset;
5428 let mut inner_depth = depth.clone();
5429 if inlined {
5430 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5431 inner_offset = next_offset;
5432 } else {
5433 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5434 inner_depth.increment()?;
5435 }
5436 let val_ref = self
5437 .masked_by_regulatory_domain
5438 .get_or_insert_with(|| fidl::new_empty!(bool, D));
5439 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5440 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5441 {
5442 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5443 }
5444 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5445 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5446 }
5447 }
5448
5449 next_offset += envelope_size;
5450
5451 while next_offset < end_offset {
5453 _next_ordinal_to_read += 1;
5454 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5455 next_offset += envelope_size;
5456 }
5457
5458 Ok(())
5459 }
5460 }
5461
5462 impl Dhcp6PdInfo {
5463 #[inline(always)]
5464 fn max_ordinal_present(&self) -> u64 {
5465 if let Some(_) = self.hashed_pd_prefix {
5466 return 3;
5467 }
5468 if let Some(_) = self.pd_processed_ra_info {
5469 return 2;
5470 }
5471 if let Some(_) = self.dhcp6pd_state {
5472 return 1;
5473 }
5474 0
5475 }
5476 }
5477
5478 impl fidl::encoding::ValueTypeMarker for Dhcp6PdInfo {
5479 type Borrowed<'a> = &'a Self;
5480 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5481 value
5482 }
5483 }
5484
5485 unsafe impl fidl::encoding::TypeMarker for Dhcp6PdInfo {
5486 type Owned = Self;
5487
5488 #[inline(always)]
5489 fn inline_align(_context: fidl::encoding::Context) -> usize {
5490 8
5491 }
5492
5493 #[inline(always)]
5494 fn inline_size(_context: fidl::encoding::Context) -> usize {
5495 16
5496 }
5497 }
5498
5499 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dhcp6PdInfo, D>
5500 for &Dhcp6PdInfo
5501 {
5502 unsafe fn encode(
5503 self,
5504 encoder: &mut fidl::encoding::Encoder<'_, D>,
5505 offset: usize,
5506 mut depth: fidl::encoding::Depth,
5507 ) -> fidl::Result<()> {
5508 encoder.debug_check_bounds::<Dhcp6PdInfo>(offset);
5509 let max_ordinal: u64 = self.max_ordinal_present();
5511 encoder.write_num(max_ordinal, offset);
5512 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5513 if max_ordinal == 0 {
5515 return Ok(());
5516 }
5517 depth.increment()?;
5518 let envelope_size = 8;
5519 let bytes_len = max_ordinal as usize * envelope_size;
5520 #[allow(unused_variables)]
5521 let offset = encoder.out_of_line_offset(bytes_len);
5522 let mut _prev_end_offset: usize = 0;
5523 if 1 > max_ordinal {
5524 return Ok(());
5525 }
5526
5527 let cur_offset: usize = (1 - 1) * envelope_size;
5530
5531 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5533
5534 fidl::encoding::encode_in_envelope_optional::<Dhcp6PdState, D>(
5539 self.dhcp6pd_state
5540 .as_ref()
5541 .map(<Dhcp6PdState as fidl::encoding::ValueTypeMarker>::borrow),
5542 encoder,
5543 offset + cur_offset,
5544 depth,
5545 )?;
5546
5547 _prev_end_offset = cur_offset + envelope_size;
5548 if 2 > max_ordinal {
5549 return Ok(());
5550 }
5551
5552 let cur_offset: usize = (2 - 1) * envelope_size;
5555
5556 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5558
5559 fidl::encoding::encode_in_envelope_optional::<PdProcessedRaInfo, D>(
5564 self.pd_processed_ra_info
5565 .as_ref()
5566 .map(<PdProcessedRaInfo as fidl::encoding::ValueTypeMarker>::borrow),
5567 encoder,
5568 offset + cur_offset,
5569 depth,
5570 )?;
5571
5572 _prev_end_offset = cur_offset + envelope_size;
5573 if 3 > max_ordinal {
5574 return Ok(());
5575 }
5576
5577 let cur_offset: usize = (3 - 1) * envelope_size;
5580
5581 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5583
5584 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
5589 self.hashed_pd_prefix.as_ref().map(
5590 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
5591 ),
5592 encoder,
5593 offset + cur_offset,
5594 depth,
5595 )?;
5596
5597 _prev_end_offset = cur_offset + envelope_size;
5598
5599 Ok(())
5600 }
5601 }
5602
5603 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dhcp6PdInfo {
5604 #[inline(always)]
5605 fn new_empty() -> Self {
5606 Self::default()
5607 }
5608
5609 unsafe fn decode(
5610 &mut self,
5611 decoder: &mut fidl::encoding::Decoder<'_, D>,
5612 offset: usize,
5613 mut depth: fidl::encoding::Depth,
5614 ) -> fidl::Result<()> {
5615 decoder.debug_check_bounds::<Self>(offset);
5616 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5617 None => return Err(fidl::Error::NotNullable),
5618 Some(len) => len,
5619 };
5620 if len == 0 {
5622 return Ok(());
5623 };
5624 depth.increment()?;
5625 let envelope_size = 8;
5626 let bytes_len = len * envelope_size;
5627 let offset = decoder.out_of_line_offset(bytes_len)?;
5628 let mut _next_ordinal_to_read = 0;
5630 let mut next_offset = offset;
5631 let end_offset = offset + bytes_len;
5632 _next_ordinal_to_read += 1;
5633 if next_offset >= end_offset {
5634 return Ok(());
5635 }
5636
5637 while _next_ordinal_to_read < 1 {
5639 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5640 _next_ordinal_to_read += 1;
5641 next_offset += envelope_size;
5642 }
5643
5644 let next_out_of_line = decoder.next_out_of_line();
5645 let handles_before = decoder.remaining_handles();
5646 if let Some((inlined, num_bytes, num_handles)) =
5647 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5648 {
5649 let member_inline_size =
5650 <Dhcp6PdState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5651 if inlined != (member_inline_size <= 4) {
5652 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5653 }
5654 let inner_offset;
5655 let mut inner_depth = depth.clone();
5656 if inlined {
5657 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5658 inner_offset = next_offset;
5659 } else {
5660 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5661 inner_depth.increment()?;
5662 }
5663 let val_ref =
5664 self.dhcp6pd_state.get_or_insert_with(|| fidl::new_empty!(Dhcp6PdState, D));
5665 fidl::decode!(Dhcp6PdState, D, val_ref, decoder, inner_offset, inner_depth)?;
5666 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5667 {
5668 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5669 }
5670 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5671 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5672 }
5673 }
5674
5675 next_offset += envelope_size;
5676 _next_ordinal_to_read += 1;
5677 if next_offset >= end_offset {
5678 return Ok(());
5679 }
5680
5681 while _next_ordinal_to_read < 2 {
5683 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5684 _next_ordinal_to_read += 1;
5685 next_offset += envelope_size;
5686 }
5687
5688 let next_out_of_line = decoder.next_out_of_line();
5689 let handles_before = decoder.remaining_handles();
5690 if let Some((inlined, num_bytes, num_handles)) =
5691 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5692 {
5693 let member_inline_size =
5694 <PdProcessedRaInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5695 if inlined != (member_inline_size <= 4) {
5696 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5697 }
5698 let inner_offset;
5699 let mut inner_depth = depth.clone();
5700 if inlined {
5701 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5702 inner_offset = next_offset;
5703 } else {
5704 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5705 inner_depth.increment()?;
5706 }
5707 let val_ref = self
5708 .pd_processed_ra_info
5709 .get_or_insert_with(|| fidl::new_empty!(PdProcessedRaInfo, D));
5710 fidl::decode!(PdProcessedRaInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
5711 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5712 {
5713 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5714 }
5715 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5716 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5717 }
5718 }
5719
5720 next_offset += envelope_size;
5721 _next_ordinal_to_read += 1;
5722 if next_offset >= end_offset {
5723 return Ok(());
5724 }
5725
5726 while _next_ordinal_to_read < 3 {
5728 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5729 _next_ordinal_to_read += 1;
5730 next_offset += envelope_size;
5731 }
5732
5733 let next_out_of_line = decoder.next_out_of_line();
5734 let handles_before = decoder.remaining_handles();
5735 if let Some((inlined, num_bytes, num_handles)) =
5736 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5737 {
5738 let member_inline_size =
5739 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
5740 decoder.context,
5741 );
5742 if inlined != (member_inline_size <= 4) {
5743 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5744 }
5745 let inner_offset;
5746 let mut inner_depth = depth.clone();
5747 if inlined {
5748 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5749 inner_offset = next_offset;
5750 } else {
5751 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5752 inner_depth.increment()?;
5753 }
5754 let val_ref = self
5755 .hashed_pd_prefix
5756 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
5757 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
5758 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5759 {
5760 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5761 }
5762 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5763 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5764 }
5765 }
5766
5767 next_offset += envelope_size;
5768
5769 while next_offset < end_offset {
5771 _next_ordinal_to_read += 1;
5772 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5773 next_offset += envelope_size;
5774 }
5775
5776 Ok(())
5777 }
5778 }
5779
5780 impl DnssdCounters {
5781 #[inline(always)]
5782 fn max_ordinal_present(&self) -> u64 {
5783 if let Some(_) = self.upstream_dns_counters {
5784 return 8;
5785 }
5786 if let Some(_) = self.resolved_by_srp {
5787 return 7;
5788 }
5789 if let Some(_) = self.other_response {
5790 return 6;
5791 }
5792 if let Some(_) = self.not_implemented_response {
5793 return 5;
5794 }
5795 if let Some(_) = self.name_error_response {
5796 return 4;
5797 }
5798 if let Some(_) = self.format_error_response {
5799 return 3;
5800 }
5801 if let Some(_) = self.server_failure_response {
5802 return 2;
5803 }
5804 if let Some(_) = self.success_response {
5805 return 1;
5806 }
5807 0
5808 }
5809 }
5810
5811 impl fidl::encoding::ValueTypeMarker for DnssdCounters {
5812 type Borrowed<'a> = &'a Self;
5813 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5814 value
5815 }
5816 }
5817
5818 unsafe impl fidl::encoding::TypeMarker for DnssdCounters {
5819 type Owned = Self;
5820
5821 #[inline(always)]
5822 fn inline_align(_context: fidl::encoding::Context) -> usize {
5823 8
5824 }
5825
5826 #[inline(always)]
5827 fn inline_size(_context: fidl::encoding::Context) -> usize {
5828 16
5829 }
5830 }
5831
5832 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DnssdCounters, D>
5833 for &DnssdCounters
5834 {
5835 unsafe fn encode(
5836 self,
5837 encoder: &mut fidl::encoding::Encoder<'_, D>,
5838 offset: usize,
5839 mut depth: fidl::encoding::Depth,
5840 ) -> fidl::Result<()> {
5841 encoder.debug_check_bounds::<DnssdCounters>(offset);
5842 let max_ordinal: u64 = self.max_ordinal_present();
5844 encoder.write_num(max_ordinal, offset);
5845 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5846 if max_ordinal == 0 {
5848 return Ok(());
5849 }
5850 depth.increment()?;
5851 let envelope_size = 8;
5852 let bytes_len = max_ordinal as usize * envelope_size;
5853 #[allow(unused_variables)]
5854 let offset = encoder.out_of_line_offset(bytes_len);
5855 let mut _prev_end_offset: usize = 0;
5856 if 1 > max_ordinal {
5857 return Ok(());
5858 }
5859
5860 let cur_offset: usize = (1 - 1) * envelope_size;
5863
5864 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5866
5867 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5872 self.success_response
5873 .as_ref()
5874 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5875 encoder,
5876 offset + cur_offset,
5877 depth,
5878 )?;
5879
5880 _prev_end_offset = cur_offset + envelope_size;
5881 if 2 > max_ordinal {
5882 return Ok(());
5883 }
5884
5885 let cur_offset: usize = (2 - 1) * envelope_size;
5888
5889 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5891
5892 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5897 self.server_failure_response
5898 .as_ref()
5899 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5900 encoder,
5901 offset + cur_offset,
5902 depth,
5903 )?;
5904
5905 _prev_end_offset = cur_offset + envelope_size;
5906 if 3 > max_ordinal {
5907 return Ok(());
5908 }
5909
5910 let cur_offset: usize = (3 - 1) * envelope_size;
5913
5914 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5916
5917 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5922 self.format_error_response
5923 .as_ref()
5924 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5925 encoder,
5926 offset + cur_offset,
5927 depth,
5928 )?;
5929
5930 _prev_end_offset = cur_offset + envelope_size;
5931 if 4 > max_ordinal {
5932 return Ok(());
5933 }
5934
5935 let cur_offset: usize = (4 - 1) * envelope_size;
5938
5939 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5941
5942 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5947 self.name_error_response
5948 .as_ref()
5949 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5950 encoder,
5951 offset + cur_offset,
5952 depth,
5953 )?;
5954
5955 _prev_end_offset = cur_offset + envelope_size;
5956 if 5 > max_ordinal {
5957 return Ok(());
5958 }
5959
5960 let cur_offset: usize = (5 - 1) * envelope_size;
5963
5964 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5966
5967 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5972 self.not_implemented_response
5973 .as_ref()
5974 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5975 encoder,
5976 offset + cur_offset,
5977 depth,
5978 )?;
5979
5980 _prev_end_offset = cur_offset + envelope_size;
5981 if 6 > max_ordinal {
5982 return Ok(());
5983 }
5984
5985 let cur_offset: usize = (6 - 1) * envelope_size;
5988
5989 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5991
5992 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5997 self.other_response.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5998 encoder,
5999 offset + cur_offset,
6000 depth,
6001 )?;
6002
6003 _prev_end_offset = cur_offset + envelope_size;
6004 if 7 > max_ordinal {
6005 return Ok(());
6006 }
6007
6008 let cur_offset: usize = (7 - 1) * envelope_size;
6011
6012 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6014
6015 fidl::encoding::encode_in_envelope_optional::<u32, D>(
6020 self.resolved_by_srp.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6021 encoder,
6022 offset + cur_offset,
6023 depth,
6024 )?;
6025
6026 _prev_end_offset = cur_offset + envelope_size;
6027 if 8 > max_ordinal {
6028 return Ok(());
6029 }
6030
6031 let cur_offset: usize = (8 - 1) * envelope_size;
6034
6035 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6037
6038 fidl::encoding::encode_in_envelope_optional::<UpstreamDnsCounters, D>(
6043 self.upstream_dns_counters
6044 .as_ref()
6045 .map(<UpstreamDnsCounters as fidl::encoding::ValueTypeMarker>::borrow),
6046 encoder,
6047 offset + cur_offset,
6048 depth,
6049 )?;
6050
6051 _prev_end_offset = cur_offset + envelope_size;
6052
6053 Ok(())
6054 }
6055 }
6056
6057 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DnssdCounters {
6058 #[inline(always)]
6059 fn new_empty() -> Self {
6060 Self::default()
6061 }
6062
6063 unsafe fn decode(
6064 &mut self,
6065 decoder: &mut fidl::encoding::Decoder<'_, D>,
6066 offset: usize,
6067 mut depth: fidl::encoding::Depth,
6068 ) -> fidl::Result<()> {
6069 decoder.debug_check_bounds::<Self>(offset);
6070 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6071 None => return Err(fidl::Error::NotNullable),
6072 Some(len) => len,
6073 };
6074 if len == 0 {
6076 return Ok(());
6077 };
6078 depth.increment()?;
6079 let envelope_size = 8;
6080 let bytes_len = len * envelope_size;
6081 let offset = decoder.out_of_line_offset(bytes_len)?;
6082 let mut _next_ordinal_to_read = 0;
6084 let mut next_offset = offset;
6085 let end_offset = offset + bytes_len;
6086 _next_ordinal_to_read += 1;
6087 if next_offset >= end_offset {
6088 return Ok(());
6089 }
6090
6091 while _next_ordinal_to_read < 1 {
6093 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6094 _next_ordinal_to_read += 1;
6095 next_offset += envelope_size;
6096 }
6097
6098 let next_out_of_line = decoder.next_out_of_line();
6099 let handles_before = decoder.remaining_handles();
6100 if let Some((inlined, num_bytes, num_handles)) =
6101 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6102 {
6103 let member_inline_size =
6104 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6105 if inlined != (member_inline_size <= 4) {
6106 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6107 }
6108 let inner_offset;
6109 let mut inner_depth = depth.clone();
6110 if inlined {
6111 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6112 inner_offset = next_offset;
6113 } else {
6114 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6115 inner_depth.increment()?;
6116 }
6117 let val_ref = self.success_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6118 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6119 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6120 {
6121 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6122 }
6123 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6124 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6125 }
6126 }
6127
6128 next_offset += envelope_size;
6129 _next_ordinal_to_read += 1;
6130 if next_offset >= end_offset {
6131 return Ok(());
6132 }
6133
6134 while _next_ordinal_to_read < 2 {
6136 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6137 _next_ordinal_to_read += 1;
6138 next_offset += envelope_size;
6139 }
6140
6141 let next_out_of_line = decoder.next_out_of_line();
6142 let handles_before = decoder.remaining_handles();
6143 if let Some((inlined, num_bytes, num_handles)) =
6144 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6145 {
6146 let member_inline_size =
6147 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6148 if inlined != (member_inline_size <= 4) {
6149 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6150 }
6151 let inner_offset;
6152 let mut inner_depth = depth.clone();
6153 if inlined {
6154 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6155 inner_offset = next_offset;
6156 } else {
6157 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6158 inner_depth.increment()?;
6159 }
6160 let val_ref =
6161 self.server_failure_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6162 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6163 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6164 {
6165 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6166 }
6167 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6168 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6169 }
6170 }
6171
6172 next_offset += envelope_size;
6173 _next_ordinal_to_read += 1;
6174 if next_offset >= end_offset {
6175 return Ok(());
6176 }
6177
6178 while _next_ordinal_to_read < 3 {
6180 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6181 _next_ordinal_to_read += 1;
6182 next_offset += envelope_size;
6183 }
6184
6185 let next_out_of_line = decoder.next_out_of_line();
6186 let handles_before = decoder.remaining_handles();
6187 if let Some((inlined, num_bytes, num_handles)) =
6188 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6189 {
6190 let member_inline_size =
6191 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6192 if inlined != (member_inline_size <= 4) {
6193 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6194 }
6195 let inner_offset;
6196 let mut inner_depth = depth.clone();
6197 if inlined {
6198 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6199 inner_offset = next_offset;
6200 } else {
6201 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6202 inner_depth.increment()?;
6203 }
6204 let val_ref =
6205 self.format_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6206 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6207 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6208 {
6209 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6210 }
6211 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6212 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6213 }
6214 }
6215
6216 next_offset += envelope_size;
6217 _next_ordinal_to_read += 1;
6218 if next_offset >= end_offset {
6219 return Ok(());
6220 }
6221
6222 while _next_ordinal_to_read < 4 {
6224 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6225 _next_ordinal_to_read += 1;
6226 next_offset += envelope_size;
6227 }
6228
6229 let next_out_of_line = decoder.next_out_of_line();
6230 let handles_before = decoder.remaining_handles();
6231 if let Some((inlined, num_bytes, num_handles)) =
6232 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6233 {
6234 let member_inline_size =
6235 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6236 if inlined != (member_inline_size <= 4) {
6237 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6238 }
6239 let inner_offset;
6240 let mut inner_depth = depth.clone();
6241 if inlined {
6242 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6243 inner_offset = next_offset;
6244 } else {
6245 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6246 inner_depth.increment()?;
6247 }
6248 let val_ref =
6249 self.name_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6250 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6251 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6252 {
6253 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6254 }
6255 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6256 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6257 }
6258 }
6259
6260 next_offset += envelope_size;
6261 _next_ordinal_to_read += 1;
6262 if next_offset >= end_offset {
6263 return Ok(());
6264 }
6265
6266 while _next_ordinal_to_read < 5 {
6268 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6269 _next_ordinal_to_read += 1;
6270 next_offset += envelope_size;
6271 }
6272
6273 let next_out_of_line = decoder.next_out_of_line();
6274 let handles_before = decoder.remaining_handles();
6275 if let Some((inlined, num_bytes, num_handles)) =
6276 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6277 {
6278 let member_inline_size =
6279 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6280 if inlined != (member_inline_size <= 4) {
6281 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6282 }
6283 let inner_offset;
6284 let mut inner_depth = depth.clone();
6285 if inlined {
6286 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6287 inner_offset = next_offset;
6288 } else {
6289 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6290 inner_depth.increment()?;
6291 }
6292 let val_ref =
6293 self.not_implemented_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6294 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6295 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6296 {
6297 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6298 }
6299 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6300 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6301 }
6302 }
6303
6304 next_offset += envelope_size;
6305 _next_ordinal_to_read += 1;
6306 if next_offset >= end_offset {
6307 return Ok(());
6308 }
6309
6310 while _next_ordinal_to_read < 6 {
6312 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6313 _next_ordinal_to_read += 1;
6314 next_offset += envelope_size;
6315 }
6316
6317 let next_out_of_line = decoder.next_out_of_line();
6318 let handles_before = decoder.remaining_handles();
6319 if let Some((inlined, num_bytes, num_handles)) =
6320 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6321 {
6322 let member_inline_size =
6323 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6324 if inlined != (member_inline_size <= 4) {
6325 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6326 }
6327 let inner_offset;
6328 let mut inner_depth = depth.clone();
6329 if inlined {
6330 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6331 inner_offset = next_offset;
6332 } else {
6333 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6334 inner_depth.increment()?;
6335 }
6336 let val_ref = self.other_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6337 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6338 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6339 {
6340 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6341 }
6342 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6343 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6344 }
6345 }
6346
6347 next_offset += envelope_size;
6348 _next_ordinal_to_read += 1;
6349 if next_offset >= end_offset {
6350 return Ok(());
6351 }
6352
6353 while _next_ordinal_to_read < 7 {
6355 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6356 _next_ordinal_to_read += 1;
6357 next_offset += envelope_size;
6358 }
6359
6360 let next_out_of_line = decoder.next_out_of_line();
6361 let handles_before = decoder.remaining_handles();
6362 if let Some((inlined, num_bytes, num_handles)) =
6363 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6364 {
6365 let member_inline_size =
6366 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6367 if inlined != (member_inline_size <= 4) {
6368 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6369 }
6370 let inner_offset;
6371 let mut inner_depth = depth.clone();
6372 if inlined {
6373 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6374 inner_offset = next_offset;
6375 } else {
6376 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6377 inner_depth.increment()?;
6378 }
6379 let val_ref = self.resolved_by_srp.get_or_insert_with(|| fidl::new_empty!(u32, D));
6380 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6381 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6382 {
6383 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6384 }
6385 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6386 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6387 }
6388 }
6389
6390 next_offset += envelope_size;
6391 _next_ordinal_to_read += 1;
6392 if next_offset >= end_offset {
6393 return Ok(());
6394 }
6395
6396 while _next_ordinal_to_read < 8 {
6398 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6399 _next_ordinal_to_read += 1;
6400 next_offset += envelope_size;
6401 }
6402
6403 let next_out_of_line = decoder.next_out_of_line();
6404 let handles_before = decoder.remaining_handles();
6405 if let Some((inlined, num_bytes, num_handles)) =
6406 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6407 {
6408 let member_inline_size =
6409 <UpstreamDnsCounters as fidl::encoding::TypeMarker>::inline_size(
6410 decoder.context,
6411 );
6412 if inlined != (member_inline_size <= 4) {
6413 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6414 }
6415 let inner_offset;
6416 let mut inner_depth = depth.clone();
6417 if inlined {
6418 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6419 inner_offset = next_offset;
6420 } else {
6421 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6422 inner_depth.increment()?;
6423 }
6424 let val_ref = self
6425 .upstream_dns_counters
6426 .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsCounters, D));
6427 fidl::decode!(UpstreamDnsCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
6428 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6429 {
6430 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6431 }
6432 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6433 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6434 }
6435 }
6436
6437 next_offset += envelope_size;
6438
6439 while next_offset < end_offset {
6441 _next_ordinal_to_read += 1;
6442 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6443 next_offset += envelope_size;
6444 }
6445
6446 Ok(())
6447 }
6448 }
6449
6450 impl ExternalRoute {
6451 #[inline(always)]
6452 fn max_ordinal_present(&self) -> u64 {
6453 if let Some(_) = self.stable {
6454 return 3;
6455 }
6456 if let Some(_) = self.route_preference {
6457 return 2;
6458 }
6459 if let Some(_) = self.subnet {
6460 return 1;
6461 }
6462 0
6463 }
6464 }
6465
6466 impl fidl::encoding::ValueTypeMarker for ExternalRoute {
6467 type Borrowed<'a> = &'a Self;
6468 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6469 value
6470 }
6471 }
6472
6473 unsafe impl fidl::encoding::TypeMarker for ExternalRoute {
6474 type Owned = Self;
6475
6476 #[inline(always)]
6477 fn inline_align(_context: fidl::encoding::Context) -> usize {
6478 8
6479 }
6480
6481 #[inline(always)]
6482 fn inline_size(_context: fidl::encoding::Context) -> usize {
6483 16
6484 }
6485 }
6486
6487 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExternalRoute, D>
6488 for &ExternalRoute
6489 {
6490 unsafe fn encode(
6491 self,
6492 encoder: &mut fidl::encoding::Encoder<'_, D>,
6493 offset: usize,
6494 mut depth: fidl::encoding::Depth,
6495 ) -> fidl::Result<()> {
6496 encoder.debug_check_bounds::<ExternalRoute>(offset);
6497 let max_ordinal: u64 = self.max_ordinal_present();
6499 encoder.write_num(max_ordinal, offset);
6500 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6501 if max_ordinal == 0 {
6503 return Ok(());
6504 }
6505 depth.increment()?;
6506 let envelope_size = 8;
6507 let bytes_len = max_ordinal as usize * envelope_size;
6508 #[allow(unused_variables)]
6509 let offset = encoder.out_of_line_offset(bytes_len);
6510 let mut _prev_end_offset: usize = 0;
6511 if 1 > max_ordinal {
6512 return Ok(());
6513 }
6514
6515 let cur_offset: usize = (1 - 1) * envelope_size;
6518
6519 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6521
6522 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
6527 self.subnet.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
6528 encoder, offset + cur_offset, depth
6529 )?;
6530
6531 _prev_end_offset = cur_offset + envelope_size;
6532 if 2 > max_ordinal {
6533 return Ok(());
6534 }
6535
6536 let cur_offset: usize = (2 - 1) * envelope_size;
6539
6540 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6542
6543 fidl::encoding::encode_in_envelope_optional::<RoutePreference, D>(
6548 self.route_preference
6549 .as_ref()
6550 .map(<RoutePreference as fidl::encoding::ValueTypeMarker>::borrow),
6551 encoder,
6552 offset + cur_offset,
6553 depth,
6554 )?;
6555
6556 _prev_end_offset = cur_offset + envelope_size;
6557 if 3 > max_ordinal {
6558 return Ok(());
6559 }
6560
6561 let cur_offset: usize = (3 - 1) * envelope_size;
6564
6565 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6567
6568 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6573 self.stable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6574 encoder,
6575 offset + cur_offset,
6576 depth,
6577 )?;
6578
6579 _prev_end_offset = cur_offset + envelope_size;
6580
6581 Ok(())
6582 }
6583 }
6584
6585 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExternalRoute {
6586 #[inline(always)]
6587 fn new_empty() -> Self {
6588 Self::default()
6589 }
6590
6591 unsafe fn decode(
6592 &mut self,
6593 decoder: &mut fidl::encoding::Decoder<'_, D>,
6594 offset: usize,
6595 mut depth: fidl::encoding::Depth,
6596 ) -> fidl::Result<()> {
6597 decoder.debug_check_bounds::<Self>(offset);
6598 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6599 None => return Err(fidl::Error::NotNullable),
6600 Some(len) => len,
6601 };
6602 if len == 0 {
6604 return Ok(());
6605 };
6606 depth.increment()?;
6607 let envelope_size = 8;
6608 let bytes_len = len * envelope_size;
6609 let offset = decoder.out_of_line_offset(bytes_len)?;
6610 let mut _next_ordinal_to_read = 0;
6612 let mut next_offset = offset;
6613 let end_offset = offset + bytes_len;
6614 _next_ordinal_to_read += 1;
6615 if next_offset >= end_offset {
6616 return Ok(());
6617 }
6618
6619 while _next_ordinal_to_read < 1 {
6621 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6622 _next_ordinal_to_read += 1;
6623 next_offset += envelope_size;
6624 }
6625
6626 let next_out_of_line = decoder.next_out_of_line();
6627 let handles_before = decoder.remaining_handles();
6628 if let Some((inlined, num_bytes, num_handles)) =
6629 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6630 {
6631 let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6632 if inlined != (member_inline_size <= 4) {
6633 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6634 }
6635 let inner_offset;
6636 let mut inner_depth = depth.clone();
6637 if inlined {
6638 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6639 inner_offset = next_offset;
6640 } else {
6641 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6642 inner_depth.increment()?;
6643 }
6644 let val_ref = self.subnet.get_or_insert_with(|| {
6645 fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
6646 });
6647 fidl::decode!(
6648 fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
6649 D,
6650 val_ref,
6651 decoder,
6652 inner_offset,
6653 inner_depth
6654 )?;
6655 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6656 {
6657 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6658 }
6659 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6660 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6661 }
6662 }
6663
6664 next_offset += envelope_size;
6665 _next_ordinal_to_read += 1;
6666 if next_offset >= end_offset {
6667 return Ok(());
6668 }
6669
6670 while _next_ordinal_to_read < 2 {
6672 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6673 _next_ordinal_to_read += 1;
6674 next_offset += envelope_size;
6675 }
6676
6677 let next_out_of_line = decoder.next_out_of_line();
6678 let handles_before = decoder.remaining_handles();
6679 if let Some((inlined, num_bytes, num_handles)) =
6680 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6681 {
6682 let member_inline_size =
6683 <RoutePreference as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6684 if inlined != (member_inline_size <= 4) {
6685 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6686 }
6687 let inner_offset;
6688 let mut inner_depth = depth.clone();
6689 if inlined {
6690 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6691 inner_offset = next_offset;
6692 } else {
6693 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6694 inner_depth.increment()?;
6695 }
6696 let val_ref = self
6697 .route_preference
6698 .get_or_insert_with(|| fidl::new_empty!(RoutePreference, D));
6699 fidl::decode!(RoutePreference, D, val_ref, decoder, inner_offset, inner_depth)?;
6700 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6701 {
6702 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6703 }
6704 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6705 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6706 }
6707 }
6708
6709 next_offset += envelope_size;
6710 _next_ordinal_to_read += 1;
6711 if next_offset >= end_offset {
6712 return Ok(());
6713 }
6714
6715 while _next_ordinal_to_read < 3 {
6717 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6718 _next_ordinal_to_read += 1;
6719 next_offset += envelope_size;
6720 }
6721
6722 let next_out_of_line = decoder.next_out_of_line();
6723 let handles_before = decoder.remaining_handles();
6724 if let Some((inlined, num_bytes, num_handles)) =
6725 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6726 {
6727 let member_inline_size =
6728 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6729 if inlined != (member_inline_size <= 4) {
6730 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6731 }
6732 let inner_offset;
6733 let mut inner_depth = depth.clone();
6734 if inlined {
6735 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6736 inner_offset = next_offset;
6737 } else {
6738 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6739 inner_depth.increment()?;
6740 }
6741 let val_ref = self.stable.get_or_insert_with(|| fidl::new_empty!(bool, D));
6742 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6743 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6744 {
6745 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6746 }
6747 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6748 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6749 }
6750 }
6751
6752 next_offset += envelope_size;
6753
6754 while next_offset < end_offset {
6756 _next_ordinal_to_read += 1;
6757 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6758 next_offset += envelope_size;
6759 }
6760
6761 Ok(())
6762 }
6763 }
6764
6765 impl JoinerCommissioningParams {
6766 #[inline(always)]
6767 fn max_ordinal_present(&self) -> u64 {
6768 if let Some(_) = self.vendor_data_string {
6769 return 6;
6770 }
6771 if let Some(_) = self.vendor_sw_version {
6772 return 5;
6773 }
6774 if let Some(_) = self.vendor_model {
6775 return 4;
6776 }
6777 if let Some(_) = self.vendor_name {
6778 return 3;
6779 }
6780 if let Some(_) = self.provisioning_url {
6781 return 2;
6782 }
6783 if let Some(_) = self.pskd {
6784 return 1;
6785 }
6786 0
6787 }
6788 }
6789
6790 impl fidl::encoding::ValueTypeMarker for JoinerCommissioningParams {
6791 type Borrowed<'a> = &'a Self;
6792 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6793 value
6794 }
6795 }
6796
6797 unsafe impl fidl::encoding::TypeMarker for JoinerCommissioningParams {
6798 type Owned = Self;
6799
6800 #[inline(always)]
6801 fn inline_align(_context: fidl::encoding::Context) -> usize {
6802 8
6803 }
6804
6805 #[inline(always)]
6806 fn inline_size(_context: fidl::encoding::Context) -> usize {
6807 16
6808 }
6809 }
6810
6811 unsafe impl<D: fidl::encoding::ResourceDialect>
6812 fidl::encoding::Encode<JoinerCommissioningParams, D> for &JoinerCommissioningParams
6813 {
6814 unsafe fn encode(
6815 self,
6816 encoder: &mut fidl::encoding::Encoder<'_, D>,
6817 offset: usize,
6818 mut depth: fidl::encoding::Depth,
6819 ) -> fidl::Result<()> {
6820 encoder.debug_check_bounds::<JoinerCommissioningParams>(offset);
6821 let max_ordinal: u64 = self.max_ordinal_present();
6823 encoder.write_num(max_ordinal, offset);
6824 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6825 if max_ordinal == 0 {
6827 return Ok(());
6828 }
6829 depth.increment()?;
6830 let envelope_size = 8;
6831 let bytes_len = max_ordinal as usize * envelope_size;
6832 #[allow(unused_variables)]
6833 let offset = encoder.out_of_line_offset(bytes_len);
6834 let mut _prev_end_offset: usize = 0;
6835 if 1 > max_ordinal {
6836 return Ok(());
6837 }
6838
6839 let cur_offset: usize = (1 - 1) * envelope_size;
6842
6843 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6845
6846 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6851 self.pskd.as_ref().map(
6852 <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6853 ),
6854 encoder,
6855 offset + cur_offset,
6856 depth,
6857 )?;
6858
6859 _prev_end_offset = cur_offset + envelope_size;
6860 if 2 > max_ordinal {
6861 return Ok(());
6862 }
6863
6864 let cur_offset: usize = (2 - 1) * envelope_size;
6867
6868 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6870
6871 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6876 self.provisioning_url.as_ref().map(
6877 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6878 ),
6879 encoder,
6880 offset + cur_offset,
6881 depth,
6882 )?;
6883
6884 _prev_end_offset = cur_offset + envelope_size;
6885 if 3 > max_ordinal {
6886 return Ok(());
6887 }
6888
6889 let cur_offset: usize = (3 - 1) * envelope_size;
6892
6893 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6895
6896 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6901 self.vendor_name.as_ref().map(
6902 <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6903 ),
6904 encoder,
6905 offset + cur_offset,
6906 depth,
6907 )?;
6908
6909 _prev_end_offset = cur_offset + envelope_size;
6910 if 4 > max_ordinal {
6911 return Ok(());
6912 }
6913
6914 let cur_offset: usize = (4 - 1) * envelope_size;
6917
6918 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6920
6921 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6926 self.vendor_model.as_ref().map(
6927 <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6928 ),
6929 encoder,
6930 offset + cur_offset,
6931 depth,
6932 )?;
6933
6934 _prev_end_offset = cur_offset + envelope_size;
6935 if 5 > max_ordinal {
6936 return Ok(());
6937 }
6938
6939 let cur_offset: usize = (5 - 1) * envelope_size;
6942
6943 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6945
6946 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<16>, D>(
6951 self.vendor_sw_version.as_ref().map(
6952 <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow,
6953 ),
6954 encoder,
6955 offset + cur_offset,
6956 depth,
6957 )?;
6958
6959 _prev_end_offset = cur_offset + envelope_size;
6960 if 6 > max_ordinal {
6961 return Ok(());
6962 }
6963
6964 let cur_offset: usize = (6 - 1) * envelope_size;
6967
6968 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6970
6971 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6976 self.vendor_data_string.as_ref().map(
6977 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6978 ),
6979 encoder,
6980 offset + cur_offset,
6981 depth,
6982 )?;
6983
6984 _prev_end_offset = cur_offset + envelope_size;
6985
6986 Ok(())
6987 }
6988 }
6989
6990 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6991 for JoinerCommissioningParams
6992 {
6993 #[inline(always)]
6994 fn new_empty() -> Self {
6995 Self::default()
6996 }
6997
6998 unsafe fn decode(
6999 &mut self,
7000 decoder: &mut fidl::encoding::Decoder<'_, D>,
7001 offset: usize,
7002 mut depth: fidl::encoding::Depth,
7003 ) -> fidl::Result<()> {
7004 decoder.debug_check_bounds::<Self>(offset);
7005 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7006 None => return Err(fidl::Error::NotNullable),
7007 Some(len) => len,
7008 };
7009 if len == 0 {
7011 return Ok(());
7012 };
7013 depth.increment()?;
7014 let envelope_size = 8;
7015 let bytes_len = len * envelope_size;
7016 let offset = decoder.out_of_line_offset(bytes_len)?;
7017 let mut _next_ordinal_to_read = 0;
7019 let mut next_offset = offset;
7020 let end_offset = offset + bytes_len;
7021 _next_ordinal_to_read += 1;
7022 if next_offset >= end_offset {
7023 return Ok(());
7024 }
7025
7026 while _next_ordinal_to_read < 1 {
7028 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7029 _next_ordinal_to_read += 1;
7030 next_offset += envelope_size;
7031 }
7032
7033 let next_out_of_line = decoder.next_out_of_line();
7034 let handles_before = decoder.remaining_handles();
7035 if let Some((inlined, num_bytes, num_handles)) =
7036 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7037 {
7038 let member_inline_size =
7039 <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
7040 decoder.context,
7041 );
7042 if inlined != (member_inline_size <= 4) {
7043 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7044 }
7045 let inner_offset;
7046 let mut inner_depth = depth.clone();
7047 if inlined {
7048 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7049 inner_offset = next_offset;
7050 } else {
7051 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7052 inner_depth.increment()?;
7053 }
7054 let val_ref = self
7055 .pskd
7056 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
7057 fidl::decode!(
7058 fidl::encoding::BoundedString<32>,
7059 D,
7060 val_ref,
7061 decoder,
7062 inner_offset,
7063 inner_depth
7064 )?;
7065 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7066 {
7067 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7068 }
7069 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7070 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7071 }
7072 }
7073
7074 next_offset += envelope_size;
7075 _next_ordinal_to_read += 1;
7076 if next_offset >= end_offset {
7077 return Ok(());
7078 }
7079
7080 while _next_ordinal_to_read < 2 {
7082 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7083 _next_ordinal_to_read += 1;
7084 next_offset += envelope_size;
7085 }
7086
7087 let next_out_of_line = decoder.next_out_of_line();
7088 let handles_before = decoder.remaining_handles();
7089 if let Some((inlined, num_bytes, num_handles)) =
7090 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7091 {
7092 let member_inline_size =
7093 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
7094 decoder.context,
7095 );
7096 if inlined != (member_inline_size <= 4) {
7097 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7098 }
7099 let inner_offset;
7100 let mut inner_depth = depth.clone();
7101 if inlined {
7102 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7103 inner_offset = next_offset;
7104 } else {
7105 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7106 inner_depth.increment()?;
7107 }
7108 let val_ref = self
7109 .provisioning_url
7110 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
7111 fidl::decode!(
7112 fidl::encoding::BoundedString<64>,
7113 D,
7114 val_ref,
7115 decoder,
7116 inner_offset,
7117 inner_depth
7118 )?;
7119 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7120 {
7121 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7122 }
7123 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7124 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7125 }
7126 }
7127
7128 next_offset += envelope_size;
7129 _next_ordinal_to_read += 1;
7130 if next_offset >= end_offset {
7131 return Ok(());
7132 }
7133
7134 while _next_ordinal_to_read < 3 {
7136 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7137 _next_ordinal_to_read += 1;
7138 next_offset += envelope_size;
7139 }
7140
7141 let next_out_of_line = decoder.next_out_of_line();
7142 let handles_before = decoder.remaining_handles();
7143 if let Some((inlined, num_bytes, num_handles)) =
7144 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7145 {
7146 let member_inline_size =
7147 <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
7148 decoder.context,
7149 );
7150 if inlined != (member_inline_size <= 4) {
7151 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7152 }
7153 let inner_offset;
7154 let mut inner_depth = depth.clone();
7155 if inlined {
7156 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7157 inner_offset = next_offset;
7158 } else {
7159 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7160 inner_depth.increment()?;
7161 }
7162 let val_ref = self
7163 .vendor_name
7164 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
7165 fidl::decode!(
7166 fidl::encoding::BoundedString<32>,
7167 D,
7168 val_ref,
7169 decoder,
7170 inner_offset,
7171 inner_depth
7172 )?;
7173 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7174 {
7175 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7176 }
7177 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7178 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7179 }
7180 }
7181
7182 next_offset += envelope_size;
7183 _next_ordinal_to_read += 1;
7184 if next_offset >= end_offset {
7185 return Ok(());
7186 }
7187
7188 while _next_ordinal_to_read < 4 {
7190 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7191 _next_ordinal_to_read += 1;
7192 next_offset += envelope_size;
7193 }
7194
7195 let next_out_of_line = decoder.next_out_of_line();
7196 let handles_before = decoder.remaining_handles();
7197 if let Some((inlined, num_bytes, num_handles)) =
7198 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7199 {
7200 let member_inline_size =
7201 <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
7202 decoder.context,
7203 );
7204 if inlined != (member_inline_size <= 4) {
7205 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7206 }
7207 let inner_offset;
7208 let mut inner_depth = depth.clone();
7209 if inlined {
7210 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7211 inner_offset = next_offset;
7212 } else {
7213 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7214 inner_depth.increment()?;
7215 }
7216 let val_ref = self
7217 .vendor_model
7218 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
7219 fidl::decode!(
7220 fidl::encoding::BoundedString<32>,
7221 D,
7222 val_ref,
7223 decoder,
7224 inner_offset,
7225 inner_depth
7226 )?;
7227 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7228 {
7229 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7230 }
7231 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7232 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7233 }
7234 }
7235
7236 next_offset += envelope_size;
7237 _next_ordinal_to_read += 1;
7238 if next_offset >= end_offset {
7239 return Ok(());
7240 }
7241
7242 while _next_ordinal_to_read < 5 {
7244 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7245 _next_ordinal_to_read += 1;
7246 next_offset += envelope_size;
7247 }
7248
7249 let next_out_of_line = decoder.next_out_of_line();
7250 let handles_before = decoder.remaining_handles();
7251 if let Some((inlined, num_bytes, num_handles)) =
7252 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7253 {
7254 let member_inline_size =
7255 <fidl::encoding::BoundedString<16> as fidl::encoding::TypeMarker>::inline_size(
7256 decoder.context,
7257 );
7258 if inlined != (member_inline_size <= 4) {
7259 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7260 }
7261 let inner_offset;
7262 let mut inner_depth = depth.clone();
7263 if inlined {
7264 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7265 inner_offset = next_offset;
7266 } else {
7267 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7268 inner_depth.increment()?;
7269 }
7270 let val_ref = self
7271 .vendor_sw_version
7272 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<16>, D));
7273 fidl::decode!(
7274 fidl::encoding::BoundedString<16>,
7275 D,
7276 val_ref,
7277 decoder,
7278 inner_offset,
7279 inner_depth
7280 )?;
7281 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7282 {
7283 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7284 }
7285 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7286 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7287 }
7288 }
7289
7290 next_offset += envelope_size;
7291 _next_ordinal_to_read += 1;
7292 if next_offset >= end_offset {
7293 return Ok(());
7294 }
7295
7296 while _next_ordinal_to_read < 6 {
7298 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7299 _next_ordinal_to_read += 1;
7300 next_offset += envelope_size;
7301 }
7302
7303 let next_out_of_line = decoder.next_out_of_line();
7304 let handles_before = decoder.remaining_handles();
7305 if let Some((inlined, num_bytes, num_handles)) =
7306 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7307 {
7308 let member_inline_size =
7309 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
7310 decoder.context,
7311 );
7312 if inlined != (member_inline_size <= 4) {
7313 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7314 }
7315 let inner_offset;
7316 let mut inner_depth = depth.clone();
7317 if inlined {
7318 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7319 inner_offset = next_offset;
7320 } else {
7321 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7322 inner_depth.increment()?;
7323 }
7324 let val_ref = self
7325 .vendor_data_string
7326 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
7327 fidl::decode!(
7328 fidl::encoding::BoundedString<64>,
7329 D,
7330 val_ref,
7331 decoder,
7332 inner_offset,
7333 inner_depth
7334 )?;
7335 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7336 {
7337 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7338 }
7339 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7340 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7341 }
7342 }
7343
7344 next_offset += envelope_size;
7345
7346 while next_offset < end_offset {
7348 _next_ordinal_to_read += 1;
7349 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7350 next_offset += envelope_size;
7351 }
7352
7353 Ok(())
7354 }
7355 }
7356
7357 impl LeaderData {
7358 #[inline(always)]
7359 fn max_ordinal_present(&self) -> u64 {
7360 if let Some(_) = self.router_id {
7361 return 5;
7362 }
7363 if let Some(_) = self.stable_network_data_version {
7364 return 4;
7365 }
7366 if let Some(_) = self.network_data_version {
7367 return 3;
7368 }
7369 if let Some(_) = self.weight {
7370 return 2;
7371 }
7372 if let Some(_) = self.partition_id {
7373 return 1;
7374 }
7375 0
7376 }
7377 }
7378
7379 impl fidl::encoding::ValueTypeMarker for LeaderData {
7380 type Borrowed<'a> = &'a Self;
7381 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7382 value
7383 }
7384 }
7385
7386 unsafe impl fidl::encoding::TypeMarker for LeaderData {
7387 type Owned = Self;
7388
7389 #[inline(always)]
7390 fn inline_align(_context: fidl::encoding::Context) -> usize {
7391 8
7392 }
7393
7394 #[inline(always)]
7395 fn inline_size(_context: fidl::encoding::Context) -> usize {
7396 16
7397 }
7398 }
7399
7400 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LeaderData, D>
7401 for &LeaderData
7402 {
7403 unsafe fn encode(
7404 self,
7405 encoder: &mut fidl::encoding::Encoder<'_, D>,
7406 offset: usize,
7407 mut depth: fidl::encoding::Depth,
7408 ) -> fidl::Result<()> {
7409 encoder.debug_check_bounds::<LeaderData>(offset);
7410 let max_ordinal: u64 = self.max_ordinal_present();
7412 encoder.write_num(max_ordinal, offset);
7413 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7414 if max_ordinal == 0 {
7416 return Ok(());
7417 }
7418 depth.increment()?;
7419 let envelope_size = 8;
7420 let bytes_len = max_ordinal as usize * envelope_size;
7421 #[allow(unused_variables)]
7422 let offset = encoder.out_of_line_offset(bytes_len);
7423 let mut _prev_end_offset: usize = 0;
7424 if 1 > max_ordinal {
7425 return Ok(());
7426 }
7427
7428 let cur_offset: usize = (1 - 1) * envelope_size;
7431
7432 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7434
7435 fidl::encoding::encode_in_envelope_optional::<u32, D>(
7440 self.partition_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7441 encoder,
7442 offset + cur_offset,
7443 depth,
7444 )?;
7445
7446 _prev_end_offset = cur_offset + envelope_size;
7447 if 2 > max_ordinal {
7448 return Ok(());
7449 }
7450
7451 let cur_offset: usize = (2 - 1) * envelope_size;
7454
7455 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7457
7458 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7463 self.weight.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7464 encoder,
7465 offset + cur_offset,
7466 depth,
7467 )?;
7468
7469 _prev_end_offset = cur_offset + envelope_size;
7470 if 3 > max_ordinal {
7471 return Ok(());
7472 }
7473
7474 let cur_offset: usize = (3 - 1) * envelope_size;
7477
7478 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7480
7481 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7486 self.network_data_version
7487 .as_ref()
7488 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7489 encoder,
7490 offset + cur_offset,
7491 depth,
7492 )?;
7493
7494 _prev_end_offset = cur_offset + envelope_size;
7495 if 4 > max_ordinal {
7496 return Ok(());
7497 }
7498
7499 let cur_offset: usize = (4 - 1) * envelope_size;
7502
7503 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7505
7506 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7511 self.stable_network_data_version
7512 .as_ref()
7513 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7514 encoder,
7515 offset + cur_offset,
7516 depth,
7517 )?;
7518
7519 _prev_end_offset = cur_offset + envelope_size;
7520 if 5 > max_ordinal {
7521 return Ok(());
7522 }
7523
7524 let cur_offset: usize = (5 - 1) * envelope_size;
7527
7528 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7530
7531 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7536 self.router_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7537 encoder,
7538 offset + cur_offset,
7539 depth,
7540 )?;
7541
7542 _prev_end_offset = cur_offset + envelope_size;
7543
7544 Ok(())
7545 }
7546 }
7547
7548 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeaderData {
7549 #[inline(always)]
7550 fn new_empty() -> Self {
7551 Self::default()
7552 }
7553
7554 unsafe fn decode(
7555 &mut self,
7556 decoder: &mut fidl::encoding::Decoder<'_, D>,
7557 offset: usize,
7558 mut depth: fidl::encoding::Depth,
7559 ) -> fidl::Result<()> {
7560 decoder.debug_check_bounds::<Self>(offset);
7561 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7562 None => return Err(fidl::Error::NotNullable),
7563 Some(len) => len,
7564 };
7565 if len == 0 {
7567 return Ok(());
7568 };
7569 depth.increment()?;
7570 let envelope_size = 8;
7571 let bytes_len = len * envelope_size;
7572 let offset = decoder.out_of_line_offset(bytes_len)?;
7573 let mut _next_ordinal_to_read = 0;
7575 let mut next_offset = offset;
7576 let end_offset = offset + bytes_len;
7577 _next_ordinal_to_read += 1;
7578 if next_offset >= end_offset {
7579 return Ok(());
7580 }
7581
7582 while _next_ordinal_to_read < 1 {
7584 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7585 _next_ordinal_to_read += 1;
7586 next_offset += envelope_size;
7587 }
7588
7589 let next_out_of_line = decoder.next_out_of_line();
7590 let handles_before = decoder.remaining_handles();
7591 if let Some((inlined, num_bytes, num_handles)) =
7592 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7593 {
7594 let member_inline_size =
7595 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7596 if inlined != (member_inline_size <= 4) {
7597 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7598 }
7599 let inner_offset;
7600 let mut inner_depth = depth.clone();
7601 if inlined {
7602 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7603 inner_offset = next_offset;
7604 } else {
7605 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7606 inner_depth.increment()?;
7607 }
7608 let val_ref = self.partition_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
7609 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7610 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7611 {
7612 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7613 }
7614 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7615 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7616 }
7617 }
7618
7619 next_offset += envelope_size;
7620 _next_ordinal_to_read += 1;
7621 if next_offset >= end_offset {
7622 return Ok(());
7623 }
7624
7625 while _next_ordinal_to_read < 2 {
7627 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7628 _next_ordinal_to_read += 1;
7629 next_offset += envelope_size;
7630 }
7631
7632 let next_out_of_line = decoder.next_out_of_line();
7633 let handles_before = decoder.remaining_handles();
7634 if let Some((inlined, num_bytes, num_handles)) =
7635 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7636 {
7637 let member_inline_size =
7638 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7639 if inlined != (member_inline_size <= 4) {
7640 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7641 }
7642 let inner_offset;
7643 let mut inner_depth = depth.clone();
7644 if inlined {
7645 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7646 inner_offset = next_offset;
7647 } else {
7648 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7649 inner_depth.increment()?;
7650 }
7651 let val_ref = self.weight.get_or_insert_with(|| fidl::new_empty!(u8, D));
7652 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7653 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7654 {
7655 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7656 }
7657 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7658 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7659 }
7660 }
7661
7662 next_offset += envelope_size;
7663 _next_ordinal_to_read += 1;
7664 if next_offset >= end_offset {
7665 return Ok(());
7666 }
7667
7668 while _next_ordinal_to_read < 3 {
7670 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7671 _next_ordinal_to_read += 1;
7672 next_offset += envelope_size;
7673 }
7674
7675 let next_out_of_line = decoder.next_out_of_line();
7676 let handles_before = decoder.remaining_handles();
7677 if let Some((inlined, num_bytes, num_handles)) =
7678 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7679 {
7680 let member_inline_size =
7681 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7682 if inlined != (member_inline_size <= 4) {
7683 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7684 }
7685 let inner_offset;
7686 let mut inner_depth = depth.clone();
7687 if inlined {
7688 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7689 inner_offset = next_offset;
7690 } else {
7691 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7692 inner_depth.increment()?;
7693 }
7694 let val_ref =
7695 self.network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
7696 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7697 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7698 {
7699 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7700 }
7701 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7702 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7703 }
7704 }
7705
7706 next_offset += envelope_size;
7707 _next_ordinal_to_read += 1;
7708 if next_offset >= end_offset {
7709 return Ok(());
7710 }
7711
7712 while _next_ordinal_to_read < 4 {
7714 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7715 _next_ordinal_to_read += 1;
7716 next_offset += envelope_size;
7717 }
7718
7719 let next_out_of_line = decoder.next_out_of_line();
7720 let handles_before = decoder.remaining_handles();
7721 if let Some((inlined, num_bytes, num_handles)) =
7722 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7723 {
7724 let member_inline_size =
7725 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7726 if inlined != (member_inline_size <= 4) {
7727 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7728 }
7729 let inner_offset;
7730 let mut inner_depth = depth.clone();
7731 if inlined {
7732 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7733 inner_offset = next_offset;
7734 } else {
7735 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7736 inner_depth.increment()?;
7737 }
7738 let val_ref =
7739 self.stable_network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
7740 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7741 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7742 {
7743 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7744 }
7745 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7746 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7747 }
7748 }
7749
7750 next_offset += envelope_size;
7751 _next_ordinal_to_read += 1;
7752 if next_offset >= end_offset {
7753 return Ok(());
7754 }
7755
7756 while _next_ordinal_to_read < 5 {
7758 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7759 _next_ordinal_to_read += 1;
7760 next_offset += envelope_size;
7761 }
7762
7763 let next_out_of_line = decoder.next_out_of_line();
7764 let handles_before = decoder.remaining_handles();
7765 if let Some((inlined, num_bytes, num_handles)) =
7766 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7767 {
7768 let member_inline_size =
7769 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7770 if inlined != (member_inline_size <= 4) {
7771 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7772 }
7773 let inner_offset;
7774 let mut inner_depth = depth.clone();
7775 if inlined {
7776 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7777 inner_offset = next_offset;
7778 } else {
7779 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7780 inner_depth.increment()?;
7781 }
7782 let val_ref = self.router_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
7783 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7784 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7785 {
7786 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7787 }
7788 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7789 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7790 }
7791 }
7792
7793 next_offset += envelope_size;
7794
7795 while next_offset < end_offset {
7797 _next_ordinal_to_read += 1;
7798 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7799 next_offset += envelope_size;
7800 }
7801
7802 Ok(())
7803 }
7804 }
7805
7806 impl LinkMetricsEntry {
7807 #[inline(always)]
7808 fn max_ordinal_present(&self) -> u64 {
7809 if let Some(_) = self.rssi {
7810 return 2;
7811 }
7812 if let Some(_) = self.link_margin {
7813 return 1;
7814 }
7815 0
7816 }
7817 }
7818
7819 impl fidl::encoding::ValueTypeMarker for LinkMetricsEntry {
7820 type Borrowed<'a> = &'a Self;
7821 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7822 value
7823 }
7824 }
7825
7826 unsafe impl fidl::encoding::TypeMarker for LinkMetricsEntry {
7827 type Owned = Self;
7828
7829 #[inline(always)]
7830 fn inline_align(_context: fidl::encoding::Context) -> usize {
7831 8
7832 }
7833
7834 #[inline(always)]
7835 fn inline_size(_context: fidl::encoding::Context) -> usize {
7836 16
7837 }
7838 }
7839
7840 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LinkMetricsEntry, D>
7841 for &LinkMetricsEntry
7842 {
7843 unsafe fn encode(
7844 self,
7845 encoder: &mut fidl::encoding::Encoder<'_, D>,
7846 offset: usize,
7847 mut depth: fidl::encoding::Depth,
7848 ) -> fidl::Result<()> {
7849 encoder.debug_check_bounds::<LinkMetricsEntry>(offset);
7850 let max_ordinal: u64 = self.max_ordinal_present();
7852 encoder.write_num(max_ordinal, offset);
7853 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7854 if max_ordinal == 0 {
7856 return Ok(());
7857 }
7858 depth.increment()?;
7859 let envelope_size = 8;
7860 let bytes_len = max_ordinal as usize * envelope_size;
7861 #[allow(unused_variables)]
7862 let offset = encoder.out_of_line_offset(bytes_len);
7863 let mut _prev_end_offset: usize = 0;
7864 if 1 > max_ordinal {
7865 return Ok(());
7866 }
7867
7868 let cur_offset: usize = (1 - 1) * envelope_size;
7871
7872 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7874
7875 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7880 self.link_margin.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7881 encoder,
7882 offset + cur_offset,
7883 depth,
7884 )?;
7885
7886 _prev_end_offset = cur_offset + envelope_size;
7887 if 2 > max_ordinal {
7888 return Ok(());
7889 }
7890
7891 let cur_offset: usize = (2 - 1) * envelope_size;
7894
7895 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7897
7898 fidl::encoding::encode_in_envelope_optional::<i8, D>(
7903 self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
7904 encoder,
7905 offset + cur_offset,
7906 depth,
7907 )?;
7908
7909 _prev_end_offset = cur_offset + envelope_size;
7910
7911 Ok(())
7912 }
7913 }
7914
7915 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LinkMetricsEntry {
7916 #[inline(always)]
7917 fn new_empty() -> Self {
7918 Self::default()
7919 }
7920
7921 unsafe fn decode(
7922 &mut self,
7923 decoder: &mut fidl::encoding::Decoder<'_, D>,
7924 offset: usize,
7925 mut depth: fidl::encoding::Depth,
7926 ) -> fidl::Result<()> {
7927 decoder.debug_check_bounds::<Self>(offset);
7928 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7929 None => return Err(fidl::Error::NotNullable),
7930 Some(len) => len,
7931 };
7932 if len == 0 {
7934 return Ok(());
7935 };
7936 depth.increment()?;
7937 let envelope_size = 8;
7938 let bytes_len = len * envelope_size;
7939 let offset = decoder.out_of_line_offset(bytes_len)?;
7940 let mut _next_ordinal_to_read = 0;
7942 let mut next_offset = offset;
7943 let end_offset = offset + bytes_len;
7944 _next_ordinal_to_read += 1;
7945 if next_offset >= end_offset {
7946 return Ok(());
7947 }
7948
7949 while _next_ordinal_to_read < 1 {
7951 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7952 _next_ordinal_to_read += 1;
7953 next_offset += envelope_size;
7954 }
7955
7956 let next_out_of_line = decoder.next_out_of_line();
7957 let handles_before = decoder.remaining_handles();
7958 if let Some((inlined, num_bytes, num_handles)) =
7959 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7960 {
7961 let member_inline_size =
7962 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7963 if inlined != (member_inline_size <= 4) {
7964 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7965 }
7966 let inner_offset;
7967 let mut inner_depth = depth.clone();
7968 if inlined {
7969 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7970 inner_offset = next_offset;
7971 } else {
7972 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7973 inner_depth.increment()?;
7974 }
7975 let val_ref = self.link_margin.get_or_insert_with(|| fidl::new_empty!(u8, D));
7976 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7977 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7978 {
7979 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7980 }
7981 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7982 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7983 }
7984 }
7985
7986 next_offset += envelope_size;
7987 _next_ordinal_to_read += 1;
7988 if next_offset >= end_offset {
7989 return Ok(());
7990 }
7991
7992 while _next_ordinal_to_read < 2 {
7994 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7995 _next_ordinal_to_read += 1;
7996 next_offset += envelope_size;
7997 }
7998
7999 let next_out_of_line = decoder.next_out_of_line();
8000 let handles_before = decoder.remaining_handles();
8001 if let Some((inlined, num_bytes, num_handles)) =
8002 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8003 {
8004 let member_inline_size =
8005 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8006 if inlined != (member_inline_size <= 4) {
8007 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8008 }
8009 let inner_offset;
8010 let mut inner_depth = depth.clone();
8011 if inlined {
8012 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8013 inner_offset = next_offset;
8014 } else {
8015 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8016 inner_depth.increment()?;
8017 }
8018 let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
8019 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
8020 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8021 {
8022 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8023 }
8024 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8025 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8026 }
8027 }
8028
8029 next_offset += envelope_size;
8030
8031 while next_offset < end_offset {
8033 _next_ordinal_to_read += 1;
8034 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8035 next_offset += envelope_size;
8036 }
8037
8038 Ok(())
8039 }
8040 }
8041
8042 impl Nat64ErrorCounters {
8043 #[inline(always)]
8044 fn max_ordinal_present(&self) -> u64 {
8045 if let Some(_) = self.no_mapping {
8046 return 4;
8047 }
8048 if let Some(_) = self.unsupported_protocol {
8049 return 3;
8050 }
8051 if let Some(_) = self.illegal_packet {
8052 return 2;
8053 }
8054 if let Some(_) = self.unknown {
8055 return 1;
8056 }
8057 0
8058 }
8059 }
8060
8061 impl fidl::encoding::ValueTypeMarker for Nat64ErrorCounters {
8062 type Borrowed<'a> = &'a Self;
8063 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8064 value
8065 }
8066 }
8067
8068 unsafe impl fidl::encoding::TypeMarker for Nat64ErrorCounters {
8069 type Owned = Self;
8070
8071 #[inline(always)]
8072 fn inline_align(_context: fidl::encoding::Context) -> usize {
8073 8
8074 }
8075
8076 #[inline(always)]
8077 fn inline_size(_context: fidl::encoding::Context) -> usize {
8078 16
8079 }
8080 }
8081
8082 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64ErrorCounters, D>
8083 for &Nat64ErrorCounters
8084 {
8085 unsafe fn encode(
8086 self,
8087 encoder: &mut fidl::encoding::Encoder<'_, D>,
8088 offset: usize,
8089 mut depth: fidl::encoding::Depth,
8090 ) -> fidl::Result<()> {
8091 encoder.debug_check_bounds::<Nat64ErrorCounters>(offset);
8092 let max_ordinal: u64 = self.max_ordinal_present();
8094 encoder.write_num(max_ordinal, offset);
8095 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8096 if max_ordinal == 0 {
8098 return Ok(());
8099 }
8100 depth.increment()?;
8101 let envelope_size = 8;
8102 let bytes_len = max_ordinal as usize * envelope_size;
8103 #[allow(unused_variables)]
8104 let offset = encoder.out_of_line_offset(bytes_len);
8105 let mut _prev_end_offset: usize = 0;
8106 if 1 > max_ordinal {
8107 return Ok(());
8108 }
8109
8110 let cur_offset: usize = (1 - 1) * envelope_size;
8113
8114 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8116
8117 fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8122 self.unknown
8123 .as_ref()
8124 .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8125 encoder,
8126 offset + cur_offset,
8127 depth,
8128 )?;
8129
8130 _prev_end_offset = cur_offset + envelope_size;
8131 if 2 > max_ordinal {
8132 return Ok(());
8133 }
8134
8135 let cur_offset: usize = (2 - 1) * envelope_size;
8138
8139 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8141
8142 fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8147 self.illegal_packet
8148 .as_ref()
8149 .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8150 encoder,
8151 offset + cur_offset,
8152 depth,
8153 )?;
8154
8155 _prev_end_offset = cur_offset + envelope_size;
8156 if 3 > max_ordinal {
8157 return Ok(());
8158 }
8159
8160 let cur_offset: usize = (3 - 1) * envelope_size;
8163
8164 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8166
8167 fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8172 self.unsupported_protocol
8173 .as_ref()
8174 .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8175 encoder,
8176 offset + cur_offset,
8177 depth,
8178 )?;
8179
8180 _prev_end_offset = cur_offset + envelope_size;
8181 if 4 > max_ordinal {
8182 return Ok(());
8183 }
8184
8185 let cur_offset: usize = (4 - 1) * envelope_size;
8188
8189 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8191
8192 fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8197 self.no_mapping
8198 .as_ref()
8199 .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8200 encoder,
8201 offset + cur_offset,
8202 depth,
8203 )?;
8204
8205 _prev_end_offset = cur_offset + envelope_size;
8206
8207 Ok(())
8208 }
8209 }
8210
8211 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64ErrorCounters {
8212 #[inline(always)]
8213 fn new_empty() -> Self {
8214 Self::default()
8215 }
8216
8217 unsafe fn decode(
8218 &mut self,
8219 decoder: &mut fidl::encoding::Decoder<'_, D>,
8220 offset: usize,
8221 mut depth: fidl::encoding::Depth,
8222 ) -> fidl::Result<()> {
8223 decoder.debug_check_bounds::<Self>(offset);
8224 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8225 None => return Err(fidl::Error::NotNullable),
8226 Some(len) => len,
8227 };
8228 if len == 0 {
8230 return Ok(());
8231 };
8232 depth.increment()?;
8233 let envelope_size = 8;
8234 let bytes_len = len * envelope_size;
8235 let offset = decoder.out_of_line_offset(bytes_len)?;
8236 let mut _next_ordinal_to_read = 0;
8238 let mut next_offset = offset;
8239 let end_offset = offset + bytes_len;
8240 _next_ordinal_to_read += 1;
8241 if next_offset >= end_offset {
8242 return Ok(());
8243 }
8244
8245 while _next_ordinal_to_read < 1 {
8247 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8248 _next_ordinal_to_read += 1;
8249 next_offset += envelope_size;
8250 }
8251
8252 let next_out_of_line = decoder.next_out_of_line();
8253 let handles_before = decoder.remaining_handles();
8254 if let Some((inlined, num_bytes, num_handles)) =
8255 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8256 {
8257 let member_inline_size =
8258 <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8259 decoder.context,
8260 );
8261 if inlined != (member_inline_size <= 4) {
8262 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8263 }
8264 let inner_offset;
8265 let mut inner_depth = depth.clone();
8266 if inlined {
8267 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8268 inner_offset = next_offset;
8269 } else {
8270 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8271 inner_depth.increment()?;
8272 }
8273 let val_ref =
8274 self.unknown.get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8275 fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8276 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8277 {
8278 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8279 }
8280 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8281 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8282 }
8283 }
8284
8285 next_offset += envelope_size;
8286 _next_ordinal_to_read += 1;
8287 if next_offset >= end_offset {
8288 return Ok(());
8289 }
8290
8291 while _next_ordinal_to_read < 2 {
8293 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8294 _next_ordinal_to_read += 1;
8295 next_offset += envelope_size;
8296 }
8297
8298 let next_out_of_line = decoder.next_out_of_line();
8299 let handles_before = decoder.remaining_handles();
8300 if let Some((inlined, num_bytes, num_handles)) =
8301 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8302 {
8303 let member_inline_size =
8304 <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8305 decoder.context,
8306 );
8307 if inlined != (member_inline_size <= 4) {
8308 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8309 }
8310 let inner_offset;
8311 let mut inner_depth = depth.clone();
8312 if inlined {
8313 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8314 inner_offset = next_offset;
8315 } else {
8316 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8317 inner_depth.increment()?;
8318 }
8319 let val_ref = self
8320 .illegal_packet
8321 .get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8322 fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8323 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8324 {
8325 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8326 }
8327 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8328 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8329 }
8330 }
8331
8332 next_offset += envelope_size;
8333 _next_ordinal_to_read += 1;
8334 if next_offset >= end_offset {
8335 return Ok(());
8336 }
8337
8338 while _next_ordinal_to_read < 3 {
8340 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8341 _next_ordinal_to_read += 1;
8342 next_offset += envelope_size;
8343 }
8344
8345 let next_out_of_line = decoder.next_out_of_line();
8346 let handles_before = decoder.remaining_handles();
8347 if let Some((inlined, num_bytes, num_handles)) =
8348 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8349 {
8350 let member_inline_size =
8351 <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8352 decoder.context,
8353 );
8354 if inlined != (member_inline_size <= 4) {
8355 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8356 }
8357 let inner_offset;
8358 let mut inner_depth = depth.clone();
8359 if inlined {
8360 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8361 inner_offset = next_offset;
8362 } else {
8363 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8364 inner_depth.increment()?;
8365 }
8366 let val_ref = self
8367 .unsupported_protocol
8368 .get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8369 fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8370 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8371 {
8372 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8373 }
8374 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8375 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8376 }
8377 }
8378
8379 next_offset += envelope_size;
8380 _next_ordinal_to_read += 1;
8381 if next_offset >= end_offset {
8382 return Ok(());
8383 }
8384
8385 while _next_ordinal_to_read < 4 {
8387 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8388 _next_ordinal_to_read += 1;
8389 next_offset += envelope_size;
8390 }
8391
8392 let next_out_of_line = decoder.next_out_of_line();
8393 let handles_before = decoder.remaining_handles();
8394 if let Some((inlined, num_bytes, num_handles)) =
8395 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8396 {
8397 let member_inline_size =
8398 <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8399 decoder.context,
8400 );
8401 if inlined != (member_inline_size <= 4) {
8402 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8403 }
8404 let inner_offset;
8405 let mut inner_depth = depth.clone();
8406 if inlined {
8407 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8408 inner_offset = next_offset;
8409 } else {
8410 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8411 inner_depth.increment()?;
8412 }
8413 let val_ref =
8414 self.no_mapping.get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8415 fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8416 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8417 {
8418 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8419 }
8420 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8421 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8422 }
8423 }
8424
8425 next_offset += envelope_size;
8426
8427 while next_offset < end_offset {
8429 _next_ordinal_to_read += 1;
8430 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8431 next_offset += envelope_size;
8432 }
8433
8434 Ok(())
8435 }
8436 }
8437
8438 impl Nat64Info {
8439 #[inline(always)]
8440 fn max_ordinal_present(&self) -> u64 {
8441 if let Some(_) = self.nat64_protocol_counters {
8442 return 4;
8443 }
8444 if let Some(_) = self.nat64_error_counters {
8445 return 3;
8446 }
8447 if let Some(_) = self.nat64_mappings {
8448 return 2;
8449 }
8450 if let Some(_) = self.nat64_state {
8451 return 1;
8452 }
8453 0
8454 }
8455 }
8456
8457 impl fidl::encoding::ValueTypeMarker for Nat64Info {
8458 type Borrowed<'a> = &'a Self;
8459 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8460 value
8461 }
8462 }
8463
8464 unsafe impl fidl::encoding::TypeMarker for Nat64Info {
8465 type Owned = Self;
8466
8467 #[inline(always)]
8468 fn inline_align(_context: fidl::encoding::Context) -> usize {
8469 8
8470 }
8471
8472 #[inline(always)]
8473 fn inline_size(_context: fidl::encoding::Context) -> usize {
8474 16
8475 }
8476 }
8477
8478 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64Info, D>
8479 for &Nat64Info
8480 {
8481 unsafe fn encode(
8482 self,
8483 encoder: &mut fidl::encoding::Encoder<'_, D>,
8484 offset: usize,
8485 mut depth: fidl::encoding::Depth,
8486 ) -> fidl::Result<()> {
8487 encoder.debug_check_bounds::<Nat64Info>(offset);
8488 let max_ordinal: u64 = self.max_ordinal_present();
8490 encoder.write_num(max_ordinal, offset);
8491 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8492 if max_ordinal == 0 {
8494 return Ok(());
8495 }
8496 depth.increment()?;
8497 let envelope_size = 8;
8498 let bytes_len = max_ordinal as usize * envelope_size;
8499 #[allow(unused_variables)]
8500 let offset = encoder.out_of_line_offset(bytes_len);
8501 let mut _prev_end_offset: usize = 0;
8502 if 1 > max_ordinal {
8503 return Ok(());
8504 }
8505
8506 let cur_offset: usize = (1 - 1) * envelope_size;
8509
8510 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8512
8513 fidl::encoding::encode_in_envelope_optional::<BorderRoutingNat64State, D>(
8518 self.nat64_state
8519 .as_ref()
8520 .map(<BorderRoutingNat64State as fidl::encoding::ValueTypeMarker>::borrow),
8521 encoder,
8522 offset + cur_offset,
8523 depth,
8524 )?;
8525
8526 _prev_end_offset = cur_offset + envelope_size;
8527 if 2 > max_ordinal {
8528 return Ok(());
8529 }
8530
8531 let cur_offset: usize = (2 - 1) * envelope_size;
8534
8535 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8537
8538 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Nat64Mapping>, D>(
8543 self.nat64_mappings.as_ref().map(<fidl::encoding::UnboundedVector<Nat64Mapping> as fidl::encoding::ValueTypeMarker>::borrow),
8544 encoder, offset + cur_offset, depth
8545 )?;
8546
8547 _prev_end_offset = cur_offset + envelope_size;
8548 if 3 > max_ordinal {
8549 return Ok(());
8550 }
8551
8552 let cur_offset: usize = (3 - 1) * envelope_size;
8555
8556 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8558
8559 fidl::encoding::encode_in_envelope_optional::<Nat64ErrorCounters, D>(
8564 self.nat64_error_counters
8565 .as_ref()
8566 .map(<Nat64ErrorCounters as fidl::encoding::ValueTypeMarker>::borrow),
8567 encoder,
8568 offset + cur_offset,
8569 depth,
8570 )?;
8571
8572 _prev_end_offset = cur_offset + envelope_size;
8573 if 4 > max_ordinal {
8574 return Ok(());
8575 }
8576
8577 let cur_offset: usize = (4 - 1) * envelope_size;
8580
8581 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8583
8584 fidl::encoding::encode_in_envelope_optional::<Nat64ProtocolCounters, D>(
8589 self.nat64_protocol_counters
8590 .as_ref()
8591 .map(<Nat64ProtocolCounters as fidl::encoding::ValueTypeMarker>::borrow),
8592 encoder,
8593 offset + cur_offset,
8594 depth,
8595 )?;
8596
8597 _prev_end_offset = cur_offset + envelope_size;
8598
8599 Ok(())
8600 }
8601 }
8602
8603 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64Info {
8604 #[inline(always)]
8605 fn new_empty() -> Self {
8606 Self::default()
8607 }
8608
8609 unsafe fn decode(
8610 &mut self,
8611 decoder: &mut fidl::encoding::Decoder<'_, D>,
8612 offset: usize,
8613 mut depth: fidl::encoding::Depth,
8614 ) -> fidl::Result<()> {
8615 decoder.debug_check_bounds::<Self>(offset);
8616 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8617 None => return Err(fidl::Error::NotNullable),
8618 Some(len) => len,
8619 };
8620 if len == 0 {
8622 return Ok(());
8623 };
8624 depth.increment()?;
8625 let envelope_size = 8;
8626 let bytes_len = len * envelope_size;
8627 let offset = decoder.out_of_line_offset(bytes_len)?;
8628 let mut _next_ordinal_to_read = 0;
8630 let mut next_offset = offset;
8631 let end_offset = offset + bytes_len;
8632 _next_ordinal_to_read += 1;
8633 if next_offset >= end_offset {
8634 return Ok(());
8635 }
8636
8637 while _next_ordinal_to_read < 1 {
8639 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8640 _next_ordinal_to_read += 1;
8641 next_offset += envelope_size;
8642 }
8643
8644 let next_out_of_line = decoder.next_out_of_line();
8645 let handles_before = decoder.remaining_handles();
8646 if let Some((inlined, num_bytes, num_handles)) =
8647 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8648 {
8649 let member_inline_size =
8650 <BorderRoutingNat64State as fidl::encoding::TypeMarker>::inline_size(
8651 decoder.context,
8652 );
8653 if inlined != (member_inline_size <= 4) {
8654 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8655 }
8656 let inner_offset;
8657 let mut inner_depth = depth.clone();
8658 if inlined {
8659 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8660 inner_offset = next_offset;
8661 } else {
8662 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8663 inner_depth.increment()?;
8664 }
8665 let val_ref = self
8666 .nat64_state
8667 .get_or_insert_with(|| fidl::new_empty!(BorderRoutingNat64State, D));
8668 fidl::decode!(
8669 BorderRoutingNat64State,
8670 D,
8671 val_ref,
8672 decoder,
8673 inner_offset,
8674 inner_depth
8675 )?;
8676 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8677 {
8678 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8679 }
8680 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8681 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8682 }
8683 }
8684
8685 next_offset += envelope_size;
8686 _next_ordinal_to_read += 1;
8687 if next_offset >= end_offset {
8688 return Ok(());
8689 }
8690
8691 while _next_ordinal_to_read < 2 {
8693 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8694 _next_ordinal_to_read += 1;
8695 next_offset += envelope_size;
8696 }
8697
8698 let next_out_of_line = decoder.next_out_of_line();
8699 let handles_before = decoder.remaining_handles();
8700 if let Some((inlined, num_bytes, num_handles)) =
8701 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8702 {
8703 let member_inline_size = <fidl::encoding::UnboundedVector<Nat64Mapping> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8704 if inlined != (member_inline_size <= 4) {
8705 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8706 }
8707 let inner_offset;
8708 let mut inner_depth = depth.clone();
8709 if inlined {
8710 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8711 inner_offset = next_offset;
8712 } else {
8713 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8714 inner_depth.increment()?;
8715 }
8716 let val_ref = self.nat64_mappings.get_or_insert_with(|| {
8717 fidl::new_empty!(fidl::encoding::UnboundedVector<Nat64Mapping>, D)
8718 });
8719 fidl::decode!(
8720 fidl::encoding::UnboundedVector<Nat64Mapping>,
8721 D,
8722 val_ref,
8723 decoder,
8724 inner_offset,
8725 inner_depth
8726 )?;
8727 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8728 {
8729 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8730 }
8731 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8732 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8733 }
8734 }
8735
8736 next_offset += envelope_size;
8737 _next_ordinal_to_read += 1;
8738 if next_offset >= end_offset {
8739 return Ok(());
8740 }
8741
8742 while _next_ordinal_to_read < 3 {
8744 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8745 _next_ordinal_to_read += 1;
8746 next_offset += envelope_size;
8747 }
8748
8749 let next_out_of_line = decoder.next_out_of_line();
8750 let handles_before = decoder.remaining_handles();
8751 if let Some((inlined, num_bytes, num_handles)) =
8752 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8753 {
8754 let member_inline_size =
8755 <Nat64ErrorCounters as fidl::encoding::TypeMarker>::inline_size(
8756 decoder.context,
8757 );
8758 if inlined != (member_inline_size <= 4) {
8759 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8760 }
8761 let inner_offset;
8762 let mut inner_depth = depth.clone();
8763 if inlined {
8764 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8765 inner_offset = next_offset;
8766 } else {
8767 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8768 inner_depth.increment()?;
8769 }
8770 let val_ref = self
8771 .nat64_error_counters
8772 .get_or_insert_with(|| fidl::new_empty!(Nat64ErrorCounters, D));
8773 fidl::decode!(Nat64ErrorCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8774 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8775 {
8776 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8777 }
8778 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8779 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8780 }
8781 }
8782
8783 next_offset += envelope_size;
8784 _next_ordinal_to_read += 1;
8785 if next_offset >= end_offset {
8786 return Ok(());
8787 }
8788
8789 while _next_ordinal_to_read < 4 {
8791 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8792 _next_ordinal_to_read += 1;
8793 next_offset += envelope_size;
8794 }
8795
8796 let next_out_of_line = decoder.next_out_of_line();
8797 let handles_before = decoder.remaining_handles();
8798 if let Some((inlined, num_bytes, num_handles)) =
8799 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8800 {
8801 let member_inline_size =
8802 <Nat64ProtocolCounters as fidl::encoding::TypeMarker>::inline_size(
8803 decoder.context,
8804 );
8805 if inlined != (member_inline_size <= 4) {
8806 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8807 }
8808 let inner_offset;
8809 let mut inner_depth = depth.clone();
8810 if inlined {
8811 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8812 inner_offset = next_offset;
8813 } else {
8814 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8815 inner_depth.increment()?;
8816 }
8817 let val_ref = self
8818 .nat64_protocol_counters
8819 .get_or_insert_with(|| fidl::new_empty!(Nat64ProtocolCounters, D));
8820 fidl::decode!(
8821 Nat64ProtocolCounters,
8822 D,
8823 val_ref,
8824 decoder,
8825 inner_offset,
8826 inner_depth
8827 )?;
8828 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8829 {
8830 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8831 }
8832 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8833 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8834 }
8835 }
8836
8837 next_offset += envelope_size;
8838
8839 while next_offset < end_offset {
8841 _next_ordinal_to_read += 1;
8842 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8843 next_offset += envelope_size;
8844 }
8845
8846 Ok(())
8847 }
8848 }
8849
8850 impl Nat64Mapping {
8851 #[inline(always)]
8852 fn max_ordinal_present(&self) -> u64 {
8853 if let Some(_) = self.counters {
8854 return 5;
8855 }
8856 if let Some(_) = self.remaining_time_ms {
8857 return 4;
8858 }
8859 if let Some(_) = self.ip6_addr {
8860 return 3;
8861 }
8862 if let Some(_) = self.ip4_addr {
8863 return 2;
8864 }
8865 if let Some(_) = self.mapping_id {
8866 return 1;
8867 }
8868 0
8869 }
8870 }
8871
8872 impl fidl::encoding::ValueTypeMarker for Nat64Mapping {
8873 type Borrowed<'a> = &'a Self;
8874 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8875 value
8876 }
8877 }
8878
8879 unsafe impl fidl::encoding::TypeMarker for Nat64Mapping {
8880 type Owned = Self;
8881
8882 #[inline(always)]
8883 fn inline_align(_context: fidl::encoding::Context) -> usize {
8884 8
8885 }
8886
8887 #[inline(always)]
8888 fn inline_size(_context: fidl::encoding::Context) -> usize {
8889 16
8890 }
8891 }
8892
8893 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64Mapping, D>
8894 for &Nat64Mapping
8895 {
8896 unsafe fn encode(
8897 self,
8898 encoder: &mut fidl::encoding::Encoder<'_, D>,
8899 offset: usize,
8900 mut depth: fidl::encoding::Depth,
8901 ) -> fidl::Result<()> {
8902 encoder.debug_check_bounds::<Nat64Mapping>(offset);
8903 let max_ordinal: u64 = self.max_ordinal_present();
8905 encoder.write_num(max_ordinal, offset);
8906 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8907 if max_ordinal == 0 {
8909 return Ok(());
8910 }
8911 depth.increment()?;
8912 let envelope_size = 8;
8913 let bytes_len = max_ordinal as usize * envelope_size;
8914 #[allow(unused_variables)]
8915 let offset = encoder.out_of_line_offset(bytes_len);
8916 let mut _prev_end_offset: usize = 0;
8917 if 1 > max_ordinal {
8918 return Ok(());
8919 }
8920
8921 let cur_offset: usize = (1 - 1) * envelope_size;
8924
8925 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8927
8928 fidl::encoding::encode_in_envelope_optional::<u64, D>(
8933 self.mapping_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
8934 encoder,
8935 offset + cur_offset,
8936 depth,
8937 )?;
8938
8939 _prev_end_offset = cur_offset + envelope_size;
8940 if 2 > max_ordinal {
8941 return Ok(());
8942 }
8943
8944 let cur_offset: usize = (2 - 1) * envelope_size;
8947
8948 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8950
8951 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8956 self.ip4_addr.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8957 encoder, offset + cur_offset, depth
8958 )?;
8959
8960 _prev_end_offset = cur_offset + envelope_size;
8961 if 3 > max_ordinal {
8962 return Ok(());
8963 }
8964
8965 let cur_offset: usize = (3 - 1) * envelope_size;
8968
8969 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8971
8972 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8977 self.ip6_addr.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8978 encoder, offset + cur_offset, depth
8979 )?;
8980
8981 _prev_end_offset = cur_offset + envelope_size;
8982 if 4 > max_ordinal {
8983 return Ok(());
8984 }
8985
8986 let cur_offset: usize = (4 - 1) * envelope_size;
8989
8990 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8992
8993 fidl::encoding::encode_in_envelope_optional::<u32, D>(
8998 self.remaining_time_ms
8999 .as_ref()
9000 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
9001 encoder,
9002 offset + cur_offset,
9003 depth,
9004 )?;
9005
9006 _prev_end_offset = cur_offset + envelope_size;
9007 if 5 > max_ordinal {
9008 return Ok(());
9009 }
9010
9011 let cur_offset: usize = (5 - 1) * envelope_size;
9014
9015 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9017
9018 fidl::encoding::encode_in_envelope_optional::<Nat64ProtocolCounters, D>(
9023 self.counters
9024 .as_ref()
9025 .map(<Nat64ProtocolCounters as fidl::encoding::ValueTypeMarker>::borrow),
9026 encoder,
9027 offset + cur_offset,
9028 depth,
9029 )?;
9030
9031 _prev_end_offset = cur_offset + envelope_size;
9032
9033 Ok(())
9034 }
9035 }
9036
9037 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64Mapping {
9038 #[inline(always)]
9039 fn new_empty() -> Self {
9040 Self::default()
9041 }
9042
9043 unsafe fn decode(
9044 &mut self,
9045 decoder: &mut fidl::encoding::Decoder<'_, D>,
9046 offset: usize,
9047 mut depth: fidl::encoding::Depth,
9048 ) -> fidl::Result<()> {
9049 decoder.debug_check_bounds::<Self>(offset);
9050 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9051 None => return Err(fidl::Error::NotNullable),
9052 Some(len) => len,
9053 };
9054 if len == 0 {
9056 return Ok(());
9057 };
9058 depth.increment()?;
9059 let envelope_size = 8;
9060 let bytes_len = len * envelope_size;
9061 let offset = decoder.out_of_line_offset(bytes_len)?;
9062 let mut _next_ordinal_to_read = 0;
9064 let mut next_offset = offset;
9065 let end_offset = offset + bytes_len;
9066 _next_ordinal_to_read += 1;
9067 if next_offset >= end_offset {
9068 return Ok(());
9069 }
9070
9071 while _next_ordinal_to_read < 1 {
9073 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9074 _next_ordinal_to_read += 1;
9075 next_offset += envelope_size;
9076 }
9077
9078 let next_out_of_line = decoder.next_out_of_line();
9079 let handles_before = decoder.remaining_handles();
9080 if let Some((inlined, num_bytes, num_handles)) =
9081 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9082 {
9083 let member_inline_size =
9084 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9085 if inlined != (member_inline_size <= 4) {
9086 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9087 }
9088 let inner_offset;
9089 let mut inner_depth = depth.clone();
9090 if inlined {
9091 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9092 inner_offset = next_offset;
9093 } else {
9094 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9095 inner_depth.increment()?;
9096 }
9097 let val_ref = self.mapping_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9098 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9099 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9100 {
9101 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9102 }
9103 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9104 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9105 }
9106 }
9107
9108 next_offset += envelope_size;
9109 _next_ordinal_to_read += 1;
9110 if next_offset >= end_offset {
9111 return Ok(());
9112 }
9113
9114 while _next_ordinal_to_read < 2 {
9116 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9117 _next_ordinal_to_read += 1;
9118 next_offset += envelope_size;
9119 }
9120
9121 let next_out_of_line = decoder.next_out_of_line();
9122 let handles_before = decoder.remaining_handles();
9123 if let Some((inlined, num_bytes, num_handles)) =
9124 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9125 {
9126 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9127 if inlined != (member_inline_size <= 4) {
9128 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9129 }
9130 let inner_offset;
9131 let mut inner_depth = depth.clone();
9132 if inlined {
9133 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9134 inner_offset = next_offset;
9135 } else {
9136 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9137 inner_depth.increment()?;
9138 }
9139 let val_ref = self.ip4_addr.get_or_insert_with(|| {
9140 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
9141 });
9142 fidl::decode!(
9143 fidl::encoding::UnboundedVector<u8>,
9144 D,
9145 val_ref,
9146 decoder,
9147 inner_offset,
9148 inner_depth
9149 )?;
9150 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9151 {
9152 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9153 }
9154 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9155 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9156 }
9157 }
9158
9159 next_offset += envelope_size;
9160 _next_ordinal_to_read += 1;
9161 if next_offset >= end_offset {
9162 return Ok(());
9163 }
9164
9165 while _next_ordinal_to_read < 3 {
9167 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9168 _next_ordinal_to_read += 1;
9169 next_offset += envelope_size;
9170 }
9171
9172 let next_out_of_line = decoder.next_out_of_line();
9173 let handles_before = decoder.remaining_handles();
9174 if let Some((inlined, num_bytes, num_handles)) =
9175 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9176 {
9177 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9178 if inlined != (member_inline_size <= 4) {
9179 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9180 }
9181 let inner_offset;
9182 let mut inner_depth = depth.clone();
9183 if inlined {
9184 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9185 inner_offset = next_offset;
9186 } else {
9187 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9188 inner_depth.increment()?;
9189 }
9190 let val_ref = self.ip6_addr.get_or_insert_with(|| {
9191 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
9192 });
9193 fidl::decode!(
9194 fidl::encoding::UnboundedVector<u8>,
9195 D,
9196 val_ref,
9197 decoder,
9198 inner_offset,
9199 inner_depth
9200 )?;
9201 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9202 {
9203 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9204 }
9205 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9206 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9207 }
9208 }
9209
9210 next_offset += envelope_size;
9211 _next_ordinal_to_read += 1;
9212 if next_offset >= end_offset {
9213 return Ok(());
9214 }
9215
9216 while _next_ordinal_to_read < 4 {
9218 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9219 _next_ordinal_to_read += 1;
9220 next_offset += envelope_size;
9221 }
9222
9223 let next_out_of_line = decoder.next_out_of_line();
9224 let handles_before = decoder.remaining_handles();
9225 if let Some((inlined, num_bytes, num_handles)) =
9226 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9227 {
9228 let member_inline_size =
9229 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9230 if inlined != (member_inline_size <= 4) {
9231 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9232 }
9233 let inner_offset;
9234 let mut inner_depth = depth.clone();
9235 if inlined {
9236 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9237 inner_offset = next_offset;
9238 } else {
9239 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9240 inner_depth.increment()?;
9241 }
9242 let val_ref =
9243 self.remaining_time_ms.get_or_insert_with(|| fidl::new_empty!(u32, D));
9244 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
9245 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9246 {
9247 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9248 }
9249 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9250 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9251 }
9252 }
9253
9254 next_offset += envelope_size;
9255 _next_ordinal_to_read += 1;
9256 if next_offset >= end_offset {
9257 return Ok(());
9258 }
9259
9260 while _next_ordinal_to_read < 5 {
9262 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9263 _next_ordinal_to_read += 1;
9264 next_offset += envelope_size;
9265 }
9266
9267 let next_out_of_line = decoder.next_out_of_line();
9268 let handles_before = decoder.remaining_handles();
9269 if let Some((inlined, num_bytes, num_handles)) =
9270 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9271 {
9272 let member_inline_size =
9273 <Nat64ProtocolCounters as fidl::encoding::TypeMarker>::inline_size(
9274 decoder.context,
9275 );
9276 if inlined != (member_inline_size <= 4) {
9277 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9278 }
9279 let inner_offset;
9280 let mut inner_depth = depth.clone();
9281 if inlined {
9282 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9283 inner_offset = next_offset;
9284 } else {
9285 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9286 inner_depth.increment()?;
9287 }
9288 let val_ref =
9289 self.counters.get_or_insert_with(|| fidl::new_empty!(Nat64ProtocolCounters, D));
9290 fidl::decode!(
9291 Nat64ProtocolCounters,
9292 D,
9293 val_ref,
9294 decoder,
9295 inner_offset,
9296 inner_depth
9297 )?;
9298 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9299 {
9300 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9301 }
9302 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9303 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9304 }
9305 }
9306
9307 next_offset += envelope_size;
9308
9309 while next_offset < end_offset {
9311 _next_ordinal_to_read += 1;
9312 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9313 next_offset += envelope_size;
9314 }
9315
9316 Ok(())
9317 }
9318 }
9319
9320 impl Nat64PacketCounters {
9321 #[inline(always)]
9322 fn max_ordinal_present(&self) -> u64 {
9323 if let Some(_) = self.ipv6_to_ipv4_packets {
9324 return 2;
9325 }
9326 if let Some(_) = self.ipv4_to_ipv6_packets {
9327 return 1;
9328 }
9329 0
9330 }
9331 }
9332
9333 impl fidl::encoding::ValueTypeMarker for Nat64PacketCounters {
9334 type Borrowed<'a> = &'a Self;
9335 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9336 value
9337 }
9338 }
9339
9340 unsafe impl fidl::encoding::TypeMarker for Nat64PacketCounters {
9341 type Owned = Self;
9342
9343 #[inline(always)]
9344 fn inline_align(_context: fidl::encoding::Context) -> usize {
9345 8
9346 }
9347
9348 #[inline(always)]
9349 fn inline_size(_context: fidl::encoding::Context) -> usize {
9350 16
9351 }
9352 }
9353
9354 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64PacketCounters, D>
9355 for &Nat64PacketCounters
9356 {
9357 unsafe fn encode(
9358 self,
9359 encoder: &mut fidl::encoding::Encoder<'_, D>,
9360 offset: usize,
9361 mut depth: fidl::encoding::Depth,
9362 ) -> fidl::Result<()> {
9363 encoder.debug_check_bounds::<Nat64PacketCounters>(offset);
9364 let max_ordinal: u64 = self.max_ordinal_present();
9366 encoder.write_num(max_ordinal, offset);
9367 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9368 if max_ordinal == 0 {
9370 return Ok(());
9371 }
9372 depth.increment()?;
9373 let envelope_size = 8;
9374 let bytes_len = max_ordinal as usize * envelope_size;
9375 #[allow(unused_variables)]
9376 let offset = encoder.out_of_line_offset(bytes_len);
9377 let mut _prev_end_offset: usize = 0;
9378 if 1 > max_ordinal {
9379 return Ok(());
9380 }
9381
9382 let cur_offset: usize = (1 - 1) * envelope_size;
9385
9386 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9388
9389 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9394 self.ipv4_to_ipv6_packets
9395 .as_ref()
9396 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9397 encoder,
9398 offset + cur_offset,
9399 depth,
9400 )?;
9401
9402 _prev_end_offset = cur_offset + envelope_size;
9403 if 2 > max_ordinal {
9404 return Ok(());
9405 }
9406
9407 let cur_offset: usize = (2 - 1) * envelope_size;
9410
9411 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9413
9414 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9419 self.ipv6_to_ipv4_packets
9420 .as_ref()
9421 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9422 encoder,
9423 offset + cur_offset,
9424 depth,
9425 )?;
9426
9427 _prev_end_offset = cur_offset + envelope_size;
9428
9429 Ok(())
9430 }
9431 }
9432
9433 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64PacketCounters {
9434 #[inline(always)]
9435 fn new_empty() -> Self {
9436 Self::default()
9437 }
9438
9439 unsafe fn decode(
9440 &mut self,
9441 decoder: &mut fidl::encoding::Decoder<'_, D>,
9442 offset: usize,
9443 mut depth: fidl::encoding::Depth,
9444 ) -> fidl::Result<()> {
9445 decoder.debug_check_bounds::<Self>(offset);
9446 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9447 None => return Err(fidl::Error::NotNullable),
9448 Some(len) => len,
9449 };
9450 if len == 0 {
9452 return Ok(());
9453 };
9454 depth.increment()?;
9455 let envelope_size = 8;
9456 let bytes_len = len * envelope_size;
9457 let offset = decoder.out_of_line_offset(bytes_len)?;
9458 let mut _next_ordinal_to_read = 0;
9460 let mut next_offset = offset;
9461 let end_offset = offset + bytes_len;
9462 _next_ordinal_to_read += 1;
9463 if next_offset >= end_offset {
9464 return Ok(());
9465 }
9466
9467 while _next_ordinal_to_read < 1 {
9469 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9470 _next_ordinal_to_read += 1;
9471 next_offset += envelope_size;
9472 }
9473
9474 let next_out_of_line = decoder.next_out_of_line();
9475 let handles_before = decoder.remaining_handles();
9476 if let Some((inlined, num_bytes, num_handles)) =
9477 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9478 {
9479 let member_inline_size =
9480 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9481 if inlined != (member_inline_size <= 4) {
9482 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9483 }
9484 let inner_offset;
9485 let mut inner_depth = depth.clone();
9486 if inlined {
9487 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9488 inner_offset = next_offset;
9489 } else {
9490 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9491 inner_depth.increment()?;
9492 }
9493 let val_ref =
9494 self.ipv4_to_ipv6_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
9495 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9496 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9497 {
9498 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9499 }
9500 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9501 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9502 }
9503 }
9504
9505 next_offset += envelope_size;
9506 _next_ordinal_to_read += 1;
9507 if next_offset >= end_offset {
9508 return Ok(());
9509 }
9510
9511 while _next_ordinal_to_read < 2 {
9513 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9514 _next_ordinal_to_read += 1;
9515 next_offset += envelope_size;
9516 }
9517
9518 let next_out_of_line = decoder.next_out_of_line();
9519 let handles_before = decoder.remaining_handles();
9520 if let Some((inlined, num_bytes, num_handles)) =
9521 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9522 {
9523 let member_inline_size =
9524 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9525 if inlined != (member_inline_size <= 4) {
9526 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9527 }
9528 let inner_offset;
9529 let mut inner_depth = depth.clone();
9530 if inlined {
9531 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9532 inner_offset = next_offset;
9533 } else {
9534 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9535 inner_depth.increment()?;
9536 }
9537 let val_ref =
9538 self.ipv6_to_ipv4_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
9539 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9540 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9541 {
9542 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9543 }
9544 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9545 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9546 }
9547 }
9548
9549 next_offset += envelope_size;
9550
9551 while next_offset < end_offset {
9553 _next_ordinal_to_read += 1;
9554 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9555 next_offset += envelope_size;
9556 }
9557
9558 Ok(())
9559 }
9560 }
9561
9562 impl Nat64ProtocolCounters {
9563 #[inline(always)]
9564 fn max_ordinal_present(&self) -> u64 {
9565 if let Some(_) = self.total {
9566 return 4;
9567 }
9568 if let Some(_) = self.icmp {
9569 return 3;
9570 }
9571 if let Some(_) = self.udp {
9572 return 2;
9573 }
9574 if let Some(_) = self.tcp {
9575 return 1;
9576 }
9577 0
9578 }
9579 }
9580
9581 impl fidl::encoding::ValueTypeMarker for Nat64ProtocolCounters {
9582 type Borrowed<'a> = &'a Self;
9583 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9584 value
9585 }
9586 }
9587
9588 unsafe impl fidl::encoding::TypeMarker for Nat64ProtocolCounters {
9589 type Owned = Self;
9590
9591 #[inline(always)]
9592 fn inline_align(_context: fidl::encoding::Context) -> usize {
9593 8
9594 }
9595
9596 #[inline(always)]
9597 fn inline_size(_context: fidl::encoding::Context) -> usize {
9598 16
9599 }
9600 }
9601
9602 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64ProtocolCounters, D>
9603 for &Nat64ProtocolCounters
9604 {
9605 unsafe fn encode(
9606 self,
9607 encoder: &mut fidl::encoding::Encoder<'_, D>,
9608 offset: usize,
9609 mut depth: fidl::encoding::Depth,
9610 ) -> fidl::Result<()> {
9611 encoder.debug_check_bounds::<Nat64ProtocolCounters>(offset);
9612 let max_ordinal: u64 = self.max_ordinal_present();
9614 encoder.write_num(max_ordinal, offset);
9615 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9616 if max_ordinal == 0 {
9618 return Ok(());
9619 }
9620 depth.increment()?;
9621 let envelope_size = 8;
9622 let bytes_len = max_ordinal as usize * envelope_size;
9623 #[allow(unused_variables)]
9624 let offset = encoder.out_of_line_offset(bytes_len);
9625 let mut _prev_end_offset: usize = 0;
9626 if 1 > max_ordinal {
9627 return Ok(());
9628 }
9629
9630 let cur_offset: usize = (1 - 1) * envelope_size;
9633
9634 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9636
9637 fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9642 self.tcp
9643 .as_ref()
9644 .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9645 encoder,
9646 offset + cur_offset,
9647 depth,
9648 )?;
9649
9650 _prev_end_offset = cur_offset + envelope_size;
9651 if 2 > max_ordinal {
9652 return Ok(());
9653 }
9654
9655 let cur_offset: usize = (2 - 1) * envelope_size;
9658
9659 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9661
9662 fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9667 self.udp
9668 .as_ref()
9669 .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9670 encoder,
9671 offset + cur_offset,
9672 depth,
9673 )?;
9674
9675 _prev_end_offset = cur_offset + envelope_size;
9676 if 3 > max_ordinal {
9677 return Ok(());
9678 }
9679
9680 let cur_offset: usize = (3 - 1) * envelope_size;
9683
9684 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9686
9687 fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9692 self.icmp
9693 .as_ref()
9694 .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9695 encoder,
9696 offset + cur_offset,
9697 depth,
9698 )?;
9699
9700 _prev_end_offset = cur_offset + envelope_size;
9701 if 4 > max_ordinal {
9702 return Ok(());
9703 }
9704
9705 let cur_offset: usize = (4 - 1) * envelope_size;
9708
9709 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9711
9712 fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9717 self.total
9718 .as_ref()
9719 .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9720 encoder,
9721 offset + cur_offset,
9722 depth,
9723 )?;
9724
9725 _prev_end_offset = cur_offset + envelope_size;
9726
9727 Ok(())
9728 }
9729 }
9730
9731 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64ProtocolCounters {
9732 #[inline(always)]
9733 fn new_empty() -> Self {
9734 Self::default()
9735 }
9736
9737 unsafe fn decode(
9738 &mut self,
9739 decoder: &mut fidl::encoding::Decoder<'_, D>,
9740 offset: usize,
9741 mut depth: fidl::encoding::Depth,
9742 ) -> fidl::Result<()> {
9743 decoder.debug_check_bounds::<Self>(offset);
9744 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9745 None => return Err(fidl::Error::NotNullable),
9746 Some(len) => len,
9747 };
9748 if len == 0 {
9750 return Ok(());
9751 };
9752 depth.increment()?;
9753 let envelope_size = 8;
9754 let bytes_len = len * envelope_size;
9755 let offset = decoder.out_of_line_offset(bytes_len)?;
9756 let mut _next_ordinal_to_read = 0;
9758 let mut next_offset = offset;
9759 let end_offset = offset + bytes_len;
9760 _next_ordinal_to_read += 1;
9761 if next_offset >= end_offset {
9762 return Ok(());
9763 }
9764
9765 while _next_ordinal_to_read < 1 {
9767 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9768 _next_ordinal_to_read += 1;
9769 next_offset += envelope_size;
9770 }
9771
9772 let next_out_of_line = decoder.next_out_of_line();
9773 let handles_before = decoder.remaining_handles();
9774 if let Some((inlined, num_bytes, num_handles)) =
9775 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9776 {
9777 let member_inline_size =
9778 <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9779 decoder.context,
9780 );
9781 if inlined != (member_inline_size <= 4) {
9782 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9783 }
9784 let inner_offset;
9785 let mut inner_depth = depth.clone();
9786 if inlined {
9787 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9788 inner_offset = next_offset;
9789 } else {
9790 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9791 inner_depth.increment()?;
9792 }
9793 let val_ref =
9794 self.tcp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9795 fidl::decode!(
9796 Nat64TrafficCounters,
9797 D,
9798 val_ref,
9799 decoder,
9800 inner_offset,
9801 inner_depth
9802 )?;
9803 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9804 {
9805 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9806 }
9807 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9808 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9809 }
9810 }
9811
9812 next_offset += envelope_size;
9813 _next_ordinal_to_read += 1;
9814 if next_offset >= end_offset {
9815 return Ok(());
9816 }
9817
9818 while _next_ordinal_to_read < 2 {
9820 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9821 _next_ordinal_to_read += 1;
9822 next_offset += envelope_size;
9823 }
9824
9825 let next_out_of_line = decoder.next_out_of_line();
9826 let handles_before = decoder.remaining_handles();
9827 if let Some((inlined, num_bytes, num_handles)) =
9828 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9829 {
9830 let member_inline_size =
9831 <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9832 decoder.context,
9833 );
9834 if inlined != (member_inline_size <= 4) {
9835 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9836 }
9837 let inner_offset;
9838 let mut inner_depth = depth.clone();
9839 if inlined {
9840 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9841 inner_offset = next_offset;
9842 } else {
9843 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9844 inner_depth.increment()?;
9845 }
9846 let val_ref =
9847 self.udp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9848 fidl::decode!(
9849 Nat64TrafficCounters,
9850 D,
9851 val_ref,
9852 decoder,
9853 inner_offset,
9854 inner_depth
9855 )?;
9856 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9857 {
9858 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9859 }
9860 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9861 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9862 }
9863 }
9864
9865 next_offset += envelope_size;
9866 _next_ordinal_to_read += 1;
9867 if next_offset >= end_offset {
9868 return Ok(());
9869 }
9870
9871 while _next_ordinal_to_read < 3 {
9873 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9874 _next_ordinal_to_read += 1;
9875 next_offset += envelope_size;
9876 }
9877
9878 let next_out_of_line = decoder.next_out_of_line();
9879 let handles_before = decoder.remaining_handles();
9880 if let Some((inlined, num_bytes, num_handles)) =
9881 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9882 {
9883 let member_inline_size =
9884 <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9885 decoder.context,
9886 );
9887 if inlined != (member_inline_size <= 4) {
9888 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9889 }
9890 let inner_offset;
9891 let mut inner_depth = depth.clone();
9892 if inlined {
9893 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9894 inner_offset = next_offset;
9895 } else {
9896 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9897 inner_depth.increment()?;
9898 }
9899 let val_ref =
9900 self.icmp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9901 fidl::decode!(
9902 Nat64TrafficCounters,
9903 D,
9904 val_ref,
9905 decoder,
9906 inner_offset,
9907 inner_depth
9908 )?;
9909 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9910 {
9911 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9912 }
9913 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9914 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9915 }
9916 }
9917
9918 next_offset += envelope_size;
9919 _next_ordinal_to_read += 1;
9920 if next_offset >= end_offset {
9921 return Ok(());
9922 }
9923
9924 while _next_ordinal_to_read < 4 {
9926 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9927 _next_ordinal_to_read += 1;
9928 next_offset += envelope_size;
9929 }
9930
9931 let next_out_of_line = decoder.next_out_of_line();
9932 let handles_before = decoder.remaining_handles();
9933 if let Some((inlined, num_bytes, num_handles)) =
9934 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9935 {
9936 let member_inline_size =
9937 <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9938 decoder.context,
9939 );
9940 if inlined != (member_inline_size <= 4) {
9941 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9942 }
9943 let inner_offset;
9944 let mut inner_depth = depth.clone();
9945 if inlined {
9946 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9947 inner_offset = next_offset;
9948 } else {
9949 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9950 inner_depth.increment()?;
9951 }
9952 let val_ref =
9953 self.total.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9954 fidl::decode!(
9955 Nat64TrafficCounters,
9956 D,
9957 val_ref,
9958 decoder,
9959 inner_offset,
9960 inner_depth
9961 )?;
9962 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9963 {
9964 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9965 }
9966 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9967 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9968 }
9969 }
9970
9971 next_offset += envelope_size;
9972
9973 while next_offset < end_offset {
9975 _next_ordinal_to_read += 1;
9976 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9977 next_offset += envelope_size;
9978 }
9979
9980 Ok(())
9981 }
9982 }
9983
9984 impl Nat64TrafficCounters {
9985 #[inline(always)]
9986 fn max_ordinal_present(&self) -> u64 {
9987 if let Some(_) = self.ipv6_to_ipv4_bytes {
9988 return 4;
9989 }
9990 if let Some(_) = self.ipv6_to_ipv4_packets {
9991 return 3;
9992 }
9993 if let Some(_) = self.ipv4_to_ipv6_bytes {
9994 return 2;
9995 }
9996 if let Some(_) = self.ipv4_to_ipv6_packets {
9997 return 1;
9998 }
9999 0
10000 }
10001 }
10002
10003 impl fidl::encoding::ValueTypeMarker for Nat64TrafficCounters {
10004 type Borrowed<'a> = &'a Self;
10005 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10006 value
10007 }
10008 }
10009
10010 unsafe impl fidl::encoding::TypeMarker for Nat64TrafficCounters {
10011 type Owned = Self;
10012
10013 #[inline(always)]
10014 fn inline_align(_context: fidl::encoding::Context) -> usize {
10015 8
10016 }
10017
10018 #[inline(always)]
10019 fn inline_size(_context: fidl::encoding::Context) -> usize {
10020 16
10021 }
10022 }
10023
10024 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64TrafficCounters, D>
10025 for &Nat64TrafficCounters
10026 {
10027 unsafe fn encode(
10028 self,
10029 encoder: &mut fidl::encoding::Encoder<'_, D>,
10030 offset: usize,
10031 mut depth: fidl::encoding::Depth,
10032 ) -> fidl::Result<()> {
10033 encoder.debug_check_bounds::<Nat64TrafficCounters>(offset);
10034 let max_ordinal: u64 = self.max_ordinal_present();
10036 encoder.write_num(max_ordinal, offset);
10037 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10038 if max_ordinal == 0 {
10040 return Ok(());
10041 }
10042 depth.increment()?;
10043 let envelope_size = 8;
10044 let bytes_len = max_ordinal as usize * envelope_size;
10045 #[allow(unused_variables)]
10046 let offset = encoder.out_of_line_offset(bytes_len);
10047 let mut _prev_end_offset: usize = 0;
10048 if 1 > max_ordinal {
10049 return Ok(());
10050 }
10051
10052 let cur_offset: usize = (1 - 1) * envelope_size;
10055
10056 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10058
10059 fidl::encoding::encode_in_envelope_optional::<u64, D>(
10064 self.ipv4_to_ipv6_packets
10065 .as_ref()
10066 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10067 encoder,
10068 offset + cur_offset,
10069 depth,
10070 )?;
10071
10072 _prev_end_offset = cur_offset + envelope_size;
10073 if 2 > max_ordinal {
10074 return Ok(());
10075 }
10076
10077 let cur_offset: usize = (2 - 1) * envelope_size;
10080
10081 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10083
10084 fidl::encoding::encode_in_envelope_optional::<u64, D>(
10089 self.ipv4_to_ipv6_bytes
10090 .as_ref()
10091 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10092 encoder,
10093 offset + cur_offset,
10094 depth,
10095 )?;
10096
10097 _prev_end_offset = cur_offset + envelope_size;
10098 if 3 > max_ordinal {
10099 return Ok(());
10100 }
10101
10102 let cur_offset: usize = (3 - 1) * envelope_size;
10105
10106 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10108
10109 fidl::encoding::encode_in_envelope_optional::<u64, D>(
10114 self.ipv6_to_ipv4_packets
10115 .as_ref()
10116 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10117 encoder,
10118 offset + cur_offset,
10119 depth,
10120 )?;
10121
10122 _prev_end_offset = cur_offset + envelope_size;
10123 if 4 > max_ordinal {
10124 return Ok(());
10125 }
10126
10127 let cur_offset: usize = (4 - 1) * envelope_size;
10130
10131 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10133
10134 fidl::encoding::encode_in_envelope_optional::<u64, D>(
10139 self.ipv6_to_ipv4_bytes
10140 .as_ref()
10141 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10142 encoder,
10143 offset + cur_offset,
10144 depth,
10145 )?;
10146
10147 _prev_end_offset = cur_offset + envelope_size;
10148
10149 Ok(())
10150 }
10151 }
10152
10153 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64TrafficCounters {
10154 #[inline(always)]
10155 fn new_empty() -> Self {
10156 Self::default()
10157 }
10158
10159 unsafe fn decode(
10160 &mut self,
10161 decoder: &mut fidl::encoding::Decoder<'_, D>,
10162 offset: usize,
10163 mut depth: fidl::encoding::Depth,
10164 ) -> fidl::Result<()> {
10165 decoder.debug_check_bounds::<Self>(offset);
10166 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10167 None => return Err(fidl::Error::NotNullable),
10168 Some(len) => len,
10169 };
10170 if len == 0 {
10172 return Ok(());
10173 };
10174 depth.increment()?;
10175 let envelope_size = 8;
10176 let bytes_len = len * envelope_size;
10177 let offset = decoder.out_of_line_offset(bytes_len)?;
10178 let mut _next_ordinal_to_read = 0;
10180 let mut next_offset = offset;
10181 let end_offset = offset + bytes_len;
10182 _next_ordinal_to_read += 1;
10183 if next_offset >= end_offset {
10184 return Ok(());
10185 }
10186
10187 while _next_ordinal_to_read < 1 {
10189 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10190 _next_ordinal_to_read += 1;
10191 next_offset += envelope_size;
10192 }
10193
10194 let next_out_of_line = decoder.next_out_of_line();
10195 let handles_before = decoder.remaining_handles();
10196 if let Some((inlined, num_bytes, num_handles)) =
10197 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10198 {
10199 let member_inline_size =
10200 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10201 if inlined != (member_inline_size <= 4) {
10202 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10203 }
10204 let inner_offset;
10205 let mut inner_depth = depth.clone();
10206 if inlined {
10207 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10208 inner_offset = next_offset;
10209 } else {
10210 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10211 inner_depth.increment()?;
10212 }
10213 let val_ref =
10214 self.ipv4_to_ipv6_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
10215 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10216 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10217 {
10218 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10219 }
10220 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10221 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10222 }
10223 }
10224
10225 next_offset += envelope_size;
10226 _next_ordinal_to_read += 1;
10227 if next_offset >= end_offset {
10228 return Ok(());
10229 }
10230
10231 while _next_ordinal_to_read < 2 {
10233 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10234 _next_ordinal_to_read += 1;
10235 next_offset += envelope_size;
10236 }
10237
10238 let next_out_of_line = decoder.next_out_of_line();
10239 let handles_before = decoder.remaining_handles();
10240 if let Some((inlined, num_bytes, num_handles)) =
10241 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10242 {
10243 let member_inline_size =
10244 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10245 if inlined != (member_inline_size <= 4) {
10246 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10247 }
10248 let inner_offset;
10249 let mut inner_depth = depth.clone();
10250 if inlined {
10251 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10252 inner_offset = next_offset;
10253 } else {
10254 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10255 inner_depth.increment()?;
10256 }
10257 let val_ref =
10258 self.ipv4_to_ipv6_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
10259 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10260 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10261 {
10262 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10263 }
10264 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10265 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10266 }
10267 }
10268
10269 next_offset += envelope_size;
10270 _next_ordinal_to_read += 1;
10271 if next_offset >= end_offset {
10272 return Ok(());
10273 }
10274
10275 while _next_ordinal_to_read < 3 {
10277 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10278 _next_ordinal_to_read += 1;
10279 next_offset += envelope_size;
10280 }
10281
10282 let next_out_of_line = decoder.next_out_of_line();
10283 let handles_before = decoder.remaining_handles();
10284 if let Some((inlined, num_bytes, num_handles)) =
10285 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10286 {
10287 let member_inline_size =
10288 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10289 if inlined != (member_inline_size <= 4) {
10290 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10291 }
10292 let inner_offset;
10293 let mut inner_depth = depth.clone();
10294 if inlined {
10295 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10296 inner_offset = next_offset;
10297 } else {
10298 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10299 inner_depth.increment()?;
10300 }
10301 let val_ref =
10302 self.ipv6_to_ipv4_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
10303 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10304 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10305 {
10306 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10307 }
10308 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10309 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10310 }
10311 }
10312
10313 next_offset += envelope_size;
10314 _next_ordinal_to_read += 1;
10315 if next_offset >= end_offset {
10316 return Ok(());
10317 }
10318
10319 while _next_ordinal_to_read < 4 {
10321 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10322 _next_ordinal_to_read += 1;
10323 next_offset += envelope_size;
10324 }
10325
10326 let next_out_of_line = decoder.next_out_of_line();
10327 let handles_before = decoder.remaining_handles();
10328 if let Some((inlined, num_bytes, num_handles)) =
10329 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10330 {
10331 let member_inline_size =
10332 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10333 if inlined != (member_inline_size <= 4) {
10334 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10335 }
10336 let inner_offset;
10337 let mut inner_depth = depth.clone();
10338 if inlined {
10339 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10340 inner_offset = next_offset;
10341 } else {
10342 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10343 inner_depth.increment()?;
10344 }
10345 let val_ref =
10346 self.ipv6_to_ipv4_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
10347 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10348 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10349 {
10350 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10351 }
10352 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10353 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10354 }
10355 }
10356
10357 next_offset += envelope_size;
10358
10359 while next_offset < end_offset {
10361 _next_ordinal_to_read += 1;
10362 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10363 next_offset += envelope_size;
10364 }
10365
10366 Ok(())
10367 }
10368 }
10369
10370 impl NetworkScanParameters {
10371 #[inline(always)]
10372 fn max_ordinal_present(&self) -> u64 {
10373 if let Some(_) = self.tx_power_dbm {
10374 return 2;
10375 }
10376 if let Some(_) = self.channels {
10377 return 1;
10378 }
10379 0
10380 }
10381 }
10382
10383 impl fidl::encoding::ValueTypeMarker for NetworkScanParameters {
10384 type Borrowed<'a> = &'a Self;
10385 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10386 value
10387 }
10388 }
10389
10390 unsafe impl fidl::encoding::TypeMarker for NetworkScanParameters {
10391 type Owned = Self;
10392
10393 #[inline(always)]
10394 fn inline_align(_context: fidl::encoding::Context) -> usize {
10395 8
10396 }
10397
10398 #[inline(always)]
10399 fn inline_size(_context: fidl::encoding::Context) -> usize {
10400 16
10401 }
10402 }
10403
10404 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NetworkScanParameters, D>
10405 for &NetworkScanParameters
10406 {
10407 unsafe fn encode(
10408 self,
10409 encoder: &mut fidl::encoding::Encoder<'_, D>,
10410 offset: usize,
10411 mut depth: fidl::encoding::Depth,
10412 ) -> fidl::Result<()> {
10413 encoder.debug_check_bounds::<NetworkScanParameters>(offset);
10414 let max_ordinal: u64 = self.max_ordinal_present();
10416 encoder.write_num(max_ordinal, offset);
10417 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10418 if max_ordinal == 0 {
10420 return Ok(());
10421 }
10422 depth.increment()?;
10423 let envelope_size = 8;
10424 let bytes_len = max_ordinal as usize * envelope_size;
10425 #[allow(unused_variables)]
10426 let offset = encoder.out_of_line_offset(bytes_len);
10427 let mut _prev_end_offset: usize = 0;
10428 if 1 > max_ordinal {
10429 return Ok(());
10430 }
10431
10432 let cur_offset: usize = (1 - 1) * envelope_size;
10435
10436 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10438
10439 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u16, 200>, D>(
10444 self.channels.as_ref().map(
10445 <fidl::encoding::Vector<u16, 200> as fidl::encoding::ValueTypeMarker>::borrow,
10446 ),
10447 encoder,
10448 offset + cur_offset,
10449 depth,
10450 )?;
10451
10452 _prev_end_offset = cur_offset + envelope_size;
10453 if 2 > max_ordinal {
10454 return Ok(());
10455 }
10456
10457 let cur_offset: usize = (2 - 1) * envelope_size;
10460
10461 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10463
10464 fidl::encoding::encode_in_envelope_optional::<i8, D>(
10469 self.tx_power_dbm.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
10470 encoder,
10471 offset + cur_offset,
10472 depth,
10473 )?;
10474
10475 _prev_end_offset = cur_offset + envelope_size;
10476
10477 Ok(())
10478 }
10479 }
10480
10481 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NetworkScanParameters {
10482 #[inline(always)]
10483 fn new_empty() -> Self {
10484 Self::default()
10485 }
10486
10487 unsafe fn decode(
10488 &mut self,
10489 decoder: &mut fidl::encoding::Decoder<'_, D>,
10490 offset: usize,
10491 mut depth: fidl::encoding::Depth,
10492 ) -> fidl::Result<()> {
10493 decoder.debug_check_bounds::<Self>(offset);
10494 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10495 None => return Err(fidl::Error::NotNullable),
10496 Some(len) => len,
10497 };
10498 if len == 0 {
10500 return Ok(());
10501 };
10502 depth.increment()?;
10503 let envelope_size = 8;
10504 let bytes_len = len * envelope_size;
10505 let offset = decoder.out_of_line_offset(bytes_len)?;
10506 let mut _next_ordinal_to_read = 0;
10508 let mut next_offset = offset;
10509 let end_offset = offset + bytes_len;
10510 _next_ordinal_to_read += 1;
10511 if next_offset >= end_offset {
10512 return Ok(());
10513 }
10514
10515 while _next_ordinal_to_read < 1 {
10517 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10518 _next_ordinal_to_read += 1;
10519 next_offset += envelope_size;
10520 }
10521
10522 let next_out_of_line = decoder.next_out_of_line();
10523 let handles_before = decoder.remaining_handles();
10524 if let Some((inlined, num_bytes, num_handles)) =
10525 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10526 {
10527 let member_inline_size =
10528 <fidl::encoding::Vector<u16, 200> as fidl::encoding::TypeMarker>::inline_size(
10529 decoder.context,
10530 );
10531 if inlined != (member_inline_size <= 4) {
10532 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10533 }
10534 let inner_offset;
10535 let mut inner_depth = depth.clone();
10536 if inlined {
10537 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10538 inner_offset = next_offset;
10539 } else {
10540 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10541 inner_depth.increment()?;
10542 }
10543 let val_ref = self
10544 .channels
10545 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u16, 200>, D));
10546 fidl::decode!(fidl::encoding::Vector<u16, 200>, D, val_ref, decoder, inner_offset, inner_depth)?;
10547 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10548 {
10549 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10550 }
10551 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10552 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10553 }
10554 }
10555
10556 next_offset += envelope_size;
10557 _next_ordinal_to_read += 1;
10558 if next_offset >= end_offset {
10559 return Ok(());
10560 }
10561
10562 while _next_ordinal_to_read < 2 {
10564 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10565 _next_ordinal_to_read += 1;
10566 next_offset += envelope_size;
10567 }
10568
10569 let next_out_of_line = decoder.next_out_of_line();
10570 let handles_before = decoder.remaining_handles();
10571 if let Some((inlined, num_bytes, num_handles)) =
10572 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10573 {
10574 let member_inline_size =
10575 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10576 if inlined != (member_inline_size <= 4) {
10577 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10578 }
10579 let inner_offset;
10580 let mut inner_depth = depth.clone();
10581 if inlined {
10582 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10583 inner_offset = next_offset;
10584 } else {
10585 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10586 inner_depth.increment()?;
10587 }
10588 let val_ref = self.tx_power_dbm.get_or_insert_with(|| fidl::new_empty!(i8, D));
10589 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
10590 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10591 {
10592 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10593 }
10594 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10595 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10596 }
10597 }
10598
10599 next_offset += envelope_size;
10600
10601 while next_offset < end_offset {
10603 _next_ordinal_to_read += 1;
10604 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10605 next_offset += envelope_size;
10606 }
10607
10608 Ok(())
10609 }
10610 }
10611
10612 impl OnMeshPrefix {
10613 #[inline(always)]
10614 fn max_ordinal_present(&self) -> u64 {
10615 if let Some(_) = self.slaac_valid {
10616 return 5;
10617 }
10618 if let Some(_) = self.slaac_preferred {
10619 return 4;
10620 }
10621 if let Some(_) = self.stable {
10622 return 3;
10623 }
10624 if let Some(_) = self.default_route_preference {
10625 return 2;
10626 }
10627 if let Some(_) = self.subnet {
10628 return 1;
10629 }
10630 0
10631 }
10632 }
10633
10634 impl fidl::encoding::ValueTypeMarker for OnMeshPrefix {
10635 type Borrowed<'a> = &'a Self;
10636 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10637 value
10638 }
10639 }
10640
10641 unsafe impl fidl::encoding::TypeMarker for OnMeshPrefix {
10642 type Owned = Self;
10643
10644 #[inline(always)]
10645 fn inline_align(_context: fidl::encoding::Context) -> usize {
10646 8
10647 }
10648
10649 #[inline(always)]
10650 fn inline_size(_context: fidl::encoding::Context) -> usize {
10651 16
10652 }
10653 }
10654
10655 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OnMeshPrefix, D>
10656 for &OnMeshPrefix
10657 {
10658 unsafe fn encode(
10659 self,
10660 encoder: &mut fidl::encoding::Encoder<'_, D>,
10661 offset: usize,
10662 mut depth: fidl::encoding::Depth,
10663 ) -> fidl::Result<()> {
10664 encoder.debug_check_bounds::<OnMeshPrefix>(offset);
10665 let max_ordinal: u64 = self.max_ordinal_present();
10667 encoder.write_num(max_ordinal, offset);
10668 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10669 if max_ordinal == 0 {
10671 return Ok(());
10672 }
10673 depth.increment()?;
10674 let envelope_size = 8;
10675 let bytes_len = max_ordinal as usize * envelope_size;
10676 #[allow(unused_variables)]
10677 let offset = encoder.out_of_line_offset(bytes_len);
10678 let mut _prev_end_offset: usize = 0;
10679 if 1 > max_ordinal {
10680 return Ok(());
10681 }
10682
10683 let cur_offset: usize = (1 - 1) * envelope_size;
10686
10687 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10689
10690 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
10695 self.subnet.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
10696 encoder, offset + cur_offset, depth
10697 )?;
10698
10699 _prev_end_offset = cur_offset + envelope_size;
10700 if 2 > max_ordinal {
10701 return Ok(());
10702 }
10703
10704 let cur_offset: usize = (2 - 1) * envelope_size;
10707
10708 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10710
10711 fidl::encoding::encode_in_envelope_optional::<RoutePreference, D>(
10716 self.default_route_preference
10717 .as_ref()
10718 .map(<RoutePreference as fidl::encoding::ValueTypeMarker>::borrow),
10719 encoder,
10720 offset + cur_offset,
10721 depth,
10722 )?;
10723
10724 _prev_end_offset = cur_offset + envelope_size;
10725 if 3 > max_ordinal {
10726 return Ok(());
10727 }
10728
10729 let cur_offset: usize = (3 - 1) * envelope_size;
10732
10733 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10735
10736 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10741 self.stable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10742 encoder,
10743 offset + cur_offset,
10744 depth,
10745 )?;
10746
10747 _prev_end_offset = cur_offset + envelope_size;
10748 if 4 > max_ordinal {
10749 return Ok(());
10750 }
10751
10752 let cur_offset: usize = (4 - 1) * envelope_size;
10755
10756 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10758
10759 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10764 self.slaac_preferred
10765 .as_ref()
10766 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10767 encoder,
10768 offset + cur_offset,
10769 depth,
10770 )?;
10771
10772 _prev_end_offset = cur_offset + envelope_size;
10773 if 5 > max_ordinal {
10774 return Ok(());
10775 }
10776
10777 let cur_offset: usize = (5 - 1) * envelope_size;
10780
10781 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10783
10784 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10789 self.slaac_valid.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10790 encoder,
10791 offset + cur_offset,
10792 depth,
10793 )?;
10794
10795 _prev_end_offset = cur_offset + envelope_size;
10796
10797 Ok(())
10798 }
10799 }
10800
10801 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OnMeshPrefix {
10802 #[inline(always)]
10803 fn new_empty() -> Self {
10804 Self::default()
10805 }
10806
10807 unsafe fn decode(
10808 &mut self,
10809 decoder: &mut fidl::encoding::Decoder<'_, D>,
10810 offset: usize,
10811 mut depth: fidl::encoding::Depth,
10812 ) -> fidl::Result<()> {
10813 decoder.debug_check_bounds::<Self>(offset);
10814 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10815 None => return Err(fidl::Error::NotNullable),
10816 Some(len) => len,
10817 };
10818 if len == 0 {
10820 return Ok(());
10821 };
10822 depth.increment()?;
10823 let envelope_size = 8;
10824 let bytes_len = len * envelope_size;
10825 let offset = decoder.out_of_line_offset(bytes_len)?;
10826 let mut _next_ordinal_to_read = 0;
10828 let mut next_offset = offset;
10829 let end_offset = offset + bytes_len;
10830 _next_ordinal_to_read += 1;
10831 if next_offset >= end_offset {
10832 return Ok(());
10833 }
10834
10835 while _next_ordinal_to_read < 1 {
10837 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10838 _next_ordinal_to_read += 1;
10839 next_offset += envelope_size;
10840 }
10841
10842 let next_out_of_line = decoder.next_out_of_line();
10843 let handles_before = decoder.remaining_handles();
10844 if let Some((inlined, num_bytes, num_handles)) =
10845 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10846 {
10847 let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10848 if inlined != (member_inline_size <= 4) {
10849 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10850 }
10851 let inner_offset;
10852 let mut inner_depth = depth.clone();
10853 if inlined {
10854 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10855 inner_offset = next_offset;
10856 } else {
10857 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10858 inner_depth.increment()?;
10859 }
10860 let val_ref = self.subnet.get_or_insert_with(|| {
10861 fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
10862 });
10863 fidl::decode!(
10864 fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
10865 D,
10866 val_ref,
10867 decoder,
10868 inner_offset,
10869 inner_depth
10870 )?;
10871 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10872 {
10873 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10874 }
10875 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10876 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10877 }
10878 }
10879
10880 next_offset += envelope_size;
10881 _next_ordinal_to_read += 1;
10882 if next_offset >= end_offset {
10883 return Ok(());
10884 }
10885
10886 while _next_ordinal_to_read < 2 {
10888 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10889 _next_ordinal_to_read += 1;
10890 next_offset += envelope_size;
10891 }
10892
10893 let next_out_of_line = decoder.next_out_of_line();
10894 let handles_before = decoder.remaining_handles();
10895 if let Some((inlined, num_bytes, num_handles)) =
10896 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10897 {
10898 let member_inline_size =
10899 <RoutePreference as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10900 if inlined != (member_inline_size <= 4) {
10901 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10902 }
10903 let inner_offset;
10904 let mut inner_depth = depth.clone();
10905 if inlined {
10906 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10907 inner_offset = next_offset;
10908 } else {
10909 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10910 inner_depth.increment()?;
10911 }
10912 let val_ref = self
10913 .default_route_preference
10914 .get_or_insert_with(|| fidl::new_empty!(RoutePreference, D));
10915 fidl::decode!(RoutePreference, D, val_ref, decoder, inner_offset, inner_depth)?;
10916 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10917 {
10918 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10919 }
10920 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10921 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10922 }
10923 }
10924
10925 next_offset += envelope_size;
10926 _next_ordinal_to_read += 1;
10927 if next_offset >= end_offset {
10928 return Ok(());
10929 }
10930
10931 while _next_ordinal_to_read < 3 {
10933 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10934 _next_ordinal_to_read += 1;
10935 next_offset += envelope_size;
10936 }
10937
10938 let next_out_of_line = decoder.next_out_of_line();
10939 let handles_before = decoder.remaining_handles();
10940 if let Some((inlined, num_bytes, num_handles)) =
10941 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10942 {
10943 let member_inline_size =
10944 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10945 if inlined != (member_inline_size <= 4) {
10946 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10947 }
10948 let inner_offset;
10949 let mut inner_depth = depth.clone();
10950 if inlined {
10951 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10952 inner_offset = next_offset;
10953 } else {
10954 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10955 inner_depth.increment()?;
10956 }
10957 let val_ref = self.stable.get_or_insert_with(|| fidl::new_empty!(bool, D));
10958 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10959 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10960 {
10961 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10962 }
10963 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10964 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10965 }
10966 }
10967
10968 next_offset += envelope_size;
10969 _next_ordinal_to_read += 1;
10970 if next_offset >= end_offset {
10971 return Ok(());
10972 }
10973
10974 while _next_ordinal_to_read < 4 {
10976 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10977 _next_ordinal_to_read += 1;
10978 next_offset += envelope_size;
10979 }
10980
10981 let next_out_of_line = decoder.next_out_of_line();
10982 let handles_before = decoder.remaining_handles();
10983 if let Some((inlined, num_bytes, num_handles)) =
10984 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10985 {
10986 let member_inline_size =
10987 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10988 if inlined != (member_inline_size <= 4) {
10989 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10990 }
10991 let inner_offset;
10992 let mut inner_depth = depth.clone();
10993 if inlined {
10994 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10995 inner_offset = next_offset;
10996 } else {
10997 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10998 inner_depth.increment()?;
10999 }
11000 let val_ref = self.slaac_preferred.get_or_insert_with(|| fidl::new_empty!(bool, D));
11001 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11002 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11003 {
11004 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11005 }
11006 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11007 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11008 }
11009 }
11010
11011 next_offset += envelope_size;
11012 _next_ordinal_to_read += 1;
11013 if next_offset >= end_offset {
11014 return Ok(());
11015 }
11016
11017 while _next_ordinal_to_read < 5 {
11019 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11020 _next_ordinal_to_read += 1;
11021 next_offset += envelope_size;
11022 }
11023
11024 let next_out_of_line = decoder.next_out_of_line();
11025 let handles_before = decoder.remaining_handles();
11026 if let Some((inlined, num_bytes, num_handles)) =
11027 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11028 {
11029 let member_inline_size =
11030 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11031 if inlined != (member_inline_size <= 4) {
11032 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11033 }
11034 let inner_offset;
11035 let mut inner_depth = depth.clone();
11036 if inlined {
11037 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11038 inner_offset = next_offset;
11039 } else {
11040 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11041 inner_depth.increment()?;
11042 }
11043 let val_ref = self.slaac_valid.get_or_insert_with(|| fidl::new_empty!(bool, D));
11044 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11045 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11046 {
11047 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11048 }
11049 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11050 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11051 }
11052 }
11053
11054 next_offset += envelope_size;
11055
11056 while next_offset < end_offset {
11058 _next_ordinal_to_read += 1;
11059 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11060 next_offset += envelope_size;
11061 }
11062
11063 Ok(())
11064 }
11065 }
11066
11067 impl PdProcessedRaInfo {
11068 #[inline(always)]
11069 fn max_ordinal_present(&self) -> u64 {
11070 if let Some(_) = self.last_platform_ra_msec {
11071 return 3;
11072 }
11073 if let Some(_) = self.num_platform_pio_processed {
11074 return 2;
11075 }
11076 if let Some(_) = self.num_platform_ra_received {
11077 return 1;
11078 }
11079 0
11080 }
11081 }
11082
11083 impl fidl::encoding::ValueTypeMarker for PdProcessedRaInfo {
11084 type Borrowed<'a> = &'a Self;
11085 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11086 value
11087 }
11088 }
11089
11090 unsafe impl fidl::encoding::TypeMarker for PdProcessedRaInfo {
11091 type Owned = Self;
11092
11093 #[inline(always)]
11094 fn inline_align(_context: fidl::encoding::Context) -> usize {
11095 8
11096 }
11097
11098 #[inline(always)]
11099 fn inline_size(_context: fidl::encoding::Context) -> usize {
11100 16
11101 }
11102 }
11103
11104 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PdProcessedRaInfo, D>
11105 for &PdProcessedRaInfo
11106 {
11107 unsafe fn encode(
11108 self,
11109 encoder: &mut fidl::encoding::Encoder<'_, D>,
11110 offset: usize,
11111 mut depth: fidl::encoding::Depth,
11112 ) -> fidl::Result<()> {
11113 encoder.debug_check_bounds::<PdProcessedRaInfo>(offset);
11114 let max_ordinal: u64 = self.max_ordinal_present();
11116 encoder.write_num(max_ordinal, offset);
11117 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11118 if max_ordinal == 0 {
11120 return Ok(());
11121 }
11122 depth.increment()?;
11123 let envelope_size = 8;
11124 let bytes_len = max_ordinal as usize * envelope_size;
11125 #[allow(unused_variables)]
11126 let offset = encoder.out_of_line_offset(bytes_len);
11127 let mut _prev_end_offset: usize = 0;
11128 if 1 > max_ordinal {
11129 return Ok(());
11130 }
11131
11132 let cur_offset: usize = (1 - 1) * envelope_size;
11135
11136 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11138
11139 fidl::encoding::encode_in_envelope_optional::<u32, D>(
11144 self.num_platform_ra_received
11145 .as_ref()
11146 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11147 encoder,
11148 offset + cur_offset,
11149 depth,
11150 )?;
11151
11152 _prev_end_offset = cur_offset + envelope_size;
11153 if 2 > max_ordinal {
11154 return Ok(());
11155 }
11156
11157 let cur_offset: usize = (2 - 1) * envelope_size;
11160
11161 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11163
11164 fidl::encoding::encode_in_envelope_optional::<u32, D>(
11169 self.num_platform_pio_processed
11170 .as_ref()
11171 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11172 encoder,
11173 offset + cur_offset,
11174 depth,
11175 )?;
11176
11177 _prev_end_offset = cur_offset + envelope_size;
11178 if 3 > max_ordinal {
11179 return Ok(());
11180 }
11181
11182 let cur_offset: usize = (3 - 1) * envelope_size;
11185
11186 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11188
11189 fidl::encoding::encode_in_envelope_optional::<u32, D>(
11194 self.last_platform_ra_msec
11195 .as_ref()
11196 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11197 encoder,
11198 offset + cur_offset,
11199 depth,
11200 )?;
11201
11202 _prev_end_offset = cur_offset + envelope_size;
11203
11204 Ok(())
11205 }
11206 }
11207
11208 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PdProcessedRaInfo {
11209 #[inline(always)]
11210 fn new_empty() -> Self {
11211 Self::default()
11212 }
11213
11214 unsafe fn decode(
11215 &mut self,
11216 decoder: &mut fidl::encoding::Decoder<'_, D>,
11217 offset: usize,
11218 mut depth: fidl::encoding::Depth,
11219 ) -> fidl::Result<()> {
11220 decoder.debug_check_bounds::<Self>(offset);
11221 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11222 None => return Err(fidl::Error::NotNullable),
11223 Some(len) => len,
11224 };
11225 if len == 0 {
11227 return Ok(());
11228 };
11229 depth.increment()?;
11230 let envelope_size = 8;
11231 let bytes_len = len * envelope_size;
11232 let offset = decoder.out_of_line_offset(bytes_len)?;
11233 let mut _next_ordinal_to_read = 0;
11235 let mut next_offset = offset;
11236 let end_offset = offset + bytes_len;
11237 _next_ordinal_to_read += 1;
11238 if next_offset >= end_offset {
11239 return Ok(());
11240 }
11241
11242 while _next_ordinal_to_read < 1 {
11244 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11245 _next_ordinal_to_read += 1;
11246 next_offset += envelope_size;
11247 }
11248
11249 let next_out_of_line = decoder.next_out_of_line();
11250 let handles_before = decoder.remaining_handles();
11251 if let Some((inlined, num_bytes, num_handles)) =
11252 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11253 {
11254 let member_inline_size =
11255 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11256 if inlined != (member_inline_size <= 4) {
11257 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11258 }
11259 let inner_offset;
11260 let mut inner_depth = depth.clone();
11261 if inlined {
11262 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11263 inner_offset = next_offset;
11264 } else {
11265 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11266 inner_depth.increment()?;
11267 }
11268 let val_ref =
11269 self.num_platform_ra_received.get_or_insert_with(|| fidl::new_empty!(u32, D));
11270 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11271 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11272 {
11273 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11274 }
11275 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11276 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11277 }
11278 }
11279
11280 next_offset += envelope_size;
11281 _next_ordinal_to_read += 1;
11282 if next_offset >= end_offset {
11283 return Ok(());
11284 }
11285
11286 while _next_ordinal_to_read < 2 {
11288 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11289 _next_ordinal_to_read += 1;
11290 next_offset += envelope_size;
11291 }
11292
11293 let next_out_of_line = decoder.next_out_of_line();
11294 let handles_before = decoder.remaining_handles();
11295 if let Some((inlined, num_bytes, num_handles)) =
11296 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11297 {
11298 let member_inline_size =
11299 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11300 if inlined != (member_inline_size <= 4) {
11301 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11302 }
11303 let inner_offset;
11304 let mut inner_depth = depth.clone();
11305 if inlined {
11306 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11307 inner_offset = next_offset;
11308 } else {
11309 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11310 inner_depth.increment()?;
11311 }
11312 let val_ref =
11313 self.num_platform_pio_processed.get_or_insert_with(|| fidl::new_empty!(u32, D));
11314 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11315 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11316 {
11317 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11318 }
11319 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11320 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11321 }
11322 }
11323
11324 next_offset += envelope_size;
11325 _next_ordinal_to_read += 1;
11326 if next_offset >= end_offset {
11327 return Ok(());
11328 }
11329
11330 while _next_ordinal_to_read < 3 {
11332 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11333 _next_ordinal_to_read += 1;
11334 next_offset += envelope_size;
11335 }
11336
11337 let next_out_of_line = decoder.next_out_of_line();
11338 let handles_before = decoder.remaining_handles();
11339 if let Some((inlined, num_bytes, num_handles)) =
11340 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11341 {
11342 let member_inline_size =
11343 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11344 if inlined != (member_inline_size <= 4) {
11345 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11346 }
11347 let inner_offset;
11348 let mut inner_depth = depth.clone();
11349 if inlined {
11350 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11351 inner_offset = next_offset;
11352 } else {
11353 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11354 inner_depth.increment()?;
11355 }
11356 let val_ref =
11357 self.last_platform_ra_msec.get_or_insert_with(|| fidl::new_empty!(u32, D));
11358 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11359 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11360 {
11361 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11362 }
11363 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11364 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11365 }
11366 }
11367
11368 next_offset += envelope_size;
11369
11370 while next_offset < end_offset {
11372 _next_ordinal_to_read += 1;
11373 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11374 next_offset += envelope_size;
11375 }
11376
11377 Ok(())
11378 }
11379 }
11380
11381 impl SrpServerInfo {
11382 #[inline(always)]
11383 fn max_ordinal_present(&self) -> u64 {
11384 if let Some(_) = self.services_registration {
11385 return 6;
11386 }
11387 if let Some(_) = self.hosts_registration {
11388 return 5;
11389 }
11390 if let Some(_) = self.response_counters {
11391 return 4;
11392 }
11393 if let Some(_) = self.address_mode {
11394 return 3;
11395 }
11396 if let Some(_) = self.port {
11397 return 2;
11398 }
11399 if let Some(_) = self.state {
11400 return 1;
11401 }
11402 0
11403 }
11404 }
11405
11406 impl fidl::encoding::ValueTypeMarker for SrpServerInfo {
11407 type Borrowed<'a> = &'a Self;
11408 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11409 value
11410 }
11411 }
11412
11413 unsafe impl fidl::encoding::TypeMarker for SrpServerInfo {
11414 type Owned = Self;
11415
11416 #[inline(always)]
11417 fn inline_align(_context: fidl::encoding::Context) -> usize {
11418 8
11419 }
11420
11421 #[inline(always)]
11422 fn inline_size(_context: fidl::encoding::Context) -> usize {
11423 16
11424 }
11425 }
11426
11427 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SrpServerInfo, D>
11428 for &SrpServerInfo
11429 {
11430 unsafe fn encode(
11431 self,
11432 encoder: &mut fidl::encoding::Encoder<'_, D>,
11433 offset: usize,
11434 mut depth: fidl::encoding::Depth,
11435 ) -> fidl::Result<()> {
11436 encoder.debug_check_bounds::<SrpServerInfo>(offset);
11437 let max_ordinal: u64 = self.max_ordinal_present();
11439 encoder.write_num(max_ordinal, offset);
11440 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11441 if max_ordinal == 0 {
11443 return Ok(());
11444 }
11445 depth.increment()?;
11446 let envelope_size = 8;
11447 let bytes_len = max_ordinal as usize * envelope_size;
11448 #[allow(unused_variables)]
11449 let offset = encoder.out_of_line_offset(bytes_len);
11450 let mut _prev_end_offset: usize = 0;
11451 if 1 > max_ordinal {
11452 return Ok(());
11453 }
11454
11455 let cur_offset: usize = (1 - 1) * envelope_size;
11458
11459 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11461
11462 fidl::encoding::encode_in_envelope_optional::<SrpServerState, D>(
11467 self.state
11468 .as_ref()
11469 .map(<SrpServerState as fidl::encoding::ValueTypeMarker>::borrow),
11470 encoder,
11471 offset + cur_offset,
11472 depth,
11473 )?;
11474
11475 _prev_end_offset = cur_offset + envelope_size;
11476 if 2 > max_ordinal {
11477 return Ok(());
11478 }
11479
11480 let cur_offset: usize = (2 - 1) * envelope_size;
11483
11484 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11486
11487 fidl::encoding::encode_in_envelope_optional::<u16, D>(
11492 self.port.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
11493 encoder,
11494 offset + cur_offset,
11495 depth,
11496 )?;
11497
11498 _prev_end_offset = cur_offset + envelope_size;
11499 if 3 > max_ordinal {
11500 return Ok(());
11501 }
11502
11503 let cur_offset: usize = (3 - 1) * envelope_size;
11506
11507 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11509
11510 fidl::encoding::encode_in_envelope_optional::<SrpServerAddressMode, D>(
11515 self.address_mode
11516 .as_ref()
11517 .map(<SrpServerAddressMode as fidl::encoding::ValueTypeMarker>::borrow),
11518 encoder,
11519 offset + cur_offset,
11520 depth,
11521 )?;
11522
11523 _prev_end_offset = cur_offset + envelope_size;
11524 if 4 > max_ordinal {
11525 return Ok(());
11526 }
11527
11528 let cur_offset: usize = (4 - 1) * envelope_size;
11531
11532 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11534
11535 fidl::encoding::encode_in_envelope_optional::<SrpServerResponseCounters, D>(
11540 self.response_counters
11541 .as_ref()
11542 .map(<SrpServerResponseCounters as fidl::encoding::ValueTypeMarker>::borrow),
11543 encoder,
11544 offset + cur_offset,
11545 depth,
11546 )?;
11547
11548 _prev_end_offset = cur_offset + envelope_size;
11549 if 5 > max_ordinal {
11550 return Ok(());
11551 }
11552
11553 let cur_offset: usize = (5 - 1) * envelope_size;
11556
11557 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11559
11560 fidl::encoding::encode_in_envelope_optional::<SrpServerRegistration, D>(
11565 self.hosts_registration
11566 .as_ref()
11567 .map(<SrpServerRegistration as fidl::encoding::ValueTypeMarker>::borrow),
11568 encoder,
11569 offset + cur_offset,
11570 depth,
11571 )?;
11572
11573 _prev_end_offset = cur_offset + envelope_size;
11574 if 6 > max_ordinal {
11575 return Ok(());
11576 }
11577
11578 let cur_offset: usize = (6 - 1) * envelope_size;
11581
11582 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11584
11585 fidl::encoding::encode_in_envelope_optional::<SrpServerRegistration, D>(
11590 self.services_registration
11591 .as_ref()
11592 .map(<SrpServerRegistration as fidl::encoding::ValueTypeMarker>::borrow),
11593 encoder,
11594 offset + cur_offset,
11595 depth,
11596 )?;
11597
11598 _prev_end_offset = cur_offset + envelope_size;
11599
11600 Ok(())
11601 }
11602 }
11603
11604 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerInfo {
11605 #[inline(always)]
11606 fn new_empty() -> Self {
11607 Self::default()
11608 }
11609
11610 unsafe fn decode(
11611 &mut self,
11612 decoder: &mut fidl::encoding::Decoder<'_, D>,
11613 offset: usize,
11614 mut depth: fidl::encoding::Depth,
11615 ) -> fidl::Result<()> {
11616 decoder.debug_check_bounds::<Self>(offset);
11617 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11618 None => return Err(fidl::Error::NotNullable),
11619 Some(len) => len,
11620 };
11621 if len == 0 {
11623 return Ok(());
11624 };
11625 depth.increment()?;
11626 let envelope_size = 8;
11627 let bytes_len = len * envelope_size;
11628 let offset = decoder.out_of_line_offset(bytes_len)?;
11629 let mut _next_ordinal_to_read = 0;
11631 let mut next_offset = offset;
11632 let end_offset = offset + bytes_len;
11633 _next_ordinal_to_read += 1;
11634 if next_offset >= end_offset {
11635 return Ok(());
11636 }
11637
11638 while _next_ordinal_to_read < 1 {
11640 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11641 _next_ordinal_to_read += 1;
11642 next_offset += envelope_size;
11643 }
11644
11645 let next_out_of_line = decoder.next_out_of_line();
11646 let handles_before = decoder.remaining_handles();
11647 if let Some((inlined, num_bytes, num_handles)) =
11648 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11649 {
11650 let member_inline_size =
11651 <SrpServerState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11652 if inlined != (member_inline_size <= 4) {
11653 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11654 }
11655 let inner_offset;
11656 let mut inner_depth = depth.clone();
11657 if inlined {
11658 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11659 inner_offset = next_offset;
11660 } else {
11661 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11662 inner_depth.increment()?;
11663 }
11664 let val_ref = self.state.get_or_insert_with(|| fidl::new_empty!(SrpServerState, D));
11665 fidl::decode!(SrpServerState, D, val_ref, decoder, inner_offset, inner_depth)?;
11666 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11667 {
11668 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11669 }
11670 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11671 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11672 }
11673 }
11674
11675 next_offset += envelope_size;
11676 _next_ordinal_to_read += 1;
11677 if next_offset >= end_offset {
11678 return Ok(());
11679 }
11680
11681 while _next_ordinal_to_read < 2 {
11683 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11684 _next_ordinal_to_read += 1;
11685 next_offset += envelope_size;
11686 }
11687
11688 let next_out_of_line = decoder.next_out_of_line();
11689 let handles_before = decoder.remaining_handles();
11690 if let Some((inlined, num_bytes, num_handles)) =
11691 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11692 {
11693 let member_inline_size =
11694 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11695 if inlined != (member_inline_size <= 4) {
11696 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11697 }
11698 let inner_offset;
11699 let mut inner_depth = depth.clone();
11700 if inlined {
11701 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11702 inner_offset = next_offset;
11703 } else {
11704 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11705 inner_depth.increment()?;
11706 }
11707 let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u16, D));
11708 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
11709 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11710 {
11711 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11712 }
11713 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11714 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11715 }
11716 }
11717
11718 next_offset += envelope_size;
11719 _next_ordinal_to_read += 1;
11720 if next_offset >= end_offset {
11721 return Ok(());
11722 }
11723
11724 while _next_ordinal_to_read < 3 {
11726 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11727 _next_ordinal_to_read += 1;
11728 next_offset += envelope_size;
11729 }
11730
11731 let next_out_of_line = decoder.next_out_of_line();
11732 let handles_before = decoder.remaining_handles();
11733 if let Some((inlined, num_bytes, num_handles)) =
11734 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11735 {
11736 let member_inline_size =
11737 <SrpServerAddressMode as fidl::encoding::TypeMarker>::inline_size(
11738 decoder.context,
11739 );
11740 if inlined != (member_inline_size <= 4) {
11741 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11742 }
11743 let inner_offset;
11744 let mut inner_depth = depth.clone();
11745 if inlined {
11746 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11747 inner_offset = next_offset;
11748 } else {
11749 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11750 inner_depth.increment()?;
11751 }
11752 let val_ref = self
11753 .address_mode
11754 .get_or_insert_with(|| fidl::new_empty!(SrpServerAddressMode, D));
11755 fidl::decode!(
11756 SrpServerAddressMode,
11757 D,
11758 val_ref,
11759 decoder,
11760 inner_offset,
11761 inner_depth
11762 )?;
11763 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11764 {
11765 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11766 }
11767 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11768 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11769 }
11770 }
11771
11772 next_offset += envelope_size;
11773 _next_ordinal_to_read += 1;
11774 if next_offset >= end_offset {
11775 return Ok(());
11776 }
11777
11778 while _next_ordinal_to_read < 4 {
11780 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11781 _next_ordinal_to_read += 1;
11782 next_offset += envelope_size;
11783 }
11784
11785 let next_out_of_line = decoder.next_out_of_line();
11786 let handles_before = decoder.remaining_handles();
11787 if let Some((inlined, num_bytes, num_handles)) =
11788 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11789 {
11790 let member_inline_size =
11791 <SrpServerResponseCounters as fidl::encoding::TypeMarker>::inline_size(
11792 decoder.context,
11793 );
11794 if inlined != (member_inline_size <= 4) {
11795 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11796 }
11797 let inner_offset;
11798 let mut inner_depth = depth.clone();
11799 if inlined {
11800 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11801 inner_offset = next_offset;
11802 } else {
11803 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11804 inner_depth.increment()?;
11805 }
11806 let val_ref = self
11807 .response_counters
11808 .get_or_insert_with(|| fidl::new_empty!(SrpServerResponseCounters, D));
11809 fidl::decode!(
11810 SrpServerResponseCounters,
11811 D,
11812 val_ref,
11813 decoder,
11814 inner_offset,
11815 inner_depth
11816 )?;
11817 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11818 {
11819 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11820 }
11821 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11822 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11823 }
11824 }
11825
11826 next_offset += envelope_size;
11827 _next_ordinal_to_read += 1;
11828 if next_offset >= end_offset {
11829 return Ok(());
11830 }
11831
11832 while _next_ordinal_to_read < 5 {
11834 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11835 _next_ordinal_to_read += 1;
11836 next_offset += envelope_size;
11837 }
11838
11839 let next_out_of_line = decoder.next_out_of_line();
11840 let handles_before = decoder.remaining_handles();
11841 if let Some((inlined, num_bytes, num_handles)) =
11842 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11843 {
11844 let member_inline_size =
11845 <SrpServerRegistration as fidl::encoding::TypeMarker>::inline_size(
11846 decoder.context,
11847 );
11848 if inlined != (member_inline_size <= 4) {
11849 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11850 }
11851 let inner_offset;
11852 let mut inner_depth = depth.clone();
11853 if inlined {
11854 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11855 inner_offset = next_offset;
11856 } else {
11857 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11858 inner_depth.increment()?;
11859 }
11860 let val_ref = self
11861 .hosts_registration
11862 .get_or_insert_with(|| fidl::new_empty!(SrpServerRegistration, D));
11863 fidl::decode!(
11864 SrpServerRegistration,
11865 D,
11866 val_ref,
11867 decoder,
11868 inner_offset,
11869 inner_depth
11870 )?;
11871 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11872 {
11873 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11874 }
11875 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11876 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11877 }
11878 }
11879
11880 next_offset += envelope_size;
11881 _next_ordinal_to_read += 1;
11882 if next_offset >= end_offset {
11883 return Ok(());
11884 }
11885
11886 while _next_ordinal_to_read < 6 {
11888 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11889 _next_ordinal_to_read += 1;
11890 next_offset += envelope_size;
11891 }
11892
11893 let next_out_of_line = decoder.next_out_of_line();
11894 let handles_before = decoder.remaining_handles();
11895 if let Some((inlined, num_bytes, num_handles)) =
11896 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11897 {
11898 let member_inline_size =
11899 <SrpServerRegistration as fidl::encoding::TypeMarker>::inline_size(
11900 decoder.context,
11901 );
11902 if inlined != (member_inline_size <= 4) {
11903 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11904 }
11905 let inner_offset;
11906 let mut inner_depth = depth.clone();
11907 if inlined {
11908 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11909 inner_offset = next_offset;
11910 } else {
11911 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11912 inner_depth.increment()?;
11913 }
11914 let val_ref = self
11915 .services_registration
11916 .get_or_insert_with(|| fidl::new_empty!(SrpServerRegistration, D));
11917 fidl::decode!(
11918 SrpServerRegistration,
11919 D,
11920 val_ref,
11921 decoder,
11922 inner_offset,
11923 inner_depth
11924 )?;
11925 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11926 {
11927 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11928 }
11929 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11930 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11931 }
11932 }
11933
11934 next_offset += envelope_size;
11935
11936 while next_offset < end_offset {
11938 _next_ordinal_to_read += 1;
11939 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11940 next_offset += envelope_size;
11941 }
11942
11943 Ok(())
11944 }
11945 }
11946
11947 impl SrpServerRegistration {
11948 #[inline(always)]
11949 fn max_ordinal_present(&self) -> u64 {
11950 if let Some(_) = self.remaining_key_lease_time_total {
11951 return 6;
11952 }
11953 if let Some(_) = self.remaining_lease_time_total {
11954 return 5;
11955 }
11956 if let Some(_) = self.key_lease_time_total {
11957 return 4;
11958 }
11959 if let Some(_) = self.lease_time_total {
11960 return 3;
11961 }
11962 if let Some(_) = self.deleted_count {
11963 return 2;
11964 }
11965 if let Some(_) = self.fresh_count {
11966 return 1;
11967 }
11968 0
11969 }
11970 }
11971
11972 impl fidl::encoding::ValueTypeMarker for SrpServerRegistration {
11973 type Borrowed<'a> = &'a Self;
11974 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11975 value
11976 }
11977 }
11978
11979 unsafe impl fidl::encoding::TypeMarker for SrpServerRegistration {
11980 type Owned = Self;
11981
11982 #[inline(always)]
11983 fn inline_align(_context: fidl::encoding::Context) -> usize {
11984 8
11985 }
11986
11987 #[inline(always)]
11988 fn inline_size(_context: fidl::encoding::Context) -> usize {
11989 16
11990 }
11991 }
11992
11993 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SrpServerRegistration, D>
11994 for &SrpServerRegistration
11995 {
11996 unsafe fn encode(
11997 self,
11998 encoder: &mut fidl::encoding::Encoder<'_, D>,
11999 offset: usize,
12000 mut depth: fidl::encoding::Depth,
12001 ) -> fidl::Result<()> {
12002 encoder.debug_check_bounds::<SrpServerRegistration>(offset);
12003 let max_ordinal: u64 = self.max_ordinal_present();
12005 encoder.write_num(max_ordinal, offset);
12006 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12007 if max_ordinal == 0 {
12009 return Ok(());
12010 }
12011 depth.increment()?;
12012 let envelope_size = 8;
12013 let bytes_len = max_ordinal as usize * envelope_size;
12014 #[allow(unused_variables)]
12015 let offset = encoder.out_of_line_offset(bytes_len);
12016 let mut _prev_end_offset: usize = 0;
12017 if 1 > max_ordinal {
12018 return Ok(());
12019 }
12020
12021 let cur_offset: usize = (1 - 1) * envelope_size;
12024
12025 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12027
12028 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12033 self.fresh_count.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12034 encoder,
12035 offset + cur_offset,
12036 depth,
12037 )?;
12038
12039 _prev_end_offset = cur_offset + envelope_size;
12040 if 2 > max_ordinal {
12041 return Ok(());
12042 }
12043
12044 let cur_offset: usize = (2 - 1) * envelope_size;
12047
12048 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12050
12051 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12056 self.deleted_count.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12057 encoder,
12058 offset + cur_offset,
12059 depth,
12060 )?;
12061
12062 _prev_end_offset = cur_offset + envelope_size;
12063 if 3 > max_ordinal {
12064 return Ok(());
12065 }
12066
12067 let cur_offset: usize = (3 - 1) * envelope_size;
12070
12071 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12073
12074 fidl::encoding::encode_in_envelope_optional::<i64, D>(
12079 self.lease_time_total
12080 .as_ref()
12081 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12082 encoder,
12083 offset + cur_offset,
12084 depth,
12085 )?;
12086
12087 _prev_end_offset = cur_offset + envelope_size;
12088 if 4 > max_ordinal {
12089 return Ok(());
12090 }
12091
12092 let cur_offset: usize = (4 - 1) * envelope_size;
12095
12096 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12098
12099 fidl::encoding::encode_in_envelope_optional::<i64, D>(
12104 self.key_lease_time_total
12105 .as_ref()
12106 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12107 encoder,
12108 offset + cur_offset,
12109 depth,
12110 )?;
12111
12112 _prev_end_offset = cur_offset + envelope_size;
12113 if 5 > max_ordinal {
12114 return Ok(());
12115 }
12116
12117 let cur_offset: usize = (5 - 1) * envelope_size;
12120
12121 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12123
12124 fidl::encoding::encode_in_envelope_optional::<i64, D>(
12129 self.remaining_lease_time_total
12130 .as_ref()
12131 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12132 encoder,
12133 offset + cur_offset,
12134 depth,
12135 )?;
12136
12137 _prev_end_offset = cur_offset + envelope_size;
12138 if 6 > max_ordinal {
12139 return Ok(());
12140 }
12141
12142 let cur_offset: usize = (6 - 1) * envelope_size;
12145
12146 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12148
12149 fidl::encoding::encode_in_envelope_optional::<i64, D>(
12154 self.remaining_key_lease_time_total
12155 .as_ref()
12156 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12157 encoder,
12158 offset + cur_offset,
12159 depth,
12160 )?;
12161
12162 _prev_end_offset = cur_offset + envelope_size;
12163
12164 Ok(())
12165 }
12166 }
12167
12168 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerRegistration {
12169 #[inline(always)]
12170 fn new_empty() -> Self {
12171 Self::default()
12172 }
12173
12174 unsafe fn decode(
12175 &mut self,
12176 decoder: &mut fidl::encoding::Decoder<'_, D>,
12177 offset: usize,
12178 mut depth: fidl::encoding::Depth,
12179 ) -> fidl::Result<()> {
12180 decoder.debug_check_bounds::<Self>(offset);
12181 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12182 None => return Err(fidl::Error::NotNullable),
12183 Some(len) => len,
12184 };
12185 if len == 0 {
12187 return Ok(());
12188 };
12189 depth.increment()?;
12190 let envelope_size = 8;
12191 let bytes_len = len * envelope_size;
12192 let offset = decoder.out_of_line_offset(bytes_len)?;
12193 let mut _next_ordinal_to_read = 0;
12195 let mut next_offset = offset;
12196 let end_offset = offset + bytes_len;
12197 _next_ordinal_to_read += 1;
12198 if next_offset >= end_offset {
12199 return Ok(());
12200 }
12201
12202 while _next_ordinal_to_read < 1 {
12204 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12205 _next_ordinal_to_read += 1;
12206 next_offset += envelope_size;
12207 }
12208
12209 let next_out_of_line = decoder.next_out_of_line();
12210 let handles_before = decoder.remaining_handles();
12211 if let Some((inlined, num_bytes, num_handles)) =
12212 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12213 {
12214 let member_inline_size =
12215 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12216 if inlined != (member_inline_size <= 4) {
12217 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12218 }
12219 let inner_offset;
12220 let mut inner_depth = depth.clone();
12221 if inlined {
12222 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12223 inner_offset = next_offset;
12224 } else {
12225 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12226 inner_depth.increment()?;
12227 }
12228 let val_ref = self.fresh_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
12229 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12230 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12231 {
12232 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12233 }
12234 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12235 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12236 }
12237 }
12238
12239 next_offset += envelope_size;
12240 _next_ordinal_to_read += 1;
12241 if next_offset >= end_offset {
12242 return Ok(());
12243 }
12244
12245 while _next_ordinal_to_read < 2 {
12247 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12248 _next_ordinal_to_read += 1;
12249 next_offset += envelope_size;
12250 }
12251
12252 let next_out_of_line = decoder.next_out_of_line();
12253 let handles_before = decoder.remaining_handles();
12254 if let Some((inlined, num_bytes, num_handles)) =
12255 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12256 {
12257 let member_inline_size =
12258 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12259 if inlined != (member_inline_size <= 4) {
12260 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12261 }
12262 let inner_offset;
12263 let mut inner_depth = depth.clone();
12264 if inlined {
12265 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12266 inner_offset = next_offset;
12267 } else {
12268 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12269 inner_depth.increment()?;
12270 }
12271 let val_ref = self.deleted_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
12272 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12273 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12274 {
12275 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12276 }
12277 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12278 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12279 }
12280 }
12281
12282 next_offset += envelope_size;
12283 _next_ordinal_to_read += 1;
12284 if next_offset >= end_offset {
12285 return Ok(());
12286 }
12287
12288 while _next_ordinal_to_read < 3 {
12290 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12291 _next_ordinal_to_read += 1;
12292 next_offset += envelope_size;
12293 }
12294
12295 let next_out_of_line = decoder.next_out_of_line();
12296 let handles_before = decoder.remaining_handles();
12297 if let Some((inlined, num_bytes, num_handles)) =
12298 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12299 {
12300 let member_inline_size =
12301 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12302 if inlined != (member_inline_size <= 4) {
12303 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12304 }
12305 let inner_offset;
12306 let mut inner_depth = depth.clone();
12307 if inlined {
12308 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12309 inner_offset = next_offset;
12310 } else {
12311 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12312 inner_depth.increment()?;
12313 }
12314 let val_ref = self.lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12315 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12316 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12317 {
12318 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12319 }
12320 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12321 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12322 }
12323 }
12324
12325 next_offset += envelope_size;
12326 _next_ordinal_to_read += 1;
12327 if next_offset >= end_offset {
12328 return Ok(());
12329 }
12330
12331 while _next_ordinal_to_read < 4 {
12333 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12334 _next_ordinal_to_read += 1;
12335 next_offset += envelope_size;
12336 }
12337
12338 let next_out_of_line = decoder.next_out_of_line();
12339 let handles_before = decoder.remaining_handles();
12340 if let Some((inlined, num_bytes, num_handles)) =
12341 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12342 {
12343 let member_inline_size =
12344 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12345 if inlined != (member_inline_size <= 4) {
12346 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12347 }
12348 let inner_offset;
12349 let mut inner_depth = depth.clone();
12350 if inlined {
12351 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12352 inner_offset = next_offset;
12353 } else {
12354 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12355 inner_depth.increment()?;
12356 }
12357 let val_ref =
12358 self.key_lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12359 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12360 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12361 {
12362 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12363 }
12364 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12365 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12366 }
12367 }
12368
12369 next_offset += envelope_size;
12370 _next_ordinal_to_read += 1;
12371 if next_offset >= end_offset {
12372 return Ok(());
12373 }
12374
12375 while _next_ordinal_to_read < 5 {
12377 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12378 _next_ordinal_to_read += 1;
12379 next_offset += envelope_size;
12380 }
12381
12382 let next_out_of_line = decoder.next_out_of_line();
12383 let handles_before = decoder.remaining_handles();
12384 if let Some((inlined, num_bytes, num_handles)) =
12385 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12386 {
12387 let member_inline_size =
12388 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12389 if inlined != (member_inline_size <= 4) {
12390 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12391 }
12392 let inner_offset;
12393 let mut inner_depth = depth.clone();
12394 if inlined {
12395 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12396 inner_offset = next_offset;
12397 } else {
12398 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12399 inner_depth.increment()?;
12400 }
12401 let val_ref =
12402 self.remaining_lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12403 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12404 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12405 {
12406 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12407 }
12408 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12409 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12410 }
12411 }
12412
12413 next_offset += envelope_size;
12414 _next_ordinal_to_read += 1;
12415 if next_offset >= end_offset {
12416 return Ok(());
12417 }
12418
12419 while _next_ordinal_to_read < 6 {
12421 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12422 _next_ordinal_to_read += 1;
12423 next_offset += envelope_size;
12424 }
12425
12426 let next_out_of_line = decoder.next_out_of_line();
12427 let handles_before = decoder.remaining_handles();
12428 if let Some((inlined, num_bytes, num_handles)) =
12429 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12430 {
12431 let member_inline_size =
12432 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12433 if inlined != (member_inline_size <= 4) {
12434 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12435 }
12436 let inner_offset;
12437 let mut inner_depth = depth.clone();
12438 if inlined {
12439 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12440 inner_offset = next_offset;
12441 } else {
12442 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12443 inner_depth.increment()?;
12444 }
12445 let val_ref = self
12446 .remaining_key_lease_time_total
12447 .get_or_insert_with(|| fidl::new_empty!(i64, D));
12448 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12449 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12450 {
12451 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12452 }
12453 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12454 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12455 }
12456 }
12457
12458 next_offset += envelope_size;
12459
12460 while next_offset < end_offset {
12462 _next_ordinal_to_read += 1;
12463 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12464 next_offset += envelope_size;
12465 }
12466
12467 Ok(())
12468 }
12469 }
12470
12471 impl SrpServerResponseCounters {
12472 #[inline(always)]
12473 fn max_ordinal_present(&self) -> u64 {
12474 if let Some(_) = self.other_response {
12475 return 6;
12476 }
12477 if let Some(_) = self.refused_response {
12478 return 5;
12479 }
12480 if let Some(_) = self.name_exists_response {
12481 return 4;
12482 }
12483 if let Some(_) = self.format_error_response {
12484 return 3;
12485 }
12486 if let Some(_) = self.server_failure_response {
12487 return 2;
12488 }
12489 if let Some(_) = self.success_response {
12490 return 1;
12491 }
12492 0
12493 }
12494 }
12495
12496 impl fidl::encoding::ValueTypeMarker for SrpServerResponseCounters {
12497 type Borrowed<'a> = &'a Self;
12498 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12499 value
12500 }
12501 }
12502
12503 unsafe impl fidl::encoding::TypeMarker for SrpServerResponseCounters {
12504 type Owned = Self;
12505
12506 #[inline(always)]
12507 fn inline_align(_context: fidl::encoding::Context) -> usize {
12508 8
12509 }
12510
12511 #[inline(always)]
12512 fn inline_size(_context: fidl::encoding::Context) -> usize {
12513 16
12514 }
12515 }
12516
12517 unsafe impl<D: fidl::encoding::ResourceDialect>
12518 fidl::encoding::Encode<SrpServerResponseCounters, D> for &SrpServerResponseCounters
12519 {
12520 unsafe fn encode(
12521 self,
12522 encoder: &mut fidl::encoding::Encoder<'_, D>,
12523 offset: usize,
12524 mut depth: fidl::encoding::Depth,
12525 ) -> fidl::Result<()> {
12526 encoder.debug_check_bounds::<SrpServerResponseCounters>(offset);
12527 let max_ordinal: u64 = self.max_ordinal_present();
12529 encoder.write_num(max_ordinal, offset);
12530 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12531 if max_ordinal == 0 {
12533 return Ok(());
12534 }
12535 depth.increment()?;
12536 let envelope_size = 8;
12537 let bytes_len = max_ordinal as usize * envelope_size;
12538 #[allow(unused_variables)]
12539 let offset = encoder.out_of_line_offset(bytes_len);
12540 let mut _prev_end_offset: usize = 0;
12541 if 1 > max_ordinal {
12542 return Ok(());
12543 }
12544
12545 let cur_offset: usize = (1 - 1) * envelope_size;
12548
12549 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12551
12552 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12557 self.success_response
12558 .as_ref()
12559 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12560 encoder,
12561 offset + cur_offset,
12562 depth,
12563 )?;
12564
12565 _prev_end_offset = cur_offset + envelope_size;
12566 if 2 > max_ordinal {
12567 return Ok(());
12568 }
12569
12570 let cur_offset: usize = (2 - 1) * envelope_size;
12573
12574 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12576
12577 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12582 self.server_failure_response
12583 .as_ref()
12584 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12585 encoder,
12586 offset + cur_offset,
12587 depth,
12588 )?;
12589
12590 _prev_end_offset = cur_offset + envelope_size;
12591 if 3 > max_ordinal {
12592 return Ok(());
12593 }
12594
12595 let cur_offset: usize = (3 - 1) * envelope_size;
12598
12599 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12601
12602 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12607 self.format_error_response
12608 .as_ref()
12609 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12610 encoder,
12611 offset + cur_offset,
12612 depth,
12613 )?;
12614
12615 _prev_end_offset = cur_offset + envelope_size;
12616 if 4 > max_ordinal {
12617 return Ok(());
12618 }
12619
12620 let cur_offset: usize = (4 - 1) * envelope_size;
12623
12624 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12626
12627 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12632 self.name_exists_response
12633 .as_ref()
12634 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12635 encoder,
12636 offset + cur_offset,
12637 depth,
12638 )?;
12639
12640 _prev_end_offset = cur_offset + envelope_size;
12641 if 5 > max_ordinal {
12642 return Ok(());
12643 }
12644
12645 let cur_offset: usize = (5 - 1) * envelope_size;
12648
12649 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12651
12652 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12657 self.refused_response
12658 .as_ref()
12659 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12660 encoder,
12661 offset + cur_offset,
12662 depth,
12663 )?;
12664
12665 _prev_end_offset = cur_offset + envelope_size;
12666 if 6 > max_ordinal {
12667 return Ok(());
12668 }
12669
12670 let cur_offset: usize = (6 - 1) * envelope_size;
12673
12674 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12676
12677 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12682 self.other_response.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12683 encoder,
12684 offset + cur_offset,
12685 depth,
12686 )?;
12687
12688 _prev_end_offset = cur_offset + envelope_size;
12689
12690 Ok(())
12691 }
12692 }
12693
12694 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12695 for SrpServerResponseCounters
12696 {
12697 #[inline(always)]
12698 fn new_empty() -> Self {
12699 Self::default()
12700 }
12701
12702 unsafe fn decode(
12703 &mut self,
12704 decoder: &mut fidl::encoding::Decoder<'_, D>,
12705 offset: usize,
12706 mut depth: fidl::encoding::Depth,
12707 ) -> fidl::Result<()> {
12708 decoder.debug_check_bounds::<Self>(offset);
12709 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12710 None => return Err(fidl::Error::NotNullable),
12711 Some(len) => len,
12712 };
12713 if len == 0 {
12715 return Ok(());
12716 };
12717 depth.increment()?;
12718 let envelope_size = 8;
12719 let bytes_len = len * envelope_size;
12720 let offset = decoder.out_of_line_offset(bytes_len)?;
12721 let mut _next_ordinal_to_read = 0;
12723 let mut next_offset = offset;
12724 let end_offset = offset + bytes_len;
12725 _next_ordinal_to_read += 1;
12726 if next_offset >= end_offset {
12727 return Ok(());
12728 }
12729
12730 while _next_ordinal_to_read < 1 {
12732 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12733 _next_ordinal_to_read += 1;
12734 next_offset += envelope_size;
12735 }
12736
12737 let next_out_of_line = decoder.next_out_of_line();
12738 let handles_before = decoder.remaining_handles();
12739 if let Some((inlined, num_bytes, num_handles)) =
12740 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12741 {
12742 let member_inline_size =
12743 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12744 if inlined != (member_inline_size <= 4) {
12745 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12746 }
12747 let inner_offset;
12748 let mut inner_depth = depth.clone();
12749 if inlined {
12750 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12751 inner_offset = next_offset;
12752 } else {
12753 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12754 inner_depth.increment()?;
12755 }
12756 let val_ref = self.success_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12757 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12758 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12759 {
12760 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12761 }
12762 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12763 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12764 }
12765 }
12766
12767 next_offset += envelope_size;
12768 _next_ordinal_to_read += 1;
12769 if next_offset >= end_offset {
12770 return Ok(());
12771 }
12772
12773 while _next_ordinal_to_read < 2 {
12775 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12776 _next_ordinal_to_read += 1;
12777 next_offset += envelope_size;
12778 }
12779
12780 let next_out_of_line = decoder.next_out_of_line();
12781 let handles_before = decoder.remaining_handles();
12782 if let Some((inlined, num_bytes, num_handles)) =
12783 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12784 {
12785 let member_inline_size =
12786 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12787 if inlined != (member_inline_size <= 4) {
12788 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12789 }
12790 let inner_offset;
12791 let mut inner_depth = depth.clone();
12792 if inlined {
12793 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12794 inner_offset = next_offset;
12795 } else {
12796 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12797 inner_depth.increment()?;
12798 }
12799 let val_ref =
12800 self.server_failure_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12801 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12802 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12803 {
12804 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12805 }
12806 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12807 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12808 }
12809 }
12810
12811 next_offset += envelope_size;
12812 _next_ordinal_to_read += 1;
12813 if next_offset >= end_offset {
12814 return Ok(());
12815 }
12816
12817 while _next_ordinal_to_read < 3 {
12819 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12820 _next_ordinal_to_read += 1;
12821 next_offset += envelope_size;
12822 }
12823
12824 let next_out_of_line = decoder.next_out_of_line();
12825 let handles_before = decoder.remaining_handles();
12826 if let Some((inlined, num_bytes, num_handles)) =
12827 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12828 {
12829 let member_inline_size =
12830 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12831 if inlined != (member_inline_size <= 4) {
12832 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12833 }
12834 let inner_offset;
12835 let mut inner_depth = depth.clone();
12836 if inlined {
12837 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12838 inner_offset = next_offset;
12839 } else {
12840 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12841 inner_depth.increment()?;
12842 }
12843 let val_ref =
12844 self.format_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12845 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12846 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12847 {
12848 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12849 }
12850 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12851 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12852 }
12853 }
12854
12855 next_offset += envelope_size;
12856 _next_ordinal_to_read += 1;
12857 if next_offset >= end_offset {
12858 return Ok(());
12859 }
12860
12861 while _next_ordinal_to_read < 4 {
12863 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12864 _next_ordinal_to_read += 1;
12865 next_offset += envelope_size;
12866 }
12867
12868 let next_out_of_line = decoder.next_out_of_line();
12869 let handles_before = decoder.remaining_handles();
12870 if let Some((inlined, num_bytes, num_handles)) =
12871 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12872 {
12873 let member_inline_size =
12874 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12875 if inlined != (member_inline_size <= 4) {
12876 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12877 }
12878 let inner_offset;
12879 let mut inner_depth = depth.clone();
12880 if inlined {
12881 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12882 inner_offset = next_offset;
12883 } else {
12884 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12885 inner_depth.increment()?;
12886 }
12887 let val_ref =
12888 self.name_exists_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12889 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12890 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12891 {
12892 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12893 }
12894 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12895 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12896 }
12897 }
12898
12899 next_offset += envelope_size;
12900 _next_ordinal_to_read += 1;
12901 if next_offset >= end_offset {
12902 return Ok(());
12903 }
12904
12905 while _next_ordinal_to_read < 5 {
12907 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12908 _next_ordinal_to_read += 1;
12909 next_offset += envelope_size;
12910 }
12911
12912 let next_out_of_line = decoder.next_out_of_line();
12913 let handles_before = decoder.remaining_handles();
12914 if let Some((inlined, num_bytes, num_handles)) =
12915 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12916 {
12917 let member_inline_size =
12918 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12919 if inlined != (member_inline_size <= 4) {
12920 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12921 }
12922 let inner_offset;
12923 let mut inner_depth = depth.clone();
12924 if inlined {
12925 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12926 inner_offset = next_offset;
12927 } else {
12928 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12929 inner_depth.increment()?;
12930 }
12931 let val_ref = self.refused_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12932 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12933 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12934 {
12935 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12936 }
12937 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12938 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12939 }
12940 }
12941
12942 next_offset += envelope_size;
12943 _next_ordinal_to_read += 1;
12944 if next_offset >= end_offset {
12945 return Ok(());
12946 }
12947
12948 while _next_ordinal_to_read < 6 {
12950 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12951 _next_ordinal_to_read += 1;
12952 next_offset += envelope_size;
12953 }
12954
12955 let next_out_of_line = decoder.next_out_of_line();
12956 let handles_before = decoder.remaining_handles();
12957 if let Some((inlined, num_bytes, num_handles)) =
12958 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12959 {
12960 let member_inline_size =
12961 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12962 if inlined != (member_inline_size <= 4) {
12963 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12964 }
12965 let inner_offset;
12966 let mut inner_depth = depth.clone();
12967 if inlined {
12968 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12969 inner_offset = next_offset;
12970 } else {
12971 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12972 inner_depth.increment()?;
12973 }
12974 let val_ref = self.other_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12975 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12976 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12977 {
12978 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12979 }
12980 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12981 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12982 }
12983 }
12984
12985 next_offset += envelope_size;
12986
12987 while next_offset < end_offset {
12989 _next_ordinal_to_read += 1;
12990 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12991 next_offset += envelope_size;
12992 }
12993
12994 Ok(())
12995 }
12996 }
12997
12998 impl Telemetry {
12999 #[inline(always)]
13000 fn max_ordinal_present(&self) -> u64 {
13001 if let Some(_) = self.link_metrics_entries {
13002 return 24;
13003 }
13004 if let Some(_) = self.dhcp6pd_info {
13005 return 23;
13006 }
13007 if let Some(_) = self.upstream_dns_info {
13008 return 22;
13009 }
13010 if let Some(_) = self.trel_peers_info {
13011 return 21;
13012 }
13013 if let Some(_) = self.trel_counters {
13014 return 20;
13015 }
13016 if let Some(_) = self.nat64_info {
13017 return 19;
13018 }
13019 if let Some(_) = self.uptime {
13020 return 18;
13021 }
13022 if let Some(_) = self.leader_data {
13023 return 17;
13024 }
13025 if let Some(_) = self.dnssd_counters {
13026 return 16;
13027 }
13028 if let Some(_) = self.srp_server_info {
13029 return 15;
13030 }
13031 if let Some(_) = self.thread_border_routing_counters {
13032 return 14;
13033 }
13034 if let Some(_) = self.thread_stable_network_data {
13035 return 13;
13036 }
13037 if let Some(_) = self.thread_network_data {
13038 return 12;
13039 }
13040 if let Some(_) = self.thread_stable_network_data_version {
13041 return 11;
13042 }
13043 if let Some(_) = self.thread_network_data_version {
13044 return 10;
13045 }
13046 if let Some(_) = self.thread_rloc {
13047 return 9;
13048 }
13049 if let Some(_) = self.thread_router_id {
13050 return 8;
13051 }
13052 if let Some(_) = self.thread_link_mode {
13053 return 7;
13054 }
13055 if let Some(_) = self.rcp_version {
13056 return 6;
13057 }
13058 if let Some(_) = self.stack_version {
13059 return 5;
13060 }
13061 if let Some(_) = self.partition_id {
13062 return 4;
13063 }
13064 if let Some(_) = self.channel_index {
13065 return 3;
13066 }
13067 if let Some(_) = self.tx_power {
13068 return 2;
13069 }
13070 if let Some(_) = self.rssi {
13071 return 1;
13072 }
13073 0
13074 }
13075 }
13076
13077 impl fidl::encoding::ValueTypeMarker for Telemetry {
13078 type Borrowed<'a> = &'a Self;
13079 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13080 value
13081 }
13082 }
13083
13084 unsafe impl fidl::encoding::TypeMarker for Telemetry {
13085 type Owned = Self;
13086
13087 #[inline(always)]
13088 fn inline_align(_context: fidl::encoding::Context) -> usize {
13089 8
13090 }
13091
13092 #[inline(always)]
13093 fn inline_size(_context: fidl::encoding::Context) -> usize {
13094 16
13095 }
13096 }
13097
13098 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Telemetry, D>
13099 for &Telemetry
13100 {
13101 unsafe fn encode(
13102 self,
13103 encoder: &mut fidl::encoding::Encoder<'_, D>,
13104 offset: usize,
13105 mut depth: fidl::encoding::Depth,
13106 ) -> fidl::Result<()> {
13107 encoder.debug_check_bounds::<Telemetry>(offset);
13108 let max_ordinal: u64 = self.max_ordinal_present();
13110 encoder.write_num(max_ordinal, offset);
13111 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13112 if max_ordinal == 0 {
13114 return Ok(());
13115 }
13116 depth.increment()?;
13117 let envelope_size = 8;
13118 let bytes_len = max_ordinal as usize * envelope_size;
13119 #[allow(unused_variables)]
13120 let offset = encoder.out_of_line_offset(bytes_len);
13121 let mut _prev_end_offset: usize = 0;
13122 if 1 > max_ordinal {
13123 return Ok(());
13124 }
13125
13126 let cur_offset: usize = (1 - 1) * envelope_size;
13129
13130 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13132
13133 fidl::encoding::encode_in_envelope_optional::<i8, D>(
13138 self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
13139 encoder,
13140 offset + cur_offset,
13141 depth,
13142 )?;
13143
13144 _prev_end_offset = cur_offset + envelope_size;
13145 if 2 > max_ordinal {
13146 return Ok(());
13147 }
13148
13149 let cur_offset: usize = (2 - 1) * envelope_size;
13152
13153 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13155
13156 fidl::encoding::encode_in_envelope_optional::<i8, D>(
13161 self.tx_power.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
13162 encoder,
13163 offset + cur_offset,
13164 depth,
13165 )?;
13166
13167 _prev_end_offset = cur_offset + envelope_size;
13168 if 3 > max_ordinal {
13169 return Ok(());
13170 }
13171
13172 let cur_offset: usize = (3 - 1) * envelope_size;
13175
13176 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13178
13179 fidl::encoding::encode_in_envelope_optional::<u16, D>(
13184 self.channel_index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
13185 encoder,
13186 offset + cur_offset,
13187 depth,
13188 )?;
13189
13190 _prev_end_offset = cur_offset + envelope_size;
13191 if 4 > max_ordinal {
13192 return Ok(());
13193 }
13194
13195 let cur_offset: usize = (4 - 1) * envelope_size;
13198
13199 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13201
13202 fidl::encoding::encode_in_envelope_optional::<u32, D>(
13207 self.partition_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13208 encoder,
13209 offset + cur_offset,
13210 depth,
13211 )?;
13212
13213 _prev_end_offset = cur_offset + envelope_size;
13214 if 5 > max_ordinal {
13215 return Ok(());
13216 }
13217
13218 let cur_offset: usize = (5 - 1) * envelope_size;
13221
13222 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13224
13225 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
13230 self.stack_version.as_ref().map(
13231 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
13232 ),
13233 encoder,
13234 offset + cur_offset,
13235 depth,
13236 )?;
13237
13238 _prev_end_offset = cur_offset + envelope_size;
13239 if 6 > max_ordinal {
13240 return Ok(());
13241 }
13242
13243 let cur_offset: usize = (6 - 1) * envelope_size;
13246
13247 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13249
13250 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
13255 self.rcp_version.as_ref().map(
13256 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
13257 ),
13258 encoder,
13259 offset + cur_offset,
13260 depth,
13261 )?;
13262
13263 _prev_end_offset = cur_offset + envelope_size;
13264 if 7 > max_ordinal {
13265 return Ok(());
13266 }
13267
13268 let cur_offset: usize = (7 - 1) * envelope_size;
13271
13272 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13274
13275 fidl::encoding::encode_in_envelope_optional::<u8, D>(
13280 self.thread_link_mode.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13281 encoder,
13282 offset + cur_offset,
13283 depth,
13284 )?;
13285
13286 _prev_end_offset = cur_offset + envelope_size;
13287 if 8 > max_ordinal {
13288 return Ok(());
13289 }
13290
13291 let cur_offset: usize = (8 - 1) * envelope_size;
13294
13295 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13297
13298 fidl::encoding::encode_in_envelope_optional::<u8, D>(
13303 self.thread_router_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13304 encoder,
13305 offset + cur_offset,
13306 depth,
13307 )?;
13308
13309 _prev_end_offset = cur_offset + envelope_size;
13310 if 9 > max_ordinal {
13311 return Ok(());
13312 }
13313
13314 let cur_offset: usize = (9 - 1) * envelope_size;
13317
13318 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13320
13321 fidl::encoding::encode_in_envelope_optional::<u16, D>(
13326 self.thread_rloc.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
13327 encoder,
13328 offset + cur_offset,
13329 depth,
13330 )?;
13331
13332 _prev_end_offset = cur_offset + envelope_size;
13333 if 10 > max_ordinal {
13334 return Ok(());
13335 }
13336
13337 let cur_offset: usize = (10 - 1) * envelope_size;
13340
13341 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13343
13344 fidl::encoding::encode_in_envelope_optional::<u8, D>(
13349 self.thread_network_data_version
13350 .as_ref()
13351 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13352 encoder,
13353 offset + cur_offset,
13354 depth,
13355 )?;
13356
13357 _prev_end_offset = cur_offset + envelope_size;
13358 if 11 > max_ordinal {
13359 return Ok(());
13360 }
13361
13362 let cur_offset: usize = (11 - 1) * envelope_size;
13365
13366 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13368
13369 fidl::encoding::encode_in_envelope_optional::<u8, D>(
13374 self.thread_stable_network_data_version
13375 .as_ref()
13376 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13377 encoder,
13378 offset + cur_offset,
13379 depth,
13380 )?;
13381
13382 _prev_end_offset = cur_offset + envelope_size;
13383 if 12 > max_ordinal {
13384 return Ok(());
13385 }
13386
13387 let cur_offset: usize = (12 - 1) * envelope_size;
13390
13391 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13393
13394 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 255>, D>(
13399 self.thread_network_data.as_ref().map(
13400 <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow,
13401 ),
13402 encoder,
13403 offset + cur_offset,
13404 depth,
13405 )?;
13406
13407 _prev_end_offset = cur_offset + envelope_size;
13408 if 13 > max_ordinal {
13409 return Ok(());
13410 }
13411
13412 let cur_offset: usize = (13 - 1) * envelope_size;
13415
13416 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13418
13419 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 255>, D>(
13424 self.thread_stable_network_data.as_ref().map(
13425 <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow,
13426 ),
13427 encoder,
13428 offset + cur_offset,
13429 depth,
13430 )?;
13431
13432 _prev_end_offset = cur_offset + envelope_size;
13433 if 14 > max_ordinal {
13434 return Ok(());
13435 }
13436
13437 let cur_offset: usize = (14 - 1) * envelope_size;
13440
13441 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13443
13444 fidl::encoding::encode_in_envelope_optional::<BorderRoutingCounters, D>(
13449 self.thread_border_routing_counters
13450 .as_ref()
13451 .map(<BorderRoutingCounters as fidl::encoding::ValueTypeMarker>::borrow),
13452 encoder,
13453 offset + cur_offset,
13454 depth,
13455 )?;
13456
13457 _prev_end_offset = cur_offset + envelope_size;
13458 if 15 > max_ordinal {
13459 return Ok(());
13460 }
13461
13462 let cur_offset: usize = (15 - 1) * envelope_size;
13465
13466 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13468
13469 fidl::encoding::encode_in_envelope_optional::<SrpServerInfo, D>(
13474 self.srp_server_info
13475 .as_ref()
13476 .map(<SrpServerInfo as fidl::encoding::ValueTypeMarker>::borrow),
13477 encoder,
13478 offset + cur_offset,
13479 depth,
13480 )?;
13481
13482 _prev_end_offset = cur_offset + envelope_size;
13483 if 16 > max_ordinal {
13484 return Ok(());
13485 }
13486
13487 let cur_offset: usize = (16 - 1) * envelope_size;
13490
13491 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13493
13494 fidl::encoding::encode_in_envelope_optional::<DnssdCounters, D>(
13499 self.dnssd_counters
13500 .as_ref()
13501 .map(<DnssdCounters as fidl::encoding::ValueTypeMarker>::borrow),
13502 encoder,
13503 offset + cur_offset,
13504 depth,
13505 )?;
13506
13507 _prev_end_offset = cur_offset + envelope_size;
13508 if 17 > max_ordinal {
13509 return Ok(());
13510 }
13511
13512 let cur_offset: usize = (17 - 1) * envelope_size;
13515
13516 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13518
13519 fidl::encoding::encode_in_envelope_optional::<LeaderData, D>(
13524 self.leader_data
13525 .as_ref()
13526 .map(<LeaderData as fidl::encoding::ValueTypeMarker>::borrow),
13527 encoder,
13528 offset + cur_offset,
13529 depth,
13530 )?;
13531
13532 _prev_end_offset = cur_offset + envelope_size;
13533 if 18 > max_ordinal {
13534 return Ok(());
13535 }
13536
13537 let cur_offset: usize = (18 - 1) * envelope_size;
13540
13541 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13543
13544 fidl::encoding::encode_in_envelope_optional::<i64, D>(
13549 self.uptime.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
13550 encoder,
13551 offset + cur_offset,
13552 depth,
13553 )?;
13554
13555 _prev_end_offset = cur_offset + envelope_size;
13556 if 19 > max_ordinal {
13557 return Ok(());
13558 }
13559
13560 let cur_offset: usize = (19 - 1) * envelope_size;
13563
13564 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13566
13567 fidl::encoding::encode_in_envelope_optional::<Nat64Info, D>(
13572 self.nat64_info
13573 .as_ref()
13574 .map(<Nat64Info as fidl::encoding::ValueTypeMarker>::borrow),
13575 encoder,
13576 offset + cur_offset,
13577 depth,
13578 )?;
13579
13580 _prev_end_offset = cur_offset + envelope_size;
13581 if 20 > max_ordinal {
13582 return Ok(());
13583 }
13584
13585 let cur_offset: usize = (20 - 1) * envelope_size;
13588
13589 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13591
13592 fidl::encoding::encode_in_envelope_optional::<TrelCounters, D>(
13597 self.trel_counters
13598 .as_ref()
13599 .map(<TrelCounters as fidl::encoding::ValueTypeMarker>::borrow),
13600 encoder,
13601 offset + cur_offset,
13602 depth,
13603 )?;
13604
13605 _prev_end_offset = cur_offset + envelope_size;
13606 if 21 > max_ordinal {
13607 return Ok(());
13608 }
13609
13610 let cur_offset: usize = (21 - 1) * envelope_size;
13613
13614 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13616
13617 fidl::encoding::encode_in_envelope_optional::<TrelPeersInfo, D>(
13622 self.trel_peers_info
13623 .as_ref()
13624 .map(<TrelPeersInfo as fidl::encoding::ValueTypeMarker>::borrow),
13625 encoder,
13626 offset + cur_offset,
13627 depth,
13628 )?;
13629
13630 _prev_end_offset = cur_offset + envelope_size;
13631 if 22 > max_ordinal {
13632 return Ok(());
13633 }
13634
13635 let cur_offset: usize = (22 - 1) * envelope_size;
13638
13639 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13641
13642 fidl::encoding::encode_in_envelope_optional::<UpstreamDnsInfo, D>(
13647 self.upstream_dns_info
13648 .as_ref()
13649 .map(<UpstreamDnsInfo as fidl::encoding::ValueTypeMarker>::borrow),
13650 encoder,
13651 offset + cur_offset,
13652 depth,
13653 )?;
13654
13655 _prev_end_offset = cur_offset + envelope_size;
13656 if 23 > max_ordinal {
13657 return Ok(());
13658 }
13659
13660 let cur_offset: usize = (23 - 1) * envelope_size;
13663
13664 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13666
13667 fidl::encoding::encode_in_envelope_optional::<Dhcp6PdInfo, D>(
13672 self.dhcp6pd_info
13673 .as_ref()
13674 .map(<Dhcp6PdInfo as fidl::encoding::ValueTypeMarker>::borrow),
13675 encoder,
13676 offset + cur_offset,
13677 depth,
13678 )?;
13679
13680 _prev_end_offset = cur_offset + envelope_size;
13681 if 24 > max_ordinal {
13682 return Ok(());
13683 }
13684
13685 let cur_offset: usize = (24 - 1) * envelope_size;
13688
13689 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13691
13692 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<LinkMetricsEntry, 64>, D>(
13697 self.link_metrics_entries.as_ref().map(<fidl::encoding::Vector<LinkMetricsEntry, 64> as fidl::encoding::ValueTypeMarker>::borrow),
13698 encoder, offset + cur_offset, depth
13699 )?;
13700
13701 _prev_end_offset = cur_offset + envelope_size;
13702
13703 Ok(())
13704 }
13705 }
13706
13707 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Telemetry {
13708 #[inline(always)]
13709 fn new_empty() -> Self {
13710 Self::default()
13711 }
13712
13713 unsafe fn decode(
13714 &mut self,
13715 decoder: &mut fidl::encoding::Decoder<'_, D>,
13716 offset: usize,
13717 mut depth: fidl::encoding::Depth,
13718 ) -> fidl::Result<()> {
13719 decoder.debug_check_bounds::<Self>(offset);
13720 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13721 None => return Err(fidl::Error::NotNullable),
13722 Some(len) => len,
13723 };
13724 if len == 0 {
13726 return Ok(());
13727 };
13728 depth.increment()?;
13729 let envelope_size = 8;
13730 let bytes_len = len * envelope_size;
13731 let offset = decoder.out_of_line_offset(bytes_len)?;
13732 let mut _next_ordinal_to_read = 0;
13734 let mut next_offset = offset;
13735 let end_offset = offset + bytes_len;
13736 _next_ordinal_to_read += 1;
13737 if next_offset >= end_offset {
13738 return Ok(());
13739 }
13740
13741 while _next_ordinal_to_read < 1 {
13743 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13744 _next_ordinal_to_read += 1;
13745 next_offset += envelope_size;
13746 }
13747
13748 let next_out_of_line = decoder.next_out_of_line();
13749 let handles_before = decoder.remaining_handles();
13750 if let Some((inlined, num_bytes, num_handles)) =
13751 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13752 {
13753 let member_inline_size =
13754 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13755 if inlined != (member_inline_size <= 4) {
13756 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13757 }
13758 let inner_offset;
13759 let mut inner_depth = depth.clone();
13760 if inlined {
13761 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13762 inner_offset = next_offset;
13763 } else {
13764 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13765 inner_depth.increment()?;
13766 }
13767 let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
13768 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
13769 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13770 {
13771 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13772 }
13773 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13774 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13775 }
13776 }
13777
13778 next_offset += envelope_size;
13779 _next_ordinal_to_read += 1;
13780 if next_offset >= end_offset {
13781 return Ok(());
13782 }
13783
13784 while _next_ordinal_to_read < 2 {
13786 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13787 _next_ordinal_to_read += 1;
13788 next_offset += envelope_size;
13789 }
13790
13791 let next_out_of_line = decoder.next_out_of_line();
13792 let handles_before = decoder.remaining_handles();
13793 if let Some((inlined, num_bytes, num_handles)) =
13794 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13795 {
13796 let member_inline_size =
13797 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13798 if inlined != (member_inline_size <= 4) {
13799 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13800 }
13801 let inner_offset;
13802 let mut inner_depth = depth.clone();
13803 if inlined {
13804 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13805 inner_offset = next_offset;
13806 } else {
13807 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13808 inner_depth.increment()?;
13809 }
13810 let val_ref = self.tx_power.get_or_insert_with(|| fidl::new_empty!(i8, D));
13811 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
13812 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13813 {
13814 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13815 }
13816 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13817 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13818 }
13819 }
13820
13821 next_offset += envelope_size;
13822 _next_ordinal_to_read += 1;
13823 if next_offset >= end_offset {
13824 return Ok(());
13825 }
13826
13827 while _next_ordinal_to_read < 3 {
13829 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13830 _next_ordinal_to_read += 1;
13831 next_offset += envelope_size;
13832 }
13833
13834 let next_out_of_line = decoder.next_out_of_line();
13835 let handles_before = decoder.remaining_handles();
13836 if let Some((inlined, num_bytes, num_handles)) =
13837 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13838 {
13839 let member_inline_size =
13840 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13841 if inlined != (member_inline_size <= 4) {
13842 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13843 }
13844 let inner_offset;
13845 let mut inner_depth = depth.clone();
13846 if inlined {
13847 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13848 inner_offset = next_offset;
13849 } else {
13850 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13851 inner_depth.increment()?;
13852 }
13853 let val_ref = self.channel_index.get_or_insert_with(|| fidl::new_empty!(u16, D));
13854 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
13855 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13856 {
13857 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13858 }
13859 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13860 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13861 }
13862 }
13863
13864 next_offset += envelope_size;
13865 _next_ordinal_to_read += 1;
13866 if next_offset >= end_offset {
13867 return Ok(());
13868 }
13869
13870 while _next_ordinal_to_read < 4 {
13872 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13873 _next_ordinal_to_read += 1;
13874 next_offset += envelope_size;
13875 }
13876
13877 let next_out_of_line = decoder.next_out_of_line();
13878 let handles_before = decoder.remaining_handles();
13879 if let Some((inlined, num_bytes, num_handles)) =
13880 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13881 {
13882 let member_inline_size =
13883 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13884 if inlined != (member_inline_size <= 4) {
13885 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13886 }
13887 let inner_offset;
13888 let mut inner_depth = depth.clone();
13889 if inlined {
13890 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13891 inner_offset = next_offset;
13892 } else {
13893 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13894 inner_depth.increment()?;
13895 }
13896 let val_ref = self.partition_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
13897 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13898 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13899 {
13900 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13901 }
13902 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13903 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13904 }
13905 }
13906
13907 next_offset += envelope_size;
13908 _next_ordinal_to_read += 1;
13909 if next_offset >= end_offset {
13910 return Ok(());
13911 }
13912
13913 while _next_ordinal_to_read < 5 {
13915 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13916 _next_ordinal_to_read += 1;
13917 next_offset += envelope_size;
13918 }
13919
13920 let next_out_of_line = decoder.next_out_of_line();
13921 let handles_before = decoder.remaining_handles();
13922 if let Some((inlined, num_bytes, num_handles)) =
13923 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13924 {
13925 let member_inline_size =
13926 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
13927 decoder.context,
13928 );
13929 if inlined != (member_inline_size <= 4) {
13930 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13931 }
13932 let inner_offset;
13933 let mut inner_depth = depth.clone();
13934 if inlined {
13935 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13936 inner_offset = next_offset;
13937 } else {
13938 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13939 inner_depth.increment()?;
13940 }
13941 let val_ref = self
13942 .stack_version
13943 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
13944 fidl::decode!(
13945 fidl::encoding::BoundedString<256>,
13946 D,
13947 val_ref,
13948 decoder,
13949 inner_offset,
13950 inner_depth
13951 )?;
13952 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13953 {
13954 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13955 }
13956 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13957 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13958 }
13959 }
13960
13961 next_offset += envelope_size;
13962 _next_ordinal_to_read += 1;
13963 if next_offset >= end_offset {
13964 return Ok(());
13965 }
13966
13967 while _next_ordinal_to_read < 6 {
13969 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13970 _next_ordinal_to_read += 1;
13971 next_offset += envelope_size;
13972 }
13973
13974 let next_out_of_line = decoder.next_out_of_line();
13975 let handles_before = decoder.remaining_handles();
13976 if let Some((inlined, num_bytes, num_handles)) =
13977 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13978 {
13979 let member_inline_size =
13980 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
13981 decoder.context,
13982 );
13983 if inlined != (member_inline_size <= 4) {
13984 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13985 }
13986 let inner_offset;
13987 let mut inner_depth = depth.clone();
13988 if inlined {
13989 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13990 inner_offset = next_offset;
13991 } else {
13992 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13993 inner_depth.increment()?;
13994 }
13995 let val_ref = self
13996 .rcp_version
13997 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
13998 fidl::decode!(
13999 fidl::encoding::BoundedString<256>,
14000 D,
14001 val_ref,
14002 decoder,
14003 inner_offset,
14004 inner_depth
14005 )?;
14006 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14007 {
14008 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14009 }
14010 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14011 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14012 }
14013 }
14014
14015 next_offset += envelope_size;
14016 _next_ordinal_to_read += 1;
14017 if next_offset >= end_offset {
14018 return Ok(());
14019 }
14020
14021 while _next_ordinal_to_read < 7 {
14023 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14024 _next_ordinal_to_read += 1;
14025 next_offset += envelope_size;
14026 }
14027
14028 let next_out_of_line = decoder.next_out_of_line();
14029 let handles_before = decoder.remaining_handles();
14030 if let Some((inlined, num_bytes, num_handles)) =
14031 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14032 {
14033 let member_inline_size =
14034 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14035 if inlined != (member_inline_size <= 4) {
14036 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14037 }
14038 let inner_offset;
14039 let mut inner_depth = depth.clone();
14040 if inlined {
14041 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14042 inner_offset = next_offset;
14043 } else {
14044 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14045 inner_depth.increment()?;
14046 }
14047 let val_ref = self.thread_link_mode.get_or_insert_with(|| fidl::new_empty!(u8, D));
14048 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14049 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14050 {
14051 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14052 }
14053 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14054 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14055 }
14056 }
14057
14058 next_offset += envelope_size;
14059 _next_ordinal_to_read += 1;
14060 if next_offset >= end_offset {
14061 return Ok(());
14062 }
14063
14064 while _next_ordinal_to_read < 8 {
14066 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14067 _next_ordinal_to_read += 1;
14068 next_offset += envelope_size;
14069 }
14070
14071 let next_out_of_line = decoder.next_out_of_line();
14072 let handles_before = decoder.remaining_handles();
14073 if let Some((inlined, num_bytes, num_handles)) =
14074 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14075 {
14076 let member_inline_size =
14077 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14078 if inlined != (member_inline_size <= 4) {
14079 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14080 }
14081 let inner_offset;
14082 let mut inner_depth = depth.clone();
14083 if inlined {
14084 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14085 inner_offset = next_offset;
14086 } else {
14087 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14088 inner_depth.increment()?;
14089 }
14090 let val_ref = self.thread_router_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
14091 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14092 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14093 {
14094 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14095 }
14096 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14097 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14098 }
14099 }
14100
14101 next_offset += envelope_size;
14102 _next_ordinal_to_read += 1;
14103 if next_offset >= end_offset {
14104 return Ok(());
14105 }
14106
14107 while _next_ordinal_to_read < 9 {
14109 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14110 _next_ordinal_to_read += 1;
14111 next_offset += envelope_size;
14112 }
14113
14114 let next_out_of_line = decoder.next_out_of_line();
14115 let handles_before = decoder.remaining_handles();
14116 if let Some((inlined, num_bytes, num_handles)) =
14117 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14118 {
14119 let member_inline_size =
14120 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14121 if inlined != (member_inline_size <= 4) {
14122 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14123 }
14124 let inner_offset;
14125 let mut inner_depth = depth.clone();
14126 if inlined {
14127 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14128 inner_offset = next_offset;
14129 } else {
14130 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14131 inner_depth.increment()?;
14132 }
14133 let val_ref = self.thread_rloc.get_or_insert_with(|| fidl::new_empty!(u16, D));
14134 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
14135 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14136 {
14137 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14138 }
14139 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14140 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14141 }
14142 }
14143
14144 next_offset += envelope_size;
14145 _next_ordinal_to_read += 1;
14146 if next_offset >= end_offset {
14147 return Ok(());
14148 }
14149
14150 while _next_ordinal_to_read < 10 {
14152 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14153 _next_ordinal_to_read += 1;
14154 next_offset += envelope_size;
14155 }
14156
14157 let next_out_of_line = decoder.next_out_of_line();
14158 let handles_before = decoder.remaining_handles();
14159 if let Some((inlined, num_bytes, num_handles)) =
14160 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14161 {
14162 let member_inline_size =
14163 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14164 if inlined != (member_inline_size <= 4) {
14165 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14166 }
14167 let inner_offset;
14168 let mut inner_depth = depth.clone();
14169 if inlined {
14170 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14171 inner_offset = next_offset;
14172 } else {
14173 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14174 inner_depth.increment()?;
14175 }
14176 let val_ref =
14177 self.thread_network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
14178 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14179 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14180 {
14181 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14182 }
14183 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14184 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14185 }
14186 }
14187
14188 next_offset += envelope_size;
14189 _next_ordinal_to_read += 1;
14190 if next_offset >= end_offset {
14191 return Ok(());
14192 }
14193
14194 while _next_ordinal_to_read < 11 {
14196 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14197 _next_ordinal_to_read += 1;
14198 next_offset += envelope_size;
14199 }
14200
14201 let next_out_of_line = decoder.next_out_of_line();
14202 let handles_before = decoder.remaining_handles();
14203 if let Some((inlined, num_bytes, num_handles)) =
14204 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14205 {
14206 let member_inline_size =
14207 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14208 if inlined != (member_inline_size <= 4) {
14209 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14210 }
14211 let inner_offset;
14212 let mut inner_depth = depth.clone();
14213 if inlined {
14214 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14215 inner_offset = next_offset;
14216 } else {
14217 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14218 inner_depth.increment()?;
14219 }
14220 let val_ref = self
14221 .thread_stable_network_data_version
14222 .get_or_insert_with(|| fidl::new_empty!(u8, D));
14223 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14224 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14225 {
14226 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14227 }
14228 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14229 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14230 }
14231 }
14232
14233 next_offset += envelope_size;
14234 _next_ordinal_to_read += 1;
14235 if next_offset >= end_offset {
14236 return Ok(());
14237 }
14238
14239 while _next_ordinal_to_read < 12 {
14241 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14242 _next_ordinal_to_read += 1;
14243 next_offset += envelope_size;
14244 }
14245
14246 let next_out_of_line = decoder.next_out_of_line();
14247 let handles_before = decoder.remaining_handles();
14248 if let Some((inlined, num_bytes, num_handles)) =
14249 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14250 {
14251 let member_inline_size =
14252 <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(
14253 decoder.context,
14254 );
14255 if inlined != (member_inline_size <= 4) {
14256 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14257 }
14258 let inner_offset;
14259 let mut inner_depth = depth.clone();
14260 if inlined {
14261 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14262 inner_offset = next_offset;
14263 } else {
14264 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14265 inner_depth.increment()?;
14266 }
14267 let val_ref = self
14268 .thread_network_data
14269 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D));
14270 fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
14271 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14272 {
14273 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14274 }
14275 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14276 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14277 }
14278 }
14279
14280 next_offset += envelope_size;
14281 _next_ordinal_to_read += 1;
14282 if next_offset >= end_offset {
14283 return Ok(());
14284 }
14285
14286 while _next_ordinal_to_read < 13 {
14288 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14289 _next_ordinal_to_read += 1;
14290 next_offset += envelope_size;
14291 }
14292
14293 let next_out_of_line = decoder.next_out_of_line();
14294 let handles_before = decoder.remaining_handles();
14295 if let Some((inlined, num_bytes, num_handles)) =
14296 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14297 {
14298 let member_inline_size =
14299 <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(
14300 decoder.context,
14301 );
14302 if inlined != (member_inline_size <= 4) {
14303 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14304 }
14305 let inner_offset;
14306 let mut inner_depth = depth.clone();
14307 if inlined {
14308 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14309 inner_offset = next_offset;
14310 } else {
14311 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14312 inner_depth.increment()?;
14313 }
14314 let val_ref = self
14315 .thread_stable_network_data
14316 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D));
14317 fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
14318 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14319 {
14320 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14321 }
14322 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14323 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14324 }
14325 }
14326
14327 next_offset += envelope_size;
14328 _next_ordinal_to_read += 1;
14329 if next_offset >= end_offset {
14330 return Ok(());
14331 }
14332
14333 while _next_ordinal_to_read < 14 {
14335 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14336 _next_ordinal_to_read += 1;
14337 next_offset += envelope_size;
14338 }
14339
14340 let next_out_of_line = decoder.next_out_of_line();
14341 let handles_before = decoder.remaining_handles();
14342 if let Some((inlined, num_bytes, num_handles)) =
14343 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14344 {
14345 let member_inline_size =
14346 <BorderRoutingCounters as fidl::encoding::TypeMarker>::inline_size(
14347 decoder.context,
14348 );
14349 if inlined != (member_inline_size <= 4) {
14350 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14351 }
14352 let inner_offset;
14353 let mut inner_depth = depth.clone();
14354 if inlined {
14355 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14356 inner_offset = next_offset;
14357 } else {
14358 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14359 inner_depth.increment()?;
14360 }
14361 let val_ref = self
14362 .thread_border_routing_counters
14363 .get_or_insert_with(|| fidl::new_empty!(BorderRoutingCounters, D));
14364 fidl::decode!(
14365 BorderRoutingCounters,
14366 D,
14367 val_ref,
14368 decoder,
14369 inner_offset,
14370 inner_depth
14371 )?;
14372 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14373 {
14374 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14375 }
14376 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14377 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14378 }
14379 }
14380
14381 next_offset += envelope_size;
14382 _next_ordinal_to_read += 1;
14383 if next_offset >= end_offset {
14384 return Ok(());
14385 }
14386
14387 while _next_ordinal_to_read < 15 {
14389 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14390 _next_ordinal_to_read += 1;
14391 next_offset += envelope_size;
14392 }
14393
14394 let next_out_of_line = decoder.next_out_of_line();
14395 let handles_before = decoder.remaining_handles();
14396 if let Some((inlined, num_bytes, num_handles)) =
14397 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14398 {
14399 let member_inline_size =
14400 <SrpServerInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14401 if inlined != (member_inline_size <= 4) {
14402 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14403 }
14404 let inner_offset;
14405 let mut inner_depth = depth.clone();
14406 if inlined {
14407 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14408 inner_offset = next_offset;
14409 } else {
14410 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14411 inner_depth.increment()?;
14412 }
14413 let val_ref =
14414 self.srp_server_info.get_or_insert_with(|| fidl::new_empty!(SrpServerInfo, D));
14415 fidl::decode!(SrpServerInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14416 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14417 {
14418 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14419 }
14420 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14421 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14422 }
14423 }
14424
14425 next_offset += envelope_size;
14426 _next_ordinal_to_read += 1;
14427 if next_offset >= end_offset {
14428 return Ok(());
14429 }
14430
14431 while _next_ordinal_to_read < 16 {
14433 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14434 _next_ordinal_to_read += 1;
14435 next_offset += envelope_size;
14436 }
14437
14438 let next_out_of_line = decoder.next_out_of_line();
14439 let handles_before = decoder.remaining_handles();
14440 if let Some((inlined, num_bytes, num_handles)) =
14441 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14442 {
14443 let member_inline_size =
14444 <DnssdCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14445 if inlined != (member_inline_size <= 4) {
14446 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14447 }
14448 let inner_offset;
14449 let mut inner_depth = depth.clone();
14450 if inlined {
14451 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14452 inner_offset = next_offset;
14453 } else {
14454 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14455 inner_depth.increment()?;
14456 }
14457 let val_ref =
14458 self.dnssd_counters.get_or_insert_with(|| fidl::new_empty!(DnssdCounters, D));
14459 fidl::decode!(DnssdCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
14460 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14461 {
14462 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14463 }
14464 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14465 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14466 }
14467 }
14468
14469 next_offset += envelope_size;
14470 _next_ordinal_to_read += 1;
14471 if next_offset >= end_offset {
14472 return Ok(());
14473 }
14474
14475 while _next_ordinal_to_read < 17 {
14477 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14478 _next_ordinal_to_read += 1;
14479 next_offset += envelope_size;
14480 }
14481
14482 let next_out_of_line = decoder.next_out_of_line();
14483 let handles_before = decoder.remaining_handles();
14484 if let Some((inlined, num_bytes, num_handles)) =
14485 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14486 {
14487 let member_inline_size =
14488 <LeaderData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14489 if inlined != (member_inline_size <= 4) {
14490 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14491 }
14492 let inner_offset;
14493 let mut inner_depth = depth.clone();
14494 if inlined {
14495 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14496 inner_offset = next_offset;
14497 } else {
14498 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14499 inner_depth.increment()?;
14500 }
14501 let val_ref =
14502 self.leader_data.get_or_insert_with(|| fidl::new_empty!(LeaderData, D));
14503 fidl::decode!(LeaderData, D, val_ref, decoder, inner_offset, inner_depth)?;
14504 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14505 {
14506 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14507 }
14508 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14509 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14510 }
14511 }
14512
14513 next_offset += envelope_size;
14514 _next_ordinal_to_read += 1;
14515 if next_offset >= end_offset {
14516 return Ok(());
14517 }
14518
14519 while _next_ordinal_to_read < 18 {
14521 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14522 _next_ordinal_to_read += 1;
14523 next_offset += envelope_size;
14524 }
14525
14526 let next_out_of_line = decoder.next_out_of_line();
14527 let handles_before = decoder.remaining_handles();
14528 if let Some((inlined, num_bytes, num_handles)) =
14529 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14530 {
14531 let member_inline_size =
14532 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14533 if inlined != (member_inline_size <= 4) {
14534 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14535 }
14536 let inner_offset;
14537 let mut inner_depth = depth.clone();
14538 if inlined {
14539 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14540 inner_offset = next_offset;
14541 } else {
14542 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14543 inner_depth.increment()?;
14544 }
14545 let val_ref = self.uptime.get_or_insert_with(|| fidl::new_empty!(i64, D));
14546 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
14547 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14548 {
14549 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14550 }
14551 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14552 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14553 }
14554 }
14555
14556 next_offset += envelope_size;
14557 _next_ordinal_to_read += 1;
14558 if next_offset >= end_offset {
14559 return Ok(());
14560 }
14561
14562 while _next_ordinal_to_read < 19 {
14564 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14565 _next_ordinal_to_read += 1;
14566 next_offset += envelope_size;
14567 }
14568
14569 let next_out_of_line = decoder.next_out_of_line();
14570 let handles_before = decoder.remaining_handles();
14571 if let Some((inlined, num_bytes, num_handles)) =
14572 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14573 {
14574 let member_inline_size =
14575 <Nat64Info as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14576 if inlined != (member_inline_size <= 4) {
14577 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14578 }
14579 let inner_offset;
14580 let mut inner_depth = depth.clone();
14581 if inlined {
14582 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14583 inner_offset = next_offset;
14584 } else {
14585 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14586 inner_depth.increment()?;
14587 }
14588 let val_ref = self.nat64_info.get_or_insert_with(|| fidl::new_empty!(Nat64Info, D));
14589 fidl::decode!(Nat64Info, D, val_ref, decoder, inner_offset, inner_depth)?;
14590 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14591 {
14592 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14593 }
14594 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14595 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14596 }
14597 }
14598
14599 next_offset += envelope_size;
14600 _next_ordinal_to_read += 1;
14601 if next_offset >= end_offset {
14602 return Ok(());
14603 }
14604
14605 while _next_ordinal_to_read < 20 {
14607 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14608 _next_ordinal_to_read += 1;
14609 next_offset += envelope_size;
14610 }
14611
14612 let next_out_of_line = decoder.next_out_of_line();
14613 let handles_before = decoder.remaining_handles();
14614 if let Some((inlined, num_bytes, num_handles)) =
14615 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14616 {
14617 let member_inline_size =
14618 <TrelCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14619 if inlined != (member_inline_size <= 4) {
14620 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14621 }
14622 let inner_offset;
14623 let mut inner_depth = depth.clone();
14624 if inlined {
14625 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14626 inner_offset = next_offset;
14627 } else {
14628 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14629 inner_depth.increment()?;
14630 }
14631 let val_ref =
14632 self.trel_counters.get_or_insert_with(|| fidl::new_empty!(TrelCounters, D));
14633 fidl::decode!(TrelCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
14634 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14635 {
14636 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14637 }
14638 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14639 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14640 }
14641 }
14642
14643 next_offset += envelope_size;
14644 _next_ordinal_to_read += 1;
14645 if next_offset >= end_offset {
14646 return Ok(());
14647 }
14648
14649 while _next_ordinal_to_read < 21 {
14651 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14652 _next_ordinal_to_read += 1;
14653 next_offset += envelope_size;
14654 }
14655
14656 let next_out_of_line = decoder.next_out_of_line();
14657 let handles_before = decoder.remaining_handles();
14658 if let Some((inlined, num_bytes, num_handles)) =
14659 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14660 {
14661 let member_inline_size =
14662 <TrelPeersInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14663 if inlined != (member_inline_size <= 4) {
14664 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14665 }
14666 let inner_offset;
14667 let mut inner_depth = depth.clone();
14668 if inlined {
14669 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14670 inner_offset = next_offset;
14671 } else {
14672 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14673 inner_depth.increment()?;
14674 }
14675 let val_ref =
14676 self.trel_peers_info.get_or_insert_with(|| fidl::new_empty!(TrelPeersInfo, D));
14677 fidl::decode!(TrelPeersInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14678 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14679 {
14680 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14681 }
14682 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14683 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14684 }
14685 }
14686
14687 next_offset += envelope_size;
14688 _next_ordinal_to_read += 1;
14689 if next_offset >= end_offset {
14690 return Ok(());
14691 }
14692
14693 while _next_ordinal_to_read < 22 {
14695 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14696 _next_ordinal_to_read += 1;
14697 next_offset += envelope_size;
14698 }
14699
14700 let next_out_of_line = decoder.next_out_of_line();
14701 let handles_before = decoder.remaining_handles();
14702 if let Some((inlined, num_bytes, num_handles)) =
14703 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14704 {
14705 let member_inline_size =
14706 <UpstreamDnsInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14707 if inlined != (member_inline_size <= 4) {
14708 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14709 }
14710 let inner_offset;
14711 let mut inner_depth = depth.clone();
14712 if inlined {
14713 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14714 inner_offset = next_offset;
14715 } else {
14716 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14717 inner_depth.increment()?;
14718 }
14719 let val_ref = self
14720 .upstream_dns_info
14721 .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsInfo, D));
14722 fidl::decode!(UpstreamDnsInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14723 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14724 {
14725 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14726 }
14727 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14728 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14729 }
14730 }
14731
14732 next_offset += envelope_size;
14733 _next_ordinal_to_read += 1;
14734 if next_offset >= end_offset {
14735 return Ok(());
14736 }
14737
14738 while _next_ordinal_to_read < 23 {
14740 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14741 _next_ordinal_to_read += 1;
14742 next_offset += envelope_size;
14743 }
14744
14745 let next_out_of_line = decoder.next_out_of_line();
14746 let handles_before = decoder.remaining_handles();
14747 if let Some((inlined, num_bytes, num_handles)) =
14748 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14749 {
14750 let member_inline_size =
14751 <Dhcp6PdInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14752 if inlined != (member_inline_size <= 4) {
14753 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14754 }
14755 let inner_offset;
14756 let mut inner_depth = depth.clone();
14757 if inlined {
14758 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14759 inner_offset = next_offset;
14760 } else {
14761 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14762 inner_depth.increment()?;
14763 }
14764 let val_ref =
14765 self.dhcp6pd_info.get_or_insert_with(|| fidl::new_empty!(Dhcp6PdInfo, D));
14766 fidl::decode!(Dhcp6PdInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14767 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14768 {
14769 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14770 }
14771 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14772 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14773 }
14774 }
14775
14776 next_offset += envelope_size;
14777 _next_ordinal_to_read += 1;
14778 if next_offset >= end_offset {
14779 return Ok(());
14780 }
14781
14782 while _next_ordinal_to_read < 24 {
14784 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14785 _next_ordinal_to_read += 1;
14786 next_offset += envelope_size;
14787 }
14788
14789 let next_out_of_line = decoder.next_out_of_line();
14790 let handles_before = decoder.remaining_handles();
14791 if let Some((inlined, num_bytes, num_handles)) =
14792 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14793 {
14794 let member_inline_size = <fidl::encoding::Vector<LinkMetricsEntry, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14795 if inlined != (member_inline_size <= 4) {
14796 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14797 }
14798 let inner_offset;
14799 let mut inner_depth = depth.clone();
14800 if inlined {
14801 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14802 inner_offset = next_offset;
14803 } else {
14804 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14805 inner_depth.increment()?;
14806 }
14807 let val_ref = self.link_metrics_entries.get_or_insert_with(
14808 || fidl::new_empty!(fidl::encoding::Vector<LinkMetricsEntry, 64>, D),
14809 );
14810 fidl::decode!(fidl::encoding::Vector<LinkMetricsEntry, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
14811 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14812 {
14813 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14814 }
14815 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14816 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14817 }
14818 }
14819
14820 next_offset += envelope_size;
14821
14822 while next_offset < end_offset {
14824 _next_ordinal_to_read += 1;
14825 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14826 next_offset += envelope_size;
14827 }
14828
14829 Ok(())
14830 }
14831 }
14832
14833 impl TrelCounters {
14834 #[inline(always)]
14835 fn max_ordinal_present(&self) -> u64 {
14836 if let Some(_) = self.tx_packets {
14837 return 5;
14838 }
14839 if let Some(_) = self.tx_failure {
14840 return 4;
14841 }
14842 if let Some(_) = self.tx_bytes {
14843 return 3;
14844 }
14845 if let Some(_) = self.rx_packets {
14846 return 2;
14847 }
14848 if let Some(_) = self.rx_bytes {
14849 return 1;
14850 }
14851 0
14852 }
14853 }
14854
14855 impl fidl::encoding::ValueTypeMarker for TrelCounters {
14856 type Borrowed<'a> = &'a Self;
14857 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14858 value
14859 }
14860 }
14861
14862 unsafe impl fidl::encoding::TypeMarker for TrelCounters {
14863 type Owned = Self;
14864
14865 #[inline(always)]
14866 fn inline_align(_context: fidl::encoding::Context) -> usize {
14867 8
14868 }
14869
14870 #[inline(always)]
14871 fn inline_size(_context: fidl::encoding::Context) -> usize {
14872 16
14873 }
14874 }
14875
14876 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TrelCounters, D>
14877 for &TrelCounters
14878 {
14879 unsafe fn encode(
14880 self,
14881 encoder: &mut fidl::encoding::Encoder<'_, D>,
14882 offset: usize,
14883 mut depth: fidl::encoding::Depth,
14884 ) -> fidl::Result<()> {
14885 encoder.debug_check_bounds::<TrelCounters>(offset);
14886 let max_ordinal: u64 = self.max_ordinal_present();
14888 encoder.write_num(max_ordinal, offset);
14889 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14890 if max_ordinal == 0 {
14892 return Ok(());
14893 }
14894 depth.increment()?;
14895 let envelope_size = 8;
14896 let bytes_len = max_ordinal as usize * envelope_size;
14897 #[allow(unused_variables)]
14898 let offset = encoder.out_of_line_offset(bytes_len);
14899 let mut _prev_end_offset: usize = 0;
14900 if 1 > max_ordinal {
14901 return Ok(());
14902 }
14903
14904 let cur_offset: usize = (1 - 1) * envelope_size;
14907
14908 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14910
14911 fidl::encoding::encode_in_envelope_optional::<u64, D>(
14916 self.rx_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14917 encoder,
14918 offset + cur_offset,
14919 depth,
14920 )?;
14921
14922 _prev_end_offset = cur_offset + envelope_size;
14923 if 2 > max_ordinal {
14924 return Ok(());
14925 }
14926
14927 let cur_offset: usize = (2 - 1) * envelope_size;
14930
14931 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14933
14934 fidl::encoding::encode_in_envelope_optional::<u64, D>(
14939 self.rx_packets.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14940 encoder,
14941 offset + cur_offset,
14942 depth,
14943 )?;
14944
14945 _prev_end_offset = cur_offset + envelope_size;
14946 if 3 > max_ordinal {
14947 return Ok(());
14948 }
14949
14950 let cur_offset: usize = (3 - 1) * envelope_size;
14953
14954 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14956
14957 fidl::encoding::encode_in_envelope_optional::<u64, D>(
14962 self.tx_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14963 encoder,
14964 offset + cur_offset,
14965 depth,
14966 )?;
14967
14968 _prev_end_offset = cur_offset + envelope_size;
14969 if 4 > max_ordinal {
14970 return Ok(());
14971 }
14972
14973 let cur_offset: usize = (4 - 1) * envelope_size;
14976
14977 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14979
14980 fidl::encoding::encode_in_envelope_optional::<u64, D>(
14985 self.tx_failure.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14986 encoder,
14987 offset + cur_offset,
14988 depth,
14989 )?;
14990
14991 _prev_end_offset = cur_offset + envelope_size;
14992 if 5 > max_ordinal {
14993 return Ok(());
14994 }
14995
14996 let cur_offset: usize = (5 - 1) * envelope_size;
14999
15000 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15002
15003 fidl::encoding::encode_in_envelope_optional::<u64, D>(
15008 self.tx_packets.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
15009 encoder,
15010 offset + cur_offset,
15011 depth,
15012 )?;
15013
15014 _prev_end_offset = cur_offset + envelope_size;
15015
15016 Ok(())
15017 }
15018 }
15019
15020 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TrelCounters {
15021 #[inline(always)]
15022 fn new_empty() -> Self {
15023 Self::default()
15024 }
15025
15026 unsafe fn decode(
15027 &mut self,
15028 decoder: &mut fidl::encoding::Decoder<'_, D>,
15029 offset: usize,
15030 mut depth: fidl::encoding::Depth,
15031 ) -> fidl::Result<()> {
15032 decoder.debug_check_bounds::<Self>(offset);
15033 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15034 None => return Err(fidl::Error::NotNullable),
15035 Some(len) => len,
15036 };
15037 if len == 0 {
15039 return Ok(());
15040 };
15041 depth.increment()?;
15042 let envelope_size = 8;
15043 let bytes_len = len * envelope_size;
15044 let offset = decoder.out_of_line_offset(bytes_len)?;
15045 let mut _next_ordinal_to_read = 0;
15047 let mut next_offset = offset;
15048 let end_offset = offset + bytes_len;
15049 _next_ordinal_to_read += 1;
15050 if next_offset >= end_offset {
15051 return Ok(());
15052 }
15053
15054 while _next_ordinal_to_read < 1 {
15056 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15057 _next_ordinal_to_read += 1;
15058 next_offset += envelope_size;
15059 }
15060
15061 let next_out_of_line = decoder.next_out_of_line();
15062 let handles_before = decoder.remaining_handles();
15063 if let Some((inlined, num_bytes, num_handles)) =
15064 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15065 {
15066 let member_inline_size =
15067 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15068 if inlined != (member_inline_size <= 4) {
15069 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15070 }
15071 let inner_offset;
15072 let mut inner_depth = depth.clone();
15073 if inlined {
15074 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15075 inner_offset = next_offset;
15076 } else {
15077 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15078 inner_depth.increment()?;
15079 }
15080 let val_ref = self.rx_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
15081 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15082 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15083 {
15084 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15085 }
15086 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15087 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15088 }
15089 }
15090
15091 next_offset += envelope_size;
15092 _next_ordinal_to_read += 1;
15093 if next_offset >= end_offset {
15094 return Ok(());
15095 }
15096
15097 while _next_ordinal_to_read < 2 {
15099 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15100 _next_ordinal_to_read += 1;
15101 next_offset += envelope_size;
15102 }
15103
15104 let next_out_of_line = decoder.next_out_of_line();
15105 let handles_before = decoder.remaining_handles();
15106 if let Some((inlined, num_bytes, num_handles)) =
15107 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15108 {
15109 let member_inline_size =
15110 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15111 if inlined != (member_inline_size <= 4) {
15112 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15113 }
15114 let inner_offset;
15115 let mut inner_depth = depth.clone();
15116 if inlined {
15117 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15118 inner_offset = next_offset;
15119 } else {
15120 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15121 inner_depth.increment()?;
15122 }
15123 let val_ref = self.rx_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
15124 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15125 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15126 {
15127 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15128 }
15129 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15130 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15131 }
15132 }
15133
15134 next_offset += envelope_size;
15135 _next_ordinal_to_read += 1;
15136 if next_offset >= end_offset {
15137 return Ok(());
15138 }
15139
15140 while _next_ordinal_to_read < 3 {
15142 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15143 _next_ordinal_to_read += 1;
15144 next_offset += envelope_size;
15145 }
15146
15147 let next_out_of_line = decoder.next_out_of_line();
15148 let handles_before = decoder.remaining_handles();
15149 if let Some((inlined, num_bytes, num_handles)) =
15150 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15151 {
15152 let member_inline_size =
15153 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15154 if inlined != (member_inline_size <= 4) {
15155 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15156 }
15157 let inner_offset;
15158 let mut inner_depth = depth.clone();
15159 if inlined {
15160 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15161 inner_offset = next_offset;
15162 } else {
15163 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15164 inner_depth.increment()?;
15165 }
15166 let val_ref = self.tx_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
15167 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15168 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15169 {
15170 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15171 }
15172 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15173 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15174 }
15175 }
15176
15177 next_offset += envelope_size;
15178 _next_ordinal_to_read += 1;
15179 if next_offset >= end_offset {
15180 return Ok(());
15181 }
15182
15183 while _next_ordinal_to_read < 4 {
15185 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15186 _next_ordinal_to_read += 1;
15187 next_offset += envelope_size;
15188 }
15189
15190 let next_out_of_line = decoder.next_out_of_line();
15191 let handles_before = decoder.remaining_handles();
15192 if let Some((inlined, num_bytes, num_handles)) =
15193 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15194 {
15195 let member_inline_size =
15196 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15197 if inlined != (member_inline_size <= 4) {
15198 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15199 }
15200 let inner_offset;
15201 let mut inner_depth = depth.clone();
15202 if inlined {
15203 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15204 inner_offset = next_offset;
15205 } else {
15206 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15207 inner_depth.increment()?;
15208 }
15209 let val_ref = self.tx_failure.get_or_insert_with(|| fidl::new_empty!(u64, D));
15210 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15211 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15212 {
15213 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15214 }
15215 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15216 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15217 }
15218 }
15219
15220 next_offset += envelope_size;
15221 _next_ordinal_to_read += 1;
15222 if next_offset >= end_offset {
15223 return Ok(());
15224 }
15225
15226 while _next_ordinal_to_read < 5 {
15228 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15229 _next_ordinal_to_read += 1;
15230 next_offset += envelope_size;
15231 }
15232
15233 let next_out_of_line = decoder.next_out_of_line();
15234 let handles_before = decoder.remaining_handles();
15235 if let Some((inlined, num_bytes, num_handles)) =
15236 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15237 {
15238 let member_inline_size =
15239 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15240 if inlined != (member_inline_size <= 4) {
15241 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15242 }
15243 let inner_offset;
15244 let mut inner_depth = depth.clone();
15245 if inlined {
15246 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15247 inner_offset = next_offset;
15248 } else {
15249 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15250 inner_depth.increment()?;
15251 }
15252 let val_ref = self.tx_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
15253 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15254 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15255 {
15256 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15257 }
15258 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15259 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15260 }
15261 }
15262
15263 next_offset += envelope_size;
15264
15265 while next_offset < end_offset {
15267 _next_ordinal_to_read += 1;
15268 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15269 next_offset += envelope_size;
15270 }
15271
15272 Ok(())
15273 }
15274 }
15275
15276 impl TrelPeersInfo {
15277 #[inline(always)]
15278 fn max_ordinal_present(&self) -> u64 {
15279 if let Some(_) = self.num_trel_peers {
15280 return 1;
15281 }
15282 0
15283 }
15284 }
15285
15286 impl fidl::encoding::ValueTypeMarker for TrelPeersInfo {
15287 type Borrowed<'a> = &'a Self;
15288 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15289 value
15290 }
15291 }
15292
15293 unsafe impl fidl::encoding::TypeMarker for TrelPeersInfo {
15294 type Owned = Self;
15295
15296 #[inline(always)]
15297 fn inline_align(_context: fidl::encoding::Context) -> usize {
15298 8
15299 }
15300
15301 #[inline(always)]
15302 fn inline_size(_context: fidl::encoding::Context) -> usize {
15303 16
15304 }
15305 }
15306
15307 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TrelPeersInfo, D>
15308 for &TrelPeersInfo
15309 {
15310 unsafe fn encode(
15311 self,
15312 encoder: &mut fidl::encoding::Encoder<'_, D>,
15313 offset: usize,
15314 mut depth: fidl::encoding::Depth,
15315 ) -> fidl::Result<()> {
15316 encoder.debug_check_bounds::<TrelPeersInfo>(offset);
15317 let max_ordinal: u64 = self.max_ordinal_present();
15319 encoder.write_num(max_ordinal, offset);
15320 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15321 if max_ordinal == 0 {
15323 return Ok(());
15324 }
15325 depth.increment()?;
15326 let envelope_size = 8;
15327 let bytes_len = max_ordinal as usize * envelope_size;
15328 #[allow(unused_variables)]
15329 let offset = encoder.out_of_line_offset(bytes_len);
15330 let mut _prev_end_offset: usize = 0;
15331 if 1 > max_ordinal {
15332 return Ok(());
15333 }
15334
15335 let cur_offset: usize = (1 - 1) * envelope_size;
15338
15339 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15341
15342 fidl::encoding::encode_in_envelope_optional::<u16, D>(
15347 self.num_trel_peers.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
15348 encoder,
15349 offset + cur_offset,
15350 depth,
15351 )?;
15352
15353 _prev_end_offset = cur_offset + envelope_size;
15354
15355 Ok(())
15356 }
15357 }
15358
15359 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TrelPeersInfo {
15360 #[inline(always)]
15361 fn new_empty() -> Self {
15362 Self::default()
15363 }
15364
15365 unsafe fn decode(
15366 &mut self,
15367 decoder: &mut fidl::encoding::Decoder<'_, D>,
15368 offset: usize,
15369 mut depth: fidl::encoding::Depth,
15370 ) -> fidl::Result<()> {
15371 decoder.debug_check_bounds::<Self>(offset);
15372 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15373 None => return Err(fidl::Error::NotNullable),
15374 Some(len) => len,
15375 };
15376 if len == 0 {
15378 return Ok(());
15379 };
15380 depth.increment()?;
15381 let envelope_size = 8;
15382 let bytes_len = len * envelope_size;
15383 let offset = decoder.out_of_line_offset(bytes_len)?;
15384 let mut _next_ordinal_to_read = 0;
15386 let mut next_offset = offset;
15387 let end_offset = offset + bytes_len;
15388 _next_ordinal_to_read += 1;
15389 if next_offset >= end_offset {
15390 return Ok(());
15391 }
15392
15393 while _next_ordinal_to_read < 1 {
15395 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15396 _next_ordinal_to_read += 1;
15397 next_offset += envelope_size;
15398 }
15399
15400 let next_out_of_line = decoder.next_out_of_line();
15401 let handles_before = decoder.remaining_handles();
15402 if let Some((inlined, num_bytes, num_handles)) =
15403 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15404 {
15405 let member_inline_size =
15406 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15407 if inlined != (member_inline_size <= 4) {
15408 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15409 }
15410 let inner_offset;
15411 let mut inner_depth = depth.clone();
15412 if inlined {
15413 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15414 inner_offset = next_offset;
15415 } else {
15416 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15417 inner_depth.increment()?;
15418 }
15419 let val_ref = self.num_trel_peers.get_or_insert_with(|| fidl::new_empty!(u16, D));
15420 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
15421 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15422 {
15423 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15424 }
15425 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15426 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15427 }
15428 }
15429
15430 next_offset += envelope_size;
15431
15432 while next_offset < end_offset {
15434 _next_ordinal_to_read += 1;
15435 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15436 next_offset += envelope_size;
15437 }
15438
15439 Ok(())
15440 }
15441 }
15442
15443 impl UpstreamDnsCounters {
15444 #[inline(always)]
15445 fn max_ordinal_present(&self) -> u64 {
15446 if let Some(_) = self.failures {
15447 return 3;
15448 }
15449 if let Some(_) = self.responses {
15450 return 2;
15451 }
15452 if let Some(_) = self.queries {
15453 return 1;
15454 }
15455 0
15456 }
15457 }
15458
15459 impl fidl::encoding::ValueTypeMarker for UpstreamDnsCounters {
15460 type Borrowed<'a> = &'a Self;
15461 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15462 value
15463 }
15464 }
15465
15466 unsafe impl fidl::encoding::TypeMarker for UpstreamDnsCounters {
15467 type Owned = Self;
15468
15469 #[inline(always)]
15470 fn inline_align(_context: fidl::encoding::Context) -> usize {
15471 8
15472 }
15473
15474 #[inline(always)]
15475 fn inline_size(_context: fidl::encoding::Context) -> usize {
15476 16
15477 }
15478 }
15479
15480 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UpstreamDnsCounters, D>
15481 for &UpstreamDnsCounters
15482 {
15483 unsafe fn encode(
15484 self,
15485 encoder: &mut fidl::encoding::Encoder<'_, D>,
15486 offset: usize,
15487 mut depth: fidl::encoding::Depth,
15488 ) -> fidl::Result<()> {
15489 encoder.debug_check_bounds::<UpstreamDnsCounters>(offset);
15490 let max_ordinal: u64 = self.max_ordinal_present();
15492 encoder.write_num(max_ordinal, offset);
15493 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15494 if max_ordinal == 0 {
15496 return Ok(());
15497 }
15498 depth.increment()?;
15499 let envelope_size = 8;
15500 let bytes_len = max_ordinal as usize * envelope_size;
15501 #[allow(unused_variables)]
15502 let offset = encoder.out_of_line_offset(bytes_len);
15503 let mut _prev_end_offset: usize = 0;
15504 if 1 > max_ordinal {
15505 return Ok(());
15506 }
15507
15508 let cur_offset: usize = (1 - 1) * envelope_size;
15511
15512 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15514
15515 fidl::encoding::encode_in_envelope_optional::<u32, D>(
15520 self.queries.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15521 encoder,
15522 offset + cur_offset,
15523 depth,
15524 )?;
15525
15526 _prev_end_offset = cur_offset + envelope_size;
15527 if 2 > max_ordinal {
15528 return Ok(());
15529 }
15530
15531 let cur_offset: usize = (2 - 1) * envelope_size;
15534
15535 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15537
15538 fidl::encoding::encode_in_envelope_optional::<u32, D>(
15543 self.responses.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15544 encoder,
15545 offset + cur_offset,
15546 depth,
15547 )?;
15548
15549 _prev_end_offset = cur_offset + envelope_size;
15550 if 3 > max_ordinal {
15551 return Ok(());
15552 }
15553
15554 let cur_offset: usize = (3 - 1) * envelope_size;
15557
15558 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15560
15561 fidl::encoding::encode_in_envelope_optional::<u32, D>(
15566 self.failures.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15567 encoder,
15568 offset + cur_offset,
15569 depth,
15570 )?;
15571
15572 _prev_end_offset = cur_offset + envelope_size;
15573
15574 Ok(())
15575 }
15576 }
15577
15578 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsCounters {
15579 #[inline(always)]
15580 fn new_empty() -> Self {
15581 Self::default()
15582 }
15583
15584 unsafe fn decode(
15585 &mut self,
15586 decoder: &mut fidl::encoding::Decoder<'_, D>,
15587 offset: usize,
15588 mut depth: fidl::encoding::Depth,
15589 ) -> fidl::Result<()> {
15590 decoder.debug_check_bounds::<Self>(offset);
15591 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15592 None => return Err(fidl::Error::NotNullable),
15593 Some(len) => len,
15594 };
15595 if len == 0 {
15597 return Ok(());
15598 };
15599 depth.increment()?;
15600 let envelope_size = 8;
15601 let bytes_len = len * envelope_size;
15602 let offset = decoder.out_of_line_offset(bytes_len)?;
15603 let mut _next_ordinal_to_read = 0;
15605 let mut next_offset = offset;
15606 let end_offset = offset + bytes_len;
15607 _next_ordinal_to_read += 1;
15608 if next_offset >= end_offset {
15609 return Ok(());
15610 }
15611
15612 while _next_ordinal_to_read < 1 {
15614 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15615 _next_ordinal_to_read += 1;
15616 next_offset += envelope_size;
15617 }
15618
15619 let next_out_of_line = decoder.next_out_of_line();
15620 let handles_before = decoder.remaining_handles();
15621 if let Some((inlined, num_bytes, num_handles)) =
15622 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15623 {
15624 let member_inline_size =
15625 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15626 if inlined != (member_inline_size <= 4) {
15627 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15628 }
15629 let inner_offset;
15630 let mut inner_depth = depth.clone();
15631 if inlined {
15632 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15633 inner_offset = next_offset;
15634 } else {
15635 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15636 inner_depth.increment()?;
15637 }
15638 let val_ref = self.queries.get_or_insert_with(|| fidl::new_empty!(u32, D));
15639 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15640 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15641 {
15642 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15643 }
15644 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15645 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15646 }
15647 }
15648
15649 next_offset += envelope_size;
15650 _next_ordinal_to_read += 1;
15651 if next_offset >= end_offset {
15652 return Ok(());
15653 }
15654
15655 while _next_ordinal_to_read < 2 {
15657 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15658 _next_ordinal_to_read += 1;
15659 next_offset += envelope_size;
15660 }
15661
15662 let next_out_of_line = decoder.next_out_of_line();
15663 let handles_before = decoder.remaining_handles();
15664 if let Some((inlined, num_bytes, num_handles)) =
15665 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15666 {
15667 let member_inline_size =
15668 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15669 if inlined != (member_inline_size <= 4) {
15670 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15671 }
15672 let inner_offset;
15673 let mut inner_depth = depth.clone();
15674 if inlined {
15675 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15676 inner_offset = next_offset;
15677 } else {
15678 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15679 inner_depth.increment()?;
15680 }
15681 let val_ref = self.responses.get_or_insert_with(|| fidl::new_empty!(u32, D));
15682 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15683 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15684 {
15685 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15686 }
15687 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15688 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15689 }
15690 }
15691
15692 next_offset += envelope_size;
15693 _next_ordinal_to_read += 1;
15694 if next_offset >= end_offset {
15695 return Ok(());
15696 }
15697
15698 while _next_ordinal_to_read < 3 {
15700 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15701 _next_ordinal_to_read += 1;
15702 next_offset += envelope_size;
15703 }
15704
15705 let next_out_of_line = decoder.next_out_of_line();
15706 let handles_before = decoder.remaining_handles();
15707 if let Some((inlined, num_bytes, num_handles)) =
15708 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15709 {
15710 let member_inline_size =
15711 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15712 if inlined != (member_inline_size <= 4) {
15713 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15714 }
15715 let inner_offset;
15716 let mut inner_depth = depth.clone();
15717 if inlined {
15718 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15719 inner_offset = next_offset;
15720 } else {
15721 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15722 inner_depth.increment()?;
15723 }
15724 let val_ref = self.failures.get_or_insert_with(|| fidl::new_empty!(u32, D));
15725 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15726 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15727 {
15728 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15729 }
15730 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15731 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15732 }
15733 }
15734
15735 next_offset += envelope_size;
15736
15737 while next_offset < end_offset {
15739 _next_ordinal_to_read += 1;
15740 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15741 next_offset += envelope_size;
15742 }
15743
15744 Ok(())
15745 }
15746 }
15747
15748 impl UpstreamDnsInfo {
15749 #[inline(always)]
15750 fn max_ordinal_present(&self) -> u64 {
15751 if let Some(_) = self.upstream_dns_query_state {
15752 return 1;
15753 }
15754 0
15755 }
15756 }
15757
15758 impl fidl::encoding::ValueTypeMarker for UpstreamDnsInfo {
15759 type Borrowed<'a> = &'a Self;
15760 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15761 value
15762 }
15763 }
15764
15765 unsafe impl fidl::encoding::TypeMarker for UpstreamDnsInfo {
15766 type Owned = Self;
15767
15768 #[inline(always)]
15769 fn inline_align(_context: fidl::encoding::Context) -> usize {
15770 8
15771 }
15772
15773 #[inline(always)]
15774 fn inline_size(_context: fidl::encoding::Context) -> usize {
15775 16
15776 }
15777 }
15778
15779 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UpstreamDnsInfo, D>
15780 for &UpstreamDnsInfo
15781 {
15782 unsafe fn encode(
15783 self,
15784 encoder: &mut fidl::encoding::Encoder<'_, D>,
15785 offset: usize,
15786 mut depth: fidl::encoding::Depth,
15787 ) -> fidl::Result<()> {
15788 encoder.debug_check_bounds::<UpstreamDnsInfo>(offset);
15789 let max_ordinal: u64 = self.max_ordinal_present();
15791 encoder.write_num(max_ordinal, offset);
15792 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15793 if max_ordinal == 0 {
15795 return Ok(());
15796 }
15797 depth.increment()?;
15798 let envelope_size = 8;
15799 let bytes_len = max_ordinal as usize * envelope_size;
15800 #[allow(unused_variables)]
15801 let offset = encoder.out_of_line_offset(bytes_len);
15802 let mut _prev_end_offset: usize = 0;
15803 if 1 > max_ordinal {
15804 return Ok(());
15805 }
15806
15807 let cur_offset: usize = (1 - 1) * envelope_size;
15810
15811 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15813
15814 fidl::encoding::encode_in_envelope_optional::<UpstreamDnsQueryState, D>(
15819 self.upstream_dns_query_state
15820 .as_ref()
15821 .map(<UpstreamDnsQueryState as fidl::encoding::ValueTypeMarker>::borrow),
15822 encoder,
15823 offset + cur_offset,
15824 depth,
15825 )?;
15826
15827 _prev_end_offset = cur_offset + envelope_size;
15828
15829 Ok(())
15830 }
15831 }
15832
15833 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsInfo {
15834 #[inline(always)]
15835 fn new_empty() -> Self {
15836 Self::default()
15837 }
15838
15839 unsafe fn decode(
15840 &mut self,
15841 decoder: &mut fidl::encoding::Decoder<'_, D>,
15842 offset: usize,
15843 mut depth: fidl::encoding::Depth,
15844 ) -> fidl::Result<()> {
15845 decoder.debug_check_bounds::<Self>(offset);
15846 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15847 None => return Err(fidl::Error::NotNullable),
15848 Some(len) => len,
15849 };
15850 if len == 0 {
15852 return Ok(());
15853 };
15854 depth.increment()?;
15855 let envelope_size = 8;
15856 let bytes_len = len * envelope_size;
15857 let offset = decoder.out_of_line_offset(bytes_len)?;
15858 let mut _next_ordinal_to_read = 0;
15860 let mut next_offset = offset;
15861 let end_offset = offset + bytes_len;
15862 _next_ordinal_to_read += 1;
15863 if next_offset >= end_offset {
15864 return Ok(());
15865 }
15866
15867 while _next_ordinal_to_read < 1 {
15869 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15870 _next_ordinal_to_read += 1;
15871 next_offset += envelope_size;
15872 }
15873
15874 let next_out_of_line = decoder.next_out_of_line();
15875 let handles_before = decoder.remaining_handles();
15876 if let Some((inlined, num_bytes, num_handles)) =
15877 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15878 {
15879 let member_inline_size =
15880 <UpstreamDnsQueryState as fidl::encoding::TypeMarker>::inline_size(
15881 decoder.context,
15882 );
15883 if inlined != (member_inline_size <= 4) {
15884 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15885 }
15886 let inner_offset;
15887 let mut inner_depth = depth.clone();
15888 if inlined {
15889 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15890 inner_offset = next_offset;
15891 } else {
15892 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15893 inner_depth.increment()?;
15894 }
15895 let val_ref = self
15896 .upstream_dns_query_state
15897 .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsQueryState, D));
15898 fidl::decode!(
15899 UpstreamDnsQueryState,
15900 D,
15901 val_ref,
15902 decoder,
15903 inner_offset,
15904 inner_depth
15905 )?;
15906 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15907 {
15908 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15909 }
15910 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15911 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15912 }
15913 }
15914
15915 next_offset += envelope_size;
15916
15917 while next_offset < end_offset {
15919 _next_ordinal_to_read += 1;
15920 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15921 next_offset += envelope_size;
15922 }
15923
15924 Ok(())
15925 }
15926 }
15927
15928 impl fidl::encoding::ValueTypeMarker for JoinParams {
15929 type Borrowed<'a> = &'a Self;
15930 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15931 value
15932 }
15933 }
15934
15935 unsafe impl fidl::encoding::TypeMarker for JoinParams {
15936 type Owned = Self;
15937
15938 #[inline(always)]
15939 fn inline_align(_context: fidl::encoding::Context) -> usize {
15940 8
15941 }
15942
15943 #[inline(always)]
15944 fn inline_size(_context: fidl::encoding::Context) -> usize {
15945 16
15946 }
15947 }
15948
15949 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<JoinParams, D>
15950 for &JoinParams
15951 {
15952 #[inline]
15953 unsafe fn encode(
15954 self,
15955 encoder: &mut fidl::encoding::Encoder<'_, D>,
15956 offset: usize,
15957 _depth: fidl::encoding::Depth,
15958 ) -> fidl::Result<()> {
15959 encoder.debug_check_bounds::<JoinParams>(offset);
15960 encoder.write_num::<u64>(self.ordinal(), offset);
15961 match self {
15962 JoinParams::ProvisioningParameter(ref val) => {
15963 fidl::encoding::encode_in_envelope::<fidl_fuchsia_lowpan_device__common::ProvisioningParams, D>(
15964 <fidl_fuchsia_lowpan_device__common::ProvisioningParams as fidl::encoding::ValueTypeMarker>::borrow(val),
15965 encoder, offset + 8, _depth
15966 )
15967 }
15968 JoinParams::JoinerParameter(ref val) => {
15969 fidl::encoding::encode_in_envelope::<JoinerCommissioningParams, D>(
15970 <JoinerCommissioningParams as fidl::encoding::ValueTypeMarker>::borrow(val),
15971 encoder, offset + 8, _depth
15972 )
15973 }
15974 JoinParams::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
15975 }
15976 }
15977 }
15978
15979 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for JoinParams {
15980 #[inline(always)]
15981 fn new_empty() -> Self {
15982 Self::__SourceBreaking { unknown_ordinal: 0 }
15983 }
15984
15985 #[inline]
15986 unsafe fn decode(
15987 &mut self,
15988 decoder: &mut fidl::encoding::Decoder<'_, D>,
15989 offset: usize,
15990 mut depth: fidl::encoding::Depth,
15991 ) -> fidl::Result<()> {
15992 decoder.debug_check_bounds::<Self>(offset);
15993 #[allow(unused_variables)]
15994 let next_out_of_line = decoder.next_out_of_line();
15995 let handles_before = decoder.remaining_handles();
15996 let (ordinal, inlined, num_bytes, num_handles) =
15997 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
15998
15999 let member_inline_size = match ordinal {
16000 1 => <fidl_fuchsia_lowpan_device__common::ProvisioningParams as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16001 2 => <JoinerCommissioningParams as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16002 0 => return Err(fidl::Error::UnknownUnionTag),
16003 _ => num_bytes as usize,
16004 };
16005
16006 if inlined != (member_inline_size <= 4) {
16007 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16008 }
16009 let _inner_offset;
16010 if inlined {
16011 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16012 _inner_offset = offset + 8;
16013 } else {
16014 depth.increment()?;
16015 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16016 }
16017 match ordinal {
16018 1 => {
16019 #[allow(irrefutable_let_patterns)]
16020 if let JoinParams::ProvisioningParameter(_) = self {
16021 } else {
16023 *self = JoinParams::ProvisioningParameter(fidl::new_empty!(
16025 fidl_fuchsia_lowpan_device__common::ProvisioningParams,
16026 D
16027 ));
16028 }
16029 #[allow(irrefutable_let_patterns)]
16030 if let JoinParams::ProvisioningParameter(ref mut val) = self {
16031 fidl::decode!(
16032 fidl_fuchsia_lowpan_device__common::ProvisioningParams,
16033 D,
16034 val,
16035 decoder,
16036 _inner_offset,
16037 depth
16038 )?;
16039 } else {
16040 unreachable!()
16041 }
16042 }
16043 2 => {
16044 #[allow(irrefutable_let_patterns)]
16045 if let JoinParams::JoinerParameter(_) = self {
16046 } else {
16048 *self = JoinParams::JoinerParameter(fidl::new_empty!(
16050 JoinerCommissioningParams,
16051 D
16052 ));
16053 }
16054 #[allow(irrefutable_let_patterns)]
16055 if let JoinParams::JoinerParameter(ref mut val) = self {
16056 fidl::decode!(
16057 JoinerCommissioningParams,
16058 D,
16059 val,
16060 decoder,
16061 _inner_offset,
16062 depth
16063 )?;
16064 } else {
16065 unreachable!()
16066 }
16067 }
16068 #[allow(deprecated)]
16069 ordinal => {
16070 for _ in 0..num_handles {
16071 decoder.drop_next_handle()?;
16072 }
16073 *self = JoinParams::__SourceBreaking { unknown_ordinal: ordinal };
16074 }
16075 }
16076 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16077 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16078 }
16079 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16080 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16081 }
16082 Ok(())
16083 }
16084 }
16085
16086 impl fidl::encoding::ValueTypeMarker for ProvisioningProgress {
16087 type Borrowed<'a> = &'a Self;
16088 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16089 value
16090 }
16091 }
16092
16093 unsafe impl fidl::encoding::TypeMarker for ProvisioningProgress {
16094 type Owned = Self;
16095
16096 #[inline(always)]
16097 fn inline_align(_context: fidl::encoding::Context) -> usize {
16098 8
16099 }
16100
16101 #[inline(always)]
16102 fn inline_size(_context: fidl::encoding::Context) -> usize {
16103 16
16104 }
16105 }
16106
16107 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProvisioningProgress, D>
16108 for &ProvisioningProgress
16109 {
16110 #[inline]
16111 unsafe fn encode(
16112 self,
16113 encoder: &mut fidl::encoding::Encoder<'_, D>,
16114 offset: usize,
16115 _depth: fidl::encoding::Depth,
16116 ) -> fidl::Result<()> {
16117 encoder.debug_check_bounds::<ProvisioningProgress>(offset);
16118 encoder.write_num::<u64>(self.ordinal(), offset);
16119 match self {
16120 ProvisioningProgress::Progress(ref val) => {
16121 fidl::encoding::encode_in_envelope::<f32, D>(
16122 <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16123 encoder, offset + 8, _depth
16124 )
16125 }
16126 ProvisioningProgress::Identity(ref val) => {
16127 fidl::encoding::encode_in_envelope::<fidl_fuchsia_lowpan_device__common::Identity, D>(
16128 <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::ValueTypeMarker>::borrow(val),
16129 encoder, offset + 8, _depth
16130 )
16131 }
16132 ProvisioningProgress::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
16133 }
16134 }
16135 }
16136
16137 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisioningProgress {
16138 #[inline(always)]
16139 fn new_empty() -> Self {
16140 Self::__SourceBreaking { unknown_ordinal: 0 }
16141 }
16142
16143 #[inline]
16144 unsafe fn decode(
16145 &mut self,
16146 decoder: &mut fidl::encoding::Decoder<'_, D>,
16147 offset: usize,
16148 mut depth: fidl::encoding::Depth,
16149 ) -> fidl::Result<()> {
16150 decoder.debug_check_bounds::<Self>(offset);
16151 #[allow(unused_variables)]
16152 let next_out_of_line = decoder.next_out_of_line();
16153 let handles_before = decoder.remaining_handles();
16154 let (ordinal, inlined, num_bytes, num_handles) =
16155 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
16156
16157 let member_inline_size = match ordinal {
16158 1 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16159 2 => <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16160 0 => return Err(fidl::Error::UnknownUnionTag),
16161 _ => num_bytes as usize,
16162 };
16163
16164 if inlined != (member_inline_size <= 4) {
16165 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16166 }
16167 let _inner_offset;
16168 if inlined {
16169 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16170 _inner_offset = offset + 8;
16171 } else {
16172 depth.increment()?;
16173 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16174 }
16175 match ordinal {
16176 1 => {
16177 #[allow(irrefutable_let_patterns)]
16178 if let ProvisioningProgress::Progress(_) = self {
16179 } else {
16181 *self = ProvisioningProgress::Progress(fidl::new_empty!(f32, D));
16183 }
16184 #[allow(irrefutable_let_patterns)]
16185 if let ProvisioningProgress::Progress(ref mut val) = self {
16186 fidl::decode!(f32, D, val, decoder, _inner_offset, depth)?;
16187 } else {
16188 unreachable!()
16189 }
16190 }
16191 2 => {
16192 #[allow(irrefutable_let_patterns)]
16193 if let ProvisioningProgress::Identity(_) = self {
16194 } else {
16196 *self = ProvisioningProgress::Identity(fidl::new_empty!(
16198 fidl_fuchsia_lowpan_device__common::Identity,
16199 D
16200 ));
16201 }
16202 #[allow(irrefutable_let_patterns)]
16203 if let ProvisioningProgress::Identity(ref mut val) = self {
16204 fidl::decode!(
16205 fidl_fuchsia_lowpan_device__common::Identity,
16206 D,
16207 val,
16208 decoder,
16209 _inner_offset,
16210 depth
16211 )?;
16212 } else {
16213 unreachable!()
16214 }
16215 }
16216 #[allow(deprecated)]
16217 ordinal => {
16218 for _ in 0..num_handles {
16219 decoder.drop_next_handle()?;
16220 }
16221 *self = ProvisioningProgress::__SourceBreaking { unknown_ordinal: ordinal };
16222 }
16223 }
16224 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16225 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16226 }
16227 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16228 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16229 }
16230 Ok(())
16231 }
16232 }
16233}