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
1410mod internal {
1411 use super::*;
1412 unsafe impl fidl::encoding::TypeMarker for Dhcp6PdState {
1413 type Owned = Self;
1414
1415 #[inline(always)]
1416 fn inline_align(_context: fidl::encoding::Context) -> usize {
1417 std::mem::align_of::<u32>()
1418 }
1419
1420 #[inline(always)]
1421 fn inline_size(_context: fidl::encoding::Context) -> usize {
1422 std::mem::size_of::<u32>()
1423 }
1424
1425 #[inline(always)]
1426 fn encode_is_copy() -> bool {
1427 false
1428 }
1429
1430 #[inline(always)]
1431 fn decode_is_copy() -> bool {
1432 false
1433 }
1434 }
1435
1436 impl fidl::encoding::ValueTypeMarker for Dhcp6PdState {
1437 type Borrowed<'a> = Self;
1438 #[inline(always)]
1439 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1440 *value
1441 }
1442 }
1443
1444 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Dhcp6PdState {
1445 #[inline]
1446 unsafe fn encode(
1447 self,
1448 encoder: &mut fidl::encoding::Encoder<'_, D>,
1449 offset: usize,
1450 _depth: fidl::encoding::Depth,
1451 ) -> fidl::Result<()> {
1452 encoder.debug_check_bounds::<Self>(offset);
1453 encoder.write_num(self.into_primitive(), offset);
1454 Ok(())
1455 }
1456 }
1457
1458 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dhcp6PdState {
1459 #[inline(always)]
1460 fn new_empty() -> Self {
1461 Self::unknown()
1462 }
1463
1464 #[inline]
1465 unsafe fn decode(
1466 &mut self,
1467 decoder: &mut fidl::encoding::Decoder<'_, D>,
1468 offset: usize,
1469 _depth: fidl::encoding::Depth,
1470 ) -> fidl::Result<()> {
1471 decoder.debug_check_bounds::<Self>(offset);
1472 let prim = decoder.read_num::<u32>(offset);
1473
1474 *self = Self::from_primitive_allow_unknown(prim);
1475 Ok(())
1476 }
1477 }
1478 unsafe impl fidl::encoding::TypeMarker for Nat64State {
1479 type Owned = Self;
1480
1481 #[inline(always)]
1482 fn inline_align(_context: fidl::encoding::Context) -> usize {
1483 std::mem::align_of::<u32>()
1484 }
1485
1486 #[inline(always)]
1487 fn inline_size(_context: fidl::encoding::Context) -> usize {
1488 std::mem::size_of::<u32>()
1489 }
1490
1491 #[inline(always)]
1492 fn encode_is_copy() -> bool {
1493 false
1494 }
1495
1496 #[inline(always)]
1497 fn decode_is_copy() -> bool {
1498 false
1499 }
1500 }
1501
1502 impl fidl::encoding::ValueTypeMarker for Nat64State {
1503 type Borrowed<'a> = Self;
1504 #[inline(always)]
1505 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1506 *value
1507 }
1508 }
1509
1510 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Nat64State {
1511 #[inline]
1512 unsafe fn encode(
1513 self,
1514 encoder: &mut fidl::encoding::Encoder<'_, D>,
1515 offset: usize,
1516 _depth: fidl::encoding::Depth,
1517 ) -> fidl::Result<()> {
1518 encoder.debug_check_bounds::<Self>(offset);
1519 encoder.write_num(self.into_primitive(), offset);
1520 Ok(())
1521 }
1522 }
1523
1524 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64State {
1525 #[inline(always)]
1526 fn new_empty() -> Self {
1527 Self::unknown()
1528 }
1529
1530 #[inline]
1531 unsafe fn decode(
1532 &mut self,
1533 decoder: &mut fidl::encoding::Decoder<'_, D>,
1534 offset: usize,
1535 _depth: fidl::encoding::Depth,
1536 ) -> fidl::Result<()> {
1537 decoder.debug_check_bounds::<Self>(offset);
1538 let prim = decoder.read_num::<u32>(offset);
1539
1540 *self = Self::from_primitive_allow_unknown(prim);
1541 Ok(())
1542 }
1543 }
1544 unsafe impl fidl::encoding::TypeMarker for ProvisionError {
1545 type Owned = Self;
1546
1547 #[inline(always)]
1548 fn inline_align(_context: fidl::encoding::Context) -> usize {
1549 std::mem::align_of::<i32>()
1550 }
1551
1552 #[inline(always)]
1553 fn inline_size(_context: fidl::encoding::Context) -> usize {
1554 std::mem::size_of::<i32>()
1555 }
1556
1557 #[inline(always)]
1558 fn encode_is_copy() -> bool {
1559 false
1560 }
1561
1562 #[inline(always)]
1563 fn decode_is_copy() -> bool {
1564 false
1565 }
1566 }
1567
1568 impl fidl::encoding::ValueTypeMarker for ProvisionError {
1569 type Borrowed<'a> = Self;
1570 #[inline(always)]
1571 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1572 *value
1573 }
1574 }
1575
1576 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ProvisionError {
1577 #[inline]
1578 unsafe fn encode(
1579 self,
1580 encoder: &mut fidl::encoding::Encoder<'_, D>,
1581 offset: usize,
1582 _depth: fidl::encoding::Depth,
1583 ) -> fidl::Result<()> {
1584 encoder.debug_check_bounds::<Self>(offset);
1585 encoder.write_num(self.into_primitive(), offset);
1586 Ok(())
1587 }
1588 }
1589
1590 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisionError {
1591 #[inline(always)]
1592 fn new_empty() -> Self {
1593 Self::unknown()
1594 }
1595
1596 #[inline]
1597 unsafe fn decode(
1598 &mut self,
1599 decoder: &mut fidl::encoding::Decoder<'_, D>,
1600 offset: usize,
1601 _depth: fidl::encoding::Depth,
1602 ) -> fidl::Result<()> {
1603 decoder.debug_check_bounds::<Self>(offset);
1604 let prim = decoder.read_num::<i32>(offset);
1605
1606 *self = Self::from_primitive_allow_unknown(prim);
1607 Ok(())
1608 }
1609 }
1610 unsafe impl fidl::encoding::TypeMarker for RoutePreference {
1611 type Owned = Self;
1612
1613 #[inline(always)]
1614 fn inline_align(_context: fidl::encoding::Context) -> usize {
1615 std::mem::align_of::<i8>()
1616 }
1617
1618 #[inline(always)]
1619 fn inline_size(_context: fidl::encoding::Context) -> usize {
1620 std::mem::size_of::<i8>()
1621 }
1622
1623 #[inline(always)]
1624 fn encode_is_copy() -> bool {
1625 true
1626 }
1627
1628 #[inline(always)]
1629 fn decode_is_copy() -> bool {
1630 false
1631 }
1632 }
1633
1634 impl fidl::encoding::ValueTypeMarker for RoutePreference {
1635 type Borrowed<'a> = Self;
1636 #[inline(always)]
1637 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1638 *value
1639 }
1640 }
1641
1642 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1643 for RoutePreference
1644 {
1645 #[inline]
1646 unsafe fn encode(
1647 self,
1648 encoder: &mut fidl::encoding::Encoder<'_, D>,
1649 offset: usize,
1650 _depth: fidl::encoding::Depth,
1651 ) -> fidl::Result<()> {
1652 encoder.debug_check_bounds::<Self>(offset);
1653 encoder.write_num(self.into_primitive(), offset);
1654 Ok(())
1655 }
1656 }
1657
1658 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoutePreference {
1659 #[inline(always)]
1660 fn new_empty() -> Self {
1661 Self::Low
1662 }
1663
1664 #[inline]
1665 unsafe fn decode(
1666 &mut self,
1667 decoder: &mut fidl::encoding::Decoder<'_, D>,
1668 offset: usize,
1669 _depth: fidl::encoding::Depth,
1670 ) -> fidl::Result<()> {
1671 decoder.debug_check_bounds::<Self>(offset);
1672 let prim = decoder.read_num::<i8>(offset);
1673
1674 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1675 Ok(())
1676 }
1677 }
1678 unsafe impl fidl::encoding::TypeMarker for SrpServerAddressMode {
1679 type Owned = Self;
1680
1681 #[inline(always)]
1682 fn inline_align(_context: fidl::encoding::Context) -> usize {
1683 std::mem::align_of::<u32>()
1684 }
1685
1686 #[inline(always)]
1687 fn inline_size(_context: fidl::encoding::Context) -> usize {
1688 std::mem::size_of::<u32>()
1689 }
1690
1691 #[inline(always)]
1692 fn encode_is_copy() -> bool {
1693 true
1694 }
1695
1696 #[inline(always)]
1697 fn decode_is_copy() -> bool {
1698 false
1699 }
1700 }
1701
1702 impl fidl::encoding::ValueTypeMarker for SrpServerAddressMode {
1703 type Borrowed<'a> = Self;
1704 #[inline(always)]
1705 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1706 *value
1707 }
1708 }
1709
1710 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1711 for SrpServerAddressMode
1712 {
1713 #[inline]
1714 unsafe fn encode(
1715 self,
1716 encoder: &mut fidl::encoding::Encoder<'_, D>,
1717 offset: usize,
1718 _depth: fidl::encoding::Depth,
1719 ) -> fidl::Result<()> {
1720 encoder.debug_check_bounds::<Self>(offset);
1721 encoder.write_num(self.into_primitive(), offset);
1722 Ok(())
1723 }
1724 }
1725
1726 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerAddressMode {
1727 #[inline(always)]
1728 fn new_empty() -> Self {
1729 Self::Unicast
1730 }
1731
1732 #[inline]
1733 unsafe fn decode(
1734 &mut self,
1735 decoder: &mut fidl::encoding::Decoder<'_, D>,
1736 offset: usize,
1737 _depth: fidl::encoding::Depth,
1738 ) -> fidl::Result<()> {
1739 decoder.debug_check_bounds::<Self>(offset);
1740 let prim = decoder.read_num::<u32>(offset);
1741
1742 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1743 Ok(())
1744 }
1745 }
1746 unsafe impl fidl::encoding::TypeMarker for SrpServerState {
1747 type Owned = Self;
1748
1749 #[inline(always)]
1750 fn inline_align(_context: fidl::encoding::Context) -> usize {
1751 std::mem::align_of::<u32>()
1752 }
1753
1754 #[inline(always)]
1755 fn inline_size(_context: fidl::encoding::Context) -> usize {
1756 std::mem::size_of::<u32>()
1757 }
1758
1759 #[inline(always)]
1760 fn encode_is_copy() -> bool {
1761 true
1762 }
1763
1764 #[inline(always)]
1765 fn decode_is_copy() -> bool {
1766 false
1767 }
1768 }
1769
1770 impl fidl::encoding::ValueTypeMarker for SrpServerState {
1771 type Borrowed<'a> = Self;
1772 #[inline(always)]
1773 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1774 *value
1775 }
1776 }
1777
1778 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SrpServerState {
1779 #[inline]
1780 unsafe fn encode(
1781 self,
1782 encoder: &mut fidl::encoding::Encoder<'_, D>,
1783 offset: usize,
1784 _depth: fidl::encoding::Depth,
1785 ) -> fidl::Result<()> {
1786 encoder.debug_check_bounds::<Self>(offset);
1787 encoder.write_num(self.into_primitive(), offset);
1788 Ok(())
1789 }
1790 }
1791
1792 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerState {
1793 #[inline(always)]
1794 fn new_empty() -> Self {
1795 Self::Disabled
1796 }
1797
1798 #[inline]
1799 unsafe fn decode(
1800 &mut self,
1801 decoder: &mut fidl::encoding::Decoder<'_, D>,
1802 offset: usize,
1803 _depth: fidl::encoding::Depth,
1804 ) -> fidl::Result<()> {
1805 decoder.debug_check_bounds::<Self>(offset);
1806 let prim = decoder.read_num::<u32>(offset);
1807
1808 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1809 Ok(())
1810 }
1811 }
1812 unsafe impl fidl::encoding::TypeMarker for UpstreamDnsQueryState {
1813 type Owned = Self;
1814
1815 #[inline(always)]
1816 fn inline_align(_context: fidl::encoding::Context) -> usize {
1817 std::mem::align_of::<u32>()
1818 }
1819
1820 #[inline(always)]
1821 fn inline_size(_context: fidl::encoding::Context) -> usize {
1822 std::mem::size_of::<u32>()
1823 }
1824
1825 #[inline(always)]
1826 fn encode_is_copy() -> bool {
1827 false
1828 }
1829
1830 #[inline(always)]
1831 fn decode_is_copy() -> bool {
1832 false
1833 }
1834 }
1835
1836 impl fidl::encoding::ValueTypeMarker for UpstreamDnsQueryState {
1837 type Borrowed<'a> = Self;
1838 #[inline(always)]
1839 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1840 *value
1841 }
1842 }
1843
1844 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1845 for UpstreamDnsQueryState
1846 {
1847 #[inline]
1848 unsafe fn encode(
1849 self,
1850 encoder: &mut fidl::encoding::Encoder<'_, D>,
1851 offset: usize,
1852 _depth: fidl::encoding::Depth,
1853 ) -> fidl::Result<()> {
1854 encoder.debug_check_bounds::<Self>(offset);
1855 encoder.write_num(self.into_primitive(), offset);
1856 Ok(())
1857 }
1858 }
1859
1860 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsQueryState {
1861 #[inline(always)]
1862 fn new_empty() -> Self {
1863 Self::unknown()
1864 }
1865
1866 #[inline]
1867 unsafe fn decode(
1868 &mut self,
1869 decoder: &mut fidl::encoding::Decoder<'_, D>,
1870 offset: usize,
1871 _depth: fidl::encoding::Depth,
1872 ) -> fidl::Result<()> {
1873 decoder.debug_check_bounds::<Self>(offset);
1874 let prim = decoder.read_num::<u32>(offset);
1875
1876 *self = Self::from_primitive_allow_unknown(prim);
1877 Ok(())
1878 }
1879 }
1880
1881 impl fidl::encoding::ValueTypeMarker for BeaconInfoStreamNextResponse {
1882 type Borrowed<'a> = &'a Self;
1883 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1884 value
1885 }
1886 }
1887
1888 unsafe impl fidl::encoding::TypeMarker for BeaconInfoStreamNextResponse {
1889 type Owned = Self;
1890
1891 #[inline(always)]
1892 fn inline_align(_context: fidl::encoding::Context) -> usize {
1893 8
1894 }
1895
1896 #[inline(always)]
1897 fn inline_size(_context: fidl::encoding::Context) -> usize {
1898 16
1899 }
1900 }
1901
1902 unsafe impl<D: fidl::encoding::ResourceDialect>
1903 fidl::encoding::Encode<BeaconInfoStreamNextResponse, D> for &BeaconInfoStreamNextResponse
1904 {
1905 #[inline]
1906 unsafe fn encode(
1907 self,
1908 encoder: &mut fidl::encoding::Encoder<'_, D>,
1909 offset: usize,
1910 _depth: fidl::encoding::Depth,
1911 ) -> fidl::Result<()> {
1912 encoder.debug_check_bounds::<BeaconInfoStreamNextResponse>(offset);
1913 fidl::encoding::Encode::<BeaconInfoStreamNextResponse, D>::encode(
1915 (
1916 <fidl::encoding::Vector<BeaconInfo, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.beacons),
1917 ),
1918 encoder, offset, _depth
1919 )
1920 }
1921 }
1922 unsafe impl<
1923 D: fidl::encoding::ResourceDialect,
1924 T0: fidl::encoding::Encode<fidl::encoding::Vector<BeaconInfo, 32>, D>,
1925 > fidl::encoding::Encode<BeaconInfoStreamNextResponse, D> for (T0,)
1926 {
1927 #[inline]
1928 unsafe fn encode(
1929 self,
1930 encoder: &mut fidl::encoding::Encoder<'_, D>,
1931 offset: usize,
1932 depth: fidl::encoding::Depth,
1933 ) -> fidl::Result<()> {
1934 encoder.debug_check_bounds::<BeaconInfoStreamNextResponse>(offset);
1935 self.0.encode(encoder, offset + 0, depth)?;
1939 Ok(())
1940 }
1941 }
1942
1943 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1944 for BeaconInfoStreamNextResponse
1945 {
1946 #[inline(always)]
1947 fn new_empty() -> Self {
1948 Self { beacons: fidl::new_empty!(fidl::encoding::Vector<BeaconInfo, 32>, D) }
1949 }
1950
1951 #[inline]
1952 unsafe fn decode(
1953 &mut self,
1954 decoder: &mut fidl::encoding::Decoder<'_, D>,
1955 offset: usize,
1956 _depth: fidl::encoding::Depth,
1957 ) -> fidl::Result<()> {
1958 decoder.debug_check_bounds::<Self>(offset);
1959 fidl::decode!(fidl::encoding::Vector<BeaconInfo, 32>, D, &mut self.beacons, decoder, offset + 0, _depth)?;
1961 Ok(())
1962 }
1963 }
1964
1965 impl fidl::encoding::ValueTypeMarker for DeviceGetSupportedChannelsResponse {
1966 type Borrowed<'a> = &'a Self;
1967 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1968 value
1969 }
1970 }
1971
1972 unsafe impl fidl::encoding::TypeMarker for DeviceGetSupportedChannelsResponse {
1973 type Owned = Self;
1974
1975 #[inline(always)]
1976 fn inline_align(_context: fidl::encoding::Context) -> usize {
1977 8
1978 }
1979
1980 #[inline(always)]
1981 fn inline_size(_context: fidl::encoding::Context) -> usize {
1982 16
1983 }
1984 }
1985
1986 unsafe impl<D: fidl::encoding::ResourceDialect>
1987 fidl::encoding::Encode<DeviceGetSupportedChannelsResponse, D>
1988 for &DeviceGetSupportedChannelsResponse
1989 {
1990 #[inline]
1991 unsafe fn encode(
1992 self,
1993 encoder: &mut fidl::encoding::Encoder<'_, D>,
1994 offset: usize,
1995 _depth: fidl::encoding::Depth,
1996 ) -> fidl::Result<()> {
1997 encoder.debug_check_bounds::<DeviceGetSupportedChannelsResponse>(offset);
1998 fidl::encoding::Encode::<DeviceGetSupportedChannelsResponse, D>::encode(
2000 (
2001 <fidl::encoding::Vector<ChannelInfo, 200> as fidl::encoding::ValueTypeMarker>::borrow(&self.channels_info),
2002 ),
2003 encoder, offset, _depth
2004 )
2005 }
2006 }
2007 unsafe impl<
2008 D: fidl::encoding::ResourceDialect,
2009 T0: fidl::encoding::Encode<fidl::encoding::Vector<ChannelInfo, 200>, D>,
2010 > fidl::encoding::Encode<DeviceGetSupportedChannelsResponse, D> for (T0,)
2011 {
2012 #[inline]
2013 unsafe fn encode(
2014 self,
2015 encoder: &mut fidl::encoding::Encoder<'_, D>,
2016 offset: usize,
2017 depth: fidl::encoding::Depth,
2018 ) -> fidl::Result<()> {
2019 encoder.debug_check_bounds::<DeviceGetSupportedChannelsResponse>(offset);
2020 self.0.encode(encoder, offset + 0, depth)?;
2024 Ok(())
2025 }
2026 }
2027
2028 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2029 for DeviceGetSupportedChannelsResponse
2030 {
2031 #[inline(always)]
2032 fn new_empty() -> Self {
2033 Self { channels_info: fidl::new_empty!(fidl::encoding::Vector<ChannelInfo, 200>, D) }
2034 }
2035
2036 #[inline]
2037 unsafe fn decode(
2038 &mut self,
2039 decoder: &mut fidl::encoding::Decoder<'_, D>,
2040 offset: usize,
2041 _depth: fidl::encoding::Depth,
2042 ) -> fidl::Result<()> {
2043 decoder.debug_check_bounds::<Self>(offset);
2044 fidl::decode!(fidl::encoding::Vector<ChannelInfo, 200>, D, &mut self.channels_info, decoder, offset + 0, _depth)?;
2046 Ok(())
2047 }
2048 }
2049
2050 impl fidl::encoding::ValueTypeMarker for DeviceRouteExtraGetLocalExternalRoutesResponse {
2051 type Borrowed<'a> = &'a Self;
2052 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2053 value
2054 }
2055 }
2056
2057 unsafe impl fidl::encoding::TypeMarker for DeviceRouteExtraGetLocalExternalRoutesResponse {
2058 type Owned = Self;
2059
2060 #[inline(always)]
2061 fn inline_align(_context: fidl::encoding::Context) -> usize {
2062 8
2063 }
2064
2065 #[inline(always)]
2066 fn inline_size(_context: fidl::encoding::Context) -> usize {
2067 16
2068 }
2069 }
2070
2071 unsafe impl<D: fidl::encoding::ResourceDialect>
2072 fidl::encoding::Encode<DeviceRouteExtraGetLocalExternalRoutesResponse, D>
2073 for &DeviceRouteExtraGetLocalExternalRoutesResponse
2074 {
2075 #[inline]
2076 unsafe fn encode(
2077 self,
2078 encoder: &mut fidl::encoding::Encoder<'_, D>,
2079 offset: usize,
2080 _depth: fidl::encoding::Depth,
2081 ) -> fidl::Result<()> {
2082 encoder.debug_check_bounds::<DeviceRouteExtraGetLocalExternalRoutesResponse>(offset);
2083 fidl::encoding::Encode::<DeviceRouteExtraGetLocalExternalRoutesResponse, D>::encode(
2085 (
2086 <fidl::encoding::Vector<ExternalRoute, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.external_routes),
2087 ),
2088 encoder, offset, _depth
2089 )
2090 }
2091 }
2092 unsafe impl<
2093 D: fidl::encoding::ResourceDialect,
2094 T0: fidl::encoding::Encode<fidl::encoding::Vector<ExternalRoute, 32>, D>,
2095 > fidl::encoding::Encode<DeviceRouteExtraGetLocalExternalRoutesResponse, D> for (T0,)
2096 {
2097 #[inline]
2098 unsafe fn encode(
2099 self,
2100 encoder: &mut fidl::encoding::Encoder<'_, D>,
2101 offset: usize,
2102 depth: fidl::encoding::Depth,
2103 ) -> fidl::Result<()> {
2104 encoder.debug_check_bounds::<DeviceRouteExtraGetLocalExternalRoutesResponse>(offset);
2105 self.0.encode(encoder, offset + 0, depth)?;
2109 Ok(())
2110 }
2111 }
2112
2113 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2114 for DeviceRouteExtraGetLocalExternalRoutesResponse
2115 {
2116 #[inline(always)]
2117 fn new_empty() -> Self {
2118 Self { external_routes: fidl::new_empty!(fidl::encoding::Vector<ExternalRoute, 32>, D) }
2119 }
2120
2121 #[inline]
2122 unsafe fn decode(
2123 &mut self,
2124 decoder: &mut fidl::encoding::Decoder<'_, D>,
2125 offset: usize,
2126 _depth: fidl::encoding::Depth,
2127 ) -> fidl::Result<()> {
2128 decoder.debug_check_bounds::<Self>(offset);
2129 fidl::decode!(fidl::encoding::Vector<ExternalRoute, 32>, D, &mut self.external_routes, decoder, offset + 0, _depth)?;
2131 Ok(())
2132 }
2133 }
2134
2135 impl fidl::encoding::ValueTypeMarker for DeviceRouteExtraGetLocalOnMeshPrefixesResponse {
2136 type Borrowed<'a> = &'a Self;
2137 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2138 value
2139 }
2140 }
2141
2142 unsafe impl fidl::encoding::TypeMarker for DeviceRouteExtraGetLocalOnMeshPrefixesResponse {
2143 type Owned = Self;
2144
2145 #[inline(always)]
2146 fn inline_align(_context: fidl::encoding::Context) -> usize {
2147 8
2148 }
2149
2150 #[inline(always)]
2151 fn inline_size(_context: fidl::encoding::Context) -> usize {
2152 16
2153 }
2154 }
2155
2156 unsafe impl<D: fidl::encoding::ResourceDialect>
2157 fidl::encoding::Encode<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D>
2158 for &DeviceRouteExtraGetLocalOnMeshPrefixesResponse
2159 {
2160 #[inline]
2161 unsafe fn encode(
2162 self,
2163 encoder: &mut fidl::encoding::Encoder<'_, D>,
2164 offset: usize,
2165 _depth: fidl::encoding::Depth,
2166 ) -> fidl::Result<()> {
2167 encoder.debug_check_bounds::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse>(offset);
2168 fidl::encoding::Encode::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D>::encode(
2170 (
2171 <fidl::encoding::Vector<OnMeshPrefix, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.prefixes),
2172 ),
2173 encoder, offset, _depth
2174 )
2175 }
2176 }
2177 unsafe impl<
2178 D: fidl::encoding::ResourceDialect,
2179 T0: fidl::encoding::Encode<fidl::encoding::Vector<OnMeshPrefix, 32>, D>,
2180 > fidl::encoding::Encode<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D> for (T0,)
2181 {
2182 #[inline]
2183 unsafe fn encode(
2184 self,
2185 encoder: &mut fidl::encoding::Encoder<'_, D>,
2186 offset: usize,
2187 depth: fidl::encoding::Depth,
2188 ) -> fidl::Result<()> {
2189 encoder.debug_check_bounds::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse>(offset);
2190 self.0.encode(encoder, offset + 0, depth)?;
2194 Ok(())
2195 }
2196 }
2197
2198 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2199 for DeviceRouteExtraGetLocalOnMeshPrefixesResponse
2200 {
2201 #[inline(always)]
2202 fn new_empty() -> Self {
2203 Self { prefixes: fidl::new_empty!(fidl::encoding::Vector<OnMeshPrefix, 32>, D) }
2204 }
2205
2206 #[inline]
2207 unsafe fn decode(
2208 &mut self,
2209 decoder: &mut fidl::encoding::Decoder<'_, D>,
2210 offset: usize,
2211 _depth: fidl::encoding::Depth,
2212 ) -> fidl::Result<()> {
2213 decoder.debug_check_bounds::<Self>(offset);
2214 fidl::decode!(fidl::encoding::Vector<OnMeshPrefix, 32>, D, &mut self.prefixes, decoder, offset + 0, _depth)?;
2216 Ok(())
2217 }
2218 }
2219
2220 impl fidl::encoding::ValueTypeMarker for DeviceRouteRegisterExternalRouteRequest {
2221 type Borrowed<'a> = &'a Self;
2222 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2223 value
2224 }
2225 }
2226
2227 unsafe impl fidl::encoding::TypeMarker for DeviceRouteRegisterExternalRouteRequest {
2228 type Owned = Self;
2229
2230 #[inline(always)]
2231 fn inline_align(_context: fidl::encoding::Context) -> usize {
2232 8
2233 }
2234
2235 #[inline(always)]
2236 fn inline_size(_context: fidl::encoding::Context) -> usize {
2237 16
2238 }
2239 }
2240
2241 unsafe impl<D: fidl::encoding::ResourceDialect>
2242 fidl::encoding::Encode<DeviceRouteRegisterExternalRouteRequest, D>
2243 for &DeviceRouteRegisterExternalRouteRequest
2244 {
2245 #[inline]
2246 unsafe fn encode(
2247 self,
2248 encoder: &mut fidl::encoding::Encoder<'_, D>,
2249 offset: usize,
2250 _depth: fidl::encoding::Depth,
2251 ) -> fidl::Result<()> {
2252 encoder.debug_check_bounds::<DeviceRouteRegisterExternalRouteRequest>(offset);
2253 fidl::encoding::Encode::<DeviceRouteRegisterExternalRouteRequest, D>::encode(
2255 (<ExternalRoute as fidl::encoding::ValueTypeMarker>::borrow(&self.external_route),),
2256 encoder,
2257 offset,
2258 _depth,
2259 )
2260 }
2261 }
2262 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ExternalRoute, D>>
2263 fidl::encoding::Encode<DeviceRouteRegisterExternalRouteRequest, D> for (T0,)
2264 {
2265 #[inline]
2266 unsafe fn encode(
2267 self,
2268 encoder: &mut fidl::encoding::Encoder<'_, D>,
2269 offset: usize,
2270 depth: fidl::encoding::Depth,
2271 ) -> fidl::Result<()> {
2272 encoder.debug_check_bounds::<DeviceRouteRegisterExternalRouteRequest>(offset);
2273 self.0.encode(encoder, offset + 0, depth)?;
2277 Ok(())
2278 }
2279 }
2280
2281 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2282 for DeviceRouteRegisterExternalRouteRequest
2283 {
2284 #[inline(always)]
2285 fn new_empty() -> Self {
2286 Self { external_route: fidl::new_empty!(ExternalRoute, D) }
2287 }
2288
2289 #[inline]
2290 unsafe fn decode(
2291 &mut self,
2292 decoder: &mut fidl::encoding::Decoder<'_, D>,
2293 offset: usize,
2294 _depth: fidl::encoding::Depth,
2295 ) -> fidl::Result<()> {
2296 decoder.debug_check_bounds::<Self>(offset);
2297 fidl::decode!(ExternalRoute, D, &mut self.external_route, decoder, offset + 0, _depth)?;
2299 Ok(())
2300 }
2301 }
2302
2303 impl fidl::encoding::ValueTypeMarker for DeviceRouteRegisterOnMeshPrefixRequest {
2304 type Borrowed<'a> = &'a Self;
2305 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2306 value
2307 }
2308 }
2309
2310 unsafe impl fidl::encoding::TypeMarker for DeviceRouteRegisterOnMeshPrefixRequest {
2311 type Owned = Self;
2312
2313 #[inline(always)]
2314 fn inline_align(_context: fidl::encoding::Context) -> usize {
2315 8
2316 }
2317
2318 #[inline(always)]
2319 fn inline_size(_context: fidl::encoding::Context) -> usize {
2320 16
2321 }
2322 }
2323
2324 unsafe impl<D: fidl::encoding::ResourceDialect>
2325 fidl::encoding::Encode<DeviceRouteRegisterOnMeshPrefixRequest, D>
2326 for &DeviceRouteRegisterOnMeshPrefixRequest
2327 {
2328 #[inline]
2329 unsafe fn encode(
2330 self,
2331 encoder: &mut fidl::encoding::Encoder<'_, D>,
2332 offset: usize,
2333 _depth: fidl::encoding::Depth,
2334 ) -> fidl::Result<()> {
2335 encoder.debug_check_bounds::<DeviceRouteRegisterOnMeshPrefixRequest>(offset);
2336 fidl::encoding::Encode::<DeviceRouteRegisterOnMeshPrefixRequest, D>::encode(
2338 (<OnMeshPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.prefix),),
2339 encoder,
2340 offset,
2341 _depth,
2342 )
2343 }
2344 }
2345 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<OnMeshPrefix, D>>
2346 fidl::encoding::Encode<DeviceRouteRegisterOnMeshPrefixRequest, D> for (T0,)
2347 {
2348 #[inline]
2349 unsafe fn encode(
2350 self,
2351 encoder: &mut fidl::encoding::Encoder<'_, D>,
2352 offset: usize,
2353 depth: fidl::encoding::Depth,
2354 ) -> fidl::Result<()> {
2355 encoder.debug_check_bounds::<DeviceRouteRegisterOnMeshPrefixRequest>(offset);
2356 self.0.encode(encoder, offset + 0, depth)?;
2360 Ok(())
2361 }
2362 }
2363
2364 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2365 for DeviceRouteRegisterOnMeshPrefixRequest
2366 {
2367 #[inline(always)]
2368 fn new_empty() -> Self {
2369 Self { prefix: fidl::new_empty!(OnMeshPrefix, D) }
2370 }
2371
2372 #[inline]
2373 unsafe fn decode(
2374 &mut self,
2375 decoder: &mut fidl::encoding::Decoder<'_, D>,
2376 offset: usize,
2377 _depth: fidl::encoding::Depth,
2378 ) -> fidl::Result<()> {
2379 decoder.debug_check_bounds::<Self>(offset);
2380 fidl::decode!(OnMeshPrefix, D, &mut self.prefix, decoder, offset + 0, _depth)?;
2382 Ok(())
2383 }
2384 }
2385
2386 impl fidl::encoding::ValueTypeMarker for DeviceRouteUnregisterExternalRouteRequest {
2387 type Borrowed<'a> = &'a Self;
2388 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2389 value
2390 }
2391 }
2392
2393 unsafe impl fidl::encoding::TypeMarker for DeviceRouteUnregisterExternalRouteRequest {
2394 type Owned = Self;
2395
2396 #[inline(always)]
2397 fn inline_align(_context: fidl::encoding::Context) -> usize {
2398 1
2399 }
2400
2401 #[inline(always)]
2402 fn inline_size(_context: fidl::encoding::Context) -> usize {
2403 17
2404 }
2405 }
2406
2407 unsafe impl<D: fidl::encoding::ResourceDialect>
2408 fidl::encoding::Encode<DeviceRouteUnregisterExternalRouteRequest, D>
2409 for &DeviceRouteUnregisterExternalRouteRequest
2410 {
2411 #[inline]
2412 unsafe fn encode(
2413 self,
2414 encoder: &mut fidl::encoding::Encoder<'_, D>,
2415 offset: usize,
2416 _depth: fidl::encoding::Depth,
2417 ) -> fidl::Result<()> {
2418 encoder.debug_check_bounds::<DeviceRouteUnregisterExternalRouteRequest>(offset);
2419 fidl::encoding::Encode::<DeviceRouteUnregisterExternalRouteRequest, D>::encode(
2421 (
2422 <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.subnet),
2423 ),
2424 encoder, offset, _depth
2425 )
2426 }
2427 }
2428 unsafe impl<
2429 D: fidl::encoding::ResourceDialect,
2430 T0: fidl::encoding::Encode<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>,
2431 > fidl::encoding::Encode<DeviceRouteUnregisterExternalRouteRequest, D> for (T0,)
2432 {
2433 #[inline]
2434 unsafe fn encode(
2435 self,
2436 encoder: &mut fidl::encoding::Encoder<'_, D>,
2437 offset: usize,
2438 depth: fidl::encoding::Depth,
2439 ) -> fidl::Result<()> {
2440 encoder.debug_check_bounds::<DeviceRouteUnregisterExternalRouteRequest>(offset);
2441 self.0.encode(encoder, offset + 0, depth)?;
2445 Ok(())
2446 }
2447 }
2448
2449 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2450 for DeviceRouteUnregisterExternalRouteRequest
2451 {
2452 #[inline(always)]
2453 fn new_empty() -> Self {
2454 Self { subnet: fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D) }
2455 }
2456
2457 #[inline]
2458 unsafe fn decode(
2459 &mut self,
2460 decoder: &mut fidl::encoding::Decoder<'_, D>,
2461 offset: usize,
2462 _depth: fidl::encoding::Depth,
2463 ) -> fidl::Result<()> {
2464 decoder.debug_check_bounds::<Self>(offset);
2465 fidl::decode!(
2467 fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
2468 D,
2469 &mut self.subnet,
2470 decoder,
2471 offset + 0,
2472 _depth
2473 )?;
2474 Ok(())
2475 }
2476 }
2477
2478 impl fidl::encoding::ValueTypeMarker for DeviceRouteUnregisterOnMeshPrefixRequest {
2479 type Borrowed<'a> = &'a Self;
2480 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2481 value
2482 }
2483 }
2484
2485 unsafe impl fidl::encoding::TypeMarker for DeviceRouteUnregisterOnMeshPrefixRequest {
2486 type Owned = Self;
2487
2488 #[inline(always)]
2489 fn inline_align(_context: fidl::encoding::Context) -> usize {
2490 1
2491 }
2492
2493 #[inline(always)]
2494 fn inline_size(_context: fidl::encoding::Context) -> usize {
2495 17
2496 }
2497 }
2498
2499 unsafe impl<D: fidl::encoding::ResourceDialect>
2500 fidl::encoding::Encode<DeviceRouteUnregisterOnMeshPrefixRequest, D>
2501 for &DeviceRouteUnregisterOnMeshPrefixRequest
2502 {
2503 #[inline]
2504 unsafe fn encode(
2505 self,
2506 encoder: &mut fidl::encoding::Encoder<'_, D>,
2507 offset: usize,
2508 _depth: fidl::encoding::Depth,
2509 ) -> fidl::Result<()> {
2510 encoder.debug_check_bounds::<DeviceRouteUnregisterOnMeshPrefixRequest>(offset);
2511 fidl::encoding::Encode::<DeviceRouteUnregisterOnMeshPrefixRequest, D>::encode(
2513 (
2514 <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.subnet),
2515 ),
2516 encoder, offset, _depth
2517 )
2518 }
2519 }
2520 unsafe impl<
2521 D: fidl::encoding::ResourceDialect,
2522 T0: fidl::encoding::Encode<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>,
2523 > fidl::encoding::Encode<DeviceRouteUnregisterOnMeshPrefixRequest, D> for (T0,)
2524 {
2525 #[inline]
2526 unsafe fn encode(
2527 self,
2528 encoder: &mut fidl::encoding::Encoder<'_, D>,
2529 offset: usize,
2530 depth: fidl::encoding::Depth,
2531 ) -> fidl::Result<()> {
2532 encoder.debug_check_bounds::<DeviceRouteUnregisterOnMeshPrefixRequest>(offset);
2533 self.0.encode(encoder, offset + 0, depth)?;
2537 Ok(())
2538 }
2539 }
2540
2541 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2542 for DeviceRouteUnregisterOnMeshPrefixRequest
2543 {
2544 #[inline(always)]
2545 fn new_empty() -> Self {
2546 Self { subnet: fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D) }
2547 }
2548
2549 #[inline]
2550 unsafe fn decode(
2551 &mut self,
2552 decoder: &mut fidl::encoding::Decoder<'_, D>,
2553 offset: usize,
2554 _depth: fidl::encoding::Depth,
2555 ) -> fidl::Result<()> {
2556 decoder.debug_check_bounds::<Self>(offset);
2557 fidl::decode!(
2559 fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
2560 D,
2561 &mut self.subnet,
2562 decoder,
2563 offset + 0,
2564 _depth
2565 )?;
2566 Ok(())
2567 }
2568 }
2569
2570 impl fidl::encoding::ValueTypeMarker for LegacyJoiningMakeJoinableRequest {
2571 type Borrowed<'a> = &'a Self;
2572 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2573 value
2574 }
2575 }
2576
2577 unsafe impl fidl::encoding::TypeMarker for LegacyJoiningMakeJoinableRequest {
2578 type Owned = Self;
2579
2580 #[inline(always)]
2581 fn inline_align(_context: fidl::encoding::Context) -> usize {
2582 8
2583 }
2584
2585 #[inline(always)]
2586 fn inline_size(_context: fidl::encoding::Context) -> usize {
2587 16
2588 }
2589 }
2590
2591 unsafe impl<D: fidl::encoding::ResourceDialect>
2592 fidl::encoding::Encode<LegacyJoiningMakeJoinableRequest, D>
2593 for &LegacyJoiningMakeJoinableRequest
2594 {
2595 #[inline]
2596 unsafe fn encode(
2597 self,
2598 encoder: &mut fidl::encoding::Encoder<'_, D>,
2599 offset: usize,
2600 _depth: fidl::encoding::Depth,
2601 ) -> fidl::Result<()> {
2602 encoder.debug_check_bounds::<LegacyJoiningMakeJoinableRequest>(offset);
2603 unsafe {
2604 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2606 (buf_ptr as *mut LegacyJoiningMakeJoinableRequest)
2607 .write_unaligned((self as *const LegacyJoiningMakeJoinableRequest).read());
2608 let padding_ptr = buf_ptr.offset(8) as *mut u64;
2611 let padding_mask = 0xffffffffffff0000u64;
2612 padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
2613 }
2614 Ok(())
2615 }
2616 }
2617 unsafe impl<
2618 D: fidl::encoding::ResourceDialect,
2619 T0: fidl::encoding::Encode<i64, D>,
2620 T1: fidl::encoding::Encode<u16, D>,
2621 > fidl::encoding::Encode<LegacyJoiningMakeJoinableRequest, D> for (T0, T1)
2622 {
2623 #[inline]
2624 unsafe fn encode(
2625 self,
2626 encoder: &mut fidl::encoding::Encoder<'_, D>,
2627 offset: usize,
2628 depth: fidl::encoding::Depth,
2629 ) -> fidl::Result<()> {
2630 encoder.debug_check_bounds::<LegacyJoiningMakeJoinableRequest>(offset);
2631 unsafe {
2634 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
2635 (ptr as *mut u64).write_unaligned(0);
2636 }
2637 self.0.encode(encoder, offset + 0, depth)?;
2639 self.1.encode(encoder, offset + 8, depth)?;
2640 Ok(())
2641 }
2642 }
2643
2644 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2645 for LegacyJoiningMakeJoinableRequest
2646 {
2647 #[inline(always)]
2648 fn new_empty() -> Self {
2649 Self { duration: fidl::new_empty!(i64, D), port: fidl::new_empty!(u16, D) }
2650 }
2651
2652 #[inline]
2653 unsafe fn decode(
2654 &mut self,
2655 decoder: &mut fidl::encoding::Decoder<'_, D>,
2656 offset: usize,
2657 _depth: fidl::encoding::Depth,
2658 ) -> fidl::Result<()> {
2659 decoder.debug_check_bounds::<Self>(offset);
2660 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2661 let ptr = unsafe { buf_ptr.offset(8) };
2663 let padval = unsafe { (ptr as *const u64).read_unaligned() };
2664 let mask = 0xffffffffffff0000u64;
2665 let maskedval = padval & mask;
2666 if maskedval != 0 {
2667 return Err(fidl::Error::NonZeroPadding {
2668 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
2669 });
2670 }
2671 unsafe {
2673 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
2674 }
2675 Ok(())
2676 }
2677 }
2678
2679 impl fidl::encoding::ValueTypeMarker for ProvisioningMonitorWatchProgressResponse {
2680 type Borrowed<'a> = &'a Self;
2681 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2682 value
2683 }
2684 }
2685
2686 unsafe impl fidl::encoding::TypeMarker for ProvisioningMonitorWatchProgressResponse {
2687 type Owned = Self;
2688
2689 #[inline(always)]
2690 fn inline_align(_context: fidl::encoding::Context) -> usize {
2691 8
2692 }
2693
2694 #[inline(always)]
2695 fn inline_size(_context: fidl::encoding::Context) -> usize {
2696 16
2697 }
2698 }
2699
2700 unsafe impl<D: fidl::encoding::ResourceDialect>
2701 fidl::encoding::Encode<ProvisioningMonitorWatchProgressResponse, D>
2702 for &ProvisioningMonitorWatchProgressResponse
2703 {
2704 #[inline]
2705 unsafe fn encode(
2706 self,
2707 encoder: &mut fidl::encoding::Encoder<'_, D>,
2708 offset: usize,
2709 _depth: fidl::encoding::Depth,
2710 ) -> fidl::Result<()> {
2711 encoder.debug_check_bounds::<ProvisioningMonitorWatchProgressResponse>(offset);
2712 fidl::encoding::Encode::<ProvisioningMonitorWatchProgressResponse, D>::encode(
2714 (<ProvisioningProgress as fidl::encoding::ValueTypeMarker>::borrow(&self.progress),),
2715 encoder,
2716 offset,
2717 _depth,
2718 )
2719 }
2720 }
2721 unsafe impl<
2722 D: fidl::encoding::ResourceDialect,
2723 T0: fidl::encoding::Encode<ProvisioningProgress, D>,
2724 > fidl::encoding::Encode<ProvisioningMonitorWatchProgressResponse, D> for (T0,)
2725 {
2726 #[inline]
2727 unsafe fn encode(
2728 self,
2729 encoder: &mut fidl::encoding::Encoder<'_, D>,
2730 offset: usize,
2731 depth: fidl::encoding::Depth,
2732 ) -> fidl::Result<()> {
2733 encoder.debug_check_bounds::<ProvisioningMonitorWatchProgressResponse>(offset);
2734 self.0.encode(encoder, offset + 0, depth)?;
2738 Ok(())
2739 }
2740 }
2741
2742 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2743 for ProvisioningMonitorWatchProgressResponse
2744 {
2745 #[inline(always)]
2746 fn new_empty() -> Self {
2747 Self { progress: fidl::new_empty!(ProvisioningProgress, D) }
2748 }
2749
2750 #[inline]
2751 unsafe fn decode(
2752 &mut self,
2753 decoder: &mut fidl::encoding::Decoder<'_, D>,
2754 offset: usize,
2755 _depth: fidl::encoding::Depth,
2756 ) -> fidl::Result<()> {
2757 decoder.debug_check_bounds::<Self>(offset);
2758 fidl::decode!(
2760 ProvisioningProgress,
2761 D,
2762 &mut self.progress,
2763 decoder,
2764 offset + 0,
2765 _depth
2766 )?;
2767 Ok(())
2768 }
2769 }
2770
2771 impl fidl::encoding::ValueTypeMarker for TelemetryProviderGetTelemetryResponse {
2772 type Borrowed<'a> = &'a Self;
2773 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2774 value
2775 }
2776 }
2777
2778 unsafe impl fidl::encoding::TypeMarker for TelemetryProviderGetTelemetryResponse {
2779 type Owned = Self;
2780
2781 #[inline(always)]
2782 fn inline_align(_context: fidl::encoding::Context) -> usize {
2783 8
2784 }
2785
2786 #[inline(always)]
2787 fn inline_size(_context: fidl::encoding::Context) -> usize {
2788 16
2789 }
2790 }
2791
2792 unsafe impl<D: fidl::encoding::ResourceDialect>
2793 fidl::encoding::Encode<TelemetryProviderGetTelemetryResponse, D>
2794 for &TelemetryProviderGetTelemetryResponse
2795 {
2796 #[inline]
2797 unsafe fn encode(
2798 self,
2799 encoder: &mut fidl::encoding::Encoder<'_, D>,
2800 offset: usize,
2801 _depth: fidl::encoding::Depth,
2802 ) -> fidl::Result<()> {
2803 encoder.debug_check_bounds::<TelemetryProviderGetTelemetryResponse>(offset);
2804 fidl::encoding::Encode::<TelemetryProviderGetTelemetryResponse, D>::encode(
2806 (<Telemetry as fidl::encoding::ValueTypeMarker>::borrow(&self.telemetry),),
2807 encoder,
2808 offset,
2809 _depth,
2810 )
2811 }
2812 }
2813 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Telemetry, D>>
2814 fidl::encoding::Encode<TelemetryProviderGetTelemetryResponse, D> for (T0,)
2815 {
2816 #[inline]
2817 unsafe fn encode(
2818 self,
2819 encoder: &mut fidl::encoding::Encoder<'_, D>,
2820 offset: usize,
2821 depth: fidl::encoding::Depth,
2822 ) -> fidl::Result<()> {
2823 encoder.debug_check_bounds::<TelemetryProviderGetTelemetryResponse>(offset);
2824 self.0.encode(encoder, offset + 0, depth)?;
2828 Ok(())
2829 }
2830 }
2831
2832 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2833 for TelemetryProviderGetTelemetryResponse
2834 {
2835 #[inline(always)]
2836 fn new_empty() -> Self {
2837 Self { telemetry: fidl::new_empty!(Telemetry, D) }
2838 }
2839
2840 #[inline]
2841 unsafe fn decode(
2842 &mut self,
2843 decoder: &mut fidl::encoding::Decoder<'_, D>,
2844 offset: usize,
2845 _depth: fidl::encoding::Depth,
2846 ) -> fidl::Result<()> {
2847 decoder.debug_check_bounds::<Self>(offset);
2848 fidl::decode!(Telemetry, D, &mut self.telemetry, decoder, offset + 0, _depth)?;
2850 Ok(())
2851 }
2852 }
2853
2854 impl BeaconInfo {
2855 #[inline(always)]
2856 fn max_ordinal_present(&self) -> u64 {
2857 if let Some(_) = self.lqi {
2858 return 4;
2859 }
2860 if let Some(_) = self.rssi {
2861 return 3;
2862 }
2863 if let Some(_) = self.identity {
2864 return 2;
2865 }
2866 if let Some(_) = self.address {
2867 return 1;
2868 }
2869 0
2870 }
2871 }
2872
2873 impl fidl::encoding::ValueTypeMarker for BeaconInfo {
2874 type Borrowed<'a> = &'a Self;
2875 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2876 value
2877 }
2878 }
2879
2880 unsafe impl fidl::encoding::TypeMarker for BeaconInfo {
2881 type Owned = Self;
2882
2883 #[inline(always)]
2884 fn inline_align(_context: fidl::encoding::Context) -> usize {
2885 8
2886 }
2887
2888 #[inline(always)]
2889 fn inline_size(_context: fidl::encoding::Context) -> usize {
2890 16
2891 }
2892 }
2893
2894 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BeaconInfo, D>
2895 for &BeaconInfo
2896 {
2897 unsafe fn encode(
2898 self,
2899 encoder: &mut fidl::encoding::Encoder<'_, D>,
2900 offset: usize,
2901 mut depth: fidl::encoding::Depth,
2902 ) -> fidl::Result<()> {
2903 encoder.debug_check_bounds::<BeaconInfo>(offset);
2904 let max_ordinal: u64 = self.max_ordinal_present();
2906 encoder.write_num(max_ordinal, offset);
2907 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2908 if max_ordinal == 0 {
2910 return Ok(());
2911 }
2912 depth.increment()?;
2913 let envelope_size = 8;
2914 let bytes_len = max_ordinal as usize * envelope_size;
2915 #[allow(unused_variables)]
2916 let offset = encoder.out_of_line_offset(bytes_len);
2917 let mut _prev_end_offset: usize = 0;
2918 if 1 > max_ordinal {
2919 return Ok(());
2920 }
2921
2922 let cur_offset: usize = (1 - 1) * envelope_size;
2925
2926 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2928
2929 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan__common::MacAddress, D>(
2934 self.address.as_ref().map(<fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2935 encoder, offset + cur_offset, depth
2936 )?;
2937
2938 _prev_end_offset = cur_offset + envelope_size;
2939 if 2 > max_ordinal {
2940 return Ok(());
2941 }
2942
2943 let cur_offset: usize = (2 - 1) * envelope_size;
2946
2947 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2949
2950 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan_device__common::Identity, D>(
2955 self.identity.as_ref().map(<fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::ValueTypeMarker>::borrow),
2956 encoder, offset + cur_offset, depth
2957 )?;
2958
2959 _prev_end_offset = cur_offset + envelope_size;
2960 if 3 > max_ordinal {
2961 return Ok(());
2962 }
2963
2964 let cur_offset: usize = (3 - 1) * envelope_size;
2967
2968 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2970
2971 fidl::encoding::encode_in_envelope_optional::<i8, D>(
2976 self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
2977 encoder,
2978 offset + cur_offset,
2979 depth,
2980 )?;
2981
2982 _prev_end_offset = cur_offset + envelope_size;
2983 if 4 > max_ordinal {
2984 return Ok(());
2985 }
2986
2987 let cur_offset: usize = (4 - 1) * envelope_size;
2990
2991 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2993
2994 fidl::encoding::encode_in_envelope_optional::<u8, D>(
2999 self.lqi.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
3000 encoder,
3001 offset + cur_offset,
3002 depth,
3003 )?;
3004
3005 _prev_end_offset = cur_offset + envelope_size;
3006
3007 Ok(())
3008 }
3009 }
3010
3011 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BeaconInfo {
3012 #[inline(always)]
3013 fn new_empty() -> Self {
3014 Self::default()
3015 }
3016
3017 unsafe fn decode(
3018 &mut self,
3019 decoder: &mut fidl::encoding::Decoder<'_, D>,
3020 offset: usize,
3021 mut depth: fidl::encoding::Depth,
3022 ) -> fidl::Result<()> {
3023 decoder.debug_check_bounds::<Self>(offset);
3024 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3025 None => return Err(fidl::Error::NotNullable),
3026 Some(len) => len,
3027 };
3028 if len == 0 {
3030 return Ok(());
3031 };
3032 depth.increment()?;
3033 let envelope_size = 8;
3034 let bytes_len = len * envelope_size;
3035 let offset = decoder.out_of_line_offset(bytes_len)?;
3036 let mut _next_ordinal_to_read = 0;
3038 let mut next_offset = offset;
3039 let end_offset = offset + bytes_len;
3040 _next_ordinal_to_read += 1;
3041 if next_offset >= end_offset {
3042 return Ok(());
3043 }
3044
3045 while _next_ordinal_to_read < 1 {
3047 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3048 _next_ordinal_to_read += 1;
3049 next_offset += envelope_size;
3050 }
3051
3052 let next_out_of_line = decoder.next_out_of_line();
3053 let handles_before = decoder.remaining_handles();
3054 if let Some((inlined, num_bytes, num_handles)) =
3055 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3056 {
3057 let member_inline_size = <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3058 if inlined != (member_inline_size <= 4) {
3059 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3060 }
3061 let inner_offset;
3062 let mut inner_depth = depth.clone();
3063 if inlined {
3064 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3065 inner_offset = next_offset;
3066 } else {
3067 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3068 inner_depth.increment()?;
3069 }
3070 let val_ref = self.address.get_or_insert_with(|| {
3071 fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D)
3072 });
3073 fidl::decode!(
3074 fidl_fuchsia_lowpan__common::MacAddress,
3075 D,
3076 val_ref,
3077 decoder,
3078 inner_offset,
3079 inner_depth
3080 )?;
3081 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3082 {
3083 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3084 }
3085 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3086 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3087 }
3088 }
3089
3090 next_offset += envelope_size;
3091 _next_ordinal_to_read += 1;
3092 if next_offset >= end_offset {
3093 return Ok(());
3094 }
3095
3096 while _next_ordinal_to_read < 2 {
3098 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3099 _next_ordinal_to_read += 1;
3100 next_offset += envelope_size;
3101 }
3102
3103 let next_out_of_line = decoder.next_out_of_line();
3104 let handles_before = decoder.remaining_handles();
3105 if let Some((inlined, num_bytes, num_handles)) =
3106 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3107 {
3108 let member_inline_size = <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3109 if inlined != (member_inline_size <= 4) {
3110 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3111 }
3112 let inner_offset;
3113 let mut inner_depth = depth.clone();
3114 if inlined {
3115 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3116 inner_offset = next_offset;
3117 } else {
3118 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3119 inner_depth.increment()?;
3120 }
3121 let val_ref = self.identity.get_or_insert_with(|| {
3122 fidl::new_empty!(fidl_fuchsia_lowpan_device__common::Identity, D)
3123 });
3124 fidl::decode!(
3125 fidl_fuchsia_lowpan_device__common::Identity,
3126 D,
3127 val_ref,
3128 decoder,
3129 inner_offset,
3130 inner_depth
3131 )?;
3132 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3133 {
3134 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3135 }
3136 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3137 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3138 }
3139 }
3140
3141 next_offset += envelope_size;
3142 _next_ordinal_to_read += 1;
3143 if next_offset >= end_offset {
3144 return Ok(());
3145 }
3146
3147 while _next_ordinal_to_read < 3 {
3149 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3150 _next_ordinal_to_read += 1;
3151 next_offset += envelope_size;
3152 }
3153
3154 let next_out_of_line = decoder.next_out_of_line();
3155 let handles_before = decoder.remaining_handles();
3156 if let Some((inlined, num_bytes, num_handles)) =
3157 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3158 {
3159 let member_inline_size =
3160 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3161 if inlined != (member_inline_size <= 4) {
3162 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3163 }
3164 let inner_offset;
3165 let mut inner_depth = depth.clone();
3166 if inlined {
3167 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3168 inner_offset = next_offset;
3169 } else {
3170 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3171 inner_depth.increment()?;
3172 }
3173 let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
3174 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
3175 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3176 {
3177 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3178 }
3179 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3180 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3181 }
3182 }
3183
3184 next_offset += envelope_size;
3185 _next_ordinal_to_read += 1;
3186 if next_offset >= end_offset {
3187 return Ok(());
3188 }
3189
3190 while _next_ordinal_to_read < 4 {
3192 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3193 _next_ordinal_to_read += 1;
3194 next_offset += envelope_size;
3195 }
3196
3197 let next_out_of_line = decoder.next_out_of_line();
3198 let handles_before = decoder.remaining_handles();
3199 if let Some((inlined, num_bytes, num_handles)) =
3200 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3201 {
3202 let member_inline_size =
3203 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3204 if inlined != (member_inline_size <= 4) {
3205 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3206 }
3207 let inner_offset;
3208 let mut inner_depth = depth.clone();
3209 if inlined {
3210 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3211 inner_offset = next_offset;
3212 } else {
3213 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3214 inner_depth.increment()?;
3215 }
3216 let val_ref = self.lqi.get_or_insert_with(|| fidl::new_empty!(u8, D));
3217 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3218 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3219 {
3220 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3221 }
3222 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3223 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3224 }
3225 }
3226
3227 next_offset += envelope_size;
3228
3229 while next_offset < end_offset {
3231 _next_ordinal_to_read += 1;
3232 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3233 next_offset += envelope_size;
3234 }
3235
3236 Ok(())
3237 }
3238 }
3239
3240 impl BorderRoutingCounters {
3241 #[inline(always)]
3242 fn max_ordinal_present(&self) -> u64 {
3243 if let Some(_) = self.outbound_internet_bytes {
3244 return 18;
3245 }
3246 if let Some(_) = self.outbound_internet_packets {
3247 return 17;
3248 }
3249 if let Some(_) = self.inbound_internet_bytes {
3250 return 16;
3251 }
3252 if let Some(_) = self.inbound_internet_packets {
3253 return 15;
3254 }
3255 if let Some(_) = self.rs_tx_failure {
3256 return 14;
3257 }
3258 if let Some(_) = self.rs_tx_success {
3259 return 13;
3260 }
3261 if let Some(_) = self.rs_rx {
3262 return 12;
3263 }
3264 if let Some(_) = self.ra_tx_failure {
3265 return 11;
3266 }
3267 if let Some(_) = self.ra_tx_success {
3268 return 10;
3269 }
3270 if let Some(_) = self.ra_rx {
3271 return 9;
3272 }
3273 if let Some(_) = self.outbound_multicast_bytes {
3274 return 8;
3275 }
3276 if let Some(_) = self.outbound_multicast_packets {
3277 return 7;
3278 }
3279 if let Some(_) = self.outbound_unicast_bytes {
3280 return 6;
3281 }
3282 if let Some(_) = self.outbound_unicast_packets {
3283 return 5;
3284 }
3285 if let Some(_) = self.inbound_multicast_bytes {
3286 return 4;
3287 }
3288 if let Some(_) = self.inbound_multicast_packets {
3289 return 3;
3290 }
3291 if let Some(_) = self.inbound_unicast_bytes {
3292 return 2;
3293 }
3294 if let Some(_) = self.inbound_unicast_packets {
3295 return 1;
3296 }
3297 0
3298 }
3299 }
3300
3301 impl fidl::encoding::ValueTypeMarker for BorderRoutingCounters {
3302 type Borrowed<'a> = &'a Self;
3303 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3304 value
3305 }
3306 }
3307
3308 unsafe impl fidl::encoding::TypeMarker for BorderRoutingCounters {
3309 type Owned = Self;
3310
3311 #[inline(always)]
3312 fn inline_align(_context: fidl::encoding::Context) -> usize {
3313 8
3314 }
3315
3316 #[inline(always)]
3317 fn inline_size(_context: fidl::encoding::Context) -> usize {
3318 16
3319 }
3320 }
3321
3322 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BorderRoutingCounters, D>
3323 for &BorderRoutingCounters
3324 {
3325 unsafe fn encode(
3326 self,
3327 encoder: &mut fidl::encoding::Encoder<'_, D>,
3328 offset: usize,
3329 mut depth: fidl::encoding::Depth,
3330 ) -> fidl::Result<()> {
3331 encoder.debug_check_bounds::<BorderRoutingCounters>(offset);
3332 let max_ordinal: u64 = self.max_ordinal_present();
3334 encoder.write_num(max_ordinal, offset);
3335 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3336 if max_ordinal == 0 {
3338 return Ok(());
3339 }
3340 depth.increment()?;
3341 let envelope_size = 8;
3342 let bytes_len = max_ordinal as usize * envelope_size;
3343 #[allow(unused_variables)]
3344 let offset = encoder.out_of_line_offset(bytes_len);
3345 let mut _prev_end_offset: usize = 0;
3346 if 1 > max_ordinal {
3347 return Ok(());
3348 }
3349
3350 let cur_offset: usize = (1 - 1) * envelope_size;
3353
3354 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3356
3357 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3362 self.inbound_unicast_packets
3363 .as_ref()
3364 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3365 encoder,
3366 offset + cur_offset,
3367 depth,
3368 )?;
3369
3370 _prev_end_offset = cur_offset + envelope_size;
3371 if 2 > max_ordinal {
3372 return Ok(());
3373 }
3374
3375 let cur_offset: usize = (2 - 1) * envelope_size;
3378
3379 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3381
3382 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3387 self.inbound_unicast_bytes
3388 .as_ref()
3389 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3390 encoder,
3391 offset + cur_offset,
3392 depth,
3393 )?;
3394
3395 _prev_end_offset = cur_offset + envelope_size;
3396 if 3 > max_ordinal {
3397 return Ok(());
3398 }
3399
3400 let cur_offset: usize = (3 - 1) * envelope_size;
3403
3404 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3406
3407 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3412 self.inbound_multicast_packets
3413 .as_ref()
3414 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3415 encoder,
3416 offset + cur_offset,
3417 depth,
3418 )?;
3419
3420 _prev_end_offset = cur_offset + envelope_size;
3421 if 4 > max_ordinal {
3422 return Ok(());
3423 }
3424
3425 let cur_offset: usize = (4 - 1) * envelope_size;
3428
3429 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3431
3432 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3437 self.inbound_multicast_bytes
3438 .as_ref()
3439 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3440 encoder,
3441 offset + cur_offset,
3442 depth,
3443 )?;
3444
3445 _prev_end_offset = cur_offset + envelope_size;
3446 if 5 > max_ordinal {
3447 return Ok(());
3448 }
3449
3450 let cur_offset: usize = (5 - 1) * envelope_size;
3453
3454 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3456
3457 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3462 self.outbound_unicast_packets
3463 .as_ref()
3464 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3465 encoder,
3466 offset + cur_offset,
3467 depth,
3468 )?;
3469
3470 _prev_end_offset = cur_offset + envelope_size;
3471 if 6 > max_ordinal {
3472 return Ok(());
3473 }
3474
3475 let cur_offset: usize = (6 - 1) * envelope_size;
3478
3479 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3481
3482 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3487 self.outbound_unicast_bytes
3488 .as_ref()
3489 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3490 encoder,
3491 offset + cur_offset,
3492 depth,
3493 )?;
3494
3495 _prev_end_offset = cur_offset + envelope_size;
3496 if 7 > max_ordinal {
3497 return Ok(());
3498 }
3499
3500 let cur_offset: usize = (7 - 1) * envelope_size;
3503
3504 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3506
3507 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3512 self.outbound_multicast_packets
3513 .as_ref()
3514 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3515 encoder,
3516 offset + cur_offset,
3517 depth,
3518 )?;
3519
3520 _prev_end_offset = cur_offset + envelope_size;
3521 if 8 > max_ordinal {
3522 return Ok(());
3523 }
3524
3525 let cur_offset: usize = (8 - 1) * envelope_size;
3528
3529 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3531
3532 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3537 self.outbound_multicast_bytes
3538 .as_ref()
3539 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3540 encoder,
3541 offset + cur_offset,
3542 depth,
3543 )?;
3544
3545 _prev_end_offset = cur_offset + envelope_size;
3546 if 9 > max_ordinal {
3547 return Ok(());
3548 }
3549
3550 let cur_offset: usize = (9 - 1) * envelope_size;
3553
3554 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3556
3557 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3562 self.ra_rx.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3563 encoder,
3564 offset + cur_offset,
3565 depth,
3566 )?;
3567
3568 _prev_end_offset = cur_offset + envelope_size;
3569 if 10 > max_ordinal {
3570 return Ok(());
3571 }
3572
3573 let cur_offset: usize = (10 - 1) * envelope_size;
3576
3577 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3579
3580 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3585 self.ra_tx_success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3586 encoder,
3587 offset + cur_offset,
3588 depth,
3589 )?;
3590
3591 _prev_end_offset = cur_offset + envelope_size;
3592 if 11 > max_ordinal {
3593 return Ok(());
3594 }
3595
3596 let cur_offset: usize = (11 - 1) * envelope_size;
3599
3600 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3602
3603 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3608 self.ra_tx_failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3609 encoder,
3610 offset + cur_offset,
3611 depth,
3612 )?;
3613
3614 _prev_end_offset = cur_offset + envelope_size;
3615 if 12 > max_ordinal {
3616 return Ok(());
3617 }
3618
3619 let cur_offset: usize = (12 - 1) * envelope_size;
3622
3623 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3625
3626 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3631 self.rs_rx.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3632 encoder,
3633 offset + cur_offset,
3634 depth,
3635 )?;
3636
3637 _prev_end_offset = cur_offset + envelope_size;
3638 if 13 > max_ordinal {
3639 return Ok(());
3640 }
3641
3642 let cur_offset: usize = (13 - 1) * envelope_size;
3645
3646 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3648
3649 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3654 self.rs_tx_success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3655 encoder,
3656 offset + cur_offset,
3657 depth,
3658 )?;
3659
3660 _prev_end_offset = cur_offset + envelope_size;
3661 if 14 > max_ordinal {
3662 return Ok(());
3663 }
3664
3665 let cur_offset: usize = (14 - 1) * envelope_size;
3668
3669 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3671
3672 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3677 self.rs_tx_failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3678 encoder,
3679 offset + cur_offset,
3680 depth,
3681 )?;
3682
3683 _prev_end_offset = cur_offset + envelope_size;
3684 if 15 > max_ordinal {
3685 return Ok(());
3686 }
3687
3688 let cur_offset: usize = (15 - 1) * envelope_size;
3691
3692 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3694
3695 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3700 self.inbound_internet_packets
3701 .as_ref()
3702 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3703 encoder,
3704 offset + cur_offset,
3705 depth,
3706 )?;
3707
3708 _prev_end_offset = cur_offset + envelope_size;
3709 if 16 > max_ordinal {
3710 return Ok(());
3711 }
3712
3713 let cur_offset: usize = (16 - 1) * envelope_size;
3716
3717 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3719
3720 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3725 self.inbound_internet_bytes
3726 .as_ref()
3727 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3728 encoder,
3729 offset + cur_offset,
3730 depth,
3731 )?;
3732
3733 _prev_end_offset = cur_offset + envelope_size;
3734 if 17 > max_ordinal {
3735 return Ok(());
3736 }
3737
3738 let cur_offset: usize = (17 - 1) * envelope_size;
3741
3742 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3744
3745 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3750 self.outbound_internet_packets
3751 .as_ref()
3752 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3753 encoder,
3754 offset + cur_offset,
3755 depth,
3756 )?;
3757
3758 _prev_end_offset = cur_offset + envelope_size;
3759 if 18 > max_ordinal {
3760 return Ok(());
3761 }
3762
3763 let cur_offset: usize = (18 - 1) * envelope_size;
3766
3767 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3769
3770 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3775 self.outbound_internet_bytes
3776 .as_ref()
3777 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3778 encoder,
3779 offset + cur_offset,
3780 depth,
3781 )?;
3782
3783 _prev_end_offset = cur_offset + envelope_size;
3784
3785 Ok(())
3786 }
3787 }
3788
3789 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BorderRoutingCounters {
3790 #[inline(always)]
3791 fn new_empty() -> Self {
3792 Self::default()
3793 }
3794
3795 unsafe fn decode(
3796 &mut self,
3797 decoder: &mut fidl::encoding::Decoder<'_, D>,
3798 offset: usize,
3799 mut depth: fidl::encoding::Depth,
3800 ) -> fidl::Result<()> {
3801 decoder.debug_check_bounds::<Self>(offset);
3802 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3803 None => return Err(fidl::Error::NotNullable),
3804 Some(len) => len,
3805 };
3806 if len == 0 {
3808 return Ok(());
3809 };
3810 depth.increment()?;
3811 let envelope_size = 8;
3812 let bytes_len = len * envelope_size;
3813 let offset = decoder.out_of_line_offset(bytes_len)?;
3814 let mut _next_ordinal_to_read = 0;
3816 let mut next_offset = offset;
3817 let end_offset = offset + bytes_len;
3818 _next_ordinal_to_read += 1;
3819 if next_offset >= end_offset {
3820 return Ok(());
3821 }
3822
3823 while _next_ordinal_to_read < 1 {
3825 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3826 _next_ordinal_to_read += 1;
3827 next_offset += envelope_size;
3828 }
3829
3830 let next_out_of_line = decoder.next_out_of_line();
3831 let handles_before = decoder.remaining_handles();
3832 if let Some((inlined, num_bytes, num_handles)) =
3833 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3834 {
3835 let member_inline_size =
3836 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3837 if inlined != (member_inline_size <= 4) {
3838 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3839 }
3840 let inner_offset;
3841 let mut inner_depth = depth.clone();
3842 if inlined {
3843 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3844 inner_offset = next_offset;
3845 } else {
3846 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3847 inner_depth.increment()?;
3848 }
3849 let val_ref =
3850 self.inbound_unicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
3851 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3852 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3853 {
3854 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3855 }
3856 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3857 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3858 }
3859 }
3860
3861 next_offset += envelope_size;
3862 _next_ordinal_to_read += 1;
3863 if next_offset >= end_offset {
3864 return Ok(());
3865 }
3866
3867 while _next_ordinal_to_read < 2 {
3869 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3870 _next_ordinal_to_read += 1;
3871 next_offset += envelope_size;
3872 }
3873
3874 let next_out_of_line = decoder.next_out_of_line();
3875 let handles_before = decoder.remaining_handles();
3876 if let Some((inlined, num_bytes, num_handles)) =
3877 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3878 {
3879 let member_inline_size =
3880 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3881 if inlined != (member_inline_size <= 4) {
3882 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3883 }
3884 let inner_offset;
3885 let mut inner_depth = depth.clone();
3886 if inlined {
3887 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3888 inner_offset = next_offset;
3889 } else {
3890 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3891 inner_depth.increment()?;
3892 }
3893 let val_ref =
3894 self.inbound_unicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3895 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3896 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3897 {
3898 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3899 }
3900 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3901 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3902 }
3903 }
3904
3905 next_offset += envelope_size;
3906 _next_ordinal_to_read += 1;
3907 if next_offset >= end_offset {
3908 return Ok(());
3909 }
3910
3911 while _next_ordinal_to_read < 3 {
3913 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3914 _next_ordinal_to_read += 1;
3915 next_offset += envelope_size;
3916 }
3917
3918 let next_out_of_line = decoder.next_out_of_line();
3919 let handles_before = decoder.remaining_handles();
3920 if let Some((inlined, num_bytes, num_handles)) =
3921 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3922 {
3923 let member_inline_size =
3924 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3925 if inlined != (member_inline_size <= 4) {
3926 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3927 }
3928 let inner_offset;
3929 let mut inner_depth = depth.clone();
3930 if inlined {
3931 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3932 inner_offset = next_offset;
3933 } else {
3934 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3935 inner_depth.increment()?;
3936 }
3937 let val_ref =
3938 self.inbound_multicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
3939 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3940 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3941 {
3942 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3943 }
3944 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3945 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3946 }
3947 }
3948
3949 next_offset += envelope_size;
3950 _next_ordinal_to_read += 1;
3951 if next_offset >= end_offset {
3952 return Ok(());
3953 }
3954
3955 while _next_ordinal_to_read < 4 {
3957 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3958 _next_ordinal_to_read += 1;
3959 next_offset += envelope_size;
3960 }
3961
3962 let next_out_of_line = decoder.next_out_of_line();
3963 let handles_before = decoder.remaining_handles();
3964 if let Some((inlined, num_bytes, num_handles)) =
3965 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3966 {
3967 let member_inline_size =
3968 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3969 if inlined != (member_inline_size <= 4) {
3970 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3971 }
3972 let inner_offset;
3973 let mut inner_depth = depth.clone();
3974 if inlined {
3975 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3976 inner_offset = next_offset;
3977 } else {
3978 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3979 inner_depth.increment()?;
3980 }
3981 let val_ref =
3982 self.inbound_multicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3983 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3984 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3985 {
3986 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3987 }
3988 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3989 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3990 }
3991 }
3992
3993 next_offset += envelope_size;
3994 _next_ordinal_to_read += 1;
3995 if next_offset >= end_offset {
3996 return Ok(());
3997 }
3998
3999 while _next_ordinal_to_read < 5 {
4001 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4002 _next_ordinal_to_read += 1;
4003 next_offset += envelope_size;
4004 }
4005
4006 let next_out_of_line = decoder.next_out_of_line();
4007 let handles_before = decoder.remaining_handles();
4008 if let Some((inlined, num_bytes, num_handles)) =
4009 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4010 {
4011 let member_inline_size =
4012 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4013 if inlined != (member_inline_size <= 4) {
4014 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4015 }
4016 let inner_offset;
4017 let mut inner_depth = depth.clone();
4018 if inlined {
4019 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4020 inner_offset = next_offset;
4021 } else {
4022 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4023 inner_depth.increment()?;
4024 }
4025 let val_ref =
4026 self.outbound_unicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4027 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4028 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4029 {
4030 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4031 }
4032 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4033 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4034 }
4035 }
4036
4037 next_offset += envelope_size;
4038 _next_ordinal_to_read += 1;
4039 if next_offset >= end_offset {
4040 return Ok(());
4041 }
4042
4043 while _next_ordinal_to_read < 6 {
4045 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4046 _next_ordinal_to_read += 1;
4047 next_offset += envelope_size;
4048 }
4049
4050 let next_out_of_line = decoder.next_out_of_line();
4051 let handles_before = decoder.remaining_handles();
4052 if let Some((inlined, num_bytes, num_handles)) =
4053 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4054 {
4055 let member_inline_size =
4056 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4057 if inlined != (member_inline_size <= 4) {
4058 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4059 }
4060 let inner_offset;
4061 let mut inner_depth = depth.clone();
4062 if inlined {
4063 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4064 inner_offset = next_offset;
4065 } else {
4066 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4067 inner_depth.increment()?;
4068 }
4069 let val_ref =
4070 self.outbound_unicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4071 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4072 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4073 {
4074 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4075 }
4076 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4077 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4078 }
4079 }
4080
4081 next_offset += envelope_size;
4082 _next_ordinal_to_read += 1;
4083 if next_offset >= end_offset {
4084 return Ok(());
4085 }
4086
4087 while _next_ordinal_to_read < 7 {
4089 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4090 _next_ordinal_to_read += 1;
4091 next_offset += envelope_size;
4092 }
4093
4094 let next_out_of_line = decoder.next_out_of_line();
4095 let handles_before = decoder.remaining_handles();
4096 if let Some((inlined, num_bytes, num_handles)) =
4097 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4098 {
4099 let member_inline_size =
4100 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4101 if inlined != (member_inline_size <= 4) {
4102 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4103 }
4104 let inner_offset;
4105 let mut inner_depth = depth.clone();
4106 if inlined {
4107 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4108 inner_offset = next_offset;
4109 } else {
4110 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4111 inner_depth.increment()?;
4112 }
4113 let val_ref =
4114 self.outbound_multicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4115 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4116 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4117 {
4118 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4119 }
4120 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4121 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4122 }
4123 }
4124
4125 next_offset += envelope_size;
4126 _next_ordinal_to_read += 1;
4127 if next_offset >= end_offset {
4128 return Ok(());
4129 }
4130
4131 while _next_ordinal_to_read < 8 {
4133 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4134 _next_ordinal_to_read += 1;
4135 next_offset += envelope_size;
4136 }
4137
4138 let next_out_of_line = decoder.next_out_of_line();
4139 let handles_before = decoder.remaining_handles();
4140 if let Some((inlined, num_bytes, num_handles)) =
4141 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4142 {
4143 let member_inline_size =
4144 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4145 if inlined != (member_inline_size <= 4) {
4146 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4147 }
4148 let inner_offset;
4149 let mut inner_depth = depth.clone();
4150 if inlined {
4151 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4152 inner_offset = next_offset;
4153 } else {
4154 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4155 inner_depth.increment()?;
4156 }
4157 let val_ref =
4158 self.outbound_multicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4159 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4160 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4161 {
4162 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4163 }
4164 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4165 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4166 }
4167 }
4168
4169 next_offset += envelope_size;
4170 _next_ordinal_to_read += 1;
4171 if next_offset >= end_offset {
4172 return Ok(());
4173 }
4174
4175 while _next_ordinal_to_read < 9 {
4177 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4178 _next_ordinal_to_read += 1;
4179 next_offset += envelope_size;
4180 }
4181
4182 let next_out_of_line = decoder.next_out_of_line();
4183 let handles_before = decoder.remaining_handles();
4184 if let Some((inlined, num_bytes, num_handles)) =
4185 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4186 {
4187 let member_inline_size =
4188 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4189 if inlined != (member_inline_size <= 4) {
4190 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4191 }
4192 let inner_offset;
4193 let mut inner_depth = depth.clone();
4194 if inlined {
4195 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4196 inner_offset = next_offset;
4197 } else {
4198 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4199 inner_depth.increment()?;
4200 }
4201 let val_ref = self.ra_rx.get_or_insert_with(|| fidl::new_empty!(u32, D));
4202 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4203 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4204 {
4205 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4206 }
4207 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4208 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4209 }
4210 }
4211
4212 next_offset += envelope_size;
4213 _next_ordinal_to_read += 1;
4214 if next_offset >= end_offset {
4215 return Ok(());
4216 }
4217
4218 while _next_ordinal_to_read < 10 {
4220 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4221 _next_ordinal_to_read += 1;
4222 next_offset += envelope_size;
4223 }
4224
4225 let next_out_of_line = decoder.next_out_of_line();
4226 let handles_before = decoder.remaining_handles();
4227 if let Some((inlined, num_bytes, num_handles)) =
4228 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4229 {
4230 let member_inline_size =
4231 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4232 if inlined != (member_inline_size <= 4) {
4233 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4234 }
4235 let inner_offset;
4236 let mut inner_depth = depth.clone();
4237 if inlined {
4238 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4239 inner_offset = next_offset;
4240 } else {
4241 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4242 inner_depth.increment()?;
4243 }
4244 let val_ref = self.ra_tx_success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4245 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4246 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4247 {
4248 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4249 }
4250 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4251 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4252 }
4253 }
4254
4255 next_offset += envelope_size;
4256 _next_ordinal_to_read += 1;
4257 if next_offset >= end_offset {
4258 return Ok(());
4259 }
4260
4261 while _next_ordinal_to_read < 11 {
4263 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4264 _next_ordinal_to_read += 1;
4265 next_offset += envelope_size;
4266 }
4267
4268 let next_out_of_line = decoder.next_out_of_line();
4269 let handles_before = decoder.remaining_handles();
4270 if let Some((inlined, num_bytes, num_handles)) =
4271 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4272 {
4273 let member_inline_size =
4274 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4275 if inlined != (member_inline_size <= 4) {
4276 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4277 }
4278 let inner_offset;
4279 let mut inner_depth = depth.clone();
4280 if inlined {
4281 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4282 inner_offset = next_offset;
4283 } else {
4284 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4285 inner_depth.increment()?;
4286 }
4287 let val_ref = self.ra_tx_failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4288 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4289 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4290 {
4291 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4292 }
4293 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4294 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4295 }
4296 }
4297
4298 next_offset += envelope_size;
4299 _next_ordinal_to_read += 1;
4300 if next_offset >= end_offset {
4301 return Ok(());
4302 }
4303
4304 while _next_ordinal_to_read < 12 {
4306 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4307 _next_ordinal_to_read += 1;
4308 next_offset += envelope_size;
4309 }
4310
4311 let next_out_of_line = decoder.next_out_of_line();
4312 let handles_before = decoder.remaining_handles();
4313 if let Some((inlined, num_bytes, num_handles)) =
4314 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4315 {
4316 let member_inline_size =
4317 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4318 if inlined != (member_inline_size <= 4) {
4319 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4320 }
4321 let inner_offset;
4322 let mut inner_depth = depth.clone();
4323 if inlined {
4324 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4325 inner_offset = next_offset;
4326 } else {
4327 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4328 inner_depth.increment()?;
4329 }
4330 let val_ref = self.rs_rx.get_or_insert_with(|| fidl::new_empty!(u32, D));
4331 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4332 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4333 {
4334 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4335 }
4336 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4337 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4338 }
4339 }
4340
4341 next_offset += envelope_size;
4342 _next_ordinal_to_read += 1;
4343 if next_offset >= end_offset {
4344 return Ok(());
4345 }
4346
4347 while _next_ordinal_to_read < 13 {
4349 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4350 _next_ordinal_to_read += 1;
4351 next_offset += envelope_size;
4352 }
4353
4354 let next_out_of_line = decoder.next_out_of_line();
4355 let handles_before = decoder.remaining_handles();
4356 if let Some((inlined, num_bytes, num_handles)) =
4357 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4358 {
4359 let member_inline_size =
4360 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4361 if inlined != (member_inline_size <= 4) {
4362 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4363 }
4364 let inner_offset;
4365 let mut inner_depth = depth.clone();
4366 if inlined {
4367 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4368 inner_offset = next_offset;
4369 } else {
4370 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4371 inner_depth.increment()?;
4372 }
4373 let val_ref = self.rs_tx_success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4374 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4375 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4376 {
4377 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4378 }
4379 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4380 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4381 }
4382 }
4383
4384 next_offset += envelope_size;
4385 _next_ordinal_to_read += 1;
4386 if next_offset >= end_offset {
4387 return Ok(());
4388 }
4389
4390 while _next_ordinal_to_read < 14 {
4392 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4393 _next_ordinal_to_read += 1;
4394 next_offset += envelope_size;
4395 }
4396
4397 let next_out_of_line = decoder.next_out_of_line();
4398 let handles_before = decoder.remaining_handles();
4399 if let Some((inlined, num_bytes, num_handles)) =
4400 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4401 {
4402 let member_inline_size =
4403 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4404 if inlined != (member_inline_size <= 4) {
4405 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4406 }
4407 let inner_offset;
4408 let mut inner_depth = depth.clone();
4409 if inlined {
4410 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4411 inner_offset = next_offset;
4412 } else {
4413 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4414 inner_depth.increment()?;
4415 }
4416 let val_ref = self.rs_tx_failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4417 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4418 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4419 {
4420 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4421 }
4422 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4423 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4424 }
4425 }
4426
4427 next_offset += envelope_size;
4428 _next_ordinal_to_read += 1;
4429 if next_offset >= end_offset {
4430 return Ok(());
4431 }
4432
4433 while _next_ordinal_to_read < 15 {
4435 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4436 _next_ordinal_to_read += 1;
4437 next_offset += envelope_size;
4438 }
4439
4440 let next_out_of_line = decoder.next_out_of_line();
4441 let handles_before = decoder.remaining_handles();
4442 if let Some((inlined, num_bytes, num_handles)) =
4443 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4444 {
4445 let member_inline_size =
4446 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4447 if inlined != (member_inline_size <= 4) {
4448 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4449 }
4450 let inner_offset;
4451 let mut inner_depth = depth.clone();
4452 if inlined {
4453 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4454 inner_offset = next_offset;
4455 } else {
4456 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4457 inner_depth.increment()?;
4458 }
4459 let val_ref =
4460 self.inbound_internet_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4461 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4462 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4463 {
4464 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4465 }
4466 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4467 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4468 }
4469 }
4470
4471 next_offset += envelope_size;
4472 _next_ordinal_to_read += 1;
4473 if next_offset >= end_offset {
4474 return Ok(());
4475 }
4476
4477 while _next_ordinal_to_read < 16 {
4479 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4480 _next_ordinal_to_read += 1;
4481 next_offset += envelope_size;
4482 }
4483
4484 let next_out_of_line = decoder.next_out_of_line();
4485 let handles_before = decoder.remaining_handles();
4486 if let Some((inlined, num_bytes, num_handles)) =
4487 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4488 {
4489 let member_inline_size =
4490 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4491 if inlined != (member_inline_size <= 4) {
4492 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4493 }
4494 let inner_offset;
4495 let mut inner_depth = depth.clone();
4496 if inlined {
4497 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4498 inner_offset = next_offset;
4499 } else {
4500 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4501 inner_depth.increment()?;
4502 }
4503 let val_ref =
4504 self.inbound_internet_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4505 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4506 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4507 {
4508 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4509 }
4510 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4511 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4512 }
4513 }
4514
4515 next_offset += envelope_size;
4516 _next_ordinal_to_read += 1;
4517 if next_offset >= end_offset {
4518 return Ok(());
4519 }
4520
4521 while _next_ordinal_to_read < 17 {
4523 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4524 _next_ordinal_to_read += 1;
4525 next_offset += envelope_size;
4526 }
4527
4528 let next_out_of_line = decoder.next_out_of_line();
4529 let handles_before = decoder.remaining_handles();
4530 if let Some((inlined, num_bytes, num_handles)) =
4531 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4532 {
4533 let member_inline_size =
4534 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4535 if inlined != (member_inline_size <= 4) {
4536 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4537 }
4538 let inner_offset;
4539 let mut inner_depth = depth.clone();
4540 if inlined {
4541 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4542 inner_offset = next_offset;
4543 } else {
4544 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4545 inner_depth.increment()?;
4546 }
4547 let val_ref =
4548 self.outbound_internet_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4549 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4550 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4551 {
4552 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4553 }
4554 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4555 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4556 }
4557 }
4558
4559 next_offset += envelope_size;
4560 _next_ordinal_to_read += 1;
4561 if next_offset >= end_offset {
4562 return Ok(());
4563 }
4564
4565 while _next_ordinal_to_read < 18 {
4567 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4568 _next_ordinal_to_read += 1;
4569 next_offset += envelope_size;
4570 }
4571
4572 let next_out_of_line = decoder.next_out_of_line();
4573 let handles_before = decoder.remaining_handles();
4574 if let Some((inlined, num_bytes, num_handles)) =
4575 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4576 {
4577 let member_inline_size =
4578 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4579 if inlined != (member_inline_size <= 4) {
4580 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4581 }
4582 let inner_offset;
4583 let mut inner_depth = depth.clone();
4584 if inlined {
4585 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4586 inner_offset = next_offset;
4587 } else {
4588 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4589 inner_depth.increment()?;
4590 }
4591 let val_ref =
4592 self.outbound_internet_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4593 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4594 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4595 {
4596 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4597 }
4598 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4599 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4600 }
4601 }
4602
4603 next_offset += envelope_size;
4604
4605 while next_offset < end_offset {
4607 _next_ordinal_to_read += 1;
4608 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4609 next_offset += envelope_size;
4610 }
4611
4612 Ok(())
4613 }
4614 }
4615
4616 impl BorderRoutingNat64State {
4617 #[inline(always)]
4618 fn max_ordinal_present(&self) -> u64 {
4619 if let Some(_) = self.translator_state {
4620 return 2;
4621 }
4622 if let Some(_) = self.prefix_manager_state {
4623 return 1;
4624 }
4625 0
4626 }
4627 }
4628
4629 impl fidl::encoding::ValueTypeMarker for BorderRoutingNat64State {
4630 type Borrowed<'a> = &'a Self;
4631 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4632 value
4633 }
4634 }
4635
4636 unsafe impl fidl::encoding::TypeMarker for BorderRoutingNat64State {
4637 type Owned = Self;
4638
4639 #[inline(always)]
4640 fn inline_align(_context: fidl::encoding::Context) -> usize {
4641 8
4642 }
4643
4644 #[inline(always)]
4645 fn inline_size(_context: fidl::encoding::Context) -> usize {
4646 16
4647 }
4648 }
4649
4650 unsafe impl<D: fidl::encoding::ResourceDialect>
4651 fidl::encoding::Encode<BorderRoutingNat64State, D> for &BorderRoutingNat64State
4652 {
4653 unsafe fn encode(
4654 self,
4655 encoder: &mut fidl::encoding::Encoder<'_, D>,
4656 offset: usize,
4657 mut depth: fidl::encoding::Depth,
4658 ) -> fidl::Result<()> {
4659 encoder.debug_check_bounds::<BorderRoutingNat64State>(offset);
4660 let max_ordinal: u64 = self.max_ordinal_present();
4662 encoder.write_num(max_ordinal, offset);
4663 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4664 if max_ordinal == 0 {
4666 return Ok(());
4667 }
4668 depth.increment()?;
4669 let envelope_size = 8;
4670 let bytes_len = max_ordinal as usize * envelope_size;
4671 #[allow(unused_variables)]
4672 let offset = encoder.out_of_line_offset(bytes_len);
4673 let mut _prev_end_offset: usize = 0;
4674 if 1 > max_ordinal {
4675 return Ok(());
4676 }
4677
4678 let cur_offset: usize = (1 - 1) * envelope_size;
4681
4682 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4684
4685 fidl::encoding::encode_in_envelope_optional::<Nat64State, D>(
4690 self.prefix_manager_state
4691 .as_ref()
4692 .map(<Nat64State as fidl::encoding::ValueTypeMarker>::borrow),
4693 encoder,
4694 offset + cur_offset,
4695 depth,
4696 )?;
4697
4698 _prev_end_offset = cur_offset + envelope_size;
4699 if 2 > max_ordinal {
4700 return Ok(());
4701 }
4702
4703 let cur_offset: usize = (2 - 1) * envelope_size;
4706
4707 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4709
4710 fidl::encoding::encode_in_envelope_optional::<Nat64State, D>(
4715 self.translator_state
4716 .as_ref()
4717 .map(<Nat64State as fidl::encoding::ValueTypeMarker>::borrow),
4718 encoder,
4719 offset + cur_offset,
4720 depth,
4721 )?;
4722
4723 _prev_end_offset = cur_offset + envelope_size;
4724
4725 Ok(())
4726 }
4727 }
4728
4729 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4730 for BorderRoutingNat64State
4731 {
4732 #[inline(always)]
4733 fn new_empty() -> Self {
4734 Self::default()
4735 }
4736
4737 unsafe fn decode(
4738 &mut self,
4739 decoder: &mut fidl::encoding::Decoder<'_, D>,
4740 offset: usize,
4741 mut depth: fidl::encoding::Depth,
4742 ) -> fidl::Result<()> {
4743 decoder.debug_check_bounds::<Self>(offset);
4744 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4745 None => return Err(fidl::Error::NotNullable),
4746 Some(len) => len,
4747 };
4748 if len == 0 {
4750 return Ok(());
4751 };
4752 depth.increment()?;
4753 let envelope_size = 8;
4754 let bytes_len = len * envelope_size;
4755 let offset = decoder.out_of_line_offset(bytes_len)?;
4756 let mut _next_ordinal_to_read = 0;
4758 let mut next_offset = offset;
4759 let end_offset = offset + bytes_len;
4760 _next_ordinal_to_read += 1;
4761 if next_offset >= end_offset {
4762 return Ok(());
4763 }
4764
4765 while _next_ordinal_to_read < 1 {
4767 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4768 _next_ordinal_to_read += 1;
4769 next_offset += envelope_size;
4770 }
4771
4772 let next_out_of_line = decoder.next_out_of_line();
4773 let handles_before = decoder.remaining_handles();
4774 if let Some((inlined, num_bytes, num_handles)) =
4775 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4776 {
4777 let member_inline_size =
4778 <Nat64State as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4779 if inlined != (member_inline_size <= 4) {
4780 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4781 }
4782 let inner_offset;
4783 let mut inner_depth = depth.clone();
4784 if inlined {
4785 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4786 inner_offset = next_offset;
4787 } else {
4788 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4789 inner_depth.increment()?;
4790 }
4791 let val_ref = self
4792 .prefix_manager_state
4793 .get_or_insert_with(|| fidl::new_empty!(Nat64State, D));
4794 fidl::decode!(Nat64State, D, val_ref, decoder, inner_offset, inner_depth)?;
4795 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4796 {
4797 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4798 }
4799 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4800 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4801 }
4802 }
4803
4804 next_offset += envelope_size;
4805 _next_ordinal_to_read += 1;
4806 if next_offset >= end_offset {
4807 return Ok(());
4808 }
4809
4810 while _next_ordinal_to_read < 2 {
4812 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4813 _next_ordinal_to_read += 1;
4814 next_offset += envelope_size;
4815 }
4816
4817 let next_out_of_line = decoder.next_out_of_line();
4818 let handles_before = decoder.remaining_handles();
4819 if let Some((inlined, num_bytes, num_handles)) =
4820 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4821 {
4822 let member_inline_size =
4823 <Nat64State as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4824 if inlined != (member_inline_size <= 4) {
4825 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4826 }
4827 let inner_offset;
4828 let mut inner_depth = depth.clone();
4829 if inlined {
4830 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4831 inner_offset = next_offset;
4832 } else {
4833 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4834 inner_depth.increment()?;
4835 }
4836 let val_ref =
4837 self.translator_state.get_or_insert_with(|| fidl::new_empty!(Nat64State, D));
4838 fidl::decode!(Nat64State, D, val_ref, decoder, inner_offset, inner_depth)?;
4839 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4840 {
4841 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4842 }
4843 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4844 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4845 }
4846 }
4847
4848 next_offset += envelope_size;
4849
4850 while next_offset < end_offset {
4852 _next_ordinal_to_read += 1;
4853 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4854 next_offset += envelope_size;
4855 }
4856
4857 Ok(())
4858 }
4859 }
4860
4861 impl ChannelInfo {
4862 #[inline(always)]
4863 fn max_ordinal_present(&self) -> u64 {
4864 if let Some(_) = self.masked_by_regulatory_domain {
4865 return 6;
4866 }
4867 if let Some(_) = self.spectrum_bandwidth_hz {
4868 return 5;
4869 }
4870 if let Some(_) = self.spectrum_center_frequency_hz {
4871 return 4;
4872 }
4873 if let Some(_) = self.max_transmit_power_dbm {
4874 return 3;
4875 }
4876 if let Some(_) = self.id {
4877 return 2;
4878 }
4879 if let Some(_) = self.index {
4880 return 1;
4881 }
4882 0
4883 }
4884 }
4885
4886 impl fidl::encoding::ValueTypeMarker for ChannelInfo {
4887 type Borrowed<'a> = &'a Self;
4888 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4889 value
4890 }
4891 }
4892
4893 unsafe impl fidl::encoding::TypeMarker for ChannelInfo {
4894 type Owned = Self;
4895
4896 #[inline(always)]
4897 fn inline_align(_context: fidl::encoding::Context) -> usize {
4898 8
4899 }
4900
4901 #[inline(always)]
4902 fn inline_size(_context: fidl::encoding::Context) -> usize {
4903 16
4904 }
4905 }
4906
4907 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelInfo, D>
4908 for &ChannelInfo
4909 {
4910 unsafe fn encode(
4911 self,
4912 encoder: &mut fidl::encoding::Encoder<'_, D>,
4913 offset: usize,
4914 mut depth: fidl::encoding::Depth,
4915 ) -> fidl::Result<()> {
4916 encoder.debug_check_bounds::<ChannelInfo>(offset);
4917 let max_ordinal: u64 = self.max_ordinal_present();
4919 encoder.write_num(max_ordinal, offset);
4920 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4921 if max_ordinal == 0 {
4923 return Ok(());
4924 }
4925 depth.increment()?;
4926 let envelope_size = 8;
4927 let bytes_len = max_ordinal as usize * envelope_size;
4928 #[allow(unused_variables)]
4929 let offset = encoder.out_of_line_offset(bytes_len);
4930 let mut _prev_end_offset: usize = 0;
4931 if 1 > max_ordinal {
4932 return Ok(());
4933 }
4934
4935 let cur_offset: usize = (1 - 1) * envelope_size;
4938
4939 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4941
4942 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4947 self.index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4948 encoder,
4949 offset + cur_offset,
4950 depth,
4951 )?;
4952
4953 _prev_end_offset = cur_offset + envelope_size;
4954 if 2 > max_ordinal {
4955 return Ok(());
4956 }
4957
4958 let cur_offset: usize = (2 - 1) * envelope_size;
4961
4962 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4964
4965 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<16>, D>(
4970 self.id.as_ref().map(
4971 <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow,
4972 ),
4973 encoder,
4974 offset + cur_offset,
4975 depth,
4976 )?;
4977
4978 _prev_end_offset = cur_offset + envelope_size;
4979 if 3 > max_ordinal {
4980 return Ok(());
4981 }
4982
4983 let cur_offset: usize = (3 - 1) * envelope_size;
4986
4987 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4989
4990 fidl::encoding::encode_in_envelope_optional::<i8, D>(
4995 self.max_transmit_power_dbm
4996 .as_ref()
4997 .map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
4998 encoder,
4999 offset + cur_offset,
5000 depth,
5001 )?;
5002
5003 _prev_end_offset = cur_offset + envelope_size;
5004 if 4 > max_ordinal {
5005 return Ok(());
5006 }
5007
5008 let cur_offset: usize = (4 - 1) * envelope_size;
5011
5012 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5014
5015 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5020 self.spectrum_center_frequency_hz
5021 .as_ref()
5022 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5023 encoder,
5024 offset + cur_offset,
5025 depth,
5026 )?;
5027
5028 _prev_end_offset = cur_offset + envelope_size;
5029 if 5 > max_ordinal {
5030 return Ok(());
5031 }
5032
5033 let cur_offset: usize = (5 - 1) * envelope_size;
5036
5037 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5039
5040 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5045 self.spectrum_bandwidth_hz
5046 .as_ref()
5047 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5048 encoder,
5049 offset + cur_offset,
5050 depth,
5051 )?;
5052
5053 _prev_end_offset = cur_offset + envelope_size;
5054 if 6 > max_ordinal {
5055 return Ok(());
5056 }
5057
5058 let cur_offset: usize = (6 - 1) * envelope_size;
5061
5062 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5064
5065 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5070 self.masked_by_regulatory_domain
5071 .as_ref()
5072 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5073 encoder,
5074 offset + cur_offset,
5075 depth,
5076 )?;
5077
5078 _prev_end_offset = cur_offset + envelope_size;
5079
5080 Ok(())
5081 }
5082 }
5083
5084 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelInfo {
5085 #[inline(always)]
5086 fn new_empty() -> Self {
5087 Self::default()
5088 }
5089
5090 unsafe fn decode(
5091 &mut self,
5092 decoder: &mut fidl::encoding::Decoder<'_, D>,
5093 offset: usize,
5094 mut depth: fidl::encoding::Depth,
5095 ) -> fidl::Result<()> {
5096 decoder.debug_check_bounds::<Self>(offset);
5097 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5098 None => return Err(fidl::Error::NotNullable),
5099 Some(len) => len,
5100 };
5101 if len == 0 {
5103 return Ok(());
5104 };
5105 depth.increment()?;
5106 let envelope_size = 8;
5107 let bytes_len = len * envelope_size;
5108 let offset = decoder.out_of_line_offset(bytes_len)?;
5109 let mut _next_ordinal_to_read = 0;
5111 let mut next_offset = offset;
5112 let end_offset = offset + bytes_len;
5113 _next_ordinal_to_read += 1;
5114 if next_offset >= end_offset {
5115 return Ok(());
5116 }
5117
5118 while _next_ordinal_to_read < 1 {
5120 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5121 _next_ordinal_to_read += 1;
5122 next_offset += envelope_size;
5123 }
5124
5125 let next_out_of_line = decoder.next_out_of_line();
5126 let handles_before = decoder.remaining_handles();
5127 if let Some((inlined, num_bytes, num_handles)) =
5128 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5129 {
5130 let member_inline_size =
5131 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5132 if inlined != (member_inline_size <= 4) {
5133 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5134 }
5135 let inner_offset;
5136 let mut inner_depth = depth.clone();
5137 if inlined {
5138 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5139 inner_offset = next_offset;
5140 } else {
5141 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5142 inner_depth.increment()?;
5143 }
5144 let val_ref = self.index.get_or_insert_with(|| fidl::new_empty!(u16, D));
5145 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5146 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5147 {
5148 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5149 }
5150 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5151 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5152 }
5153 }
5154
5155 next_offset += envelope_size;
5156 _next_ordinal_to_read += 1;
5157 if next_offset >= end_offset {
5158 return Ok(());
5159 }
5160
5161 while _next_ordinal_to_read < 2 {
5163 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5164 _next_ordinal_to_read += 1;
5165 next_offset += envelope_size;
5166 }
5167
5168 let next_out_of_line = decoder.next_out_of_line();
5169 let handles_before = decoder.remaining_handles();
5170 if let Some((inlined, num_bytes, num_handles)) =
5171 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5172 {
5173 let member_inline_size =
5174 <fidl::encoding::BoundedString<16> as fidl::encoding::TypeMarker>::inline_size(
5175 decoder.context,
5176 );
5177 if inlined != (member_inline_size <= 4) {
5178 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5179 }
5180 let inner_offset;
5181 let mut inner_depth = depth.clone();
5182 if inlined {
5183 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5184 inner_offset = next_offset;
5185 } else {
5186 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5187 inner_depth.increment()?;
5188 }
5189 let val_ref = self
5190 .id
5191 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<16>, D));
5192 fidl::decode!(
5193 fidl::encoding::BoundedString<16>,
5194 D,
5195 val_ref,
5196 decoder,
5197 inner_offset,
5198 inner_depth
5199 )?;
5200 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5201 {
5202 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5203 }
5204 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5205 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5206 }
5207 }
5208
5209 next_offset += envelope_size;
5210 _next_ordinal_to_read += 1;
5211 if next_offset >= end_offset {
5212 return Ok(());
5213 }
5214
5215 while _next_ordinal_to_read < 3 {
5217 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5218 _next_ordinal_to_read += 1;
5219 next_offset += envelope_size;
5220 }
5221
5222 let next_out_of_line = decoder.next_out_of_line();
5223 let handles_before = decoder.remaining_handles();
5224 if let Some((inlined, num_bytes, num_handles)) =
5225 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5226 {
5227 let member_inline_size =
5228 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5229 if inlined != (member_inline_size <= 4) {
5230 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5231 }
5232 let inner_offset;
5233 let mut inner_depth = depth.clone();
5234 if inlined {
5235 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5236 inner_offset = next_offset;
5237 } else {
5238 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5239 inner_depth.increment()?;
5240 }
5241 let val_ref =
5242 self.max_transmit_power_dbm.get_or_insert_with(|| fidl::new_empty!(i8, D));
5243 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
5244 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5245 {
5246 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5247 }
5248 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5249 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5250 }
5251 }
5252
5253 next_offset += envelope_size;
5254 _next_ordinal_to_read += 1;
5255 if next_offset >= end_offset {
5256 return Ok(());
5257 }
5258
5259 while _next_ordinal_to_read < 4 {
5261 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5262 _next_ordinal_to_read += 1;
5263 next_offset += envelope_size;
5264 }
5265
5266 let next_out_of_line = decoder.next_out_of_line();
5267 let handles_before = decoder.remaining_handles();
5268 if let Some((inlined, num_bytes, num_handles)) =
5269 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5270 {
5271 let member_inline_size =
5272 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5273 if inlined != (member_inline_size <= 4) {
5274 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5275 }
5276 let inner_offset;
5277 let mut inner_depth = depth.clone();
5278 if inlined {
5279 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5280 inner_offset = next_offset;
5281 } else {
5282 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5283 inner_depth.increment()?;
5284 }
5285 let val_ref = self
5286 .spectrum_center_frequency_hz
5287 .get_or_insert_with(|| fidl::new_empty!(u64, D));
5288 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5289 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5290 {
5291 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5292 }
5293 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5294 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5295 }
5296 }
5297
5298 next_offset += envelope_size;
5299 _next_ordinal_to_read += 1;
5300 if next_offset >= end_offset {
5301 return Ok(());
5302 }
5303
5304 while _next_ordinal_to_read < 5 {
5306 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5307 _next_ordinal_to_read += 1;
5308 next_offset += envelope_size;
5309 }
5310
5311 let next_out_of_line = decoder.next_out_of_line();
5312 let handles_before = decoder.remaining_handles();
5313 if let Some((inlined, num_bytes, num_handles)) =
5314 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5315 {
5316 let member_inline_size =
5317 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5318 if inlined != (member_inline_size <= 4) {
5319 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5320 }
5321 let inner_offset;
5322 let mut inner_depth = depth.clone();
5323 if inlined {
5324 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5325 inner_offset = next_offset;
5326 } else {
5327 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5328 inner_depth.increment()?;
5329 }
5330 let val_ref =
5331 self.spectrum_bandwidth_hz.get_or_insert_with(|| fidl::new_empty!(u64, D));
5332 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5333 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5334 {
5335 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5336 }
5337 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5338 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5339 }
5340 }
5341
5342 next_offset += envelope_size;
5343 _next_ordinal_to_read += 1;
5344 if next_offset >= end_offset {
5345 return Ok(());
5346 }
5347
5348 while _next_ordinal_to_read < 6 {
5350 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5351 _next_ordinal_to_read += 1;
5352 next_offset += envelope_size;
5353 }
5354
5355 let next_out_of_line = decoder.next_out_of_line();
5356 let handles_before = decoder.remaining_handles();
5357 if let Some((inlined, num_bytes, num_handles)) =
5358 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5359 {
5360 let member_inline_size =
5361 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5362 if inlined != (member_inline_size <= 4) {
5363 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5364 }
5365 let inner_offset;
5366 let mut inner_depth = depth.clone();
5367 if inlined {
5368 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5369 inner_offset = next_offset;
5370 } else {
5371 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5372 inner_depth.increment()?;
5373 }
5374 let val_ref = self
5375 .masked_by_regulatory_domain
5376 .get_or_insert_with(|| fidl::new_empty!(bool, D));
5377 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5378 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5379 {
5380 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5381 }
5382 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5383 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5384 }
5385 }
5386
5387 next_offset += envelope_size;
5388
5389 while next_offset < end_offset {
5391 _next_ordinal_to_read += 1;
5392 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5393 next_offset += envelope_size;
5394 }
5395
5396 Ok(())
5397 }
5398 }
5399
5400 impl Dhcp6PdInfo {
5401 #[inline(always)]
5402 fn max_ordinal_present(&self) -> u64 {
5403 if let Some(_) = self.hashed_pd_prefix {
5404 return 3;
5405 }
5406 if let Some(_) = self.pd_processed_ra_info {
5407 return 2;
5408 }
5409 if let Some(_) = self.dhcp6pd_state {
5410 return 1;
5411 }
5412 0
5413 }
5414 }
5415
5416 impl fidl::encoding::ValueTypeMarker for Dhcp6PdInfo {
5417 type Borrowed<'a> = &'a Self;
5418 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5419 value
5420 }
5421 }
5422
5423 unsafe impl fidl::encoding::TypeMarker for Dhcp6PdInfo {
5424 type Owned = Self;
5425
5426 #[inline(always)]
5427 fn inline_align(_context: fidl::encoding::Context) -> usize {
5428 8
5429 }
5430
5431 #[inline(always)]
5432 fn inline_size(_context: fidl::encoding::Context) -> usize {
5433 16
5434 }
5435 }
5436
5437 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dhcp6PdInfo, D>
5438 for &Dhcp6PdInfo
5439 {
5440 unsafe fn encode(
5441 self,
5442 encoder: &mut fidl::encoding::Encoder<'_, D>,
5443 offset: usize,
5444 mut depth: fidl::encoding::Depth,
5445 ) -> fidl::Result<()> {
5446 encoder.debug_check_bounds::<Dhcp6PdInfo>(offset);
5447 let max_ordinal: u64 = self.max_ordinal_present();
5449 encoder.write_num(max_ordinal, offset);
5450 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5451 if max_ordinal == 0 {
5453 return Ok(());
5454 }
5455 depth.increment()?;
5456 let envelope_size = 8;
5457 let bytes_len = max_ordinal as usize * envelope_size;
5458 #[allow(unused_variables)]
5459 let offset = encoder.out_of_line_offset(bytes_len);
5460 let mut _prev_end_offset: usize = 0;
5461 if 1 > max_ordinal {
5462 return Ok(());
5463 }
5464
5465 let cur_offset: usize = (1 - 1) * envelope_size;
5468
5469 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5471
5472 fidl::encoding::encode_in_envelope_optional::<Dhcp6PdState, D>(
5477 self.dhcp6pd_state
5478 .as_ref()
5479 .map(<Dhcp6PdState as fidl::encoding::ValueTypeMarker>::borrow),
5480 encoder,
5481 offset + cur_offset,
5482 depth,
5483 )?;
5484
5485 _prev_end_offset = cur_offset + envelope_size;
5486 if 2 > max_ordinal {
5487 return Ok(());
5488 }
5489
5490 let cur_offset: usize = (2 - 1) * envelope_size;
5493
5494 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5496
5497 fidl::encoding::encode_in_envelope_optional::<PdProcessedRaInfo, D>(
5502 self.pd_processed_ra_info
5503 .as_ref()
5504 .map(<PdProcessedRaInfo as fidl::encoding::ValueTypeMarker>::borrow),
5505 encoder,
5506 offset + cur_offset,
5507 depth,
5508 )?;
5509
5510 _prev_end_offset = cur_offset + envelope_size;
5511 if 3 > max_ordinal {
5512 return Ok(());
5513 }
5514
5515 let cur_offset: usize = (3 - 1) * envelope_size;
5518
5519 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5521
5522 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
5527 self.hashed_pd_prefix.as_ref().map(
5528 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
5529 ),
5530 encoder,
5531 offset + cur_offset,
5532 depth,
5533 )?;
5534
5535 _prev_end_offset = cur_offset + envelope_size;
5536
5537 Ok(())
5538 }
5539 }
5540
5541 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dhcp6PdInfo {
5542 #[inline(always)]
5543 fn new_empty() -> Self {
5544 Self::default()
5545 }
5546
5547 unsafe fn decode(
5548 &mut self,
5549 decoder: &mut fidl::encoding::Decoder<'_, D>,
5550 offset: usize,
5551 mut depth: fidl::encoding::Depth,
5552 ) -> fidl::Result<()> {
5553 decoder.debug_check_bounds::<Self>(offset);
5554 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5555 None => return Err(fidl::Error::NotNullable),
5556 Some(len) => len,
5557 };
5558 if len == 0 {
5560 return Ok(());
5561 };
5562 depth.increment()?;
5563 let envelope_size = 8;
5564 let bytes_len = len * envelope_size;
5565 let offset = decoder.out_of_line_offset(bytes_len)?;
5566 let mut _next_ordinal_to_read = 0;
5568 let mut next_offset = offset;
5569 let end_offset = offset + bytes_len;
5570 _next_ordinal_to_read += 1;
5571 if next_offset >= end_offset {
5572 return Ok(());
5573 }
5574
5575 while _next_ordinal_to_read < 1 {
5577 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5578 _next_ordinal_to_read += 1;
5579 next_offset += envelope_size;
5580 }
5581
5582 let next_out_of_line = decoder.next_out_of_line();
5583 let handles_before = decoder.remaining_handles();
5584 if let Some((inlined, num_bytes, num_handles)) =
5585 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5586 {
5587 let member_inline_size =
5588 <Dhcp6PdState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5589 if inlined != (member_inline_size <= 4) {
5590 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5591 }
5592 let inner_offset;
5593 let mut inner_depth = depth.clone();
5594 if inlined {
5595 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5596 inner_offset = next_offset;
5597 } else {
5598 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5599 inner_depth.increment()?;
5600 }
5601 let val_ref =
5602 self.dhcp6pd_state.get_or_insert_with(|| fidl::new_empty!(Dhcp6PdState, D));
5603 fidl::decode!(Dhcp6PdState, D, val_ref, decoder, inner_offset, inner_depth)?;
5604 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5605 {
5606 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5607 }
5608 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5609 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5610 }
5611 }
5612
5613 next_offset += envelope_size;
5614 _next_ordinal_to_read += 1;
5615 if next_offset >= end_offset {
5616 return Ok(());
5617 }
5618
5619 while _next_ordinal_to_read < 2 {
5621 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5622 _next_ordinal_to_read += 1;
5623 next_offset += envelope_size;
5624 }
5625
5626 let next_out_of_line = decoder.next_out_of_line();
5627 let handles_before = decoder.remaining_handles();
5628 if let Some((inlined, num_bytes, num_handles)) =
5629 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5630 {
5631 let member_inline_size =
5632 <PdProcessedRaInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5633 if inlined != (member_inline_size <= 4) {
5634 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5635 }
5636 let inner_offset;
5637 let mut inner_depth = depth.clone();
5638 if inlined {
5639 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5640 inner_offset = next_offset;
5641 } else {
5642 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5643 inner_depth.increment()?;
5644 }
5645 let val_ref = self
5646 .pd_processed_ra_info
5647 .get_or_insert_with(|| fidl::new_empty!(PdProcessedRaInfo, D));
5648 fidl::decode!(PdProcessedRaInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
5649 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5650 {
5651 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5652 }
5653 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5654 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5655 }
5656 }
5657
5658 next_offset += envelope_size;
5659 _next_ordinal_to_read += 1;
5660 if next_offset >= end_offset {
5661 return Ok(());
5662 }
5663
5664 while _next_ordinal_to_read < 3 {
5666 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5667 _next_ordinal_to_read += 1;
5668 next_offset += envelope_size;
5669 }
5670
5671 let next_out_of_line = decoder.next_out_of_line();
5672 let handles_before = decoder.remaining_handles();
5673 if let Some((inlined, num_bytes, num_handles)) =
5674 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5675 {
5676 let member_inline_size =
5677 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
5678 decoder.context,
5679 );
5680 if inlined != (member_inline_size <= 4) {
5681 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5682 }
5683 let inner_offset;
5684 let mut inner_depth = depth.clone();
5685 if inlined {
5686 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5687 inner_offset = next_offset;
5688 } else {
5689 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5690 inner_depth.increment()?;
5691 }
5692 let val_ref = self
5693 .hashed_pd_prefix
5694 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
5695 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
5696 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5697 {
5698 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5699 }
5700 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5701 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5702 }
5703 }
5704
5705 next_offset += envelope_size;
5706
5707 while next_offset < end_offset {
5709 _next_ordinal_to_read += 1;
5710 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5711 next_offset += envelope_size;
5712 }
5713
5714 Ok(())
5715 }
5716 }
5717
5718 impl DnssdCounters {
5719 #[inline(always)]
5720 fn max_ordinal_present(&self) -> u64 {
5721 if let Some(_) = self.upstream_dns_counters {
5722 return 8;
5723 }
5724 if let Some(_) = self.resolved_by_srp {
5725 return 7;
5726 }
5727 if let Some(_) = self.other_response {
5728 return 6;
5729 }
5730 if let Some(_) = self.not_implemented_response {
5731 return 5;
5732 }
5733 if let Some(_) = self.name_error_response {
5734 return 4;
5735 }
5736 if let Some(_) = self.format_error_response {
5737 return 3;
5738 }
5739 if let Some(_) = self.server_failure_response {
5740 return 2;
5741 }
5742 if let Some(_) = self.success_response {
5743 return 1;
5744 }
5745 0
5746 }
5747 }
5748
5749 impl fidl::encoding::ValueTypeMarker for DnssdCounters {
5750 type Borrowed<'a> = &'a Self;
5751 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5752 value
5753 }
5754 }
5755
5756 unsafe impl fidl::encoding::TypeMarker for DnssdCounters {
5757 type Owned = Self;
5758
5759 #[inline(always)]
5760 fn inline_align(_context: fidl::encoding::Context) -> usize {
5761 8
5762 }
5763
5764 #[inline(always)]
5765 fn inline_size(_context: fidl::encoding::Context) -> usize {
5766 16
5767 }
5768 }
5769
5770 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DnssdCounters, D>
5771 for &DnssdCounters
5772 {
5773 unsafe fn encode(
5774 self,
5775 encoder: &mut fidl::encoding::Encoder<'_, D>,
5776 offset: usize,
5777 mut depth: fidl::encoding::Depth,
5778 ) -> fidl::Result<()> {
5779 encoder.debug_check_bounds::<DnssdCounters>(offset);
5780 let max_ordinal: u64 = self.max_ordinal_present();
5782 encoder.write_num(max_ordinal, offset);
5783 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5784 if max_ordinal == 0 {
5786 return Ok(());
5787 }
5788 depth.increment()?;
5789 let envelope_size = 8;
5790 let bytes_len = max_ordinal as usize * envelope_size;
5791 #[allow(unused_variables)]
5792 let offset = encoder.out_of_line_offset(bytes_len);
5793 let mut _prev_end_offset: usize = 0;
5794 if 1 > max_ordinal {
5795 return Ok(());
5796 }
5797
5798 let cur_offset: usize = (1 - 1) * envelope_size;
5801
5802 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5804
5805 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5810 self.success_response
5811 .as_ref()
5812 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5813 encoder,
5814 offset + cur_offset,
5815 depth,
5816 )?;
5817
5818 _prev_end_offset = cur_offset + envelope_size;
5819 if 2 > max_ordinal {
5820 return Ok(());
5821 }
5822
5823 let cur_offset: usize = (2 - 1) * envelope_size;
5826
5827 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5829
5830 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5835 self.server_failure_response
5836 .as_ref()
5837 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5838 encoder,
5839 offset + cur_offset,
5840 depth,
5841 )?;
5842
5843 _prev_end_offset = cur_offset + envelope_size;
5844 if 3 > max_ordinal {
5845 return Ok(());
5846 }
5847
5848 let cur_offset: usize = (3 - 1) * envelope_size;
5851
5852 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5854
5855 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5860 self.format_error_response
5861 .as_ref()
5862 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5863 encoder,
5864 offset + cur_offset,
5865 depth,
5866 )?;
5867
5868 _prev_end_offset = cur_offset + envelope_size;
5869 if 4 > max_ordinal {
5870 return Ok(());
5871 }
5872
5873 let cur_offset: usize = (4 - 1) * envelope_size;
5876
5877 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5879
5880 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5885 self.name_error_response
5886 .as_ref()
5887 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5888 encoder,
5889 offset + cur_offset,
5890 depth,
5891 )?;
5892
5893 _prev_end_offset = cur_offset + envelope_size;
5894 if 5 > max_ordinal {
5895 return Ok(());
5896 }
5897
5898 let cur_offset: usize = (5 - 1) * envelope_size;
5901
5902 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5904
5905 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5910 self.not_implemented_response
5911 .as_ref()
5912 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5913 encoder,
5914 offset + cur_offset,
5915 depth,
5916 )?;
5917
5918 _prev_end_offset = cur_offset + envelope_size;
5919 if 6 > max_ordinal {
5920 return Ok(());
5921 }
5922
5923 let cur_offset: usize = (6 - 1) * envelope_size;
5926
5927 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5929
5930 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5935 self.other_response.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5936 encoder,
5937 offset + cur_offset,
5938 depth,
5939 )?;
5940
5941 _prev_end_offset = cur_offset + envelope_size;
5942 if 7 > max_ordinal {
5943 return Ok(());
5944 }
5945
5946 let cur_offset: usize = (7 - 1) * envelope_size;
5949
5950 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5952
5953 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5958 self.resolved_by_srp.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5959 encoder,
5960 offset + cur_offset,
5961 depth,
5962 )?;
5963
5964 _prev_end_offset = cur_offset + envelope_size;
5965 if 8 > max_ordinal {
5966 return Ok(());
5967 }
5968
5969 let cur_offset: usize = (8 - 1) * envelope_size;
5972
5973 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5975
5976 fidl::encoding::encode_in_envelope_optional::<UpstreamDnsCounters, D>(
5981 self.upstream_dns_counters
5982 .as_ref()
5983 .map(<UpstreamDnsCounters as fidl::encoding::ValueTypeMarker>::borrow),
5984 encoder,
5985 offset + cur_offset,
5986 depth,
5987 )?;
5988
5989 _prev_end_offset = cur_offset + envelope_size;
5990
5991 Ok(())
5992 }
5993 }
5994
5995 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DnssdCounters {
5996 #[inline(always)]
5997 fn new_empty() -> Self {
5998 Self::default()
5999 }
6000
6001 unsafe fn decode(
6002 &mut self,
6003 decoder: &mut fidl::encoding::Decoder<'_, D>,
6004 offset: usize,
6005 mut depth: fidl::encoding::Depth,
6006 ) -> fidl::Result<()> {
6007 decoder.debug_check_bounds::<Self>(offset);
6008 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6009 None => return Err(fidl::Error::NotNullable),
6010 Some(len) => len,
6011 };
6012 if len == 0 {
6014 return Ok(());
6015 };
6016 depth.increment()?;
6017 let envelope_size = 8;
6018 let bytes_len = len * envelope_size;
6019 let offset = decoder.out_of_line_offset(bytes_len)?;
6020 let mut _next_ordinal_to_read = 0;
6022 let mut next_offset = offset;
6023 let end_offset = offset + bytes_len;
6024 _next_ordinal_to_read += 1;
6025 if next_offset >= end_offset {
6026 return Ok(());
6027 }
6028
6029 while _next_ordinal_to_read < 1 {
6031 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6032 _next_ordinal_to_read += 1;
6033 next_offset += envelope_size;
6034 }
6035
6036 let next_out_of_line = decoder.next_out_of_line();
6037 let handles_before = decoder.remaining_handles();
6038 if let Some((inlined, num_bytes, num_handles)) =
6039 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6040 {
6041 let member_inline_size =
6042 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6043 if inlined != (member_inline_size <= 4) {
6044 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6045 }
6046 let inner_offset;
6047 let mut inner_depth = depth.clone();
6048 if inlined {
6049 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6050 inner_offset = next_offset;
6051 } else {
6052 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6053 inner_depth.increment()?;
6054 }
6055 let val_ref = self.success_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6056 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6057 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6058 {
6059 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6060 }
6061 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6062 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6063 }
6064 }
6065
6066 next_offset += envelope_size;
6067 _next_ordinal_to_read += 1;
6068 if next_offset >= end_offset {
6069 return Ok(());
6070 }
6071
6072 while _next_ordinal_to_read < 2 {
6074 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6075 _next_ordinal_to_read += 1;
6076 next_offset += envelope_size;
6077 }
6078
6079 let next_out_of_line = decoder.next_out_of_line();
6080 let handles_before = decoder.remaining_handles();
6081 if let Some((inlined, num_bytes, num_handles)) =
6082 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6083 {
6084 let member_inline_size =
6085 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6086 if inlined != (member_inline_size <= 4) {
6087 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6088 }
6089 let inner_offset;
6090 let mut inner_depth = depth.clone();
6091 if inlined {
6092 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6093 inner_offset = next_offset;
6094 } else {
6095 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6096 inner_depth.increment()?;
6097 }
6098 let val_ref =
6099 self.server_failure_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6100 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6101 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6102 {
6103 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6104 }
6105 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6106 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6107 }
6108 }
6109
6110 next_offset += envelope_size;
6111 _next_ordinal_to_read += 1;
6112 if next_offset >= end_offset {
6113 return Ok(());
6114 }
6115
6116 while _next_ordinal_to_read < 3 {
6118 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6119 _next_ordinal_to_read += 1;
6120 next_offset += envelope_size;
6121 }
6122
6123 let next_out_of_line = decoder.next_out_of_line();
6124 let handles_before = decoder.remaining_handles();
6125 if let Some((inlined, num_bytes, num_handles)) =
6126 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6127 {
6128 let member_inline_size =
6129 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6130 if inlined != (member_inline_size <= 4) {
6131 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6132 }
6133 let inner_offset;
6134 let mut inner_depth = depth.clone();
6135 if inlined {
6136 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6137 inner_offset = next_offset;
6138 } else {
6139 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6140 inner_depth.increment()?;
6141 }
6142 let val_ref =
6143 self.format_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6144 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6145 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6146 {
6147 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6148 }
6149 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6150 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6151 }
6152 }
6153
6154 next_offset += envelope_size;
6155 _next_ordinal_to_read += 1;
6156 if next_offset >= end_offset {
6157 return Ok(());
6158 }
6159
6160 while _next_ordinal_to_read < 4 {
6162 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6163 _next_ordinal_to_read += 1;
6164 next_offset += envelope_size;
6165 }
6166
6167 let next_out_of_line = decoder.next_out_of_line();
6168 let handles_before = decoder.remaining_handles();
6169 if let Some((inlined, num_bytes, num_handles)) =
6170 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6171 {
6172 let member_inline_size =
6173 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6174 if inlined != (member_inline_size <= 4) {
6175 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6176 }
6177 let inner_offset;
6178 let mut inner_depth = depth.clone();
6179 if inlined {
6180 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6181 inner_offset = next_offset;
6182 } else {
6183 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6184 inner_depth.increment()?;
6185 }
6186 let val_ref =
6187 self.name_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6188 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6189 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6190 {
6191 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6192 }
6193 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6194 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6195 }
6196 }
6197
6198 next_offset += envelope_size;
6199 _next_ordinal_to_read += 1;
6200 if next_offset >= end_offset {
6201 return Ok(());
6202 }
6203
6204 while _next_ordinal_to_read < 5 {
6206 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6207 _next_ordinal_to_read += 1;
6208 next_offset += envelope_size;
6209 }
6210
6211 let next_out_of_line = decoder.next_out_of_line();
6212 let handles_before = decoder.remaining_handles();
6213 if let Some((inlined, num_bytes, num_handles)) =
6214 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6215 {
6216 let member_inline_size =
6217 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6218 if inlined != (member_inline_size <= 4) {
6219 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6220 }
6221 let inner_offset;
6222 let mut inner_depth = depth.clone();
6223 if inlined {
6224 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6225 inner_offset = next_offset;
6226 } else {
6227 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6228 inner_depth.increment()?;
6229 }
6230 let val_ref =
6231 self.not_implemented_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6232 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6233 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6234 {
6235 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6236 }
6237 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6238 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6239 }
6240 }
6241
6242 next_offset += envelope_size;
6243 _next_ordinal_to_read += 1;
6244 if next_offset >= end_offset {
6245 return Ok(());
6246 }
6247
6248 while _next_ordinal_to_read < 6 {
6250 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6251 _next_ordinal_to_read += 1;
6252 next_offset += envelope_size;
6253 }
6254
6255 let next_out_of_line = decoder.next_out_of_line();
6256 let handles_before = decoder.remaining_handles();
6257 if let Some((inlined, num_bytes, num_handles)) =
6258 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6259 {
6260 let member_inline_size =
6261 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6262 if inlined != (member_inline_size <= 4) {
6263 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6264 }
6265 let inner_offset;
6266 let mut inner_depth = depth.clone();
6267 if inlined {
6268 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6269 inner_offset = next_offset;
6270 } else {
6271 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6272 inner_depth.increment()?;
6273 }
6274 let val_ref = self.other_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6275 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6276 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6277 {
6278 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6279 }
6280 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6281 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6282 }
6283 }
6284
6285 next_offset += envelope_size;
6286 _next_ordinal_to_read += 1;
6287 if next_offset >= end_offset {
6288 return Ok(());
6289 }
6290
6291 while _next_ordinal_to_read < 7 {
6293 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6294 _next_ordinal_to_read += 1;
6295 next_offset += envelope_size;
6296 }
6297
6298 let next_out_of_line = decoder.next_out_of_line();
6299 let handles_before = decoder.remaining_handles();
6300 if let Some((inlined, num_bytes, num_handles)) =
6301 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6302 {
6303 let member_inline_size =
6304 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6305 if inlined != (member_inline_size <= 4) {
6306 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6307 }
6308 let inner_offset;
6309 let mut inner_depth = depth.clone();
6310 if inlined {
6311 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6312 inner_offset = next_offset;
6313 } else {
6314 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6315 inner_depth.increment()?;
6316 }
6317 let val_ref = self.resolved_by_srp.get_or_insert_with(|| fidl::new_empty!(u32, D));
6318 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6319 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6320 {
6321 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6322 }
6323 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6324 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6325 }
6326 }
6327
6328 next_offset += envelope_size;
6329 _next_ordinal_to_read += 1;
6330 if next_offset >= end_offset {
6331 return Ok(());
6332 }
6333
6334 while _next_ordinal_to_read < 8 {
6336 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6337 _next_ordinal_to_read += 1;
6338 next_offset += envelope_size;
6339 }
6340
6341 let next_out_of_line = decoder.next_out_of_line();
6342 let handles_before = decoder.remaining_handles();
6343 if let Some((inlined, num_bytes, num_handles)) =
6344 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6345 {
6346 let member_inline_size =
6347 <UpstreamDnsCounters as fidl::encoding::TypeMarker>::inline_size(
6348 decoder.context,
6349 );
6350 if inlined != (member_inline_size <= 4) {
6351 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6352 }
6353 let inner_offset;
6354 let mut inner_depth = depth.clone();
6355 if inlined {
6356 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6357 inner_offset = next_offset;
6358 } else {
6359 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6360 inner_depth.increment()?;
6361 }
6362 let val_ref = self
6363 .upstream_dns_counters
6364 .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsCounters, D));
6365 fidl::decode!(UpstreamDnsCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
6366 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6367 {
6368 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6369 }
6370 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6371 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6372 }
6373 }
6374
6375 next_offset += envelope_size;
6376
6377 while next_offset < end_offset {
6379 _next_ordinal_to_read += 1;
6380 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6381 next_offset += envelope_size;
6382 }
6383
6384 Ok(())
6385 }
6386 }
6387
6388 impl ExternalRoute {
6389 #[inline(always)]
6390 fn max_ordinal_present(&self) -> u64 {
6391 if let Some(_) = self.stable {
6392 return 3;
6393 }
6394 if let Some(_) = self.route_preference {
6395 return 2;
6396 }
6397 if let Some(_) = self.subnet {
6398 return 1;
6399 }
6400 0
6401 }
6402 }
6403
6404 impl fidl::encoding::ValueTypeMarker for ExternalRoute {
6405 type Borrowed<'a> = &'a Self;
6406 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6407 value
6408 }
6409 }
6410
6411 unsafe impl fidl::encoding::TypeMarker for ExternalRoute {
6412 type Owned = Self;
6413
6414 #[inline(always)]
6415 fn inline_align(_context: fidl::encoding::Context) -> usize {
6416 8
6417 }
6418
6419 #[inline(always)]
6420 fn inline_size(_context: fidl::encoding::Context) -> usize {
6421 16
6422 }
6423 }
6424
6425 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExternalRoute, D>
6426 for &ExternalRoute
6427 {
6428 unsafe fn encode(
6429 self,
6430 encoder: &mut fidl::encoding::Encoder<'_, D>,
6431 offset: usize,
6432 mut depth: fidl::encoding::Depth,
6433 ) -> fidl::Result<()> {
6434 encoder.debug_check_bounds::<ExternalRoute>(offset);
6435 let max_ordinal: u64 = self.max_ordinal_present();
6437 encoder.write_num(max_ordinal, offset);
6438 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6439 if max_ordinal == 0 {
6441 return Ok(());
6442 }
6443 depth.increment()?;
6444 let envelope_size = 8;
6445 let bytes_len = max_ordinal as usize * envelope_size;
6446 #[allow(unused_variables)]
6447 let offset = encoder.out_of_line_offset(bytes_len);
6448 let mut _prev_end_offset: usize = 0;
6449 if 1 > max_ordinal {
6450 return Ok(());
6451 }
6452
6453 let cur_offset: usize = (1 - 1) * envelope_size;
6456
6457 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6459
6460 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
6465 self.subnet.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
6466 encoder, offset + cur_offset, depth
6467 )?;
6468
6469 _prev_end_offset = cur_offset + envelope_size;
6470 if 2 > max_ordinal {
6471 return Ok(());
6472 }
6473
6474 let cur_offset: usize = (2 - 1) * envelope_size;
6477
6478 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6480
6481 fidl::encoding::encode_in_envelope_optional::<RoutePreference, D>(
6486 self.route_preference
6487 .as_ref()
6488 .map(<RoutePreference as fidl::encoding::ValueTypeMarker>::borrow),
6489 encoder,
6490 offset + cur_offset,
6491 depth,
6492 )?;
6493
6494 _prev_end_offset = cur_offset + envelope_size;
6495 if 3 > max_ordinal {
6496 return Ok(());
6497 }
6498
6499 let cur_offset: usize = (3 - 1) * envelope_size;
6502
6503 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6505
6506 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6511 self.stable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6512 encoder,
6513 offset + cur_offset,
6514 depth,
6515 )?;
6516
6517 _prev_end_offset = cur_offset + envelope_size;
6518
6519 Ok(())
6520 }
6521 }
6522
6523 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExternalRoute {
6524 #[inline(always)]
6525 fn new_empty() -> Self {
6526 Self::default()
6527 }
6528
6529 unsafe fn decode(
6530 &mut self,
6531 decoder: &mut fidl::encoding::Decoder<'_, D>,
6532 offset: usize,
6533 mut depth: fidl::encoding::Depth,
6534 ) -> fidl::Result<()> {
6535 decoder.debug_check_bounds::<Self>(offset);
6536 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6537 None => return Err(fidl::Error::NotNullable),
6538 Some(len) => len,
6539 };
6540 if len == 0 {
6542 return Ok(());
6543 };
6544 depth.increment()?;
6545 let envelope_size = 8;
6546 let bytes_len = len * envelope_size;
6547 let offset = decoder.out_of_line_offset(bytes_len)?;
6548 let mut _next_ordinal_to_read = 0;
6550 let mut next_offset = offset;
6551 let end_offset = offset + bytes_len;
6552 _next_ordinal_to_read += 1;
6553 if next_offset >= end_offset {
6554 return Ok(());
6555 }
6556
6557 while _next_ordinal_to_read < 1 {
6559 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6560 _next_ordinal_to_read += 1;
6561 next_offset += envelope_size;
6562 }
6563
6564 let next_out_of_line = decoder.next_out_of_line();
6565 let handles_before = decoder.remaining_handles();
6566 if let Some((inlined, num_bytes, num_handles)) =
6567 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6568 {
6569 let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6570 if inlined != (member_inline_size <= 4) {
6571 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6572 }
6573 let inner_offset;
6574 let mut inner_depth = depth.clone();
6575 if inlined {
6576 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6577 inner_offset = next_offset;
6578 } else {
6579 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6580 inner_depth.increment()?;
6581 }
6582 let val_ref = self.subnet.get_or_insert_with(|| {
6583 fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
6584 });
6585 fidl::decode!(
6586 fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
6587 D,
6588 val_ref,
6589 decoder,
6590 inner_offset,
6591 inner_depth
6592 )?;
6593 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6594 {
6595 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6596 }
6597 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6598 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6599 }
6600 }
6601
6602 next_offset += envelope_size;
6603 _next_ordinal_to_read += 1;
6604 if next_offset >= end_offset {
6605 return Ok(());
6606 }
6607
6608 while _next_ordinal_to_read < 2 {
6610 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6611 _next_ordinal_to_read += 1;
6612 next_offset += envelope_size;
6613 }
6614
6615 let next_out_of_line = decoder.next_out_of_line();
6616 let handles_before = decoder.remaining_handles();
6617 if let Some((inlined, num_bytes, num_handles)) =
6618 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6619 {
6620 let member_inline_size =
6621 <RoutePreference as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6622 if inlined != (member_inline_size <= 4) {
6623 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6624 }
6625 let inner_offset;
6626 let mut inner_depth = depth.clone();
6627 if inlined {
6628 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6629 inner_offset = next_offset;
6630 } else {
6631 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6632 inner_depth.increment()?;
6633 }
6634 let val_ref = self
6635 .route_preference
6636 .get_or_insert_with(|| fidl::new_empty!(RoutePreference, D));
6637 fidl::decode!(RoutePreference, D, val_ref, decoder, inner_offset, inner_depth)?;
6638 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6639 {
6640 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6641 }
6642 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6643 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6644 }
6645 }
6646
6647 next_offset += envelope_size;
6648 _next_ordinal_to_read += 1;
6649 if next_offset >= end_offset {
6650 return Ok(());
6651 }
6652
6653 while _next_ordinal_to_read < 3 {
6655 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6656 _next_ordinal_to_read += 1;
6657 next_offset += envelope_size;
6658 }
6659
6660 let next_out_of_line = decoder.next_out_of_line();
6661 let handles_before = decoder.remaining_handles();
6662 if let Some((inlined, num_bytes, num_handles)) =
6663 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6664 {
6665 let member_inline_size =
6666 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6667 if inlined != (member_inline_size <= 4) {
6668 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6669 }
6670 let inner_offset;
6671 let mut inner_depth = depth.clone();
6672 if inlined {
6673 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6674 inner_offset = next_offset;
6675 } else {
6676 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6677 inner_depth.increment()?;
6678 }
6679 let val_ref = self.stable.get_or_insert_with(|| fidl::new_empty!(bool, D));
6680 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6681 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6682 {
6683 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6684 }
6685 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6686 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6687 }
6688 }
6689
6690 next_offset += envelope_size;
6691
6692 while next_offset < end_offset {
6694 _next_ordinal_to_read += 1;
6695 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6696 next_offset += envelope_size;
6697 }
6698
6699 Ok(())
6700 }
6701 }
6702
6703 impl JoinerCommissioningParams {
6704 #[inline(always)]
6705 fn max_ordinal_present(&self) -> u64 {
6706 if let Some(_) = self.vendor_data_string {
6707 return 6;
6708 }
6709 if let Some(_) = self.vendor_sw_version {
6710 return 5;
6711 }
6712 if let Some(_) = self.vendor_model {
6713 return 4;
6714 }
6715 if let Some(_) = self.vendor_name {
6716 return 3;
6717 }
6718 if let Some(_) = self.provisioning_url {
6719 return 2;
6720 }
6721 if let Some(_) = self.pskd {
6722 return 1;
6723 }
6724 0
6725 }
6726 }
6727
6728 impl fidl::encoding::ValueTypeMarker for JoinerCommissioningParams {
6729 type Borrowed<'a> = &'a Self;
6730 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6731 value
6732 }
6733 }
6734
6735 unsafe impl fidl::encoding::TypeMarker for JoinerCommissioningParams {
6736 type Owned = Self;
6737
6738 #[inline(always)]
6739 fn inline_align(_context: fidl::encoding::Context) -> usize {
6740 8
6741 }
6742
6743 #[inline(always)]
6744 fn inline_size(_context: fidl::encoding::Context) -> usize {
6745 16
6746 }
6747 }
6748
6749 unsafe impl<D: fidl::encoding::ResourceDialect>
6750 fidl::encoding::Encode<JoinerCommissioningParams, D> for &JoinerCommissioningParams
6751 {
6752 unsafe fn encode(
6753 self,
6754 encoder: &mut fidl::encoding::Encoder<'_, D>,
6755 offset: usize,
6756 mut depth: fidl::encoding::Depth,
6757 ) -> fidl::Result<()> {
6758 encoder.debug_check_bounds::<JoinerCommissioningParams>(offset);
6759 let max_ordinal: u64 = self.max_ordinal_present();
6761 encoder.write_num(max_ordinal, offset);
6762 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6763 if max_ordinal == 0 {
6765 return Ok(());
6766 }
6767 depth.increment()?;
6768 let envelope_size = 8;
6769 let bytes_len = max_ordinal as usize * envelope_size;
6770 #[allow(unused_variables)]
6771 let offset = encoder.out_of_line_offset(bytes_len);
6772 let mut _prev_end_offset: usize = 0;
6773 if 1 > max_ordinal {
6774 return Ok(());
6775 }
6776
6777 let cur_offset: usize = (1 - 1) * envelope_size;
6780
6781 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6783
6784 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6789 self.pskd.as_ref().map(
6790 <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6791 ),
6792 encoder,
6793 offset + cur_offset,
6794 depth,
6795 )?;
6796
6797 _prev_end_offset = cur_offset + envelope_size;
6798 if 2 > max_ordinal {
6799 return Ok(());
6800 }
6801
6802 let cur_offset: usize = (2 - 1) * envelope_size;
6805
6806 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6808
6809 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6814 self.provisioning_url.as_ref().map(
6815 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6816 ),
6817 encoder,
6818 offset + cur_offset,
6819 depth,
6820 )?;
6821
6822 _prev_end_offset = cur_offset + envelope_size;
6823 if 3 > max_ordinal {
6824 return Ok(());
6825 }
6826
6827 let cur_offset: usize = (3 - 1) * envelope_size;
6830
6831 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6833
6834 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6839 self.vendor_name.as_ref().map(
6840 <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6841 ),
6842 encoder,
6843 offset + cur_offset,
6844 depth,
6845 )?;
6846
6847 _prev_end_offset = cur_offset + envelope_size;
6848 if 4 > max_ordinal {
6849 return Ok(());
6850 }
6851
6852 let cur_offset: usize = (4 - 1) * envelope_size;
6855
6856 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6858
6859 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6864 self.vendor_model.as_ref().map(
6865 <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6866 ),
6867 encoder,
6868 offset + cur_offset,
6869 depth,
6870 )?;
6871
6872 _prev_end_offset = cur_offset + envelope_size;
6873 if 5 > max_ordinal {
6874 return Ok(());
6875 }
6876
6877 let cur_offset: usize = (5 - 1) * envelope_size;
6880
6881 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6883
6884 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<16>, D>(
6889 self.vendor_sw_version.as_ref().map(
6890 <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow,
6891 ),
6892 encoder,
6893 offset + cur_offset,
6894 depth,
6895 )?;
6896
6897 _prev_end_offset = cur_offset + envelope_size;
6898 if 6 > max_ordinal {
6899 return Ok(());
6900 }
6901
6902 let cur_offset: usize = (6 - 1) * envelope_size;
6905
6906 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6908
6909 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6914 self.vendor_data_string.as_ref().map(
6915 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6916 ),
6917 encoder,
6918 offset + cur_offset,
6919 depth,
6920 )?;
6921
6922 _prev_end_offset = cur_offset + envelope_size;
6923
6924 Ok(())
6925 }
6926 }
6927
6928 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6929 for JoinerCommissioningParams
6930 {
6931 #[inline(always)]
6932 fn new_empty() -> Self {
6933 Self::default()
6934 }
6935
6936 unsafe fn decode(
6937 &mut self,
6938 decoder: &mut fidl::encoding::Decoder<'_, D>,
6939 offset: usize,
6940 mut depth: fidl::encoding::Depth,
6941 ) -> fidl::Result<()> {
6942 decoder.debug_check_bounds::<Self>(offset);
6943 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6944 None => return Err(fidl::Error::NotNullable),
6945 Some(len) => len,
6946 };
6947 if len == 0 {
6949 return Ok(());
6950 };
6951 depth.increment()?;
6952 let envelope_size = 8;
6953 let bytes_len = len * envelope_size;
6954 let offset = decoder.out_of_line_offset(bytes_len)?;
6955 let mut _next_ordinal_to_read = 0;
6957 let mut next_offset = offset;
6958 let end_offset = offset + bytes_len;
6959 _next_ordinal_to_read += 1;
6960 if next_offset >= end_offset {
6961 return Ok(());
6962 }
6963
6964 while _next_ordinal_to_read < 1 {
6966 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6967 _next_ordinal_to_read += 1;
6968 next_offset += envelope_size;
6969 }
6970
6971 let next_out_of_line = decoder.next_out_of_line();
6972 let handles_before = decoder.remaining_handles();
6973 if let Some((inlined, num_bytes, num_handles)) =
6974 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6975 {
6976 let member_inline_size =
6977 <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
6978 decoder.context,
6979 );
6980 if inlined != (member_inline_size <= 4) {
6981 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6982 }
6983 let inner_offset;
6984 let mut inner_depth = depth.clone();
6985 if inlined {
6986 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6987 inner_offset = next_offset;
6988 } else {
6989 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6990 inner_depth.increment()?;
6991 }
6992 let val_ref = self
6993 .pskd
6994 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
6995 fidl::decode!(
6996 fidl::encoding::BoundedString<32>,
6997 D,
6998 val_ref,
6999 decoder,
7000 inner_offset,
7001 inner_depth
7002 )?;
7003 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7004 {
7005 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7006 }
7007 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7008 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7009 }
7010 }
7011
7012 next_offset += envelope_size;
7013 _next_ordinal_to_read += 1;
7014 if next_offset >= end_offset {
7015 return Ok(());
7016 }
7017
7018 while _next_ordinal_to_read < 2 {
7020 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7021 _next_ordinal_to_read += 1;
7022 next_offset += envelope_size;
7023 }
7024
7025 let next_out_of_line = decoder.next_out_of_line();
7026 let handles_before = decoder.remaining_handles();
7027 if let Some((inlined, num_bytes, num_handles)) =
7028 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7029 {
7030 let member_inline_size =
7031 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
7032 decoder.context,
7033 );
7034 if inlined != (member_inline_size <= 4) {
7035 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7036 }
7037 let inner_offset;
7038 let mut inner_depth = depth.clone();
7039 if inlined {
7040 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7041 inner_offset = next_offset;
7042 } else {
7043 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7044 inner_depth.increment()?;
7045 }
7046 let val_ref = self
7047 .provisioning_url
7048 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
7049 fidl::decode!(
7050 fidl::encoding::BoundedString<64>,
7051 D,
7052 val_ref,
7053 decoder,
7054 inner_offset,
7055 inner_depth
7056 )?;
7057 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7058 {
7059 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7060 }
7061 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7062 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7063 }
7064 }
7065
7066 next_offset += envelope_size;
7067 _next_ordinal_to_read += 1;
7068 if next_offset >= end_offset {
7069 return Ok(());
7070 }
7071
7072 while _next_ordinal_to_read < 3 {
7074 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7075 _next_ordinal_to_read += 1;
7076 next_offset += envelope_size;
7077 }
7078
7079 let next_out_of_line = decoder.next_out_of_line();
7080 let handles_before = decoder.remaining_handles();
7081 if let Some((inlined, num_bytes, num_handles)) =
7082 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7083 {
7084 let member_inline_size =
7085 <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
7086 decoder.context,
7087 );
7088 if inlined != (member_inline_size <= 4) {
7089 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7090 }
7091 let inner_offset;
7092 let mut inner_depth = depth.clone();
7093 if inlined {
7094 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7095 inner_offset = next_offset;
7096 } else {
7097 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7098 inner_depth.increment()?;
7099 }
7100 let val_ref = self
7101 .vendor_name
7102 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
7103 fidl::decode!(
7104 fidl::encoding::BoundedString<32>,
7105 D,
7106 val_ref,
7107 decoder,
7108 inner_offset,
7109 inner_depth
7110 )?;
7111 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7112 {
7113 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7114 }
7115 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7116 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7117 }
7118 }
7119
7120 next_offset += envelope_size;
7121 _next_ordinal_to_read += 1;
7122 if next_offset >= end_offset {
7123 return Ok(());
7124 }
7125
7126 while _next_ordinal_to_read < 4 {
7128 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7129 _next_ordinal_to_read += 1;
7130 next_offset += envelope_size;
7131 }
7132
7133 let next_out_of_line = decoder.next_out_of_line();
7134 let handles_before = decoder.remaining_handles();
7135 if let Some((inlined, num_bytes, num_handles)) =
7136 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7137 {
7138 let member_inline_size =
7139 <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
7140 decoder.context,
7141 );
7142 if inlined != (member_inline_size <= 4) {
7143 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7144 }
7145 let inner_offset;
7146 let mut inner_depth = depth.clone();
7147 if inlined {
7148 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7149 inner_offset = next_offset;
7150 } else {
7151 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7152 inner_depth.increment()?;
7153 }
7154 let val_ref = self
7155 .vendor_model
7156 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
7157 fidl::decode!(
7158 fidl::encoding::BoundedString<32>,
7159 D,
7160 val_ref,
7161 decoder,
7162 inner_offset,
7163 inner_depth
7164 )?;
7165 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7166 {
7167 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7168 }
7169 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7170 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7171 }
7172 }
7173
7174 next_offset += envelope_size;
7175 _next_ordinal_to_read += 1;
7176 if next_offset >= end_offset {
7177 return Ok(());
7178 }
7179
7180 while _next_ordinal_to_read < 5 {
7182 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7183 _next_ordinal_to_read += 1;
7184 next_offset += envelope_size;
7185 }
7186
7187 let next_out_of_line = decoder.next_out_of_line();
7188 let handles_before = decoder.remaining_handles();
7189 if let Some((inlined, num_bytes, num_handles)) =
7190 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7191 {
7192 let member_inline_size =
7193 <fidl::encoding::BoundedString<16> as fidl::encoding::TypeMarker>::inline_size(
7194 decoder.context,
7195 );
7196 if inlined != (member_inline_size <= 4) {
7197 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7198 }
7199 let inner_offset;
7200 let mut inner_depth = depth.clone();
7201 if inlined {
7202 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7203 inner_offset = next_offset;
7204 } else {
7205 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7206 inner_depth.increment()?;
7207 }
7208 let val_ref = self
7209 .vendor_sw_version
7210 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<16>, D));
7211 fidl::decode!(
7212 fidl::encoding::BoundedString<16>,
7213 D,
7214 val_ref,
7215 decoder,
7216 inner_offset,
7217 inner_depth
7218 )?;
7219 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7220 {
7221 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7222 }
7223 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7224 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7225 }
7226 }
7227
7228 next_offset += envelope_size;
7229 _next_ordinal_to_read += 1;
7230 if next_offset >= end_offset {
7231 return Ok(());
7232 }
7233
7234 while _next_ordinal_to_read < 6 {
7236 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7237 _next_ordinal_to_read += 1;
7238 next_offset += envelope_size;
7239 }
7240
7241 let next_out_of_line = decoder.next_out_of_line();
7242 let handles_before = decoder.remaining_handles();
7243 if let Some((inlined, num_bytes, num_handles)) =
7244 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7245 {
7246 let member_inline_size =
7247 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
7248 decoder.context,
7249 );
7250 if inlined != (member_inline_size <= 4) {
7251 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7252 }
7253 let inner_offset;
7254 let mut inner_depth = depth.clone();
7255 if inlined {
7256 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7257 inner_offset = next_offset;
7258 } else {
7259 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7260 inner_depth.increment()?;
7261 }
7262 let val_ref = self
7263 .vendor_data_string
7264 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
7265 fidl::decode!(
7266 fidl::encoding::BoundedString<64>,
7267 D,
7268 val_ref,
7269 decoder,
7270 inner_offset,
7271 inner_depth
7272 )?;
7273 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7274 {
7275 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7276 }
7277 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7278 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7279 }
7280 }
7281
7282 next_offset += envelope_size;
7283
7284 while next_offset < end_offset {
7286 _next_ordinal_to_read += 1;
7287 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7288 next_offset += envelope_size;
7289 }
7290
7291 Ok(())
7292 }
7293 }
7294
7295 impl LeaderData {
7296 #[inline(always)]
7297 fn max_ordinal_present(&self) -> u64 {
7298 if let Some(_) = self.router_id {
7299 return 5;
7300 }
7301 if let Some(_) = self.stable_network_data_version {
7302 return 4;
7303 }
7304 if let Some(_) = self.network_data_version {
7305 return 3;
7306 }
7307 if let Some(_) = self.weight {
7308 return 2;
7309 }
7310 if let Some(_) = self.partition_id {
7311 return 1;
7312 }
7313 0
7314 }
7315 }
7316
7317 impl fidl::encoding::ValueTypeMarker for LeaderData {
7318 type Borrowed<'a> = &'a Self;
7319 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7320 value
7321 }
7322 }
7323
7324 unsafe impl fidl::encoding::TypeMarker for LeaderData {
7325 type Owned = Self;
7326
7327 #[inline(always)]
7328 fn inline_align(_context: fidl::encoding::Context) -> usize {
7329 8
7330 }
7331
7332 #[inline(always)]
7333 fn inline_size(_context: fidl::encoding::Context) -> usize {
7334 16
7335 }
7336 }
7337
7338 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LeaderData, D>
7339 for &LeaderData
7340 {
7341 unsafe fn encode(
7342 self,
7343 encoder: &mut fidl::encoding::Encoder<'_, D>,
7344 offset: usize,
7345 mut depth: fidl::encoding::Depth,
7346 ) -> fidl::Result<()> {
7347 encoder.debug_check_bounds::<LeaderData>(offset);
7348 let max_ordinal: u64 = self.max_ordinal_present();
7350 encoder.write_num(max_ordinal, offset);
7351 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7352 if max_ordinal == 0 {
7354 return Ok(());
7355 }
7356 depth.increment()?;
7357 let envelope_size = 8;
7358 let bytes_len = max_ordinal as usize * envelope_size;
7359 #[allow(unused_variables)]
7360 let offset = encoder.out_of_line_offset(bytes_len);
7361 let mut _prev_end_offset: usize = 0;
7362 if 1 > max_ordinal {
7363 return Ok(());
7364 }
7365
7366 let cur_offset: usize = (1 - 1) * envelope_size;
7369
7370 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7372
7373 fidl::encoding::encode_in_envelope_optional::<u32, D>(
7378 self.partition_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7379 encoder,
7380 offset + cur_offset,
7381 depth,
7382 )?;
7383
7384 _prev_end_offset = cur_offset + envelope_size;
7385 if 2 > max_ordinal {
7386 return Ok(());
7387 }
7388
7389 let cur_offset: usize = (2 - 1) * envelope_size;
7392
7393 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7395
7396 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7401 self.weight.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7402 encoder,
7403 offset + cur_offset,
7404 depth,
7405 )?;
7406
7407 _prev_end_offset = cur_offset + envelope_size;
7408 if 3 > max_ordinal {
7409 return Ok(());
7410 }
7411
7412 let cur_offset: usize = (3 - 1) * envelope_size;
7415
7416 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7418
7419 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7424 self.network_data_version
7425 .as_ref()
7426 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7427 encoder,
7428 offset + cur_offset,
7429 depth,
7430 )?;
7431
7432 _prev_end_offset = cur_offset + envelope_size;
7433 if 4 > max_ordinal {
7434 return Ok(());
7435 }
7436
7437 let cur_offset: usize = (4 - 1) * envelope_size;
7440
7441 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7443
7444 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7449 self.stable_network_data_version
7450 .as_ref()
7451 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7452 encoder,
7453 offset + cur_offset,
7454 depth,
7455 )?;
7456
7457 _prev_end_offset = cur_offset + envelope_size;
7458 if 5 > max_ordinal {
7459 return Ok(());
7460 }
7461
7462 let cur_offset: usize = (5 - 1) * envelope_size;
7465
7466 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7468
7469 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7474 self.router_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7475 encoder,
7476 offset + cur_offset,
7477 depth,
7478 )?;
7479
7480 _prev_end_offset = cur_offset + envelope_size;
7481
7482 Ok(())
7483 }
7484 }
7485
7486 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeaderData {
7487 #[inline(always)]
7488 fn new_empty() -> Self {
7489 Self::default()
7490 }
7491
7492 unsafe fn decode(
7493 &mut self,
7494 decoder: &mut fidl::encoding::Decoder<'_, D>,
7495 offset: usize,
7496 mut depth: fidl::encoding::Depth,
7497 ) -> fidl::Result<()> {
7498 decoder.debug_check_bounds::<Self>(offset);
7499 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7500 None => return Err(fidl::Error::NotNullable),
7501 Some(len) => len,
7502 };
7503 if len == 0 {
7505 return Ok(());
7506 };
7507 depth.increment()?;
7508 let envelope_size = 8;
7509 let bytes_len = len * envelope_size;
7510 let offset = decoder.out_of_line_offset(bytes_len)?;
7511 let mut _next_ordinal_to_read = 0;
7513 let mut next_offset = offset;
7514 let end_offset = offset + bytes_len;
7515 _next_ordinal_to_read += 1;
7516 if next_offset >= end_offset {
7517 return Ok(());
7518 }
7519
7520 while _next_ordinal_to_read < 1 {
7522 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7523 _next_ordinal_to_read += 1;
7524 next_offset += envelope_size;
7525 }
7526
7527 let next_out_of_line = decoder.next_out_of_line();
7528 let handles_before = decoder.remaining_handles();
7529 if let Some((inlined, num_bytes, num_handles)) =
7530 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7531 {
7532 let member_inline_size =
7533 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7534 if inlined != (member_inline_size <= 4) {
7535 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7536 }
7537 let inner_offset;
7538 let mut inner_depth = depth.clone();
7539 if inlined {
7540 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7541 inner_offset = next_offset;
7542 } else {
7543 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7544 inner_depth.increment()?;
7545 }
7546 let val_ref = self.partition_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
7547 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7548 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7549 {
7550 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7551 }
7552 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7553 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7554 }
7555 }
7556
7557 next_offset += envelope_size;
7558 _next_ordinal_to_read += 1;
7559 if next_offset >= end_offset {
7560 return Ok(());
7561 }
7562
7563 while _next_ordinal_to_read < 2 {
7565 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7566 _next_ordinal_to_read += 1;
7567 next_offset += envelope_size;
7568 }
7569
7570 let next_out_of_line = decoder.next_out_of_line();
7571 let handles_before = decoder.remaining_handles();
7572 if let Some((inlined, num_bytes, num_handles)) =
7573 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7574 {
7575 let member_inline_size =
7576 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7577 if inlined != (member_inline_size <= 4) {
7578 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7579 }
7580 let inner_offset;
7581 let mut inner_depth = depth.clone();
7582 if inlined {
7583 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7584 inner_offset = next_offset;
7585 } else {
7586 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7587 inner_depth.increment()?;
7588 }
7589 let val_ref = self.weight.get_or_insert_with(|| fidl::new_empty!(u8, D));
7590 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7591 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7592 {
7593 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7594 }
7595 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7596 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7597 }
7598 }
7599
7600 next_offset += envelope_size;
7601 _next_ordinal_to_read += 1;
7602 if next_offset >= end_offset {
7603 return Ok(());
7604 }
7605
7606 while _next_ordinal_to_read < 3 {
7608 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7609 _next_ordinal_to_read += 1;
7610 next_offset += envelope_size;
7611 }
7612
7613 let next_out_of_line = decoder.next_out_of_line();
7614 let handles_before = decoder.remaining_handles();
7615 if let Some((inlined, num_bytes, num_handles)) =
7616 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7617 {
7618 let member_inline_size =
7619 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7620 if inlined != (member_inline_size <= 4) {
7621 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7622 }
7623 let inner_offset;
7624 let mut inner_depth = depth.clone();
7625 if inlined {
7626 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7627 inner_offset = next_offset;
7628 } else {
7629 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7630 inner_depth.increment()?;
7631 }
7632 let val_ref =
7633 self.network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
7634 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7635 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7636 {
7637 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7638 }
7639 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7640 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7641 }
7642 }
7643
7644 next_offset += envelope_size;
7645 _next_ordinal_to_read += 1;
7646 if next_offset >= end_offset {
7647 return Ok(());
7648 }
7649
7650 while _next_ordinal_to_read < 4 {
7652 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7653 _next_ordinal_to_read += 1;
7654 next_offset += envelope_size;
7655 }
7656
7657 let next_out_of_line = decoder.next_out_of_line();
7658 let handles_before = decoder.remaining_handles();
7659 if let Some((inlined, num_bytes, num_handles)) =
7660 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7661 {
7662 let member_inline_size =
7663 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7664 if inlined != (member_inline_size <= 4) {
7665 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7666 }
7667 let inner_offset;
7668 let mut inner_depth = depth.clone();
7669 if inlined {
7670 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7671 inner_offset = next_offset;
7672 } else {
7673 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7674 inner_depth.increment()?;
7675 }
7676 let val_ref =
7677 self.stable_network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
7678 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7679 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7680 {
7681 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7682 }
7683 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7684 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7685 }
7686 }
7687
7688 next_offset += envelope_size;
7689 _next_ordinal_to_read += 1;
7690 if next_offset >= end_offset {
7691 return Ok(());
7692 }
7693
7694 while _next_ordinal_to_read < 5 {
7696 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7697 _next_ordinal_to_read += 1;
7698 next_offset += envelope_size;
7699 }
7700
7701 let next_out_of_line = decoder.next_out_of_line();
7702 let handles_before = decoder.remaining_handles();
7703 if let Some((inlined, num_bytes, num_handles)) =
7704 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7705 {
7706 let member_inline_size =
7707 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7708 if inlined != (member_inline_size <= 4) {
7709 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7710 }
7711 let inner_offset;
7712 let mut inner_depth = depth.clone();
7713 if inlined {
7714 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7715 inner_offset = next_offset;
7716 } else {
7717 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7718 inner_depth.increment()?;
7719 }
7720 let val_ref = self.router_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
7721 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7722 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7723 {
7724 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7725 }
7726 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7727 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7728 }
7729 }
7730
7731 next_offset += envelope_size;
7732
7733 while next_offset < end_offset {
7735 _next_ordinal_to_read += 1;
7736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7737 next_offset += envelope_size;
7738 }
7739
7740 Ok(())
7741 }
7742 }
7743
7744 impl LinkMetricsEntry {
7745 #[inline(always)]
7746 fn max_ordinal_present(&self) -> u64 {
7747 if let Some(_) = self.rssi {
7748 return 2;
7749 }
7750 if let Some(_) = self.link_margin {
7751 return 1;
7752 }
7753 0
7754 }
7755 }
7756
7757 impl fidl::encoding::ValueTypeMarker for LinkMetricsEntry {
7758 type Borrowed<'a> = &'a Self;
7759 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7760 value
7761 }
7762 }
7763
7764 unsafe impl fidl::encoding::TypeMarker for LinkMetricsEntry {
7765 type Owned = Self;
7766
7767 #[inline(always)]
7768 fn inline_align(_context: fidl::encoding::Context) -> usize {
7769 8
7770 }
7771
7772 #[inline(always)]
7773 fn inline_size(_context: fidl::encoding::Context) -> usize {
7774 16
7775 }
7776 }
7777
7778 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LinkMetricsEntry, D>
7779 for &LinkMetricsEntry
7780 {
7781 unsafe fn encode(
7782 self,
7783 encoder: &mut fidl::encoding::Encoder<'_, D>,
7784 offset: usize,
7785 mut depth: fidl::encoding::Depth,
7786 ) -> fidl::Result<()> {
7787 encoder.debug_check_bounds::<LinkMetricsEntry>(offset);
7788 let max_ordinal: u64 = self.max_ordinal_present();
7790 encoder.write_num(max_ordinal, offset);
7791 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7792 if max_ordinal == 0 {
7794 return Ok(());
7795 }
7796 depth.increment()?;
7797 let envelope_size = 8;
7798 let bytes_len = max_ordinal as usize * envelope_size;
7799 #[allow(unused_variables)]
7800 let offset = encoder.out_of_line_offset(bytes_len);
7801 let mut _prev_end_offset: usize = 0;
7802 if 1 > max_ordinal {
7803 return Ok(());
7804 }
7805
7806 let cur_offset: usize = (1 - 1) * envelope_size;
7809
7810 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7812
7813 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7818 self.link_margin.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7819 encoder,
7820 offset + cur_offset,
7821 depth,
7822 )?;
7823
7824 _prev_end_offset = cur_offset + envelope_size;
7825 if 2 > max_ordinal {
7826 return Ok(());
7827 }
7828
7829 let cur_offset: usize = (2 - 1) * envelope_size;
7832
7833 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7835
7836 fidl::encoding::encode_in_envelope_optional::<i8, D>(
7841 self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
7842 encoder,
7843 offset + cur_offset,
7844 depth,
7845 )?;
7846
7847 _prev_end_offset = cur_offset + envelope_size;
7848
7849 Ok(())
7850 }
7851 }
7852
7853 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LinkMetricsEntry {
7854 #[inline(always)]
7855 fn new_empty() -> Self {
7856 Self::default()
7857 }
7858
7859 unsafe fn decode(
7860 &mut self,
7861 decoder: &mut fidl::encoding::Decoder<'_, D>,
7862 offset: usize,
7863 mut depth: fidl::encoding::Depth,
7864 ) -> fidl::Result<()> {
7865 decoder.debug_check_bounds::<Self>(offset);
7866 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7867 None => return Err(fidl::Error::NotNullable),
7868 Some(len) => len,
7869 };
7870 if len == 0 {
7872 return Ok(());
7873 };
7874 depth.increment()?;
7875 let envelope_size = 8;
7876 let bytes_len = len * envelope_size;
7877 let offset = decoder.out_of_line_offset(bytes_len)?;
7878 let mut _next_ordinal_to_read = 0;
7880 let mut next_offset = offset;
7881 let end_offset = offset + bytes_len;
7882 _next_ordinal_to_read += 1;
7883 if next_offset >= end_offset {
7884 return Ok(());
7885 }
7886
7887 while _next_ordinal_to_read < 1 {
7889 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7890 _next_ordinal_to_read += 1;
7891 next_offset += envelope_size;
7892 }
7893
7894 let next_out_of_line = decoder.next_out_of_line();
7895 let handles_before = decoder.remaining_handles();
7896 if let Some((inlined, num_bytes, num_handles)) =
7897 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7898 {
7899 let member_inline_size =
7900 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7901 if inlined != (member_inline_size <= 4) {
7902 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7903 }
7904 let inner_offset;
7905 let mut inner_depth = depth.clone();
7906 if inlined {
7907 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7908 inner_offset = next_offset;
7909 } else {
7910 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7911 inner_depth.increment()?;
7912 }
7913 let val_ref = self.link_margin.get_or_insert_with(|| fidl::new_empty!(u8, D));
7914 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7915 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7916 {
7917 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7918 }
7919 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7920 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7921 }
7922 }
7923
7924 next_offset += envelope_size;
7925 _next_ordinal_to_read += 1;
7926 if next_offset >= end_offset {
7927 return Ok(());
7928 }
7929
7930 while _next_ordinal_to_read < 2 {
7932 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7933 _next_ordinal_to_read += 1;
7934 next_offset += envelope_size;
7935 }
7936
7937 let next_out_of_line = decoder.next_out_of_line();
7938 let handles_before = decoder.remaining_handles();
7939 if let Some((inlined, num_bytes, num_handles)) =
7940 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7941 {
7942 let member_inline_size =
7943 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7944 if inlined != (member_inline_size <= 4) {
7945 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7946 }
7947 let inner_offset;
7948 let mut inner_depth = depth.clone();
7949 if inlined {
7950 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7951 inner_offset = next_offset;
7952 } else {
7953 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7954 inner_depth.increment()?;
7955 }
7956 let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
7957 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
7958 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7959 {
7960 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7961 }
7962 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7963 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7964 }
7965 }
7966
7967 next_offset += envelope_size;
7968
7969 while next_offset < end_offset {
7971 _next_ordinal_to_read += 1;
7972 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7973 next_offset += envelope_size;
7974 }
7975
7976 Ok(())
7977 }
7978 }
7979
7980 impl Nat64ErrorCounters {
7981 #[inline(always)]
7982 fn max_ordinal_present(&self) -> u64 {
7983 if let Some(_) = self.no_mapping {
7984 return 4;
7985 }
7986 if let Some(_) = self.unsupported_protocol {
7987 return 3;
7988 }
7989 if let Some(_) = self.illegal_packet {
7990 return 2;
7991 }
7992 if let Some(_) = self.unknown {
7993 return 1;
7994 }
7995 0
7996 }
7997 }
7998
7999 impl fidl::encoding::ValueTypeMarker for Nat64ErrorCounters {
8000 type Borrowed<'a> = &'a Self;
8001 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8002 value
8003 }
8004 }
8005
8006 unsafe impl fidl::encoding::TypeMarker for Nat64ErrorCounters {
8007 type Owned = Self;
8008
8009 #[inline(always)]
8010 fn inline_align(_context: fidl::encoding::Context) -> usize {
8011 8
8012 }
8013
8014 #[inline(always)]
8015 fn inline_size(_context: fidl::encoding::Context) -> usize {
8016 16
8017 }
8018 }
8019
8020 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64ErrorCounters, D>
8021 for &Nat64ErrorCounters
8022 {
8023 unsafe fn encode(
8024 self,
8025 encoder: &mut fidl::encoding::Encoder<'_, D>,
8026 offset: usize,
8027 mut depth: fidl::encoding::Depth,
8028 ) -> fidl::Result<()> {
8029 encoder.debug_check_bounds::<Nat64ErrorCounters>(offset);
8030 let max_ordinal: u64 = self.max_ordinal_present();
8032 encoder.write_num(max_ordinal, offset);
8033 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8034 if max_ordinal == 0 {
8036 return Ok(());
8037 }
8038 depth.increment()?;
8039 let envelope_size = 8;
8040 let bytes_len = max_ordinal as usize * envelope_size;
8041 #[allow(unused_variables)]
8042 let offset = encoder.out_of_line_offset(bytes_len);
8043 let mut _prev_end_offset: usize = 0;
8044 if 1 > max_ordinal {
8045 return Ok(());
8046 }
8047
8048 let cur_offset: usize = (1 - 1) * envelope_size;
8051
8052 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8054
8055 fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8060 self.unknown
8061 .as_ref()
8062 .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8063 encoder,
8064 offset + cur_offset,
8065 depth,
8066 )?;
8067
8068 _prev_end_offset = cur_offset + envelope_size;
8069 if 2 > max_ordinal {
8070 return Ok(());
8071 }
8072
8073 let cur_offset: usize = (2 - 1) * envelope_size;
8076
8077 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8079
8080 fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8085 self.illegal_packet
8086 .as_ref()
8087 .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8088 encoder,
8089 offset + cur_offset,
8090 depth,
8091 )?;
8092
8093 _prev_end_offset = cur_offset + envelope_size;
8094 if 3 > max_ordinal {
8095 return Ok(());
8096 }
8097
8098 let cur_offset: usize = (3 - 1) * envelope_size;
8101
8102 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8104
8105 fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8110 self.unsupported_protocol
8111 .as_ref()
8112 .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8113 encoder,
8114 offset + cur_offset,
8115 depth,
8116 )?;
8117
8118 _prev_end_offset = cur_offset + envelope_size;
8119 if 4 > max_ordinal {
8120 return Ok(());
8121 }
8122
8123 let cur_offset: usize = (4 - 1) * envelope_size;
8126
8127 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8129
8130 fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8135 self.no_mapping
8136 .as_ref()
8137 .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8138 encoder,
8139 offset + cur_offset,
8140 depth,
8141 )?;
8142
8143 _prev_end_offset = cur_offset + envelope_size;
8144
8145 Ok(())
8146 }
8147 }
8148
8149 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64ErrorCounters {
8150 #[inline(always)]
8151 fn new_empty() -> Self {
8152 Self::default()
8153 }
8154
8155 unsafe fn decode(
8156 &mut self,
8157 decoder: &mut fidl::encoding::Decoder<'_, D>,
8158 offset: usize,
8159 mut depth: fidl::encoding::Depth,
8160 ) -> fidl::Result<()> {
8161 decoder.debug_check_bounds::<Self>(offset);
8162 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8163 None => return Err(fidl::Error::NotNullable),
8164 Some(len) => len,
8165 };
8166 if len == 0 {
8168 return Ok(());
8169 };
8170 depth.increment()?;
8171 let envelope_size = 8;
8172 let bytes_len = len * envelope_size;
8173 let offset = decoder.out_of_line_offset(bytes_len)?;
8174 let mut _next_ordinal_to_read = 0;
8176 let mut next_offset = offset;
8177 let end_offset = offset + bytes_len;
8178 _next_ordinal_to_read += 1;
8179 if next_offset >= end_offset {
8180 return Ok(());
8181 }
8182
8183 while _next_ordinal_to_read < 1 {
8185 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8186 _next_ordinal_to_read += 1;
8187 next_offset += envelope_size;
8188 }
8189
8190 let next_out_of_line = decoder.next_out_of_line();
8191 let handles_before = decoder.remaining_handles();
8192 if let Some((inlined, num_bytes, num_handles)) =
8193 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8194 {
8195 let member_inline_size =
8196 <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8197 decoder.context,
8198 );
8199 if inlined != (member_inline_size <= 4) {
8200 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8201 }
8202 let inner_offset;
8203 let mut inner_depth = depth.clone();
8204 if inlined {
8205 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8206 inner_offset = next_offset;
8207 } else {
8208 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8209 inner_depth.increment()?;
8210 }
8211 let val_ref =
8212 self.unknown.get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8213 fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8214 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8215 {
8216 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8217 }
8218 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8219 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8220 }
8221 }
8222
8223 next_offset += envelope_size;
8224 _next_ordinal_to_read += 1;
8225 if next_offset >= end_offset {
8226 return Ok(());
8227 }
8228
8229 while _next_ordinal_to_read < 2 {
8231 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8232 _next_ordinal_to_read += 1;
8233 next_offset += envelope_size;
8234 }
8235
8236 let next_out_of_line = decoder.next_out_of_line();
8237 let handles_before = decoder.remaining_handles();
8238 if let Some((inlined, num_bytes, num_handles)) =
8239 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8240 {
8241 let member_inline_size =
8242 <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8243 decoder.context,
8244 );
8245 if inlined != (member_inline_size <= 4) {
8246 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8247 }
8248 let inner_offset;
8249 let mut inner_depth = depth.clone();
8250 if inlined {
8251 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8252 inner_offset = next_offset;
8253 } else {
8254 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8255 inner_depth.increment()?;
8256 }
8257 let val_ref = self
8258 .illegal_packet
8259 .get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8260 fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8261 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8262 {
8263 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8264 }
8265 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8266 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8267 }
8268 }
8269
8270 next_offset += envelope_size;
8271 _next_ordinal_to_read += 1;
8272 if next_offset >= end_offset {
8273 return Ok(());
8274 }
8275
8276 while _next_ordinal_to_read < 3 {
8278 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8279 _next_ordinal_to_read += 1;
8280 next_offset += envelope_size;
8281 }
8282
8283 let next_out_of_line = decoder.next_out_of_line();
8284 let handles_before = decoder.remaining_handles();
8285 if let Some((inlined, num_bytes, num_handles)) =
8286 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8287 {
8288 let member_inline_size =
8289 <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8290 decoder.context,
8291 );
8292 if inlined != (member_inline_size <= 4) {
8293 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8294 }
8295 let inner_offset;
8296 let mut inner_depth = depth.clone();
8297 if inlined {
8298 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8299 inner_offset = next_offset;
8300 } else {
8301 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8302 inner_depth.increment()?;
8303 }
8304 let val_ref = self
8305 .unsupported_protocol
8306 .get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8307 fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8308 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8309 {
8310 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8311 }
8312 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8313 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8314 }
8315 }
8316
8317 next_offset += envelope_size;
8318 _next_ordinal_to_read += 1;
8319 if next_offset >= end_offset {
8320 return Ok(());
8321 }
8322
8323 while _next_ordinal_to_read < 4 {
8325 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8326 _next_ordinal_to_read += 1;
8327 next_offset += envelope_size;
8328 }
8329
8330 let next_out_of_line = decoder.next_out_of_line();
8331 let handles_before = decoder.remaining_handles();
8332 if let Some((inlined, num_bytes, num_handles)) =
8333 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8334 {
8335 let member_inline_size =
8336 <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8337 decoder.context,
8338 );
8339 if inlined != (member_inline_size <= 4) {
8340 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8341 }
8342 let inner_offset;
8343 let mut inner_depth = depth.clone();
8344 if inlined {
8345 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8346 inner_offset = next_offset;
8347 } else {
8348 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8349 inner_depth.increment()?;
8350 }
8351 let val_ref =
8352 self.no_mapping.get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8353 fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8354 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8355 {
8356 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8357 }
8358 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8359 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8360 }
8361 }
8362
8363 next_offset += envelope_size;
8364
8365 while next_offset < end_offset {
8367 _next_ordinal_to_read += 1;
8368 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8369 next_offset += envelope_size;
8370 }
8371
8372 Ok(())
8373 }
8374 }
8375
8376 impl Nat64Info {
8377 #[inline(always)]
8378 fn max_ordinal_present(&self) -> u64 {
8379 if let Some(_) = self.nat64_protocol_counters {
8380 return 4;
8381 }
8382 if let Some(_) = self.nat64_error_counters {
8383 return 3;
8384 }
8385 if let Some(_) = self.nat64_mappings {
8386 return 2;
8387 }
8388 if let Some(_) = self.nat64_state {
8389 return 1;
8390 }
8391 0
8392 }
8393 }
8394
8395 impl fidl::encoding::ValueTypeMarker for Nat64Info {
8396 type Borrowed<'a> = &'a Self;
8397 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8398 value
8399 }
8400 }
8401
8402 unsafe impl fidl::encoding::TypeMarker for Nat64Info {
8403 type Owned = Self;
8404
8405 #[inline(always)]
8406 fn inline_align(_context: fidl::encoding::Context) -> usize {
8407 8
8408 }
8409
8410 #[inline(always)]
8411 fn inline_size(_context: fidl::encoding::Context) -> usize {
8412 16
8413 }
8414 }
8415
8416 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64Info, D>
8417 for &Nat64Info
8418 {
8419 unsafe fn encode(
8420 self,
8421 encoder: &mut fidl::encoding::Encoder<'_, D>,
8422 offset: usize,
8423 mut depth: fidl::encoding::Depth,
8424 ) -> fidl::Result<()> {
8425 encoder.debug_check_bounds::<Nat64Info>(offset);
8426 let max_ordinal: u64 = self.max_ordinal_present();
8428 encoder.write_num(max_ordinal, offset);
8429 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8430 if max_ordinal == 0 {
8432 return Ok(());
8433 }
8434 depth.increment()?;
8435 let envelope_size = 8;
8436 let bytes_len = max_ordinal as usize * envelope_size;
8437 #[allow(unused_variables)]
8438 let offset = encoder.out_of_line_offset(bytes_len);
8439 let mut _prev_end_offset: usize = 0;
8440 if 1 > max_ordinal {
8441 return Ok(());
8442 }
8443
8444 let cur_offset: usize = (1 - 1) * envelope_size;
8447
8448 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8450
8451 fidl::encoding::encode_in_envelope_optional::<BorderRoutingNat64State, D>(
8456 self.nat64_state
8457 .as_ref()
8458 .map(<BorderRoutingNat64State as fidl::encoding::ValueTypeMarker>::borrow),
8459 encoder,
8460 offset + cur_offset,
8461 depth,
8462 )?;
8463
8464 _prev_end_offset = cur_offset + envelope_size;
8465 if 2 > max_ordinal {
8466 return Ok(());
8467 }
8468
8469 let cur_offset: usize = (2 - 1) * envelope_size;
8472
8473 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8475
8476 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Nat64Mapping>, D>(
8481 self.nat64_mappings.as_ref().map(<fidl::encoding::UnboundedVector<Nat64Mapping> as fidl::encoding::ValueTypeMarker>::borrow),
8482 encoder, offset + cur_offset, depth
8483 )?;
8484
8485 _prev_end_offset = cur_offset + envelope_size;
8486 if 3 > max_ordinal {
8487 return Ok(());
8488 }
8489
8490 let cur_offset: usize = (3 - 1) * envelope_size;
8493
8494 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8496
8497 fidl::encoding::encode_in_envelope_optional::<Nat64ErrorCounters, D>(
8502 self.nat64_error_counters
8503 .as_ref()
8504 .map(<Nat64ErrorCounters as fidl::encoding::ValueTypeMarker>::borrow),
8505 encoder,
8506 offset + cur_offset,
8507 depth,
8508 )?;
8509
8510 _prev_end_offset = cur_offset + envelope_size;
8511 if 4 > max_ordinal {
8512 return Ok(());
8513 }
8514
8515 let cur_offset: usize = (4 - 1) * envelope_size;
8518
8519 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8521
8522 fidl::encoding::encode_in_envelope_optional::<Nat64ProtocolCounters, D>(
8527 self.nat64_protocol_counters
8528 .as_ref()
8529 .map(<Nat64ProtocolCounters as fidl::encoding::ValueTypeMarker>::borrow),
8530 encoder,
8531 offset + cur_offset,
8532 depth,
8533 )?;
8534
8535 _prev_end_offset = cur_offset + envelope_size;
8536
8537 Ok(())
8538 }
8539 }
8540
8541 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64Info {
8542 #[inline(always)]
8543 fn new_empty() -> Self {
8544 Self::default()
8545 }
8546
8547 unsafe fn decode(
8548 &mut self,
8549 decoder: &mut fidl::encoding::Decoder<'_, D>,
8550 offset: usize,
8551 mut depth: fidl::encoding::Depth,
8552 ) -> fidl::Result<()> {
8553 decoder.debug_check_bounds::<Self>(offset);
8554 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8555 None => return Err(fidl::Error::NotNullable),
8556 Some(len) => len,
8557 };
8558 if len == 0 {
8560 return Ok(());
8561 };
8562 depth.increment()?;
8563 let envelope_size = 8;
8564 let bytes_len = len * envelope_size;
8565 let offset = decoder.out_of_line_offset(bytes_len)?;
8566 let mut _next_ordinal_to_read = 0;
8568 let mut next_offset = offset;
8569 let end_offset = offset + bytes_len;
8570 _next_ordinal_to_read += 1;
8571 if next_offset >= end_offset {
8572 return Ok(());
8573 }
8574
8575 while _next_ordinal_to_read < 1 {
8577 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8578 _next_ordinal_to_read += 1;
8579 next_offset += envelope_size;
8580 }
8581
8582 let next_out_of_line = decoder.next_out_of_line();
8583 let handles_before = decoder.remaining_handles();
8584 if let Some((inlined, num_bytes, num_handles)) =
8585 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8586 {
8587 let member_inline_size =
8588 <BorderRoutingNat64State as fidl::encoding::TypeMarker>::inline_size(
8589 decoder.context,
8590 );
8591 if inlined != (member_inline_size <= 4) {
8592 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8593 }
8594 let inner_offset;
8595 let mut inner_depth = depth.clone();
8596 if inlined {
8597 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8598 inner_offset = next_offset;
8599 } else {
8600 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8601 inner_depth.increment()?;
8602 }
8603 let val_ref = self
8604 .nat64_state
8605 .get_or_insert_with(|| fidl::new_empty!(BorderRoutingNat64State, D));
8606 fidl::decode!(
8607 BorderRoutingNat64State,
8608 D,
8609 val_ref,
8610 decoder,
8611 inner_offset,
8612 inner_depth
8613 )?;
8614 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8615 {
8616 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8617 }
8618 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8619 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8620 }
8621 }
8622
8623 next_offset += envelope_size;
8624 _next_ordinal_to_read += 1;
8625 if next_offset >= end_offset {
8626 return Ok(());
8627 }
8628
8629 while _next_ordinal_to_read < 2 {
8631 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8632 _next_ordinal_to_read += 1;
8633 next_offset += envelope_size;
8634 }
8635
8636 let next_out_of_line = decoder.next_out_of_line();
8637 let handles_before = decoder.remaining_handles();
8638 if let Some((inlined, num_bytes, num_handles)) =
8639 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8640 {
8641 let member_inline_size = <fidl::encoding::UnboundedVector<Nat64Mapping> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8642 if inlined != (member_inline_size <= 4) {
8643 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8644 }
8645 let inner_offset;
8646 let mut inner_depth = depth.clone();
8647 if inlined {
8648 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8649 inner_offset = next_offset;
8650 } else {
8651 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8652 inner_depth.increment()?;
8653 }
8654 let val_ref = self.nat64_mappings.get_or_insert_with(|| {
8655 fidl::new_empty!(fidl::encoding::UnboundedVector<Nat64Mapping>, D)
8656 });
8657 fidl::decode!(
8658 fidl::encoding::UnboundedVector<Nat64Mapping>,
8659 D,
8660 val_ref,
8661 decoder,
8662 inner_offset,
8663 inner_depth
8664 )?;
8665 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8666 {
8667 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8668 }
8669 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8670 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8671 }
8672 }
8673
8674 next_offset += envelope_size;
8675 _next_ordinal_to_read += 1;
8676 if next_offset >= end_offset {
8677 return Ok(());
8678 }
8679
8680 while _next_ordinal_to_read < 3 {
8682 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8683 _next_ordinal_to_read += 1;
8684 next_offset += envelope_size;
8685 }
8686
8687 let next_out_of_line = decoder.next_out_of_line();
8688 let handles_before = decoder.remaining_handles();
8689 if let Some((inlined, num_bytes, num_handles)) =
8690 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8691 {
8692 let member_inline_size =
8693 <Nat64ErrorCounters as fidl::encoding::TypeMarker>::inline_size(
8694 decoder.context,
8695 );
8696 if inlined != (member_inline_size <= 4) {
8697 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8698 }
8699 let inner_offset;
8700 let mut inner_depth = depth.clone();
8701 if inlined {
8702 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8703 inner_offset = next_offset;
8704 } else {
8705 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8706 inner_depth.increment()?;
8707 }
8708 let val_ref = self
8709 .nat64_error_counters
8710 .get_or_insert_with(|| fidl::new_empty!(Nat64ErrorCounters, D));
8711 fidl::decode!(Nat64ErrorCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8712 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8713 {
8714 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8715 }
8716 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8717 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8718 }
8719 }
8720
8721 next_offset += envelope_size;
8722 _next_ordinal_to_read += 1;
8723 if next_offset >= end_offset {
8724 return Ok(());
8725 }
8726
8727 while _next_ordinal_to_read < 4 {
8729 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8730 _next_ordinal_to_read += 1;
8731 next_offset += envelope_size;
8732 }
8733
8734 let next_out_of_line = decoder.next_out_of_line();
8735 let handles_before = decoder.remaining_handles();
8736 if let Some((inlined, num_bytes, num_handles)) =
8737 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8738 {
8739 let member_inline_size =
8740 <Nat64ProtocolCounters as fidl::encoding::TypeMarker>::inline_size(
8741 decoder.context,
8742 );
8743 if inlined != (member_inline_size <= 4) {
8744 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8745 }
8746 let inner_offset;
8747 let mut inner_depth = depth.clone();
8748 if inlined {
8749 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8750 inner_offset = next_offset;
8751 } else {
8752 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8753 inner_depth.increment()?;
8754 }
8755 let val_ref = self
8756 .nat64_protocol_counters
8757 .get_or_insert_with(|| fidl::new_empty!(Nat64ProtocolCounters, D));
8758 fidl::decode!(
8759 Nat64ProtocolCounters,
8760 D,
8761 val_ref,
8762 decoder,
8763 inner_offset,
8764 inner_depth
8765 )?;
8766 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8767 {
8768 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8769 }
8770 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8771 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8772 }
8773 }
8774
8775 next_offset += envelope_size;
8776
8777 while next_offset < end_offset {
8779 _next_ordinal_to_read += 1;
8780 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8781 next_offset += envelope_size;
8782 }
8783
8784 Ok(())
8785 }
8786 }
8787
8788 impl Nat64Mapping {
8789 #[inline(always)]
8790 fn max_ordinal_present(&self) -> u64 {
8791 if let Some(_) = self.counters {
8792 return 5;
8793 }
8794 if let Some(_) = self.remaining_time_ms {
8795 return 4;
8796 }
8797 if let Some(_) = self.ip6_addr {
8798 return 3;
8799 }
8800 if let Some(_) = self.ip4_addr {
8801 return 2;
8802 }
8803 if let Some(_) = self.mapping_id {
8804 return 1;
8805 }
8806 0
8807 }
8808 }
8809
8810 impl fidl::encoding::ValueTypeMarker for Nat64Mapping {
8811 type Borrowed<'a> = &'a Self;
8812 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8813 value
8814 }
8815 }
8816
8817 unsafe impl fidl::encoding::TypeMarker for Nat64Mapping {
8818 type Owned = Self;
8819
8820 #[inline(always)]
8821 fn inline_align(_context: fidl::encoding::Context) -> usize {
8822 8
8823 }
8824
8825 #[inline(always)]
8826 fn inline_size(_context: fidl::encoding::Context) -> usize {
8827 16
8828 }
8829 }
8830
8831 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64Mapping, D>
8832 for &Nat64Mapping
8833 {
8834 unsafe fn encode(
8835 self,
8836 encoder: &mut fidl::encoding::Encoder<'_, D>,
8837 offset: usize,
8838 mut depth: fidl::encoding::Depth,
8839 ) -> fidl::Result<()> {
8840 encoder.debug_check_bounds::<Nat64Mapping>(offset);
8841 let max_ordinal: u64 = self.max_ordinal_present();
8843 encoder.write_num(max_ordinal, offset);
8844 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8845 if max_ordinal == 0 {
8847 return Ok(());
8848 }
8849 depth.increment()?;
8850 let envelope_size = 8;
8851 let bytes_len = max_ordinal as usize * envelope_size;
8852 #[allow(unused_variables)]
8853 let offset = encoder.out_of_line_offset(bytes_len);
8854 let mut _prev_end_offset: usize = 0;
8855 if 1 > max_ordinal {
8856 return Ok(());
8857 }
8858
8859 let cur_offset: usize = (1 - 1) * envelope_size;
8862
8863 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8865
8866 fidl::encoding::encode_in_envelope_optional::<u64, D>(
8871 self.mapping_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
8872 encoder,
8873 offset + cur_offset,
8874 depth,
8875 )?;
8876
8877 _prev_end_offset = cur_offset + envelope_size;
8878 if 2 > max_ordinal {
8879 return Ok(());
8880 }
8881
8882 let cur_offset: usize = (2 - 1) * envelope_size;
8885
8886 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8888
8889 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8894 self.ip4_addr.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8895 encoder, offset + cur_offset, depth
8896 )?;
8897
8898 _prev_end_offset = cur_offset + envelope_size;
8899 if 3 > max_ordinal {
8900 return Ok(());
8901 }
8902
8903 let cur_offset: usize = (3 - 1) * envelope_size;
8906
8907 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8909
8910 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8915 self.ip6_addr.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8916 encoder, offset + cur_offset, depth
8917 )?;
8918
8919 _prev_end_offset = cur_offset + envelope_size;
8920 if 4 > max_ordinal {
8921 return Ok(());
8922 }
8923
8924 let cur_offset: usize = (4 - 1) * envelope_size;
8927
8928 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8930
8931 fidl::encoding::encode_in_envelope_optional::<u32, D>(
8936 self.remaining_time_ms
8937 .as_ref()
8938 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
8939 encoder,
8940 offset + cur_offset,
8941 depth,
8942 )?;
8943
8944 _prev_end_offset = cur_offset + envelope_size;
8945 if 5 > max_ordinal {
8946 return Ok(());
8947 }
8948
8949 let cur_offset: usize = (5 - 1) * envelope_size;
8952
8953 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8955
8956 fidl::encoding::encode_in_envelope_optional::<Nat64ProtocolCounters, D>(
8961 self.counters
8962 .as_ref()
8963 .map(<Nat64ProtocolCounters as fidl::encoding::ValueTypeMarker>::borrow),
8964 encoder,
8965 offset + cur_offset,
8966 depth,
8967 )?;
8968
8969 _prev_end_offset = cur_offset + envelope_size;
8970
8971 Ok(())
8972 }
8973 }
8974
8975 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64Mapping {
8976 #[inline(always)]
8977 fn new_empty() -> Self {
8978 Self::default()
8979 }
8980
8981 unsafe fn decode(
8982 &mut self,
8983 decoder: &mut fidl::encoding::Decoder<'_, D>,
8984 offset: usize,
8985 mut depth: fidl::encoding::Depth,
8986 ) -> fidl::Result<()> {
8987 decoder.debug_check_bounds::<Self>(offset);
8988 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8989 None => return Err(fidl::Error::NotNullable),
8990 Some(len) => len,
8991 };
8992 if len == 0 {
8994 return Ok(());
8995 };
8996 depth.increment()?;
8997 let envelope_size = 8;
8998 let bytes_len = len * envelope_size;
8999 let offset = decoder.out_of_line_offset(bytes_len)?;
9000 let mut _next_ordinal_to_read = 0;
9002 let mut next_offset = offset;
9003 let end_offset = offset + bytes_len;
9004 _next_ordinal_to_read += 1;
9005 if next_offset >= end_offset {
9006 return Ok(());
9007 }
9008
9009 while _next_ordinal_to_read < 1 {
9011 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9012 _next_ordinal_to_read += 1;
9013 next_offset += envelope_size;
9014 }
9015
9016 let next_out_of_line = decoder.next_out_of_line();
9017 let handles_before = decoder.remaining_handles();
9018 if let Some((inlined, num_bytes, num_handles)) =
9019 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9020 {
9021 let member_inline_size =
9022 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9023 if inlined != (member_inline_size <= 4) {
9024 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9025 }
9026 let inner_offset;
9027 let mut inner_depth = depth.clone();
9028 if inlined {
9029 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9030 inner_offset = next_offset;
9031 } else {
9032 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9033 inner_depth.increment()?;
9034 }
9035 let val_ref = self.mapping_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9036 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9037 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9038 {
9039 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9040 }
9041 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9042 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9043 }
9044 }
9045
9046 next_offset += envelope_size;
9047 _next_ordinal_to_read += 1;
9048 if next_offset >= end_offset {
9049 return Ok(());
9050 }
9051
9052 while _next_ordinal_to_read < 2 {
9054 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9055 _next_ordinal_to_read += 1;
9056 next_offset += envelope_size;
9057 }
9058
9059 let next_out_of_line = decoder.next_out_of_line();
9060 let handles_before = decoder.remaining_handles();
9061 if let Some((inlined, num_bytes, num_handles)) =
9062 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9063 {
9064 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9065 if inlined != (member_inline_size <= 4) {
9066 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9067 }
9068 let inner_offset;
9069 let mut inner_depth = depth.clone();
9070 if inlined {
9071 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9072 inner_offset = next_offset;
9073 } else {
9074 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9075 inner_depth.increment()?;
9076 }
9077 let val_ref = self.ip4_addr.get_or_insert_with(|| {
9078 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
9079 });
9080 fidl::decode!(
9081 fidl::encoding::UnboundedVector<u8>,
9082 D,
9083 val_ref,
9084 decoder,
9085 inner_offset,
9086 inner_depth
9087 )?;
9088 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9089 {
9090 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9091 }
9092 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9093 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9094 }
9095 }
9096
9097 next_offset += envelope_size;
9098 _next_ordinal_to_read += 1;
9099 if next_offset >= end_offset {
9100 return Ok(());
9101 }
9102
9103 while _next_ordinal_to_read < 3 {
9105 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9106 _next_ordinal_to_read += 1;
9107 next_offset += envelope_size;
9108 }
9109
9110 let next_out_of_line = decoder.next_out_of_line();
9111 let handles_before = decoder.remaining_handles();
9112 if let Some((inlined, num_bytes, num_handles)) =
9113 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9114 {
9115 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9116 if inlined != (member_inline_size <= 4) {
9117 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9118 }
9119 let inner_offset;
9120 let mut inner_depth = depth.clone();
9121 if inlined {
9122 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9123 inner_offset = next_offset;
9124 } else {
9125 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9126 inner_depth.increment()?;
9127 }
9128 let val_ref = self.ip6_addr.get_or_insert_with(|| {
9129 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
9130 });
9131 fidl::decode!(
9132 fidl::encoding::UnboundedVector<u8>,
9133 D,
9134 val_ref,
9135 decoder,
9136 inner_offset,
9137 inner_depth
9138 )?;
9139 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9140 {
9141 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9142 }
9143 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9144 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9145 }
9146 }
9147
9148 next_offset += envelope_size;
9149 _next_ordinal_to_read += 1;
9150 if next_offset >= end_offset {
9151 return Ok(());
9152 }
9153
9154 while _next_ordinal_to_read < 4 {
9156 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9157 _next_ordinal_to_read += 1;
9158 next_offset += envelope_size;
9159 }
9160
9161 let next_out_of_line = decoder.next_out_of_line();
9162 let handles_before = decoder.remaining_handles();
9163 if let Some((inlined, num_bytes, num_handles)) =
9164 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9165 {
9166 let member_inline_size =
9167 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9168 if inlined != (member_inline_size <= 4) {
9169 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9170 }
9171 let inner_offset;
9172 let mut inner_depth = depth.clone();
9173 if inlined {
9174 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9175 inner_offset = next_offset;
9176 } else {
9177 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9178 inner_depth.increment()?;
9179 }
9180 let val_ref =
9181 self.remaining_time_ms.get_or_insert_with(|| fidl::new_empty!(u32, D));
9182 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
9183 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9184 {
9185 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9186 }
9187 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9188 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9189 }
9190 }
9191
9192 next_offset += envelope_size;
9193 _next_ordinal_to_read += 1;
9194 if next_offset >= end_offset {
9195 return Ok(());
9196 }
9197
9198 while _next_ordinal_to_read < 5 {
9200 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9201 _next_ordinal_to_read += 1;
9202 next_offset += envelope_size;
9203 }
9204
9205 let next_out_of_line = decoder.next_out_of_line();
9206 let handles_before = decoder.remaining_handles();
9207 if let Some((inlined, num_bytes, num_handles)) =
9208 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9209 {
9210 let member_inline_size =
9211 <Nat64ProtocolCounters as fidl::encoding::TypeMarker>::inline_size(
9212 decoder.context,
9213 );
9214 if inlined != (member_inline_size <= 4) {
9215 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9216 }
9217 let inner_offset;
9218 let mut inner_depth = depth.clone();
9219 if inlined {
9220 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9221 inner_offset = next_offset;
9222 } else {
9223 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9224 inner_depth.increment()?;
9225 }
9226 let val_ref =
9227 self.counters.get_or_insert_with(|| fidl::new_empty!(Nat64ProtocolCounters, D));
9228 fidl::decode!(
9229 Nat64ProtocolCounters,
9230 D,
9231 val_ref,
9232 decoder,
9233 inner_offset,
9234 inner_depth
9235 )?;
9236 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9237 {
9238 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9239 }
9240 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9241 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9242 }
9243 }
9244
9245 next_offset += envelope_size;
9246
9247 while next_offset < end_offset {
9249 _next_ordinal_to_read += 1;
9250 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9251 next_offset += envelope_size;
9252 }
9253
9254 Ok(())
9255 }
9256 }
9257
9258 impl Nat64PacketCounters {
9259 #[inline(always)]
9260 fn max_ordinal_present(&self) -> u64 {
9261 if let Some(_) = self.ipv6_to_ipv4_packets {
9262 return 2;
9263 }
9264 if let Some(_) = self.ipv4_to_ipv6_packets {
9265 return 1;
9266 }
9267 0
9268 }
9269 }
9270
9271 impl fidl::encoding::ValueTypeMarker for Nat64PacketCounters {
9272 type Borrowed<'a> = &'a Self;
9273 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9274 value
9275 }
9276 }
9277
9278 unsafe impl fidl::encoding::TypeMarker for Nat64PacketCounters {
9279 type Owned = Self;
9280
9281 #[inline(always)]
9282 fn inline_align(_context: fidl::encoding::Context) -> usize {
9283 8
9284 }
9285
9286 #[inline(always)]
9287 fn inline_size(_context: fidl::encoding::Context) -> usize {
9288 16
9289 }
9290 }
9291
9292 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64PacketCounters, D>
9293 for &Nat64PacketCounters
9294 {
9295 unsafe fn encode(
9296 self,
9297 encoder: &mut fidl::encoding::Encoder<'_, D>,
9298 offset: usize,
9299 mut depth: fidl::encoding::Depth,
9300 ) -> fidl::Result<()> {
9301 encoder.debug_check_bounds::<Nat64PacketCounters>(offset);
9302 let max_ordinal: u64 = self.max_ordinal_present();
9304 encoder.write_num(max_ordinal, offset);
9305 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9306 if max_ordinal == 0 {
9308 return Ok(());
9309 }
9310 depth.increment()?;
9311 let envelope_size = 8;
9312 let bytes_len = max_ordinal as usize * envelope_size;
9313 #[allow(unused_variables)]
9314 let offset = encoder.out_of_line_offset(bytes_len);
9315 let mut _prev_end_offset: usize = 0;
9316 if 1 > max_ordinal {
9317 return Ok(());
9318 }
9319
9320 let cur_offset: usize = (1 - 1) * envelope_size;
9323
9324 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9326
9327 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9332 self.ipv4_to_ipv6_packets
9333 .as_ref()
9334 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9335 encoder,
9336 offset + cur_offset,
9337 depth,
9338 )?;
9339
9340 _prev_end_offset = cur_offset + envelope_size;
9341 if 2 > max_ordinal {
9342 return Ok(());
9343 }
9344
9345 let cur_offset: usize = (2 - 1) * envelope_size;
9348
9349 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9351
9352 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9357 self.ipv6_to_ipv4_packets
9358 .as_ref()
9359 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9360 encoder,
9361 offset + cur_offset,
9362 depth,
9363 )?;
9364
9365 _prev_end_offset = cur_offset + envelope_size;
9366
9367 Ok(())
9368 }
9369 }
9370
9371 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64PacketCounters {
9372 #[inline(always)]
9373 fn new_empty() -> Self {
9374 Self::default()
9375 }
9376
9377 unsafe fn decode(
9378 &mut self,
9379 decoder: &mut fidl::encoding::Decoder<'_, D>,
9380 offset: usize,
9381 mut depth: fidl::encoding::Depth,
9382 ) -> fidl::Result<()> {
9383 decoder.debug_check_bounds::<Self>(offset);
9384 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9385 None => return Err(fidl::Error::NotNullable),
9386 Some(len) => len,
9387 };
9388 if len == 0 {
9390 return Ok(());
9391 };
9392 depth.increment()?;
9393 let envelope_size = 8;
9394 let bytes_len = len * envelope_size;
9395 let offset = decoder.out_of_line_offset(bytes_len)?;
9396 let mut _next_ordinal_to_read = 0;
9398 let mut next_offset = offset;
9399 let end_offset = offset + bytes_len;
9400 _next_ordinal_to_read += 1;
9401 if next_offset >= end_offset {
9402 return Ok(());
9403 }
9404
9405 while _next_ordinal_to_read < 1 {
9407 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9408 _next_ordinal_to_read += 1;
9409 next_offset += envelope_size;
9410 }
9411
9412 let next_out_of_line = decoder.next_out_of_line();
9413 let handles_before = decoder.remaining_handles();
9414 if let Some((inlined, num_bytes, num_handles)) =
9415 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9416 {
9417 let member_inline_size =
9418 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9419 if inlined != (member_inline_size <= 4) {
9420 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9421 }
9422 let inner_offset;
9423 let mut inner_depth = depth.clone();
9424 if inlined {
9425 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9426 inner_offset = next_offset;
9427 } else {
9428 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9429 inner_depth.increment()?;
9430 }
9431 let val_ref =
9432 self.ipv4_to_ipv6_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
9433 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9434 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9435 {
9436 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9437 }
9438 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9439 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9440 }
9441 }
9442
9443 next_offset += envelope_size;
9444 _next_ordinal_to_read += 1;
9445 if next_offset >= end_offset {
9446 return Ok(());
9447 }
9448
9449 while _next_ordinal_to_read < 2 {
9451 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9452 _next_ordinal_to_read += 1;
9453 next_offset += envelope_size;
9454 }
9455
9456 let next_out_of_line = decoder.next_out_of_line();
9457 let handles_before = decoder.remaining_handles();
9458 if let Some((inlined, num_bytes, num_handles)) =
9459 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9460 {
9461 let member_inline_size =
9462 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9463 if inlined != (member_inline_size <= 4) {
9464 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9465 }
9466 let inner_offset;
9467 let mut inner_depth = depth.clone();
9468 if inlined {
9469 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9470 inner_offset = next_offset;
9471 } else {
9472 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9473 inner_depth.increment()?;
9474 }
9475 let val_ref =
9476 self.ipv6_to_ipv4_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
9477 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9478 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9479 {
9480 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9481 }
9482 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9483 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9484 }
9485 }
9486
9487 next_offset += envelope_size;
9488
9489 while next_offset < end_offset {
9491 _next_ordinal_to_read += 1;
9492 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9493 next_offset += envelope_size;
9494 }
9495
9496 Ok(())
9497 }
9498 }
9499
9500 impl Nat64ProtocolCounters {
9501 #[inline(always)]
9502 fn max_ordinal_present(&self) -> u64 {
9503 if let Some(_) = self.total {
9504 return 4;
9505 }
9506 if let Some(_) = self.icmp {
9507 return 3;
9508 }
9509 if let Some(_) = self.udp {
9510 return 2;
9511 }
9512 if let Some(_) = self.tcp {
9513 return 1;
9514 }
9515 0
9516 }
9517 }
9518
9519 impl fidl::encoding::ValueTypeMarker for Nat64ProtocolCounters {
9520 type Borrowed<'a> = &'a Self;
9521 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9522 value
9523 }
9524 }
9525
9526 unsafe impl fidl::encoding::TypeMarker for Nat64ProtocolCounters {
9527 type Owned = Self;
9528
9529 #[inline(always)]
9530 fn inline_align(_context: fidl::encoding::Context) -> usize {
9531 8
9532 }
9533
9534 #[inline(always)]
9535 fn inline_size(_context: fidl::encoding::Context) -> usize {
9536 16
9537 }
9538 }
9539
9540 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64ProtocolCounters, D>
9541 for &Nat64ProtocolCounters
9542 {
9543 unsafe fn encode(
9544 self,
9545 encoder: &mut fidl::encoding::Encoder<'_, D>,
9546 offset: usize,
9547 mut depth: fidl::encoding::Depth,
9548 ) -> fidl::Result<()> {
9549 encoder.debug_check_bounds::<Nat64ProtocolCounters>(offset);
9550 let max_ordinal: u64 = self.max_ordinal_present();
9552 encoder.write_num(max_ordinal, offset);
9553 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9554 if max_ordinal == 0 {
9556 return Ok(());
9557 }
9558 depth.increment()?;
9559 let envelope_size = 8;
9560 let bytes_len = max_ordinal as usize * envelope_size;
9561 #[allow(unused_variables)]
9562 let offset = encoder.out_of_line_offset(bytes_len);
9563 let mut _prev_end_offset: usize = 0;
9564 if 1 > max_ordinal {
9565 return Ok(());
9566 }
9567
9568 let cur_offset: usize = (1 - 1) * envelope_size;
9571
9572 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9574
9575 fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9580 self.tcp
9581 .as_ref()
9582 .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9583 encoder,
9584 offset + cur_offset,
9585 depth,
9586 )?;
9587
9588 _prev_end_offset = cur_offset + envelope_size;
9589 if 2 > max_ordinal {
9590 return Ok(());
9591 }
9592
9593 let cur_offset: usize = (2 - 1) * envelope_size;
9596
9597 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9599
9600 fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9605 self.udp
9606 .as_ref()
9607 .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9608 encoder,
9609 offset + cur_offset,
9610 depth,
9611 )?;
9612
9613 _prev_end_offset = cur_offset + envelope_size;
9614 if 3 > max_ordinal {
9615 return Ok(());
9616 }
9617
9618 let cur_offset: usize = (3 - 1) * envelope_size;
9621
9622 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9624
9625 fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9630 self.icmp
9631 .as_ref()
9632 .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9633 encoder,
9634 offset + cur_offset,
9635 depth,
9636 )?;
9637
9638 _prev_end_offset = cur_offset + envelope_size;
9639 if 4 > max_ordinal {
9640 return Ok(());
9641 }
9642
9643 let cur_offset: usize = (4 - 1) * envelope_size;
9646
9647 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9649
9650 fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9655 self.total
9656 .as_ref()
9657 .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9658 encoder,
9659 offset + cur_offset,
9660 depth,
9661 )?;
9662
9663 _prev_end_offset = cur_offset + envelope_size;
9664
9665 Ok(())
9666 }
9667 }
9668
9669 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64ProtocolCounters {
9670 #[inline(always)]
9671 fn new_empty() -> Self {
9672 Self::default()
9673 }
9674
9675 unsafe fn decode(
9676 &mut self,
9677 decoder: &mut fidl::encoding::Decoder<'_, D>,
9678 offset: usize,
9679 mut depth: fidl::encoding::Depth,
9680 ) -> fidl::Result<()> {
9681 decoder.debug_check_bounds::<Self>(offset);
9682 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9683 None => return Err(fidl::Error::NotNullable),
9684 Some(len) => len,
9685 };
9686 if len == 0 {
9688 return Ok(());
9689 };
9690 depth.increment()?;
9691 let envelope_size = 8;
9692 let bytes_len = len * envelope_size;
9693 let offset = decoder.out_of_line_offset(bytes_len)?;
9694 let mut _next_ordinal_to_read = 0;
9696 let mut next_offset = offset;
9697 let end_offset = offset + bytes_len;
9698 _next_ordinal_to_read += 1;
9699 if next_offset >= end_offset {
9700 return Ok(());
9701 }
9702
9703 while _next_ordinal_to_read < 1 {
9705 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9706 _next_ordinal_to_read += 1;
9707 next_offset += envelope_size;
9708 }
9709
9710 let next_out_of_line = decoder.next_out_of_line();
9711 let handles_before = decoder.remaining_handles();
9712 if let Some((inlined, num_bytes, num_handles)) =
9713 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9714 {
9715 let member_inline_size =
9716 <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9717 decoder.context,
9718 );
9719 if inlined != (member_inline_size <= 4) {
9720 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9721 }
9722 let inner_offset;
9723 let mut inner_depth = depth.clone();
9724 if inlined {
9725 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9726 inner_offset = next_offset;
9727 } else {
9728 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9729 inner_depth.increment()?;
9730 }
9731 let val_ref =
9732 self.tcp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9733 fidl::decode!(
9734 Nat64TrafficCounters,
9735 D,
9736 val_ref,
9737 decoder,
9738 inner_offset,
9739 inner_depth
9740 )?;
9741 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9742 {
9743 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9744 }
9745 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9746 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9747 }
9748 }
9749
9750 next_offset += envelope_size;
9751 _next_ordinal_to_read += 1;
9752 if next_offset >= end_offset {
9753 return Ok(());
9754 }
9755
9756 while _next_ordinal_to_read < 2 {
9758 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9759 _next_ordinal_to_read += 1;
9760 next_offset += envelope_size;
9761 }
9762
9763 let next_out_of_line = decoder.next_out_of_line();
9764 let handles_before = decoder.remaining_handles();
9765 if let Some((inlined, num_bytes, num_handles)) =
9766 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9767 {
9768 let member_inline_size =
9769 <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9770 decoder.context,
9771 );
9772 if inlined != (member_inline_size <= 4) {
9773 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9774 }
9775 let inner_offset;
9776 let mut inner_depth = depth.clone();
9777 if inlined {
9778 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9779 inner_offset = next_offset;
9780 } else {
9781 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9782 inner_depth.increment()?;
9783 }
9784 let val_ref =
9785 self.udp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9786 fidl::decode!(
9787 Nat64TrafficCounters,
9788 D,
9789 val_ref,
9790 decoder,
9791 inner_offset,
9792 inner_depth
9793 )?;
9794 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9795 {
9796 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9797 }
9798 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9799 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9800 }
9801 }
9802
9803 next_offset += envelope_size;
9804 _next_ordinal_to_read += 1;
9805 if next_offset >= end_offset {
9806 return Ok(());
9807 }
9808
9809 while _next_ordinal_to_read < 3 {
9811 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9812 _next_ordinal_to_read += 1;
9813 next_offset += envelope_size;
9814 }
9815
9816 let next_out_of_line = decoder.next_out_of_line();
9817 let handles_before = decoder.remaining_handles();
9818 if let Some((inlined, num_bytes, num_handles)) =
9819 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9820 {
9821 let member_inline_size =
9822 <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9823 decoder.context,
9824 );
9825 if inlined != (member_inline_size <= 4) {
9826 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9827 }
9828 let inner_offset;
9829 let mut inner_depth = depth.clone();
9830 if inlined {
9831 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9832 inner_offset = next_offset;
9833 } else {
9834 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9835 inner_depth.increment()?;
9836 }
9837 let val_ref =
9838 self.icmp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9839 fidl::decode!(
9840 Nat64TrafficCounters,
9841 D,
9842 val_ref,
9843 decoder,
9844 inner_offset,
9845 inner_depth
9846 )?;
9847 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9848 {
9849 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9850 }
9851 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9852 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9853 }
9854 }
9855
9856 next_offset += envelope_size;
9857 _next_ordinal_to_read += 1;
9858 if next_offset >= end_offset {
9859 return Ok(());
9860 }
9861
9862 while _next_ordinal_to_read < 4 {
9864 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9865 _next_ordinal_to_read += 1;
9866 next_offset += envelope_size;
9867 }
9868
9869 let next_out_of_line = decoder.next_out_of_line();
9870 let handles_before = decoder.remaining_handles();
9871 if let Some((inlined, num_bytes, num_handles)) =
9872 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9873 {
9874 let member_inline_size =
9875 <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9876 decoder.context,
9877 );
9878 if inlined != (member_inline_size <= 4) {
9879 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9880 }
9881 let inner_offset;
9882 let mut inner_depth = depth.clone();
9883 if inlined {
9884 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9885 inner_offset = next_offset;
9886 } else {
9887 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9888 inner_depth.increment()?;
9889 }
9890 let val_ref =
9891 self.total.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9892 fidl::decode!(
9893 Nat64TrafficCounters,
9894 D,
9895 val_ref,
9896 decoder,
9897 inner_offset,
9898 inner_depth
9899 )?;
9900 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9901 {
9902 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9903 }
9904 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9905 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9906 }
9907 }
9908
9909 next_offset += envelope_size;
9910
9911 while next_offset < end_offset {
9913 _next_ordinal_to_read += 1;
9914 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9915 next_offset += envelope_size;
9916 }
9917
9918 Ok(())
9919 }
9920 }
9921
9922 impl Nat64TrafficCounters {
9923 #[inline(always)]
9924 fn max_ordinal_present(&self) -> u64 {
9925 if let Some(_) = self.ipv6_to_ipv4_bytes {
9926 return 4;
9927 }
9928 if let Some(_) = self.ipv6_to_ipv4_packets {
9929 return 3;
9930 }
9931 if let Some(_) = self.ipv4_to_ipv6_bytes {
9932 return 2;
9933 }
9934 if let Some(_) = self.ipv4_to_ipv6_packets {
9935 return 1;
9936 }
9937 0
9938 }
9939 }
9940
9941 impl fidl::encoding::ValueTypeMarker for Nat64TrafficCounters {
9942 type Borrowed<'a> = &'a Self;
9943 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9944 value
9945 }
9946 }
9947
9948 unsafe impl fidl::encoding::TypeMarker for Nat64TrafficCounters {
9949 type Owned = Self;
9950
9951 #[inline(always)]
9952 fn inline_align(_context: fidl::encoding::Context) -> usize {
9953 8
9954 }
9955
9956 #[inline(always)]
9957 fn inline_size(_context: fidl::encoding::Context) -> usize {
9958 16
9959 }
9960 }
9961
9962 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64TrafficCounters, D>
9963 for &Nat64TrafficCounters
9964 {
9965 unsafe fn encode(
9966 self,
9967 encoder: &mut fidl::encoding::Encoder<'_, D>,
9968 offset: usize,
9969 mut depth: fidl::encoding::Depth,
9970 ) -> fidl::Result<()> {
9971 encoder.debug_check_bounds::<Nat64TrafficCounters>(offset);
9972 let max_ordinal: u64 = self.max_ordinal_present();
9974 encoder.write_num(max_ordinal, offset);
9975 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9976 if max_ordinal == 0 {
9978 return Ok(());
9979 }
9980 depth.increment()?;
9981 let envelope_size = 8;
9982 let bytes_len = max_ordinal as usize * envelope_size;
9983 #[allow(unused_variables)]
9984 let offset = encoder.out_of_line_offset(bytes_len);
9985 let mut _prev_end_offset: usize = 0;
9986 if 1 > max_ordinal {
9987 return Ok(());
9988 }
9989
9990 let cur_offset: usize = (1 - 1) * envelope_size;
9993
9994 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9996
9997 fidl::encoding::encode_in_envelope_optional::<u64, D>(
10002 self.ipv4_to_ipv6_packets
10003 .as_ref()
10004 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10005 encoder,
10006 offset + cur_offset,
10007 depth,
10008 )?;
10009
10010 _prev_end_offset = cur_offset + envelope_size;
10011 if 2 > max_ordinal {
10012 return Ok(());
10013 }
10014
10015 let cur_offset: usize = (2 - 1) * envelope_size;
10018
10019 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10021
10022 fidl::encoding::encode_in_envelope_optional::<u64, D>(
10027 self.ipv4_to_ipv6_bytes
10028 .as_ref()
10029 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10030 encoder,
10031 offset + cur_offset,
10032 depth,
10033 )?;
10034
10035 _prev_end_offset = cur_offset + envelope_size;
10036 if 3 > max_ordinal {
10037 return Ok(());
10038 }
10039
10040 let cur_offset: usize = (3 - 1) * envelope_size;
10043
10044 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10046
10047 fidl::encoding::encode_in_envelope_optional::<u64, D>(
10052 self.ipv6_to_ipv4_packets
10053 .as_ref()
10054 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10055 encoder,
10056 offset + cur_offset,
10057 depth,
10058 )?;
10059
10060 _prev_end_offset = cur_offset + envelope_size;
10061 if 4 > max_ordinal {
10062 return Ok(());
10063 }
10064
10065 let cur_offset: usize = (4 - 1) * envelope_size;
10068
10069 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10071
10072 fidl::encoding::encode_in_envelope_optional::<u64, D>(
10077 self.ipv6_to_ipv4_bytes
10078 .as_ref()
10079 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10080 encoder,
10081 offset + cur_offset,
10082 depth,
10083 )?;
10084
10085 _prev_end_offset = cur_offset + envelope_size;
10086
10087 Ok(())
10088 }
10089 }
10090
10091 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64TrafficCounters {
10092 #[inline(always)]
10093 fn new_empty() -> Self {
10094 Self::default()
10095 }
10096
10097 unsafe fn decode(
10098 &mut self,
10099 decoder: &mut fidl::encoding::Decoder<'_, D>,
10100 offset: usize,
10101 mut depth: fidl::encoding::Depth,
10102 ) -> fidl::Result<()> {
10103 decoder.debug_check_bounds::<Self>(offset);
10104 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10105 None => return Err(fidl::Error::NotNullable),
10106 Some(len) => len,
10107 };
10108 if len == 0 {
10110 return Ok(());
10111 };
10112 depth.increment()?;
10113 let envelope_size = 8;
10114 let bytes_len = len * envelope_size;
10115 let offset = decoder.out_of_line_offset(bytes_len)?;
10116 let mut _next_ordinal_to_read = 0;
10118 let mut next_offset = offset;
10119 let end_offset = offset + bytes_len;
10120 _next_ordinal_to_read += 1;
10121 if next_offset >= end_offset {
10122 return Ok(());
10123 }
10124
10125 while _next_ordinal_to_read < 1 {
10127 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10128 _next_ordinal_to_read += 1;
10129 next_offset += envelope_size;
10130 }
10131
10132 let next_out_of_line = decoder.next_out_of_line();
10133 let handles_before = decoder.remaining_handles();
10134 if let Some((inlined, num_bytes, num_handles)) =
10135 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10136 {
10137 let member_inline_size =
10138 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10139 if inlined != (member_inline_size <= 4) {
10140 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10141 }
10142 let inner_offset;
10143 let mut inner_depth = depth.clone();
10144 if inlined {
10145 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10146 inner_offset = next_offset;
10147 } else {
10148 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10149 inner_depth.increment()?;
10150 }
10151 let val_ref =
10152 self.ipv4_to_ipv6_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
10153 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10154 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10155 {
10156 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10157 }
10158 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10159 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10160 }
10161 }
10162
10163 next_offset += envelope_size;
10164 _next_ordinal_to_read += 1;
10165 if next_offset >= end_offset {
10166 return Ok(());
10167 }
10168
10169 while _next_ordinal_to_read < 2 {
10171 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10172 _next_ordinal_to_read += 1;
10173 next_offset += envelope_size;
10174 }
10175
10176 let next_out_of_line = decoder.next_out_of_line();
10177 let handles_before = decoder.remaining_handles();
10178 if let Some((inlined, num_bytes, num_handles)) =
10179 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10180 {
10181 let member_inline_size =
10182 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10183 if inlined != (member_inline_size <= 4) {
10184 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10185 }
10186 let inner_offset;
10187 let mut inner_depth = depth.clone();
10188 if inlined {
10189 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10190 inner_offset = next_offset;
10191 } else {
10192 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10193 inner_depth.increment()?;
10194 }
10195 let val_ref =
10196 self.ipv4_to_ipv6_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
10197 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10198 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10199 {
10200 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10201 }
10202 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10203 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10204 }
10205 }
10206
10207 next_offset += envelope_size;
10208 _next_ordinal_to_read += 1;
10209 if next_offset >= end_offset {
10210 return Ok(());
10211 }
10212
10213 while _next_ordinal_to_read < 3 {
10215 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10216 _next_ordinal_to_read += 1;
10217 next_offset += envelope_size;
10218 }
10219
10220 let next_out_of_line = decoder.next_out_of_line();
10221 let handles_before = decoder.remaining_handles();
10222 if let Some((inlined, num_bytes, num_handles)) =
10223 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10224 {
10225 let member_inline_size =
10226 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10227 if inlined != (member_inline_size <= 4) {
10228 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10229 }
10230 let inner_offset;
10231 let mut inner_depth = depth.clone();
10232 if inlined {
10233 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10234 inner_offset = next_offset;
10235 } else {
10236 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10237 inner_depth.increment()?;
10238 }
10239 let val_ref =
10240 self.ipv6_to_ipv4_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
10241 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10242 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10243 {
10244 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10245 }
10246 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10247 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10248 }
10249 }
10250
10251 next_offset += envelope_size;
10252 _next_ordinal_to_read += 1;
10253 if next_offset >= end_offset {
10254 return Ok(());
10255 }
10256
10257 while _next_ordinal_to_read < 4 {
10259 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10260 _next_ordinal_to_read += 1;
10261 next_offset += envelope_size;
10262 }
10263
10264 let next_out_of_line = decoder.next_out_of_line();
10265 let handles_before = decoder.remaining_handles();
10266 if let Some((inlined, num_bytes, num_handles)) =
10267 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10268 {
10269 let member_inline_size =
10270 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10271 if inlined != (member_inline_size <= 4) {
10272 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10273 }
10274 let inner_offset;
10275 let mut inner_depth = depth.clone();
10276 if inlined {
10277 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10278 inner_offset = next_offset;
10279 } else {
10280 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10281 inner_depth.increment()?;
10282 }
10283 let val_ref =
10284 self.ipv6_to_ipv4_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
10285 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10286 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10287 {
10288 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10289 }
10290 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10291 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10292 }
10293 }
10294
10295 next_offset += envelope_size;
10296
10297 while next_offset < end_offset {
10299 _next_ordinal_to_read += 1;
10300 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10301 next_offset += envelope_size;
10302 }
10303
10304 Ok(())
10305 }
10306 }
10307
10308 impl NetworkScanParameters {
10309 #[inline(always)]
10310 fn max_ordinal_present(&self) -> u64 {
10311 if let Some(_) = self.tx_power_dbm {
10312 return 2;
10313 }
10314 if let Some(_) = self.channels {
10315 return 1;
10316 }
10317 0
10318 }
10319 }
10320
10321 impl fidl::encoding::ValueTypeMarker for NetworkScanParameters {
10322 type Borrowed<'a> = &'a Self;
10323 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10324 value
10325 }
10326 }
10327
10328 unsafe impl fidl::encoding::TypeMarker for NetworkScanParameters {
10329 type Owned = Self;
10330
10331 #[inline(always)]
10332 fn inline_align(_context: fidl::encoding::Context) -> usize {
10333 8
10334 }
10335
10336 #[inline(always)]
10337 fn inline_size(_context: fidl::encoding::Context) -> usize {
10338 16
10339 }
10340 }
10341
10342 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NetworkScanParameters, D>
10343 for &NetworkScanParameters
10344 {
10345 unsafe fn encode(
10346 self,
10347 encoder: &mut fidl::encoding::Encoder<'_, D>,
10348 offset: usize,
10349 mut depth: fidl::encoding::Depth,
10350 ) -> fidl::Result<()> {
10351 encoder.debug_check_bounds::<NetworkScanParameters>(offset);
10352 let max_ordinal: u64 = self.max_ordinal_present();
10354 encoder.write_num(max_ordinal, offset);
10355 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10356 if max_ordinal == 0 {
10358 return Ok(());
10359 }
10360 depth.increment()?;
10361 let envelope_size = 8;
10362 let bytes_len = max_ordinal as usize * envelope_size;
10363 #[allow(unused_variables)]
10364 let offset = encoder.out_of_line_offset(bytes_len);
10365 let mut _prev_end_offset: usize = 0;
10366 if 1 > max_ordinal {
10367 return Ok(());
10368 }
10369
10370 let cur_offset: usize = (1 - 1) * envelope_size;
10373
10374 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10376
10377 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u16, 200>, D>(
10382 self.channels.as_ref().map(
10383 <fidl::encoding::Vector<u16, 200> as fidl::encoding::ValueTypeMarker>::borrow,
10384 ),
10385 encoder,
10386 offset + cur_offset,
10387 depth,
10388 )?;
10389
10390 _prev_end_offset = cur_offset + envelope_size;
10391 if 2 > max_ordinal {
10392 return Ok(());
10393 }
10394
10395 let cur_offset: usize = (2 - 1) * envelope_size;
10398
10399 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10401
10402 fidl::encoding::encode_in_envelope_optional::<i8, D>(
10407 self.tx_power_dbm.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
10408 encoder,
10409 offset + cur_offset,
10410 depth,
10411 )?;
10412
10413 _prev_end_offset = cur_offset + envelope_size;
10414
10415 Ok(())
10416 }
10417 }
10418
10419 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NetworkScanParameters {
10420 #[inline(always)]
10421 fn new_empty() -> Self {
10422 Self::default()
10423 }
10424
10425 unsafe fn decode(
10426 &mut self,
10427 decoder: &mut fidl::encoding::Decoder<'_, D>,
10428 offset: usize,
10429 mut depth: fidl::encoding::Depth,
10430 ) -> fidl::Result<()> {
10431 decoder.debug_check_bounds::<Self>(offset);
10432 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10433 None => return Err(fidl::Error::NotNullable),
10434 Some(len) => len,
10435 };
10436 if len == 0 {
10438 return Ok(());
10439 };
10440 depth.increment()?;
10441 let envelope_size = 8;
10442 let bytes_len = len * envelope_size;
10443 let offset = decoder.out_of_line_offset(bytes_len)?;
10444 let mut _next_ordinal_to_read = 0;
10446 let mut next_offset = offset;
10447 let end_offset = offset + bytes_len;
10448 _next_ordinal_to_read += 1;
10449 if next_offset >= end_offset {
10450 return Ok(());
10451 }
10452
10453 while _next_ordinal_to_read < 1 {
10455 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10456 _next_ordinal_to_read += 1;
10457 next_offset += envelope_size;
10458 }
10459
10460 let next_out_of_line = decoder.next_out_of_line();
10461 let handles_before = decoder.remaining_handles();
10462 if let Some((inlined, num_bytes, num_handles)) =
10463 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10464 {
10465 let member_inline_size =
10466 <fidl::encoding::Vector<u16, 200> as fidl::encoding::TypeMarker>::inline_size(
10467 decoder.context,
10468 );
10469 if inlined != (member_inline_size <= 4) {
10470 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10471 }
10472 let inner_offset;
10473 let mut inner_depth = depth.clone();
10474 if inlined {
10475 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10476 inner_offset = next_offset;
10477 } else {
10478 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10479 inner_depth.increment()?;
10480 }
10481 let val_ref = self
10482 .channels
10483 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u16, 200>, D));
10484 fidl::decode!(fidl::encoding::Vector<u16, 200>, D, val_ref, decoder, inner_offset, inner_depth)?;
10485 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10486 {
10487 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10488 }
10489 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10490 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10491 }
10492 }
10493
10494 next_offset += envelope_size;
10495 _next_ordinal_to_read += 1;
10496 if next_offset >= end_offset {
10497 return Ok(());
10498 }
10499
10500 while _next_ordinal_to_read < 2 {
10502 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10503 _next_ordinal_to_read += 1;
10504 next_offset += envelope_size;
10505 }
10506
10507 let next_out_of_line = decoder.next_out_of_line();
10508 let handles_before = decoder.remaining_handles();
10509 if let Some((inlined, num_bytes, num_handles)) =
10510 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10511 {
10512 let member_inline_size =
10513 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10514 if inlined != (member_inline_size <= 4) {
10515 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10516 }
10517 let inner_offset;
10518 let mut inner_depth = depth.clone();
10519 if inlined {
10520 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10521 inner_offset = next_offset;
10522 } else {
10523 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10524 inner_depth.increment()?;
10525 }
10526 let val_ref = self.tx_power_dbm.get_or_insert_with(|| fidl::new_empty!(i8, D));
10527 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
10528 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10529 {
10530 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10531 }
10532 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10533 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10534 }
10535 }
10536
10537 next_offset += envelope_size;
10538
10539 while next_offset < end_offset {
10541 _next_ordinal_to_read += 1;
10542 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10543 next_offset += envelope_size;
10544 }
10545
10546 Ok(())
10547 }
10548 }
10549
10550 impl OnMeshPrefix {
10551 #[inline(always)]
10552 fn max_ordinal_present(&self) -> u64 {
10553 if let Some(_) = self.slaac_valid {
10554 return 5;
10555 }
10556 if let Some(_) = self.slaac_preferred {
10557 return 4;
10558 }
10559 if let Some(_) = self.stable {
10560 return 3;
10561 }
10562 if let Some(_) = self.default_route_preference {
10563 return 2;
10564 }
10565 if let Some(_) = self.subnet {
10566 return 1;
10567 }
10568 0
10569 }
10570 }
10571
10572 impl fidl::encoding::ValueTypeMarker for OnMeshPrefix {
10573 type Borrowed<'a> = &'a Self;
10574 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10575 value
10576 }
10577 }
10578
10579 unsafe impl fidl::encoding::TypeMarker for OnMeshPrefix {
10580 type Owned = Self;
10581
10582 #[inline(always)]
10583 fn inline_align(_context: fidl::encoding::Context) -> usize {
10584 8
10585 }
10586
10587 #[inline(always)]
10588 fn inline_size(_context: fidl::encoding::Context) -> usize {
10589 16
10590 }
10591 }
10592
10593 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OnMeshPrefix, D>
10594 for &OnMeshPrefix
10595 {
10596 unsafe fn encode(
10597 self,
10598 encoder: &mut fidl::encoding::Encoder<'_, D>,
10599 offset: usize,
10600 mut depth: fidl::encoding::Depth,
10601 ) -> fidl::Result<()> {
10602 encoder.debug_check_bounds::<OnMeshPrefix>(offset);
10603 let max_ordinal: u64 = self.max_ordinal_present();
10605 encoder.write_num(max_ordinal, offset);
10606 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10607 if max_ordinal == 0 {
10609 return Ok(());
10610 }
10611 depth.increment()?;
10612 let envelope_size = 8;
10613 let bytes_len = max_ordinal as usize * envelope_size;
10614 #[allow(unused_variables)]
10615 let offset = encoder.out_of_line_offset(bytes_len);
10616 let mut _prev_end_offset: usize = 0;
10617 if 1 > max_ordinal {
10618 return Ok(());
10619 }
10620
10621 let cur_offset: usize = (1 - 1) * envelope_size;
10624
10625 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10627
10628 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
10633 self.subnet.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
10634 encoder, offset + cur_offset, depth
10635 )?;
10636
10637 _prev_end_offset = cur_offset + envelope_size;
10638 if 2 > max_ordinal {
10639 return Ok(());
10640 }
10641
10642 let cur_offset: usize = (2 - 1) * envelope_size;
10645
10646 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10648
10649 fidl::encoding::encode_in_envelope_optional::<RoutePreference, D>(
10654 self.default_route_preference
10655 .as_ref()
10656 .map(<RoutePreference as fidl::encoding::ValueTypeMarker>::borrow),
10657 encoder,
10658 offset + cur_offset,
10659 depth,
10660 )?;
10661
10662 _prev_end_offset = cur_offset + envelope_size;
10663 if 3 > max_ordinal {
10664 return Ok(());
10665 }
10666
10667 let cur_offset: usize = (3 - 1) * envelope_size;
10670
10671 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10673
10674 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10679 self.stable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10680 encoder,
10681 offset + cur_offset,
10682 depth,
10683 )?;
10684
10685 _prev_end_offset = cur_offset + envelope_size;
10686 if 4 > max_ordinal {
10687 return Ok(());
10688 }
10689
10690 let cur_offset: usize = (4 - 1) * envelope_size;
10693
10694 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10696
10697 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10702 self.slaac_preferred
10703 .as_ref()
10704 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10705 encoder,
10706 offset + cur_offset,
10707 depth,
10708 )?;
10709
10710 _prev_end_offset = cur_offset + envelope_size;
10711 if 5 > max_ordinal {
10712 return Ok(());
10713 }
10714
10715 let cur_offset: usize = (5 - 1) * envelope_size;
10718
10719 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10721
10722 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10727 self.slaac_valid.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10728 encoder,
10729 offset + cur_offset,
10730 depth,
10731 )?;
10732
10733 _prev_end_offset = cur_offset + envelope_size;
10734
10735 Ok(())
10736 }
10737 }
10738
10739 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OnMeshPrefix {
10740 #[inline(always)]
10741 fn new_empty() -> Self {
10742 Self::default()
10743 }
10744
10745 unsafe fn decode(
10746 &mut self,
10747 decoder: &mut fidl::encoding::Decoder<'_, D>,
10748 offset: usize,
10749 mut depth: fidl::encoding::Depth,
10750 ) -> fidl::Result<()> {
10751 decoder.debug_check_bounds::<Self>(offset);
10752 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10753 None => return Err(fidl::Error::NotNullable),
10754 Some(len) => len,
10755 };
10756 if len == 0 {
10758 return Ok(());
10759 };
10760 depth.increment()?;
10761 let envelope_size = 8;
10762 let bytes_len = len * envelope_size;
10763 let offset = decoder.out_of_line_offset(bytes_len)?;
10764 let mut _next_ordinal_to_read = 0;
10766 let mut next_offset = offset;
10767 let end_offset = offset + bytes_len;
10768 _next_ordinal_to_read += 1;
10769 if next_offset >= end_offset {
10770 return Ok(());
10771 }
10772
10773 while _next_ordinal_to_read < 1 {
10775 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10776 _next_ordinal_to_read += 1;
10777 next_offset += envelope_size;
10778 }
10779
10780 let next_out_of_line = decoder.next_out_of_line();
10781 let handles_before = decoder.remaining_handles();
10782 if let Some((inlined, num_bytes, num_handles)) =
10783 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10784 {
10785 let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10786 if inlined != (member_inline_size <= 4) {
10787 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10788 }
10789 let inner_offset;
10790 let mut inner_depth = depth.clone();
10791 if inlined {
10792 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10793 inner_offset = next_offset;
10794 } else {
10795 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10796 inner_depth.increment()?;
10797 }
10798 let val_ref = self.subnet.get_or_insert_with(|| {
10799 fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
10800 });
10801 fidl::decode!(
10802 fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
10803 D,
10804 val_ref,
10805 decoder,
10806 inner_offset,
10807 inner_depth
10808 )?;
10809 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10810 {
10811 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10812 }
10813 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10814 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10815 }
10816 }
10817
10818 next_offset += envelope_size;
10819 _next_ordinal_to_read += 1;
10820 if next_offset >= end_offset {
10821 return Ok(());
10822 }
10823
10824 while _next_ordinal_to_read < 2 {
10826 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10827 _next_ordinal_to_read += 1;
10828 next_offset += envelope_size;
10829 }
10830
10831 let next_out_of_line = decoder.next_out_of_line();
10832 let handles_before = decoder.remaining_handles();
10833 if let Some((inlined, num_bytes, num_handles)) =
10834 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10835 {
10836 let member_inline_size =
10837 <RoutePreference as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10838 if inlined != (member_inline_size <= 4) {
10839 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10840 }
10841 let inner_offset;
10842 let mut inner_depth = depth.clone();
10843 if inlined {
10844 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10845 inner_offset = next_offset;
10846 } else {
10847 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10848 inner_depth.increment()?;
10849 }
10850 let val_ref = self
10851 .default_route_preference
10852 .get_or_insert_with(|| fidl::new_empty!(RoutePreference, D));
10853 fidl::decode!(RoutePreference, D, val_ref, decoder, inner_offset, inner_depth)?;
10854 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10855 {
10856 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10857 }
10858 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10859 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10860 }
10861 }
10862
10863 next_offset += envelope_size;
10864 _next_ordinal_to_read += 1;
10865 if next_offset >= end_offset {
10866 return Ok(());
10867 }
10868
10869 while _next_ordinal_to_read < 3 {
10871 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10872 _next_ordinal_to_read += 1;
10873 next_offset += envelope_size;
10874 }
10875
10876 let next_out_of_line = decoder.next_out_of_line();
10877 let handles_before = decoder.remaining_handles();
10878 if let Some((inlined, num_bytes, num_handles)) =
10879 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10880 {
10881 let member_inline_size =
10882 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10883 if inlined != (member_inline_size <= 4) {
10884 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10885 }
10886 let inner_offset;
10887 let mut inner_depth = depth.clone();
10888 if inlined {
10889 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10890 inner_offset = next_offset;
10891 } else {
10892 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10893 inner_depth.increment()?;
10894 }
10895 let val_ref = self.stable.get_or_insert_with(|| fidl::new_empty!(bool, D));
10896 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10897 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10898 {
10899 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10900 }
10901 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10902 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10903 }
10904 }
10905
10906 next_offset += envelope_size;
10907 _next_ordinal_to_read += 1;
10908 if next_offset >= end_offset {
10909 return Ok(());
10910 }
10911
10912 while _next_ordinal_to_read < 4 {
10914 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10915 _next_ordinal_to_read += 1;
10916 next_offset += envelope_size;
10917 }
10918
10919 let next_out_of_line = decoder.next_out_of_line();
10920 let handles_before = decoder.remaining_handles();
10921 if let Some((inlined, num_bytes, num_handles)) =
10922 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10923 {
10924 let member_inline_size =
10925 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10926 if inlined != (member_inline_size <= 4) {
10927 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10928 }
10929 let inner_offset;
10930 let mut inner_depth = depth.clone();
10931 if inlined {
10932 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10933 inner_offset = next_offset;
10934 } else {
10935 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10936 inner_depth.increment()?;
10937 }
10938 let val_ref = self.slaac_preferred.get_or_insert_with(|| fidl::new_empty!(bool, D));
10939 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10940 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10941 {
10942 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10943 }
10944 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10945 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10946 }
10947 }
10948
10949 next_offset += envelope_size;
10950 _next_ordinal_to_read += 1;
10951 if next_offset >= end_offset {
10952 return Ok(());
10953 }
10954
10955 while _next_ordinal_to_read < 5 {
10957 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10958 _next_ordinal_to_read += 1;
10959 next_offset += envelope_size;
10960 }
10961
10962 let next_out_of_line = decoder.next_out_of_line();
10963 let handles_before = decoder.remaining_handles();
10964 if let Some((inlined, num_bytes, num_handles)) =
10965 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10966 {
10967 let member_inline_size =
10968 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10969 if inlined != (member_inline_size <= 4) {
10970 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10971 }
10972 let inner_offset;
10973 let mut inner_depth = depth.clone();
10974 if inlined {
10975 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10976 inner_offset = next_offset;
10977 } else {
10978 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10979 inner_depth.increment()?;
10980 }
10981 let val_ref = self.slaac_valid.get_or_insert_with(|| fidl::new_empty!(bool, D));
10982 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10983 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10984 {
10985 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10986 }
10987 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10988 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10989 }
10990 }
10991
10992 next_offset += envelope_size;
10993
10994 while next_offset < end_offset {
10996 _next_ordinal_to_read += 1;
10997 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10998 next_offset += envelope_size;
10999 }
11000
11001 Ok(())
11002 }
11003 }
11004
11005 impl PdProcessedRaInfo {
11006 #[inline(always)]
11007 fn max_ordinal_present(&self) -> u64 {
11008 if let Some(_) = self.last_platform_ra_msec {
11009 return 3;
11010 }
11011 if let Some(_) = self.num_platform_pio_processed {
11012 return 2;
11013 }
11014 if let Some(_) = self.num_platform_ra_received {
11015 return 1;
11016 }
11017 0
11018 }
11019 }
11020
11021 impl fidl::encoding::ValueTypeMarker for PdProcessedRaInfo {
11022 type Borrowed<'a> = &'a Self;
11023 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11024 value
11025 }
11026 }
11027
11028 unsafe impl fidl::encoding::TypeMarker for PdProcessedRaInfo {
11029 type Owned = Self;
11030
11031 #[inline(always)]
11032 fn inline_align(_context: fidl::encoding::Context) -> usize {
11033 8
11034 }
11035
11036 #[inline(always)]
11037 fn inline_size(_context: fidl::encoding::Context) -> usize {
11038 16
11039 }
11040 }
11041
11042 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PdProcessedRaInfo, D>
11043 for &PdProcessedRaInfo
11044 {
11045 unsafe fn encode(
11046 self,
11047 encoder: &mut fidl::encoding::Encoder<'_, D>,
11048 offset: usize,
11049 mut depth: fidl::encoding::Depth,
11050 ) -> fidl::Result<()> {
11051 encoder.debug_check_bounds::<PdProcessedRaInfo>(offset);
11052 let max_ordinal: u64 = self.max_ordinal_present();
11054 encoder.write_num(max_ordinal, offset);
11055 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11056 if max_ordinal == 0 {
11058 return Ok(());
11059 }
11060 depth.increment()?;
11061 let envelope_size = 8;
11062 let bytes_len = max_ordinal as usize * envelope_size;
11063 #[allow(unused_variables)]
11064 let offset = encoder.out_of_line_offset(bytes_len);
11065 let mut _prev_end_offset: usize = 0;
11066 if 1 > max_ordinal {
11067 return Ok(());
11068 }
11069
11070 let cur_offset: usize = (1 - 1) * envelope_size;
11073
11074 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11076
11077 fidl::encoding::encode_in_envelope_optional::<u32, D>(
11082 self.num_platform_ra_received
11083 .as_ref()
11084 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11085 encoder,
11086 offset + cur_offset,
11087 depth,
11088 )?;
11089
11090 _prev_end_offset = cur_offset + envelope_size;
11091 if 2 > max_ordinal {
11092 return Ok(());
11093 }
11094
11095 let cur_offset: usize = (2 - 1) * envelope_size;
11098
11099 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11101
11102 fidl::encoding::encode_in_envelope_optional::<u32, D>(
11107 self.num_platform_pio_processed
11108 .as_ref()
11109 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11110 encoder,
11111 offset + cur_offset,
11112 depth,
11113 )?;
11114
11115 _prev_end_offset = cur_offset + envelope_size;
11116 if 3 > max_ordinal {
11117 return Ok(());
11118 }
11119
11120 let cur_offset: usize = (3 - 1) * envelope_size;
11123
11124 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11126
11127 fidl::encoding::encode_in_envelope_optional::<u32, D>(
11132 self.last_platform_ra_msec
11133 .as_ref()
11134 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11135 encoder,
11136 offset + cur_offset,
11137 depth,
11138 )?;
11139
11140 _prev_end_offset = cur_offset + envelope_size;
11141
11142 Ok(())
11143 }
11144 }
11145
11146 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PdProcessedRaInfo {
11147 #[inline(always)]
11148 fn new_empty() -> Self {
11149 Self::default()
11150 }
11151
11152 unsafe fn decode(
11153 &mut self,
11154 decoder: &mut fidl::encoding::Decoder<'_, D>,
11155 offset: usize,
11156 mut depth: fidl::encoding::Depth,
11157 ) -> fidl::Result<()> {
11158 decoder.debug_check_bounds::<Self>(offset);
11159 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11160 None => return Err(fidl::Error::NotNullable),
11161 Some(len) => len,
11162 };
11163 if len == 0 {
11165 return Ok(());
11166 };
11167 depth.increment()?;
11168 let envelope_size = 8;
11169 let bytes_len = len * envelope_size;
11170 let offset = decoder.out_of_line_offset(bytes_len)?;
11171 let mut _next_ordinal_to_read = 0;
11173 let mut next_offset = offset;
11174 let end_offset = offset + bytes_len;
11175 _next_ordinal_to_read += 1;
11176 if next_offset >= end_offset {
11177 return Ok(());
11178 }
11179
11180 while _next_ordinal_to_read < 1 {
11182 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11183 _next_ordinal_to_read += 1;
11184 next_offset += envelope_size;
11185 }
11186
11187 let next_out_of_line = decoder.next_out_of_line();
11188 let handles_before = decoder.remaining_handles();
11189 if let Some((inlined, num_bytes, num_handles)) =
11190 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11191 {
11192 let member_inline_size =
11193 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11194 if inlined != (member_inline_size <= 4) {
11195 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11196 }
11197 let inner_offset;
11198 let mut inner_depth = depth.clone();
11199 if inlined {
11200 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11201 inner_offset = next_offset;
11202 } else {
11203 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11204 inner_depth.increment()?;
11205 }
11206 let val_ref =
11207 self.num_platform_ra_received.get_or_insert_with(|| fidl::new_empty!(u32, D));
11208 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11209 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11210 {
11211 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11212 }
11213 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11214 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11215 }
11216 }
11217
11218 next_offset += envelope_size;
11219 _next_ordinal_to_read += 1;
11220 if next_offset >= end_offset {
11221 return Ok(());
11222 }
11223
11224 while _next_ordinal_to_read < 2 {
11226 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11227 _next_ordinal_to_read += 1;
11228 next_offset += envelope_size;
11229 }
11230
11231 let next_out_of_line = decoder.next_out_of_line();
11232 let handles_before = decoder.remaining_handles();
11233 if let Some((inlined, num_bytes, num_handles)) =
11234 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11235 {
11236 let member_inline_size =
11237 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11238 if inlined != (member_inline_size <= 4) {
11239 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11240 }
11241 let inner_offset;
11242 let mut inner_depth = depth.clone();
11243 if inlined {
11244 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11245 inner_offset = next_offset;
11246 } else {
11247 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11248 inner_depth.increment()?;
11249 }
11250 let val_ref =
11251 self.num_platform_pio_processed.get_or_insert_with(|| fidl::new_empty!(u32, D));
11252 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11253 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11254 {
11255 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11256 }
11257 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11258 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11259 }
11260 }
11261
11262 next_offset += envelope_size;
11263 _next_ordinal_to_read += 1;
11264 if next_offset >= end_offset {
11265 return Ok(());
11266 }
11267
11268 while _next_ordinal_to_read < 3 {
11270 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11271 _next_ordinal_to_read += 1;
11272 next_offset += envelope_size;
11273 }
11274
11275 let next_out_of_line = decoder.next_out_of_line();
11276 let handles_before = decoder.remaining_handles();
11277 if let Some((inlined, num_bytes, num_handles)) =
11278 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11279 {
11280 let member_inline_size =
11281 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11282 if inlined != (member_inline_size <= 4) {
11283 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11284 }
11285 let inner_offset;
11286 let mut inner_depth = depth.clone();
11287 if inlined {
11288 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11289 inner_offset = next_offset;
11290 } else {
11291 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11292 inner_depth.increment()?;
11293 }
11294 let val_ref =
11295 self.last_platform_ra_msec.get_or_insert_with(|| fidl::new_empty!(u32, D));
11296 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11297 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11298 {
11299 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11300 }
11301 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11302 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11303 }
11304 }
11305
11306 next_offset += envelope_size;
11307
11308 while next_offset < end_offset {
11310 _next_ordinal_to_read += 1;
11311 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11312 next_offset += envelope_size;
11313 }
11314
11315 Ok(())
11316 }
11317 }
11318
11319 impl SrpServerInfo {
11320 #[inline(always)]
11321 fn max_ordinal_present(&self) -> u64 {
11322 if let Some(_) = self.services_registration {
11323 return 6;
11324 }
11325 if let Some(_) = self.hosts_registration {
11326 return 5;
11327 }
11328 if let Some(_) = self.response_counters {
11329 return 4;
11330 }
11331 if let Some(_) = self.address_mode {
11332 return 3;
11333 }
11334 if let Some(_) = self.port {
11335 return 2;
11336 }
11337 if let Some(_) = self.state {
11338 return 1;
11339 }
11340 0
11341 }
11342 }
11343
11344 impl fidl::encoding::ValueTypeMarker for SrpServerInfo {
11345 type Borrowed<'a> = &'a Self;
11346 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11347 value
11348 }
11349 }
11350
11351 unsafe impl fidl::encoding::TypeMarker for SrpServerInfo {
11352 type Owned = Self;
11353
11354 #[inline(always)]
11355 fn inline_align(_context: fidl::encoding::Context) -> usize {
11356 8
11357 }
11358
11359 #[inline(always)]
11360 fn inline_size(_context: fidl::encoding::Context) -> usize {
11361 16
11362 }
11363 }
11364
11365 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SrpServerInfo, D>
11366 for &SrpServerInfo
11367 {
11368 unsafe fn encode(
11369 self,
11370 encoder: &mut fidl::encoding::Encoder<'_, D>,
11371 offset: usize,
11372 mut depth: fidl::encoding::Depth,
11373 ) -> fidl::Result<()> {
11374 encoder.debug_check_bounds::<SrpServerInfo>(offset);
11375 let max_ordinal: u64 = self.max_ordinal_present();
11377 encoder.write_num(max_ordinal, offset);
11378 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11379 if max_ordinal == 0 {
11381 return Ok(());
11382 }
11383 depth.increment()?;
11384 let envelope_size = 8;
11385 let bytes_len = max_ordinal as usize * envelope_size;
11386 #[allow(unused_variables)]
11387 let offset = encoder.out_of_line_offset(bytes_len);
11388 let mut _prev_end_offset: usize = 0;
11389 if 1 > max_ordinal {
11390 return Ok(());
11391 }
11392
11393 let cur_offset: usize = (1 - 1) * envelope_size;
11396
11397 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11399
11400 fidl::encoding::encode_in_envelope_optional::<SrpServerState, D>(
11405 self.state
11406 .as_ref()
11407 .map(<SrpServerState as fidl::encoding::ValueTypeMarker>::borrow),
11408 encoder,
11409 offset + cur_offset,
11410 depth,
11411 )?;
11412
11413 _prev_end_offset = cur_offset + envelope_size;
11414 if 2 > max_ordinal {
11415 return Ok(());
11416 }
11417
11418 let cur_offset: usize = (2 - 1) * envelope_size;
11421
11422 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11424
11425 fidl::encoding::encode_in_envelope_optional::<u16, D>(
11430 self.port.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
11431 encoder,
11432 offset + cur_offset,
11433 depth,
11434 )?;
11435
11436 _prev_end_offset = cur_offset + envelope_size;
11437 if 3 > max_ordinal {
11438 return Ok(());
11439 }
11440
11441 let cur_offset: usize = (3 - 1) * envelope_size;
11444
11445 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11447
11448 fidl::encoding::encode_in_envelope_optional::<SrpServerAddressMode, D>(
11453 self.address_mode
11454 .as_ref()
11455 .map(<SrpServerAddressMode as fidl::encoding::ValueTypeMarker>::borrow),
11456 encoder,
11457 offset + cur_offset,
11458 depth,
11459 )?;
11460
11461 _prev_end_offset = cur_offset + envelope_size;
11462 if 4 > max_ordinal {
11463 return Ok(());
11464 }
11465
11466 let cur_offset: usize = (4 - 1) * envelope_size;
11469
11470 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11472
11473 fidl::encoding::encode_in_envelope_optional::<SrpServerResponseCounters, D>(
11478 self.response_counters
11479 .as_ref()
11480 .map(<SrpServerResponseCounters as fidl::encoding::ValueTypeMarker>::borrow),
11481 encoder,
11482 offset + cur_offset,
11483 depth,
11484 )?;
11485
11486 _prev_end_offset = cur_offset + envelope_size;
11487 if 5 > max_ordinal {
11488 return Ok(());
11489 }
11490
11491 let cur_offset: usize = (5 - 1) * envelope_size;
11494
11495 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11497
11498 fidl::encoding::encode_in_envelope_optional::<SrpServerRegistration, D>(
11503 self.hosts_registration
11504 .as_ref()
11505 .map(<SrpServerRegistration as fidl::encoding::ValueTypeMarker>::borrow),
11506 encoder,
11507 offset + cur_offset,
11508 depth,
11509 )?;
11510
11511 _prev_end_offset = cur_offset + envelope_size;
11512 if 6 > max_ordinal {
11513 return Ok(());
11514 }
11515
11516 let cur_offset: usize = (6 - 1) * envelope_size;
11519
11520 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11522
11523 fidl::encoding::encode_in_envelope_optional::<SrpServerRegistration, D>(
11528 self.services_registration
11529 .as_ref()
11530 .map(<SrpServerRegistration as fidl::encoding::ValueTypeMarker>::borrow),
11531 encoder,
11532 offset + cur_offset,
11533 depth,
11534 )?;
11535
11536 _prev_end_offset = cur_offset + envelope_size;
11537
11538 Ok(())
11539 }
11540 }
11541
11542 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerInfo {
11543 #[inline(always)]
11544 fn new_empty() -> Self {
11545 Self::default()
11546 }
11547
11548 unsafe fn decode(
11549 &mut self,
11550 decoder: &mut fidl::encoding::Decoder<'_, D>,
11551 offset: usize,
11552 mut depth: fidl::encoding::Depth,
11553 ) -> fidl::Result<()> {
11554 decoder.debug_check_bounds::<Self>(offset);
11555 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11556 None => return Err(fidl::Error::NotNullable),
11557 Some(len) => len,
11558 };
11559 if len == 0 {
11561 return Ok(());
11562 };
11563 depth.increment()?;
11564 let envelope_size = 8;
11565 let bytes_len = len * envelope_size;
11566 let offset = decoder.out_of_line_offset(bytes_len)?;
11567 let mut _next_ordinal_to_read = 0;
11569 let mut next_offset = offset;
11570 let end_offset = offset + bytes_len;
11571 _next_ordinal_to_read += 1;
11572 if next_offset >= end_offset {
11573 return Ok(());
11574 }
11575
11576 while _next_ordinal_to_read < 1 {
11578 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11579 _next_ordinal_to_read += 1;
11580 next_offset += envelope_size;
11581 }
11582
11583 let next_out_of_line = decoder.next_out_of_line();
11584 let handles_before = decoder.remaining_handles();
11585 if let Some((inlined, num_bytes, num_handles)) =
11586 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11587 {
11588 let member_inline_size =
11589 <SrpServerState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11590 if inlined != (member_inline_size <= 4) {
11591 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11592 }
11593 let inner_offset;
11594 let mut inner_depth = depth.clone();
11595 if inlined {
11596 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11597 inner_offset = next_offset;
11598 } else {
11599 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11600 inner_depth.increment()?;
11601 }
11602 let val_ref = self.state.get_or_insert_with(|| fidl::new_empty!(SrpServerState, D));
11603 fidl::decode!(SrpServerState, D, val_ref, decoder, inner_offset, inner_depth)?;
11604 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11605 {
11606 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11607 }
11608 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11609 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11610 }
11611 }
11612
11613 next_offset += envelope_size;
11614 _next_ordinal_to_read += 1;
11615 if next_offset >= end_offset {
11616 return Ok(());
11617 }
11618
11619 while _next_ordinal_to_read < 2 {
11621 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11622 _next_ordinal_to_read += 1;
11623 next_offset += envelope_size;
11624 }
11625
11626 let next_out_of_line = decoder.next_out_of_line();
11627 let handles_before = decoder.remaining_handles();
11628 if let Some((inlined, num_bytes, num_handles)) =
11629 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11630 {
11631 let member_inline_size =
11632 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11633 if inlined != (member_inline_size <= 4) {
11634 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11635 }
11636 let inner_offset;
11637 let mut inner_depth = depth.clone();
11638 if inlined {
11639 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11640 inner_offset = next_offset;
11641 } else {
11642 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11643 inner_depth.increment()?;
11644 }
11645 let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u16, D));
11646 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
11647 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11648 {
11649 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11650 }
11651 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11652 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11653 }
11654 }
11655
11656 next_offset += envelope_size;
11657 _next_ordinal_to_read += 1;
11658 if next_offset >= end_offset {
11659 return Ok(());
11660 }
11661
11662 while _next_ordinal_to_read < 3 {
11664 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11665 _next_ordinal_to_read += 1;
11666 next_offset += envelope_size;
11667 }
11668
11669 let next_out_of_line = decoder.next_out_of_line();
11670 let handles_before = decoder.remaining_handles();
11671 if let Some((inlined, num_bytes, num_handles)) =
11672 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11673 {
11674 let member_inline_size =
11675 <SrpServerAddressMode as fidl::encoding::TypeMarker>::inline_size(
11676 decoder.context,
11677 );
11678 if inlined != (member_inline_size <= 4) {
11679 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11680 }
11681 let inner_offset;
11682 let mut inner_depth = depth.clone();
11683 if inlined {
11684 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11685 inner_offset = next_offset;
11686 } else {
11687 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11688 inner_depth.increment()?;
11689 }
11690 let val_ref = self
11691 .address_mode
11692 .get_or_insert_with(|| fidl::new_empty!(SrpServerAddressMode, D));
11693 fidl::decode!(
11694 SrpServerAddressMode,
11695 D,
11696 val_ref,
11697 decoder,
11698 inner_offset,
11699 inner_depth
11700 )?;
11701 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11702 {
11703 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11704 }
11705 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11706 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11707 }
11708 }
11709
11710 next_offset += envelope_size;
11711 _next_ordinal_to_read += 1;
11712 if next_offset >= end_offset {
11713 return Ok(());
11714 }
11715
11716 while _next_ordinal_to_read < 4 {
11718 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11719 _next_ordinal_to_read += 1;
11720 next_offset += envelope_size;
11721 }
11722
11723 let next_out_of_line = decoder.next_out_of_line();
11724 let handles_before = decoder.remaining_handles();
11725 if let Some((inlined, num_bytes, num_handles)) =
11726 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11727 {
11728 let member_inline_size =
11729 <SrpServerResponseCounters as fidl::encoding::TypeMarker>::inline_size(
11730 decoder.context,
11731 );
11732 if inlined != (member_inline_size <= 4) {
11733 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11734 }
11735 let inner_offset;
11736 let mut inner_depth = depth.clone();
11737 if inlined {
11738 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11739 inner_offset = next_offset;
11740 } else {
11741 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11742 inner_depth.increment()?;
11743 }
11744 let val_ref = self
11745 .response_counters
11746 .get_or_insert_with(|| fidl::new_empty!(SrpServerResponseCounters, D));
11747 fidl::decode!(
11748 SrpServerResponseCounters,
11749 D,
11750 val_ref,
11751 decoder,
11752 inner_offset,
11753 inner_depth
11754 )?;
11755 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11756 {
11757 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11758 }
11759 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11760 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11761 }
11762 }
11763
11764 next_offset += envelope_size;
11765 _next_ordinal_to_read += 1;
11766 if next_offset >= end_offset {
11767 return Ok(());
11768 }
11769
11770 while _next_ordinal_to_read < 5 {
11772 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11773 _next_ordinal_to_read += 1;
11774 next_offset += envelope_size;
11775 }
11776
11777 let next_out_of_line = decoder.next_out_of_line();
11778 let handles_before = decoder.remaining_handles();
11779 if let Some((inlined, num_bytes, num_handles)) =
11780 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11781 {
11782 let member_inline_size =
11783 <SrpServerRegistration as fidl::encoding::TypeMarker>::inline_size(
11784 decoder.context,
11785 );
11786 if inlined != (member_inline_size <= 4) {
11787 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11788 }
11789 let inner_offset;
11790 let mut inner_depth = depth.clone();
11791 if inlined {
11792 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11793 inner_offset = next_offset;
11794 } else {
11795 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11796 inner_depth.increment()?;
11797 }
11798 let val_ref = self
11799 .hosts_registration
11800 .get_or_insert_with(|| fidl::new_empty!(SrpServerRegistration, D));
11801 fidl::decode!(
11802 SrpServerRegistration,
11803 D,
11804 val_ref,
11805 decoder,
11806 inner_offset,
11807 inner_depth
11808 )?;
11809 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11810 {
11811 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11812 }
11813 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11814 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11815 }
11816 }
11817
11818 next_offset += envelope_size;
11819 _next_ordinal_to_read += 1;
11820 if next_offset >= end_offset {
11821 return Ok(());
11822 }
11823
11824 while _next_ordinal_to_read < 6 {
11826 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11827 _next_ordinal_to_read += 1;
11828 next_offset += envelope_size;
11829 }
11830
11831 let next_out_of_line = decoder.next_out_of_line();
11832 let handles_before = decoder.remaining_handles();
11833 if let Some((inlined, num_bytes, num_handles)) =
11834 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11835 {
11836 let member_inline_size =
11837 <SrpServerRegistration as fidl::encoding::TypeMarker>::inline_size(
11838 decoder.context,
11839 );
11840 if inlined != (member_inline_size <= 4) {
11841 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11842 }
11843 let inner_offset;
11844 let mut inner_depth = depth.clone();
11845 if inlined {
11846 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11847 inner_offset = next_offset;
11848 } else {
11849 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11850 inner_depth.increment()?;
11851 }
11852 let val_ref = self
11853 .services_registration
11854 .get_or_insert_with(|| fidl::new_empty!(SrpServerRegistration, D));
11855 fidl::decode!(
11856 SrpServerRegistration,
11857 D,
11858 val_ref,
11859 decoder,
11860 inner_offset,
11861 inner_depth
11862 )?;
11863 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11864 {
11865 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11866 }
11867 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11868 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11869 }
11870 }
11871
11872 next_offset += envelope_size;
11873
11874 while next_offset < end_offset {
11876 _next_ordinal_to_read += 1;
11877 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11878 next_offset += envelope_size;
11879 }
11880
11881 Ok(())
11882 }
11883 }
11884
11885 impl SrpServerRegistration {
11886 #[inline(always)]
11887 fn max_ordinal_present(&self) -> u64 {
11888 if let Some(_) = self.remaining_key_lease_time_total {
11889 return 6;
11890 }
11891 if let Some(_) = self.remaining_lease_time_total {
11892 return 5;
11893 }
11894 if let Some(_) = self.key_lease_time_total {
11895 return 4;
11896 }
11897 if let Some(_) = self.lease_time_total {
11898 return 3;
11899 }
11900 if let Some(_) = self.deleted_count {
11901 return 2;
11902 }
11903 if let Some(_) = self.fresh_count {
11904 return 1;
11905 }
11906 0
11907 }
11908 }
11909
11910 impl fidl::encoding::ValueTypeMarker for SrpServerRegistration {
11911 type Borrowed<'a> = &'a Self;
11912 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11913 value
11914 }
11915 }
11916
11917 unsafe impl fidl::encoding::TypeMarker for SrpServerRegistration {
11918 type Owned = Self;
11919
11920 #[inline(always)]
11921 fn inline_align(_context: fidl::encoding::Context) -> usize {
11922 8
11923 }
11924
11925 #[inline(always)]
11926 fn inline_size(_context: fidl::encoding::Context) -> usize {
11927 16
11928 }
11929 }
11930
11931 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SrpServerRegistration, D>
11932 for &SrpServerRegistration
11933 {
11934 unsafe fn encode(
11935 self,
11936 encoder: &mut fidl::encoding::Encoder<'_, D>,
11937 offset: usize,
11938 mut depth: fidl::encoding::Depth,
11939 ) -> fidl::Result<()> {
11940 encoder.debug_check_bounds::<SrpServerRegistration>(offset);
11941 let max_ordinal: u64 = self.max_ordinal_present();
11943 encoder.write_num(max_ordinal, offset);
11944 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11945 if max_ordinal == 0 {
11947 return Ok(());
11948 }
11949 depth.increment()?;
11950 let envelope_size = 8;
11951 let bytes_len = max_ordinal as usize * envelope_size;
11952 #[allow(unused_variables)]
11953 let offset = encoder.out_of_line_offset(bytes_len);
11954 let mut _prev_end_offset: usize = 0;
11955 if 1 > max_ordinal {
11956 return Ok(());
11957 }
11958
11959 let cur_offset: usize = (1 - 1) * envelope_size;
11962
11963 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11965
11966 fidl::encoding::encode_in_envelope_optional::<u32, D>(
11971 self.fresh_count.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11972 encoder,
11973 offset + cur_offset,
11974 depth,
11975 )?;
11976
11977 _prev_end_offset = cur_offset + envelope_size;
11978 if 2 > max_ordinal {
11979 return Ok(());
11980 }
11981
11982 let cur_offset: usize = (2 - 1) * envelope_size;
11985
11986 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11988
11989 fidl::encoding::encode_in_envelope_optional::<u32, D>(
11994 self.deleted_count.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11995 encoder,
11996 offset + cur_offset,
11997 depth,
11998 )?;
11999
12000 _prev_end_offset = cur_offset + envelope_size;
12001 if 3 > max_ordinal {
12002 return Ok(());
12003 }
12004
12005 let cur_offset: usize = (3 - 1) * envelope_size;
12008
12009 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12011
12012 fidl::encoding::encode_in_envelope_optional::<i64, D>(
12017 self.lease_time_total
12018 .as_ref()
12019 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12020 encoder,
12021 offset + cur_offset,
12022 depth,
12023 )?;
12024
12025 _prev_end_offset = cur_offset + envelope_size;
12026 if 4 > max_ordinal {
12027 return Ok(());
12028 }
12029
12030 let cur_offset: usize = (4 - 1) * envelope_size;
12033
12034 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12036
12037 fidl::encoding::encode_in_envelope_optional::<i64, D>(
12042 self.key_lease_time_total
12043 .as_ref()
12044 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12045 encoder,
12046 offset + cur_offset,
12047 depth,
12048 )?;
12049
12050 _prev_end_offset = cur_offset + envelope_size;
12051 if 5 > max_ordinal {
12052 return Ok(());
12053 }
12054
12055 let cur_offset: usize = (5 - 1) * envelope_size;
12058
12059 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12061
12062 fidl::encoding::encode_in_envelope_optional::<i64, D>(
12067 self.remaining_lease_time_total
12068 .as_ref()
12069 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12070 encoder,
12071 offset + cur_offset,
12072 depth,
12073 )?;
12074
12075 _prev_end_offset = cur_offset + envelope_size;
12076 if 6 > max_ordinal {
12077 return Ok(());
12078 }
12079
12080 let cur_offset: usize = (6 - 1) * envelope_size;
12083
12084 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12086
12087 fidl::encoding::encode_in_envelope_optional::<i64, D>(
12092 self.remaining_key_lease_time_total
12093 .as_ref()
12094 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12095 encoder,
12096 offset + cur_offset,
12097 depth,
12098 )?;
12099
12100 _prev_end_offset = cur_offset + envelope_size;
12101
12102 Ok(())
12103 }
12104 }
12105
12106 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerRegistration {
12107 #[inline(always)]
12108 fn new_empty() -> Self {
12109 Self::default()
12110 }
12111
12112 unsafe fn decode(
12113 &mut self,
12114 decoder: &mut fidl::encoding::Decoder<'_, D>,
12115 offset: usize,
12116 mut depth: fidl::encoding::Depth,
12117 ) -> fidl::Result<()> {
12118 decoder.debug_check_bounds::<Self>(offset);
12119 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12120 None => return Err(fidl::Error::NotNullable),
12121 Some(len) => len,
12122 };
12123 if len == 0 {
12125 return Ok(());
12126 };
12127 depth.increment()?;
12128 let envelope_size = 8;
12129 let bytes_len = len * envelope_size;
12130 let offset = decoder.out_of_line_offset(bytes_len)?;
12131 let mut _next_ordinal_to_read = 0;
12133 let mut next_offset = offset;
12134 let end_offset = offset + bytes_len;
12135 _next_ordinal_to_read += 1;
12136 if next_offset >= end_offset {
12137 return Ok(());
12138 }
12139
12140 while _next_ordinal_to_read < 1 {
12142 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12143 _next_ordinal_to_read += 1;
12144 next_offset += envelope_size;
12145 }
12146
12147 let next_out_of_line = decoder.next_out_of_line();
12148 let handles_before = decoder.remaining_handles();
12149 if let Some((inlined, num_bytes, num_handles)) =
12150 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12151 {
12152 let member_inline_size =
12153 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12154 if inlined != (member_inline_size <= 4) {
12155 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12156 }
12157 let inner_offset;
12158 let mut inner_depth = depth.clone();
12159 if inlined {
12160 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12161 inner_offset = next_offset;
12162 } else {
12163 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12164 inner_depth.increment()?;
12165 }
12166 let val_ref = self.fresh_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
12167 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12168 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12169 {
12170 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12171 }
12172 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12173 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12174 }
12175 }
12176
12177 next_offset += envelope_size;
12178 _next_ordinal_to_read += 1;
12179 if next_offset >= end_offset {
12180 return Ok(());
12181 }
12182
12183 while _next_ordinal_to_read < 2 {
12185 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12186 _next_ordinal_to_read += 1;
12187 next_offset += envelope_size;
12188 }
12189
12190 let next_out_of_line = decoder.next_out_of_line();
12191 let handles_before = decoder.remaining_handles();
12192 if let Some((inlined, num_bytes, num_handles)) =
12193 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12194 {
12195 let member_inline_size =
12196 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12197 if inlined != (member_inline_size <= 4) {
12198 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12199 }
12200 let inner_offset;
12201 let mut inner_depth = depth.clone();
12202 if inlined {
12203 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12204 inner_offset = next_offset;
12205 } else {
12206 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12207 inner_depth.increment()?;
12208 }
12209 let val_ref = self.deleted_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
12210 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12211 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12212 {
12213 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12214 }
12215 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12216 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12217 }
12218 }
12219
12220 next_offset += envelope_size;
12221 _next_ordinal_to_read += 1;
12222 if next_offset >= end_offset {
12223 return Ok(());
12224 }
12225
12226 while _next_ordinal_to_read < 3 {
12228 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12229 _next_ordinal_to_read += 1;
12230 next_offset += envelope_size;
12231 }
12232
12233 let next_out_of_line = decoder.next_out_of_line();
12234 let handles_before = decoder.remaining_handles();
12235 if let Some((inlined, num_bytes, num_handles)) =
12236 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12237 {
12238 let member_inline_size =
12239 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12240 if inlined != (member_inline_size <= 4) {
12241 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12242 }
12243 let inner_offset;
12244 let mut inner_depth = depth.clone();
12245 if inlined {
12246 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12247 inner_offset = next_offset;
12248 } else {
12249 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12250 inner_depth.increment()?;
12251 }
12252 let val_ref = self.lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12253 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12254 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12255 {
12256 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12257 }
12258 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12259 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12260 }
12261 }
12262
12263 next_offset += envelope_size;
12264 _next_ordinal_to_read += 1;
12265 if next_offset >= end_offset {
12266 return Ok(());
12267 }
12268
12269 while _next_ordinal_to_read < 4 {
12271 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12272 _next_ordinal_to_read += 1;
12273 next_offset += envelope_size;
12274 }
12275
12276 let next_out_of_line = decoder.next_out_of_line();
12277 let handles_before = decoder.remaining_handles();
12278 if let Some((inlined, num_bytes, num_handles)) =
12279 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12280 {
12281 let member_inline_size =
12282 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12283 if inlined != (member_inline_size <= 4) {
12284 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12285 }
12286 let inner_offset;
12287 let mut inner_depth = depth.clone();
12288 if inlined {
12289 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12290 inner_offset = next_offset;
12291 } else {
12292 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12293 inner_depth.increment()?;
12294 }
12295 let val_ref =
12296 self.key_lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12297 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12298 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12299 {
12300 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12301 }
12302 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12303 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12304 }
12305 }
12306
12307 next_offset += envelope_size;
12308 _next_ordinal_to_read += 1;
12309 if next_offset >= end_offset {
12310 return Ok(());
12311 }
12312
12313 while _next_ordinal_to_read < 5 {
12315 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12316 _next_ordinal_to_read += 1;
12317 next_offset += envelope_size;
12318 }
12319
12320 let next_out_of_line = decoder.next_out_of_line();
12321 let handles_before = decoder.remaining_handles();
12322 if let Some((inlined, num_bytes, num_handles)) =
12323 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12324 {
12325 let member_inline_size =
12326 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12327 if inlined != (member_inline_size <= 4) {
12328 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12329 }
12330 let inner_offset;
12331 let mut inner_depth = depth.clone();
12332 if inlined {
12333 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12334 inner_offset = next_offset;
12335 } else {
12336 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12337 inner_depth.increment()?;
12338 }
12339 let val_ref =
12340 self.remaining_lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12341 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12342 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12343 {
12344 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12345 }
12346 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12347 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12348 }
12349 }
12350
12351 next_offset += envelope_size;
12352 _next_ordinal_to_read += 1;
12353 if next_offset >= end_offset {
12354 return Ok(());
12355 }
12356
12357 while _next_ordinal_to_read < 6 {
12359 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12360 _next_ordinal_to_read += 1;
12361 next_offset += envelope_size;
12362 }
12363
12364 let next_out_of_line = decoder.next_out_of_line();
12365 let handles_before = decoder.remaining_handles();
12366 if let Some((inlined, num_bytes, num_handles)) =
12367 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12368 {
12369 let member_inline_size =
12370 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12371 if inlined != (member_inline_size <= 4) {
12372 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12373 }
12374 let inner_offset;
12375 let mut inner_depth = depth.clone();
12376 if inlined {
12377 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12378 inner_offset = next_offset;
12379 } else {
12380 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12381 inner_depth.increment()?;
12382 }
12383 let val_ref = self
12384 .remaining_key_lease_time_total
12385 .get_or_insert_with(|| fidl::new_empty!(i64, D));
12386 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12387 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12388 {
12389 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12390 }
12391 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12392 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12393 }
12394 }
12395
12396 next_offset += envelope_size;
12397
12398 while next_offset < end_offset {
12400 _next_ordinal_to_read += 1;
12401 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12402 next_offset += envelope_size;
12403 }
12404
12405 Ok(())
12406 }
12407 }
12408
12409 impl SrpServerResponseCounters {
12410 #[inline(always)]
12411 fn max_ordinal_present(&self) -> u64 {
12412 if let Some(_) = self.other_response {
12413 return 6;
12414 }
12415 if let Some(_) = self.refused_response {
12416 return 5;
12417 }
12418 if let Some(_) = self.name_exists_response {
12419 return 4;
12420 }
12421 if let Some(_) = self.format_error_response {
12422 return 3;
12423 }
12424 if let Some(_) = self.server_failure_response {
12425 return 2;
12426 }
12427 if let Some(_) = self.success_response {
12428 return 1;
12429 }
12430 0
12431 }
12432 }
12433
12434 impl fidl::encoding::ValueTypeMarker for SrpServerResponseCounters {
12435 type Borrowed<'a> = &'a Self;
12436 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12437 value
12438 }
12439 }
12440
12441 unsafe impl fidl::encoding::TypeMarker for SrpServerResponseCounters {
12442 type Owned = Self;
12443
12444 #[inline(always)]
12445 fn inline_align(_context: fidl::encoding::Context) -> usize {
12446 8
12447 }
12448
12449 #[inline(always)]
12450 fn inline_size(_context: fidl::encoding::Context) -> usize {
12451 16
12452 }
12453 }
12454
12455 unsafe impl<D: fidl::encoding::ResourceDialect>
12456 fidl::encoding::Encode<SrpServerResponseCounters, D> for &SrpServerResponseCounters
12457 {
12458 unsafe fn encode(
12459 self,
12460 encoder: &mut fidl::encoding::Encoder<'_, D>,
12461 offset: usize,
12462 mut depth: fidl::encoding::Depth,
12463 ) -> fidl::Result<()> {
12464 encoder.debug_check_bounds::<SrpServerResponseCounters>(offset);
12465 let max_ordinal: u64 = self.max_ordinal_present();
12467 encoder.write_num(max_ordinal, offset);
12468 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12469 if max_ordinal == 0 {
12471 return Ok(());
12472 }
12473 depth.increment()?;
12474 let envelope_size = 8;
12475 let bytes_len = max_ordinal as usize * envelope_size;
12476 #[allow(unused_variables)]
12477 let offset = encoder.out_of_line_offset(bytes_len);
12478 let mut _prev_end_offset: usize = 0;
12479 if 1 > max_ordinal {
12480 return Ok(());
12481 }
12482
12483 let cur_offset: usize = (1 - 1) * envelope_size;
12486
12487 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12489
12490 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12495 self.success_response
12496 .as_ref()
12497 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12498 encoder,
12499 offset + cur_offset,
12500 depth,
12501 )?;
12502
12503 _prev_end_offset = cur_offset + envelope_size;
12504 if 2 > max_ordinal {
12505 return Ok(());
12506 }
12507
12508 let cur_offset: usize = (2 - 1) * envelope_size;
12511
12512 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12514
12515 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12520 self.server_failure_response
12521 .as_ref()
12522 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12523 encoder,
12524 offset + cur_offset,
12525 depth,
12526 )?;
12527
12528 _prev_end_offset = cur_offset + envelope_size;
12529 if 3 > max_ordinal {
12530 return Ok(());
12531 }
12532
12533 let cur_offset: usize = (3 - 1) * envelope_size;
12536
12537 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12539
12540 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12545 self.format_error_response
12546 .as_ref()
12547 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12548 encoder,
12549 offset + cur_offset,
12550 depth,
12551 )?;
12552
12553 _prev_end_offset = cur_offset + envelope_size;
12554 if 4 > max_ordinal {
12555 return Ok(());
12556 }
12557
12558 let cur_offset: usize = (4 - 1) * envelope_size;
12561
12562 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12564
12565 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12570 self.name_exists_response
12571 .as_ref()
12572 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12573 encoder,
12574 offset + cur_offset,
12575 depth,
12576 )?;
12577
12578 _prev_end_offset = cur_offset + envelope_size;
12579 if 5 > max_ordinal {
12580 return Ok(());
12581 }
12582
12583 let cur_offset: usize = (5 - 1) * envelope_size;
12586
12587 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12589
12590 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12595 self.refused_response
12596 .as_ref()
12597 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12598 encoder,
12599 offset + cur_offset,
12600 depth,
12601 )?;
12602
12603 _prev_end_offset = cur_offset + envelope_size;
12604 if 6 > max_ordinal {
12605 return Ok(());
12606 }
12607
12608 let cur_offset: usize = (6 - 1) * envelope_size;
12611
12612 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12614
12615 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12620 self.other_response.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12621 encoder,
12622 offset + cur_offset,
12623 depth,
12624 )?;
12625
12626 _prev_end_offset = cur_offset + envelope_size;
12627
12628 Ok(())
12629 }
12630 }
12631
12632 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12633 for SrpServerResponseCounters
12634 {
12635 #[inline(always)]
12636 fn new_empty() -> Self {
12637 Self::default()
12638 }
12639
12640 unsafe fn decode(
12641 &mut self,
12642 decoder: &mut fidl::encoding::Decoder<'_, D>,
12643 offset: usize,
12644 mut depth: fidl::encoding::Depth,
12645 ) -> fidl::Result<()> {
12646 decoder.debug_check_bounds::<Self>(offset);
12647 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12648 None => return Err(fidl::Error::NotNullable),
12649 Some(len) => len,
12650 };
12651 if len == 0 {
12653 return Ok(());
12654 };
12655 depth.increment()?;
12656 let envelope_size = 8;
12657 let bytes_len = len * envelope_size;
12658 let offset = decoder.out_of_line_offset(bytes_len)?;
12659 let mut _next_ordinal_to_read = 0;
12661 let mut next_offset = offset;
12662 let end_offset = offset + bytes_len;
12663 _next_ordinal_to_read += 1;
12664 if next_offset >= end_offset {
12665 return Ok(());
12666 }
12667
12668 while _next_ordinal_to_read < 1 {
12670 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12671 _next_ordinal_to_read += 1;
12672 next_offset += envelope_size;
12673 }
12674
12675 let next_out_of_line = decoder.next_out_of_line();
12676 let handles_before = decoder.remaining_handles();
12677 if let Some((inlined, num_bytes, num_handles)) =
12678 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12679 {
12680 let member_inline_size =
12681 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12682 if inlined != (member_inline_size <= 4) {
12683 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12684 }
12685 let inner_offset;
12686 let mut inner_depth = depth.clone();
12687 if inlined {
12688 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12689 inner_offset = next_offset;
12690 } else {
12691 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12692 inner_depth.increment()?;
12693 }
12694 let val_ref = self.success_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12695 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12696 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12697 {
12698 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12699 }
12700 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12701 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12702 }
12703 }
12704
12705 next_offset += envelope_size;
12706 _next_ordinal_to_read += 1;
12707 if next_offset >= end_offset {
12708 return Ok(());
12709 }
12710
12711 while _next_ordinal_to_read < 2 {
12713 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12714 _next_ordinal_to_read += 1;
12715 next_offset += envelope_size;
12716 }
12717
12718 let next_out_of_line = decoder.next_out_of_line();
12719 let handles_before = decoder.remaining_handles();
12720 if let Some((inlined, num_bytes, num_handles)) =
12721 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12722 {
12723 let member_inline_size =
12724 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12725 if inlined != (member_inline_size <= 4) {
12726 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12727 }
12728 let inner_offset;
12729 let mut inner_depth = depth.clone();
12730 if inlined {
12731 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12732 inner_offset = next_offset;
12733 } else {
12734 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12735 inner_depth.increment()?;
12736 }
12737 let val_ref =
12738 self.server_failure_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12739 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12740 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12741 {
12742 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12743 }
12744 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12745 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12746 }
12747 }
12748
12749 next_offset += envelope_size;
12750 _next_ordinal_to_read += 1;
12751 if next_offset >= end_offset {
12752 return Ok(());
12753 }
12754
12755 while _next_ordinal_to_read < 3 {
12757 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12758 _next_ordinal_to_read += 1;
12759 next_offset += envelope_size;
12760 }
12761
12762 let next_out_of_line = decoder.next_out_of_line();
12763 let handles_before = decoder.remaining_handles();
12764 if let Some((inlined, num_bytes, num_handles)) =
12765 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12766 {
12767 let member_inline_size =
12768 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12769 if inlined != (member_inline_size <= 4) {
12770 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12771 }
12772 let inner_offset;
12773 let mut inner_depth = depth.clone();
12774 if inlined {
12775 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12776 inner_offset = next_offset;
12777 } else {
12778 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12779 inner_depth.increment()?;
12780 }
12781 let val_ref =
12782 self.format_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12783 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12784 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12785 {
12786 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12787 }
12788 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12789 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12790 }
12791 }
12792
12793 next_offset += envelope_size;
12794 _next_ordinal_to_read += 1;
12795 if next_offset >= end_offset {
12796 return Ok(());
12797 }
12798
12799 while _next_ordinal_to_read < 4 {
12801 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12802 _next_ordinal_to_read += 1;
12803 next_offset += envelope_size;
12804 }
12805
12806 let next_out_of_line = decoder.next_out_of_line();
12807 let handles_before = decoder.remaining_handles();
12808 if let Some((inlined, num_bytes, num_handles)) =
12809 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12810 {
12811 let member_inline_size =
12812 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12813 if inlined != (member_inline_size <= 4) {
12814 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12815 }
12816 let inner_offset;
12817 let mut inner_depth = depth.clone();
12818 if inlined {
12819 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12820 inner_offset = next_offset;
12821 } else {
12822 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12823 inner_depth.increment()?;
12824 }
12825 let val_ref =
12826 self.name_exists_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12827 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12828 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12829 {
12830 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12831 }
12832 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12833 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12834 }
12835 }
12836
12837 next_offset += envelope_size;
12838 _next_ordinal_to_read += 1;
12839 if next_offset >= end_offset {
12840 return Ok(());
12841 }
12842
12843 while _next_ordinal_to_read < 5 {
12845 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12846 _next_ordinal_to_read += 1;
12847 next_offset += envelope_size;
12848 }
12849
12850 let next_out_of_line = decoder.next_out_of_line();
12851 let handles_before = decoder.remaining_handles();
12852 if let Some((inlined, num_bytes, num_handles)) =
12853 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12854 {
12855 let member_inline_size =
12856 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12857 if inlined != (member_inline_size <= 4) {
12858 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12859 }
12860 let inner_offset;
12861 let mut inner_depth = depth.clone();
12862 if inlined {
12863 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12864 inner_offset = next_offset;
12865 } else {
12866 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12867 inner_depth.increment()?;
12868 }
12869 let val_ref = self.refused_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12870 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12871 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12872 {
12873 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12874 }
12875 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12876 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12877 }
12878 }
12879
12880 next_offset += envelope_size;
12881 _next_ordinal_to_read += 1;
12882 if next_offset >= end_offset {
12883 return Ok(());
12884 }
12885
12886 while _next_ordinal_to_read < 6 {
12888 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12889 _next_ordinal_to_read += 1;
12890 next_offset += envelope_size;
12891 }
12892
12893 let next_out_of_line = decoder.next_out_of_line();
12894 let handles_before = decoder.remaining_handles();
12895 if let Some((inlined, num_bytes, num_handles)) =
12896 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12897 {
12898 let member_inline_size =
12899 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12900 if inlined != (member_inline_size <= 4) {
12901 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12902 }
12903 let inner_offset;
12904 let mut inner_depth = depth.clone();
12905 if inlined {
12906 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12907 inner_offset = next_offset;
12908 } else {
12909 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12910 inner_depth.increment()?;
12911 }
12912 let val_ref = self.other_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12913 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12914 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12915 {
12916 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12917 }
12918 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12919 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12920 }
12921 }
12922
12923 next_offset += envelope_size;
12924
12925 while next_offset < end_offset {
12927 _next_ordinal_to_read += 1;
12928 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12929 next_offset += envelope_size;
12930 }
12931
12932 Ok(())
12933 }
12934 }
12935
12936 impl Telemetry {
12937 #[inline(always)]
12938 fn max_ordinal_present(&self) -> u64 {
12939 if let Some(_) = self.link_metrics_entries {
12940 return 24;
12941 }
12942 if let Some(_) = self.dhcp6pd_info {
12943 return 23;
12944 }
12945 if let Some(_) = self.upstream_dns_info {
12946 return 22;
12947 }
12948 if let Some(_) = self.trel_peers_info {
12949 return 21;
12950 }
12951 if let Some(_) = self.trel_counters {
12952 return 20;
12953 }
12954 if let Some(_) = self.nat64_info {
12955 return 19;
12956 }
12957 if let Some(_) = self.uptime {
12958 return 18;
12959 }
12960 if let Some(_) = self.leader_data {
12961 return 17;
12962 }
12963 if let Some(_) = self.dnssd_counters {
12964 return 16;
12965 }
12966 if let Some(_) = self.srp_server_info {
12967 return 15;
12968 }
12969 if let Some(_) = self.thread_border_routing_counters {
12970 return 14;
12971 }
12972 if let Some(_) = self.thread_stable_network_data {
12973 return 13;
12974 }
12975 if let Some(_) = self.thread_network_data {
12976 return 12;
12977 }
12978 if let Some(_) = self.thread_stable_network_data_version {
12979 return 11;
12980 }
12981 if let Some(_) = self.thread_network_data_version {
12982 return 10;
12983 }
12984 if let Some(_) = self.thread_rloc {
12985 return 9;
12986 }
12987 if let Some(_) = self.thread_router_id {
12988 return 8;
12989 }
12990 if let Some(_) = self.thread_link_mode {
12991 return 7;
12992 }
12993 if let Some(_) = self.rcp_version {
12994 return 6;
12995 }
12996 if let Some(_) = self.stack_version {
12997 return 5;
12998 }
12999 if let Some(_) = self.partition_id {
13000 return 4;
13001 }
13002 if let Some(_) = self.channel_index {
13003 return 3;
13004 }
13005 if let Some(_) = self.tx_power {
13006 return 2;
13007 }
13008 if let Some(_) = self.rssi {
13009 return 1;
13010 }
13011 0
13012 }
13013 }
13014
13015 impl fidl::encoding::ValueTypeMarker for Telemetry {
13016 type Borrowed<'a> = &'a Self;
13017 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13018 value
13019 }
13020 }
13021
13022 unsafe impl fidl::encoding::TypeMarker for Telemetry {
13023 type Owned = Self;
13024
13025 #[inline(always)]
13026 fn inline_align(_context: fidl::encoding::Context) -> usize {
13027 8
13028 }
13029
13030 #[inline(always)]
13031 fn inline_size(_context: fidl::encoding::Context) -> usize {
13032 16
13033 }
13034 }
13035
13036 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Telemetry, D>
13037 for &Telemetry
13038 {
13039 unsafe fn encode(
13040 self,
13041 encoder: &mut fidl::encoding::Encoder<'_, D>,
13042 offset: usize,
13043 mut depth: fidl::encoding::Depth,
13044 ) -> fidl::Result<()> {
13045 encoder.debug_check_bounds::<Telemetry>(offset);
13046 let max_ordinal: u64 = self.max_ordinal_present();
13048 encoder.write_num(max_ordinal, offset);
13049 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13050 if max_ordinal == 0 {
13052 return Ok(());
13053 }
13054 depth.increment()?;
13055 let envelope_size = 8;
13056 let bytes_len = max_ordinal as usize * envelope_size;
13057 #[allow(unused_variables)]
13058 let offset = encoder.out_of_line_offset(bytes_len);
13059 let mut _prev_end_offset: usize = 0;
13060 if 1 > max_ordinal {
13061 return Ok(());
13062 }
13063
13064 let cur_offset: usize = (1 - 1) * envelope_size;
13067
13068 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13070
13071 fidl::encoding::encode_in_envelope_optional::<i8, D>(
13076 self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
13077 encoder,
13078 offset + cur_offset,
13079 depth,
13080 )?;
13081
13082 _prev_end_offset = cur_offset + envelope_size;
13083 if 2 > max_ordinal {
13084 return Ok(());
13085 }
13086
13087 let cur_offset: usize = (2 - 1) * envelope_size;
13090
13091 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13093
13094 fidl::encoding::encode_in_envelope_optional::<i8, D>(
13099 self.tx_power.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
13100 encoder,
13101 offset + cur_offset,
13102 depth,
13103 )?;
13104
13105 _prev_end_offset = cur_offset + envelope_size;
13106 if 3 > max_ordinal {
13107 return Ok(());
13108 }
13109
13110 let cur_offset: usize = (3 - 1) * envelope_size;
13113
13114 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13116
13117 fidl::encoding::encode_in_envelope_optional::<u16, D>(
13122 self.channel_index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
13123 encoder,
13124 offset + cur_offset,
13125 depth,
13126 )?;
13127
13128 _prev_end_offset = cur_offset + envelope_size;
13129 if 4 > max_ordinal {
13130 return Ok(());
13131 }
13132
13133 let cur_offset: usize = (4 - 1) * envelope_size;
13136
13137 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13139
13140 fidl::encoding::encode_in_envelope_optional::<u32, D>(
13145 self.partition_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13146 encoder,
13147 offset + cur_offset,
13148 depth,
13149 )?;
13150
13151 _prev_end_offset = cur_offset + envelope_size;
13152 if 5 > max_ordinal {
13153 return Ok(());
13154 }
13155
13156 let cur_offset: usize = (5 - 1) * envelope_size;
13159
13160 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13162
13163 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
13168 self.stack_version.as_ref().map(
13169 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
13170 ),
13171 encoder,
13172 offset + cur_offset,
13173 depth,
13174 )?;
13175
13176 _prev_end_offset = cur_offset + envelope_size;
13177 if 6 > max_ordinal {
13178 return Ok(());
13179 }
13180
13181 let cur_offset: usize = (6 - 1) * envelope_size;
13184
13185 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13187
13188 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
13193 self.rcp_version.as_ref().map(
13194 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
13195 ),
13196 encoder,
13197 offset + cur_offset,
13198 depth,
13199 )?;
13200
13201 _prev_end_offset = cur_offset + envelope_size;
13202 if 7 > max_ordinal {
13203 return Ok(());
13204 }
13205
13206 let cur_offset: usize = (7 - 1) * envelope_size;
13209
13210 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13212
13213 fidl::encoding::encode_in_envelope_optional::<u8, D>(
13218 self.thread_link_mode.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13219 encoder,
13220 offset + cur_offset,
13221 depth,
13222 )?;
13223
13224 _prev_end_offset = cur_offset + envelope_size;
13225 if 8 > max_ordinal {
13226 return Ok(());
13227 }
13228
13229 let cur_offset: usize = (8 - 1) * envelope_size;
13232
13233 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13235
13236 fidl::encoding::encode_in_envelope_optional::<u8, D>(
13241 self.thread_router_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13242 encoder,
13243 offset + cur_offset,
13244 depth,
13245 )?;
13246
13247 _prev_end_offset = cur_offset + envelope_size;
13248 if 9 > max_ordinal {
13249 return Ok(());
13250 }
13251
13252 let cur_offset: usize = (9 - 1) * envelope_size;
13255
13256 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13258
13259 fidl::encoding::encode_in_envelope_optional::<u16, D>(
13264 self.thread_rloc.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
13265 encoder,
13266 offset + cur_offset,
13267 depth,
13268 )?;
13269
13270 _prev_end_offset = cur_offset + envelope_size;
13271 if 10 > max_ordinal {
13272 return Ok(());
13273 }
13274
13275 let cur_offset: usize = (10 - 1) * envelope_size;
13278
13279 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13281
13282 fidl::encoding::encode_in_envelope_optional::<u8, D>(
13287 self.thread_network_data_version
13288 .as_ref()
13289 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13290 encoder,
13291 offset + cur_offset,
13292 depth,
13293 )?;
13294
13295 _prev_end_offset = cur_offset + envelope_size;
13296 if 11 > max_ordinal {
13297 return Ok(());
13298 }
13299
13300 let cur_offset: usize = (11 - 1) * envelope_size;
13303
13304 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13306
13307 fidl::encoding::encode_in_envelope_optional::<u8, D>(
13312 self.thread_stable_network_data_version
13313 .as_ref()
13314 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13315 encoder,
13316 offset + cur_offset,
13317 depth,
13318 )?;
13319
13320 _prev_end_offset = cur_offset + envelope_size;
13321 if 12 > max_ordinal {
13322 return Ok(());
13323 }
13324
13325 let cur_offset: usize = (12 - 1) * envelope_size;
13328
13329 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13331
13332 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 255>, D>(
13337 self.thread_network_data.as_ref().map(
13338 <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow,
13339 ),
13340 encoder,
13341 offset + cur_offset,
13342 depth,
13343 )?;
13344
13345 _prev_end_offset = cur_offset + envelope_size;
13346 if 13 > max_ordinal {
13347 return Ok(());
13348 }
13349
13350 let cur_offset: usize = (13 - 1) * envelope_size;
13353
13354 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13356
13357 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 255>, D>(
13362 self.thread_stable_network_data.as_ref().map(
13363 <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow,
13364 ),
13365 encoder,
13366 offset + cur_offset,
13367 depth,
13368 )?;
13369
13370 _prev_end_offset = cur_offset + envelope_size;
13371 if 14 > max_ordinal {
13372 return Ok(());
13373 }
13374
13375 let cur_offset: usize = (14 - 1) * envelope_size;
13378
13379 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13381
13382 fidl::encoding::encode_in_envelope_optional::<BorderRoutingCounters, D>(
13387 self.thread_border_routing_counters
13388 .as_ref()
13389 .map(<BorderRoutingCounters as fidl::encoding::ValueTypeMarker>::borrow),
13390 encoder,
13391 offset + cur_offset,
13392 depth,
13393 )?;
13394
13395 _prev_end_offset = cur_offset + envelope_size;
13396 if 15 > max_ordinal {
13397 return Ok(());
13398 }
13399
13400 let cur_offset: usize = (15 - 1) * envelope_size;
13403
13404 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13406
13407 fidl::encoding::encode_in_envelope_optional::<SrpServerInfo, D>(
13412 self.srp_server_info
13413 .as_ref()
13414 .map(<SrpServerInfo as fidl::encoding::ValueTypeMarker>::borrow),
13415 encoder,
13416 offset + cur_offset,
13417 depth,
13418 )?;
13419
13420 _prev_end_offset = cur_offset + envelope_size;
13421 if 16 > max_ordinal {
13422 return Ok(());
13423 }
13424
13425 let cur_offset: usize = (16 - 1) * envelope_size;
13428
13429 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13431
13432 fidl::encoding::encode_in_envelope_optional::<DnssdCounters, D>(
13437 self.dnssd_counters
13438 .as_ref()
13439 .map(<DnssdCounters as fidl::encoding::ValueTypeMarker>::borrow),
13440 encoder,
13441 offset + cur_offset,
13442 depth,
13443 )?;
13444
13445 _prev_end_offset = cur_offset + envelope_size;
13446 if 17 > max_ordinal {
13447 return Ok(());
13448 }
13449
13450 let cur_offset: usize = (17 - 1) * envelope_size;
13453
13454 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13456
13457 fidl::encoding::encode_in_envelope_optional::<LeaderData, D>(
13462 self.leader_data
13463 .as_ref()
13464 .map(<LeaderData as fidl::encoding::ValueTypeMarker>::borrow),
13465 encoder,
13466 offset + cur_offset,
13467 depth,
13468 )?;
13469
13470 _prev_end_offset = cur_offset + envelope_size;
13471 if 18 > max_ordinal {
13472 return Ok(());
13473 }
13474
13475 let cur_offset: usize = (18 - 1) * envelope_size;
13478
13479 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13481
13482 fidl::encoding::encode_in_envelope_optional::<i64, D>(
13487 self.uptime.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
13488 encoder,
13489 offset + cur_offset,
13490 depth,
13491 )?;
13492
13493 _prev_end_offset = cur_offset + envelope_size;
13494 if 19 > max_ordinal {
13495 return Ok(());
13496 }
13497
13498 let cur_offset: usize = (19 - 1) * envelope_size;
13501
13502 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13504
13505 fidl::encoding::encode_in_envelope_optional::<Nat64Info, D>(
13510 self.nat64_info
13511 .as_ref()
13512 .map(<Nat64Info as fidl::encoding::ValueTypeMarker>::borrow),
13513 encoder,
13514 offset + cur_offset,
13515 depth,
13516 )?;
13517
13518 _prev_end_offset = cur_offset + envelope_size;
13519 if 20 > max_ordinal {
13520 return Ok(());
13521 }
13522
13523 let cur_offset: usize = (20 - 1) * envelope_size;
13526
13527 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13529
13530 fidl::encoding::encode_in_envelope_optional::<TrelCounters, D>(
13535 self.trel_counters
13536 .as_ref()
13537 .map(<TrelCounters as fidl::encoding::ValueTypeMarker>::borrow),
13538 encoder,
13539 offset + cur_offset,
13540 depth,
13541 )?;
13542
13543 _prev_end_offset = cur_offset + envelope_size;
13544 if 21 > max_ordinal {
13545 return Ok(());
13546 }
13547
13548 let cur_offset: usize = (21 - 1) * envelope_size;
13551
13552 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13554
13555 fidl::encoding::encode_in_envelope_optional::<TrelPeersInfo, D>(
13560 self.trel_peers_info
13561 .as_ref()
13562 .map(<TrelPeersInfo as fidl::encoding::ValueTypeMarker>::borrow),
13563 encoder,
13564 offset + cur_offset,
13565 depth,
13566 )?;
13567
13568 _prev_end_offset = cur_offset + envelope_size;
13569 if 22 > max_ordinal {
13570 return Ok(());
13571 }
13572
13573 let cur_offset: usize = (22 - 1) * envelope_size;
13576
13577 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13579
13580 fidl::encoding::encode_in_envelope_optional::<UpstreamDnsInfo, D>(
13585 self.upstream_dns_info
13586 .as_ref()
13587 .map(<UpstreamDnsInfo as fidl::encoding::ValueTypeMarker>::borrow),
13588 encoder,
13589 offset + cur_offset,
13590 depth,
13591 )?;
13592
13593 _prev_end_offset = cur_offset + envelope_size;
13594 if 23 > max_ordinal {
13595 return Ok(());
13596 }
13597
13598 let cur_offset: usize = (23 - 1) * envelope_size;
13601
13602 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13604
13605 fidl::encoding::encode_in_envelope_optional::<Dhcp6PdInfo, D>(
13610 self.dhcp6pd_info
13611 .as_ref()
13612 .map(<Dhcp6PdInfo as fidl::encoding::ValueTypeMarker>::borrow),
13613 encoder,
13614 offset + cur_offset,
13615 depth,
13616 )?;
13617
13618 _prev_end_offset = cur_offset + envelope_size;
13619 if 24 > max_ordinal {
13620 return Ok(());
13621 }
13622
13623 let cur_offset: usize = (24 - 1) * envelope_size;
13626
13627 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13629
13630 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<LinkMetricsEntry, 64>, D>(
13635 self.link_metrics_entries.as_ref().map(<fidl::encoding::Vector<LinkMetricsEntry, 64> as fidl::encoding::ValueTypeMarker>::borrow),
13636 encoder, offset + cur_offset, depth
13637 )?;
13638
13639 _prev_end_offset = cur_offset + envelope_size;
13640
13641 Ok(())
13642 }
13643 }
13644
13645 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Telemetry {
13646 #[inline(always)]
13647 fn new_empty() -> Self {
13648 Self::default()
13649 }
13650
13651 unsafe fn decode(
13652 &mut self,
13653 decoder: &mut fidl::encoding::Decoder<'_, D>,
13654 offset: usize,
13655 mut depth: fidl::encoding::Depth,
13656 ) -> fidl::Result<()> {
13657 decoder.debug_check_bounds::<Self>(offset);
13658 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13659 None => return Err(fidl::Error::NotNullable),
13660 Some(len) => len,
13661 };
13662 if len == 0 {
13664 return Ok(());
13665 };
13666 depth.increment()?;
13667 let envelope_size = 8;
13668 let bytes_len = len * envelope_size;
13669 let offset = decoder.out_of_line_offset(bytes_len)?;
13670 let mut _next_ordinal_to_read = 0;
13672 let mut next_offset = offset;
13673 let end_offset = offset + bytes_len;
13674 _next_ordinal_to_read += 1;
13675 if next_offset >= end_offset {
13676 return Ok(());
13677 }
13678
13679 while _next_ordinal_to_read < 1 {
13681 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13682 _next_ordinal_to_read += 1;
13683 next_offset += envelope_size;
13684 }
13685
13686 let next_out_of_line = decoder.next_out_of_line();
13687 let handles_before = decoder.remaining_handles();
13688 if let Some((inlined, num_bytes, num_handles)) =
13689 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13690 {
13691 let member_inline_size =
13692 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13693 if inlined != (member_inline_size <= 4) {
13694 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13695 }
13696 let inner_offset;
13697 let mut inner_depth = depth.clone();
13698 if inlined {
13699 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13700 inner_offset = next_offset;
13701 } else {
13702 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13703 inner_depth.increment()?;
13704 }
13705 let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
13706 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
13707 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13708 {
13709 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13710 }
13711 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13712 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13713 }
13714 }
13715
13716 next_offset += envelope_size;
13717 _next_ordinal_to_read += 1;
13718 if next_offset >= end_offset {
13719 return Ok(());
13720 }
13721
13722 while _next_ordinal_to_read < 2 {
13724 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13725 _next_ordinal_to_read += 1;
13726 next_offset += envelope_size;
13727 }
13728
13729 let next_out_of_line = decoder.next_out_of_line();
13730 let handles_before = decoder.remaining_handles();
13731 if let Some((inlined, num_bytes, num_handles)) =
13732 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13733 {
13734 let member_inline_size =
13735 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13736 if inlined != (member_inline_size <= 4) {
13737 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13738 }
13739 let inner_offset;
13740 let mut inner_depth = depth.clone();
13741 if inlined {
13742 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13743 inner_offset = next_offset;
13744 } else {
13745 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13746 inner_depth.increment()?;
13747 }
13748 let val_ref = self.tx_power.get_or_insert_with(|| fidl::new_empty!(i8, D));
13749 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
13750 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13751 {
13752 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13753 }
13754 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13755 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13756 }
13757 }
13758
13759 next_offset += envelope_size;
13760 _next_ordinal_to_read += 1;
13761 if next_offset >= end_offset {
13762 return Ok(());
13763 }
13764
13765 while _next_ordinal_to_read < 3 {
13767 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13768 _next_ordinal_to_read += 1;
13769 next_offset += envelope_size;
13770 }
13771
13772 let next_out_of_line = decoder.next_out_of_line();
13773 let handles_before = decoder.remaining_handles();
13774 if let Some((inlined, num_bytes, num_handles)) =
13775 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13776 {
13777 let member_inline_size =
13778 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13779 if inlined != (member_inline_size <= 4) {
13780 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13781 }
13782 let inner_offset;
13783 let mut inner_depth = depth.clone();
13784 if inlined {
13785 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13786 inner_offset = next_offset;
13787 } else {
13788 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13789 inner_depth.increment()?;
13790 }
13791 let val_ref = self.channel_index.get_or_insert_with(|| fidl::new_empty!(u16, D));
13792 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
13793 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13794 {
13795 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13796 }
13797 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13798 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13799 }
13800 }
13801
13802 next_offset += envelope_size;
13803 _next_ordinal_to_read += 1;
13804 if next_offset >= end_offset {
13805 return Ok(());
13806 }
13807
13808 while _next_ordinal_to_read < 4 {
13810 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13811 _next_ordinal_to_read += 1;
13812 next_offset += envelope_size;
13813 }
13814
13815 let next_out_of_line = decoder.next_out_of_line();
13816 let handles_before = decoder.remaining_handles();
13817 if let Some((inlined, num_bytes, num_handles)) =
13818 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13819 {
13820 let member_inline_size =
13821 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13822 if inlined != (member_inline_size <= 4) {
13823 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13824 }
13825 let inner_offset;
13826 let mut inner_depth = depth.clone();
13827 if inlined {
13828 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13829 inner_offset = next_offset;
13830 } else {
13831 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13832 inner_depth.increment()?;
13833 }
13834 let val_ref = self.partition_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
13835 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13836 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13837 {
13838 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13839 }
13840 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13841 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13842 }
13843 }
13844
13845 next_offset += envelope_size;
13846 _next_ordinal_to_read += 1;
13847 if next_offset >= end_offset {
13848 return Ok(());
13849 }
13850
13851 while _next_ordinal_to_read < 5 {
13853 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13854 _next_ordinal_to_read += 1;
13855 next_offset += envelope_size;
13856 }
13857
13858 let next_out_of_line = decoder.next_out_of_line();
13859 let handles_before = decoder.remaining_handles();
13860 if let Some((inlined, num_bytes, num_handles)) =
13861 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13862 {
13863 let member_inline_size =
13864 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
13865 decoder.context,
13866 );
13867 if inlined != (member_inline_size <= 4) {
13868 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13869 }
13870 let inner_offset;
13871 let mut inner_depth = depth.clone();
13872 if inlined {
13873 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13874 inner_offset = next_offset;
13875 } else {
13876 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13877 inner_depth.increment()?;
13878 }
13879 let val_ref = self
13880 .stack_version
13881 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
13882 fidl::decode!(
13883 fidl::encoding::BoundedString<256>,
13884 D,
13885 val_ref,
13886 decoder,
13887 inner_offset,
13888 inner_depth
13889 )?;
13890 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13891 {
13892 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13893 }
13894 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13895 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13896 }
13897 }
13898
13899 next_offset += envelope_size;
13900 _next_ordinal_to_read += 1;
13901 if next_offset >= end_offset {
13902 return Ok(());
13903 }
13904
13905 while _next_ordinal_to_read < 6 {
13907 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13908 _next_ordinal_to_read += 1;
13909 next_offset += envelope_size;
13910 }
13911
13912 let next_out_of_line = decoder.next_out_of_line();
13913 let handles_before = decoder.remaining_handles();
13914 if let Some((inlined, num_bytes, num_handles)) =
13915 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13916 {
13917 let member_inline_size =
13918 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
13919 decoder.context,
13920 );
13921 if inlined != (member_inline_size <= 4) {
13922 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13923 }
13924 let inner_offset;
13925 let mut inner_depth = depth.clone();
13926 if inlined {
13927 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13928 inner_offset = next_offset;
13929 } else {
13930 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13931 inner_depth.increment()?;
13932 }
13933 let val_ref = self
13934 .rcp_version
13935 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
13936 fidl::decode!(
13937 fidl::encoding::BoundedString<256>,
13938 D,
13939 val_ref,
13940 decoder,
13941 inner_offset,
13942 inner_depth
13943 )?;
13944 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13945 {
13946 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13947 }
13948 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13949 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13950 }
13951 }
13952
13953 next_offset += envelope_size;
13954 _next_ordinal_to_read += 1;
13955 if next_offset >= end_offset {
13956 return Ok(());
13957 }
13958
13959 while _next_ordinal_to_read < 7 {
13961 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13962 _next_ordinal_to_read += 1;
13963 next_offset += envelope_size;
13964 }
13965
13966 let next_out_of_line = decoder.next_out_of_line();
13967 let handles_before = decoder.remaining_handles();
13968 if let Some((inlined, num_bytes, num_handles)) =
13969 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13970 {
13971 let member_inline_size =
13972 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13973 if inlined != (member_inline_size <= 4) {
13974 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13975 }
13976 let inner_offset;
13977 let mut inner_depth = depth.clone();
13978 if inlined {
13979 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13980 inner_offset = next_offset;
13981 } else {
13982 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13983 inner_depth.increment()?;
13984 }
13985 let val_ref = self.thread_link_mode.get_or_insert_with(|| fidl::new_empty!(u8, D));
13986 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
13987 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13988 {
13989 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13990 }
13991 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13992 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13993 }
13994 }
13995
13996 next_offset += envelope_size;
13997 _next_ordinal_to_read += 1;
13998 if next_offset >= end_offset {
13999 return Ok(());
14000 }
14001
14002 while _next_ordinal_to_read < 8 {
14004 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14005 _next_ordinal_to_read += 1;
14006 next_offset += envelope_size;
14007 }
14008
14009 let next_out_of_line = decoder.next_out_of_line();
14010 let handles_before = decoder.remaining_handles();
14011 if let Some((inlined, num_bytes, num_handles)) =
14012 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14013 {
14014 let member_inline_size =
14015 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14016 if inlined != (member_inline_size <= 4) {
14017 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14018 }
14019 let inner_offset;
14020 let mut inner_depth = depth.clone();
14021 if inlined {
14022 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14023 inner_offset = next_offset;
14024 } else {
14025 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14026 inner_depth.increment()?;
14027 }
14028 let val_ref = self.thread_router_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
14029 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14030 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14031 {
14032 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14033 }
14034 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14035 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14036 }
14037 }
14038
14039 next_offset += envelope_size;
14040 _next_ordinal_to_read += 1;
14041 if next_offset >= end_offset {
14042 return Ok(());
14043 }
14044
14045 while _next_ordinal_to_read < 9 {
14047 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14048 _next_ordinal_to_read += 1;
14049 next_offset += envelope_size;
14050 }
14051
14052 let next_out_of_line = decoder.next_out_of_line();
14053 let handles_before = decoder.remaining_handles();
14054 if let Some((inlined, num_bytes, num_handles)) =
14055 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14056 {
14057 let member_inline_size =
14058 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14059 if inlined != (member_inline_size <= 4) {
14060 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14061 }
14062 let inner_offset;
14063 let mut inner_depth = depth.clone();
14064 if inlined {
14065 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14066 inner_offset = next_offset;
14067 } else {
14068 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14069 inner_depth.increment()?;
14070 }
14071 let val_ref = self.thread_rloc.get_or_insert_with(|| fidl::new_empty!(u16, D));
14072 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
14073 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14074 {
14075 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14076 }
14077 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14078 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14079 }
14080 }
14081
14082 next_offset += envelope_size;
14083 _next_ordinal_to_read += 1;
14084 if next_offset >= end_offset {
14085 return Ok(());
14086 }
14087
14088 while _next_ordinal_to_read < 10 {
14090 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14091 _next_ordinal_to_read += 1;
14092 next_offset += envelope_size;
14093 }
14094
14095 let next_out_of_line = decoder.next_out_of_line();
14096 let handles_before = decoder.remaining_handles();
14097 if let Some((inlined, num_bytes, num_handles)) =
14098 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14099 {
14100 let member_inline_size =
14101 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14102 if inlined != (member_inline_size <= 4) {
14103 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14104 }
14105 let inner_offset;
14106 let mut inner_depth = depth.clone();
14107 if inlined {
14108 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14109 inner_offset = next_offset;
14110 } else {
14111 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14112 inner_depth.increment()?;
14113 }
14114 let val_ref =
14115 self.thread_network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
14116 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14117 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14118 {
14119 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14120 }
14121 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14122 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14123 }
14124 }
14125
14126 next_offset += envelope_size;
14127 _next_ordinal_to_read += 1;
14128 if next_offset >= end_offset {
14129 return Ok(());
14130 }
14131
14132 while _next_ordinal_to_read < 11 {
14134 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14135 _next_ordinal_to_read += 1;
14136 next_offset += envelope_size;
14137 }
14138
14139 let next_out_of_line = decoder.next_out_of_line();
14140 let handles_before = decoder.remaining_handles();
14141 if let Some((inlined, num_bytes, num_handles)) =
14142 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14143 {
14144 let member_inline_size =
14145 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14146 if inlined != (member_inline_size <= 4) {
14147 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14148 }
14149 let inner_offset;
14150 let mut inner_depth = depth.clone();
14151 if inlined {
14152 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14153 inner_offset = next_offset;
14154 } else {
14155 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14156 inner_depth.increment()?;
14157 }
14158 let val_ref = self
14159 .thread_stable_network_data_version
14160 .get_or_insert_with(|| fidl::new_empty!(u8, D));
14161 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14162 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14163 {
14164 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14165 }
14166 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14167 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14168 }
14169 }
14170
14171 next_offset += envelope_size;
14172 _next_ordinal_to_read += 1;
14173 if next_offset >= end_offset {
14174 return Ok(());
14175 }
14176
14177 while _next_ordinal_to_read < 12 {
14179 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14180 _next_ordinal_to_read += 1;
14181 next_offset += envelope_size;
14182 }
14183
14184 let next_out_of_line = decoder.next_out_of_line();
14185 let handles_before = decoder.remaining_handles();
14186 if let Some((inlined, num_bytes, num_handles)) =
14187 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14188 {
14189 let member_inline_size =
14190 <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(
14191 decoder.context,
14192 );
14193 if inlined != (member_inline_size <= 4) {
14194 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14195 }
14196 let inner_offset;
14197 let mut inner_depth = depth.clone();
14198 if inlined {
14199 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14200 inner_offset = next_offset;
14201 } else {
14202 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14203 inner_depth.increment()?;
14204 }
14205 let val_ref = self
14206 .thread_network_data
14207 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D));
14208 fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
14209 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14210 {
14211 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14212 }
14213 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14214 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14215 }
14216 }
14217
14218 next_offset += envelope_size;
14219 _next_ordinal_to_read += 1;
14220 if next_offset >= end_offset {
14221 return Ok(());
14222 }
14223
14224 while _next_ordinal_to_read < 13 {
14226 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14227 _next_ordinal_to_read += 1;
14228 next_offset += envelope_size;
14229 }
14230
14231 let next_out_of_line = decoder.next_out_of_line();
14232 let handles_before = decoder.remaining_handles();
14233 if let Some((inlined, num_bytes, num_handles)) =
14234 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14235 {
14236 let member_inline_size =
14237 <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(
14238 decoder.context,
14239 );
14240 if inlined != (member_inline_size <= 4) {
14241 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14242 }
14243 let inner_offset;
14244 let mut inner_depth = depth.clone();
14245 if inlined {
14246 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14247 inner_offset = next_offset;
14248 } else {
14249 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14250 inner_depth.increment()?;
14251 }
14252 let val_ref = self
14253 .thread_stable_network_data
14254 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D));
14255 fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
14256 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14257 {
14258 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14259 }
14260 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14261 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14262 }
14263 }
14264
14265 next_offset += envelope_size;
14266 _next_ordinal_to_read += 1;
14267 if next_offset >= end_offset {
14268 return Ok(());
14269 }
14270
14271 while _next_ordinal_to_read < 14 {
14273 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14274 _next_ordinal_to_read += 1;
14275 next_offset += envelope_size;
14276 }
14277
14278 let next_out_of_line = decoder.next_out_of_line();
14279 let handles_before = decoder.remaining_handles();
14280 if let Some((inlined, num_bytes, num_handles)) =
14281 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14282 {
14283 let member_inline_size =
14284 <BorderRoutingCounters as fidl::encoding::TypeMarker>::inline_size(
14285 decoder.context,
14286 );
14287 if inlined != (member_inline_size <= 4) {
14288 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14289 }
14290 let inner_offset;
14291 let mut inner_depth = depth.clone();
14292 if inlined {
14293 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14294 inner_offset = next_offset;
14295 } else {
14296 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14297 inner_depth.increment()?;
14298 }
14299 let val_ref = self
14300 .thread_border_routing_counters
14301 .get_or_insert_with(|| fidl::new_empty!(BorderRoutingCounters, D));
14302 fidl::decode!(
14303 BorderRoutingCounters,
14304 D,
14305 val_ref,
14306 decoder,
14307 inner_offset,
14308 inner_depth
14309 )?;
14310 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14311 {
14312 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14313 }
14314 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14315 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14316 }
14317 }
14318
14319 next_offset += envelope_size;
14320 _next_ordinal_to_read += 1;
14321 if next_offset >= end_offset {
14322 return Ok(());
14323 }
14324
14325 while _next_ordinal_to_read < 15 {
14327 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14328 _next_ordinal_to_read += 1;
14329 next_offset += envelope_size;
14330 }
14331
14332 let next_out_of_line = decoder.next_out_of_line();
14333 let handles_before = decoder.remaining_handles();
14334 if let Some((inlined, num_bytes, num_handles)) =
14335 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14336 {
14337 let member_inline_size =
14338 <SrpServerInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14339 if inlined != (member_inline_size <= 4) {
14340 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14341 }
14342 let inner_offset;
14343 let mut inner_depth = depth.clone();
14344 if inlined {
14345 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14346 inner_offset = next_offset;
14347 } else {
14348 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14349 inner_depth.increment()?;
14350 }
14351 let val_ref =
14352 self.srp_server_info.get_or_insert_with(|| fidl::new_empty!(SrpServerInfo, D));
14353 fidl::decode!(SrpServerInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14354 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14355 {
14356 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14357 }
14358 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14359 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14360 }
14361 }
14362
14363 next_offset += envelope_size;
14364 _next_ordinal_to_read += 1;
14365 if next_offset >= end_offset {
14366 return Ok(());
14367 }
14368
14369 while _next_ordinal_to_read < 16 {
14371 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14372 _next_ordinal_to_read += 1;
14373 next_offset += envelope_size;
14374 }
14375
14376 let next_out_of_line = decoder.next_out_of_line();
14377 let handles_before = decoder.remaining_handles();
14378 if let Some((inlined, num_bytes, num_handles)) =
14379 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14380 {
14381 let member_inline_size =
14382 <DnssdCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14383 if inlined != (member_inline_size <= 4) {
14384 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14385 }
14386 let inner_offset;
14387 let mut inner_depth = depth.clone();
14388 if inlined {
14389 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14390 inner_offset = next_offset;
14391 } else {
14392 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14393 inner_depth.increment()?;
14394 }
14395 let val_ref =
14396 self.dnssd_counters.get_or_insert_with(|| fidl::new_empty!(DnssdCounters, D));
14397 fidl::decode!(DnssdCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
14398 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14399 {
14400 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14401 }
14402 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14403 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14404 }
14405 }
14406
14407 next_offset += envelope_size;
14408 _next_ordinal_to_read += 1;
14409 if next_offset >= end_offset {
14410 return Ok(());
14411 }
14412
14413 while _next_ordinal_to_read < 17 {
14415 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14416 _next_ordinal_to_read += 1;
14417 next_offset += envelope_size;
14418 }
14419
14420 let next_out_of_line = decoder.next_out_of_line();
14421 let handles_before = decoder.remaining_handles();
14422 if let Some((inlined, num_bytes, num_handles)) =
14423 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14424 {
14425 let member_inline_size =
14426 <LeaderData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14427 if inlined != (member_inline_size <= 4) {
14428 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14429 }
14430 let inner_offset;
14431 let mut inner_depth = depth.clone();
14432 if inlined {
14433 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14434 inner_offset = next_offset;
14435 } else {
14436 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14437 inner_depth.increment()?;
14438 }
14439 let val_ref =
14440 self.leader_data.get_or_insert_with(|| fidl::new_empty!(LeaderData, D));
14441 fidl::decode!(LeaderData, D, val_ref, decoder, inner_offset, inner_depth)?;
14442 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14443 {
14444 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14445 }
14446 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14447 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14448 }
14449 }
14450
14451 next_offset += envelope_size;
14452 _next_ordinal_to_read += 1;
14453 if next_offset >= end_offset {
14454 return Ok(());
14455 }
14456
14457 while _next_ordinal_to_read < 18 {
14459 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14460 _next_ordinal_to_read += 1;
14461 next_offset += envelope_size;
14462 }
14463
14464 let next_out_of_line = decoder.next_out_of_line();
14465 let handles_before = decoder.remaining_handles();
14466 if let Some((inlined, num_bytes, num_handles)) =
14467 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14468 {
14469 let member_inline_size =
14470 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14471 if inlined != (member_inline_size <= 4) {
14472 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14473 }
14474 let inner_offset;
14475 let mut inner_depth = depth.clone();
14476 if inlined {
14477 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14478 inner_offset = next_offset;
14479 } else {
14480 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14481 inner_depth.increment()?;
14482 }
14483 let val_ref = self.uptime.get_or_insert_with(|| fidl::new_empty!(i64, D));
14484 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
14485 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14486 {
14487 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14488 }
14489 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14490 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14491 }
14492 }
14493
14494 next_offset += envelope_size;
14495 _next_ordinal_to_read += 1;
14496 if next_offset >= end_offset {
14497 return Ok(());
14498 }
14499
14500 while _next_ordinal_to_read < 19 {
14502 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14503 _next_ordinal_to_read += 1;
14504 next_offset += envelope_size;
14505 }
14506
14507 let next_out_of_line = decoder.next_out_of_line();
14508 let handles_before = decoder.remaining_handles();
14509 if let Some((inlined, num_bytes, num_handles)) =
14510 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14511 {
14512 let member_inline_size =
14513 <Nat64Info as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14514 if inlined != (member_inline_size <= 4) {
14515 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14516 }
14517 let inner_offset;
14518 let mut inner_depth = depth.clone();
14519 if inlined {
14520 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14521 inner_offset = next_offset;
14522 } else {
14523 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14524 inner_depth.increment()?;
14525 }
14526 let val_ref = self.nat64_info.get_or_insert_with(|| fidl::new_empty!(Nat64Info, D));
14527 fidl::decode!(Nat64Info, D, val_ref, decoder, inner_offset, inner_depth)?;
14528 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14529 {
14530 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14531 }
14532 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14533 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14534 }
14535 }
14536
14537 next_offset += envelope_size;
14538 _next_ordinal_to_read += 1;
14539 if next_offset >= end_offset {
14540 return Ok(());
14541 }
14542
14543 while _next_ordinal_to_read < 20 {
14545 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14546 _next_ordinal_to_read += 1;
14547 next_offset += envelope_size;
14548 }
14549
14550 let next_out_of_line = decoder.next_out_of_line();
14551 let handles_before = decoder.remaining_handles();
14552 if let Some((inlined, num_bytes, num_handles)) =
14553 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14554 {
14555 let member_inline_size =
14556 <TrelCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14557 if inlined != (member_inline_size <= 4) {
14558 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14559 }
14560 let inner_offset;
14561 let mut inner_depth = depth.clone();
14562 if inlined {
14563 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14564 inner_offset = next_offset;
14565 } else {
14566 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14567 inner_depth.increment()?;
14568 }
14569 let val_ref =
14570 self.trel_counters.get_or_insert_with(|| fidl::new_empty!(TrelCounters, D));
14571 fidl::decode!(TrelCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
14572 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14573 {
14574 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14575 }
14576 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14577 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14578 }
14579 }
14580
14581 next_offset += envelope_size;
14582 _next_ordinal_to_read += 1;
14583 if next_offset >= end_offset {
14584 return Ok(());
14585 }
14586
14587 while _next_ordinal_to_read < 21 {
14589 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14590 _next_ordinal_to_read += 1;
14591 next_offset += envelope_size;
14592 }
14593
14594 let next_out_of_line = decoder.next_out_of_line();
14595 let handles_before = decoder.remaining_handles();
14596 if let Some((inlined, num_bytes, num_handles)) =
14597 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14598 {
14599 let member_inline_size =
14600 <TrelPeersInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14601 if inlined != (member_inline_size <= 4) {
14602 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14603 }
14604 let inner_offset;
14605 let mut inner_depth = depth.clone();
14606 if inlined {
14607 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14608 inner_offset = next_offset;
14609 } else {
14610 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14611 inner_depth.increment()?;
14612 }
14613 let val_ref =
14614 self.trel_peers_info.get_or_insert_with(|| fidl::new_empty!(TrelPeersInfo, D));
14615 fidl::decode!(TrelPeersInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14616 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14617 {
14618 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14619 }
14620 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14621 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14622 }
14623 }
14624
14625 next_offset += envelope_size;
14626 _next_ordinal_to_read += 1;
14627 if next_offset >= end_offset {
14628 return Ok(());
14629 }
14630
14631 while _next_ordinal_to_read < 22 {
14633 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14634 _next_ordinal_to_read += 1;
14635 next_offset += envelope_size;
14636 }
14637
14638 let next_out_of_line = decoder.next_out_of_line();
14639 let handles_before = decoder.remaining_handles();
14640 if let Some((inlined, num_bytes, num_handles)) =
14641 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14642 {
14643 let member_inline_size =
14644 <UpstreamDnsInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14645 if inlined != (member_inline_size <= 4) {
14646 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14647 }
14648 let inner_offset;
14649 let mut inner_depth = depth.clone();
14650 if inlined {
14651 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14652 inner_offset = next_offset;
14653 } else {
14654 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14655 inner_depth.increment()?;
14656 }
14657 let val_ref = self
14658 .upstream_dns_info
14659 .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsInfo, D));
14660 fidl::decode!(UpstreamDnsInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14661 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14662 {
14663 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14664 }
14665 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14666 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14667 }
14668 }
14669
14670 next_offset += envelope_size;
14671 _next_ordinal_to_read += 1;
14672 if next_offset >= end_offset {
14673 return Ok(());
14674 }
14675
14676 while _next_ordinal_to_read < 23 {
14678 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14679 _next_ordinal_to_read += 1;
14680 next_offset += envelope_size;
14681 }
14682
14683 let next_out_of_line = decoder.next_out_of_line();
14684 let handles_before = decoder.remaining_handles();
14685 if let Some((inlined, num_bytes, num_handles)) =
14686 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14687 {
14688 let member_inline_size =
14689 <Dhcp6PdInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14690 if inlined != (member_inline_size <= 4) {
14691 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14692 }
14693 let inner_offset;
14694 let mut inner_depth = depth.clone();
14695 if inlined {
14696 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14697 inner_offset = next_offset;
14698 } else {
14699 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14700 inner_depth.increment()?;
14701 }
14702 let val_ref =
14703 self.dhcp6pd_info.get_or_insert_with(|| fidl::new_empty!(Dhcp6PdInfo, D));
14704 fidl::decode!(Dhcp6PdInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14705 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14706 {
14707 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14708 }
14709 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14710 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14711 }
14712 }
14713
14714 next_offset += envelope_size;
14715 _next_ordinal_to_read += 1;
14716 if next_offset >= end_offset {
14717 return Ok(());
14718 }
14719
14720 while _next_ordinal_to_read < 24 {
14722 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14723 _next_ordinal_to_read += 1;
14724 next_offset += envelope_size;
14725 }
14726
14727 let next_out_of_line = decoder.next_out_of_line();
14728 let handles_before = decoder.remaining_handles();
14729 if let Some((inlined, num_bytes, num_handles)) =
14730 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14731 {
14732 let member_inline_size = <fidl::encoding::Vector<LinkMetricsEntry, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14733 if inlined != (member_inline_size <= 4) {
14734 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14735 }
14736 let inner_offset;
14737 let mut inner_depth = depth.clone();
14738 if inlined {
14739 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14740 inner_offset = next_offset;
14741 } else {
14742 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14743 inner_depth.increment()?;
14744 }
14745 let val_ref = self.link_metrics_entries.get_or_insert_with(
14746 || fidl::new_empty!(fidl::encoding::Vector<LinkMetricsEntry, 64>, D),
14747 );
14748 fidl::decode!(fidl::encoding::Vector<LinkMetricsEntry, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
14749 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14750 {
14751 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14752 }
14753 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14754 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14755 }
14756 }
14757
14758 next_offset += envelope_size;
14759
14760 while next_offset < end_offset {
14762 _next_ordinal_to_read += 1;
14763 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14764 next_offset += envelope_size;
14765 }
14766
14767 Ok(())
14768 }
14769 }
14770
14771 impl TrelCounters {
14772 #[inline(always)]
14773 fn max_ordinal_present(&self) -> u64 {
14774 if let Some(_) = self.tx_packets {
14775 return 5;
14776 }
14777 if let Some(_) = self.tx_failure {
14778 return 4;
14779 }
14780 if let Some(_) = self.tx_bytes {
14781 return 3;
14782 }
14783 if let Some(_) = self.rx_packets {
14784 return 2;
14785 }
14786 if let Some(_) = self.rx_bytes {
14787 return 1;
14788 }
14789 0
14790 }
14791 }
14792
14793 impl fidl::encoding::ValueTypeMarker for TrelCounters {
14794 type Borrowed<'a> = &'a Self;
14795 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14796 value
14797 }
14798 }
14799
14800 unsafe impl fidl::encoding::TypeMarker for TrelCounters {
14801 type Owned = Self;
14802
14803 #[inline(always)]
14804 fn inline_align(_context: fidl::encoding::Context) -> usize {
14805 8
14806 }
14807
14808 #[inline(always)]
14809 fn inline_size(_context: fidl::encoding::Context) -> usize {
14810 16
14811 }
14812 }
14813
14814 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TrelCounters, D>
14815 for &TrelCounters
14816 {
14817 unsafe fn encode(
14818 self,
14819 encoder: &mut fidl::encoding::Encoder<'_, D>,
14820 offset: usize,
14821 mut depth: fidl::encoding::Depth,
14822 ) -> fidl::Result<()> {
14823 encoder.debug_check_bounds::<TrelCounters>(offset);
14824 let max_ordinal: u64 = self.max_ordinal_present();
14826 encoder.write_num(max_ordinal, offset);
14827 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14828 if max_ordinal == 0 {
14830 return Ok(());
14831 }
14832 depth.increment()?;
14833 let envelope_size = 8;
14834 let bytes_len = max_ordinal as usize * envelope_size;
14835 #[allow(unused_variables)]
14836 let offset = encoder.out_of_line_offset(bytes_len);
14837 let mut _prev_end_offset: usize = 0;
14838 if 1 > max_ordinal {
14839 return Ok(());
14840 }
14841
14842 let cur_offset: usize = (1 - 1) * envelope_size;
14845
14846 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14848
14849 fidl::encoding::encode_in_envelope_optional::<u64, D>(
14854 self.rx_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14855 encoder,
14856 offset + cur_offset,
14857 depth,
14858 )?;
14859
14860 _prev_end_offset = cur_offset + envelope_size;
14861 if 2 > max_ordinal {
14862 return Ok(());
14863 }
14864
14865 let cur_offset: usize = (2 - 1) * envelope_size;
14868
14869 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14871
14872 fidl::encoding::encode_in_envelope_optional::<u64, D>(
14877 self.rx_packets.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14878 encoder,
14879 offset + cur_offset,
14880 depth,
14881 )?;
14882
14883 _prev_end_offset = cur_offset + envelope_size;
14884 if 3 > max_ordinal {
14885 return Ok(());
14886 }
14887
14888 let cur_offset: usize = (3 - 1) * envelope_size;
14891
14892 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14894
14895 fidl::encoding::encode_in_envelope_optional::<u64, D>(
14900 self.tx_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14901 encoder,
14902 offset + cur_offset,
14903 depth,
14904 )?;
14905
14906 _prev_end_offset = cur_offset + envelope_size;
14907 if 4 > max_ordinal {
14908 return Ok(());
14909 }
14910
14911 let cur_offset: usize = (4 - 1) * envelope_size;
14914
14915 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14917
14918 fidl::encoding::encode_in_envelope_optional::<u64, D>(
14923 self.tx_failure.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14924 encoder,
14925 offset + cur_offset,
14926 depth,
14927 )?;
14928
14929 _prev_end_offset = cur_offset + envelope_size;
14930 if 5 > max_ordinal {
14931 return Ok(());
14932 }
14933
14934 let cur_offset: usize = (5 - 1) * envelope_size;
14937
14938 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14940
14941 fidl::encoding::encode_in_envelope_optional::<u64, D>(
14946 self.tx_packets.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14947 encoder,
14948 offset + cur_offset,
14949 depth,
14950 )?;
14951
14952 _prev_end_offset = cur_offset + envelope_size;
14953
14954 Ok(())
14955 }
14956 }
14957
14958 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TrelCounters {
14959 #[inline(always)]
14960 fn new_empty() -> Self {
14961 Self::default()
14962 }
14963
14964 unsafe fn decode(
14965 &mut self,
14966 decoder: &mut fidl::encoding::Decoder<'_, D>,
14967 offset: usize,
14968 mut depth: fidl::encoding::Depth,
14969 ) -> fidl::Result<()> {
14970 decoder.debug_check_bounds::<Self>(offset);
14971 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14972 None => return Err(fidl::Error::NotNullable),
14973 Some(len) => len,
14974 };
14975 if len == 0 {
14977 return Ok(());
14978 };
14979 depth.increment()?;
14980 let envelope_size = 8;
14981 let bytes_len = len * envelope_size;
14982 let offset = decoder.out_of_line_offset(bytes_len)?;
14983 let mut _next_ordinal_to_read = 0;
14985 let mut next_offset = offset;
14986 let end_offset = offset + bytes_len;
14987 _next_ordinal_to_read += 1;
14988 if next_offset >= end_offset {
14989 return Ok(());
14990 }
14991
14992 while _next_ordinal_to_read < 1 {
14994 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14995 _next_ordinal_to_read += 1;
14996 next_offset += envelope_size;
14997 }
14998
14999 let next_out_of_line = decoder.next_out_of_line();
15000 let handles_before = decoder.remaining_handles();
15001 if let Some((inlined, num_bytes, num_handles)) =
15002 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15003 {
15004 let member_inline_size =
15005 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15006 if inlined != (member_inline_size <= 4) {
15007 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15008 }
15009 let inner_offset;
15010 let mut inner_depth = depth.clone();
15011 if inlined {
15012 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15013 inner_offset = next_offset;
15014 } else {
15015 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15016 inner_depth.increment()?;
15017 }
15018 let val_ref = self.rx_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
15019 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15020 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15021 {
15022 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15023 }
15024 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15025 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15026 }
15027 }
15028
15029 next_offset += envelope_size;
15030 _next_ordinal_to_read += 1;
15031 if next_offset >= end_offset {
15032 return Ok(());
15033 }
15034
15035 while _next_ordinal_to_read < 2 {
15037 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15038 _next_ordinal_to_read += 1;
15039 next_offset += envelope_size;
15040 }
15041
15042 let next_out_of_line = decoder.next_out_of_line();
15043 let handles_before = decoder.remaining_handles();
15044 if let Some((inlined, num_bytes, num_handles)) =
15045 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15046 {
15047 let member_inline_size =
15048 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15049 if inlined != (member_inline_size <= 4) {
15050 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15051 }
15052 let inner_offset;
15053 let mut inner_depth = depth.clone();
15054 if inlined {
15055 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15056 inner_offset = next_offset;
15057 } else {
15058 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15059 inner_depth.increment()?;
15060 }
15061 let val_ref = self.rx_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
15062 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15063 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15064 {
15065 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15066 }
15067 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15068 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15069 }
15070 }
15071
15072 next_offset += envelope_size;
15073 _next_ordinal_to_read += 1;
15074 if next_offset >= end_offset {
15075 return Ok(());
15076 }
15077
15078 while _next_ordinal_to_read < 3 {
15080 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15081 _next_ordinal_to_read += 1;
15082 next_offset += envelope_size;
15083 }
15084
15085 let next_out_of_line = decoder.next_out_of_line();
15086 let handles_before = decoder.remaining_handles();
15087 if let Some((inlined, num_bytes, num_handles)) =
15088 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15089 {
15090 let member_inline_size =
15091 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15092 if inlined != (member_inline_size <= 4) {
15093 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15094 }
15095 let inner_offset;
15096 let mut inner_depth = depth.clone();
15097 if inlined {
15098 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15099 inner_offset = next_offset;
15100 } else {
15101 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15102 inner_depth.increment()?;
15103 }
15104 let val_ref = self.tx_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
15105 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15106 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15107 {
15108 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15109 }
15110 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15111 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15112 }
15113 }
15114
15115 next_offset += envelope_size;
15116 _next_ordinal_to_read += 1;
15117 if next_offset >= end_offset {
15118 return Ok(());
15119 }
15120
15121 while _next_ordinal_to_read < 4 {
15123 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15124 _next_ordinal_to_read += 1;
15125 next_offset += envelope_size;
15126 }
15127
15128 let next_out_of_line = decoder.next_out_of_line();
15129 let handles_before = decoder.remaining_handles();
15130 if let Some((inlined, num_bytes, num_handles)) =
15131 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15132 {
15133 let member_inline_size =
15134 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15135 if inlined != (member_inline_size <= 4) {
15136 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15137 }
15138 let inner_offset;
15139 let mut inner_depth = depth.clone();
15140 if inlined {
15141 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15142 inner_offset = next_offset;
15143 } else {
15144 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15145 inner_depth.increment()?;
15146 }
15147 let val_ref = self.tx_failure.get_or_insert_with(|| fidl::new_empty!(u64, D));
15148 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15149 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15150 {
15151 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15152 }
15153 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15154 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15155 }
15156 }
15157
15158 next_offset += envelope_size;
15159 _next_ordinal_to_read += 1;
15160 if next_offset >= end_offset {
15161 return Ok(());
15162 }
15163
15164 while _next_ordinal_to_read < 5 {
15166 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15167 _next_ordinal_to_read += 1;
15168 next_offset += envelope_size;
15169 }
15170
15171 let next_out_of_line = decoder.next_out_of_line();
15172 let handles_before = decoder.remaining_handles();
15173 if let Some((inlined, num_bytes, num_handles)) =
15174 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15175 {
15176 let member_inline_size =
15177 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15178 if inlined != (member_inline_size <= 4) {
15179 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15180 }
15181 let inner_offset;
15182 let mut inner_depth = depth.clone();
15183 if inlined {
15184 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15185 inner_offset = next_offset;
15186 } else {
15187 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15188 inner_depth.increment()?;
15189 }
15190 let val_ref = self.tx_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
15191 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15192 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15193 {
15194 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15195 }
15196 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15197 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15198 }
15199 }
15200
15201 next_offset += envelope_size;
15202
15203 while next_offset < end_offset {
15205 _next_ordinal_to_read += 1;
15206 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15207 next_offset += envelope_size;
15208 }
15209
15210 Ok(())
15211 }
15212 }
15213
15214 impl TrelPeersInfo {
15215 #[inline(always)]
15216 fn max_ordinal_present(&self) -> u64 {
15217 if let Some(_) = self.num_trel_peers {
15218 return 1;
15219 }
15220 0
15221 }
15222 }
15223
15224 impl fidl::encoding::ValueTypeMarker for TrelPeersInfo {
15225 type Borrowed<'a> = &'a Self;
15226 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15227 value
15228 }
15229 }
15230
15231 unsafe impl fidl::encoding::TypeMarker for TrelPeersInfo {
15232 type Owned = Self;
15233
15234 #[inline(always)]
15235 fn inline_align(_context: fidl::encoding::Context) -> usize {
15236 8
15237 }
15238
15239 #[inline(always)]
15240 fn inline_size(_context: fidl::encoding::Context) -> usize {
15241 16
15242 }
15243 }
15244
15245 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TrelPeersInfo, D>
15246 for &TrelPeersInfo
15247 {
15248 unsafe fn encode(
15249 self,
15250 encoder: &mut fidl::encoding::Encoder<'_, D>,
15251 offset: usize,
15252 mut depth: fidl::encoding::Depth,
15253 ) -> fidl::Result<()> {
15254 encoder.debug_check_bounds::<TrelPeersInfo>(offset);
15255 let max_ordinal: u64 = self.max_ordinal_present();
15257 encoder.write_num(max_ordinal, offset);
15258 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15259 if max_ordinal == 0 {
15261 return Ok(());
15262 }
15263 depth.increment()?;
15264 let envelope_size = 8;
15265 let bytes_len = max_ordinal as usize * envelope_size;
15266 #[allow(unused_variables)]
15267 let offset = encoder.out_of_line_offset(bytes_len);
15268 let mut _prev_end_offset: usize = 0;
15269 if 1 > max_ordinal {
15270 return Ok(());
15271 }
15272
15273 let cur_offset: usize = (1 - 1) * envelope_size;
15276
15277 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15279
15280 fidl::encoding::encode_in_envelope_optional::<u16, D>(
15285 self.num_trel_peers.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
15286 encoder,
15287 offset + cur_offset,
15288 depth,
15289 )?;
15290
15291 _prev_end_offset = cur_offset + envelope_size;
15292
15293 Ok(())
15294 }
15295 }
15296
15297 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TrelPeersInfo {
15298 #[inline(always)]
15299 fn new_empty() -> Self {
15300 Self::default()
15301 }
15302
15303 unsafe fn decode(
15304 &mut self,
15305 decoder: &mut fidl::encoding::Decoder<'_, D>,
15306 offset: usize,
15307 mut depth: fidl::encoding::Depth,
15308 ) -> fidl::Result<()> {
15309 decoder.debug_check_bounds::<Self>(offset);
15310 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15311 None => return Err(fidl::Error::NotNullable),
15312 Some(len) => len,
15313 };
15314 if len == 0 {
15316 return Ok(());
15317 };
15318 depth.increment()?;
15319 let envelope_size = 8;
15320 let bytes_len = len * envelope_size;
15321 let offset = decoder.out_of_line_offset(bytes_len)?;
15322 let mut _next_ordinal_to_read = 0;
15324 let mut next_offset = offset;
15325 let end_offset = offset + bytes_len;
15326 _next_ordinal_to_read += 1;
15327 if next_offset >= end_offset {
15328 return Ok(());
15329 }
15330
15331 while _next_ordinal_to_read < 1 {
15333 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15334 _next_ordinal_to_read += 1;
15335 next_offset += envelope_size;
15336 }
15337
15338 let next_out_of_line = decoder.next_out_of_line();
15339 let handles_before = decoder.remaining_handles();
15340 if let Some((inlined, num_bytes, num_handles)) =
15341 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15342 {
15343 let member_inline_size =
15344 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15345 if inlined != (member_inline_size <= 4) {
15346 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15347 }
15348 let inner_offset;
15349 let mut inner_depth = depth.clone();
15350 if inlined {
15351 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15352 inner_offset = next_offset;
15353 } else {
15354 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15355 inner_depth.increment()?;
15356 }
15357 let val_ref = self.num_trel_peers.get_or_insert_with(|| fidl::new_empty!(u16, D));
15358 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
15359 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15360 {
15361 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15362 }
15363 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15364 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15365 }
15366 }
15367
15368 next_offset += envelope_size;
15369
15370 while next_offset < end_offset {
15372 _next_ordinal_to_read += 1;
15373 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15374 next_offset += envelope_size;
15375 }
15376
15377 Ok(())
15378 }
15379 }
15380
15381 impl UpstreamDnsCounters {
15382 #[inline(always)]
15383 fn max_ordinal_present(&self) -> u64 {
15384 if let Some(_) = self.failures {
15385 return 3;
15386 }
15387 if let Some(_) = self.responses {
15388 return 2;
15389 }
15390 if let Some(_) = self.queries {
15391 return 1;
15392 }
15393 0
15394 }
15395 }
15396
15397 impl fidl::encoding::ValueTypeMarker for UpstreamDnsCounters {
15398 type Borrowed<'a> = &'a Self;
15399 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15400 value
15401 }
15402 }
15403
15404 unsafe impl fidl::encoding::TypeMarker for UpstreamDnsCounters {
15405 type Owned = Self;
15406
15407 #[inline(always)]
15408 fn inline_align(_context: fidl::encoding::Context) -> usize {
15409 8
15410 }
15411
15412 #[inline(always)]
15413 fn inline_size(_context: fidl::encoding::Context) -> usize {
15414 16
15415 }
15416 }
15417
15418 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UpstreamDnsCounters, D>
15419 for &UpstreamDnsCounters
15420 {
15421 unsafe fn encode(
15422 self,
15423 encoder: &mut fidl::encoding::Encoder<'_, D>,
15424 offset: usize,
15425 mut depth: fidl::encoding::Depth,
15426 ) -> fidl::Result<()> {
15427 encoder.debug_check_bounds::<UpstreamDnsCounters>(offset);
15428 let max_ordinal: u64 = self.max_ordinal_present();
15430 encoder.write_num(max_ordinal, offset);
15431 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15432 if max_ordinal == 0 {
15434 return Ok(());
15435 }
15436 depth.increment()?;
15437 let envelope_size = 8;
15438 let bytes_len = max_ordinal as usize * envelope_size;
15439 #[allow(unused_variables)]
15440 let offset = encoder.out_of_line_offset(bytes_len);
15441 let mut _prev_end_offset: usize = 0;
15442 if 1 > max_ordinal {
15443 return Ok(());
15444 }
15445
15446 let cur_offset: usize = (1 - 1) * envelope_size;
15449
15450 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15452
15453 fidl::encoding::encode_in_envelope_optional::<u32, D>(
15458 self.queries.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15459 encoder,
15460 offset + cur_offset,
15461 depth,
15462 )?;
15463
15464 _prev_end_offset = cur_offset + envelope_size;
15465 if 2 > max_ordinal {
15466 return Ok(());
15467 }
15468
15469 let cur_offset: usize = (2 - 1) * envelope_size;
15472
15473 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15475
15476 fidl::encoding::encode_in_envelope_optional::<u32, D>(
15481 self.responses.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15482 encoder,
15483 offset + cur_offset,
15484 depth,
15485 )?;
15486
15487 _prev_end_offset = cur_offset + envelope_size;
15488 if 3 > max_ordinal {
15489 return Ok(());
15490 }
15491
15492 let cur_offset: usize = (3 - 1) * envelope_size;
15495
15496 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15498
15499 fidl::encoding::encode_in_envelope_optional::<u32, D>(
15504 self.failures.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15505 encoder,
15506 offset + cur_offset,
15507 depth,
15508 )?;
15509
15510 _prev_end_offset = cur_offset + envelope_size;
15511
15512 Ok(())
15513 }
15514 }
15515
15516 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsCounters {
15517 #[inline(always)]
15518 fn new_empty() -> Self {
15519 Self::default()
15520 }
15521
15522 unsafe fn decode(
15523 &mut self,
15524 decoder: &mut fidl::encoding::Decoder<'_, D>,
15525 offset: usize,
15526 mut depth: fidl::encoding::Depth,
15527 ) -> fidl::Result<()> {
15528 decoder.debug_check_bounds::<Self>(offset);
15529 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15530 None => return Err(fidl::Error::NotNullable),
15531 Some(len) => len,
15532 };
15533 if len == 0 {
15535 return Ok(());
15536 };
15537 depth.increment()?;
15538 let envelope_size = 8;
15539 let bytes_len = len * envelope_size;
15540 let offset = decoder.out_of_line_offset(bytes_len)?;
15541 let mut _next_ordinal_to_read = 0;
15543 let mut next_offset = offset;
15544 let end_offset = offset + bytes_len;
15545 _next_ordinal_to_read += 1;
15546 if next_offset >= end_offset {
15547 return Ok(());
15548 }
15549
15550 while _next_ordinal_to_read < 1 {
15552 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15553 _next_ordinal_to_read += 1;
15554 next_offset += envelope_size;
15555 }
15556
15557 let next_out_of_line = decoder.next_out_of_line();
15558 let handles_before = decoder.remaining_handles();
15559 if let Some((inlined, num_bytes, num_handles)) =
15560 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15561 {
15562 let member_inline_size =
15563 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15564 if inlined != (member_inline_size <= 4) {
15565 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15566 }
15567 let inner_offset;
15568 let mut inner_depth = depth.clone();
15569 if inlined {
15570 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15571 inner_offset = next_offset;
15572 } else {
15573 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15574 inner_depth.increment()?;
15575 }
15576 let val_ref = self.queries.get_or_insert_with(|| fidl::new_empty!(u32, D));
15577 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15578 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15579 {
15580 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15581 }
15582 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15583 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15584 }
15585 }
15586
15587 next_offset += envelope_size;
15588 _next_ordinal_to_read += 1;
15589 if next_offset >= end_offset {
15590 return Ok(());
15591 }
15592
15593 while _next_ordinal_to_read < 2 {
15595 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15596 _next_ordinal_to_read += 1;
15597 next_offset += envelope_size;
15598 }
15599
15600 let next_out_of_line = decoder.next_out_of_line();
15601 let handles_before = decoder.remaining_handles();
15602 if let Some((inlined, num_bytes, num_handles)) =
15603 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15604 {
15605 let member_inline_size =
15606 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15607 if inlined != (member_inline_size <= 4) {
15608 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15609 }
15610 let inner_offset;
15611 let mut inner_depth = depth.clone();
15612 if inlined {
15613 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15614 inner_offset = next_offset;
15615 } else {
15616 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15617 inner_depth.increment()?;
15618 }
15619 let val_ref = self.responses.get_or_insert_with(|| fidl::new_empty!(u32, D));
15620 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15621 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15622 {
15623 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15624 }
15625 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15626 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15627 }
15628 }
15629
15630 next_offset += envelope_size;
15631 _next_ordinal_to_read += 1;
15632 if next_offset >= end_offset {
15633 return Ok(());
15634 }
15635
15636 while _next_ordinal_to_read < 3 {
15638 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15639 _next_ordinal_to_read += 1;
15640 next_offset += envelope_size;
15641 }
15642
15643 let next_out_of_line = decoder.next_out_of_line();
15644 let handles_before = decoder.remaining_handles();
15645 if let Some((inlined, num_bytes, num_handles)) =
15646 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15647 {
15648 let member_inline_size =
15649 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15650 if inlined != (member_inline_size <= 4) {
15651 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15652 }
15653 let inner_offset;
15654 let mut inner_depth = depth.clone();
15655 if inlined {
15656 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15657 inner_offset = next_offset;
15658 } else {
15659 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15660 inner_depth.increment()?;
15661 }
15662 let val_ref = self.failures.get_or_insert_with(|| fidl::new_empty!(u32, D));
15663 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15664 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15665 {
15666 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15667 }
15668 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15669 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15670 }
15671 }
15672
15673 next_offset += envelope_size;
15674
15675 while next_offset < end_offset {
15677 _next_ordinal_to_read += 1;
15678 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15679 next_offset += envelope_size;
15680 }
15681
15682 Ok(())
15683 }
15684 }
15685
15686 impl UpstreamDnsInfo {
15687 #[inline(always)]
15688 fn max_ordinal_present(&self) -> u64 {
15689 if let Some(_) = self.upstream_dns_query_state {
15690 return 1;
15691 }
15692 0
15693 }
15694 }
15695
15696 impl fidl::encoding::ValueTypeMarker for UpstreamDnsInfo {
15697 type Borrowed<'a> = &'a Self;
15698 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15699 value
15700 }
15701 }
15702
15703 unsafe impl fidl::encoding::TypeMarker for UpstreamDnsInfo {
15704 type Owned = Self;
15705
15706 #[inline(always)]
15707 fn inline_align(_context: fidl::encoding::Context) -> usize {
15708 8
15709 }
15710
15711 #[inline(always)]
15712 fn inline_size(_context: fidl::encoding::Context) -> usize {
15713 16
15714 }
15715 }
15716
15717 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UpstreamDnsInfo, D>
15718 for &UpstreamDnsInfo
15719 {
15720 unsafe fn encode(
15721 self,
15722 encoder: &mut fidl::encoding::Encoder<'_, D>,
15723 offset: usize,
15724 mut depth: fidl::encoding::Depth,
15725 ) -> fidl::Result<()> {
15726 encoder.debug_check_bounds::<UpstreamDnsInfo>(offset);
15727 let max_ordinal: u64 = self.max_ordinal_present();
15729 encoder.write_num(max_ordinal, offset);
15730 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15731 if max_ordinal == 0 {
15733 return Ok(());
15734 }
15735 depth.increment()?;
15736 let envelope_size = 8;
15737 let bytes_len = max_ordinal as usize * envelope_size;
15738 #[allow(unused_variables)]
15739 let offset = encoder.out_of_line_offset(bytes_len);
15740 let mut _prev_end_offset: usize = 0;
15741 if 1 > max_ordinal {
15742 return Ok(());
15743 }
15744
15745 let cur_offset: usize = (1 - 1) * envelope_size;
15748
15749 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15751
15752 fidl::encoding::encode_in_envelope_optional::<UpstreamDnsQueryState, D>(
15757 self.upstream_dns_query_state
15758 .as_ref()
15759 .map(<UpstreamDnsQueryState as fidl::encoding::ValueTypeMarker>::borrow),
15760 encoder,
15761 offset + cur_offset,
15762 depth,
15763 )?;
15764
15765 _prev_end_offset = cur_offset + envelope_size;
15766
15767 Ok(())
15768 }
15769 }
15770
15771 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsInfo {
15772 #[inline(always)]
15773 fn new_empty() -> Self {
15774 Self::default()
15775 }
15776
15777 unsafe fn decode(
15778 &mut self,
15779 decoder: &mut fidl::encoding::Decoder<'_, D>,
15780 offset: usize,
15781 mut depth: fidl::encoding::Depth,
15782 ) -> fidl::Result<()> {
15783 decoder.debug_check_bounds::<Self>(offset);
15784 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15785 None => return Err(fidl::Error::NotNullable),
15786 Some(len) => len,
15787 };
15788 if len == 0 {
15790 return Ok(());
15791 };
15792 depth.increment()?;
15793 let envelope_size = 8;
15794 let bytes_len = len * envelope_size;
15795 let offset = decoder.out_of_line_offset(bytes_len)?;
15796 let mut _next_ordinal_to_read = 0;
15798 let mut next_offset = offset;
15799 let end_offset = offset + bytes_len;
15800 _next_ordinal_to_read += 1;
15801 if next_offset >= end_offset {
15802 return Ok(());
15803 }
15804
15805 while _next_ordinal_to_read < 1 {
15807 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15808 _next_ordinal_to_read += 1;
15809 next_offset += envelope_size;
15810 }
15811
15812 let next_out_of_line = decoder.next_out_of_line();
15813 let handles_before = decoder.remaining_handles();
15814 if let Some((inlined, num_bytes, num_handles)) =
15815 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15816 {
15817 let member_inline_size =
15818 <UpstreamDnsQueryState as fidl::encoding::TypeMarker>::inline_size(
15819 decoder.context,
15820 );
15821 if inlined != (member_inline_size <= 4) {
15822 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15823 }
15824 let inner_offset;
15825 let mut inner_depth = depth.clone();
15826 if inlined {
15827 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15828 inner_offset = next_offset;
15829 } else {
15830 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15831 inner_depth.increment()?;
15832 }
15833 let val_ref = self
15834 .upstream_dns_query_state
15835 .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsQueryState, D));
15836 fidl::decode!(
15837 UpstreamDnsQueryState,
15838 D,
15839 val_ref,
15840 decoder,
15841 inner_offset,
15842 inner_depth
15843 )?;
15844 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15845 {
15846 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15847 }
15848 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15849 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15850 }
15851 }
15852
15853 next_offset += envelope_size;
15854
15855 while next_offset < end_offset {
15857 _next_ordinal_to_read += 1;
15858 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15859 next_offset += envelope_size;
15860 }
15861
15862 Ok(())
15863 }
15864 }
15865
15866 impl fidl::encoding::ValueTypeMarker for JoinParams {
15867 type Borrowed<'a> = &'a Self;
15868 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15869 value
15870 }
15871 }
15872
15873 unsafe impl fidl::encoding::TypeMarker for JoinParams {
15874 type Owned = Self;
15875
15876 #[inline(always)]
15877 fn inline_align(_context: fidl::encoding::Context) -> usize {
15878 8
15879 }
15880
15881 #[inline(always)]
15882 fn inline_size(_context: fidl::encoding::Context) -> usize {
15883 16
15884 }
15885 }
15886
15887 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<JoinParams, D>
15888 for &JoinParams
15889 {
15890 #[inline]
15891 unsafe fn encode(
15892 self,
15893 encoder: &mut fidl::encoding::Encoder<'_, D>,
15894 offset: usize,
15895 _depth: fidl::encoding::Depth,
15896 ) -> fidl::Result<()> {
15897 encoder.debug_check_bounds::<JoinParams>(offset);
15898 encoder.write_num::<u64>(self.ordinal(), offset);
15899 match self {
15900 JoinParams::ProvisioningParameter(ref val) => {
15901 fidl::encoding::encode_in_envelope::<fidl_fuchsia_lowpan_device__common::ProvisioningParams, D>(
15902 <fidl_fuchsia_lowpan_device__common::ProvisioningParams as fidl::encoding::ValueTypeMarker>::borrow(val),
15903 encoder, offset + 8, _depth
15904 )
15905 }
15906 JoinParams::JoinerParameter(ref val) => {
15907 fidl::encoding::encode_in_envelope::<JoinerCommissioningParams, D>(
15908 <JoinerCommissioningParams as fidl::encoding::ValueTypeMarker>::borrow(val),
15909 encoder, offset + 8, _depth
15910 )
15911 }
15912 JoinParams::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
15913 }
15914 }
15915 }
15916
15917 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for JoinParams {
15918 #[inline(always)]
15919 fn new_empty() -> Self {
15920 Self::__SourceBreaking { unknown_ordinal: 0 }
15921 }
15922
15923 #[inline]
15924 unsafe fn decode(
15925 &mut self,
15926 decoder: &mut fidl::encoding::Decoder<'_, D>,
15927 offset: usize,
15928 mut depth: fidl::encoding::Depth,
15929 ) -> fidl::Result<()> {
15930 decoder.debug_check_bounds::<Self>(offset);
15931 #[allow(unused_variables)]
15932 let next_out_of_line = decoder.next_out_of_line();
15933 let handles_before = decoder.remaining_handles();
15934 let (ordinal, inlined, num_bytes, num_handles) =
15935 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
15936
15937 let member_inline_size = match ordinal {
15938 1 => <fidl_fuchsia_lowpan_device__common::ProvisioningParams as fidl::encoding::TypeMarker>::inline_size(decoder.context),
15939 2 => <JoinerCommissioningParams as fidl::encoding::TypeMarker>::inline_size(decoder.context),
15940 0 => return Err(fidl::Error::UnknownUnionTag),
15941 _ => num_bytes as usize,
15942 };
15943
15944 if inlined != (member_inline_size <= 4) {
15945 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15946 }
15947 let _inner_offset;
15948 if inlined {
15949 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
15950 _inner_offset = offset + 8;
15951 } else {
15952 depth.increment()?;
15953 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15954 }
15955 match ordinal {
15956 1 => {
15957 #[allow(irrefutable_let_patterns)]
15958 if let JoinParams::ProvisioningParameter(_) = self {
15959 } else {
15961 *self = JoinParams::ProvisioningParameter(fidl::new_empty!(
15963 fidl_fuchsia_lowpan_device__common::ProvisioningParams,
15964 D
15965 ));
15966 }
15967 #[allow(irrefutable_let_patterns)]
15968 if let JoinParams::ProvisioningParameter(ref mut val) = self {
15969 fidl::decode!(
15970 fidl_fuchsia_lowpan_device__common::ProvisioningParams,
15971 D,
15972 val,
15973 decoder,
15974 _inner_offset,
15975 depth
15976 )?;
15977 } else {
15978 unreachable!()
15979 }
15980 }
15981 2 => {
15982 #[allow(irrefutable_let_patterns)]
15983 if let JoinParams::JoinerParameter(_) = self {
15984 } else {
15986 *self = JoinParams::JoinerParameter(fidl::new_empty!(
15988 JoinerCommissioningParams,
15989 D
15990 ));
15991 }
15992 #[allow(irrefutable_let_patterns)]
15993 if let JoinParams::JoinerParameter(ref mut val) = self {
15994 fidl::decode!(
15995 JoinerCommissioningParams,
15996 D,
15997 val,
15998 decoder,
15999 _inner_offset,
16000 depth
16001 )?;
16002 } else {
16003 unreachable!()
16004 }
16005 }
16006 #[allow(deprecated)]
16007 ordinal => {
16008 for _ in 0..num_handles {
16009 decoder.drop_next_handle()?;
16010 }
16011 *self = JoinParams::__SourceBreaking { unknown_ordinal: ordinal };
16012 }
16013 }
16014 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16015 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16016 }
16017 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16018 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16019 }
16020 Ok(())
16021 }
16022 }
16023
16024 impl fidl::encoding::ValueTypeMarker for ProvisioningProgress {
16025 type Borrowed<'a> = &'a Self;
16026 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16027 value
16028 }
16029 }
16030
16031 unsafe impl fidl::encoding::TypeMarker for ProvisioningProgress {
16032 type Owned = Self;
16033
16034 #[inline(always)]
16035 fn inline_align(_context: fidl::encoding::Context) -> usize {
16036 8
16037 }
16038
16039 #[inline(always)]
16040 fn inline_size(_context: fidl::encoding::Context) -> usize {
16041 16
16042 }
16043 }
16044
16045 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProvisioningProgress, D>
16046 for &ProvisioningProgress
16047 {
16048 #[inline]
16049 unsafe fn encode(
16050 self,
16051 encoder: &mut fidl::encoding::Encoder<'_, D>,
16052 offset: usize,
16053 _depth: fidl::encoding::Depth,
16054 ) -> fidl::Result<()> {
16055 encoder.debug_check_bounds::<ProvisioningProgress>(offset);
16056 encoder.write_num::<u64>(self.ordinal(), offset);
16057 match self {
16058 ProvisioningProgress::Progress(ref val) => {
16059 fidl::encoding::encode_in_envelope::<f32, D>(
16060 <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16061 encoder, offset + 8, _depth
16062 )
16063 }
16064 ProvisioningProgress::Identity(ref val) => {
16065 fidl::encoding::encode_in_envelope::<fidl_fuchsia_lowpan_device__common::Identity, D>(
16066 <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::ValueTypeMarker>::borrow(val),
16067 encoder, offset + 8, _depth
16068 )
16069 }
16070 ProvisioningProgress::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
16071 }
16072 }
16073 }
16074
16075 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisioningProgress {
16076 #[inline(always)]
16077 fn new_empty() -> Self {
16078 Self::__SourceBreaking { unknown_ordinal: 0 }
16079 }
16080
16081 #[inline]
16082 unsafe fn decode(
16083 &mut self,
16084 decoder: &mut fidl::encoding::Decoder<'_, D>,
16085 offset: usize,
16086 mut depth: fidl::encoding::Depth,
16087 ) -> fidl::Result<()> {
16088 decoder.debug_check_bounds::<Self>(offset);
16089 #[allow(unused_variables)]
16090 let next_out_of_line = decoder.next_out_of_line();
16091 let handles_before = decoder.remaining_handles();
16092 let (ordinal, inlined, num_bytes, num_handles) =
16093 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
16094
16095 let member_inline_size = match ordinal {
16096 1 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16097 2 => <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16098 0 => return Err(fidl::Error::UnknownUnionTag),
16099 _ => num_bytes as usize,
16100 };
16101
16102 if inlined != (member_inline_size <= 4) {
16103 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16104 }
16105 let _inner_offset;
16106 if inlined {
16107 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16108 _inner_offset = offset + 8;
16109 } else {
16110 depth.increment()?;
16111 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16112 }
16113 match ordinal {
16114 1 => {
16115 #[allow(irrefutable_let_patterns)]
16116 if let ProvisioningProgress::Progress(_) = self {
16117 } else {
16119 *self = ProvisioningProgress::Progress(fidl::new_empty!(f32, D));
16121 }
16122 #[allow(irrefutable_let_patterns)]
16123 if let ProvisioningProgress::Progress(ref mut val) = self {
16124 fidl::decode!(f32, D, val, decoder, _inner_offset, depth)?;
16125 } else {
16126 unreachable!()
16127 }
16128 }
16129 2 => {
16130 #[allow(irrefutable_let_patterns)]
16131 if let ProvisioningProgress::Identity(_) = self {
16132 } else {
16134 *self = ProvisioningProgress::Identity(fidl::new_empty!(
16136 fidl_fuchsia_lowpan_device__common::Identity,
16137 D
16138 ));
16139 }
16140 #[allow(irrefutable_let_patterns)]
16141 if let ProvisioningProgress::Identity(ref mut val) = self {
16142 fidl::decode!(
16143 fidl_fuchsia_lowpan_device__common::Identity,
16144 D,
16145 val,
16146 decoder,
16147 _inner_offset,
16148 depth
16149 )?;
16150 } else {
16151 unreachable!()
16152 }
16153 }
16154 #[allow(deprecated)]
16155 ordinal => {
16156 for _ in 0..num_handles {
16157 decoder.drop_next_handle()?;
16158 }
16159 *self = ProvisioningProgress::__SourceBreaking { unknown_ordinal: ordinal };
16160 }
16161 }
16162 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16163 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16164 }
16165 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16166 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16167 }
16168 Ok(())
16169 }
16170 }
16171}