1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type ConfigKey = String;
13
14pub type ChildName = String;
15
16pub type DictionaryPath = String;
24
25pub type Name = String;
26
27pub type UrlScheme = String;
28
29pub const CONFIG_KEY_MAX_SIZE: u32 = 64;
31
32pub const MAX_CHILD_NAME_LENGTH: u32 = 1024;
33
34pub const MAX_MONIKER_LENGTH: u32 = 4096;
35
36pub const MAX_NAME_LENGTH: u32 = 100;
37
38pub const MAX_NUM_EVENT_STREAM_SUBSCRIPTIONS: u64 = 100;
40
41pub const MAX_PATH_LENGTH: u32 = 1024;
42
43pub const MAX_URL_SCHEME_LENGTH: u32 = 100;
44
45bitflags! {
46 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
48 pub struct ConfigMutability: u32 {
49 const PARENT = 1;
51 }
52}
53
54impl ConfigMutability {
55 #[inline(always)]
56 pub fn from_bits_allow_unknown(bits: u32) -> Self {
57 Self::from_bits_retain(bits)
58 }
59
60 #[inline(always)]
61 pub fn has_unknown_bits(&self) -> bool {
62 self.get_unknown_bits() != 0
63 }
64
65 #[inline(always)]
66 pub fn get_unknown_bits(&self) -> u32 {
67 self.bits() & !Self::all().bits()
68 }
69}
70
71#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
73#[repr(u32)]
74pub enum AllowedOffers {
75 StaticOnly = 1,
81 StaticAndDynamic = 2,
86}
87
88impl AllowedOffers {
89 #[inline]
90 pub fn from_primitive(prim: u32) -> Option<Self> {
91 match prim {
92 1 => Some(Self::StaticOnly),
93 2 => Some(Self::StaticAndDynamic),
94 _ => None,
95 }
96 }
97
98 #[inline]
99 pub const fn into_primitive(self) -> u32 {
100 self as u32
101 }
102}
103
104#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
112#[repr(u32)]
113pub enum Availability {
114 Required = 1,
117 Optional = 2,
124 SameAsTarget = 3,
132 Transitional = 4,
138}
139
140impl Availability {
141 #[inline]
142 pub fn from_primitive(prim: u32) -> Option<Self> {
143 match prim {
144 1 => Some(Self::Required),
145 2 => Some(Self::Optional),
146 3 => Some(Self::SameAsTarget),
147 4 => Some(Self::Transitional),
148 _ => None,
149 }
150 }
151
152 #[inline]
153 pub const fn into_primitive(self) -> u32 {
154 self as u32
155 }
156}
157
158#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
159pub enum ConfigTypeLayout {
160 Bool,
161 Uint8,
162 Uint16,
163 Uint32,
164 Uint64,
165 Int8,
166 Int16,
167 Int32,
168 Int64,
169 String,
170 Vector,
171 #[doc(hidden)]
172 __SourceBreaking {
173 unknown_ordinal: u32,
174 },
175}
176
177#[macro_export]
179macro_rules! ConfigTypeLayoutUnknown {
180 () => {
181 _
182 };
183}
184
185impl ConfigTypeLayout {
186 #[inline]
187 pub fn from_primitive(prim: u32) -> Option<Self> {
188 match prim {
189 1 => Some(Self::Bool),
190 2 => Some(Self::Uint8),
191 3 => Some(Self::Uint16),
192 4 => Some(Self::Uint32),
193 5 => Some(Self::Uint64),
194 6 => Some(Self::Int8),
195 7 => Some(Self::Int16),
196 8 => Some(Self::Int32),
197 9 => Some(Self::Int64),
198 10 => Some(Self::String),
199 11 => Some(Self::Vector),
200 _ => None,
201 }
202 }
203
204 #[inline]
205 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
206 match prim {
207 1 => Self::Bool,
208 2 => Self::Uint8,
209 3 => Self::Uint16,
210 4 => Self::Uint32,
211 5 => Self::Uint64,
212 6 => Self::Int8,
213 7 => Self::Int16,
214 8 => Self::Int32,
215 9 => Self::Int64,
216 10 => Self::String,
217 11 => Self::Vector,
218 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
219 }
220 }
221
222 #[inline]
223 pub fn unknown() -> Self {
224 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
225 }
226
227 #[inline]
228 pub const fn into_primitive(self) -> u32 {
229 match self {
230 Self::Bool => 1,
231 Self::Uint8 => 2,
232 Self::Uint16 => 3,
233 Self::Uint32 => 4,
234 Self::Uint64 => 5,
235 Self::Int8 => 6,
236 Self::Int16 => 7,
237 Self::Int32 => 8,
238 Self::Int64 => 9,
239 Self::String => 10,
240 Self::Vector => 11,
241 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
242 }
243 }
244
245 #[inline]
246 pub fn is_unknown(&self) -> bool {
247 match self {
248 Self::__SourceBreaking { unknown_ordinal: _ } => true,
249 _ => false,
250 }
251 }
252}
253
254#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
258pub enum DeliveryType {
259 Immediate,
262 OnReadable,
267 #[doc(hidden)]
268 __SourceBreaking { unknown_ordinal: u32 },
269}
270
271#[macro_export]
273macro_rules! DeliveryTypeUnknown {
274 () => {
275 _
276 };
277}
278
279impl DeliveryType {
280 #[inline]
281 pub fn from_primitive(prim: u32) -> Option<Self> {
282 match prim {
283 0 => Some(Self::Immediate),
284 1 => Some(Self::OnReadable),
285 _ => None,
286 }
287 }
288
289 #[inline]
290 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
291 match prim {
292 0 => Self::Immediate,
293 1 => Self::OnReadable,
294 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
295 }
296 }
297
298 #[inline]
299 pub fn unknown() -> Self {
300 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
301 }
302
303 #[inline]
304 pub const fn into_primitive(self) -> u32 {
305 match self {
306 Self::Immediate => 0,
307 Self::OnReadable => 1,
308 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
309 }
310 }
311
312 #[inline]
313 pub fn is_unknown(&self) -> bool {
314 match self {
315 Self::__SourceBreaking { unknown_ordinal: _ } => true,
316 _ => false,
317 }
318 }
319}
320
321#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
323#[repr(u32)]
324pub enum DependencyType {
325 Strong = 1,
327 Weak = 2,
331}
332
333impl DependencyType {
334 #[inline]
335 pub fn from_primitive(prim: u32) -> Option<Self> {
336 match prim {
337 1 => Some(Self::Strong),
338 2 => Some(Self::Weak),
339 _ => None,
340 }
341 }
342
343 #[inline]
344 pub const fn into_primitive(self) -> u32 {
345 self as u32
346 }
347}
348
349#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
351#[repr(u32)]
352pub enum Durability {
353 Transient = 2,
356 SingleRun = 3,
359}
360
361impl Durability {
362 #[inline]
363 pub fn from_primitive(prim: u32) -> Option<Self> {
364 match prim {
365 2 => Some(Self::Transient),
366 3 => Some(Self::SingleRun),
367 _ => None,
368 }
369 }
370
371 #[inline]
372 pub const fn into_primitive(self) -> u32 {
373 self as u32
374 }
375}
376
377#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
379#[repr(u32)]
380pub enum EnvironmentExtends {
381 None = 0,
383 Realm = 1,
386}
387
388impl EnvironmentExtends {
389 #[inline]
390 pub fn from_primitive(prim: u32) -> Option<Self> {
391 match prim {
392 0 => Some(Self::None),
393 1 => Some(Self::Realm),
394 _ => None,
395 }
396 }
397
398 #[inline]
399 pub const fn into_primitive(self) -> u32 {
400 self as u32
401 }
402}
403
404#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
407#[repr(u32)]
408pub enum OnTerminate {
409 None = 0,
411 Reboot = 1,
416}
417
418impl OnTerminate {
419 #[inline]
420 pub fn from_primitive(prim: u32) -> Option<Self> {
421 match prim {
422 0 => Some(Self::None),
423 1 => Some(Self::Reboot),
424 _ => None,
425 }
426 }
427
428 #[inline]
429 pub const fn into_primitive(self) -> u32 {
430 self as u32
431 }
432}
433
434#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
436#[repr(u32)]
437pub enum StartupMode {
438 Lazy = 0,
441 Eager = 1,
444}
445
446impl StartupMode {
447 #[inline]
448 pub fn from_primitive(prim: u32) -> Option<Self> {
449 match prim {
450 0 => Some(Self::Lazy),
451 1 => Some(Self::Eager),
452 _ => None,
453 }
454 }
455
456 #[inline]
457 pub const fn into_primitive(self) -> u32 {
458 self as u32
459 }
460}
461
462#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
465#[repr(u32)]
466pub enum StorageId {
467 StaticInstanceId = 1,
471 StaticInstanceIdOrMoniker = 2,
476}
477
478impl StorageId {
479 #[inline]
480 pub fn from_primitive(prim: u32) -> Option<Self> {
481 match prim {
482 1 => Some(Self::StaticInstanceId),
483 2 => Some(Self::StaticInstanceIdOrMoniker),
484 _ => None,
485 }
486 }
487
488 #[inline]
489 pub const fn into_primitive(self) -> u32 {
490 self as u32
491 }
492}
493
494#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
496pub struct CapabilityRef {
497 pub name: String,
498}
499
500impl fidl::Persistable for CapabilityRef {}
501
502#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
504pub struct ChildRef {
505 pub name: String,
508 pub collection: Option<String>,
512}
513
514impl fidl::Persistable for ChildRef {}
515
516#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
518pub struct CollectionRef {
519 pub name: String,
520}
521
522impl fidl::Persistable for CollectionRef {}
523
524#[derive(Clone, Debug, PartialEq)]
525pub struct ConfigType {
526 pub layout: ConfigTypeLayout,
527 pub parameters: Option<Vec<LayoutParameter>>,
528 pub constraints: Vec<LayoutConstraint>,
529}
530
531impl fidl::Persistable for ConfigType {}
532
533#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
535pub struct DebugRef;
536
537impl fidl::Persistable for DebugRef {}
538
539#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
541pub struct EnvironmentRef;
542
543impl fidl::Persistable for EnvironmentRef {}
544
545#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
547pub struct FrameworkRef;
548
549impl fidl::Persistable for FrameworkRef {}
550
551#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
554pub struct NameMapping {
555 pub source_name: String,
557 pub target_name: String,
559}
560
561impl fidl::Persistable for NameMapping {}
562
563#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
565pub struct ParentRef;
566
567impl fidl::Persistable for ParentRef {}
568
569#[derive(Clone, Debug, PartialEq)]
571pub struct ResolvedConfig {
572 pub fields: Vec<ResolvedConfigField>,
573 pub checksum: ConfigChecksum,
574}
575
576impl fidl::Persistable for ResolvedConfig {}
577
578#[derive(Clone, Debug, PartialEq)]
579pub struct ResolvedConfigField {
580 pub key: String,
581 pub value: ConfigValue,
582}
583
584impl fidl::Persistable for ResolvedConfigField {}
585
586#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
588pub struct SelfRef;
589
590impl fidl::Persistable for SelfRef {}
591
592#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
594pub struct VoidRef;
595
596impl fidl::Persistable for VoidRef {}
597
598#[derive(Clone, Debug, Default, PartialEq)]
600pub struct Child {
601 pub name: Option<String>,
606 pub url: Option<String>,
610 pub startup: Option<StartupMode>,
614 pub environment: Option<String>,
621 pub on_terminate: Option<OnTerminate>,
624 pub config_overrides: Option<Vec<ConfigOverride>>,
631 #[doc(hidden)]
632 pub __source_breaking: fidl::marker::SourceBreaking,
633}
634
635impl fidl::Persistable for Child {}
636
637#[derive(Clone, Debug, Default, PartialEq)]
639pub struct Collection {
640 pub name: Option<String>,
643 pub durability: Option<Durability>,
645 pub environment: Option<String>,
653 pub allowed_offers: Option<AllowedOffers>,
659 pub allow_long_names: Option<bool>,
665 pub persistent_storage: Option<bool>,
679 #[doc(hidden)]
680 pub __source_breaking: fidl::marker::SourceBreaking,
681}
682
683impl fidl::Persistable for Collection {}
684
685#[derive(Clone, Debug, Default, PartialEq)]
691pub struct Component {
692 pub program: Option<Program>,
695 pub uses: Option<Vec<Use>>,
701 pub exposes: Option<Vec<Expose>>,
707 pub offers: Option<Vec<Offer>>,
713 pub capabilities: Option<Vec<Capability>>,
715 pub children: Option<Vec<Child>>,
718 pub collections: Option<Vec<Collection>>,
720 pub environments: Option<Vec<Environment>>,
724 pub facets: Option<fidl_fuchsia_data__common::Dictionary>,
726 pub config: Option<ConfigSchema>,
728 #[doc(hidden)]
729 pub __source_breaking: fidl::marker::SourceBreaking,
730}
731
732impl fidl::Persistable for Component {}
733
734#[derive(Clone, Debug, Default, PartialEq)]
736pub struct ConfigField {
737 pub key: Option<String>,
740 pub type_: Option<ConfigType>,
743 pub mutability: Option<ConfigMutability>,
745 #[doc(hidden)]
746 pub __source_breaking: fidl::marker::SourceBreaking,
747}
748
749impl fidl::Persistable for ConfigField {}
750
751#[derive(Clone, Debug, Default, PartialEq)]
753pub struct ConfigOverride {
754 pub key: Option<String>,
755 pub value: Option<ConfigValue>,
756 #[doc(hidden)]
757 pub __source_breaking: fidl::marker::SourceBreaking,
758}
759
760impl fidl::Persistable for ConfigOverride {}
761
762#[derive(Clone, Debug, Default, PartialEq)]
764pub struct ConfigSchema {
765 pub fields: Option<Vec<ConfigField>>,
767 pub checksum: Option<ConfigChecksum>,
769 pub value_source: Option<ConfigValueSource>,
771 #[doc(hidden)]
772 pub __source_breaking: fidl::marker::SourceBreaking,
773}
774
775impl fidl::Persistable for ConfigSchema {}
776
777#[derive(Clone, Debug, Default, PartialEq)]
778pub struct ConfigSourceCapabilities {
779 #[doc(hidden)]
780 pub __source_breaking: fidl::marker::SourceBreaking,
781}
782
783impl fidl::Persistable for ConfigSourceCapabilities {}
784
785#[derive(Clone, Debug, Default, PartialEq)]
788pub struct ConfigValueSpec {
789 pub value: Option<ConfigValue>,
790 #[doc(hidden)]
791 pub __source_breaking: fidl::marker::SourceBreaking,
792}
793
794impl fidl::Persistable for ConfigValueSpec {}
795
796#[derive(Clone, Debug, Default, PartialEq)]
798pub struct ConfigValuesData {
799 pub values: Option<Vec<ConfigValueSpec>>,
801 pub checksum: Option<ConfigChecksum>,
804 #[doc(hidden)]
805 pub __source_breaking: fidl::marker::SourceBreaking,
806}
807
808impl fidl::Persistable for ConfigValuesData {}
809
810#[derive(Clone, Debug, Default, PartialEq)]
817pub struct Configuration {
818 pub name: Option<String>,
820 pub value: Option<ConfigValue>,
822 #[doc(hidden)]
823 pub __source_breaking: fidl::marker::SourceBreaking,
824}
825
826impl fidl::Persistable for Configuration {}
827
828#[derive(Clone, Debug, Default, PartialEq)]
835pub struct DebugProtocolRegistration {
836 pub source: Option<Ref>,
839 pub source_name: Option<String>,
841 pub target_name: Option<String>,
843 #[doc(hidden)]
844 pub __source_breaking: fidl::marker::SourceBreaking,
845}
846
847impl fidl::Persistable for DebugProtocolRegistration {}
848
849#[derive(Clone, Debug, Default, PartialEq)]
851pub struct Dictionary {
852 pub name: Option<String>,
856 pub source: Option<Ref>,
859 pub source_dictionary: Option<String>,
864 pub source_path: Option<String>,
871 #[doc(hidden)]
872 pub __source_breaking: fidl::marker::SourceBreaking,
873}
874
875impl fidl::Persistable for Dictionary {}
876
877#[derive(Clone, Debug, Default, PartialEq)]
882pub struct Directory {
883 pub name: Option<String>,
885 pub source_path: Option<String>,
890 pub rights: Option<fidl_fuchsia_io__common::Operations>,
893 #[doc(hidden)]
894 pub __source_breaking: fidl::marker::SourceBreaking,
895}
896
897impl fidl::Persistable for Directory {}
898
899#[derive(Clone, Debug, Default, PartialEq)]
901pub struct Environment {
902 pub name: Option<String>,
904 pub extends: Option<EnvironmentExtends>,
907 pub runners: Option<Vec<RunnerRegistration>>,
912 pub resolvers: Option<Vec<ResolverRegistration>>,
918 pub debug_capabilities: Option<Vec<DebugRegistration>>,
926 pub stop_timeout_ms: Option<u32>,
930 #[doc(hidden)]
931 pub __source_breaking: fidl::marker::SourceBreaking,
932}
933
934impl fidl::Persistable for Environment {}
935
936#[derive(Clone, Debug, Default, PartialEq)]
942pub struct EventStream {
943 pub name: Option<String>,
947 #[doc(hidden)]
948 pub __source_breaking: fidl::marker::SourceBreaking,
949}
950
951impl fidl::Persistable for EventStream {}
952
953#[derive(Clone, Debug, Default, PartialEq)]
955pub struct EventSubscription {
956 pub event_name: Option<String>,
958 #[doc(hidden)]
959 pub __source_breaking: fidl::marker::SourceBreaking,
960}
961
962impl fidl::Persistable for EventSubscription {}
963
964#[derive(Clone, Debug, Default, PartialEq)]
967pub struct ExposeConfiguration {
968 pub source: Option<Ref>,
973 pub source_name: Option<String>,
976 pub target: Option<Ref>,
978 pub target_name: Option<String>,
980 pub availability: Option<Availability>,
983 pub source_dictionary: Option<String>,
988 #[doc(hidden)]
989 pub __source_breaking: fidl::marker::SourceBreaking,
990}
991
992impl fidl::Persistable for ExposeConfiguration {}
993
994#[derive(Clone, Debug, Default, PartialEq)]
1000pub struct ExposeDictionary {
1001 pub source: Option<Ref>,
1006 pub source_name: Option<String>,
1009 pub target: Option<Ref>,
1012 pub target_name: Option<String>,
1014 pub availability: Option<Availability>,
1017 pub source_dictionary: Option<String>,
1026 #[doc(hidden)]
1027 pub __source_breaking: fidl::marker::SourceBreaking,
1028}
1029
1030impl fidl::Persistable for ExposeDictionary {}
1031
1032#[derive(Clone, Debug, Default, PartialEq)]
1035pub struct ExposeDirectory {
1036 pub source: Option<Ref>,
1041 pub source_name: Option<String>,
1044 pub target: Option<Ref>,
1047 pub target_name: Option<String>,
1049 pub rights: Option<fidl_fuchsia_io__common::Operations>,
1052 pub subdir: Option<String>,
1055 pub availability: Option<Availability>,
1058 pub source_dictionary: Option<String>,
1067 #[doc(hidden)]
1068 pub __source_breaking: fidl::marker::SourceBreaking,
1069}
1070
1071impl fidl::Persistable for ExposeDirectory {}
1072
1073#[derive(Clone, Debug, Default, PartialEq)]
1079pub struct ExposeProtocol {
1080 pub source: Option<Ref>,
1085 pub source_name: Option<String>,
1088 pub target: Option<Ref>,
1091 pub target_name: Option<String>,
1093 pub availability: Option<Availability>,
1096 pub source_dictionary: Option<String>,
1105 #[doc(hidden)]
1106 pub __source_breaking: fidl::marker::SourceBreaking,
1107}
1108
1109impl fidl::Persistable for ExposeProtocol {}
1110
1111#[derive(Clone, Debug, Default, PartialEq)]
1114pub struct ExposeResolver {
1115 pub source: Option<Ref>,
1118 pub source_name: Option<String>,
1121 pub target: Option<Ref>,
1123 pub target_name: Option<String>,
1125 pub source_dictionary: Option<String>,
1134 #[doc(hidden)]
1135 pub __source_breaking: fidl::marker::SourceBreaking,
1136}
1137
1138impl fidl::Persistable for ExposeResolver {}
1139
1140#[derive(Clone, Debug, Default, PartialEq)]
1143pub struct ExposeRunner {
1144 pub source: Option<Ref>,
1147 pub source_name: Option<String>,
1150 pub target: Option<Ref>,
1153 pub target_name: Option<String>,
1155 pub source_dictionary: Option<String>,
1164 #[doc(hidden)]
1165 pub __source_breaking: fidl::marker::SourceBreaking,
1166}
1167
1168impl fidl::Persistable for ExposeRunner {}
1169
1170#[derive(Clone, Debug, Default, PartialEq)]
1176pub struct ExposeService {
1177 pub source: Option<Ref>,
1182 pub source_name: Option<String>,
1185 pub target: Option<Ref>,
1188 pub target_name: Option<String>,
1190 pub availability: Option<Availability>,
1193 pub source_dictionary: Option<String>,
1198 #[doc(hidden)]
1199 pub __source_breaking: fidl::marker::SourceBreaking,
1200}
1201
1202impl fidl::Persistable for ExposeService {}
1203
1204#[derive(Clone, Debug, Default, PartialEq)]
1208pub struct OfferConfiguration {
1209 pub source: Option<Ref>,
1214 pub source_name: Option<String>,
1216 pub target: Option<Ref>,
1218 pub target_name: Option<String>,
1220 pub availability: Option<Availability>,
1227 pub source_dictionary: Option<String>,
1232 #[doc(hidden)]
1233 pub __source_breaking: fidl::marker::SourceBreaking,
1234}
1235
1236impl fidl::Persistable for OfferConfiguration {}
1237
1238#[derive(Clone, Debug, Default, PartialEq)]
1245pub struct OfferDictionary {
1246 pub source: Option<Ref>,
1251 pub source_name: Option<String>,
1253 pub target: Option<Ref>,
1256 pub target_name: Option<String>,
1258 pub dependency_type: Option<DependencyType>,
1262 pub availability: Option<Availability>,
1269 pub source_dictionary: Option<String>,
1274 #[doc(hidden)]
1275 pub __source_breaking: fidl::marker::SourceBreaking,
1276}
1277
1278impl fidl::Persistable for OfferDictionary {}
1279
1280#[derive(Clone, Debug, Default, PartialEq)]
1284pub struct OfferDirectory {
1285 pub source: Option<Ref>,
1290 pub source_name: Option<String>,
1292 pub target: Option<Ref>,
1295 pub target_name: Option<String>,
1297 pub rights: Option<fidl_fuchsia_io__common::Operations>,
1300 pub subdir: Option<String>,
1303 pub dependency_type: Option<DependencyType>,
1307 pub availability: Option<Availability>,
1314 pub source_dictionary: Option<String>,
1319 #[doc(hidden)]
1320 pub __source_breaking: fidl::marker::SourceBreaking,
1321}
1322
1323impl fidl::Persistable for OfferDirectory {}
1324
1325#[derive(Clone, Debug, Default, PartialEq)]
1327pub struct OfferEventStream {
1328 pub source: Option<Ref>,
1333 pub source_name: Option<String>,
1335 pub scope: Option<Vec<Ref>>,
1341 pub target: Option<Ref>,
1343 pub target_name: Option<String>,
1345 pub availability: Option<Availability>,
1352 #[doc(hidden)]
1353 pub __source_breaking: fidl::marker::SourceBreaking,
1354}
1355
1356impl fidl::Persistable for OfferEventStream {}
1357
1358#[derive(Clone, Debug, Default, PartialEq)]
1365pub struct OfferProtocol {
1366 pub source: Option<Ref>,
1371 pub source_name: Option<String>,
1373 pub target: Option<Ref>,
1376 pub target_name: Option<String>,
1378 pub dependency_type: Option<DependencyType>,
1382 pub availability: Option<Availability>,
1389 pub source_dictionary: Option<String>,
1394 #[doc(hidden)]
1395 pub __source_breaking: fidl::marker::SourceBreaking,
1396}
1397
1398impl fidl::Persistable for OfferProtocol {}
1399
1400#[derive(Clone, Debug, Default, PartialEq)]
1404pub struct OfferResolver {
1405 pub source: Option<Ref>,
1410 pub source_name: Option<String>,
1412 pub target: Option<Ref>,
1415 pub target_name: Option<String>,
1417 pub source_dictionary: Option<String>,
1422 #[doc(hidden)]
1423 pub __source_breaking: fidl::marker::SourceBreaking,
1424}
1425
1426impl fidl::Persistable for OfferResolver {}
1427
1428#[derive(Clone, Debug, Default, PartialEq)]
1432pub struct OfferRunner {
1433 pub source: Option<Ref>,
1438 pub source_name: Option<String>,
1440 pub target: Option<Ref>,
1443 pub target_name: Option<String>,
1445 pub source_dictionary: Option<String>,
1450 #[doc(hidden)]
1451 pub __source_breaking: fidl::marker::SourceBreaking,
1452}
1453
1454impl fidl::Persistable for OfferRunner {}
1455
1456#[derive(Clone, Debug, Default, PartialEq)]
1463pub struct OfferService {
1464 pub source: Option<Ref>,
1469 pub source_name: Option<String>,
1471 pub target: Option<Ref>,
1474 pub target_name: Option<String>,
1476 pub source_instance_filter: Option<Vec<String>>,
1481 pub renamed_instances: Option<Vec<NameMapping>>,
1493 pub availability: Option<Availability>,
1500 pub source_dictionary: Option<String>,
1505 pub dependency_type: Option<DependencyType>,
1509 #[doc(hidden)]
1510 pub __source_breaking: fidl::marker::SourceBreaking,
1511}
1512
1513impl fidl::Persistable for OfferService {}
1514
1515#[derive(Clone, Debug, Default, PartialEq)]
1519pub struct OfferStorage {
1520 pub source_name: Option<String>,
1522 pub source: Option<Ref>,
1527 pub target: Option<Ref>,
1530 pub target_name: Option<String>,
1532 pub availability: Option<Availability>,
1539 #[doc(hidden)]
1540 pub __source_breaking: fidl::marker::SourceBreaking,
1541}
1542
1543impl fidl::Persistable for OfferStorage {}
1544
1545#[derive(Clone, Debug, Default, PartialEq)]
1553pub struct Program {
1554 pub runner: Option<String>,
1559 pub info: Option<fidl_fuchsia_data__common::Dictionary>,
1570 #[doc(hidden)]
1571 pub __source_breaking: fidl::marker::SourceBreaking,
1572}
1573
1574impl fidl::Persistable for Program {}
1575
1576#[derive(Clone, Debug, Default, PartialEq)]
1581pub struct Protocol {
1582 pub name: Option<String>,
1584 pub source_path: Option<String>,
1589 pub delivery: Option<DeliveryType>,
1593 #[doc(hidden)]
1594 pub __source_breaking: fidl::marker::SourceBreaking,
1595}
1596
1597impl fidl::Persistable for Protocol {}
1598
1599#[derive(Clone, Debug, Default, PartialEq)]
1603pub struct Resolver {
1604 pub name: Option<String>,
1608 pub source_path: Option<String>,
1613 #[doc(hidden)]
1614 pub __source_breaking: fidl::marker::SourceBreaking,
1615}
1616
1617impl fidl::Persistable for Resolver {}
1618
1619#[derive(Clone, Debug, Default, PartialEq)]
1621pub struct ResolverRegistration {
1622 pub resolver: Option<String>,
1624 pub source: Option<Ref>,
1627 pub scheme: Option<String>,
1632 #[doc(hidden)]
1633 pub __source_breaking: fidl::marker::SourceBreaking,
1634}
1635
1636impl fidl::Persistable for ResolverRegistration {}
1637
1638#[derive(Clone, Debug, Default, PartialEq)]
1640pub struct Runner {
1641 pub name: Option<String>,
1645 pub source_path: Option<String>,
1650 #[doc(hidden)]
1651 pub __source_breaking: fidl::marker::SourceBreaking,
1652}
1653
1654impl fidl::Persistable for Runner {}
1655
1656#[derive(Clone, Debug, Default, PartialEq)]
1658pub struct RunnerRegistration {
1659 pub source_name: Option<String>,
1662 pub source: Option<Ref>,
1665 pub target_name: Option<String>,
1668 #[doc(hidden)]
1669 pub __source_breaking: fidl::marker::SourceBreaking,
1670}
1671
1672impl fidl::Persistable for RunnerRegistration {}
1673
1674#[derive(Clone, Debug, Default, PartialEq)]
1679pub struct Service {
1680 pub name: Option<String>,
1682 pub source_path: Option<String>,
1687 #[doc(hidden)]
1688 pub __source_breaking: fidl::marker::SourceBreaking,
1689}
1690
1691impl fidl::Persistable for Service {}
1692
1693#[derive(Clone, Debug, Default, PartialEq)]
1696pub struct Storage {
1697 pub name: Option<String>,
1699 pub source: Option<Ref>,
1702 pub backing_dir: Option<String>,
1705 pub subdir: Option<String>,
1708 pub storage_id: Option<StorageId>,
1712 #[doc(hidden)]
1713 pub __source_breaking: fidl::marker::SourceBreaking,
1714}
1715
1716impl fidl::Persistable for Storage {}
1717
1718#[derive(Clone, Debug, Default, PartialEq)]
1719pub struct UseConfiguration {
1720 pub source: Option<Ref>,
1723 pub source_name: Option<String>,
1726 pub target_name: Option<String>,
1730 pub availability: Option<Availability>,
1735 pub type_: Option<ConfigType>,
1738 pub default: Option<ConfigValue>,
1741 pub source_dictionary: Option<String>,
1746 #[doc(hidden)]
1747 pub __source_breaking: fidl::marker::SourceBreaking,
1748}
1749
1750impl fidl::Persistable for UseConfiguration {}
1751
1752#[derive(Clone, Debug, Default, PartialEq)]
1754pub struct UseDirectory {
1755 pub source: Option<Ref>,
1758 pub source_name: Option<String>,
1761 pub target_path: Option<String>,
1766 pub rights: Option<fidl_fuchsia_io__common::Operations>,
1768 pub subdir: Option<String>,
1771 pub dependency_type: Option<DependencyType>,
1780 pub availability: Option<Availability>,
1785 pub source_dictionary: Option<String>,
1790 #[doc(hidden)]
1791 pub __source_breaking: fidl::marker::SourceBreaking,
1792}
1793
1794impl fidl::Persistable for UseDirectory {}
1795
1796#[derive(Clone, Debug, Default, PartialEq)]
1798pub struct UseEventStream {
1799 pub source_name: Option<String>,
1801 pub source: Option<Ref>,
1803 pub scope: Option<Vec<Ref>>,
1809 pub target_path: Option<String>,
1812 pub availability: Option<Availability>,
1817 pub filter: Option<fidl_fuchsia_data__common::Dictionary>,
1821 #[doc(hidden)]
1822 pub __source_breaking: fidl::marker::SourceBreaking,
1823}
1824
1825impl fidl::Persistable for UseEventStream {}
1826
1827#[derive(Clone, Debug, Default, PartialEq)]
1832pub struct UseProtocol {
1833 pub source: Option<Ref>,
1836 pub source_name: Option<String>,
1839 pub target_path: Option<String>,
1844 pub dependency_type: Option<DependencyType>,
1853 pub availability: Option<Availability>,
1858 pub source_dictionary: Option<String>,
1863 #[doc(hidden)]
1864 pub __source_breaking: fidl::marker::SourceBreaking,
1865}
1866
1867impl fidl::Persistable for UseProtocol {}
1868
1869#[derive(Clone, Debug, Default, PartialEq)]
1871pub struct UseRunner {
1872 pub source: Option<Ref>,
1875 pub source_name: Option<String>,
1878 pub source_dictionary: Option<String>,
1883 #[doc(hidden)]
1884 pub __source_breaking: fidl::marker::SourceBreaking,
1885}
1886
1887impl fidl::Persistable for UseRunner {}
1888
1889#[derive(Clone, Debug, Default, PartialEq)]
1894pub struct UseService {
1895 pub source: Option<Ref>,
1898 pub source_name: Option<String>,
1901 pub target_path: Option<String>,
1906 pub dependency_type: Option<DependencyType>,
1915 pub availability: Option<Availability>,
1920 pub source_dictionary: Option<String>,
1925 #[doc(hidden)]
1926 pub __source_breaking: fidl::marker::SourceBreaking,
1927}
1928
1929impl fidl::Persistable for UseService {}
1930
1931#[derive(Clone, Debug, Default, PartialEq)]
1933pub struct UseStorage {
1934 pub source_name: Option<String>,
1937 pub target_path: Option<String>,
1942 pub availability: Option<Availability>,
1947 #[doc(hidden)]
1948 pub __source_breaking: fidl::marker::SourceBreaking,
1949}
1950
1951impl fidl::Persistable for UseStorage {}
1952
1953#[derive(Clone, Debug)]
1955pub enum Capability {
1956 Service(Service),
1957 Protocol(Protocol),
1958 Directory(Directory),
1959 Storage(Storage),
1960 Runner(Runner),
1961 Resolver(Resolver),
1962 EventStream(EventStream),
1963 Dictionary(Dictionary),
1964 Config(Configuration),
1965 #[doc(hidden)]
1966 __SourceBreaking {
1967 unknown_ordinal: u64,
1968 },
1969}
1970
1971#[macro_export]
1973macro_rules! CapabilityUnknown {
1974 () => {
1975 _
1976 };
1977}
1978
1979impl PartialEq for Capability {
1981 fn eq(&self, other: &Self) -> bool {
1982 match (self, other) {
1983 (Self::Service(x), Self::Service(y)) => *x == *y,
1984 (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
1985 (Self::Directory(x), Self::Directory(y)) => *x == *y,
1986 (Self::Storage(x), Self::Storage(y)) => *x == *y,
1987 (Self::Runner(x), Self::Runner(y)) => *x == *y,
1988 (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
1989 (Self::EventStream(x), Self::EventStream(y)) => *x == *y,
1990 (Self::Dictionary(x), Self::Dictionary(y)) => *x == *y,
1991 (Self::Config(x), Self::Config(y)) => *x == *y,
1992 _ => false,
1993 }
1994 }
1995}
1996
1997impl Capability {
1998 #[inline]
1999 pub fn ordinal(&self) -> u64 {
2000 match *self {
2001 Self::Service(_) => 1,
2002 Self::Protocol(_) => 2,
2003 Self::Directory(_) => 3,
2004 Self::Storage(_) => 4,
2005 Self::Runner(_) => 5,
2006 Self::Resolver(_) => 6,
2007 Self::EventStream(_) => 8,
2008 Self::Dictionary(_) => 9,
2009 Self::Config(_) => 10,
2010 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2011 }
2012 }
2013
2014 #[inline]
2015 pub fn unknown_variant_for_testing() -> Self {
2016 Self::__SourceBreaking { unknown_ordinal: 0 }
2017 }
2018
2019 #[inline]
2020 pub fn is_unknown(&self) -> bool {
2021 match self {
2022 Self::__SourceBreaking { .. } => true,
2023 _ => false,
2024 }
2025 }
2026}
2027
2028impl fidl::Persistable for Capability {}
2029
2030#[derive(Clone, Debug)]
2033pub enum ConfigChecksum {
2034 Sha256([u8; 32]),
2036 #[doc(hidden)]
2037 __SourceBreaking { unknown_ordinal: u64 },
2038}
2039
2040#[macro_export]
2042macro_rules! ConfigChecksumUnknown {
2043 () => {
2044 _
2045 };
2046}
2047
2048impl PartialEq for ConfigChecksum {
2050 fn eq(&self, other: &Self) -> bool {
2051 match (self, other) {
2052 (Self::Sha256(x), Self::Sha256(y)) => *x == *y,
2053 _ => false,
2054 }
2055 }
2056}
2057
2058impl ConfigChecksum {
2059 #[inline]
2060 pub fn ordinal(&self) -> u64 {
2061 match *self {
2062 Self::Sha256(_) => 1,
2063 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2064 }
2065 }
2066
2067 #[inline]
2068 pub fn unknown_variant_for_testing() -> Self {
2069 Self::__SourceBreaking { unknown_ordinal: 0 }
2070 }
2071
2072 #[inline]
2073 pub fn is_unknown(&self) -> bool {
2074 match self {
2075 Self::__SourceBreaking { .. } => true,
2076 _ => false,
2077 }
2078 }
2079}
2080
2081impl fidl::Persistable for ConfigChecksum {}
2082
2083#[derive(Clone, Debug)]
2085pub enum ConfigSingleValue {
2086 Bool(bool),
2087 Uint8(u8),
2088 Uint16(u16),
2089 Uint32(u32),
2090 Uint64(u64),
2091 Int8(i8),
2092 Int16(i16),
2093 Int32(i32),
2094 Int64(i64),
2095 String(String),
2096 #[doc(hidden)]
2097 __SourceBreaking {
2098 unknown_ordinal: u64,
2099 },
2100}
2101
2102#[macro_export]
2104macro_rules! ConfigSingleValueUnknown {
2105 () => {
2106 _
2107 };
2108}
2109
2110impl PartialEq for ConfigSingleValue {
2112 fn eq(&self, other: &Self) -> bool {
2113 match (self, other) {
2114 (Self::Bool(x), Self::Bool(y)) => *x == *y,
2115 (Self::Uint8(x), Self::Uint8(y)) => *x == *y,
2116 (Self::Uint16(x), Self::Uint16(y)) => *x == *y,
2117 (Self::Uint32(x), Self::Uint32(y)) => *x == *y,
2118 (Self::Uint64(x), Self::Uint64(y)) => *x == *y,
2119 (Self::Int8(x), Self::Int8(y)) => *x == *y,
2120 (Self::Int16(x), Self::Int16(y)) => *x == *y,
2121 (Self::Int32(x), Self::Int32(y)) => *x == *y,
2122 (Self::Int64(x), Self::Int64(y)) => *x == *y,
2123 (Self::String(x), Self::String(y)) => *x == *y,
2124 _ => false,
2125 }
2126 }
2127}
2128
2129impl ConfigSingleValue {
2130 #[inline]
2131 pub fn ordinal(&self) -> u64 {
2132 match *self {
2133 Self::Bool(_) => 1,
2134 Self::Uint8(_) => 2,
2135 Self::Uint16(_) => 3,
2136 Self::Uint32(_) => 4,
2137 Self::Uint64(_) => 5,
2138 Self::Int8(_) => 6,
2139 Self::Int16(_) => 7,
2140 Self::Int32(_) => 8,
2141 Self::Int64(_) => 9,
2142 Self::String(_) => 10,
2143 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2144 }
2145 }
2146
2147 #[inline]
2148 pub fn unknown_variant_for_testing() -> Self {
2149 Self::__SourceBreaking { unknown_ordinal: 0 }
2150 }
2151
2152 #[inline]
2153 pub fn is_unknown(&self) -> bool {
2154 match self {
2155 Self::__SourceBreaking { .. } => true,
2156 _ => false,
2157 }
2158 }
2159}
2160
2161impl fidl::Persistable for ConfigSingleValue {}
2162
2163#[derive(Clone, Debug)]
2167pub enum ConfigValue {
2168 Single(ConfigSingleValue),
2169 Vector(ConfigVectorValue),
2170 #[doc(hidden)]
2171 __SourceBreaking {
2172 unknown_ordinal: u64,
2173 },
2174}
2175
2176#[macro_export]
2178macro_rules! ConfigValueUnknown {
2179 () => {
2180 _
2181 };
2182}
2183
2184impl PartialEq for ConfigValue {
2186 fn eq(&self, other: &Self) -> bool {
2187 match (self, other) {
2188 (Self::Single(x), Self::Single(y)) => *x == *y,
2189 (Self::Vector(x), Self::Vector(y)) => *x == *y,
2190 _ => false,
2191 }
2192 }
2193}
2194
2195impl ConfigValue {
2196 #[inline]
2197 pub fn ordinal(&self) -> u64 {
2198 match *self {
2199 Self::Single(_) => 1,
2200 Self::Vector(_) => 2,
2201 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2202 }
2203 }
2204
2205 #[inline]
2206 pub fn unknown_variant_for_testing() -> Self {
2207 Self::__SourceBreaking { unknown_ordinal: 0 }
2208 }
2209
2210 #[inline]
2211 pub fn is_unknown(&self) -> bool {
2212 match self {
2213 Self::__SourceBreaking { .. } => true,
2214 _ => false,
2215 }
2216 }
2217}
2218
2219impl fidl::Persistable for ConfigValue {}
2220
2221#[derive(Clone, Debug)]
2223pub enum ConfigValueSource {
2224 PackagePath(String),
2226 Capabilities(ConfigSourceCapabilities),
2228 #[doc(hidden)]
2229 __SourceBreaking { unknown_ordinal: u64 },
2230}
2231
2232#[macro_export]
2234macro_rules! ConfigValueSourceUnknown {
2235 () => {
2236 _
2237 };
2238}
2239
2240impl PartialEq for ConfigValueSource {
2242 fn eq(&self, other: &Self) -> bool {
2243 match (self, other) {
2244 (Self::PackagePath(x), Self::PackagePath(y)) => *x == *y,
2245 (Self::Capabilities(x), Self::Capabilities(y)) => *x == *y,
2246 _ => false,
2247 }
2248 }
2249}
2250
2251impl ConfigValueSource {
2252 #[inline]
2253 pub fn ordinal(&self) -> u64 {
2254 match *self {
2255 Self::PackagePath(_) => 1,
2256 Self::Capabilities(_) => 2,
2257 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2258 }
2259 }
2260
2261 #[inline]
2262 pub fn unknown_variant_for_testing() -> Self {
2263 Self::__SourceBreaking { unknown_ordinal: 0 }
2264 }
2265
2266 #[inline]
2267 pub fn is_unknown(&self) -> bool {
2268 match self {
2269 Self::__SourceBreaking { .. } => true,
2270 _ => false,
2271 }
2272 }
2273}
2274
2275impl fidl::Persistable for ConfigValueSource {}
2276
2277#[derive(Clone, Debug)]
2279pub enum ConfigVectorValue {
2280 BoolVector(Vec<bool>),
2281 Uint8Vector(Vec<u8>),
2282 Uint16Vector(Vec<u16>),
2283 Uint32Vector(Vec<u32>),
2284 Uint64Vector(Vec<u64>),
2285 Int8Vector(Vec<i8>),
2286 Int16Vector(Vec<i16>),
2287 Int32Vector(Vec<i32>),
2288 Int64Vector(Vec<i64>),
2289 StringVector(Vec<String>),
2290 #[doc(hidden)]
2291 __SourceBreaking {
2292 unknown_ordinal: u64,
2293 },
2294}
2295
2296#[macro_export]
2298macro_rules! ConfigVectorValueUnknown {
2299 () => {
2300 _
2301 };
2302}
2303
2304impl PartialEq for ConfigVectorValue {
2306 fn eq(&self, other: &Self) -> bool {
2307 match (self, other) {
2308 (Self::BoolVector(x), Self::BoolVector(y)) => *x == *y,
2309 (Self::Uint8Vector(x), Self::Uint8Vector(y)) => *x == *y,
2310 (Self::Uint16Vector(x), Self::Uint16Vector(y)) => *x == *y,
2311 (Self::Uint32Vector(x), Self::Uint32Vector(y)) => *x == *y,
2312 (Self::Uint64Vector(x), Self::Uint64Vector(y)) => *x == *y,
2313 (Self::Int8Vector(x), Self::Int8Vector(y)) => *x == *y,
2314 (Self::Int16Vector(x), Self::Int16Vector(y)) => *x == *y,
2315 (Self::Int32Vector(x), Self::Int32Vector(y)) => *x == *y,
2316 (Self::Int64Vector(x), Self::Int64Vector(y)) => *x == *y,
2317 (Self::StringVector(x), Self::StringVector(y)) => *x == *y,
2318 _ => false,
2319 }
2320 }
2321}
2322
2323impl ConfigVectorValue {
2324 #[inline]
2325 pub fn ordinal(&self) -> u64 {
2326 match *self {
2327 Self::BoolVector(_) => 1,
2328 Self::Uint8Vector(_) => 2,
2329 Self::Uint16Vector(_) => 3,
2330 Self::Uint32Vector(_) => 4,
2331 Self::Uint64Vector(_) => 5,
2332 Self::Int8Vector(_) => 6,
2333 Self::Int16Vector(_) => 7,
2334 Self::Int32Vector(_) => 8,
2335 Self::Int64Vector(_) => 9,
2336 Self::StringVector(_) => 10,
2337 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2338 }
2339 }
2340
2341 #[inline]
2342 pub fn unknown_variant_for_testing() -> Self {
2343 Self::__SourceBreaking { unknown_ordinal: 0 }
2344 }
2345
2346 #[inline]
2347 pub fn is_unknown(&self) -> bool {
2348 match self {
2349 Self::__SourceBreaking { .. } => true,
2350 _ => false,
2351 }
2352 }
2353}
2354
2355impl fidl::Persistable for ConfigVectorValue {}
2356
2357#[derive(Clone, Debug)]
2359pub enum DebugRegistration {
2360 Protocol(DebugProtocolRegistration),
2361 #[doc(hidden)]
2362 __SourceBreaking {
2363 unknown_ordinal: u64,
2364 },
2365}
2366
2367#[macro_export]
2369macro_rules! DebugRegistrationUnknown {
2370 () => {
2371 _
2372 };
2373}
2374
2375impl PartialEq for DebugRegistration {
2377 fn eq(&self, other: &Self) -> bool {
2378 match (self, other) {
2379 (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
2380 _ => false,
2381 }
2382 }
2383}
2384
2385impl DebugRegistration {
2386 #[inline]
2387 pub fn ordinal(&self) -> u64 {
2388 match *self {
2389 Self::Protocol(_) => 1,
2390 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2391 }
2392 }
2393
2394 #[inline]
2395 pub fn unknown_variant_for_testing() -> Self {
2396 Self::__SourceBreaking { unknown_ordinal: 0 }
2397 }
2398
2399 #[inline]
2400 pub fn is_unknown(&self) -> bool {
2401 match self {
2402 Self::__SourceBreaking { .. } => true,
2403 _ => false,
2404 }
2405 }
2406}
2407
2408impl fidl::Persistable for DebugRegistration {}
2409
2410#[derive(Clone, Debug)]
2414pub enum Expose {
2415 Service(ExposeService),
2416 Protocol(ExposeProtocol),
2417 Directory(ExposeDirectory),
2418 Runner(ExposeRunner),
2419 Resolver(ExposeResolver),
2420 Dictionary(ExposeDictionary),
2421 Config(ExposeConfiguration),
2422 #[doc(hidden)]
2423 __SourceBreaking {
2424 unknown_ordinal: u64,
2425 },
2426}
2427
2428#[macro_export]
2430macro_rules! ExposeUnknown {
2431 () => {
2432 _
2433 };
2434}
2435
2436impl PartialEq for Expose {
2438 fn eq(&self, other: &Self) -> bool {
2439 match (self, other) {
2440 (Self::Service(x), Self::Service(y)) => *x == *y,
2441 (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
2442 (Self::Directory(x), Self::Directory(y)) => *x == *y,
2443 (Self::Runner(x), Self::Runner(y)) => *x == *y,
2444 (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
2445 (Self::Dictionary(x), Self::Dictionary(y)) => *x == *y,
2446 (Self::Config(x), Self::Config(y)) => *x == *y,
2447 _ => false,
2448 }
2449 }
2450}
2451
2452impl Expose {
2453 #[inline]
2454 pub fn ordinal(&self) -> u64 {
2455 match *self {
2456 Self::Service(_) => 1,
2457 Self::Protocol(_) => 2,
2458 Self::Directory(_) => 3,
2459 Self::Runner(_) => 4,
2460 Self::Resolver(_) => 5,
2461 Self::Dictionary(_) => 7,
2462 Self::Config(_) => 8,
2463 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2464 }
2465 }
2466
2467 #[inline]
2468 pub fn unknown_variant_for_testing() -> Self {
2469 Self::__SourceBreaking { unknown_ordinal: 0 }
2470 }
2471
2472 #[inline]
2473 pub fn is_unknown(&self) -> bool {
2474 match self {
2475 Self::__SourceBreaking { .. } => true,
2476 _ => false,
2477 }
2478 }
2479}
2480
2481impl fidl::Persistable for Expose {}
2482
2483#[derive(Clone, Debug)]
2484pub enum LayoutConstraint {
2485 MaxSize(u32),
2486 #[doc(hidden)]
2487 __SourceBreaking {
2488 unknown_ordinal: u64,
2489 },
2490}
2491
2492#[macro_export]
2494macro_rules! LayoutConstraintUnknown {
2495 () => {
2496 _
2497 };
2498}
2499
2500impl PartialEq for LayoutConstraint {
2502 fn eq(&self, other: &Self) -> bool {
2503 match (self, other) {
2504 (Self::MaxSize(x), Self::MaxSize(y)) => *x == *y,
2505 _ => false,
2506 }
2507 }
2508}
2509
2510impl LayoutConstraint {
2511 #[inline]
2512 pub fn ordinal(&self) -> u64 {
2513 match *self {
2514 Self::MaxSize(_) => 1,
2515 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2516 }
2517 }
2518
2519 #[inline]
2520 pub fn unknown_variant_for_testing() -> Self {
2521 Self::__SourceBreaking { unknown_ordinal: 0 }
2522 }
2523
2524 #[inline]
2525 pub fn is_unknown(&self) -> bool {
2526 match self {
2527 Self::__SourceBreaking { .. } => true,
2528 _ => false,
2529 }
2530 }
2531}
2532
2533impl fidl::Persistable for LayoutConstraint {}
2534
2535#[derive(Clone, Debug)]
2536pub enum LayoutParameter {
2537 NestedType(ConfigType),
2538 #[doc(hidden)]
2539 __SourceBreaking {
2540 unknown_ordinal: u64,
2541 },
2542}
2543
2544#[macro_export]
2546macro_rules! LayoutParameterUnknown {
2547 () => {
2548 _
2549 };
2550}
2551
2552impl PartialEq for LayoutParameter {
2554 fn eq(&self, other: &Self) -> bool {
2555 match (self, other) {
2556 (Self::NestedType(x), Self::NestedType(y)) => *x == *y,
2557 _ => false,
2558 }
2559 }
2560}
2561
2562impl LayoutParameter {
2563 #[inline]
2564 pub fn ordinal(&self) -> u64 {
2565 match *self {
2566 Self::NestedType(_) => 1,
2567 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2568 }
2569 }
2570
2571 #[inline]
2572 pub fn unknown_variant_for_testing() -> Self {
2573 Self::__SourceBreaking { unknown_ordinal: 0 }
2574 }
2575
2576 #[inline]
2577 pub fn is_unknown(&self) -> bool {
2578 match self {
2579 Self::__SourceBreaking { .. } => true,
2580 _ => false,
2581 }
2582 }
2583}
2584
2585impl fidl::Persistable for LayoutParameter {}
2586
2587#[derive(Clone, Debug)]
2591pub enum Offer {
2592 Service(OfferService),
2593 Protocol(OfferProtocol),
2594 Directory(OfferDirectory),
2595 Storage(OfferStorage),
2596 Runner(OfferRunner),
2597 Resolver(OfferResolver),
2598 EventStream(OfferEventStream),
2599 Dictionary(OfferDictionary),
2600 Config(OfferConfiguration),
2601 #[doc(hidden)]
2602 __SourceBreaking {
2603 unknown_ordinal: u64,
2604 },
2605}
2606
2607#[macro_export]
2609macro_rules! OfferUnknown {
2610 () => {
2611 _
2612 };
2613}
2614
2615impl PartialEq for Offer {
2617 fn eq(&self, other: &Self) -> bool {
2618 match (self, other) {
2619 (Self::Service(x), Self::Service(y)) => *x == *y,
2620 (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
2621 (Self::Directory(x), Self::Directory(y)) => *x == *y,
2622 (Self::Storage(x), Self::Storage(y)) => *x == *y,
2623 (Self::Runner(x), Self::Runner(y)) => *x == *y,
2624 (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
2625 (Self::EventStream(x), Self::EventStream(y)) => *x == *y,
2626 (Self::Dictionary(x), Self::Dictionary(y)) => *x == *y,
2627 (Self::Config(x), Self::Config(y)) => *x == *y,
2628 _ => false,
2629 }
2630 }
2631}
2632
2633impl Offer {
2634 #[inline]
2635 pub fn ordinal(&self) -> u64 {
2636 match *self {
2637 Self::Service(_) => 1,
2638 Self::Protocol(_) => 2,
2639 Self::Directory(_) => 3,
2640 Self::Storage(_) => 4,
2641 Self::Runner(_) => 5,
2642 Self::Resolver(_) => 6,
2643 Self::EventStream(_) => 8,
2644 Self::Dictionary(_) => 9,
2645 Self::Config(_) => 10,
2646 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2647 }
2648 }
2649
2650 #[inline]
2651 pub fn unknown_variant_for_testing() -> Self {
2652 Self::__SourceBreaking { unknown_ordinal: 0 }
2653 }
2654
2655 #[inline]
2656 pub fn is_unknown(&self) -> bool {
2657 match self {
2658 Self::__SourceBreaking { .. } => true,
2659 _ => false,
2660 }
2661 }
2662}
2663
2664impl fidl::Persistable for Offer {}
2665
2666#[derive(Clone, Debug)]
2669pub enum Ref {
2670 Parent(ParentRef),
2671 Self_(SelfRef),
2672 Child(ChildRef),
2673 Collection(CollectionRef),
2674 Framework(FrameworkRef),
2675 Capability(CapabilityRef),
2676 Debug(DebugRef),
2677 VoidType(VoidRef),
2678 Environment(EnvironmentRef),
2679 #[doc(hidden)]
2680 __SourceBreaking {
2681 unknown_ordinal: u64,
2682 },
2683}
2684
2685#[macro_export]
2687macro_rules! RefUnknown {
2688 () => {
2689 _
2690 };
2691}
2692
2693impl PartialEq for Ref {
2695 fn eq(&self, other: &Self) -> bool {
2696 match (self, other) {
2697 (Self::Parent(x), Self::Parent(y)) => *x == *y,
2698 (Self::Self_(x), Self::Self_(y)) => *x == *y,
2699 (Self::Child(x), Self::Child(y)) => *x == *y,
2700 (Self::Collection(x), Self::Collection(y)) => *x == *y,
2701 (Self::Framework(x), Self::Framework(y)) => *x == *y,
2702 (Self::Capability(x), Self::Capability(y)) => *x == *y,
2703 (Self::Debug(x), Self::Debug(y)) => *x == *y,
2704 (Self::VoidType(x), Self::VoidType(y)) => *x == *y,
2705 (Self::Environment(x), Self::Environment(y)) => *x == *y,
2706 _ => false,
2707 }
2708 }
2709}
2710
2711impl Ref {
2712 #[inline]
2713 pub fn ordinal(&self) -> u64 {
2714 match *self {
2715 Self::Parent(_) => 1,
2716 Self::Self_(_) => 2,
2717 Self::Child(_) => 3,
2718 Self::Collection(_) => 4,
2719 Self::Framework(_) => 5,
2720 Self::Capability(_) => 6,
2721 Self::Debug(_) => 7,
2722 Self::VoidType(_) => 8,
2723 Self::Environment(_) => 9,
2724 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2725 }
2726 }
2727
2728 #[inline]
2729 pub fn unknown_variant_for_testing() -> Self {
2730 Self::__SourceBreaking { unknown_ordinal: 0 }
2731 }
2732
2733 #[inline]
2734 pub fn is_unknown(&self) -> bool {
2735 match self {
2736 Self::__SourceBreaking { .. } => true,
2737 _ => false,
2738 }
2739 }
2740}
2741
2742impl fidl::Persistable for Ref {}
2743
2744#[derive(Clone, Debug)]
2746pub enum Use {
2747 Service(UseService),
2748 Protocol(UseProtocol),
2749 Directory(UseDirectory),
2750 Storage(UseStorage),
2751 EventStream(UseEventStream),
2752 Runner(UseRunner),
2753 Config(UseConfiguration),
2754 #[doc(hidden)]
2755 __SourceBreaking {
2756 unknown_ordinal: u64,
2757 },
2758}
2759
2760#[macro_export]
2762macro_rules! UseUnknown {
2763 () => {
2764 _
2765 };
2766}
2767
2768impl PartialEq for Use {
2770 fn eq(&self, other: &Self) -> bool {
2771 match (self, other) {
2772 (Self::Service(x), Self::Service(y)) => *x == *y,
2773 (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
2774 (Self::Directory(x), Self::Directory(y)) => *x == *y,
2775 (Self::Storage(x), Self::Storage(y)) => *x == *y,
2776 (Self::EventStream(x), Self::EventStream(y)) => *x == *y,
2777 (Self::Runner(x), Self::Runner(y)) => *x == *y,
2778 (Self::Config(x), Self::Config(y)) => *x == *y,
2779 _ => false,
2780 }
2781 }
2782}
2783
2784impl Use {
2785 #[inline]
2786 pub fn ordinal(&self) -> u64 {
2787 match *self {
2788 Self::Service(_) => 1,
2789 Self::Protocol(_) => 2,
2790 Self::Directory(_) => 3,
2791 Self::Storage(_) => 4,
2792 Self::EventStream(_) => 7,
2793 Self::Runner(_) => 8,
2794 Self::Config(_) => 9,
2795 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2796 }
2797 }
2798
2799 #[inline]
2800 pub fn unknown_variant_for_testing() -> Self {
2801 Self::__SourceBreaking { unknown_ordinal: 0 }
2802 }
2803
2804 #[inline]
2805 pub fn is_unknown(&self) -> bool {
2806 match self {
2807 Self::__SourceBreaking { .. } => true,
2808 _ => false,
2809 }
2810 }
2811}
2812
2813impl fidl::Persistable for Use {}
2814
2815mod internal {
2816 use super::*;
2817 unsafe impl fidl::encoding::TypeMarker for ConfigMutability {
2818 type Owned = Self;
2819
2820 #[inline(always)]
2821 fn inline_align(_context: fidl::encoding::Context) -> usize {
2822 4
2823 }
2824
2825 #[inline(always)]
2826 fn inline_size(_context: fidl::encoding::Context) -> usize {
2827 4
2828 }
2829 }
2830
2831 impl fidl::encoding::ValueTypeMarker for ConfigMutability {
2832 type Borrowed<'a> = Self;
2833 #[inline(always)]
2834 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2835 *value
2836 }
2837 }
2838
2839 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2840 for ConfigMutability
2841 {
2842 #[inline]
2843 unsafe fn encode(
2844 self,
2845 encoder: &mut fidl::encoding::Encoder<'_, D>,
2846 offset: usize,
2847 _depth: fidl::encoding::Depth,
2848 ) -> fidl::Result<()> {
2849 encoder.debug_check_bounds::<Self>(offset);
2850 encoder.write_num(self.bits(), offset);
2851 Ok(())
2852 }
2853 }
2854
2855 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigMutability {
2856 #[inline(always)]
2857 fn new_empty() -> Self {
2858 Self::empty()
2859 }
2860
2861 #[inline]
2862 unsafe fn decode(
2863 &mut self,
2864 decoder: &mut fidl::encoding::Decoder<'_, D>,
2865 offset: usize,
2866 _depth: fidl::encoding::Depth,
2867 ) -> fidl::Result<()> {
2868 decoder.debug_check_bounds::<Self>(offset);
2869 let prim = decoder.read_num::<u32>(offset);
2870 *self = Self::from_bits_allow_unknown(prim);
2871 Ok(())
2872 }
2873 }
2874 unsafe impl fidl::encoding::TypeMarker for AllowedOffers {
2875 type Owned = Self;
2876
2877 #[inline(always)]
2878 fn inline_align(_context: fidl::encoding::Context) -> usize {
2879 std::mem::align_of::<u32>()
2880 }
2881
2882 #[inline(always)]
2883 fn inline_size(_context: fidl::encoding::Context) -> usize {
2884 std::mem::size_of::<u32>()
2885 }
2886
2887 #[inline(always)]
2888 fn encode_is_copy() -> bool {
2889 true
2890 }
2891
2892 #[inline(always)]
2893 fn decode_is_copy() -> bool {
2894 false
2895 }
2896 }
2897
2898 impl fidl::encoding::ValueTypeMarker for AllowedOffers {
2899 type Borrowed<'a> = Self;
2900 #[inline(always)]
2901 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2902 *value
2903 }
2904 }
2905
2906 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AllowedOffers {
2907 #[inline]
2908 unsafe fn encode(
2909 self,
2910 encoder: &mut fidl::encoding::Encoder<'_, D>,
2911 offset: usize,
2912 _depth: fidl::encoding::Depth,
2913 ) -> fidl::Result<()> {
2914 encoder.debug_check_bounds::<Self>(offset);
2915 encoder.write_num(self.into_primitive(), offset);
2916 Ok(())
2917 }
2918 }
2919
2920 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowedOffers {
2921 #[inline(always)]
2922 fn new_empty() -> Self {
2923 Self::StaticOnly
2924 }
2925
2926 #[inline]
2927 unsafe fn decode(
2928 &mut self,
2929 decoder: &mut fidl::encoding::Decoder<'_, D>,
2930 offset: usize,
2931 _depth: fidl::encoding::Depth,
2932 ) -> fidl::Result<()> {
2933 decoder.debug_check_bounds::<Self>(offset);
2934 let prim = decoder.read_num::<u32>(offset);
2935
2936 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2937 Ok(())
2938 }
2939 }
2940 unsafe impl fidl::encoding::TypeMarker for Availability {
2941 type Owned = Self;
2942
2943 #[inline(always)]
2944 fn inline_align(_context: fidl::encoding::Context) -> usize {
2945 std::mem::align_of::<u32>()
2946 }
2947
2948 #[inline(always)]
2949 fn inline_size(_context: fidl::encoding::Context) -> usize {
2950 std::mem::size_of::<u32>()
2951 }
2952
2953 #[inline(always)]
2954 fn encode_is_copy() -> bool {
2955 true
2956 }
2957
2958 #[inline(always)]
2959 fn decode_is_copy() -> bool {
2960 false
2961 }
2962 }
2963
2964 impl fidl::encoding::ValueTypeMarker for Availability {
2965 type Borrowed<'a> = Self;
2966 #[inline(always)]
2967 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2968 *value
2969 }
2970 }
2971
2972 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Availability {
2973 #[inline]
2974 unsafe fn encode(
2975 self,
2976 encoder: &mut fidl::encoding::Encoder<'_, D>,
2977 offset: usize,
2978 _depth: fidl::encoding::Depth,
2979 ) -> fidl::Result<()> {
2980 encoder.debug_check_bounds::<Self>(offset);
2981 encoder.write_num(self.into_primitive(), offset);
2982 Ok(())
2983 }
2984 }
2985
2986 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Availability {
2987 #[inline(always)]
2988 fn new_empty() -> Self {
2989 Self::Required
2990 }
2991
2992 #[inline]
2993 unsafe fn decode(
2994 &mut self,
2995 decoder: &mut fidl::encoding::Decoder<'_, D>,
2996 offset: usize,
2997 _depth: fidl::encoding::Depth,
2998 ) -> fidl::Result<()> {
2999 decoder.debug_check_bounds::<Self>(offset);
3000 let prim = decoder.read_num::<u32>(offset);
3001
3002 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3003 Ok(())
3004 }
3005 }
3006 unsafe impl fidl::encoding::TypeMarker for ConfigTypeLayout {
3007 type Owned = Self;
3008
3009 #[inline(always)]
3010 fn inline_align(_context: fidl::encoding::Context) -> usize {
3011 std::mem::align_of::<u32>()
3012 }
3013
3014 #[inline(always)]
3015 fn inline_size(_context: fidl::encoding::Context) -> usize {
3016 std::mem::size_of::<u32>()
3017 }
3018
3019 #[inline(always)]
3020 fn encode_is_copy() -> bool {
3021 false
3022 }
3023
3024 #[inline(always)]
3025 fn decode_is_copy() -> bool {
3026 false
3027 }
3028 }
3029
3030 impl fidl::encoding::ValueTypeMarker for ConfigTypeLayout {
3031 type Borrowed<'a> = Self;
3032 #[inline(always)]
3033 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3034 *value
3035 }
3036 }
3037
3038 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3039 for ConfigTypeLayout
3040 {
3041 #[inline]
3042 unsafe fn encode(
3043 self,
3044 encoder: &mut fidl::encoding::Encoder<'_, D>,
3045 offset: usize,
3046 _depth: fidl::encoding::Depth,
3047 ) -> fidl::Result<()> {
3048 encoder.debug_check_bounds::<Self>(offset);
3049 encoder.write_num(self.into_primitive(), offset);
3050 Ok(())
3051 }
3052 }
3053
3054 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigTypeLayout {
3055 #[inline(always)]
3056 fn new_empty() -> Self {
3057 Self::unknown()
3058 }
3059
3060 #[inline]
3061 unsafe fn decode(
3062 &mut self,
3063 decoder: &mut fidl::encoding::Decoder<'_, D>,
3064 offset: usize,
3065 _depth: fidl::encoding::Depth,
3066 ) -> fidl::Result<()> {
3067 decoder.debug_check_bounds::<Self>(offset);
3068 let prim = decoder.read_num::<u32>(offset);
3069
3070 *self = Self::from_primitive_allow_unknown(prim);
3071 Ok(())
3072 }
3073 }
3074 unsafe impl fidl::encoding::TypeMarker for DeliveryType {
3075 type Owned = Self;
3076
3077 #[inline(always)]
3078 fn inline_align(_context: fidl::encoding::Context) -> usize {
3079 std::mem::align_of::<u32>()
3080 }
3081
3082 #[inline(always)]
3083 fn inline_size(_context: fidl::encoding::Context) -> usize {
3084 std::mem::size_of::<u32>()
3085 }
3086
3087 #[inline(always)]
3088 fn encode_is_copy() -> bool {
3089 false
3090 }
3091
3092 #[inline(always)]
3093 fn decode_is_copy() -> bool {
3094 false
3095 }
3096 }
3097
3098 impl fidl::encoding::ValueTypeMarker for DeliveryType {
3099 type Borrowed<'a> = Self;
3100 #[inline(always)]
3101 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3102 *value
3103 }
3104 }
3105
3106 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeliveryType {
3107 #[inline]
3108 unsafe fn encode(
3109 self,
3110 encoder: &mut fidl::encoding::Encoder<'_, D>,
3111 offset: usize,
3112 _depth: fidl::encoding::Depth,
3113 ) -> fidl::Result<()> {
3114 encoder.debug_check_bounds::<Self>(offset);
3115 encoder.write_num(self.into_primitive(), offset);
3116 Ok(())
3117 }
3118 }
3119
3120 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeliveryType {
3121 #[inline(always)]
3122 fn new_empty() -> Self {
3123 Self::unknown()
3124 }
3125
3126 #[inline]
3127 unsafe fn decode(
3128 &mut self,
3129 decoder: &mut fidl::encoding::Decoder<'_, D>,
3130 offset: usize,
3131 _depth: fidl::encoding::Depth,
3132 ) -> fidl::Result<()> {
3133 decoder.debug_check_bounds::<Self>(offset);
3134 let prim = decoder.read_num::<u32>(offset);
3135
3136 *self = Self::from_primitive_allow_unknown(prim);
3137 Ok(())
3138 }
3139 }
3140 unsafe impl fidl::encoding::TypeMarker for DependencyType {
3141 type Owned = Self;
3142
3143 #[inline(always)]
3144 fn inline_align(_context: fidl::encoding::Context) -> usize {
3145 std::mem::align_of::<u32>()
3146 }
3147
3148 #[inline(always)]
3149 fn inline_size(_context: fidl::encoding::Context) -> usize {
3150 std::mem::size_of::<u32>()
3151 }
3152
3153 #[inline(always)]
3154 fn encode_is_copy() -> bool {
3155 true
3156 }
3157
3158 #[inline(always)]
3159 fn decode_is_copy() -> bool {
3160 false
3161 }
3162 }
3163
3164 impl fidl::encoding::ValueTypeMarker for DependencyType {
3165 type Borrowed<'a> = Self;
3166 #[inline(always)]
3167 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3168 *value
3169 }
3170 }
3171
3172 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DependencyType {
3173 #[inline]
3174 unsafe fn encode(
3175 self,
3176 encoder: &mut fidl::encoding::Encoder<'_, D>,
3177 offset: usize,
3178 _depth: fidl::encoding::Depth,
3179 ) -> fidl::Result<()> {
3180 encoder.debug_check_bounds::<Self>(offset);
3181 encoder.write_num(self.into_primitive(), offset);
3182 Ok(())
3183 }
3184 }
3185
3186 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DependencyType {
3187 #[inline(always)]
3188 fn new_empty() -> Self {
3189 Self::Strong
3190 }
3191
3192 #[inline]
3193 unsafe fn decode(
3194 &mut self,
3195 decoder: &mut fidl::encoding::Decoder<'_, D>,
3196 offset: usize,
3197 _depth: fidl::encoding::Depth,
3198 ) -> fidl::Result<()> {
3199 decoder.debug_check_bounds::<Self>(offset);
3200 let prim = decoder.read_num::<u32>(offset);
3201
3202 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3203 Ok(())
3204 }
3205 }
3206 unsafe impl fidl::encoding::TypeMarker for Durability {
3207 type Owned = Self;
3208
3209 #[inline(always)]
3210 fn inline_align(_context: fidl::encoding::Context) -> usize {
3211 std::mem::align_of::<u32>()
3212 }
3213
3214 #[inline(always)]
3215 fn inline_size(_context: fidl::encoding::Context) -> usize {
3216 std::mem::size_of::<u32>()
3217 }
3218
3219 #[inline(always)]
3220 fn encode_is_copy() -> bool {
3221 true
3222 }
3223
3224 #[inline(always)]
3225 fn decode_is_copy() -> bool {
3226 false
3227 }
3228 }
3229
3230 impl fidl::encoding::ValueTypeMarker for Durability {
3231 type Borrowed<'a> = Self;
3232 #[inline(always)]
3233 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3234 *value
3235 }
3236 }
3237
3238 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Durability {
3239 #[inline]
3240 unsafe fn encode(
3241 self,
3242 encoder: &mut fidl::encoding::Encoder<'_, D>,
3243 offset: usize,
3244 _depth: fidl::encoding::Depth,
3245 ) -> fidl::Result<()> {
3246 encoder.debug_check_bounds::<Self>(offset);
3247 encoder.write_num(self.into_primitive(), offset);
3248 Ok(())
3249 }
3250 }
3251
3252 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Durability {
3253 #[inline(always)]
3254 fn new_empty() -> Self {
3255 Self::Transient
3256 }
3257
3258 #[inline]
3259 unsafe fn decode(
3260 &mut self,
3261 decoder: &mut fidl::encoding::Decoder<'_, D>,
3262 offset: usize,
3263 _depth: fidl::encoding::Depth,
3264 ) -> fidl::Result<()> {
3265 decoder.debug_check_bounds::<Self>(offset);
3266 let prim = decoder.read_num::<u32>(offset);
3267
3268 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3269 Ok(())
3270 }
3271 }
3272 unsafe impl fidl::encoding::TypeMarker for EnvironmentExtends {
3273 type Owned = Self;
3274
3275 #[inline(always)]
3276 fn inline_align(_context: fidl::encoding::Context) -> usize {
3277 std::mem::align_of::<u32>()
3278 }
3279
3280 #[inline(always)]
3281 fn inline_size(_context: fidl::encoding::Context) -> usize {
3282 std::mem::size_of::<u32>()
3283 }
3284
3285 #[inline(always)]
3286 fn encode_is_copy() -> bool {
3287 true
3288 }
3289
3290 #[inline(always)]
3291 fn decode_is_copy() -> bool {
3292 false
3293 }
3294 }
3295
3296 impl fidl::encoding::ValueTypeMarker for EnvironmentExtends {
3297 type Borrowed<'a> = Self;
3298 #[inline(always)]
3299 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3300 *value
3301 }
3302 }
3303
3304 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3305 for EnvironmentExtends
3306 {
3307 #[inline]
3308 unsafe fn encode(
3309 self,
3310 encoder: &mut fidl::encoding::Encoder<'_, D>,
3311 offset: usize,
3312 _depth: fidl::encoding::Depth,
3313 ) -> fidl::Result<()> {
3314 encoder.debug_check_bounds::<Self>(offset);
3315 encoder.write_num(self.into_primitive(), offset);
3316 Ok(())
3317 }
3318 }
3319
3320 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentExtends {
3321 #[inline(always)]
3322 fn new_empty() -> Self {
3323 Self::None
3324 }
3325
3326 #[inline]
3327 unsafe fn decode(
3328 &mut self,
3329 decoder: &mut fidl::encoding::Decoder<'_, D>,
3330 offset: usize,
3331 _depth: fidl::encoding::Depth,
3332 ) -> fidl::Result<()> {
3333 decoder.debug_check_bounds::<Self>(offset);
3334 let prim = decoder.read_num::<u32>(offset);
3335
3336 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3337 Ok(())
3338 }
3339 }
3340 unsafe impl fidl::encoding::TypeMarker for OnTerminate {
3341 type Owned = Self;
3342
3343 #[inline(always)]
3344 fn inline_align(_context: fidl::encoding::Context) -> usize {
3345 std::mem::align_of::<u32>()
3346 }
3347
3348 #[inline(always)]
3349 fn inline_size(_context: fidl::encoding::Context) -> usize {
3350 std::mem::size_of::<u32>()
3351 }
3352
3353 #[inline(always)]
3354 fn encode_is_copy() -> bool {
3355 true
3356 }
3357
3358 #[inline(always)]
3359 fn decode_is_copy() -> bool {
3360 false
3361 }
3362 }
3363
3364 impl fidl::encoding::ValueTypeMarker for OnTerminate {
3365 type Borrowed<'a> = Self;
3366 #[inline(always)]
3367 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3368 *value
3369 }
3370 }
3371
3372 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OnTerminate {
3373 #[inline]
3374 unsafe fn encode(
3375 self,
3376 encoder: &mut fidl::encoding::Encoder<'_, D>,
3377 offset: usize,
3378 _depth: fidl::encoding::Depth,
3379 ) -> fidl::Result<()> {
3380 encoder.debug_check_bounds::<Self>(offset);
3381 encoder.write_num(self.into_primitive(), offset);
3382 Ok(())
3383 }
3384 }
3385
3386 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OnTerminate {
3387 #[inline(always)]
3388 fn new_empty() -> Self {
3389 Self::None
3390 }
3391
3392 #[inline]
3393 unsafe fn decode(
3394 &mut self,
3395 decoder: &mut fidl::encoding::Decoder<'_, D>,
3396 offset: usize,
3397 _depth: fidl::encoding::Depth,
3398 ) -> fidl::Result<()> {
3399 decoder.debug_check_bounds::<Self>(offset);
3400 let prim = decoder.read_num::<u32>(offset);
3401
3402 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3403 Ok(())
3404 }
3405 }
3406 unsafe impl fidl::encoding::TypeMarker for StartupMode {
3407 type Owned = Self;
3408
3409 #[inline(always)]
3410 fn inline_align(_context: fidl::encoding::Context) -> usize {
3411 std::mem::align_of::<u32>()
3412 }
3413
3414 #[inline(always)]
3415 fn inline_size(_context: fidl::encoding::Context) -> usize {
3416 std::mem::size_of::<u32>()
3417 }
3418
3419 #[inline(always)]
3420 fn encode_is_copy() -> bool {
3421 true
3422 }
3423
3424 #[inline(always)]
3425 fn decode_is_copy() -> bool {
3426 false
3427 }
3428 }
3429
3430 impl fidl::encoding::ValueTypeMarker for StartupMode {
3431 type Borrowed<'a> = Self;
3432 #[inline(always)]
3433 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3434 *value
3435 }
3436 }
3437
3438 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StartupMode {
3439 #[inline]
3440 unsafe fn encode(
3441 self,
3442 encoder: &mut fidl::encoding::Encoder<'_, D>,
3443 offset: usize,
3444 _depth: fidl::encoding::Depth,
3445 ) -> fidl::Result<()> {
3446 encoder.debug_check_bounds::<Self>(offset);
3447 encoder.write_num(self.into_primitive(), offset);
3448 Ok(())
3449 }
3450 }
3451
3452 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartupMode {
3453 #[inline(always)]
3454 fn new_empty() -> Self {
3455 Self::Lazy
3456 }
3457
3458 #[inline]
3459 unsafe fn decode(
3460 &mut self,
3461 decoder: &mut fidl::encoding::Decoder<'_, D>,
3462 offset: usize,
3463 _depth: fidl::encoding::Depth,
3464 ) -> fidl::Result<()> {
3465 decoder.debug_check_bounds::<Self>(offset);
3466 let prim = decoder.read_num::<u32>(offset);
3467
3468 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3469 Ok(())
3470 }
3471 }
3472 unsafe impl fidl::encoding::TypeMarker for StorageId {
3473 type Owned = Self;
3474
3475 #[inline(always)]
3476 fn inline_align(_context: fidl::encoding::Context) -> usize {
3477 std::mem::align_of::<u32>()
3478 }
3479
3480 #[inline(always)]
3481 fn inline_size(_context: fidl::encoding::Context) -> usize {
3482 std::mem::size_of::<u32>()
3483 }
3484
3485 #[inline(always)]
3486 fn encode_is_copy() -> bool {
3487 true
3488 }
3489
3490 #[inline(always)]
3491 fn decode_is_copy() -> bool {
3492 false
3493 }
3494 }
3495
3496 impl fidl::encoding::ValueTypeMarker for StorageId {
3497 type Borrowed<'a> = Self;
3498 #[inline(always)]
3499 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3500 *value
3501 }
3502 }
3503
3504 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StorageId {
3505 #[inline]
3506 unsafe fn encode(
3507 self,
3508 encoder: &mut fidl::encoding::Encoder<'_, D>,
3509 offset: usize,
3510 _depth: fidl::encoding::Depth,
3511 ) -> fidl::Result<()> {
3512 encoder.debug_check_bounds::<Self>(offset);
3513 encoder.write_num(self.into_primitive(), offset);
3514 Ok(())
3515 }
3516 }
3517
3518 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StorageId {
3519 #[inline(always)]
3520 fn new_empty() -> Self {
3521 Self::StaticInstanceId
3522 }
3523
3524 #[inline]
3525 unsafe fn decode(
3526 &mut self,
3527 decoder: &mut fidl::encoding::Decoder<'_, D>,
3528 offset: usize,
3529 _depth: fidl::encoding::Depth,
3530 ) -> fidl::Result<()> {
3531 decoder.debug_check_bounds::<Self>(offset);
3532 let prim = decoder.read_num::<u32>(offset);
3533
3534 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3535 Ok(())
3536 }
3537 }
3538
3539 impl fidl::encoding::ValueTypeMarker for CapabilityRef {
3540 type Borrowed<'a> = &'a Self;
3541 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3542 value
3543 }
3544 }
3545
3546 unsafe impl fidl::encoding::TypeMarker for CapabilityRef {
3547 type Owned = Self;
3548
3549 #[inline(always)]
3550 fn inline_align(_context: fidl::encoding::Context) -> usize {
3551 8
3552 }
3553
3554 #[inline(always)]
3555 fn inline_size(_context: fidl::encoding::Context) -> usize {
3556 16
3557 }
3558 }
3559
3560 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CapabilityRef, D>
3561 for &CapabilityRef
3562 {
3563 #[inline]
3564 unsafe fn encode(
3565 self,
3566 encoder: &mut fidl::encoding::Encoder<'_, D>,
3567 offset: usize,
3568 _depth: fidl::encoding::Depth,
3569 ) -> fidl::Result<()> {
3570 encoder.debug_check_bounds::<CapabilityRef>(offset);
3571 fidl::encoding::Encode::<CapabilityRef, D>::encode(
3573 (<fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
3574 &self.name,
3575 ),),
3576 encoder,
3577 offset,
3578 _depth,
3579 )
3580 }
3581 }
3582 unsafe impl<
3583 D: fidl::encoding::ResourceDialect,
3584 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<100>, D>,
3585 > fidl::encoding::Encode<CapabilityRef, D> for (T0,)
3586 {
3587 #[inline]
3588 unsafe fn encode(
3589 self,
3590 encoder: &mut fidl::encoding::Encoder<'_, D>,
3591 offset: usize,
3592 depth: fidl::encoding::Depth,
3593 ) -> fidl::Result<()> {
3594 encoder.debug_check_bounds::<CapabilityRef>(offset);
3595 self.0.encode(encoder, offset + 0, depth)?;
3599 Ok(())
3600 }
3601 }
3602
3603 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CapabilityRef {
3604 #[inline(always)]
3605 fn new_empty() -> Self {
3606 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<100>, D) }
3607 }
3608
3609 #[inline]
3610 unsafe fn decode(
3611 &mut self,
3612 decoder: &mut fidl::encoding::Decoder<'_, D>,
3613 offset: usize,
3614 _depth: fidl::encoding::Depth,
3615 ) -> fidl::Result<()> {
3616 decoder.debug_check_bounds::<Self>(offset);
3617 fidl::decode!(
3619 fidl::encoding::BoundedString<100>,
3620 D,
3621 &mut self.name,
3622 decoder,
3623 offset + 0,
3624 _depth
3625 )?;
3626 Ok(())
3627 }
3628 }
3629
3630 impl fidl::encoding::ValueTypeMarker for ChildRef {
3631 type Borrowed<'a> = &'a Self;
3632 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3633 value
3634 }
3635 }
3636
3637 unsafe impl fidl::encoding::TypeMarker for ChildRef {
3638 type Owned = Self;
3639
3640 #[inline(always)]
3641 fn inline_align(_context: fidl::encoding::Context) -> usize {
3642 8
3643 }
3644
3645 #[inline(always)]
3646 fn inline_size(_context: fidl::encoding::Context) -> usize {
3647 32
3648 }
3649 }
3650
3651 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChildRef, D> for &ChildRef {
3652 #[inline]
3653 unsafe fn encode(
3654 self,
3655 encoder: &mut fidl::encoding::Encoder<'_, D>,
3656 offset: usize,
3657 _depth: fidl::encoding::Depth,
3658 ) -> fidl::Result<()> {
3659 encoder.debug_check_bounds::<ChildRef>(offset);
3660 fidl::encoding::Encode::<ChildRef, D>::encode(
3662 (
3663 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
3664 <fidl::encoding::Optional<fidl::encoding::BoundedString<100>> as fidl::encoding::ValueTypeMarker>::borrow(&self.collection),
3665 ),
3666 encoder, offset, _depth
3667 )
3668 }
3669 }
3670 unsafe impl<
3671 D: fidl::encoding::ResourceDialect,
3672 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
3673 T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<100>>, D>,
3674 > fidl::encoding::Encode<ChildRef, D> for (T0, T1)
3675 {
3676 #[inline]
3677 unsafe fn encode(
3678 self,
3679 encoder: &mut fidl::encoding::Encoder<'_, D>,
3680 offset: usize,
3681 depth: fidl::encoding::Depth,
3682 ) -> fidl::Result<()> {
3683 encoder.debug_check_bounds::<ChildRef>(offset);
3684 self.0.encode(encoder, offset + 0, depth)?;
3688 self.1.encode(encoder, offset + 16, depth)?;
3689 Ok(())
3690 }
3691 }
3692
3693 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildRef {
3694 #[inline(always)]
3695 fn new_empty() -> Self {
3696 Self {
3697 name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D),
3698 collection: fidl::new_empty!(
3699 fidl::encoding::Optional<fidl::encoding::BoundedString<100>>,
3700 D
3701 ),
3702 }
3703 }
3704
3705 #[inline]
3706 unsafe fn decode(
3707 &mut self,
3708 decoder: &mut fidl::encoding::Decoder<'_, D>,
3709 offset: usize,
3710 _depth: fidl::encoding::Depth,
3711 ) -> fidl::Result<()> {
3712 decoder.debug_check_bounds::<Self>(offset);
3713 fidl::decode!(
3715 fidl::encoding::BoundedString<1024>,
3716 D,
3717 &mut self.name,
3718 decoder,
3719 offset + 0,
3720 _depth
3721 )?;
3722 fidl::decode!(
3723 fidl::encoding::Optional<fidl::encoding::BoundedString<100>>,
3724 D,
3725 &mut self.collection,
3726 decoder,
3727 offset + 16,
3728 _depth
3729 )?;
3730 Ok(())
3731 }
3732 }
3733
3734 impl fidl::encoding::ValueTypeMarker for CollectionRef {
3735 type Borrowed<'a> = &'a Self;
3736 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3737 value
3738 }
3739 }
3740
3741 unsafe impl fidl::encoding::TypeMarker for CollectionRef {
3742 type Owned = Self;
3743
3744 #[inline(always)]
3745 fn inline_align(_context: fidl::encoding::Context) -> usize {
3746 8
3747 }
3748
3749 #[inline(always)]
3750 fn inline_size(_context: fidl::encoding::Context) -> usize {
3751 16
3752 }
3753 }
3754
3755 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CollectionRef, D>
3756 for &CollectionRef
3757 {
3758 #[inline]
3759 unsafe fn encode(
3760 self,
3761 encoder: &mut fidl::encoding::Encoder<'_, D>,
3762 offset: usize,
3763 _depth: fidl::encoding::Depth,
3764 ) -> fidl::Result<()> {
3765 encoder.debug_check_bounds::<CollectionRef>(offset);
3766 fidl::encoding::Encode::<CollectionRef, D>::encode(
3768 (<fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
3769 &self.name,
3770 ),),
3771 encoder,
3772 offset,
3773 _depth,
3774 )
3775 }
3776 }
3777 unsafe impl<
3778 D: fidl::encoding::ResourceDialect,
3779 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<100>, D>,
3780 > fidl::encoding::Encode<CollectionRef, D> for (T0,)
3781 {
3782 #[inline]
3783 unsafe fn encode(
3784 self,
3785 encoder: &mut fidl::encoding::Encoder<'_, D>,
3786 offset: usize,
3787 depth: fidl::encoding::Depth,
3788 ) -> fidl::Result<()> {
3789 encoder.debug_check_bounds::<CollectionRef>(offset);
3790 self.0.encode(encoder, offset + 0, depth)?;
3794 Ok(())
3795 }
3796 }
3797
3798 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CollectionRef {
3799 #[inline(always)]
3800 fn new_empty() -> Self {
3801 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<100>, D) }
3802 }
3803
3804 #[inline]
3805 unsafe fn decode(
3806 &mut self,
3807 decoder: &mut fidl::encoding::Decoder<'_, D>,
3808 offset: usize,
3809 _depth: fidl::encoding::Depth,
3810 ) -> fidl::Result<()> {
3811 decoder.debug_check_bounds::<Self>(offset);
3812 fidl::decode!(
3814 fidl::encoding::BoundedString<100>,
3815 D,
3816 &mut self.name,
3817 decoder,
3818 offset + 0,
3819 _depth
3820 )?;
3821 Ok(())
3822 }
3823 }
3824
3825 impl fidl::encoding::ValueTypeMarker for ConfigType {
3826 type Borrowed<'a> = &'a Self;
3827 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3828 value
3829 }
3830 }
3831
3832 unsafe impl fidl::encoding::TypeMarker for ConfigType {
3833 type Owned = Self;
3834
3835 #[inline(always)]
3836 fn inline_align(_context: fidl::encoding::Context) -> usize {
3837 8
3838 }
3839
3840 #[inline(always)]
3841 fn inline_size(_context: fidl::encoding::Context) -> usize {
3842 40
3843 }
3844 }
3845
3846 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigType, D>
3847 for &ConfigType
3848 {
3849 #[inline]
3850 unsafe fn encode(
3851 self,
3852 encoder: &mut fidl::encoding::Encoder<'_, D>,
3853 offset: usize,
3854 _depth: fidl::encoding::Depth,
3855 ) -> fidl::Result<()> {
3856 encoder.debug_check_bounds::<ConfigType>(offset);
3857 fidl::encoding::Encode::<ConfigType, D>::encode(
3859 (
3860 <ConfigTypeLayout as fidl::encoding::ValueTypeMarker>::borrow(&self.layout),
3861 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<LayoutParameter>> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
3862 <fidl::encoding::UnboundedVector<LayoutConstraint> as fidl::encoding::ValueTypeMarker>::borrow(&self.constraints),
3863 ),
3864 encoder, offset, _depth
3865 )
3866 }
3867 }
3868 unsafe impl<
3869 D: fidl::encoding::ResourceDialect,
3870 T0: fidl::encoding::Encode<ConfigTypeLayout, D>,
3871 T1: fidl::encoding::Encode<
3872 fidl::encoding::Optional<fidl::encoding::UnboundedVector<LayoutParameter>>,
3873 D,
3874 >,
3875 T2: fidl::encoding::Encode<fidl::encoding::UnboundedVector<LayoutConstraint>, D>,
3876 > fidl::encoding::Encode<ConfigType, D> for (T0, T1, T2)
3877 {
3878 #[inline]
3879 unsafe fn encode(
3880 self,
3881 encoder: &mut fidl::encoding::Encoder<'_, D>,
3882 offset: usize,
3883 depth: fidl::encoding::Depth,
3884 ) -> fidl::Result<()> {
3885 encoder.debug_check_bounds::<ConfigType>(offset);
3886 unsafe {
3889 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3890 (ptr as *mut u64).write_unaligned(0);
3891 }
3892 self.0.encode(encoder, offset + 0, depth)?;
3894 self.1.encode(encoder, offset + 8, depth)?;
3895 self.2.encode(encoder, offset + 24, depth)?;
3896 Ok(())
3897 }
3898 }
3899
3900 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigType {
3901 #[inline(always)]
3902 fn new_empty() -> Self {
3903 Self {
3904 layout: fidl::new_empty!(ConfigTypeLayout, D),
3905 parameters: fidl::new_empty!(
3906 fidl::encoding::Optional<fidl::encoding::UnboundedVector<LayoutParameter>>,
3907 D
3908 ),
3909 constraints: fidl::new_empty!(fidl::encoding::UnboundedVector<LayoutConstraint>, D),
3910 }
3911 }
3912
3913 #[inline]
3914 unsafe fn decode(
3915 &mut self,
3916 decoder: &mut fidl::encoding::Decoder<'_, D>,
3917 offset: usize,
3918 _depth: fidl::encoding::Depth,
3919 ) -> fidl::Result<()> {
3920 decoder.debug_check_bounds::<Self>(offset);
3921 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3923 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3924 let mask = 0xffffffff00000000u64;
3925 let maskedval = padval & mask;
3926 if maskedval != 0 {
3927 return Err(fidl::Error::NonZeroPadding {
3928 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3929 });
3930 }
3931 fidl::decode!(ConfigTypeLayout, D, &mut self.layout, decoder, offset + 0, _depth)?;
3932 fidl::decode!(
3933 fidl::encoding::Optional<fidl::encoding::UnboundedVector<LayoutParameter>>,
3934 D,
3935 &mut self.parameters,
3936 decoder,
3937 offset + 8,
3938 _depth
3939 )?;
3940 fidl::decode!(
3941 fidl::encoding::UnboundedVector<LayoutConstraint>,
3942 D,
3943 &mut self.constraints,
3944 decoder,
3945 offset + 24,
3946 _depth
3947 )?;
3948 Ok(())
3949 }
3950 }
3951
3952 impl fidl::encoding::ValueTypeMarker for DebugRef {
3953 type Borrowed<'a> = &'a Self;
3954 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3955 value
3956 }
3957 }
3958
3959 unsafe impl fidl::encoding::TypeMarker for DebugRef {
3960 type Owned = Self;
3961
3962 #[inline(always)]
3963 fn inline_align(_context: fidl::encoding::Context) -> usize {
3964 1
3965 }
3966
3967 #[inline(always)]
3968 fn inline_size(_context: fidl::encoding::Context) -> usize {
3969 1
3970 }
3971 }
3972
3973 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DebugRef, D> for &DebugRef {
3974 #[inline]
3975 unsafe fn encode(
3976 self,
3977 encoder: &mut fidl::encoding::Encoder<'_, D>,
3978 offset: usize,
3979 _depth: fidl::encoding::Depth,
3980 ) -> fidl::Result<()> {
3981 encoder.debug_check_bounds::<DebugRef>(offset);
3982 encoder.write_num(0u8, offset);
3983 Ok(())
3984 }
3985 }
3986
3987 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DebugRef {
3988 #[inline(always)]
3989 fn new_empty() -> Self {
3990 Self
3991 }
3992
3993 #[inline]
3994 unsafe fn decode(
3995 &mut self,
3996 decoder: &mut fidl::encoding::Decoder<'_, D>,
3997 offset: usize,
3998 _depth: fidl::encoding::Depth,
3999 ) -> fidl::Result<()> {
4000 decoder.debug_check_bounds::<Self>(offset);
4001 match decoder.read_num::<u8>(offset) {
4002 0 => Ok(()),
4003 _ => Err(fidl::Error::Invalid),
4004 }
4005 }
4006 }
4007
4008 impl fidl::encoding::ValueTypeMarker for EnvironmentRef {
4009 type Borrowed<'a> = &'a Self;
4010 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4011 value
4012 }
4013 }
4014
4015 unsafe impl fidl::encoding::TypeMarker for EnvironmentRef {
4016 type Owned = Self;
4017
4018 #[inline(always)]
4019 fn inline_align(_context: fidl::encoding::Context) -> usize {
4020 1
4021 }
4022
4023 #[inline(always)]
4024 fn inline_size(_context: fidl::encoding::Context) -> usize {
4025 1
4026 }
4027 }
4028
4029 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnvironmentRef, D>
4030 for &EnvironmentRef
4031 {
4032 #[inline]
4033 unsafe fn encode(
4034 self,
4035 encoder: &mut fidl::encoding::Encoder<'_, D>,
4036 offset: usize,
4037 _depth: fidl::encoding::Depth,
4038 ) -> fidl::Result<()> {
4039 encoder.debug_check_bounds::<EnvironmentRef>(offset);
4040 encoder.write_num(0u8, offset);
4041 Ok(())
4042 }
4043 }
4044
4045 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentRef {
4046 #[inline(always)]
4047 fn new_empty() -> Self {
4048 Self
4049 }
4050
4051 #[inline]
4052 unsafe fn decode(
4053 &mut self,
4054 decoder: &mut fidl::encoding::Decoder<'_, D>,
4055 offset: usize,
4056 _depth: fidl::encoding::Depth,
4057 ) -> fidl::Result<()> {
4058 decoder.debug_check_bounds::<Self>(offset);
4059 match decoder.read_num::<u8>(offset) {
4060 0 => Ok(()),
4061 _ => Err(fidl::Error::Invalid),
4062 }
4063 }
4064 }
4065
4066 impl fidl::encoding::ValueTypeMarker for FrameworkRef {
4067 type Borrowed<'a> = &'a Self;
4068 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4069 value
4070 }
4071 }
4072
4073 unsafe impl fidl::encoding::TypeMarker for FrameworkRef {
4074 type Owned = Self;
4075
4076 #[inline(always)]
4077 fn inline_align(_context: fidl::encoding::Context) -> usize {
4078 1
4079 }
4080
4081 #[inline(always)]
4082 fn inline_size(_context: fidl::encoding::Context) -> usize {
4083 1
4084 }
4085 }
4086
4087 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FrameworkRef, D>
4088 for &FrameworkRef
4089 {
4090 #[inline]
4091 unsafe fn encode(
4092 self,
4093 encoder: &mut fidl::encoding::Encoder<'_, D>,
4094 offset: usize,
4095 _depth: fidl::encoding::Depth,
4096 ) -> fidl::Result<()> {
4097 encoder.debug_check_bounds::<FrameworkRef>(offset);
4098 encoder.write_num(0u8, offset);
4099 Ok(())
4100 }
4101 }
4102
4103 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameworkRef {
4104 #[inline(always)]
4105 fn new_empty() -> Self {
4106 Self
4107 }
4108
4109 #[inline]
4110 unsafe fn decode(
4111 &mut self,
4112 decoder: &mut fidl::encoding::Decoder<'_, D>,
4113 offset: usize,
4114 _depth: fidl::encoding::Depth,
4115 ) -> fidl::Result<()> {
4116 decoder.debug_check_bounds::<Self>(offset);
4117 match decoder.read_num::<u8>(offset) {
4118 0 => Ok(()),
4119 _ => Err(fidl::Error::Invalid),
4120 }
4121 }
4122 }
4123
4124 impl fidl::encoding::ValueTypeMarker for NameMapping {
4125 type Borrowed<'a> = &'a Self;
4126 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4127 value
4128 }
4129 }
4130
4131 unsafe impl fidl::encoding::TypeMarker for NameMapping {
4132 type Owned = Self;
4133
4134 #[inline(always)]
4135 fn inline_align(_context: fidl::encoding::Context) -> usize {
4136 8
4137 }
4138
4139 #[inline(always)]
4140 fn inline_size(_context: fidl::encoding::Context) -> usize {
4141 32
4142 }
4143 }
4144
4145 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NameMapping, D>
4146 for &NameMapping
4147 {
4148 #[inline]
4149 unsafe fn encode(
4150 self,
4151 encoder: &mut fidl::encoding::Encoder<'_, D>,
4152 offset: usize,
4153 _depth: fidl::encoding::Depth,
4154 ) -> fidl::Result<()> {
4155 encoder.debug_check_bounds::<NameMapping>(offset);
4156 fidl::encoding::Encode::<NameMapping, D>::encode(
4158 (
4159 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
4160 &self.source_name,
4161 ),
4162 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
4163 &self.target_name,
4164 ),
4165 ),
4166 encoder,
4167 offset,
4168 _depth,
4169 )
4170 }
4171 }
4172 unsafe impl<
4173 D: fidl::encoding::ResourceDialect,
4174 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<100>, D>,
4175 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<100>, D>,
4176 > fidl::encoding::Encode<NameMapping, D> for (T0, T1)
4177 {
4178 #[inline]
4179 unsafe fn encode(
4180 self,
4181 encoder: &mut fidl::encoding::Encoder<'_, D>,
4182 offset: usize,
4183 depth: fidl::encoding::Depth,
4184 ) -> fidl::Result<()> {
4185 encoder.debug_check_bounds::<NameMapping>(offset);
4186 self.0.encode(encoder, offset + 0, depth)?;
4190 self.1.encode(encoder, offset + 16, depth)?;
4191 Ok(())
4192 }
4193 }
4194
4195 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NameMapping {
4196 #[inline(always)]
4197 fn new_empty() -> Self {
4198 Self {
4199 source_name: fidl::new_empty!(fidl::encoding::BoundedString<100>, D),
4200 target_name: fidl::new_empty!(fidl::encoding::BoundedString<100>, D),
4201 }
4202 }
4203
4204 #[inline]
4205 unsafe fn decode(
4206 &mut self,
4207 decoder: &mut fidl::encoding::Decoder<'_, D>,
4208 offset: usize,
4209 _depth: fidl::encoding::Depth,
4210 ) -> fidl::Result<()> {
4211 decoder.debug_check_bounds::<Self>(offset);
4212 fidl::decode!(
4214 fidl::encoding::BoundedString<100>,
4215 D,
4216 &mut self.source_name,
4217 decoder,
4218 offset + 0,
4219 _depth
4220 )?;
4221 fidl::decode!(
4222 fidl::encoding::BoundedString<100>,
4223 D,
4224 &mut self.target_name,
4225 decoder,
4226 offset + 16,
4227 _depth
4228 )?;
4229 Ok(())
4230 }
4231 }
4232
4233 impl fidl::encoding::ValueTypeMarker for ParentRef {
4234 type Borrowed<'a> = &'a Self;
4235 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4236 value
4237 }
4238 }
4239
4240 unsafe impl fidl::encoding::TypeMarker for ParentRef {
4241 type Owned = Self;
4242
4243 #[inline(always)]
4244 fn inline_align(_context: fidl::encoding::Context) -> usize {
4245 1
4246 }
4247
4248 #[inline(always)]
4249 fn inline_size(_context: fidl::encoding::Context) -> usize {
4250 1
4251 }
4252 }
4253
4254 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ParentRef, D>
4255 for &ParentRef
4256 {
4257 #[inline]
4258 unsafe fn encode(
4259 self,
4260 encoder: &mut fidl::encoding::Encoder<'_, D>,
4261 offset: usize,
4262 _depth: fidl::encoding::Depth,
4263 ) -> fidl::Result<()> {
4264 encoder.debug_check_bounds::<ParentRef>(offset);
4265 encoder.write_num(0u8, offset);
4266 Ok(())
4267 }
4268 }
4269
4270 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParentRef {
4271 #[inline(always)]
4272 fn new_empty() -> Self {
4273 Self
4274 }
4275
4276 #[inline]
4277 unsafe fn decode(
4278 &mut self,
4279 decoder: &mut fidl::encoding::Decoder<'_, D>,
4280 offset: usize,
4281 _depth: fidl::encoding::Depth,
4282 ) -> fidl::Result<()> {
4283 decoder.debug_check_bounds::<Self>(offset);
4284 match decoder.read_num::<u8>(offset) {
4285 0 => Ok(()),
4286 _ => Err(fidl::Error::Invalid),
4287 }
4288 }
4289 }
4290
4291 impl fidl::encoding::ValueTypeMarker for ResolvedConfig {
4292 type Borrowed<'a> = &'a Self;
4293 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4294 value
4295 }
4296 }
4297
4298 unsafe impl fidl::encoding::TypeMarker for ResolvedConfig {
4299 type Owned = Self;
4300
4301 #[inline(always)]
4302 fn inline_align(_context: fidl::encoding::Context) -> usize {
4303 8
4304 }
4305
4306 #[inline(always)]
4307 fn inline_size(_context: fidl::encoding::Context) -> usize {
4308 32
4309 }
4310 }
4311
4312 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolvedConfig, D>
4313 for &ResolvedConfig
4314 {
4315 #[inline]
4316 unsafe fn encode(
4317 self,
4318 encoder: &mut fidl::encoding::Encoder<'_, D>,
4319 offset: usize,
4320 _depth: fidl::encoding::Depth,
4321 ) -> fidl::Result<()> {
4322 encoder.debug_check_bounds::<ResolvedConfig>(offset);
4323 fidl::encoding::Encode::<ResolvedConfig, D>::encode(
4325 (
4326 <fidl::encoding::UnboundedVector<ResolvedConfigField> as fidl::encoding::ValueTypeMarker>::borrow(&self.fields),
4327 <ConfigChecksum as fidl::encoding::ValueTypeMarker>::borrow(&self.checksum),
4328 ),
4329 encoder, offset, _depth
4330 )
4331 }
4332 }
4333 unsafe impl<
4334 D: fidl::encoding::ResourceDialect,
4335 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<ResolvedConfigField>, D>,
4336 T1: fidl::encoding::Encode<ConfigChecksum, D>,
4337 > fidl::encoding::Encode<ResolvedConfig, D> for (T0, T1)
4338 {
4339 #[inline]
4340 unsafe fn encode(
4341 self,
4342 encoder: &mut fidl::encoding::Encoder<'_, D>,
4343 offset: usize,
4344 depth: fidl::encoding::Depth,
4345 ) -> fidl::Result<()> {
4346 encoder.debug_check_bounds::<ResolvedConfig>(offset);
4347 self.0.encode(encoder, offset + 0, depth)?;
4351 self.1.encode(encoder, offset + 16, depth)?;
4352 Ok(())
4353 }
4354 }
4355
4356 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolvedConfig {
4357 #[inline(always)]
4358 fn new_empty() -> Self {
4359 Self {
4360 fields: fidl::new_empty!(fidl::encoding::UnboundedVector<ResolvedConfigField>, D),
4361 checksum: fidl::new_empty!(ConfigChecksum, D),
4362 }
4363 }
4364
4365 #[inline]
4366 unsafe fn decode(
4367 &mut self,
4368 decoder: &mut fidl::encoding::Decoder<'_, D>,
4369 offset: usize,
4370 _depth: fidl::encoding::Depth,
4371 ) -> fidl::Result<()> {
4372 decoder.debug_check_bounds::<Self>(offset);
4373 fidl::decode!(
4375 fidl::encoding::UnboundedVector<ResolvedConfigField>,
4376 D,
4377 &mut self.fields,
4378 decoder,
4379 offset + 0,
4380 _depth
4381 )?;
4382 fidl::decode!(ConfigChecksum, D, &mut self.checksum, decoder, offset + 16, _depth)?;
4383 Ok(())
4384 }
4385 }
4386
4387 impl fidl::encoding::ValueTypeMarker for ResolvedConfigField {
4388 type Borrowed<'a> = &'a Self;
4389 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4390 value
4391 }
4392 }
4393
4394 unsafe impl fidl::encoding::TypeMarker for ResolvedConfigField {
4395 type Owned = Self;
4396
4397 #[inline(always)]
4398 fn inline_align(_context: fidl::encoding::Context) -> usize {
4399 8
4400 }
4401
4402 #[inline(always)]
4403 fn inline_size(_context: fidl::encoding::Context) -> usize {
4404 32
4405 }
4406 }
4407
4408 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolvedConfigField, D>
4409 for &ResolvedConfigField
4410 {
4411 #[inline]
4412 unsafe fn encode(
4413 self,
4414 encoder: &mut fidl::encoding::Encoder<'_, D>,
4415 offset: usize,
4416 _depth: fidl::encoding::Depth,
4417 ) -> fidl::Result<()> {
4418 encoder.debug_check_bounds::<ResolvedConfigField>(offset);
4419 fidl::encoding::Encode::<ResolvedConfigField, D>::encode(
4421 (
4422 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
4423 &self.key,
4424 ),
4425 <ConfigValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
4426 ),
4427 encoder,
4428 offset,
4429 _depth,
4430 )
4431 }
4432 }
4433 unsafe impl<
4434 D: fidl::encoding::ResourceDialect,
4435 T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
4436 T1: fidl::encoding::Encode<ConfigValue, D>,
4437 > fidl::encoding::Encode<ResolvedConfigField, D> for (T0, T1)
4438 {
4439 #[inline]
4440 unsafe fn encode(
4441 self,
4442 encoder: &mut fidl::encoding::Encoder<'_, D>,
4443 offset: usize,
4444 depth: fidl::encoding::Depth,
4445 ) -> fidl::Result<()> {
4446 encoder.debug_check_bounds::<ResolvedConfigField>(offset);
4447 self.0.encode(encoder, offset + 0, depth)?;
4451 self.1.encode(encoder, offset + 16, depth)?;
4452 Ok(())
4453 }
4454 }
4455
4456 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolvedConfigField {
4457 #[inline(always)]
4458 fn new_empty() -> Self {
4459 Self {
4460 key: fidl::new_empty!(fidl::encoding::UnboundedString, D),
4461 value: fidl::new_empty!(ConfigValue, D),
4462 }
4463 }
4464
4465 #[inline]
4466 unsafe fn decode(
4467 &mut self,
4468 decoder: &mut fidl::encoding::Decoder<'_, D>,
4469 offset: usize,
4470 _depth: fidl::encoding::Depth,
4471 ) -> fidl::Result<()> {
4472 decoder.debug_check_bounds::<Self>(offset);
4473 fidl::decode!(
4475 fidl::encoding::UnboundedString,
4476 D,
4477 &mut self.key,
4478 decoder,
4479 offset + 0,
4480 _depth
4481 )?;
4482 fidl::decode!(ConfigValue, D, &mut self.value, decoder, offset + 16, _depth)?;
4483 Ok(())
4484 }
4485 }
4486
4487 impl fidl::encoding::ValueTypeMarker for SelfRef {
4488 type Borrowed<'a> = &'a Self;
4489 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4490 value
4491 }
4492 }
4493
4494 unsafe impl fidl::encoding::TypeMarker for SelfRef {
4495 type Owned = Self;
4496
4497 #[inline(always)]
4498 fn inline_align(_context: fidl::encoding::Context) -> usize {
4499 1
4500 }
4501
4502 #[inline(always)]
4503 fn inline_size(_context: fidl::encoding::Context) -> usize {
4504 1
4505 }
4506 }
4507
4508 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SelfRef, D> for &SelfRef {
4509 #[inline]
4510 unsafe fn encode(
4511 self,
4512 encoder: &mut fidl::encoding::Encoder<'_, D>,
4513 offset: usize,
4514 _depth: fidl::encoding::Depth,
4515 ) -> fidl::Result<()> {
4516 encoder.debug_check_bounds::<SelfRef>(offset);
4517 encoder.write_num(0u8, offset);
4518 Ok(())
4519 }
4520 }
4521
4522 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SelfRef {
4523 #[inline(always)]
4524 fn new_empty() -> Self {
4525 Self
4526 }
4527
4528 #[inline]
4529 unsafe fn decode(
4530 &mut self,
4531 decoder: &mut fidl::encoding::Decoder<'_, D>,
4532 offset: usize,
4533 _depth: fidl::encoding::Depth,
4534 ) -> fidl::Result<()> {
4535 decoder.debug_check_bounds::<Self>(offset);
4536 match decoder.read_num::<u8>(offset) {
4537 0 => Ok(()),
4538 _ => Err(fidl::Error::Invalid),
4539 }
4540 }
4541 }
4542
4543 impl fidl::encoding::ValueTypeMarker for VoidRef {
4544 type Borrowed<'a> = &'a Self;
4545 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4546 value
4547 }
4548 }
4549
4550 unsafe impl fidl::encoding::TypeMarker for VoidRef {
4551 type Owned = Self;
4552
4553 #[inline(always)]
4554 fn inline_align(_context: fidl::encoding::Context) -> usize {
4555 1
4556 }
4557
4558 #[inline(always)]
4559 fn inline_size(_context: fidl::encoding::Context) -> usize {
4560 1
4561 }
4562 }
4563
4564 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VoidRef, D> for &VoidRef {
4565 #[inline]
4566 unsafe fn encode(
4567 self,
4568 encoder: &mut fidl::encoding::Encoder<'_, D>,
4569 offset: usize,
4570 _depth: fidl::encoding::Depth,
4571 ) -> fidl::Result<()> {
4572 encoder.debug_check_bounds::<VoidRef>(offset);
4573 encoder.write_num(0u8, offset);
4574 Ok(())
4575 }
4576 }
4577
4578 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VoidRef {
4579 #[inline(always)]
4580 fn new_empty() -> Self {
4581 Self
4582 }
4583
4584 #[inline]
4585 unsafe fn decode(
4586 &mut self,
4587 decoder: &mut fidl::encoding::Decoder<'_, D>,
4588 offset: usize,
4589 _depth: fidl::encoding::Depth,
4590 ) -> fidl::Result<()> {
4591 decoder.debug_check_bounds::<Self>(offset);
4592 match decoder.read_num::<u8>(offset) {
4593 0 => Ok(()),
4594 _ => Err(fidl::Error::Invalid),
4595 }
4596 }
4597 }
4598
4599 impl Child {
4600 #[inline(always)]
4601 fn max_ordinal_present(&self) -> u64 {
4602 if let Some(_) = self.config_overrides {
4603 return 6;
4604 }
4605 if let Some(_) = self.on_terminate {
4606 return 5;
4607 }
4608 if let Some(_) = self.environment {
4609 return 4;
4610 }
4611 if let Some(_) = self.startup {
4612 return 3;
4613 }
4614 if let Some(_) = self.url {
4615 return 2;
4616 }
4617 if let Some(_) = self.name {
4618 return 1;
4619 }
4620 0
4621 }
4622 }
4623
4624 impl fidl::encoding::ValueTypeMarker for Child {
4625 type Borrowed<'a> = &'a Self;
4626 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4627 value
4628 }
4629 }
4630
4631 unsafe impl fidl::encoding::TypeMarker for Child {
4632 type Owned = Self;
4633
4634 #[inline(always)]
4635 fn inline_align(_context: fidl::encoding::Context) -> usize {
4636 8
4637 }
4638
4639 #[inline(always)]
4640 fn inline_size(_context: fidl::encoding::Context) -> usize {
4641 16
4642 }
4643 }
4644
4645 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Child, D> for &Child {
4646 unsafe fn encode(
4647 self,
4648 encoder: &mut fidl::encoding::Encoder<'_, D>,
4649 offset: usize,
4650 mut depth: fidl::encoding::Depth,
4651 ) -> fidl::Result<()> {
4652 encoder.debug_check_bounds::<Child>(offset);
4653 let max_ordinal: u64 = self.max_ordinal_present();
4655 encoder.write_num(max_ordinal, offset);
4656 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4657 if max_ordinal == 0 {
4659 return Ok(());
4660 }
4661 depth.increment()?;
4662 let envelope_size = 8;
4663 let bytes_len = max_ordinal as usize * envelope_size;
4664 #[allow(unused_variables)]
4665 let offset = encoder.out_of_line_offset(bytes_len);
4666 let mut _prev_end_offset: usize = 0;
4667 if 1 > max_ordinal {
4668 return Ok(());
4669 }
4670
4671 let cur_offset: usize = (1 - 1) * envelope_size;
4674
4675 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4677
4678 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
4683 self.name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
4684 encoder, offset + cur_offset, depth
4685 )?;
4686
4687 _prev_end_offset = cur_offset + envelope_size;
4688 if 2 > max_ordinal {
4689 return Ok(());
4690 }
4691
4692 let cur_offset: usize = (2 - 1) * envelope_size;
4695
4696 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4698
4699 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
4704 self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
4705 encoder, offset + cur_offset, depth
4706 )?;
4707
4708 _prev_end_offset = cur_offset + envelope_size;
4709 if 3 > max_ordinal {
4710 return Ok(());
4711 }
4712
4713 let cur_offset: usize = (3 - 1) * envelope_size;
4716
4717 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4719
4720 fidl::encoding::encode_in_envelope_optional::<StartupMode, D>(
4725 self.startup.as_ref().map(<StartupMode as fidl::encoding::ValueTypeMarker>::borrow),
4726 encoder,
4727 offset + cur_offset,
4728 depth,
4729 )?;
4730
4731 _prev_end_offset = cur_offset + envelope_size;
4732 if 4 > max_ordinal {
4733 return Ok(());
4734 }
4735
4736 let cur_offset: usize = (4 - 1) * envelope_size;
4739
4740 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4742
4743 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
4748 self.environment.as_ref().map(
4749 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
4750 ),
4751 encoder,
4752 offset + cur_offset,
4753 depth,
4754 )?;
4755
4756 _prev_end_offset = cur_offset + envelope_size;
4757 if 5 > max_ordinal {
4758 return Ok(());
4759 }
4760
4761 let cur_offset: usize = (5 - 1) * envelope_size;
4764
4765 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4767
4768 fidl::encoding::encode_in_envelope_optional::<OnTerminate, D>(
4773 self.on_terminate
4774 .as_ref()
4775 .map(<OnTerminate as fidl::encoding::ValueTypeMarker>::borrow),
4776 encoder,
4777 offset + cur_offset,
4778 depth,
4779 )?;
4780
4781 _prev_end_offset = cur_offset + envelope_size;
4782 if 6 > max_ordinal {
4783 return Ok(());
4784 }
4785
4786 let cur_offset: usize = (6 - 1) * envelope_size;
4789
4790 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4792
4793 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ConfigOverride>, D>(
4798 self.config_overrides.as_ref().map(<fidl::encoding::UnboundedVector<ConfigOverride> as fidl::encoding::ValueTypeMarker>::borrow),
4799 encoder, offset + cur_offset, depth
4800 )?;
4801
4802 _prev_end_offset = cur_offset + envelope_size;
4803
4804 Ok(())
4805 }
4806 }
4807
4808 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Child {
4809 #[inline(always)]
4810 fn new_empty() -> Self {
4811 Self::default()
4812 }
4813
4814 unsafe fn decode(
4815 &mut self,
4816 decoder: &mut fidl::encoding::Decoder<'_, D>,
4817 offset: usize,
4818 mut depth: fidl::encoding::Depth,
4819 ) -> fidl::Result<()> {
4820 decoder.debug_check_bounds::<Self>(offset);
4821 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4822 None => return Err(fidl::Error::NotNullable),
4823 Some(len) => len,
4824 };
4825 if len == 0 {
4827 return Ok(());
4828 };
4829 depth.increment()?;
4830 let envelope_size = 8;
4831 let bytes_len = len * envelope_size;
4832 let offset = decoder.out_of_line_offset(bytes_len)?;
4833 let mut _next_ordinal_to_read = 0;
4835 let mut next_offset = offset;
4836 let end_offset = offset + bytes_len;
4837 _next_ordinal_to_read += 1;
4838 if next_offset >= end_offset {
4839 return Ok(());
4840 }
4841
4842 while _next_ordinal_to_read < 1 {
4844 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4845 _next_ordinal_to_read += 1;
4846 next_offset += envelope_size;
4847 }
4848
4849 let next_out_of_line = decoder.next_out_of_line();
4850 let handles_before = decoder.remaining_handles();
4851 if let Some((inlined, num_bytes, num_handles)) =
4852 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4853 {
4854 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4855 if inlined != (member_inline_size <= 4) {
4856 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4857 }
4858 let inner_offset;
4859 let mut inner_depth = depth.clone();
4860 if inlined {
4861 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4862 inner_offset = next_offset;
4863 } else {
4864 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4865 inner_depth.increment()?;
4866 }
4867 let val_ref = self.name.get_or_insert_with(|| {
4868 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
4869 });
4870 fidl::decode!(
4871 fidl::encoding::BoundedString<1024>,
4872 D,
4873 val_ref,
4874 decoder,
4875 inner_offset,
4876 inner_depth
4877 )?;
4878 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4879 {
4880 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4881 }
4882 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4883 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4884 }
4885 }
4886
4887 next_offset += envelope_size;
4888 _next_ordinal_to_read += 1;
4889 if next_offset >= end_offset {
4890 return Ok(());
4891 }
4892
4893 while _next_ordinal_to_read < 2 {
4895 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4896 _next_ordinal_to_read += 1;
4897 next_offset += envelope_size;
4898 }
4899
4900 let next_out_of_line = decoder.next_out_of_line();
4901 let handles_before = decoder.remaining_handles();
4902 if let Some((inlined, num_bytes, num_handles)) =
4903 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4904 {
4905 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4906 if inlined != (member_inline_size <= 4) {
4907 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4908 }
4909 let inner_offset;
4910 let mut inner_depth = depth.clone();
4911 if inlined {
4912 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4913 inner_offset = next_offset;
4914 } else {
4915 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4916 inner_depth.increment()?;
4917 }
4918 let val_ref = self.url.get_or_insert_with(|| {
4919 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
4920 });
4921 fidl::decode!(
4922 fidl::encoding::BoundedString<4096>,
4923 D,
4924 val_ref,
4925 decoder,
4926 inner_offset,
4927 inner_depth
4928 )?;
4929 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4930 {
4931 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4932 }
4933 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4934 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4935 }
4936 }
4937
4938 next_offset += envelope_size;
4939 _next_ordinal_to_read += 1;
4940 if next_offset >= end_offset {
4941 return Ok(());
4942 }
4943
4944 while _next_ordinal_to_read < 3 {
4946 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4947 _next_ordinal_to_read += 1;
4948 next_offset += envelope_size;
4949 }
4950
4951 let next_out_of_line = decoder.next_out_of_line();
4952 let handles_before = decoder.remaining_handles();
4953 if let Some((inlined, num_bytes, num_handles)) =
4954 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4955 {
4956 let member_inline_size =
4957 <StartupMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4958 if inlined != (member_inline_size <= 4) {
4959 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4960 }
4961 let inner_offset;
4962 let mut inner_depth = depth.clone();
4963 if inlined {
4964 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4965 inner_offset = next_offset;
4966 } else {
4967 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4968 inner_depth.increment()?;
4969 }
4970 let val_ref = self.startup.get_or_insert_with(|| fidl::new_empty!(StartupMode, D));
4971 fidl::decode!(StartupMode, D, val_ref, decoder, inner_offset, inner_depth)?;
4972 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4973 {
4974 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4975 }
4976 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4977 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4978 }
4979 }
4980
4981 next_offset += envelope_size;
4982 _next_ordinal_to_read += 1;
4983 if next_offset >= end_offset {
4984 return Ok(());
4985 }
4986
4987 while _next_ordinal_to_read < 4 {
4989 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4990 _next_ordinal_to_read += 1;
4991 next_offset += envelope_size;
4992 }
4993
4994 let next_out_of_line = decoder.next_out_of_line();
4995 let handles_before = decoder.remaining_handles();
4996 if let Some((inlined, num_bytes, num_handles)) =
4997 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4998 {
4999 let member_inline_size =
5000 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
5001 decoder.context,
5002 );
5003 if inlined != (member_inline_size <= 4) {
5004 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5005 }
5006 let inner_offset;
5007 let mut inner_depth = depth.clone();
5008 if inlined {
5009 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5010 inner_offset = next_offset;
5011 } else {
5012 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5013 inner_depth.increment()?;
5014 }
5015 let val_ref = self
5016 .environment
5017 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
5018 fidl::decode!(
5019 fidl::encoding::BoundedString<100>,
5020 D,
5021 val_ref,
5022 decoder,
5023 inner_offset,
5024 inner_depth
5025 )?;
5026 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5027 {
5028 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5029 }
5030 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5031 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5032 }
5033 }
5034
5035 next_offset += envelope_size;
5036 _next_ordinal_to_read += 1;
5037 if next_offset >= end_offset {
5038 return Ok(());
5039 }
5040
5041 while _next_ordinal_to_read < 5 {
5043 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5044 _next_ordinal_to_read += 1;
5045 next_offset += envelope_size;
5046 }
5047
5048 let next_out_of_line = decoder.next_out_of_line();
5049 let handles_before = decoder.remaining_handles();
5050 if let Some((inlined, num_bytes, num_handles)) =
5051 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5052 {
5053 let member_inline_size =
5054 <OnTerminate as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5055 if inlined != (member_inline_size <= 4) {
5056 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5057 }
5058 let inner_offset;
5059 let mut inner_depth = depth.clone();
5060 if inlined {
5061 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5062 inner_offset = next_offset;
5063 } else {
5064 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5065 inner_depth.increment()?;
5066 }
5067 let val_ref =
5068 self.on_terminate.get_or_insert_with(|| fidl::new_empty!(OnTerminate, D));
5069 fidl::decode!(OnTerminate, D, val_ref, decoder, inner_offset, inner_depth)?;
5070 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5071 {
5072 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5073 }
5074 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5075 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5076 }
5077 }
5078
5079 next_offset += envelope_size;
5080 _next_ordinal_to_read += 1;
5081 if next_offset >= end_offset {
5082 return Ok(());
5083 }
5084
5085 while _next_ordinal_to_read < 6 {
5087 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5088 _next_ordinal_to_read += 1;
5089 next_offset += envelope_size;
5090 }
5091
5092 let next_out_of_line = decoder.next_out_of_line();
5093 let handles_before = decoder.remaining_handles();
5094 if let Some((inlined, num_bytes, num_handles)) =
5095 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5096 {
5097 let member_inline_size = <fidl::encoding::UnboundedVector<ConfigOverride> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5098 if inlined != (member_inline_size <= 4) {
5099 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5100 }
5101 let inner_offset;
5102 let mut inner_depth = depth.clone();
5103 if inlined {
5104 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5105 inner_offset = next_offset;
5106 } else {
5107 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5108 inner_depth.increment()?;
5109 }
5110 let val_ref = self.config_overrides.get_or_insert_with(|| {
5111 fidl::new_empty!(fidl::encoding::UnboundedVector<ConfigOverride>, D)
5112 });
5113 fidl::decode!(
5114 fidl::encoding::UnboundedVector<ConfigOverride>,
5115 D,
5116 val_ref,
5117 decoder,
5118 inner_offset,
5119 inner_depth
5120 )?;
5121 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5122 {
5123 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5124 }
5125 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5126 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5127 }
5128 }
5129
5130 next_offset += envelope_size;
5131
5132 while next_offset < end_offset {
5134 _next_ordinal_to_read += 1;
5135 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5136 next_offset += envelope_size;
5137 }
5138
5139 Ok(())
5140 }
5141 }
5142
5143 impl Collection {
5144 #[inline(always)]
5145 fn max_ordinal_present(&self) -> u64 {
5146 if let Some(_) = self.persistent_storage {
5147 return 6;
5148 }
5149 if let Some(_) = self.allow_long_names {
5150 return 5;
5151 }
5152 if let Some(_) = self.allowed_offers {
5153 return 4;
5154 }
5155 if let Some(_) = self.environment {
5156 return 3;
5157 }
5158 if let Some(_) = self.durability {
5159 return 2;
5160 }
5161 if let Some(_) = self.name {
5162 return 1;
5163 }
5164 0
5165 }
5166 }
5167
5168 impl fidl::encoding::ValueTypeMarker for Collection {
5169 type Borrowed<'a> = &'a Self;
5170 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5171 value
5172 }
5173 }
5174
5175 unsafe impl fidl::encoding::TypeMarker for Collection {
5176 type Owned = Self;
5177
5178 #[inline(always)]
5179 fn inline_align(_context: fidl::encoding::Context) -> usize {
5180 8
5181 }
5182
5183 #[inline(always)]
5184 fn inline_size(_context: fidl::encoding::Context) -> usize {
5185 16
5186 }
5187 }
5188
5189 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Collection, D>
5190 for &Collection
5191 {
5192 unsafe fn encode(
5193 self,
5194 encoder: &mut fidl::encoding::Encoder<'_, D>,
5195 offset: usize,
5196 mut depth: fidl::encoding::Depth,
5197 ) -> fidl::Result<()> {
5198 encoder.debug_check_bounds::<Collection>(offset);
5199 let max_ordinal: u64 = self.max_ordinal_present();
5201 encoder.write_num(max_ordinal, offset);
5202 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5203 if max_ordinal == 0 {
5205 return Ok(());
5206 }
5207 depth.increment()?;
5208 let envelope_size = 8;
5209 let bytes_len = max_ordinal as usize * envelope_size;
5210 #[allow(unused_variables)]
5211 let offset = encoder.out_of_line_offset(bytes_len);
5212 let mut _prev_end_offset: usize = 0;
5213 if 1 > max_ordinal {
5214 return Ok(());
5215 }
5216
5217 let cur_offset: usize = (1 - 1) * envelope_size;
5220
5221 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5223
5224 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
5229 self.name.as_ref().map(
5230 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
5231 ),
5232 encoder,
5233 offset + cur_offset,
5234 depth,
5235 )?;
5236
5237 _prev_end_offset = cur_offset + envelope_size;
5238 if 2 > max_ordinal {
5239 return Ok(());
5240 }
5241
5242 let cur_offset: usize = (2 - 1) * envelope_size;
5245
5246 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5248
5249 fidl::encoding::encode_in_envelope_optional::<Durability, D>(
5254 self.durability
5255 .as_ref()
5256 .map(<Durability as fidl::encoding::ValueTypeMarker>::borrow),
5257 encoder,
5258 offset + cur_offset,
5259 depth,
5260 )?;
5261
5262 _prev_end_offset = cur_offset + envelope_size;
5263 if 3 > max_ordinal {
5264 return Ok(());
5265 }
5266
5267 let cur_offset: usize = (3 - 1) * envelope_size;
5270
5271 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5273
5274 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
5279 self.environment.as_ref().map(
5280 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
5281 ),
5282 encoder,
5283 offset + cur_offset,
5284 depth,
5285 )?;
5286
5287 _prev_end_offset = cur_offset + envelope_size;
5288 if 4 > max_ordinal {
5289 return Ok(());
5290 }
5291
5292 let cur_offset: usize = (4 - 1) * envelope_size;
5295
5296 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5298
5299 fidl::encoding::encode_in_envelope_optional::<AllowedOffers, D>(
5304 self.allowed_offers
5305 .as_ref()
5306 .map(<AllowedOffers as fidl::encoding::ValueTypeMarker>::borrow),
5307 encoder,
5308 offset + cur_offset,
5309 depth,
5310 )?;
5311
5312 _prev_end_offset = cur_offset + envelope_size;
5313 if 5 > max_ordinal {
5314 return Ok(());
5315 }
5316
5317 let cur_offset: usize = (5 - 1) * envelope_size;
5320
5321 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5323
5324 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5329 self.allow_long_names
5330 .as_ref()
5331 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5332 encoder,
5333 offset + cur_offset,
5334 depth,
5335 )?;
5336
5337 _prev_end_offset = cur_offset + envelope_size;
5338 if 6 > max_ordinal {
5339 return Ok(());
5340 }
5341
5342 let cur_offset: usize = (6 - 1) * envelope_size;
5345
5346 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5348
5349 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5354 self.persistent_storage
5355 .as_ref()
5356 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5357 encoder,
5358 offset + cur_offset,
5359 depth,
5360 )?;
5361
5362 _prev_end_offset = cur_offset + envelope_size;
5363
5364 Ok(())
5365 }
5366 }
5367
5368 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Collection {
5369 #[inline(always)]
5370 fn new_empty() -> Self {
5371 Self::default()
5372 }
5373
5374 unsafe fn decode(
5375 &mut self,
5376 decoder: &mut fidl::encoding::Decoder<'_, D>,
5377 offset: usize,
5378 mut depth: fidl::encoding::Depth,
5379 ) -> fidl::Result<()> {
5380 decoder.debug_check_bounds::<Self>(offset);
5381 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5382 None => return Err(fidl::Error::NotNullable),
5383 Some(len) => len,
5384 };
5385 if len == 0 {
5387 return Ok(());
5388 };
5389 depth.increment()?;
5390 let envelope_size = 8;
5391 let bytes_len = len * envelope_size;
5392 let offset = decoder.out_of_line_offset(bytes_len)?;
5393 let mut _next_ordinal_to_read = 0;
5395 let mut next_offset = offset;
5396 let end_offset = offset + bytes_len;
5397 _next_ordinal_to_read += 1;
5398 if next_offset >= end_offset {
5399 return Ok(());
5400 }
5401
5402 while _next_ordinal_to_read < 1 {
5404 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5405 _next_ordinal_to_read += 1;
5406 next_offset += envelope_size;
5407 }
5408
5409 let next_out_of_line = decoder.next_out_of_line();
5410 let handles_before = decoder.remaining_handles();
5411 if let Some((inlined, num_bytes, num_handles)) =
5412 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5413 {
5414 let member_inline_size =
5415 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
5416 decoder.context,
5417 );
5418 if inlined != (member_inline_size <= 4) {
5419 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5420 }
5421 let inner_offset;
5422 let mut inner_depth = depth.clone();
5423 if inlined {
5424 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5425 inner_offset = next_offset;
5426 } else {
5427 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5428 inner_depth.increment()?;
5429 }
5430 let val_ref = self
5431 .name
5432 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
5433 fidl::decode!(
5434 fidl::encoding::BoundedString<100>,
5435 D,
5436 val_ref,
5437 decoder,
5438 inner_offset,
5439 inner_depth
5440 )?;
5441 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5442 {
5443 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5444 }
5445 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5446 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5447 }
5448 }
5449
5450 next_offset += envelope_size;
5451 _next_ordinal_to_read += 1;
5452 if next_offset >= end_offset {
5453 return Ok(());
5454 }
5455
5456 while _next_ordinal_to_read < 2 {
5458 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5459 _next_ordinal_to_read += 1;
5460 next_offset += envelope_size;
5461 }
5462
5463 let next_out_of_line = decoder.next_out_of_line();
5464 let handles_before = decoder.remaining_handles();
5465 if let Some((inlined, num_bytes, num_handles)) =
5466 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5467 {
5468 let member_inline_size =
5469 <Durability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5470 if inlined != (member_inline_size <= 4) {
5471 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5472 }
5473 let inner_offset;
5474 let mut inner_depth = depth.clone();
5475 if inlined {
5476 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5477 inner_offset = next_offset;
5478 } else {
5479 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5480 inner_depth.increment()?;
5481 }
5482 let val_ref =
5483 self.durability.get_or_insert_with(|| fidl::new_empty!(Durability, D));
5484 fidl::decode!(Durability, D, val_ref, decoder, inner_offset, inner_depth)?;
5485 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5486 {
5487 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5488 }
5489 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5490 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5491 }
5492 }
5493
5494 next_offset += envelope_size;
5495 _next_ordinal_to_read += 1;
5496 if next_offset >= end_offset {
5497 return Ok(());
5498 }
5499
5500 while _next_ordinal_to_read < 3 {
5502 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5503 _next_ordinal_to_read += 1;
5504 next_offset += envelope_size;
5505 }
5506
5507 let next_out_of_line = decoder.next_out_of_line();
5508 let handles_before = decoder.remaining_handles();
5509 if let Some((inlined, num_bytes, num_handles)) =
5510 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5511 {
5512 let member_inline_size =
5513 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
5514 decoder.context,
5515 );
5516 if inlined != (member_inline_size <= 4) {
5517 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5518 }
5519 let inner_offset;
5520 let mut inner_depth = depth.clone();
5521 if inlined {
5522 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5523 inner_offset = next_offset;
5524 } else {
5525 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5526 inner_depth.increment()?;
5527 }
5528 let val_ref = self
5529 .environment
5530 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
5531 fidl::decode!(
5532 fidl::encoding::BoundedString<100>,
5533 D,
5534 val_ref,
5535 decoder,
5536 inner_offset,
5537 inner_depth
5538 )?;
5539 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5540 {
5541 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5542 }
5543 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5544 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5545 }
5546 }
5547
5548 next_offset += envelope_size;
5549 _next_ordinal_to_read += 1;
5550 if next_offset >= end_offset {
5551 return Ok(());
5552 }
5553
5554 while _next_ordinal_to_read < 4 {
5556 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5557 _next_ordinal_to_read += 1;
5558 next_offset += envelope_size;
5559 }
5560
5561 let next_out_of_line = decoder.next_out_of_line();
5562 let handles_before = decoder.remaining_handles();
5563 if let Some((inlined, num_bytes, num_handles)) =
5564 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5565 {
5566 let member_inline_size =
5567 <AllowedOffers as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5568 if inlined != (member_inline_size <= 4) {
5569 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5570 }
5571 let inner_offset;
5572 let mut inner_depth = depth.clone();
5573 if inlined {
5574 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5575 inner_offset = next_offset;
5576 } else {
5577 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5578 inner_depth.increment()?;
5579 }
5580 let val_ref =
5581 self.allowed_offers.get_or_insert_with(|| fidl::new_empty!(AllowedOffers, D));
5582 fidl::decode!(AllowedOffers, D, val_ref, decoder, inner_offset, inner_depth)?;
5583 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5584 {
5585 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5586 }
5587 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5588 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5589 }
5590 }
5591
5592 next_offset += envelope_size;
5593 _next_ordinal_to_read += 1;
5594 if next_offset >= end_offset {
5595 return Ok(());
5596 }
5597
5598 while _next_ordinal_to_read < 5 {
5600 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5601 _next_ordinal_to_read += 1;
5602 next_offset += envelope_size;
5603 }
5604
5605 let next_out_of_line = decoder.next_out_of_line();
5606 let handles_before = decoder.remaining_handles();
5607 if let Some((inlined, num_bytes, num_handles)) =
5608 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5609 {
5610 let member_inline_size =
5611 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5612 if inlined != (member_inline_size <= 4) {
5613 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5614 }
5615 let inner_offset;
5616 let mut inner_depth = depth.clone();
5617 if inlined {
5618 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5619 inner_offset = next_offset;
5620 } else {
5621 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5622 inner_depth.increment()?;
5623 }
5624 let val_ref =
5625 self.allow_long_names.get_or_insert_with(|| fidl::new_empty!(bool, D));
5626 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5627 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5628 {
5629 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5630 }
5631 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5632 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5633 }
5634 }
5635
5636 next_offset += envelope_size;
5637 _next_ordinal_to_read += 1;
5638 if next_offset >= end_offset {
5639 return Ok(());
5640 }
5641
5642 while _next_ordinal_to_read < 6 {
5644 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5645 _next_ordinal_to_read += 1;
5646 next_offset += envelope_size;
5647 }
5648
5649 let next_out_of_line = decoder.next_out_of_line();
5650 let handles_before = decoder.remaining_handles();
5651 if let Some((inlined, num_bytes, num_handles)) =
5652 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5653 {
5654 let member_inline_size =
5655 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5656 if inlined != (member_inline_size <= 4) {
5657 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5658 }
5659 let inner_offset;
5660 let mut inner_depth = depth.clone();
5661 if inlined {
5662 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5663 inner_offset = next_offset;
5664 } else {
5665 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5666 inner_depth.increment()?;
5667 }
5668 let val_ref =
5669 self.persistent_storage.get_or_insert_with(|| fidl::new_empty!(bool, D));
5670 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5671 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5672 {
5673 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5674 }
5675 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5676 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5677 }
5678 }
5679
5680 next_offset += envelope_size;
5681
5682 while next_offset < end_offset {
5684 _next_ordinal_to_read += 1;
5685 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5686 next_offset += envelope_size;
5687 }
5688
5689 Ok(())
5690 }
5691 }
5692
5693 impl Component {
5694 #[inline(always)]
5695 fn max_ordinal_present(&self) -> u64 {
5696 if let Some(_) = self.config {
5697 return 10;
5698 }
5699 if let Some(_) = self.facets {
5700 return 9;
5701 }
5702 if let Some(_) = self.environments {
5703 return 8;
5704 }
5705 if let Some(_) = self.collections {
5706 return 7;
5707 }
5708 if let Some(_) = self.children {
5709 return 6;
5710 }
5711 if let Some(_) = self.capabilities {
5712 return 5;
5713 }
5714 if let Some(_) = self.offers {
5715 return 4;
5716 }
5717 if let Some(_) = self.exposes {
5718 return 3;
5719 }
5720 if let Some(_) = self.uses {
5721 return 2;
5722 }
5723 if let Some(_) = self.program {
5724 return 1;
5725 }
5726 0
5727 }
5728 }
5729
5730 impl fidl::encoding::ValueTypeMarker for Component {
5731 type Borrowed<'a> = &'a Self;
5732 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5733 value
5734 }
5735 }
5736
5737 unsafe impl fidl::encoding::TypeMarker for Component {
5738 type Owned = Self;
5739
5740 #[inline(always)]
5741 fn inline_align(_context: fidl::encoding::Context) -> usize {
5742 8
5743 }
5744
5745 #[inline(always)]
5746 fn inline_size(_context: fidl::encoding::Context) -> usize {
5747 16
5748 }
5749 }
5750
5751 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Component, D>
5752 for &Component
5753 {
5754 unsafe fn encode(
5755 self,
5756 encoder: &mut fidl::encoding::Encoder<'_, D>,
5757 offset: usize,
5758 mut depth: fidl::encoding::Depth,
5759 ) -> fidl::Result<()> {
5760 encoder.debug_check_bounds::<Component>(offset);
5761 let max_ordinal: u64 = self.max_ordinal_present();
5763 encoder.write_num(max_ordinal, offset);
5764 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5765 if max_ordinal == 0 {
5767 return Ok(());
5768 }
5769 depth.increment()?;
5770 let envelope_size = 8;
5771 let bytes_len = max_ordinal as usize * envelope_size;
5772 #[allow(unused_variables)]
5773 let offset = encoder.out_of_line_offset(bytes_len);
5774 let mut _prev_end_offset: usize = 0;
5775 if 1 > max_ordinal {
5776 return Ok(());
5777 }
5778
5779 let cur_offset: usize = (1 - 1) * envelope_size;
5782
5783 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5785
5786 fidl::encoding::encode_in_envelope_optional::<Program, D>(
5791 self.program.as_ref().map(<Program as fidl::encoding::ValueTypeMarker>::borrow),
5792 encoder,
5793 offset + cur_offset,
5794 depth,
5795 )?;
5796
5797 _prev_end_offset = cur_offset + envelope_size;
5798 if 2 > max_ordinal {
5799 return Ok(());
5800 }
5801
5802 let cur_offset: usize = (2 - 1) * envelope_size;
5805
5806 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5808
5809 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Use>, D>(
5814 self.uses.as_ref().map(<fidl::encoding::UnboundedVector<Use> as fidl::encoding::ValueTypeMarker>::borrow),
5815 encoder, offset + cur_offset, depth
5816 )?;
5817
5818 _prev_end_offset = cur_offset + envelope_size;
5819 if 3 > max_ordinal {
5820 return Ok(());
5821 }
5822
5823 let cur_offset: usize = (3 - 1) * envelope_size;
5826
5827 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5829
5830 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Expose>, D>(
5835 self.exposes.as_ref().map(<fidl::encoding::UnboundedVector<Expose> as fidl::encoding::ValueTypeMarker>::borrow),
5836 encoder, offset + cur_offset, depth
5837 )?;
5838
5839 _prev_end_offset = cur_offset + envelope_size;
5840 if 4 > max_ordinal {
5841 return Ok(());
5842 }
5843
5844 let cur_offset: usize = (4 - 1) * envelope_size;
5847
5848 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5850
5851 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Offer>, D>(
5856 self.offers.as_ref().map(<fidl::encoding::UnboundedVector<Offer> as fidl::encoding::ValueTypeMarker>::borrow),
5857 encoder, offset + cur_offset, depth
5858 )?;
5859
5860 _prev_end_offset = cur_offset + envelope_size;
5861 if 5 > max_ordinal {
5862 return Ok(());
5863 }
5864
5865 let cur_offset: usize = (5 - 1) * envelope_size;
5868
5869 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5871
5872 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Capability>, D>(
5877 self.capabilities.as_ref().map(<fidl::encoding::UnboundedVector<Capability> as fidl::encoding::ValueTypeMarker>::borrow),
5878 encoder, offset + cur_offset, depth
5879 )?;
5880
5881 _prev_end_offset = cur_offset + envelope_size;
5882 if 6 > max_ordinal {
5883 return Ok(());
5884 }
5885
5886 let cur_offset: usize = (6 - 1) * envelope_size;
5889
5890 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5892
5893 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Child>, D>(
5898 self.children.as_ref().map(<fidl::encoding::UnboundedVector<Child> as fidl::encoding::ValueTypeMarker>::borrow),
5899 encoder, offset + cur_offset, depth
5900 )?;
5901
5902 _prev_end_offset = cur_offset + envelope_size;
5903 if 7 > max_ordinal {
5904 return Ok(());
5905 }
5906
5907 let cur_offset: usize = (7 - 1) * envelope_size;
5910
5911 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5913
5914 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Collection>, D>(
5919 self.collections.as_ref().map(<fidl::encoding::UnboundedVector<Collection> as fidl::encoding::ValueTypeMarker>::borrow),
5920 encoder, offset + cur_offset, depth
5921 )?;
5922
5923 _prev_end_offset = cur_offset + envelope_size;
5924 if 8 > max_ordinal {
5925 return Ok(());
5926 }
5927
5928 let cur_offset: usize = (8 - 1) * envelope_size;
5931
5932 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5934
5935 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Environment>, D>(
5940 self.environments.as_ref().map(<fidl::encoding::UnboundedVector<Environment> as fidl::encoding::ValueTypeMarker>::borrow),
5941 encoder, offset + cur_offset, depth
5942 )?;
5943
5944 _prev_end_offset = cur_offset + envelope_size;
5945 if 9 > max_ordinal {
5946 return Ok(());
5947 }
5948
5949 let cur_offset: usize = (9 - 1) * envelope_size;
5952
5953 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5955
5956 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_data__common::Dictionary, D>(
5961 self.facets.as_ref().map(<fidl_fuchsia_data__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow),
5962 encoder, offset + cur_offset, depth
5963 )?;
5964
5965 _prev_end_offset = cur_offset + envelope_size;
5966 if 10 > max_ordinal {
5967 return Ok(());
5968 }
5969
5970 let cur_offset: usize = (10 - 1) * envelope_size;
5973
5974 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5976
5977 fidl::encoding::encode_in_envelope_optional::<ConfigSchema, D>(
5982 self.config.as_ref().map(<ConfigSchema as fidl::encoding::ValueTypeMarker>::borrow),
5983 encoder,
5984 offset + cur_offset,
5985 depth,
5986 )?;
5987
5988 _prev_end_offset = cur_offset + envelope_size;
5989
5990 Ok(())
5991 }
5992 }
5993
5994 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Component {
5995 #[inline(always)]
5996 fn new_empty() -> Self {
5997 Self::default()
5998 }
5999
6000 unsafe fn decode(
6001 &mut self,
6002 decoder: &mut fidl::encoding::Decoder<'_, D>,
6003 offset: usize,
6004 mut depth: fidl::encoding::Depth,
6005 ) -> fidl::Result<()> {
6006 decoder.debug_check_bounds::<Self>(offset);
6007 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6008 None => return Err(fidl::Error::NotNullable),
6009 Some(len) => len,
6010 };
6011 if len == 0 {
6013 return Ok(());
6014 };
6015 depth.increment()?;
6016 let envelope_size = 8;
6017 let bytes_len = len * envelope_size;
6018 let offset = decoder.out_of_line_offset(bytes_len)?;
6019 let mut _next_ordinal_to_read = 0;
6021 let mut next_offset = offset;
6022 let end_offset = offset + bytes_len;
6023 _next_ordinal_to_read += 1;
6024 if next_offset >= end_offset {
6025 return Ok(());
6026 }
6027
6028 while _next_ordinal_to_read < 1 {
6030 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6031 _next_ordinal_to_read += 1;
6032 next_offset += envelope_size;
6033 }
6034
6035 let next_out_of_line = decoder.next_out_of_line();
6036 let handles_before = decoder.remaining_handles();
6037 if let Some((inlined, num_bytes, num_handles)) =
6038 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6039 {
6040 let member_inline_size =
6041 <Program as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6042 if inlined != (member_inline_size <= 4) {
6043 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6044 }
6045 let inner_offset;
6046 let mut inner_depth = depth.clone();
6047 if inlined {
6048 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6049 inner_offset = next_offset;
6050 } else {
6051 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6052 inner_depth.increment()?;
6053 }
6054 let val_ref = self.program.get_or_insert_with(|| fidl::new_empty!(Program, D));
6055 fidl::decode!(Program, D, val_ref, decoder, inner_offset, inner_depth)?;
6056 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6057 {
6058 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6059 }
6060 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6061 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6062 }
6063 }
6064
6065 next_offset += envelope_size;
6066 _next_ordinal_to_read += 1;
6067 if next_offset >= end_offset {
6068 return Ok(());
6069 }
6070
6071 while _next_ordinal_to_read < 2 {
6073 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6074 _next_ordinal_to_read += 1;
6075 next_offset += envelope_size;
6076 }
6077
6078 let next_out_of_line = decoder.next_out_of_line();
6079 let handles_before = decoder.remaining_handles();
6080 if let Some((inlined, num_bytes, num_handles)) =
6081 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6082 {
6083 let member_inline_size = <fidl::encoding::UnboundedVector<Use> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6084 if inlined != (member_inline_size <= 4) {
6085 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6086 }
6087 let inner_offset;
6088 let mut inner_depth = depth.clone();
6089 if inlined {
6090 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6091 inner_offset = next_offset;
6092 } else {
6093 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6094 inner_depth.increment()?;
6095 }
6096 let val_ref = self.uses.get_or_insert_with(|| {
6097 fidl::new_empty!(fidl::encoding::UnboundedVector<Use>, D)
6098 });
6099 fidl::decode!(
6100 fidl::encoding::UnboundedVector<Use>,
6101 D,
6102 val_ref,
6103 decoder,
6104 inner_offset,
6105 inner_depth
6106 )?;
6107 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6108 {
6109 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6110 }
6111 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6112 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6113 }
6114 }
6115
6116 next_offset += envelope_size;
6117 _next_ordinal_to_read += 1;
6118 if next_offset >= end_offset {
6119 return Ok(());
6120 }
6121
6122 while _next_ordinal_to_read < 3 {
6124 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6125 _next_ordinal_to_read += 1;
6126 next_offset += envelope_size;
6127 }
6128
6129 let next_out_of_line = decoder.next_out_of_line();
6130 let handles_before = decoder.remaining_handles();
6131 if let Some((inlined, num_bytes, num_handles)) =
6132 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6133 {
6134 let member_inline_size = <fidl::encoding::UnboundedVector<Expose> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6135 if inlined != (member_inline_size <= 4) {
6136 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6137 }
6138 let inner_offset;
6139 let mut inner_depth = depth.clone();
6140 if inlined {
6141 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6142 inner_offset = next_offset;
6143 } else {
6144 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6145 inner_depth.increment()?;
6146 }
6147 let val_ref = self.exposes.get_or_insert_with(|| {
6148 fidl::new_empty!(fidl::encoding::UnboundedVector<Expose>, D)
6149 });
6150 fidl::decode!(
6151 fidl::encoding::UnboundedVector<Expose>,
6152 D,
6153 val_ref,
6154 decoder,
6155 inner_offset,
6156 inner_depth
6157 )?;
6158 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6159 {
6160 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6161 }
6162 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6163 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6164 }
6165 }
6166
6167 next_offset += envelope_size;
6168 _next_ordinal_to_read += 1;
6169 if next_offset >= end_offset {
6170 return Ok(());
6171 }
6172
6173 while _next_ordinal_to_read < 4 {
6175 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6176 _next_ordinal_to_read += 1;
6177 next_offset += envelope_size;
6178 }
6179
6180 let next_out_of_line = decoder.next_out_of_line();
6181 let handles_before = decoder.remaining_handles();
6182 if let Some((inlined, num_bytes, num_handles)) =
6183 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6184 {
6185 let member_inline_size = <fidl::encoding::UnboundedVector<Offer> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6186 if inlined != (member_inline_size <= 4) {
6187 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6188 }
6189 let inner_offset;
6190 let mut inner_depth = depth.clone();
6191 if inlined {
6192 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6193 inner_offset = next_offset;
6194 } else {
6195 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6196 inner_depth.increment()?;
6197 }
6198 let val_ref = self.offers.get_or_insert_with(|| {
6199 fidl::new_empty!(fidl::encoding::UnboundedVector<Offer>, D)
6200 });
6201 fidl::decode!(
6202 fidl::encoding::UnboundedVector<Offer>,
6203 D,
6204 val_ref,
6205 decoder,
6206 inner_offset,
6207 inner_depth
6208 )?;
6209 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6210 {
6211 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6212 }
6213 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6214 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6215 }
6216 }
6217
6218 next_offset += envelope_size;
6219 _next_ordinal_to_read += 1;
6220 if next_offset >= end_offset {
6221 return Ok(());
6222 }
6223
6224 while _next_ordinal_to_read < 5 {
6226 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6227 _next_ordinal_to_read += 1;
6228 next_offset += envelope_size;
6229 }
6230
6231 let next_out_of_line = decoder.next_out_of_line();
6232 let handles_before = decoder.remaining_handles();
6233 if let Some((inlined, num_bytes, num_handles)) =
6234 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6235 {
6236 let member_inline_size = <fidl::encoding::UnboundedVector<Capability> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6237 if inlined != (member_inline_size <= 4) {
6238 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6239 }
6240 let inner_offset;
6241 let mut inner_depth = depth.clone();
6242 if inlined {
6243 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6244 inner_offset = next_offset;
6245 } else {
6246 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6247 inner_depth.increment()?;
6248 }
6249 let val_ref = self.capabilities.get_or_insert_with(|| {
6250 fidl::new_empty!(fidl::encoding::UnboundedVector<Capability>, D)
6251 });
6252 fidl::decode!(
6253 fidl::encoding::UnboundedVector<Capability>,
6254 D,
6255 val_ref,
6256 decoder,
6257 inner_offset,
6258 inner_depth
6259 )?;
6260 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6261 {
6262 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6263 }
6264 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6265 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6266 }
6267 }
6268
6269 next_offset += envelope_size;
6270 _next_ordinal_to_read += 1;
6271 if next_offset >= end_offset {
6272 return Ok(());
6273 }
6274
6275 while _next_ordinal_to_read < 6 {
6277 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6278 _next_ordinal_to_read += 1;
6279 next_offset += envelope_size;
6280 }
6281
6282 let next_out_of_line = decoder.next_out_of_line();
6283 let handles_before = decoder.remaining_handles();
6284 if let Some((inlined, num_bytes, num_handles)) =
6285 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6286 {
6287 let member_inline_size = <fidl::encoding::UnboundedVector<Child> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6288 if inlined != (member_inline_size <= 4) {
6289 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6290 }
6291 let inner_offset;
6292 let mut inner_depth = depth.clone();
6293 if inlined {
6294 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6295 inner_offset = next_offset;
6296 } else {
6297 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6298 inner_depth.increment()?;
6299 }
6300 let val_ref = self.children.get_or_insert_with(|| {
6301 fidl::new_empty!(fidl::encoding::UnboundedVector<Child>, D)
6302 });
6303 fidl::decode!(
6304 fidl::encoding::UnboundedVector<Child>,
6305 D,
6306 val_ref,
6307 decoder,
6308 inner_offset,
6309 inner_depth
6310 )?;
6311 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6312 {
6313 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6314 }
6315 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6316 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6317 }
6318 }
6319
6320 next_offset += envelope_size;
6321 _next_ordinal_to_read += 1;
6322 if next_offset >= end_offset {
6323 return Ok(());
6324 }
6325
6326 while _next_ordinal_to_read < 7 {
6328 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6329 _next_ordinal_to_read += 1;
6330 next_offset += envelope_size;
6331 }
6332
6333 let next_out_of_line = decoder.next_out_of_line();
6334 let handles_before = decoder.remaining_handles();
6335 if let Some((inlined, num_bytes, num_handles)) =
6336 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6337 {
6338 let member_inline_size = <fidl::encoding::UnboundedVector<Collection> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6339 if inlined != (member_inline_size <= 4) {
6340 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6341 }
6342 let inner_offset;
6343 let mut inner_depth = depth.clone();
6344 if inlined {
6345 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6346 inner_offset = next_offset;
6347 } else {
6348 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6349 inner_depth.increment()?;
6350 }
6351 let val_ref = self.collections.get_or_insert_with(|| {
6352 fidl::new_empty!(fidl::encoding::UnboundedVector<Collection>, D)
6353 });
6354 fidl::decode!(
6355 fidl::encoding::UnboundedVector<Collection>,
6356 D,
6357 val_ref,
6358 decoder,
6359 inner_offset,
6360 inner_depth
6361 )?;
6362 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6363 {
6364 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6365 }
6366 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6367 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6368 }
6369 }
6370
6371 next_offset += envelope_size;
6372 _next_ordinal_to_read += 1;
6373 if next_offset >= end_offset {
6374 return Ok(());
6375 }
6376
6377 while _next_ordinal_to_read < 8 {
6379 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6380 _next_ordinal_to_read += 1;
6381 next_offset += envelope_size;
6382 }
6383
6384 let next_out_of_line = decoder.next_out_of_line();
6385 let handles_before = decoder.remaining_handles();
6386 if let Some((inlined, num_bytes, num_handles)) =
6387 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6388 {
6389 let member_inline_size = <fidl::encoding::UnboundedVector<Environment> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6390 if inlined != (member_inline_size <= 4) {
6391 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6392 }
6393 let inner_offset;
6394 let mut inner_depth = depth.clone();
6395 if inlined {
6396 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6397 inner_offset = next_offset;
6398 } else {
6399 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6400 inner_depth.increment()?;
6401 }
6402 let val_ref = self.environments.get_or_insert_with(|| {
6403 fidl::new_empty!(fidl::encoding::UnboundedVector<Environment>, D)
6404 });
6405 fidl::decode!(
6406 fidl::encoding::UnboundedVector<Environment>,
6407 D,
6408 val_ref,
6409 decoder,
6410 inner_offset,
6411 inner_depth
6412 )?;
6413 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6414 {
6415 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6416 }
6417 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6418 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6419 }
6420 }
6421
6422 next_offset += envelope_size;
6423 _next_ordinal_to_read += 1;
6424 if next_offset >= end_offset {
6425 return Ok(());
6426 }
6427
6428 while _next_ordinal_to_read < 9 {
6430 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6431 _next_ordinal_to_read += 1;
6432 next_offset += envelope_size;
6433 }
6434
6435 let next_out_of_line = decoder.next_out_of_line();
6436 let handles_before = decoder.remaining_handles();
6437 if let Some((inlined, num_bytes, num_handles)) =
6438 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6439 {
6440 let member_inline_size = <fidl_fuchsia_data__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6441 if inlined != (member_inline_size <= 4) {
6442 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6443 }
6444 let inner_offset;
6445 let mut inner_depth = depth.clone();
6446 if inlined {
6447 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6448 inner_offset = next_offset;
6449 } else {
6450 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6451 inner_depth.increment()?;
6452 }
6453 let val_ref = self.facets.get_or_insert_with(|| {
6454 fidl::new_empty!(fidl_fuchsia_data__common::Dictionary, D)
6455 });
6456 fidl::decode!(
6457 fidl_fuchsia_data__common::Dictionary,
6458 D,
6459 val_ref,
6460 decoder,
6461 inner_offset,
6462 inner_depth
6463 )?;
6464 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6465 {
6466 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6467 }
6468 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6469 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6470 }
6471 }
6472
6473 next_offset += envelope_size;
6474 _next_ordinal_to_read += 1;
6475 if next_offset >= end_offset {
6476 return Ok(());
6477 }
6478
6479 while _next_ordinal_to_read < 10 {
6481 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6482 _next_ordinal_to_read += 1;
6483 next_offset += envelope_size;
6484 }
6485
6486 let next_out_of_line = decoder.next_out_of_line();
6487 let handles_before = decoder.remaining_handles();
6488 if let Some((inlined, num_bytes, num_handles)) =
6489 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6490 {
6491 let member_inline_size =
6492 <ConfigSchema as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6493 if inlined != (member_inline_size <= 4) {
6494 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6495 }
6496 let inner_offset;
6497 let mut inner_depth = depth.clone();
6498 if inlined {
6499 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6500 inner_offset = next_offset;
6501 } else {
6502 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6503 inner_depth.increment()?;
6504 }
6505 let val_ref = self.config.get_or_insert_with(|| fidl::new_empty!(ConfigSchema, D));
6506 fidl::decode!(ConfigSchema, D, val_ref, decoder, inner_offset, inner_depth)?;
6507 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6508 {
6509 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6510 }
6511 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6512 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6513 }
6514 }
6515
6516 next_offset += envelope_size;
6517
6518 while next_offset < end_offset {
6520 _next_ordinal_to_read += 1;
6521 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6522 next_offset += envelope_size;
6523 }
6524
6525 Ok(())
6526 }
6527 }
6528
6529 impl ConfigField {
6530 #[inline(always)]
6531 fn max_ordinal_present(&self) -> u64 {
6532 if let Some(_) = self.mutability {
6533 return 3;
6534 }
6535 if let Some(_) = self.type_ {
6536 return 2;
6537 }
6538 if let Some(_) = self.key {
6539 return 1;
6540 }
6541 0
6542 }
6543 }
6544
6545 impl fidl::encoding::ValueTypeMarker for ConfigField {
6546 type Borrowed<'a> = &'a Self;
6547 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6548 value
6549 }
6550 }
6551
6552 unsafe impl fidl::encoding::TypeMarker for ConfigField {
6553 type Owned = Self;
6554
6555 #[inline(always)]
6556 fn inline_align(_context: fidl::encoding::Context) -> usize {
6557 8
6558 }
6559
6560 #[inline(always)]
6561 fn inline_size(_context: fidl::encoding::Context) -> usize {
6562 16
6563 }
6564 }
6565
6566 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigField, D>
6567 for &ConfigField
6568 {
6569 unsafe fn encode(
6570 self,
6571 encoder: &mut fidl::encoding::Encoder<'_, D>,
6572 offset: usize,
6573 mut depth: fidl::encoding::Depth,
6574 ) -> fidl::Result<()> {
6575 encoder.debug_check_bounds::<ConfigField>(offset);
6576 let max_ordinal: u64 = self.max_ordinal_present();
6578 encoder.write_num(max_ordinal, offset);
6579 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6580 if max_ordinal == 0 {
6582 return Ok(());
6583 }
6584 depth.increment()?;
6585 let envelope_size = 8;
6586 let bytes_len = max_ordinal as usize * envelope_size;
6587 #[allow(unused_variables)]
6588 let offset = encoder.out_of_line_offset(bytes_len);
6589 let mut _prev_end_offset: usize = 0;
6590 if 1 > max_ordinal {
6591 return Ok(());
6592 }
6593
6594 let cur_offset: usize = (1 - 1) * envelope_size;
6597
6598 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6600
6601 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6606 self.key.as_ref().map(
6607 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6608 ),
6609 encoder,
6610 offset + cur_offset,
6611 depth,
6612 )?;
6613
6614 _prev_end_offset = cur_offset + envelope_size;
6615 if 2 > max_ordinal {
6616 return Ok(());
6617 }
6618
6619 let cur_offset: usize = (2 - 1) * envelope_size;
6622
6623 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6625
6626 fidl::encoding::encode_in_envelope_optional::<ConfigType, D>(
6631 self.type_.as_ref().map(<ConfigType as fidl::encoding::ValueTypeMarker>::borrow),
6632 encoder,
6633 offset + cur_offset,
6634 depth,
6635 )?;
6636
6637 _prev_end_offset = cur_offset + envelope_size;
6638 if 3 > max_ordinal {
6639 return Ok(());
6640 }
6641
6642 let cur_offset: usize = (3 - 1) * envelope_size;
6645
6646 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6648
6649 fidl::encoding::encode_in_envelope_optional::<ConfigMutability, D>(
6654 self.mutability
6655 .as_ref()
6656 .map(<ConfigMutability as fidl::encoding::ValueTypeMarker>::borrow),
6657 encoder,
6658 offset + cur_offset,
6659 depth,
6660 )?;
6661
6662 _prev_end_offset = cur_offset + envelope_size;
6663
6664 Ok(())
6665 }
6666 }
6667
6668 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigField {
6669 #[inline(always)]
6670 fn new_empty() -> Self {
6671 Self::default()
6672 }
6673
6674 unsafe fn decode(
6675 &mut self,
6676 decoder: &mut fidl::encoding::Decoder<'_, D>,
6677 offset: usize,
6678 mut depth: fidl::encoding::Depth,
6679 ) -> fidl::Result<()> {
6680 decoder.debug_check_bounds::<Self>(offset);
6681 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6682 None => return Err(fidl::Error::NotNullable),
6683 Some(len) => len,
6684 };
6685 if len == 0 {
6687 return Ok(());
6688 };
6689 depth.increment()?;
6690 let envelope_size = 8;
6691 let bytes_len = len * envelope_size;
6692 let offset = decoder.out_of_line_offset(bytes_len)?;
6693 let mut _next_ordinal_to_read = 0;
6695 let mut next_offset = offset;
6696 let end_offset = offset + bytes_len;
6697 _next_ordinal_to_read += 1;
6698 if next_offset >= end_offset {
6699 return Ok(());
6700 }
6701
6702 while _next_ordinal_to_read < 1 {
6704 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6705 _next_ordinal_to_read += 1;
6706 next_offset += envelope_size;
6707 }
6708
6709 let next_out_of_line = decoder.next_out_of_line();
6710 let handles_before = decoder.remaining_handles();
6711 if let Some((inlined, num_bytes, num_handles)) =
6712 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6713 {
6714 let member_inline_size =
6715 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
6716 decoder.context,
6717 );
6718 if inlined != (member_inline_size <= 4) {
6719 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6720 }
6721 let inner_offset;
6722 let mut inner_depth = depth.clone();
6723 if inlined {
6724 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6725 inner_offset = next_offset;
6726 } else {
6727 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6728 inner_depth.increment()?;
6729 }
6730 let val_ref = self
6731 .key
6732 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
6733 fidl::decode!(
6734 fidl::encoding::BoundedString<64>,
6735 D,
6736 val_ref,
6737 decoder,
6738 inner_offset,
6739 inner_depth
6740 )?;
6741 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6742 {
6743 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6744 }
6745 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6746 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6747 }
6748 }
6749
6750 next_offset += envelope_size;
6751 _next_ordinal_to_read += 1;
6752 if next_offset >= end_offset {
6753 return Ok(());
6754 }
6755
6756 while _next_ordinal_to_read < 2 {
6758 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6759 _next_ordinal_to_read += 1;
6760 next_offset += envelope_size;
6761 }
6762
6763 let next_out_of_line = decoder.next_out_of_line();
6764 let handles_before = decoder.remaining_handles();
6765 if let Some((inlined, num_bytes, num_handles)) =
6766 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6767 {
6768 let member_inline_size =
6769 <ConfigType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6770 if inlined != (member_inline_size <= 4) {
6771 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6772 }
6773 let inner_offset;
6774 let mut inner_depth = depth.clone();
6775 if inlined {
6776 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6777 inner_offset = next_offset;
6778 } else {
6779 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6780 inner_depth.increment()?;
6781 }
6782 let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(ConfigType, D));
6783 fidl::decode!(ConfigType, D, val_ref, decoder, inner_offset, inner_depth)?;
6784 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6785 {
6786 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6787 }
6788 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6789 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6790 }
6791 }
6792
6793 next_offset += envelope_size;
6794 _next_ordinal_to_read += 1;
6795 if next_offset >= end_offset {
6796 return Ok(());
6797 }
6798
6799 while _next_ordinal_to_read < 3 {
6801 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6802 _next_ordinal_to_read += 1;
6803 next_offset += envelope_size;
6804 }
6805
6806 let next_out_of_line = decoder.next_out_of_line();
6807 let handles_before = decoder.remaining_handles();
6808 if let Some((inlined, num_bytes, num_handles)) =
6809 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6810 {
6811 let member_inline_size =
6812 <ConfigMutability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6813 if inlined != (member_inline_size <= 4) {
6814 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6815 }
6816 let inner_offset;
6817 let mut inner_depth = depth.clone();
6818 if inlined {
6819 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6820 inner_offset = next_offset;
6821 } else {
6822 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6823 inner_depth.increment()?;
6824 }
6825 let val_ref =
6826 self.mutability.get_or_insert_with(|| fidl::new_empty!(ConfigMutability, D));
6827 fidl::decode!(ConfigMutability, D, val_ref, decoder, inner_offset, inner_depth)?;
6828 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6829 {
6830 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6831 }
6832 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6833 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6834 }
6835 }
6836
6837 next_offset += envelope_size;
6838
6839 while next_offset < end_offset {
6841 _next_ordinal_to_read += 1;
6842 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6843 next_offset += envelope_size;
6844 }
6845
6846 Ok(())
6847 }
6848 }
6849
6850 impl ConfigOverride {
6851 #[inline(always)]
6852 fn max_ordinal_present(&self) -> u64 {
6853 if let Some(_) = self.value {
6854 return 2;
6855 }
6856 if let Some(_) = self.key {
6857 return 1;
6858 }
6859 0
6860 }
6861 }
6862
6863 impl fidl::encoding::ValueTypeMarker for ConfigOverride {
6864 type Borrowed<'a> = &'a Self;
6865 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6866 value
6867 }
6868 }
6869
6870 unsafe impl fidl::encoding::TypeMarker for ConfigOverride {
6871 type Owned = Self;
6872
6873 #[inline(always)]
6874 fn inline_align(_context: fidl::encoding::Context) -> usize {
6875 8
6876 }
6877
6878 #[inline(always)]
6879 fn inline_size(_context: fidl::encoding::Context) -> usize {
6880 16
6881 }
6882 }
6883
6884 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigOverride, D>
6885 for &ConfigOverride
6886 {
6887 unsafe fn encode(
6888 self,
6889 encoder: &mut fidl::encoding::Encoder<'_, D>,
6890 offset: usize,
6891 mut depth: fidl::encoding::Depth,
6892 ) -> fidl::Result<()> {
6893 encoder.debug_check_bounds::<ConfigOverride>(offset);
6894 let max_ordinal: u64 = self.max_ordinal_present();
6896 encoder.write_num(max_ordinal, offset);
6897 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6898 if max_ordinal == 0 {
6900 return Ok(());
6901 }
6902 depth.increment()?;
6903 let envelope_size = 8;
6904 let bytes_len = max_ordinal as usize * envelope_size;
6905 #[allow(unused_variables)]
6906 let offset = encoder.out_of_line_offset(bytes_len);
6907 let mut _prev_end_offset: usize = 0;
6908 if 1 > max_ordinal {
6909 return Ok(());
6910 }
6911
6912 let cur_offset: usize = (1 - 1) * envelope_size;
6915
6916 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6918
6919 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6924 self.key.as_ref().map(
6925 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6926 ),
6927 encoder,
6928 offset + cur_offset,
6929 depth,
6930 )?;
6931
6932 _prev_end_offset = cur_offset + envelope_size;
6933 if 2 > max_ordinal {
6934 return Ok(());
6935 }
6936
6937 let cur_offset: usize = (2 - 1) * envelope_size;
6940
6941 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6943
6944 fidl::encoding::encode_in_envelope_optional::<ConfigValue, D>(
6949 self.value.as_ref().map(<ConfigValue as fidl::encoding::ValueTypeMarker>::borrow),
6950 encoder,
6951 offset + cur_offset,
6952 depth,
6953 )?;
6954
6955 _prev_end_offset = cur_offset + envelope_size;
6956
6957 Ok(())
6958 }
6959 }
6960
6961 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigOverride {
6962 #[inline(always)]
6963 fn new_empty() -> Self {
6964 Self::default()
6965 }
6966
6967 unsafe fn decode(
6968 &mut self,
6969 decoder: &mut fidl::encoding::Decoder<'_, D>,
6970 offset: usize,
6971 mut depth: fidl::encoding::Depth,
6972 ) -> fidl::Result<()> {
6973 decoder.debug_check_bounds::<Self>(offset);
6974 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6975 None => return Err(fidl::Error::NotNullable),
6976 Some(len) => len,
6977 };
6978 if len == 0 {
6980 return Ok(());
6981 };
6982 depth.increment()?;
6983 let envelope_size = 8;
6984 let bytes_len = len * envelope_size;
6985 let offset = decoder.out_of_line_offset(bytes_len)?;
6986 let mut _next_ordinal_to_read = 0;
6988 let mut next_offset = offset;
6989 let end_offset = offset + bytes_len;
6990 _next_ordinal_to_read += 1;
6991 if next_offset >= end_offset {
6992 return Ok(());
6993 }
6994
6995 while _next_ordinal_to_read < 1 {
6997 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6998 _next_ordinal_to_read += 1;
6999 next_offset += envelope_size;
7000 }
7001
7002 let next_out_of_line = decoder.next_out_of_line();
7003 let handles_before = decoder.remaining_handles();
7004 if let Some((inlined, num_bytes, num_handles)) =
7005 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7006 {
7007 let member_inline_size =
7008 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
7009 decoder.context,
7010 );
7011 if inlined != (member_inline_size <= 4) {
7012 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7013 }
7014 let inner_offset;
7015 let mut inner_depth = depth.clone();
7016 if inlined {
7017 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7018 inner_offset = next_offset;
7019 } else {
7020 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7021 inner_depth.increment()?;
7022 }
7023 let val_ref = self
7024 .key
7025 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
7026 fidl::decode!(
7027 fidl::encoding::BoundedString<64>,
7028 D,
7029 val_ref,
7030 decoder,
7031 inner_offset,
7032 inner_depth
7033 )?;
7034 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7035 {
7036 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7037 }
7038 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7039 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7040 }
7041 }
7042
7043 next_offset += envelope_size;
7044 _next_ordinal_to_read += 1;
7045 if next_offset >= end_offset {
7046 return Ok(());
7047 }
7048
7049 while _next_ordinal_to_read < 2 {
7051 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7052 _next_ordinal_to_read += 1;
7053 next_offset += envelope_size;
7054 }
7055
7056 let next_out_of_line = decoder.next_out_of_line();
7057 let handles_before = decoder.remaining_handles();
7058 if let Some((inlined, num_bytes, num_handles)) =
7059 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7060 {
7061 let member_inline_size =
7062 <ConfigValue as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7063 if inlined != (member_inline_size <= 4) {
7064 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7065 }
7066 let inner_offset;
7067 let mut inner_depth = depth.clone();
7068 if inlined {
7069 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7070 inner_offset = next_offset;
7071 } else {
7072 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7073 inner_depth.increment()?;
7074 }
7075 let val_ref = self.value.get_or_insert_with(|| fidl::new_empty!(ConfigValue, D));
7076 fidl::decode!(ConfigValue, D, val_ref, decoder, inner_offset, inner_depth)?;
7077 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7078 {
7079 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7080 }
7081 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7082 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7083 }
7084 }
7085
7086 next_offset += envelope_size;
7087
7088 while next_offset < end_offset {
7090 _next_ordinal_to_read += 1;
7091 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7092 next_offset += envelope_size;
7093 }
7094
7095 Ok(())
7096 }
7097 }
7098
7099 impl ConfigSchema {
7100 #[inline(always)]
7101 fn max_ordinal_present(&self) -> u64 {
7102 if let Some(_) = self.value_source {
7103 return 3;
7104 }
7105 if let Some(_) = self.checksum {
7106 return 2;
7107 }
7108 if let Some(_) = self.fields {
7109 return 1;
7110 }
7111 0
7112 }
7113 }
7114
7115 impl fidl::encoding::ValueTypeMarker for ConfigSchema {
7116 type Borrowed<'a> = &'a Self;
7117 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7118 value
7119 }
7120 }
7121
7122 unsafe impl fidl::encoding::TypeMarker for ConfigSchema {
7123 type Owned = Self;
7124
7125 #[inline(always)]
7126 fn inline_align(_context: fidl::encoding::Context) -> usize {
7127 8
7128 }
7129
7130 #[inline(always)]
7131 fn inline_size(_context: fidl::encoding::Context) -> usize {
7132 16
7133 }
7134 }
7135
7136 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigSchema, D>
7137 for &ConfigSchema
7138 {
7139 unsafe fn encode(
7140 self,
7141 encoder: &mut fidl::encoding::Encoder<'_, D>,
7142 offset: usize,
7143 mut depth: fidl::encoding::Depth,
7144 ) -> fidl::Result<()> {
7145 encoder.debug_check_bounds::<ConfigSchema>(offset);
7146 let max_ordinal: u64 = self.max_ordinal_present();
7148 encoder.write_num(max_ordinal, offset);
7149 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7150 if max_ordinal == 0 {
7152 return Ok(());
7153 }
7154 depth.increment()?;
7155 let envelope_size = 8;
7156 let bytes_len = max_ordinal as usize * envelope_size;
7157 #[allow(unused_variables)]
7158 let offset = encoder.out_of_line_offset(bytes_len);
7159 let mut _prev_end_offset: usize = 0;
7160 if 1 > max_ordinal {
7161 return Ok(());
7162 }
7163
7164 let cur_offset: usize = (1 - 1) * envelope_size;
7167
7168 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7170
7171 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ConfigField>, D>(
7176 self.fields.as_ref().map(<fidl::encoding::UnboundedVector<ConfigField> as fidl::encoding::ValueTypeMarker>::borrow),
7177 encoder, offset + cur_offset, depth
7178 )?;
7179
7180 _prev_end_offset = cur_offset + envelope_size;
7181 if 2 > max_ordinal {
7182 return Ok(());
7183 }
7184
7185 let cur_offset: usize = (2 - 1) * envelope_size;
7188
7189 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7191
7192 fidl::encoding::encode_in_envelope_optional::<ConfigChecksum, D>(
7197 self.checksum
7198 .as_ref()
7199 .map(<ConfigChecksum as fidl::encoding::ValueTypeMarker>::borrow),
7200 encoder,
7201 offset + cur_offset,
7202 depth,
7203 )?;
7204
7205 _prev_end_offset = cur_offset + envelope_size;
7206 if 3 > max_ordinal {
7207 return Ok(());
7208 }
7209
7210 let cur_offset: usize = (3 - 1) * envelope_size;
7213
7214 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7216
7217 fidl::encoding::encode_in_envelope_optional::<ConfigValueSource, D>(
7222 self.value_source
7223 .as_ref()
7224 .map(<ConfigValueSource as fidl::encoding::ValueTypeMarker>::borrow),
7225 encoder,
7226 offset + cur_offset,
7227 depth,
7228 )?;
7229
7230 _prev_end_offset = cur_offset + envelope_size;
7231
7232 Ok(())
7233 }
7234 }
7235
7236 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigSchema {
7237 #[inline(always)]
7238 fn new_empty() -> Self {
7239 Self::default()
7240 }
7241
7242 unsafe fn decode(
7243 &mut self,
7244 decoder: &mut fidl::encoding::Decoder<'_, D>,
7245 offset: usize,
7246 mut depth: fidl::encoding::Depth,
7247 ) -> fidl::Result<()> {
7248 decoder.debug_check_bounds::<Self>(offset);
7249 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7250 None => return Err(fidl::Error::NotNullable),
7251 Some(len) => len,
7252 };
7253 if len == 0 {
7255 return Ok(());
7256 };
7257 depth.increment()?;
7258 let envelope_size = 8;
7259 let bytes_len = len * envelope_size;
7260 let offset = decoder.out_of_line_offset(bytes_len)?;
7261 let mut _next_ordinal_to_read = 0;
7263 let mut next_offset = offset;
7264 let end_offset = offset + bytes_len;
7265 _next_ordinal_to_read += 1;
7266 if next_offset >= end_offset {
7267 return Ok(());
7268 }
7269
7270 while _next_ordinal_to_read < 1 {
7272 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7273 _next_ordinal_to_read += 1;
7274 next_offset += envelope_size;
7275 }
7276
7277 let next_out_of_line = decoder.next_out_of_line();
7278 let handles_before = decoder.remaining_handles();
7279 if let Some((inlined, num_bytes, num_handles)) =
7280 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7281 {
7282 let member_inline_size = <fidl::encoding::UnboundedVector<ConfigField> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7283 if inlined != (member_inline_size <= 4) {
7284 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7285 }
7286 let inner_offset;
7287 let mut inner_depth = depth.clone();
7288 if inlined {
7289 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7290 inner_offset = next_offset;
7291 } else {
7292 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7293 inner_depth.increment()?;
7294 }
7295 let val_ref = self.fields.get_or_insert_with(|| {
7296 fidl::new_empty!(fidl::encoding::UnboundedVector<ConfigField>, D)
7297 });
7298 fidl::decode!(
7299 fidl::encoding::UnboundedVector<ConfigField>,
7300 D,
7301 val_ref,
7302 decoder,
7303 inner_offset,
7304 inner_depth
7305 )?;
7306 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7307 {
7308 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7309 }
7310 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7311 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7312 }
7313 }
7314
7315 next_offset += envelope_size;
7316 _next_ordinal_to_read += 1;
7317 if next_offset >= end_offset {
7318 return Ok(());
7319 }
7320
7321 while _next_ordinal_to_read < 2 {
7323 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7324 _next_ordinal_to_read += 1;
7325 next_offset += envelope_size;
7326 }
7327
7328 let next_out_of_line = decoder.next_out_of_line();
7329 let handles_before = decoder.remaining_handles();
7330 if let Some((inlined, num_bytes, num_handles)) =
7331 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7332 {
7333 let member_inline_size =
7334 <ConfigChecksum as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7335 if inlined != (member_inline_size <= 4) {
7336 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7337 }
7338 let inner_offset;
7339 let mut inner_depth = depth.clone();
7340 if inlined {
7341 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7342 inner_offset = next_offset;
7343 } else {
7344 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7345 inner_depth.increment()?;
7346 }
7347 let val_ref =
7348 self.checksum.get_or_insert_with(|| fidl::new_empty!(ConfigChecksum, D));
7349 fidl::decode!(ConfigChecksum, D, val_ref, decoder, inner_offset, inner_depth)?;
7350 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7351 {
7352 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7353 }
7354 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7355 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7356 }
7357 }
7358
7359 next_offset += envelope_size;
7360 _next_ordinal_to_read += 1;
7361 if next_offset >= end_offset {
7362 return Ok(());
7363 }
7364
7365 while _next_ordinal_to_read < 3 {
7367 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7368 _next_ordinal_to_read += 1;
7369 next_offset += envelope_size;
7370 }
7371
7372 let next_out_of_line = decoder.next_out_of_line();
7373 let handles_before = decoder.remaining_handles();
7374 if let Some((inlined, num_bytes, num_handles)) =
7375 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7376 {
7377 let member_inline_size =
7378 <ConfigValueSource as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7379 if inlined != (member_inline_size <= 4) {
7380 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7381 }
7382 let inner_offset;
7383 let mut inner_depth = depth.clone();
7384 if inlined {
7385 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7386 inner_offset = next_offset;
7387 } else {
7388 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7389 inner_depth.increment()?;
7390 }
7391 let val_ref =
7392 self.value_source.get_or_insert_with(|| fidl::new_empty!(ConfigValueSource, D));
7393 fidl::decode!(ConfigValueSource, D, val_ref, decoder, inner_offset, inner_depth)?;
7394 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7395 {
7396 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7397 }
7398 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7399 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7400 }
7401 }
7402
7403 next_offset += envelope_size;
7404
7405 while next_offset < end_offset {
7407 _next_ordinal_to_read += 1;
7408 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7409 next_offset += envelope_size;
7410 }
7411
7412 Ok(())
7413 }
7414 }
7415
7416 impl ConfigSourceCapabilities {
7417 #[inline(always)]
7418 fn max_ordinal_present(&self) -> u64 {
7419 0
7420 }
7421 }
7422
7423 impl fidl::encoding::ValueTypeMarker for ConfigSourceCapabilities {
7424 type Borrowed<'a> = &'a Self;
7425 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7426 value
7427 }
7428 }
7429
7430 unsafe impl fidl::encoding::TypeMarker for ConfigSourceCapabilities {
7431 type Owned = Self;
7432
7433 #[inline(always)]
7434 fn inline_align(_context: fidl::encoding::Context) -> usize {
7435 8
7436 }
7437
7438 #[inline(always)]
7439 fn inline_size(_context: fidl::encoding::Context) -> usize {
7440 16
7441 }
7442 }
7443
7444 unsafe impl<D: fidl::encoding::ResourceDialect>
7445 fidl::encoding::Encode<ConfigSourceCapabilities, D> for &ConfigSourceCapabilities
7446 {
7447 unsafe fn encode(
7448 self,
7449 encoder: &mut fidl::encoding::Encoder<'_, D>,
7450 offset: usize,
7451 mut depth: fidl::encoding::Depth,
7452 ) -> fidl::Result<()> {
7453 encoder.debug_check_bounds::<ConfigSourceCapabilities>(offset);
7454 let max_ordinal: u64 = self.max_ordinal_present();
7456 encoder.write_num(max_ordinal, offset);
7457 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7458 if max_ordinal == 0 {
7460 return Ok(());
7461 }
7462 depth.increment()?;
7463 let envelope_size = 8;
7464 let bytes_len = max_ordinal as usize * envelope_size;
7465 #[allow(unused_variables)]
7466 let offset = encoder.out_of_line_offset(bytes_len);
7467 let mut _prev_end_offset: usize = 0;
7468
7469 Ok(())
7470 }
7471 }
7472
7473 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7474 for ConfigSourceCapabilities
7475 {
7476 #[inline(always)]
7477 fn new_empty() -> Self {
7478 Self::default()
7479 }
7480
7481 unsafe fn decode(
7482 &mut self,
7483 decoder: &mut fidl::encoding::Decoder<'_, D>,
7484 offset: usize,
7485 mut depth: fidl::encoding::Depth,
7486 ) -> fidl::Result<()> {
7487 decoder.debug_check_bounds::<Self>(offset);
7488 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7489 None => return Err(fidl::Error::NotNullable),
7490 Some(len) => len,
7491 };
7492 if len == 0 {
7494 return Ok(());
7495 };
7496 depth.increment()?;
7497 let envelope_size = 8;
7498 let bytes_len = len * envelope_size;
7499 let offset = decoder.out_of_line_offset(bytes_len)?;
7500 let mut _next_ordinal_to_read = 0;
7502 let mut next_offset = offset;
7503 let end_offset = offset + bytes_len;
7504
7505 while next_offset < end_offset {
7507 _next_ordinal_to_read += 1;
7508 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7509 next_offset += envelope_size;
7510 }
7511
7512 Ok(())
7513 }
7514 }
7515
7516 impl ConfigValueSpec {
7517 #[inline(always)]
7518 fn max_ordinal_present(&self) -> u64 {
7519 if let Some(_) = self.value {
7520 return 1;
7521 }
7522 0
7523 }
7524 }
7525
7526 impl fidl::encoding::ValueTypeMarker for ConfigValueSpec {
7527 type Borrowed<'a> = &'a Self;
7528 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7529 value
7530 }
7531 }
7532
7533 unsafe impl fidl::encoding::TypeMarker for ConfigValueSpec {
7534 type Owned = Self;
7535
7536 #[inline(always)]
7537 fn inline_align(_context: fidl::encoding::Context) -> usize {
7538 8
7539 }
7540
7541 #[inline(always)]
7542 fn inline_size(_context: fidl::encoding::Context) -> usize {
7543 16
7544 }
7545 }
7546
7547 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigValueSpec, D>
7548 for &ConfigValueSpec
7549 {
7550 unsafe fn encode(
7551 self,
7552 encoder: &mut fidl::encoding::Encoder<'_, D>,
7553 offset: usize,
7554 mut depth: fidl::encoding::Depth,
7555 ) -> fidl::Result<()> {
7556 encoder.debug_check_bounds::<ConfigValueSpec>(offset);
7557 let max_ordinal: u64 = self.max_ordinal_present();
7559 encoder.write_num(max_ordinal, offset);
7560 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7561 if max_ordinal == 0 {
7563 return Ok(());
7564 }
7565 depth.increment()?;
7566 let envelope_size = 8;
7567 let bytes_len = max_ordinal as usize * envelope_size;
7568 #[allow(unused_variables)]
7569 let offset = encoder.out_of_line_offset(bytes_len);
7570 let mut _prev_end_offset: usize = 0;
7571 if 1 > max_ordinal {
7572 return Ok(());
7573 }
7574
7575 let cur_offset: usize = (1 - 1) * envelope_size;
7578
7579 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7581
7582 fidl::encoding::encode_in_envelope_optional::<ConfigValue, D>(
7587 self.value.as_ref().map(<ConfigValue as fidl::encoding::ValueTypeMarker>::borrow),
7588 encoder,
7589 offset + cur_offset,
7590 depth,
7591 )?;
7592
7593 _prev_end_offset = cur_offset + envelope_size;
7594
7595 Ok(())
7596 }
7597 }
7598
7599 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigValueSpec {
7600 #[inline(always)]
7601 fn new_empty() -> Self {
7602 Self::default()
7603 }
7604
7605 unsafe fn decode(
7606 &mut self,
7607 decoder: &mut fidl::encoding::Decoder<'_, D>,
7608 offset: usize,
7609 mut depth: fidl::encoding::Depth,
7610 ) -> fidl::Result<()> {
7611 decoder.debug_check_bounds::<Self>(offset);
7612 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7613 None => return Err(fidl::Error::NotNullable),
7614 Some(len) => len,
7615 };
7616 if len == 0 {
7618 return Ok(());
7619 };
7620 depth.increment()?;
7621 let envelope_size = 8;
7622 let bytes_len = len * envelope_size;
7623 let offset = decoder.out_of_line_offset(bytes_len)?;
7624 let mut _next_ordinal_to_read = 0;
7626 let mut next_offset = offset;
7627 let end_offset = offset + bytes_len;
7628 _next_ordinal_to_read += 1;
7629 if next_offset >= end_offset {
7630 return Ok(());
7631 }
7632
7633 while _next_ordinal_to_read < 1 {
7635 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7636 _next_ordinal_to_read += 1;
7637 next_offset += envelope_size;
7638 }
7639
7640 let next_out_of_line = decoder.next_out_of_line();
7641 let handles_before = decoder.remaining_handles();
7642 if let Some((inlined, num_bytes, num_handles)) =
7643 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7644 {
7645 let member_inline_size =
7646 <ConfigValue as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7647 if inlined != (member_inline_size <= 4) {
7648 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7649 }
7650 let inner_offset;
7651 let mut inner_depth = depth.clone();
7652 if inlined {
7653 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7654 inner_offset = next_offset;
7655 } else {
7656 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7657 inner_depth.increment()?;
7658 }
7659 let val_ref = self.value.get_or_insert_with(|| fidl::new_empty!(ConfigValue, D));
7660 fidl::decode!(ConfigValue, D, val_ref, decoder, inner_offset, inner_depth)?;
7661 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7662 {
7663 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7664 }
7665 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7666 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7667 }
7668 }
7669
7670 next_offset += envelope_size;
7671
7672 while next_offset < end_offset {
7674 _next_ordinal_to_read += 1;
7675 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7676 next_offset += envelope_size;
7677 }
7678
7679 Ok(())
7680 }
7681 }
7682
7683 impl ConfigValuesData {
7684 #[inline(always)]
7685 fn max_ordinal_present(&self) -> u64 {
7686 if let Some(_) = self.checksum {
7687 return 2;
7688 }
7689 if let Some(_) = self.values {
7690 return 1;
7691 }
7692 0
7693 }
7694 }
7695
7696 impl fidl::encoding::ValueTypeMarker for ConfigValuesData {
7697 type Borrowed<'a> = &'a Self;
7698 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7699 value
7700 }
7701 }
7702
7703 unsafe impl fidl::encoding::TypeMarker for ConfigValuesData {
7704 type Owned = Self;
7705
7706 #[inline(always)]
7707 fn inline_align(_context: fidl::encoding::Context) -> usize {
7708 8
7709 }
7710
7711 #[inline(always)]
7712 fn inline_size(_context: fidl::encoding::Context) -> usize {
7713 16
7714 }
7715 }
7716
7717 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigValuesData, D>
7718 for &ConfigValuesData
7719 {
7720 unsafe fn encode(
7721 self,
7722 encoder: &mut fidl::encoding::Encoder<'_, D>,
7723 offset: usize,
7724 mut depth: fidl::encoding::Depth,
7725 ) -> fidl::Result<()> {
7726 encoder.debug_check_bounds::<ConfigValuesData>(offset);
7727 let max_ordinal: u64 = self.max_ordinal_present();
7729 encoder.write_num(max_ordinal, offset);
7730 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7731 if max_ordinal == 0 {
7733 return Ok(());
7734 }
7735 depth.increment()?;
7736 let envelope_size = 8;
7737 let bytes_len = max_ordinal as usize * envelope_size;
7738 #[allow(unused_variables)]
7739 let offset = encoder.out_of_line_offset(bytes_len);
7740 let mut _prev_end_offset: usize = 0;
7741 if 1 > max_ordinal {
7742 return Ok(());
7743 }
7744
7745 let cur_offset: usize = (1 - 1) * envelope_size;
7748
7749 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7751
7752 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ConfigValueSpec>, D>(
7757 self.values.as_ref().map(<fidl::encoding::UnboundedVector<ConfigValueSpec> as fidl::encoding::ValueTypeMarker>::borrow),
7758 encoder, offset + cur_offset, depth
7759 )?;
7760
7761 _prev_end_offset = cur_offset + envelope_size;
7762 if 2 > max_ordinal {
7763 return Ok(());
7764 }
7765
7766 let cur_offset: usize = (2 - 1) * envelope_size;
7769
7770 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7772
7773 fidl::encoding::encode_in_envelope_optional::<ConfigChecksum, D>(
7778 self.checksum
7779 .as_ref()
7780 .map(<ConfigChecksum as fidl::encoding::ValueTypeMarker>::borrow),
7781 encoder,
7782 offset + cur_offset,
7783 depth,
7784 )?;
7785
7786 _prev_end_offset = cur_offset + envelope_size;
7787
7788 Ok(())
7789 }
7790 }
7791
7792 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigValuesData {
7793 #[inline(always)]
7794 fn new_empty() -> Self {
7795 Self::default()
7796 }
7797
7798 unsafe fn decode(
7799 &mut self,
7800 decoder: &mut fidl::encoding::Decoder<'_, D>,
7801 offset: usize,
7802 mut depth: fidl::encoding::Depth,
7803 ) -> fidl::Result<()> {
7804 decoder.debug_check_bounds::<Self>(offset);
7805 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7806 None => return Err(fidl::Error::NotNullable),
7807 Some(len) => len,
7808 };
7809 if len == 0 {
7811 return Ok(());
7812 };
7813 depth.increment()?;
7814 let envelope_size = 8;
7815 let bytes_len = len * envelope_size;
7816 let offset = decoder.out_of_line_offset(bytes_len)?;
7817 let mut _next_ordinal_to_read = 0;
7819 let mut next_offset = offset;
7820 let end_offset = offset + bytes_len;
7821 _next_ordinal_to_read += 1;
7822 if next_offset >= end_offset {
7823 return Ok(());
7824 }
7825
7826 while _next_ordinal_to_read < 1 {
7828 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7829 _next_ordinal_to_read += 1;
7830 next_offset += envelope_size;
7831 }
7832
7833 let next_out_of_line = decoder.next_out_of_line();
7834 let handles_before = decoder.remaining_handles();
7835 if let Some((inlined, num_bytes, num_handles)) =
7836 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7837 {
7838 let member_inline_size = <fidl::encoding::UnboundedVector<ConfigValueSpec> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7839 if inlined != (member_inline_size <= 4) {
7840 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7841 }
7842 let inner_offset;
7843 let mut inner_depth = depth.clone();
7844 if inlined {
7845 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7846 inner_offset = next_offset;
7847 } else {
7848 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7849 inner_depth.increment()?;
7850 }
7851 let val_ref = self.values.get_or_insert_with(|| {
7852 fidl::new_empty!(fidl::encoding::UnboundedVector<ConfigValueSpec>, D)
7853 });
7854 fidl::decode!(
7855 fidl::encoding::UnboundedVector<ConfigValueSpec>,
7856 D,
7857 val_ref,
7858 decoder,
7859 inner_offset,
7860 inner_depth
7861 )?;
7862 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7863 {
7864 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7865 }
7866 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7867 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7868 }
7869 }
7870
7871 next_offset += envelope_size;
7872 _next_ordinal_to_read += 1;
7873 if next_offset >= end_offset {
7874 return Ok(());
7875 }
7876
7877 while _next_ordinal_to_read < 2 {
7879 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7880 _next_ordinal_to_read += 1;
7881 next_offset += envelope_size;
7882 }
7883
7884 let next_out_of_line = decoder.next_out_of_line();
7885 let handles_before = decoder.remaining_handles();
7886 if let Some((inlined, num_bytes, num_handles)) =
7887 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7888 {
7889 let member_inline_size =
7890 <ConfigChecksum as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7891 if inlined != (member_inline_size <= 4) {
7892 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7893 }
7894 let inner_offset;
7895 let mut inner_depth = depth.clone();
7896 if inlined {
7897 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7898 inner_offset = next_offset;
7899 } else {
7900 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7901 inner_depth.increment()?;
7902 }
7903 let val_ref =
7904 self.checksum.get_or_insert_with(|| fidl::new_empty!(ConfigChecksum, D));
7905 fidl::decode!(ConfigChecksum, D, val_ref, decoder, inner_offset, inner_depth)?;
7906 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7907 {
7908 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7909 }
7910 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7911 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7912 }
7913 }
7914
7915 next_offset += envelope_size;
7916
7917 while next_offset < end_offset {
7919 _next_ordinal_to_read += 1;
7920 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7921 next_offset += envelope_size;
7922 }
7923
7924 Ok(())
7925 }
7926 }
7927
7928 impl Configuration {
7929 #[inline(always)]
7930 fn max_ordinal_present(&self) -> u64 {
7931 if let Some(_) = self.value {
7932 return 2;
7933 }
7934 if let Some(_) = self.name {
7935 return 1;
7936 }
7937 0
7938 }
7939 }
7940
7941 impl fidl::encoding::ValueTypeMarker for Configuration {
7942 type Borrowed<'a> = &'a Self;
7943 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7944 value
7945 }
7946 }
7947
7948 unsafe impl fidl::encoding::TypeMarker for Configuration {
7949 type Owned = Self;
7950
7951 #[inline(always)]
7952 fn inline_align(_context: fidl::encoding::Context) -> usize {
7953 8
7954 }
7955
7956 #[inline(always)]
7957 fn inline_size(_context: fidl::encoding::Context) -> usize {
7958 16
7959 }
7960 }
7961
7962 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Configuration, D>
7963 for &Configuration
7964 {
7965 unsafe fn encode(
7966 self,
7967 encoder: &mut fidl::encoding::Encoder<'_, D>,
7968 offset: usize,
7969 mut depth: fidl::encoding::Depth,
7970 ) -> fidl::Result<()> {
7971 encoder.debug_check_bounds::<Configuration>(offset);
7972 let max_ordinal: u64 = self.max_ordinal_present();
7974 encoder.write_num(max_ordinal, offset);
7975 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7976 if max_ordinal == 0 {
7978 return Ok(());
7979 }
7980 depth.increment()?;
7981 let envelope_size = 8;
7982 let bytes_len = max_ordinal as usize * envelope_size;
7983 #[allow(unused_variables)]
7984 let offset = encoder.out_of_line_offset(bytes_len);
7985 let mut _prev_end_offset: usize = 0;
7986 if 1 > max_ordinal {
7987 return Ok(());
7988 }
7989
7990 let cur_offset: usize = (1 - 1) * envelope_size;
7993
7994 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7996
7997 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8002 self.name.as_ref().map(
8003 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8004 ),
8005 encoder,
8006 offset + cur_offset,
8007 depth,
8008 )?;
8009
8010 _prev_end_offset = cur_offset + envelope_size;
8011 if 2 > max_ordinal {
8012 return Ok(());
8013 }
8014
8015 let cur_offset: usize = (2 - 1) * envelope_size;
8018
8019 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8021
8022 fidl::encoding::encode_in_envelope_optional::<ConfigValue, D>(
8027 self.value.as_ref().map(<ConfigValue as fidl::encoding::ValueTypeMarker>::borrow),
8028 encoder,
8029 offset + cur_offset,
8030 depth,
8031 )?;
8032
8033 _prev_end_offset = cur_offset + envelope_size;
8034
8035 Ok(())
8036 }
8037 }
8038
8039 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Configuration {
8040 #[inline(always)]
8041 fn new_empty() -> Self {
8042 Self::default()
8043 }
8044
8045 unsafe fn decode(
8046 &mut self,
8047 decoder: &mut fidl::encoding::Decoder<'_, D>,
8048 offset: usize,
8049 mut depth: fidl::encoding::Depth,
8050 ) -> fidl::Result<()> {
8051 decoder.debug_check_bounds::<Self>(offset);
8052 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8053 None => return Err(fidl::Error::NotNullable),
8054 Some(len) => len,
8055 };
8056 if len == 0 {
8058 return Ok(());
8059 };
8060 depth.increment()?;
8061 let envelope_size = 8;
8062 let bytes_len = len * envelope_size;
8063 let offset = decoder.out_of_line_offset(bytes_len)?;
8064 let mut _next_ordinal_to_read = 0;
8066 let mut next_offset = offset;
8067 let end_offset = offset + bytes_len;
8068 _next_ordinal_to_read += 1;
8069 if next_offset >= end_offset {
8070 return Ok(());
8071 }
8072
8073 while _next_ordinal_to_read < 1 {
8075 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8076 _next_ordinal_to_read += 1;
8077 next_offset += envelope_size;
8078 }
8079
8080 let next_out_of_line = decoder.next_out_of_line();
8081 let handles_before = decoder.remaining_handles();
8082 if let Some((inlined, num_bytes, num_handles)) =
8083 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8084 {
8085 let member_inline_size =
8086 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
8087 decoder.context,
8088 );
8089 if inlined != (member_inline_size <= 4) {
8090 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8091 }
8092 let inner_offset;
8093 let mut inner_depth = depth.clone();
8094 if inlined {
8095 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8096 inner_offset = next_offset;
8097 } else {
8098 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8099 inner_depth.increment()?;
8100 }
8101 let val_ref = self
8102 .name
8103 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
8104 fidl::decode!(
8105 fidl::encoding::BoundedString<100>,
8106 D,
8107 val_ref,
8108 decoder,
8109 inner_offset,
8110 inner_depth
8111 )?;
8112 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8113 {
8114 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8115 }
8116 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8117 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8118 }
8119 }
8120
8121 next_offset += envelope_size;
8122 _next_ordinal_to_read += 1;
8123 if next_offset >= end_offset {
8124 return Ok(());
8125 }
8126
8127 while _next_ordinal_to_read < 2 {
8129 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8130 _next_ordinal_to_read += 1;
8131 next_offset += envelope_size;
8132 }
8133
8134 let next_out_of_line = decoder.next_out_of_line();
8135 let handles_before = decoder.remaining_handles();
8136 if let Some((inlined, num_bytes, num_handles)) =
8137 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8138 {
8139 let member_inline_size =
8140 <ConfigValue as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8141 if inlined != (member_inline_size <= 4) {
8142 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8143 }
8144 let inner_offset;
8145 let mut inner_depth = depth.clone();
8146 if inlined {
8147 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8148 inner_offset = next_offset;
8149 } else {
8150 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8151 inner_depth.increment()?;
8152 }
8153 let val_ref = self.value.get_or_insert_with(|| fidl::new_empty!(ConfigValue, D));
8154 fidl::decode!(ConfigValue, D, val_ref, decoder, inner_offset, inner_depth)?;
8155 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8156 {
8157 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8158 }
8159 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8160 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8161 }
8162 }
8163
8164 next_offset += envelope_size;
8165
8166 while next_offset < end_offset {
8168 _next_ordinal_to_read += 1;
8169 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8170 next_offset += envelope_size;
8171 }
8172
8173 Ok(())
8174 }
8175 }
8176
8177 impl DebugProtocolRegistration {
8178 #[inline(always)]
8179 fn max_ordinal_present(&self) -> u64 {
8180 if let Some(_) = self.target_name {
8181 return 3;
8182 }
8183 if let Some(_) = self.source_name {
8184 return 2;
8185 }
8186 if let Some(_) = self.source {
8187 return 1;
8188 }
8189 0
8190 }
8191 }
8192
8193 impl fidl::encoding::ValueTypeMarker for DebugProtocolRegistration {
8194 type Borrowed<'a> = &'a Self;
8195 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8196 value
8197 }
8198 }
8199
8200 unsafe impl fidl::encoding::TypeMarker for DebugProtocolRegistration {
8201 type Owned = Self;
8202
8203 #[inline(always)]
8204 fn inline_align(_context: fidl::encoding::Context) -> usize {
8205 8
8206 }
8207
8208 #[inline(always)]
8209 fn inline_size(_context: fidl::encoding::Context) -> usize {
8210 16
8211 }
8212 }
8213
8214 unsafe impl<D: fidl::encoding::ResourceDialect>
8215 fidl::encoding::Encode<DebugProtocolRegistration, D> for &DebugProtocolRegistration
8216 {
8217 unsafe fn encode(
8218 self,
8219 encoder: &mut fidl::encoding::Encoder<'_, D>,
8220 offset: usize,
8221 mut depth: fidl::encoding::Depth,
8222 ) -> fidl::Result<()> {
8223 encoder.debug_check_bounds::<DebugProtocolRegistration>(offset);
8224 let max_ordinal: u64 = self.max_ordinal_present();
8226 encoder.write_num(max_ordinal, offset);
8227 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8228 if max_ordinal == 0 {
8230 return Ok(());
8231 }
8232 depth.increment()?;
8233 let envelope_size = 8;
8234 let bytes_len = max_ordinal as usize * envelope_size;
8235 #[allow(unused_variables)]
8236 let offset = encoder.out_of_line_offset(bytes_len);
8237 let mut _prev_end_offset: usize = 0;
8238 if 1 > max_ordinal {
8239 return Ok(());
8240 }
8241
8242 let cur_offset: usize = (1 - 1) * envelope_size;
8245
8246 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8248
8249 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
8254 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
8255 encoder,
8256 offset + cur_offset,
8257 depth,
8258 )?;
8259
8260 _prev_end_offset = cur_offset + envelope_size;
8261 if 2 > max_ordinal {
8262 return Ok(());
8263 }
8264
8265 let cur_offset: usize = (2 - 1) * envelope_size;
8268
8269 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8271
8272 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8277 self.source_name.as_ref().map(
8278 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8279 ),
8280 encoder,
8281 offset + cur_offset,
8282 depth,
8283 )?;
8284
8285 _prev_end_offset = cur_offset + envelope_size;
8286 if 3 > max_ordinal {
8287 return Ok(());
8288 }
8289
8290 let cur_offset: usize = (3 - 1) * envelope_size;
8293
8294 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8296
8297 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8302 self.target_name.as_ref().map(
8303 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8304 ),
8305 encoder,
8306 offset + cur_offset,
8307 depth,
8308 )?;
8309
8310 _prev_end_offset = cur_offset + envelope_size;
8311
8312 Ok(())
8313 }
8314 }
8315
8316 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8317 for DebugProtocolRegistration
8318 {
8319 #[inline(always)]
8320 fn new_empty() -> Self {
8321 Self::default()
8322 }
8323
8324 unsafe fn decode(
8325 &mut self,
8326 decoder: &mut fidl::encoding::Decoder<'_, D>,
8327 offset: usize,
8328 mut depth: fidl::encoding::Depth,
8329 ) -> fidl::Result<()> {
8330 decoder.debug_check_bounds::<Self>(offset);
8331 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8332 None => return Err(fidl::Error::NotNullable),
8333 Some(len) => len,
8334 };
8335 if len == 0 {
8337 return Ok(());
8338 };
8339 depth.increment()?;
8340 let envelope_size = 8;
8341 let bytes_len = len * envelope_size;
8342 let offset = decoder.out_of_line_offset(bytes_len)?;
8343 let mut _next_ordinal_to_read = 0;
8345 let mut next_offset = offset;
8346 let end_offset = offset + bytes_len;
8347 _next_ordinal_to_read += 1;
8348 if next_offset >= end_offset {
8349 return Ok(());
8350 }
8351
8352 while _next_ordinal_to_read < 1 {
8354 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8355 _next_ordinal_to_read += 1;
8356 next_offset += envelope_size;
8357 }
8358
8359 let next_out_of_line = decoder.next_out_of_line();
8360 let handles_before = decoder.remaining_handles();
8361 if let Some((inlined, num_bytes, num_handles)) =
8362 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8363 {
8364 let member_inline_size =
8365 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8366 if inlined != (member_inline_size <= 4) {
8367 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8368 }
8369 let inner_offset;
8370 let mut inner_depth = depth.clone();
8371 if inlined {
8372 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8373 inner_offset = next_offset;
8374 } else {
8375 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8376 inner_depth.increment()?;
8377 }
8378 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
8379 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
8380 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8381 {
8382 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8383 }
8384 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8385 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8386 }
8387 }
8388
8389 next_offset += envelope_size;
8390 _next_ordinal_to_read += 1;
8391 if next_offset >= end_offset {
8392 return Ok(());
8393 }
8394
8395 while _next_ordinal_to_read < 2 {
8397 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8398 _next_ordinal_to_read += 1;
8399 next_offset += envelope_size;
8400 }
8401
8402 let next_out_of_line = decoder.next_out_of_line();
8403 let handles_before = decoder.remaining_handles();
8404 if let Some((inlined, num_bytes, num_handles)) =
8405 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8406 {
8407 let member_inline_size =
8408 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
8409 decoder.context,
8410 );
8411 if inlined != (member_inline_size <= 4) {
8412 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8413 }
8414 let inner_offset;
8415 let mut inner_depth = depth.clone();
8416 if inlined {
8417 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8418 inner_offset = next_offset;
8419 } else {
8420 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8421 inner_depth.increment()?;
8422 }
8423 let val_ref = self
8424 .source_name
8425 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
8426 fidl::decode!(
8427 fidl::encoding::BoundedString<100>,
8428 D,
8429 val_ref,
8430 decoder,
8431 inner_offset,
8432 inner_depth
8433 )?;
8434 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8435 {
8436 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8437 }
8438 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8439 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8440 }
8441 }
8442
8443 next_offset += envelope_size;
8444 _next_ordinal_to_read += 1;
8445 if next_offset >= end_offset {
8446 return Ok(());
8447 }
8448
8449 while _next_ordinal_to_read < 3 {
8451 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8452 _next_ordinal_to_read += 1;
8453 next_offset += envelope_size;
8454 }
8455
8456 let next_out_of_line = decoder.next_out_of_line();
8457 let handles_before = decoder.remaining_handles();
8458 if let Some((inlined, num_bytes, num_handles)) =
8459 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8460 {
8461 let member_inline_size =
8462 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
8463 decoder.context,
8464 );
8465 if inlined != (member_inline_size <= 4) {
8466 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8467 }
8468 let inner_offset;
8469 let mut inner_depth = depth.clone();
8470 if inlined {
8471 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8472 inner_offset = next_offset;
8473 } else {
8474 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8475 inner_depth.increment()?;
8476 }
8477 let val_ref = self
8478 .target_name
8479 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
8480 fidl::decode!(
8481 fidl::encoding::BoundedString<100>,
8482 D,
8483 val_ref,
8484 decoder,
8485 inner_offset,
8486 inner_depth
8487 )?;
8488 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8489 {
8490 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8491 }
8492 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8493 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8494 }
8495 }
8496
8497 next_offset += envelope_size;
8498
8499 while next_offset < end_offset {
8501 _next_ordinal_to_read += 1;
8502 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8503 next_offset += envelope_size;
8504 }
8505
8506 Ok(())
8507 }
8508 }
8509
8510 impl Dictionary {
8511 #[inline(always)]
8512 fn max_ordinal_present(&self) -> u64 {
8513 if let Some(_) = self.source_path {
8514 return 4;
8515 }
8516 if let Some(_) = self.source_dictionary {
8517 return 3;
8518 }
8519 if let Some(_) = self.source {
8520 return 2;
8521 }
8522 if let Some(_) = self.name {
8523 return 1;
8524 }
8525 0
8526 }
8527 }
8528
8529 impl fidl::encoding::ValueTypeMarker for Dictionary {
8530 type Borrowed<'a> = &'a Self;
8531 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8532 value
8533 }
8534 }
8535
8536 unsafe impl fidl::encoding::TypeMarker for Dictionary {
8537 type Owned = Self;
8538
8539 #[inline(always)]
8540 fn inline_align(_context: fidl::encoding::Context) -> usize {
8541 8
8542 }
8543
8544 #[inline(always)]
8545 fn inline_size(_context: fidl::encoding::Context) -> usize {
8546 16
8547 }
8548 }
8549
8550 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dictionary, D>
8551 for &Dictionary
8552 {
8553 unsafe fn encode(
8554 self,
8555 encoder: &mut fidl::encoding::Encoder<'_, D>,
8556 offset: usize,
8557 mut depth: fidl::encoding::Depth,
8558 ) -> fidl::Result<()> {
8559 encoder.debug_check_bounds::<Dictionary>(offset);
8560 let max_ordinal: u64 = self.max_ordinal_present();
8562 encoder.write_num(max_ordinal, offset);
8563 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8564 if max_ordinal == 0 {
8566 return Ok(());
8567 }
8568 depth.increment()?;
8569 let envelope_size = 8;
8570 let bytes_len = max_ordinal as usize * envelope_size;
8571 #[allow(unused_variables)]
8572 let offset = encoder.out_of_line_offset(bytes_len);
8573 let mut _prev_end_offset: usize = 0;
8574 if 1 > max_ordinal {
8575 return Ok(());
8576 }
8577
8578 let cur_offset: usize = (1 - 1) * envelope_size;
8581
8582 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8584
8585 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8590 self.name.as_ref().map(
8591 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8592 ),
8593 encoder,
8594 offset + cur_offset,
8595 depth,
8596 )?;
8597
8598 _prev_end_offset = cur_offset + envelope_size;
8599 if 2 > max_ordinal {
8600 return Ok(());
8601 }
8602
8603 let cur_offset: usize = (2 - 1) * envelope_size;
8606
8607 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8609
8610 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
8615 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
8616 encoder,
8617 offset + cur_offset,
8618 depth,
8619 )?;
8620
8621 _prev_end_offset = cur_offset + envelope_size;
8622 if 3 > max_ordinal {
8623 return Ok(());
8624 }
8625
8626 let cur_offset: usize = (3 - 1) * envelope_size;
8629
8630 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8632
8633 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
8638 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
8639 encoder, offset + cur_offset, depth
8640 )?;
8641
8642 _prev_end_offset = cur_offset + envelope_size;
8643 if 4 > max_ordinal {
8644 return Ok(());
8645 }
8646
8647 let cur_offset: usize = (4 - 1) * envelope_size;
8650
8651 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8653
8654 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
8659 self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
8660 encoder, offset + cur_offset, depth
8661 )?;
8662
8663 _prev_end_offset = cur_offset + envelope_size;
8664
8665 Ok(())
8666 }
8667 }
8668
8669 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dictionary {
8670 #[inline(always)]
8671 fn new_empty() -> Self {
8672 Self::default()
8673 }
8674
8675 unsafe fn decode(
8676 &mut self,
8677 decoder: &mut fidl::encoding::Decoder<'_, D>,
8678 offset: usize,
8679 mut depth: fidl::encoding::Depth,
8680 ) -> fidl::Result<()> {
8681 decoder.debug_check_bounds::<Self>(offset);
8682 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8683 None => return Err(fidl::Error::NotNullable),
8684 Some(len) => len,
8685 };
8686 if len == 0 {
8688 return Ok(());
8689 };
8690 depth.increment()?;
8691 let envelope_size = 8;
8692 let bytes_len = len * envelope_size;
8693 let offset = decoder.out_of_line_offset(bytes_len)?;
8694 let mut _next_ordinal_to_read = 0;
8696 let mut next_offset = offset;
8697 let end_offset = offset + bytes_len;
8698 _next_ordinal_to_read += 1;
8699 if next_offset >= end_offset {
8700 return Ok(());
8701 }
8702
8703 while _next_ordinal_to_read < 1 {
8705 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8706 _next_ordinal_to_read += 1;
8707 next_offset += envelope_size;
8708 }
8709
8710 let next_out_of_line = decoder.next_out_of_line();
8711 let handles_before = decoder.remaining_handles();
8712 if let Some((inlined, num_bytes, num_handles)) =
8713 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8714 {
8715 let member_inline_size =
8716 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
8717 decoder.context,
8718 );
8719 if inlined != (member_inline_size <= 4) {
8720 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8721 }
8722 let inner_offset;
8723 let mut inner_depth = depth.clone();
8724 if inlined {
8725 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8726 inner_offset = next_offset;
8727 } else {
8728 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8729 inner_depth.increment()?;
8730 }
8731 let val_ref = self
8732 .name
8733 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
8734 fidl::decode!(
8735 fidl::encoding::BoundedString<100>,
8736 D,
8737 val_ref,
8738 decoder,
8739 inner_offset,
8740 inner_depth
8741 )?;
8742 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8743 {
8744 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8745 }
8746 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8747 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8748 }
8749 }
8750
8751 next_offset += envelope_size;
8752 _next_ordinal_to_read += 1;
8753 if next_offset >= end_offset {
8754 return Ok(());
8755 }
8756
8757 while _next_ordinal_to_read < 2 {
8759 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8760 _next_ordinal_to_read += 1;
8761 next_offset += envelope_size;
8762 }
8763
8764 let next_out_of_line = decoder.next_out_of_line();
8765 let handles_before = decoder.remaining_handles();
8766 if let Some((inlined, num_bytes, num_handles)) =
8767 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8768 {
8769 let member_inline_size =
8770 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8771 if inlined != (member_inline_size <= 4) {
8772 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8773 }
8774 let inner_offset;
8775 let mut inner_depth = depth.clone();
8776 if inlined {
8777 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8778 inner_offset = next_offset;
8779 } else {
8780 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8781 inner_depth.increment()?;
8782 }
8783 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
8784 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
8785 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8786 {
8787 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8788 }
8789 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8790 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8791 }
8792 }
8793
8794 next_offset += envelope_size;
8795 _next_ordinal_to_read += 1;
8796 if next_offset >= end_offset {
8797 return Ok(());
8798 }
8799
8800 while _next_ordinal_to_read < 3 {
8802 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8803 _next_ordinal_to_read += 1;
8804 next_offset += envelope_size;
8805 }
8806
8807 let next_out_of_line = decoder.next_out_of_line();
8808 let handles_before = decoder.remaining_handles();
8809 if let Some((inlined, num_bytes, num_handles)) =
8810 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8811 {
8812 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8813 if inlined != (member_inline_size <= 4) {
8814 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8815 }
8816 let inner_offset;
8817 let mut inner_depth = depth.clone();
8818 if inlined {
8819 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8820 inner_offset = next_offset;
8821 } else {
8822 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8823 inner_depth.increment()?;
8824 }
8825 let val_ref = self.source_dictionary.get_or_insert_with(|| {
8826 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
8827 });
8828 fidl::decode!(
8829 fidl::encoding::BoundedString<1024>,
8830 D,
8831 val_ref,
8832 decoder,
8833 inner_offset,
8834 inner_depth
8835 )?;
8836 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8837 {
8838 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8839 }
8840 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8841 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8842 }
8843 }
8844
8845 next_offset += envelope_size;
8846 _next_ordinal_to_read += 1;
8847 if next_offset >= end_offset {
8848 return Ok(());
8849 }
8850
8851 while _next_ordinal_to_read < 4 {
8853 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8854 _next_ordinal_to_read += 1;
8855 next_offset += envelope_size;
8856 }
8857
8858 let next_out_of_line = decoder.next_out_of_line();
8859 let handles_before = decoder.remaining_handles();
8860 if let Some((inlined, num_bytes, num_handles)) =
8861 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8862 {
8863 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8864 if inlined != (member_inline_size <= 4) {
8865 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8866 }
8867 let inner_offset;
8868 let mut inner_depth = depth.clone();
8869 if inlined {
8870 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8871 inner_offset = next_offset;
8872 } else {
8873 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8874 inner_depth.increment()?;
8875 }
8876 let val_ref = self.source_path.get_or_insert_with(|| {
8877 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
8878 });
8879 fidl::decode!(
8880 fidl::encoding::BoundedString<1024>,
8881 D,
8882 val_ref,
8883 decoder,
8884 inner_offset,
8885 inner_depth
8886 )?;
8887 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8888 {
8889 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8890 }
8891 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8892 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8893 }
8894 }
8895
8896 next_offset += envelope_size;
8897
8898 while next_offset < end_offset {
8900 _next_ordinal_to_read += 1;
8901 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8902 next_offset += envelope_size;
8903 }
8904
8905 Ok(())
8906 }
8907 }
8908
8909 impl Directory {
8910 #[inline(always)]
8911 fn max_ordinal_present(&self) -> u64 {
8912 if let Some(_) = self.rights {
8913 return 3;
8914 }
8915 if let Some(_) = self.source_path {
8916 return 2;
8917 }
8918 if let Some(_) = self.name {
8919 return 1;
8920 }
8921 0
8922 }
8923 }
8924
8925 impl fidl::encoding::ValueTypeMarker for Directory {
8926 type Borrowed<'a> = &'a Self;
8927 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8928 value
8929 }
8930 }
8931
8932 unsafe impl fidl::encoding::TypeMarker for Directory {
8933 type Owned = Self;
8934
8935 #[inline(always)]
8936 fn inline_align(_context: fidl::encoding::Context) -> usize {
8937 8
8938 }
8939
8940 #[inline(always)]
8941 fn inline_size(_context: fidl::encoding::Context) -> usize {
8942 16
8943 }
8944 }
8945
8946 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Directory, D>
8947 for &Directory
8948 {
8949 unsafe fn encode(
8950 self,
8951 encoder: &mut fidl::encoding::Encoder<'_, D>,
8952 offset: usize,
8953 mut depth: fidl::encoding::Depth,
8954 ) -> fidl::Result<()> {
8955 encoder.debug_check_bounds::<Directory>(offset);
8956 let max_ordinal: u64 = self.max_ordinal_present();
8958 encoder.write_num(max_ordinal, offset);
8959 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8960 if max_ordinal == 0 {
8962 return Ok(());
8963 }
8964 depth.increment()?;
8965 let envelope_size = 8;
8966 let bytes_len = max_ordinal as usize * envelope_size;
8967 #[allow(unused_variables)]
8968 let offset = encoder.out_of_line_offset(bytes_len);
8969 let mut _prev_end_offset: usize = 0;
8970 if 1 > max_ordinal {
8971 return Ok(());
8972 }
8973
8974 let cur_offset: usize = (1 - 1) * envelope_size;
8977
8978 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8980
8981 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8986 self.name.as_ref().map(
8987 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8988 ),
8989 encoder,
8990 offset + cur_offset,
8991 depth,
8992 )?;
8993
8994 _prev_end_offset = cur_offset + envelope_size;
8995 if 2 > max_ordinal {
8996 return Ok(());
8997 }
8998
8999 let cur_offset: usize = (2 - 1) * envelope_size;
9002
9003 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9005
9006 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
9011 self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
9012 encoder, offset + cur_offset, depth
9013 )?;
9014
9015 _prev_end_offset = cur_offset + envelope_size;
9016 if 3 > max_ordinal {
9017 return Ok(());
9018 }
9019
9020 let cur_offset: usize = (3 - 1) * envelope_size;
9023
9024 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9026
9027 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_io__common::Operations, D>(
9032 self.rights.as_ref().map(<fidl_fuchsia_io__common::Operations as fidl::encoding::ValueTypeMarker>::borrow),
9033 encoder, offset + cur_offset, depth
9034 )?;
9035
9036 _prev_end_offset = cur_offset + envelope_size;
9037
9038 Ok(())
9039 }
9040 }
9041
9042 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Directory {
9043 #[inline(always)]
9044 fn new_empty() -> Self {
9045 Self::default()
9046 }
9047
9048 unsafe fn decode(
9049 &mut self,
9050 decoder: &mut fidl::encoding::Decoder<'_, D>,
9051 offset: usize,
9052 mut depth: fidl::encoding::Depth,
9053 ) -> fidl::Result<()> {
9054 decoder.debug_check_bounds::<Self>(offset);
9055 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9056 None => return Err(fidl::Error::NotNullable),
9057 Some(len) => len,
9058 };
9059 if len == 0 {
9061 return Ok(());
9062 };
9063 depth.increment()?;
9064 let envelope_size = 8;
9065 let bytes_len = len * envelope_size;
9066 let offset = decoder.out_of_line_offset(bytes_len)?;
9067 let mut _next_ordinal_to_read = 0;
9069 let mut next_offset = offset;
9070 let end_offset = offset + bytes_len;
9071 _next_ordinal_to_read += 1;
9072 if next_offset >= end_offset {
9073 return Ok(());
9074 }
9075
9076 while _next_ordinal_to_read < 1 {
9078 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9079 _next_ordinal_to_read += 1;
9080 next_offset += envelope_size;
9081 }
9082
9083 let next_out_of_line = decoder.next_out_of_line();
9084 let handles_before = decoder.remaining_handles();
9085 if let Some((inlined, num_bytes, num_handles)) =
9086 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9087 {
9088 let member_inline_size =
9089 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
9090 decoder.context,
9091 );
9092 if inlined != (member_inline_size <= 4) {
9093 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9094 }
9095 let inner_offset;
9096 let mut inner_depth = depth.clone();
9097 if inlined {
9098 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9099 inner_offset = next_offset;
9100 } else {
9101 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9102 inner_depth.increment()?;
9103 }
9104 let val_ref = self
9105 .name
9106 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
9107 fidl::decode!(
9108 fidl::encoding::BoundedString<100>,
9109 D,
9110 val_ref,
9111 decoder,
9112 inner_offset,
9113 inner_depth
9114 )?;
9115 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9116 {
9117 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9118 }
9119 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9120 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9121 }
9122 }
9123
9124 next_offset += envelope_size;
9125 _next_ordinal_to_read += 1;
9126 if next_offset >= end_offset {
9127 return Ok(());
9128 }
9129
9130 while _next_ordinal_to_read < 2 {
9132 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9133 _next_ordinal_to_read += 1;
9134 next_offset += envelope_size;
9135 }
9136
9137 let next_out_of_line = decoder.next_out_of_line();
9138 let handles_before = decoder.remaining_handles();
9139 if let Some((inlined, num_bytes, num_handles)) =
9140 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9141 {
9142 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9143 if inlined != (member_inline_size <= 4) {
9144 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9145 }
9146 let inner_offset;
9147 let mut inner_depth = depth.clone();
9148 if inlined {
9149 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9150 inner_offset = next_offset;
9151 } else {
9152 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9153 inner_depth.increment()?;
9154 }
9155 let val_ref = self.source_path.get_or_insert_with(|| {
9156 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
9157 });
9158 fidl::decode!(
9159 fidl::encoding::BoundedString<1024>,
9160 D,
9161 val_ref,
9162 decoder,
9163 inner_offset,
9164 inner_depth
9165 )?;
9166 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9167 {
9168 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9169 }
9170 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9171 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9172 }
9173 }
9174
9175 next_offset += envelope_size;
9176 _next_ordinal_to_read += 1;
9177 if next_offset >= end_offset {
9178 return Ok(());
9179 }
9180
9181 while _next_ordinal_to_read < 3 {
9183 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9184 _next_ordinal_to_read += 1;
9185 next_offset += envelope_size;
9186 }
9187
9188 let next_out_of_line = decoder.next_out_of_line();
9189 let handles_before = decoder.remaining_handles();
9190 if let Some((inlined, num_bytes, num_handles)) =
9191 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9192 {
9193 let member_inline_size = <fidl_fuchsia_io__common::Operations as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9194 if inlined != (member_inline_size <= 4) {
9195 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9196 }
9197 let inner_offset;
9198 let mut inner_depth = depth.clone();
9199 if inlined {
9200 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9201 inner_offset = next_offset;
9202 } else {
9203 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9204 inner_depth.increment()?;
9205 }
9206 let val_ref = self.rights.get_or_insert_with(|| {
9207 fidl::new_empty!(fidl_fuchsia_io__common::Operations, D)
9208 });
9209 fidl::decode!(
9210 fidl_fuchsia_io__common::Operations,
9211 D,
9212 val_ref,
9213 decoder,
9214 inner_offset,
9215 inner_depth
9216 )?;
9217 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9218 {
9219 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9220 }
9221 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9222 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9223 }
9224 }
9225
9226 next_offset += envelope_size;
9227
9228 while next_offset < end_offset {
9230 _next_ordinal_to_read += 1;
9231 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9232 next_offset += envelope_size;
9233 }
9234
9235 Ok(())
9236 }
9237 }
9238
9239 impl Environment {
9240 #[inline(always)]
9241 fn max_ordinal_present(&self) -> u64 {
9242 if let Some(_) = self.stop_timeout_ms {
9243 return 6;
9244 }
9245 if let Some(_) = self.debug_capabilities {
9246 return 5;
9247 }
9248 if let Some(_) = self.resolvers {
9249 return 4;
9250 }
9251 if let Some(_) = self.runners {
9252 return 3;
9253 }
9254 if let Some(_) = self.extends {
9255 return 2;
9256 }
9257 if let Some(_) = self.name {
9258 return 1;
9259 }
9260 0
9261 }
9262 }
9263
9264 impl fidl::encoding::ValueTypeMarker for Environment {
9265 type Borrowed<'a> = &'a Self;
9266 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9267 value
9268 }
9269 }
9270
9271 unsafe impl fidl::encoding::TypeMarker for Environment {
9272 type Owned = Self;
9273
9274 #[inline(always)]
9275 fn inline_align(_context: fidl::encoding::Context) -> usize {
9276 8
9277 }
9278
9279 #[inline(always)]
9280 fn inline_size(_context: fidl::encoding::Context) -> usize {
9281 16
9282 }
9283 }
9284
9285 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Environment, D>
9286 for &Environment
9287 {
9288 unsafe fn encode(
9289 self,
9290 encoder: &mut fidl::encoding::Encoder<'_, D>,
9291 offset: usize,
9292 mut depth: fidl::encoding::Depth,
9293 ) -> fidl::Result<()> {
9294 encoder.debug_check_bounds::<Environment>(offset);
9295 let max_ordinal: u64 = self.max_ordinal_present();
9297 encoder.write_num(max_ordinal, offset);
9298 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9299 if max_ordinal == 0 {
9301 return Ok(());
9302 }
9303 depth.increment()?;
9304 let envelope_size = 8;
9305 let bytes_len = max_ordinal as usize * envelope_size;
9306 #[allow(unused_variables)]
9307 let offset = encoder.out_of_line_offset(bytes_len);
9308 let mut _prev_end_offset: usize = 0;
9309 if 1 > max_ordinal {
9310 return Ok(());
9311 }
9312
9313 let cur_offset: usize = (1 - 1) * envelope_size;
9316
9317 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9319
9320 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
9325 self.name.as_ref().map(
9326 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
9327 ),
9328 encoder,
9329 offset + cur_offset,
9330 depth,
9331 )?;
9332
9333 _prev_end_offset = cur_offset + envelope_size;
9334 if 2 > max_ordinal {
9335 return Ok(());
9336 }
9337
9338 let cur_offset: usize = (2 - 1) * envelope_size;
9341
9342 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9344
9345 fidl::encoding::encode_in_envelope_optional::<EnvironmentExtends, D>(
9350 self.extends
9351 .as_ref()
9352 .map(<EnvironmentExtends as fidl::encoding::ValueTypeMarker>::borrow),
9353 encoder,
9354 offset + cur_offset,
9355 depth,
9356 )?;
9357
9358 _prev_end_offset = cur_offset + envelope_size;
9359 if 3 > max_ordinal {
9360 return Ok(());
9361 }
9362
9363 let cur_offset: usize = (3 - 1) * envelope_size;
9366
9367 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9369
9370 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<RunnerRegistration>, D>(
9375 self.runners.as_ref().map(<fidl::encoding::UnboundedVector<RunnerRegistration> as fidl::encoding::ValueTypeMarker>::borrow),
9376 encoder, offset + cur_offset, depth
9377 )?;
9378
9379 _prev_end_offset = cur_offset + envelope_size;
9380 if 4 > max_ordinal {
9381 return Ok(());
9382 }
9383
9384 let cur_offset: usize = (4 - 1) * envelope_size;
9387
9388 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9390
9391 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ResolverRegistration>, D>(
9396 self.resolvers.as_ref().map(<fidl::encoding::UnboundedVector<ResolverRegistration> as fidl::encoding::ValueTypeMarker>::borrow),
9397 encoder, offset + cur_offset, depth
9398 )?;
9399
9400 _prev_end_offset = cur_offset + envelope_size;
9401 if 5 > max_ordinal {
9402 return Ok(());
9403 }
9404
9405 let cur_offset: usize = (5 - 1) * envelope_size;
9408
9409 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9411
9412 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<DebugRegistration>, D>(
9417 self.debug_capabilities.as_ref().map(<fidl::encoding::UnboundedVector<DebugRegistration> as fidl::encoding::ValueTypeMarker>::borrow),
9418 encoder, offset + cur_offset, depth
9419 )?;
9420
9421 _prev_end_offset = cur_offset + envelope_size;
9422 if 6 > max_ordinal {
9423 return Ok(());
9424 }
9425
9426 let cur_offset: usize = (6 - 1) * envelope_size;
9429
9430 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9432
9433 fidl::encoding::encode_in_envelope_optional::<u32, D>(
9438 self.stop_timeout_ms.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
9439 encoder,
9440 offset + cur_offset,
9441 depth,
9442 )?;
9443
9444 _prev_end_offset = cur_offset + envelope_size;
9445
9446 Ok(())
9447 }
9448 }
9449
9450 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Environment {
9451 #[inline(always)]
9452 fn new_empty() -> Self {
9453 Self::default()
9454 }
9455
9456 unsafe fn decode(
9457 &mut self,
9458 decoder: &mut fidl::encoding::Decoder<'_, D>,
9459 offset: usize,
9460 mut depth: fidl::encoding::Depth,
9461 ) -> fidl::Result<()> {
9462 decoder.debug_check_bounds::<Self>(offset);
9463 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9464 None => return Err(fidl::Error::NotNullable),
9465 Some(len) => len,
9466 };
9467 if len == 0 {
9469 return Ok(());
9470 };
9471 depth.increment()?;
9472 let envelope_size = 8;
9473 let bytes_len = len * envelope_size;
9474 let offset = decoder.out_of_line_offset(bytes_len)?;
9475 let mut _next_ordinal_to_read = 0;
9477 let mut next_offset = offset;
9478 let end_offset = offset + bytes_len;
9479 _next_ordinal_to_read += 1;
9480 if next_offset >= end_offset {
9481 return Ok(());
9482 }
9483
9484 while _next_ordinal_to_read < 1 {
9486 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9487 _next_ordinal_to_read += 1;
9488 next_offset += envelope_size;
9489 }
9490
9491 let next_out_of_line = decoder.next_out_of_line();
9492 let handles_before = decoder.remaining_handles();
9493 if let Some((inlined, num_bytes, num_handles)) =
9494 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9495 {
9496 let member_inline_size =
9497 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
9498 decoder.context,
9499 );
9500 if inlined != (member_inline_size <= 4) {
9501 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9502 }
9503 let inner_offset;
9504 let mut inner_depth = depth.clone();
9505 if inlined {
9506 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9507 inner_offset = next_offset;
9508 } else {
9509 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9510 inner_depth.increment()?;
9511 }
9512 let val_ref = self
9513 .name
9514 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
9515 fidl::decode!(
9516 fidl::encoding::BoundedString<100>,
9517 D,
9518 val_ref,
9519 decoder,
9520 inner_offset,
9521 inner_depth
9522 )?;
9523 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9524 {
9525 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9526 }
9527 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9528 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9529 }
9530 }
9531
9532 next_offset += envelope_size;
9533 _next_ordinal_to_read += 1;
9534 if next_offset >= end_offset {
9535 return Ok(());
9536 }
9537
9538 while _next_ordinal_to_read < 2 {
9540 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9541 _next_ordinal_to_read += 1;
9542 next_offset += envelope_size;
9543 }
9544
9545 let next_out_of_line = decoder.next_out_of_line();
9546 let handles_before = decoder.remaining_handles();
9547 if let Some((inlined, num_bytes, num_handles)) =
9548 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9549 {
9550 let member_inline_size =
9551 <EnvironmentExtends as fidl::encoding::TypeMarker>::inline_size(
9552 decoder.context,
9553 );
9554 if inlined != (member_inline_size <= 4) {
9555 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9556 }
9557 let inner_offset;
9558 let mut inner_depth = depth.clone();
9559 if inlined {
9560 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9561 inner_offset = next_offset;
9562 } else {
9563 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9564 inner_depth.increment()?;
9565 }
9566 let val_ref =
9567 self.extends.get_or_insert_with(|| fidl::new_empty!(EnvironmentExtends, D));
9568 fidl::decode!(EnvironmentExtends, D, val_ref, decoder, inner_offset, inner_depth)?;
9569 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9570 {
9571 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9572 }
9573 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9574 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9575 }
9576 }
9577
9578 next_offset += envelope_size;
9579 _next_ordinal_to_read += 1;
9580 if next_offset >= end_offset {
9581 return Ok(());
9582 }
9583
9584 while _next_ordinal_to_read < 3 {
9586 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9587 _next_ordinal_to_read += 1;
9588 next_offset += envelope_size;
9589 }
9590
9591 let next_out_of_line = decoder.next_out_of_line();
9592 let handles_before = decoder.remaining_handles();
9593 if let Some((inlined, num_bytes, num_handles)) =
9594 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9595 {
9596 let member_inline_size = <fidl::encoding::UnboundedVector<RunnerRegistration> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9597 if inlined != (member_inline_size <= 4) {
9598 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9599 }
9600 let inner_offset;
9601 let mut inner_depth = depth.clone();
9602 if inlined {
9603 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9604 inner_offset = next_offset;
9605 } else {
9606 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9607 inner_depth.increment()?;
9608 }
9609 let val_ref = self.runners.get_or_insert_with(|| {
9610 fidl::new_empty!(fidl::encoding::UnboundedVector<RunnerRegistration>, D)
9611 });
9612 fidl::decode!(
9613 fidl::encoding::UnboundedVector<RunnerRegistration>,
9614 D,
9615 val_ref,
9616 decoder,
9617 inner_offset,
9618 inner_depth
9619 )?;
9620 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9621 {
9622 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9623 }
9624 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9625 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9626 }
9627 }
9628
9629 next_offset += envelope_size;
9630 _next_ordinal_to_read += 1;
9631 if next_offset >= end_offset {
9632 return Ok(());
9633 }
9634
9635 while _next_ordinal_to_read < 4 {
9637 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9638 _next_ordinal_to_read += 1;
9639 next_offset += envelope_size;
9640 }
9641
9642 let next_out_of_line = decoder.next_out_of_line();
9643 let handles_before = decoder.remaining_handles();
9644 if let Some((inlined, num_bytes, num_handles)) =
9645 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9646 {
9647 let member_inline_size = <fidl::encoding::UnboundedVector<ResolverRegistration> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9648 if inlined != (member_inline_size <= 4) {
9649 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9650 }
9651 let inner_offset;
9652 let mut inner_depth = depth.clone();
9653 if inlined {
9654 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9655 inner_offset = next_offset;
9656 } else {
9657 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9658 inner_depth.increment()?;
9659 }
9660 let val_ref = self.resolvers.get_or_insert_with(|| {
9661 fidl::new_empty!(fidl::encoding::UnboundedVector<ResolverRegistration>, D)
9662 });
9663 fidl::decode!(
9664 fidl::encoding::UnboundedVector<ResolverRegistration>,
9665 D,
9666 val_ref,
9667 decoder,
9668 inner_offset,
9669 inner_depth
9670 )?;
9671 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9672 {
9673 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9674 }
9675 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9676 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9677 }
9678 }
9679
9680 next_offset += envelope_size;
9681 _next_ordinal_to_read += 1;
9682 if next_offset >= end_offset {
9683 return Ok(());
9684 }
9685
9686 while _next_ordinal_to_read < 5 {
9688 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9689 _next_ordinal_to_read += 1;
9690 next_offset += envelope_size;
9691 }
9692
9693 let next_out_of_line = decoder.next_out_of_line();
9694 let handles_before = decoder.remaining_handles();
9695 if let Some((inlined, num_bytes, num_handles)) =
9696 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9697 {
9698 let member_inline_size = <fidl::encoding::UnboundedVector<DebugRegistration> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9699 if inlined != (member_inline_size <= 4) {
9700 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9701 }
9702 let inner_offset;
9703 let mut inner_depth = depth.clone();
9704 if inlined {
9705 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9706 inner_offset = next_offset;
9707 } else {
9708 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9709 inner_depth.increment()?;
9710 }
9711 let val_ref = self.debug_capabilities.get_or_insert_with(|| {
9712 fidl::new_empty!(fidl::encoding::UnboundedVector<DebugRegistration>, D)
9713 });
9714 fidl::decode!(
9715 fidl::encoding::UnboundedVector<DebugRegistration>,
9716 D,
9717 val_ref,
9718 decoder,
9719 inner_offset,
9720 inner_depth
9721 )?;
9722 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9723 {
9724 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9725 }
9726 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9727 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9728 }
9729 }
9730
9731 next_offset += envelope_size;
9732 _next_ordinal_to_read += 1;
9733 if next_offset >= end_offset {
9734 return Ok(());
9735 }
9736
9737 while _next_ordinal_to_read < 6 {
9739 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9740 _next_ordinal_to_read += 1;
9741 next_offset += envelope_size;
9742 }
9743
9744 let next_out_of_line = decoder.next_out_of_line();
9745 let handles_before = decoder.remaining_handles();
9746 if let Some((inlined, num_bytes, num_handles)) =
9747 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9748 {
9749 let member_inline_size =
9750 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9751 if inlined != (member_inline_size <= 4) {
9752 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9753 }
9754 let inner_offset;
9755 let mut inner_depth = depth.clone();
9756 if inlined {
9757 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9758 inner_offset = next_offset;
9759 } else {
9760 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9761 inner_depth.increment()?;
9762 }
9763 let val_ref = self.stop_timeout_ms.get_or_insert_with(|| fidl::new_empty!(u32, D));
9764 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
9765 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9766 {
9767 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9768 }
9769 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9770 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9771 }
9772 }
9773
9774 next_offset += envelope_size;
9775
9776 while next_offset < end_offset {
9778 _next_ordinal_to_read += 1;
9779 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9780 next_offset += envelope_size;
9781 }
9782
9783 Ok(())
9784 }
9785 }
9786
9787 impl EventStream {
9788 #[inline(always)]
9789 fn max_ordinal_present(&self) -> u64 {
9790 if let Some(_) = self.name {
9791 return 1;
9792 }
9793 0
9794 }
9795 }
9796
9797 impl fidl::encoding::ValueTypeMarker for EventStream {
9798 type Borrowed<'a> = &'a Self;
9799 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9800 value
9801 }
9802 }
9803
9804 unsafe impl fidl::encoding::TypeMarker for EventStream {
9805 type Owned = Self;
9806
9807 #[inline(always)]
9808 fn inline_align(_context: fidl::encoding::Context) -> usize {
9809 8
9810 }
9811
9812 #[inline(always)]
9813 fn inline_size(_context: fidl::encoding::Context) -> usize {
9814 16
9815 }
9816 }
9817
9818 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EventStream, D>
9819 for &EventStream
9820 {
9821 unsafe fn encode(
9822 self,
9823 encoder: &mut fidl::encoding::Encoder<'_, D>,
9824 offset: usize,
9825 mut depth: fidl::encoding::Depth,
9826 ) -> fidl::Result<()> {
9827 encoder.debug_check_bounds::<EventStream>(offset);
9828 let max_ordinal: u64 = self.max_ordinal_present();
9830 encoder.write_num(max_ordinal, offset);
9831 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9832 if max_ordinal == 0 {
9834 return Ok(());
9835 }
9836 depth.increment()?;
9837 let envelope_size = 8;
9838 let bytes_len = max_ordinal as usize * envelope_size;
9839 #[allow(unused_variables)]
9840 let offset = encoder.out_of_line_offset(bytes_len);
9841 let mut _prev_end_offset: usize = 0;
9842 if 1 > max_ordinal {
9843 return Ok(());
9844 }
9845
9846 let cur_offset: usize = (1 - 1) * envelope_size;
9849
9850 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9852
9853 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
9858 self.name.as_ref().map(
9859 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
9860 ),
9861 encoder,
9862 offset + cur_offset,
9863 depth,
9864 )?;
9865
9866 _prev_end_offset = cur_offset + envelope_size;
9867
9868 Ok(())
9869 }
9870 }
9871
9872 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventStream {
9873 #[inline(always)]
9874 fn new_empty() -> Self {
9875 Self::default()
9876 }
9877
9878 unsafe fn decode(
9879 &mut self,
9880 decoder: &mut fidl::encoding::Decoder<'_, D>,
9881 offset: usize,
9882 mut depth: fidl::encoding::Depth,
9883 ) -> fidl::Result<()> {
9884 decoder.debug_check_bounds::<Self>(offset);
9885 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9886 None => return Err(fidl::Error::NotNullable),
9887 Some(len) => len,
9888 };
9889 if len == 0 {
9891 return Ok(());
9892 };
9893 depth.increment()?;
9894 let envelope_size = 8;
9895 let bytes_len = len * envelope_size;
9896 let offset = decoder.out_of_line_offset(bytes_len)?;
9897 let mut _next_ordinal_to_read = 0;
9899 let mut next_offset = offset;
9900 let end_offset = offset + bytes_len;
9901 _next_ordinal_to_read += 1;
9902 if next_offset >= end_offset {
9903 return Ok(());
9904 }
9905
9906 while _next_ordinal_to_read < 1 {
9908 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9909 _next_ordinal_to_read += 1;
9910 next_offset += envelope_size;
9911 }
9912
9913 let next_out_of_line = decoder.next_out_of_line();
9914 let handles_before = decoder.remaining_handles();
9915 if let Some((inlined, num_bytes, num_handles)) =
9916 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9917 {
9918 let member_inline_size =
9919 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
9920 decoder.context,
9921 );
9922 if inlined != (member_inline_size <= 4) {
9923 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9924 }
9925 let inner_offset;
9926 let mut inner_depth = depth.clone();
9927 if inlined {
9928 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9929 inner_offset = next_offset;
9930 } else {
9931 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9932 inner_depth.increment()?;
9933 }
9934 let val_ref = self
9935 .name
9936 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
9937 fidl::decode!(
9938 fidl::encoding::BoundedString<100>,
9939 D,
9940 val_ref,
9941 decoder,
9942 inner_offset,
9943 inner_depth
9944 )?;
9945 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9946 {
9947 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9948 }
9949 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9950 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9951 }
9952 }
9953
9954 next_offset += envelope_size;
9955
9956 while next_offset < end_offset {
9958 _next_ordinal_to_read += 1;
9959 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9960 next_offset += envelope_size;
9961 }
9962
9963 Ok(())
9964 }
9965 }
9966
9967 impl EventSubscription {
9968 #[inline(always)]
9969 fn max_ordinal_present(&self) -> u64 {
9970 if let Some(_) = self.event_name {
9971 return 1;
9972 }
9973 0
9974 }
9975 }
9976
9977 impl fidl::encoding::ValueTypeMarker for EventSubscription {
9978 type Borrowed<'a> = &'a Self;
9979 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9980 value
9981 }
9982 }
9983
9984 unsafe impl fidl::encoding::TypeMarker for EventSubscription {
9985 type Owned = Self;
9986
9987 #[inline(always)]
9988 fn inline_align(_context: fidl::encoding::Context) -> usize {
9989 8
9990 }
9991
9992 #[inline(always)]
9993 fn inline_size(_context: fidl::encoding::Context) -> usize {
9994 16
9995 }
9996 }
9997
9998 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EventSubscription, D>
9999 for &EventSubscription
10000 {
10001 unsafe fn encode(
10002 self,
10003 encoder: &mut fidl::encoding::Encoder<'_, D>,
10004 offset: usize,
10005 mut depth: fidl::encoding::Depth,
10006 ) -> fidl::Result<()> {
10007 encoder.debug_check_bounds::<EventSubscription>(offset);
10008 let max_ordinal: u64 = self.max_ordinal_present();
10010 encoder.write_num(max_ordinal, offset);
10011 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10012 if max_ordinal == 0 {
10014 return Ok(());
10015 }
10016 depth.increment()?;
10017 let envelope_size = 8;
10018 let bytes_len = max_ordinal as usize * envelope_size;
10019 #[allow(unused_variables)]
10020 let offset = encoder.out_of_line_offset(bytes_len);
10021 let mut _prev_end_offset: usize = 0;
10022 if 1 > max_ordinal {
10023 return Ok(());
10024 }
10025
10026 let cur_offset: usize = (1 - 1) * envelope_size;
10029
10030 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10032
10033 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10038 self.event_name.as_ref().map(
10039 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10040 ),
10041 encoder,
10042 offset + cur_offset,
10043 depth,
10044 )?;
10045
10046 _prev_end_offset = cur_offset + envelope_size;
10047
10048 Ok(())
10049 }
10050 }
10051
10052 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventSubscription {
10053 #[inline(always)]
10054 fn new_empty() -> Self {
10055 Self::default()
10056 }
10057
10058 unsafe fn decode(
10059 &mut self,
10060 decoder: &mut fidl::encoding::Decoder<'_, D>,
10061 offset: usize,
10062 mut depth: fidl::encoding::Depth,
10063 ) -> fidl::Result<()> {
10064 decoder.debug_check_bounds::<Self>(offset);
10065 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10066 None => return Err(fidl::Error::NotNullable),
10067 Some(len) => len,
10068 };
10069 if len == 0 {
10071 return Ok(());
10072 };
10073 depth.increment()?;
10074 let envelope_size = 8;
10075 let bytes_len = len * envelope_size;
10076 let offset = decoder.out_of_line_offset(bytes_len)?;
10077 let mut _next_ordinal_to_read = 0;
10079 let mut next_offset = offset;
10080 let end_offset = offset + bytes_len;
10081 _next_ordinal_to_read += 1;
10082 if next_offset >= end_offset {
10083 return Ok(());
10084 }
10085
10086 while _next_ordinal_to_read < 1 {
10088 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10089 _next_ordinal_to_read += 1;
10090 next_offset += envelope_size;
10091 }
10092
10093 let next_out_of_line = decoder.next_out_of_line();
10094 let handles_before = decoder.remaining_handles();
10095 if let Some((inlined, num_bytes, num_handles)) =
10096 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10097 {
10098 let member_inline_size =
10099 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
10100 decoder.context,
10101 );
10102 if inlined != (member_inline_size <= 4) {
10103 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10104 }
10105 let inner_offset;
10106 let mut inner_depth = depth.clone();
10107 if inlined {
10108 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10109 inner_offset = next_offset;
10110 } else {
10111 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10112 inner_depth.increment()?;
10113 }
10114 let val_ref = self
10115 .event_name
10116 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
10117 fidl::decode!(
10118 fidl::encoding::BoundedString<100>,
10119 D,
10120 val_ref,
10121 decoder,
10122 inner_offset,
10123 inner_depth
10124 )?;
10125 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10126 {
10127 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10128 }
10129 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10130 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10131 }
10132 }
10133
10134 next_offset += envelope_size;
10135
10136 while next_offset < end_offset {
10138 _next_ordinal_to_read += 1;
10139 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10140 next_offset += envelope_size;
10141 }
10142
10143 Ok(())
10144 }
10145 }
10146
10147 impl ExposeConfiguration {
10148 #[inline(always)]
10149 fn max_ordinal_present(&self) -> u64 {
10150 if let Some(_) = self.source_dictionary {
10151 return 6;
10152 }
10153 if let Some(_) = self.availability {
10154 return 5;
10155 }
10156 if let Some(_) = self.target_name {
10157 return 4;
10158 }
10159 if let Some(_) = self.target {
10160 return 3;
10161 }
10162 if let Some(_) = self.source_name {
10163 return 2;
10164 }
10165 if let Some(_) = self.source {
10166 return 1;
10167 }
10168 0
10169 }
10170 }
10171
10172 impl fidl::encoding::ValueTypeMarker for ExposeConfiguration {
10173 type Borrowed<'a> = &'a Self;
10174 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10175 value
10176 }
10177 }
10178
10179 unsafe impl fidl::encoding::TypeMarker for ExposeConfiguration {
10180 type Owned = Self;
10181
10182 #[inline(always)]
10183 fn inline_align(_context: fidl::encoding::Context) -> usize {
10184 8
10185 }
10186
10187 #[inline(always)]
10188 fn inline_size(_context: fidl::encoding::Context) -> usize {
10189 16
10190 }
10191 }
10192
10193 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeConfiguration, D>
10194 for &ExposeConfiguration
10195 {
10196 unsafe fn encode(
10197 self,
10198 encoder: &mut fidl::encoding::Encoder<'_, D>,
10199 offset: usize,
10200 mut depth: fidl::encoding::Depth,
10201 ) -> fidl::Result<()> {
10202 encoder.debug_check_bounds::<ExposeConfiguration>(offset);
10203 let max_ordinal: u64 = self.max_ordinal_present();
10205 encoder.write_num(max_ordinal, offset);
10206 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10207 if max_ordinal == 0 {
10209 return Ok(());
10210 }
10211 depth.increment()?;
10212 let envelope_size = 8;
10213 let bytes_len = max_ordinal as usize * envelope_size;
10214 #[allow(unused_variables)]
10215 let offset = encoder.out_of_line_offset(bytes_len);
10216 let mut _prev_end_offset: usize = 0;
10217 if 1 > max_ordinal {
10218 return Ok(());
10219 }
10220
10221 let cur_offset: usize = (1 - 1) * envelope_size;
10224
10225 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10227
10228 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
10233 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
10234 encoder,
10235 offset + cur_offset,
10236 depth,
10237 )?;
10238
10239 _prev_end_offset = cur_offset + envelope_size;
10240 if 2 > max_ordinal {
10241 return Ok(());
10242 }
10243
10244 let cur_offset: usize = (2 - 1) * envelope_size;
10247
10248 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10250
10251 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10256 self.source_name.as_ref().map(
10257 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10258 ),
10259 encoder,
10260 offset + cur_offset,
10261 depth,
10262 )?;
10263
10264 _prev_end_offset = cur_offset + envelope_size;
10265 if 3 > max_ordinal {
10266 return Ok(());
10267 }
10268
10269 let cur_offset: usize = (3 - 1) * envelope_size;
10272
10273 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10275
10276 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
10281 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
10282 encoder,
10283 offset + cur_offset,
10284 depth,
10285 )?;
10286
10287 _prev_end_offset = cur_offset + envelope_size;
10288 if 4 > max_ordinal {
10289 return Ok(());
10290 }
10291
10292 let cur_offset: usize = (4 - 1) * envelope_size;
10295
10296 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10298
10299 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10304 self.target_name.as_ref().map(
10305 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10306 ),
10307 encoder,
10308 offset + cur_offset,
10309 depth,
10310 )?;
10311
10312 _prev_end_offset = cur_offset + envelope_size;
10313 if 5 > max_ordinal {
10314 return Ok(());
10315 }
10316
10317 let cur_offset: usize = (5 - 1) * envelope_size;
10320
10321 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10323
10324 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
10329 self.availability
10330 .as_ref()
10331 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
10332 encoder,
10333 offset + cur_offset,
10334 depth,
10335 )?;
10336
10337 _prev_end_offset = cur_offset + envelope_size;
10338 if 6 > max_ordinal {
10339 return Ok(());
10340 }
10341
10342 let cur_offset: usize = (6 - 1) * envelope_size;
10345
10346 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10348
10349 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
10354 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
10355 encoder, offset + cur_offset, depth
10356 )?;
10357
10358 _prev_end_offset = cur_offset + envelope_size;
10359
10360 Ok(())
10361 }
10362 }
10363
10364 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeConfiguration {
10365 #[inline(always)]
10366 fn new_empty() -> Self {
10367 Self::default()
10368 }
10369
10370 unsafe fn decode(
10371 &mut self,
10372 decoder: &mut fidl::encoding::Decoder<'_, D>,
10373 offset: usize,
10374 mut depth: fidl::encoding::Depth,
10375 ) -> fidl::Result<()> {
10376 decoder.debug_check_bounds::<Self>(offset);
10377 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10378 None => return Err(fidl::Error::NotNullable),
10379 Some(len) => len,
10380 };
10381 if len == 0 {
10383 return Ok(());
10384 };
10385 depth.increment()?;
10386 let envelope_size = 8;
10387 let bytes_len = len * envelope_size;
10388 let offset = decoder.out_of_line_offset(bytes_len)?;
10389 let mut _next_ordinal_to_read = 0;
10391 let mut next_offset = offset;
10392 let end_offset = offset + bytes_len;
10393 _next_ordinal_to_read += 1;
10394 if next_offset >= end_offset {
10395 return Ok(());
10396 }
10397
10398 while _next_ordinal_to_read < 1 {
10400 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10401 _next_ordinal_to_read += 1;
10402 next_offset += envelope_size;
10403 }
10404
10405 let next_out_of_line = decoder.next_out_of_line();
10406 let handles_before = decoder.remaining_handles();
10407 if let Some((inlined, num_bytes, num_handles)) =
10408 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10409 {
10410 let member_inline_size =
10411 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10412 if inlined != (member_inline_size <= 4) {
10413 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10414 }
10415 let inner_offset;
10416 let mut inner_depth = depth.clone();
10417 if inlined {
10418 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10419 inner_offset = next_offset;
10420 } else {
10421 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10422 inner_depth.increment()?;
10423 }
10424 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
10425 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
10426 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10427 {
10428 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10429 }
10430 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10431 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10432 }
10433 }
10434
10435 next_offset += envelope_size;
10436 _next_ordinal_to_read += 1;
10437 if next_offset >= end_offset {
10438 return Ok(());
10439 }
10440
10441 while _next_ordinal_to_read < 2 {
10443 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10444 _next_ordinal_to_read += 1;
10445 next_offset += envelope_size;
10446 }
10447
10448 let next_out_of_line = decoder.next_out_of_line();
10449 let handles_before = decoder.remaining_handles();
10450 if let Some((inlined, num_bytes, num_handles)) =
10451 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10452 {
10453 let member_inline_size =
10454 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
10455 decoder.context,
10456 );
10457 if inlined != (member_inline_size <= 4) {
10458 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10459 }
10460 let inner_offset;
10461 let mut inner_depth = depth.clone();
10462 if inlined {
10463 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10464 inner_offset = next_offset;
10465 } else {
10466 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10467 inner_depth.increment()?;
10468 }
10469 let val_ref = self
10470 .source_name
10471 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
10472 fidl::decode!(
10473 fidl::encoding::BoundedString<100>,
10474 D,
10475 val_ref,
10476 decoder,
10477 inner_offset,
10478 inner_depth
10479 )?;
10480 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10481 {
10482 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10483 }
10484 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10485 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10486 }
10487 }
10488
10489 next_offset += envelope_size;
10490 _next_ordinal_to_read += 1;
10491 if next_offset >= end_offset {
10492 return Ok(());
10493 }
10494
10495 while _next_ordinal_to_read < 3 {
10497 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10498 _next_ordinal_to_read += 1;
10499 next_offset += envelope_size;
10500 }
10501
10502 let next_out_of_line = decoder.next_out_of_line();
10503 let handles_before = decoder.remaining_handles();
10504 if let Some((inlined, num_bytes, num_handles)) =
10505 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10506 {
10507 let member_inline_size =
10508 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10509 if inlined != (member_inline_size <= 4) {
10510 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10511 }
10512 let inner_offset;
10513 let mut inner_depth = depth.clone();
10514 if inlined {
10515 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10516 inner_offset = next_offset;
10517 } else {
10518 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10519 inner_depth.increment()?;
10520 }
10521 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
10522 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
10523 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10524 {
10525 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10526 }
10527 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10528 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10529 }
10530 }
10531
10532 next_offset += envelope_size;
10533 _next_ordinal_to_read += 1;
10534 if next_offset >= end_offset {
10535 return Ok(());
10536 }
10537
10538 while _next_ordinal_to_read < 4 {
10540 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10541 _next_ordinal_to_read += 1;
10542 next_offset += envelope_size;
10543 }
10544
10545 let next_out_of_line = decoder.next_out_of_line();
10546 let handles_before = decoder.remaining_handles();
10547 if let Some((inlined, num_bytes, num_handles)) =
10548 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10549 {
10550 let member_inline_size =
10551 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
10552 decoder.context,
10553 );
10554 if inlined != (member_inline_size <= 4) {
10555 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10556 }
10557 let inner_offset;
10558 let mut inner_depth = depth.clone();
10559 if inlined {
10560 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10561 inner_offset = next_offset;
10562 } else {
10563 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10564 inner_depth.increment()?;
10565 }
10566 let val_ref = self
10567 .target_name
10568 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
10569 fidl::decode!(
10570 fidl::encoding::BoundedString<100>,
10571 D,
10572 val_ref,
10573 decoder,
10574 inner_offset,
10575 inner_depth
10576 )?;
10577 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10578 {
10579 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10580 }
10581 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10582 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10583 }
10584 }
10585
10586 next_offset += envelope_size;
10587 _next_ordinal_to_read += 1;
10588 if next_offset >= end_offset {
10589 return Ok(());
10590 }
10591
10592 while _next_ordinal_to_read < 5 {
10594 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10595 _next_ordinal_to_read += 1;
10596 next_offset += envelope_size;
10597 }
10598
10599 let next_out_of_line = decoder.next_out_of_line();
10600 let handles_before = decoder.remaining_handles();
10601 if let Some((inlined, num_bytes, num_handles)) =
10602 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10603 {
10604 let member_inline_size =
10605 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10606 if inlined != (member_inline_size <= 4) {
10607 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10608 }
10609 let inner_offset;
10610 let mut inner_depth = depth.clone();
10611 if inlined {
10612 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10613 inner_offset = next_offset;
10614 } else {
10615 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10616 inner_depth.increment()?;
10617 }
10618 let val_ref =
10619 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
10620 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
10621 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10622 {
10623 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10624 }
10625 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10626 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10627 }
10628 }
10629
10630 next_offset += envelope_size;
10631 _next_ordinal_to_read += 1;
10632 if next_offset >= end_offset {
10633 return Ok(());
10634 }
10635
10636 while _next_ordinal_to_read < 6 {
10638 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10639 _next_ordinal_to_read += 1;
10640 next_offset += envelope_size;
10641 }
10642
10643 let next_out_of_line = decoder.next_out_of_line();
10644 let handles_before = decoder.remaining_handles();
10645 if let Some((inlined, num_bytes, num_handles)) =
10646 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10647 {
10648 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10649 if inlined != (member_inline_size <= 4) {
10650 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10651 }
10652 let inner_offset;
10653 let mut inner_depth = depth.clone();
10654 if inlined {
10655 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10656 inner_offset = next_offset;
10657 } else {
10658 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10659 inner_depth.increment()?;
10660 }
10661 let val_ref = self.source_dictionary.get_or_insert_with(|| {
10662 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
10663 });
10664 fidl::decode!(
10665 fidl::encoding::BoundedString<1024>,
10666 D,
10667 val_ref,
10668 decoder,
10669 inner_offset,
10670 inner_depth
10671 )?;
10672 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10673 {
10674 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10675 }
10676 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10677 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10678 }
10679 }
10680
10681 next_offset += envelope_size;
10682
10683 while next_offset < end_offset {
10685 _next_ordinal_to_read += 1;
10686 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10687 next_offset += envelope_size;
10688 }
10689
10690 Ok(())
10691 }
10692 }
10693
10694 impl ExposeDictionary {
10695 #[inline(always)]
10696 fn max_ordinal_present(&self) -> u64 {
10697 if let Some(_) = self.source_dictionary {
10698 return 6;
10699 }
10700 if let Some(_) = self.availability {
10701 return 5;
10702 }
10703 if let Some(_) = self.target_name {
10704 return 4;
10705 }
10706 if let Some(_) = self.target {
10707 return 3;
10708 }
10709 if let Some(_) = self.source_name {
10710 return 2;
10711 }
10712 if let Some(_) = self.source {
10713 return 1;
10714 }
10715 0
10716 }
10717 }
10718
10719 impl fidl::encoding::ValueTypeMarker for ExposeDictionary {
10720 type Borrowed<'a> = &'a Self;
10721 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10722 value
10723 }
10724 }
10725
10726 unsafe impl fidl::encoding::TypeMarker for ExposeDictionary {
10727 type Owned = Self;
10728
10729 #[inline(always)]
10730 fn inline_align(_context: fidl::encoding::Context) -> usize {
10731 8
10732 }
10733
10734 #[inline(always)]
10735 fn inline_size(_context: fidl::encoding::Context) -> usize {
10736 16
10737 }
10738 }
10739
10740 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeDictionary, D>
10741 for &ExposeDictionary
10742 {
10743 unsafe fn encode(
10744 self,
10745 encoder: &mut fidl::encoding::Encoder<'_, D>,
10746 offset: usize,
10747 mut depth: fidl::encoding::Depth,
10748 ) -> fidl::Result<()> {
10749 encoder.debug_check_bounds::<ExposeDictionary>(offset);
10750 let max_ordinal: u64 = self.max_ordinal_present();
10752 encoder.write_num(max_ordinal, offset);
10753 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10754 if max_ordinal == 0 {
10756 return Ok(());
10757 }
10758 depth.increment()?;
10759 let envelope_size = 8;
10760 let bytes_len = max_ordinal as usize * envelope_size;
10761 #[allow(unused_variables)]
10762 let offset = encoder.out_of_line_offset(bytes_len);
10763 let mut _prev_end_offset: usize = 0;
10764 if 1 > max_ordinal {
10765 return Ok(());
10766 }
10767
10768 let cur_offset: usize = (1 - 1) * envelope_size;
10771
10772 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10774
10775 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
10780 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
10781 encoder,
10782 offset + cur_offset,
10783 depth,
10784 )?;
10785
10786 _prev_end_offset = cur_offset + envelope_size;
10787 if 2 > max_ordinal {
10788 return Ok(());
10789 }
10790
10791 let cur_offset: usize = (2 - 1) * envelope_size;
10794
10795 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10797
10798 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10803 self.source_name.as_ref().map(
10804 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10805 ),
10806 encoder,
10807 offset + cur_offset,
10808 depth,
10809 )?;
10810
10811 _prev_end_offset = cur_offset + envelope_size;
10812 if 3 > max_ordinal {
10813 return Ok(());
10814 }
10815
10816 let cur_offset: usize = (3 - 1) * envelope_size;
10819
10820 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10822
10823 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
10828 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
10829 encoder,
10830 offset + cur_offset,
10831 depth,
10832 )?;
10833
10834 _prev_end_offset = cur_offset + envelope_size;
10835 if 4 > max_ordinal {
10836 return Ok(());
10837 }
10838
10839 let cur_offset: usize = (4 - 1) * envelope_size;
10842
10843 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10845
10846 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10851 self.target_name.as_ref().map(
10852 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10853 ),
10854 encoder,
10855 offset + cur_offset,
10856 depth,
10857 )?;
10858
10859 _prev_end_offset = cur_offset + envelope_size;
10860 if 5 > max_ordinal {
10861 return Ok(());
10862 }
10863
10864 let cur_offset: usize = (5 - 1) * envelope_size;
10867
10868 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10870
10871 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
10876 self.availability
10877 .as_ref()
10878 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
10879 encoder,
10880 offset + cur_offset,
10881 depth,
10882 )?;
10883
10884 _prev_end_offset = cur_offset + envelope_size;
10885 if 6 > max_ordinal {
10886 return Ok(());
10887 }
10888
10889 let cur_offset: usize = (6 - 1) * envelope_size;
10892
10893 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10895
10896 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
10901 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
10902 encoder, offset + cur_offset, depth
10903 )?;
10904
10905 _prev_end_offset = cur_offset + envelope_size;
10906
10907 Ok(())
10908 }
10909 }
10910
10911 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeDictionary {
10912 #[inline(always)]
10913 fn new_empty() -> Self {
10914 Self::default()
10915 }
10916
10917 unsafe fn decode(
10918 &mut self,
10919 decoder: &mut fidl::encoding::Decoder<'_, D>,
10920 offset: usize,
10921 mut depth: fidl::encoding::Depth,
10922 ) -> fidl::Result<()> {
10923 decoder.debug_check_bounds::<Self>(offset);
10924 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10925 None => return Err(fidl::Error::NotNullable),
10926 Some(len) => len,
10927 };
10928 if len == 0 {
10930 return Ok(());
10931 };
10932 depth.increment()?;
10933 let envelope_size = 8;
10934 let bytes_len = len * envelope_size;
10935 let offset = decoder.out_of_line_offset(bytes_len)?;
10936 let mut _next_ordinal_to_read = 0;
10938 let mut next_offset = offset;
10939 let end_offset = offset + bytes_len;
10940 _next_ordinal_to_read += 1;
10941 if next_offset >= end_offset {
10942 return Ok(());
10943 }
10944
10945 while _next_ordinal_to_read < 1 {
10947 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10948 _next_ordinal_to_read += 1;
10949 next_offset += envelope_size;
10950 }
10951
10952 let next_out_of_line = decoder.next_out_of_line();
10953 let handles_before = decoder.remaining_handles();
10954 if let Some((inlined, num_bytes, num_handles)) =
10955 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10956 {
10957 let member_inline_size =
10958 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10959 if inlined != (member_inline_size <= 4) {
10960 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10961 }
10962 let inner_offset;
10963 let mut inner_depth = depth.clone();
10964 if inlined {
10965 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10966 inner_offset = next_offset;
10967 } else {
10968 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10969 inner_depth.increment()?;
10970 }
10971 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
10972 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
10973 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10974 {
10975 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10976 }
10977 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10978 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10979 }
10980 }
10981
10982 next_offset += envelope_size;
10983 _next_ordinal_to_read += 1;
10984 if next_offset >= end_offset {
10985 return Ok(());
10986 }
10987
10988 while _next_ordinal_to_read < 2 {
10990 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10991 _next_ordinal_to_read += 1;
10992 next_offset += envelope_size;
10993 }
10994
10995 let next_out_of_line = decoder.next_out_of_line();
10996 let handles_before = decoder.remaining_handles();
10997 if let Some((inlined, num_bytes, num_handles)) =
10998 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10999 {
11000 let member_inline_size =
11001 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11002 decoder.context,
11003 );
11004 if inlined != (member_inline_size <= 4) {
11005 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11006 }
11007 let inner_offset;
11008 let mut inner_depth = depth.clone();
11009 if inlined {
11010 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11011 inner_offset = next_offset;
11012 } else {
11013 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11014 inner_depth.increment()?;
11015 }
11016 let val_ref = self
11017 .source_name
11018 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
11019 fidl::decode!(
11020 fidl::encoding::BoundedString<100>,
11021 D,
11022 val_ref,
11023 decoder,
11024 inner_offset,
11025 inner_depth
11026 )?;
11027 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11028 {
11029 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11030 }
11031 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11032 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11033 }
11034 }
11035
11036 next_offset += envelope_size;
11037 _next_ordinal_to_read += 1;
11038 if next_offset >= end_offset {
11039 return Ok(());
11040 }
11041
11042 while _next_ordinal_to_read < 3 {
11044 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11045 _next_ordinal_to_read += 1;
11046 next_offset += envelope_size;
11047 }
11048
11049 let next_out_of_line = decoder.next_out_of_line();
11050 let handles_before = decoder.remaining_handles();
11051 if let Some((inlined, num_bytes, num_handles)) =
11052 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11053 {
11054 let member_inline_size =
11055 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11056 if inlined != (member_inline_size <= 4) {
11057 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11058 }
11059 let inner_offset;
11060 let mut inner_depth = depth.clone();
11061 if inlined {
11062 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11063 inner_offset = next_offset;
11064 } else {
11065 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11066 inner_depth.increment()?;
11067 }
11068 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
11069 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
11070 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11071 {
11072 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11073 }
11074 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11075 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11076 }
11077 }
11078
11079 next_offset += envelope_size;
11080 _next_ordinal_to_read += 1;
11081 if next_offset >= end_offset {
11082 return Ok(());
11083 }
11084
11085 while _next_ordinal_to_read < 4 {
11087 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11088 _next_ordinal_to_read += 1;
11089 next_offset += envelope_size;
11090 }
11091
11092 let next_out_of_line = decoder.next_out_of_line();
11093 let handles_before = decoder.remaining_handles();
11094 if let Some((inlined, num_bytes, num_handles)) =
11095 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11096 {
11097 let member_inline_size =
11098 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11099 decoder.context,
11100 );
11101 if inlined != (member_inline_size <= 4) {
11102 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11103 }
11104 let inner_offset;
11105 let mut inner_depth = depth.clone();
11106 if inlined {
11107 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11108 inner_offset = next_offset;
11109 } else {
11110 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11111 inner_depth.increment()?;
11112 }
11113 let val_ref = self
11114 .target_name
11115 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
11116 fidl::decode!(
11117 fidl::encoding::BoundedString<100>,
11118 D,
11119 val_ref,
11120 decoder,
11121 inner_offset,
11122 inner_depth
11123 )?;
11124 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11125 {
11126 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11127 }
11128 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11129 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11130 }
11131 }
11132
11133 next_offset += envelope_size;
11134 _next_ordinal_to_read += 1;
11135 if next_offset >= end_offset {
11136 return Ok(());
11137 }
11138
11139 while _next_ordinal_to_read < 5 {
11141 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11142 _next_ordinal_to_read += 1;
11143 next_offset += envelope_size;
11144 }
11145
11146 let next_out_of_line = decoder.next_out_of_line();
11147 let handles_before = decoder.remaining_handles();
11148 if let Some((inlined, num_bytes, num_handles)) =
11149 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11150 {
11151 let member_inline_size =
11152 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11153 if inlined != (member_inline_size <= 4) {
11154 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11155 }
11156 let inner_offset;
11157 let mut inner_depth = depth.clone();
11158 if inlined {
11159 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11160 inner_offset = next_offset;
11161 } else {
11162 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11163 inner_depth.increment()?;
11164 }
11165 let val_ref =
11166 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
11167 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
11168 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11169 {
11170 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11171 }
11172 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11173 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11174 }
11175 }
11176
11177 next_offset += envelope_size;
11178 _next_ordinal_to_read += 1;
11179 if next_offset >= end_offset {
11180 return Ok(());
11181 }
11182
11183 while _next_ordinal_to_read < 6 {
11185 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11186 _next_ordinal_to_read += 1;
11187 next_offset += envelope_size;
11188 }
11189
11190 let next_out_of_line = decoder.next_out_of_line();
11191 let handles_before = decoder.remaining_handles();
11192 if let Some((inlined, num_bytes, num_handles)) =
11193 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11194 {
11195 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11196 if inlined != (member_inline_size <= 4) {
11197 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11198 }
11199 let inner_offset;
11200 let mut inner_depth = depth.clone();
11201 if inlined {
11202 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11203 inner_offset = next_offset;
11204 } else {
11205 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11206 inner_depth.increment()?;
11207 }
11208 let val_ref = self.source_dictionary.get_or_insert_with(|| {
11209 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
11210 });
11211 fidl::decode!(
11212 fidl::encoding::BoundedString<1024>,
11213 D,
11214 val_ref,
11215 decoder,
11216 inner_offset,
11217 inner_depth
11218 )?;
11219 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11220 {
11221 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11222 }
11223 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11224 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11225 }
11226 }
11227
11228 next_offset += envelope_size;
11229
11230 while next_offset < end_offset {
11232 _next_ordinal_to_read += 1;
11233 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11234 next_offset += envelope_size;
11235 }
11236
11237 Ok(())
11238 }
11239 }
11240
11241 impl ExposeDirectory {
11242 #[inline(always)]
11243 fn max_ordinal_present(&self) -> u64 {
11244 if let Some(_) = self.source_dictionary {
11245 return 8;
11246 }
11247 if let Some(_) = self.availability {
11248 return 7;
11249 }
11250 if let Some(_) = self.subdir {
11251 return 6;
11252 }
11253 if let Some(_) = self.rights {
11254 return 5;
11255 }
11256 if let Some(_) = self.target_name {
11257 return 4;
11258 }
11259 if let Some(_) = self.target {
11260 return 3;
11261 }
11262 if let Some(_) = self.source_name {
11263 return 2;
11264 }
11265 if let Some(_) = self.source {
11266 return 1;
11267 }
11268 0
11269 }
11270 }
11271
11272 impl fidl::encoding::ValueTypeMarker for ExposeDirectory {
11273 type Borrowed<'a> = &'a Self;
11274 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11275 value
11276 }
11277 }
11278
11279 unsafe impl fidl::encoding::TypeMarker for ExposeDirectory {
11280 type Owned = Self;
11281
11282 #[inline(always)]
11283 fn inline_align(_context: fidl::encoding::Context) -> usize {
11284 8
11285 }
11286
11287 #[inline(always)]
11288 fn inline_size(_context: fidl::encoding::Context) -> usize {
11289 16
11290 }
11291 }
11292
11293 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeDirectory, D>
11294 for &ExposeDirectory
11295 {
11296 unsafe fn encode(
11297 self,
11298 encoder: &mut fidl::encoding::Encoder<'_, D>,
11299 offset: usize,
11300 mut depth: fidl::encoding::Depth,
11301 ) -> fidl::Result<()> {
11302 encoder.debug_check_bounds::<ExposeDirectory>(offset);
11303 let max_ordinal: u64 = self.max_ordinal_present();
11305 encoder.write_num(max_ordinal, offset);
11306 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11307 if max_ordinal == 0 {
11309 return Ok(());
11310 }
11311 depth.increment()?;
11312 let envelope_size = 8;
11313 let bytes_len = max_ordinal as usize * envelope_size;
11314 #[allow(unused_variables)]
11315 let offset = encoder.out_of_line_offset(bytes_len);
11316 let mut _prev_end_offset: usize = 0;
11317 if 1 > max_ordinal {
11318 return Ok(());
11319 }
11320
11321 let cur_offset: usize = (1 - 1) * envelope_size;
11324
11325 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11327
11328 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
11333 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
11334 encoder,
11335 offset + cur_offset,
11336 depth,
11337 )?;
11338
11339 _prev_end_offset = cur_offset + envelope_size;
11340 if 2 > max_ordinal {
11341 return Ok(());
11342 }
11343
11344 let cur_offset: usize = (2 - 1) * envelope_size;
11347
11348 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11350
11351 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
11356 self.source_name.as_ref().map(
11357 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
11358 ),
11359 encoder,
11360 offset + cur_offset,
11361 depth,
11362 )?;
11363
11364 _prev_end_offset = cur_offset + envelope_size;
11365 if 3 > max_ordinal {
11366 return Ok(());
11367 }
11368
11369 let cur_offset: usize = (3 - 1) * envelope_size;
11372
11373 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11375
11376 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
11381 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
11382 encoder,
11383 offset + cur_offset,
11384 depth,
11385 )?;
11386
11387 _prev_end_offset = cur_offset + envelope_size;
11388 if 4 > max_ordinal {
11389 return Ok(());
11390 }
11391
11392 let cur_offset: usize = (4 - 1) * envelope_size;
11395
11396 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11398
11399 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
11404 self.target_name.as_ref().map(
11405 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
11406 ),
11407 encoder,
11408 offset + cur_offset,
11409 depth,
11410 )?;
11411
11412 _prev_end_offset = cur_offset + envelope_size;
11413 if 5 > max_ordinal {
11414 return Ok(());
11415 }
11416
11417 let cur_offset: usize = (5 - 1) * envelope_size;
11420
11421 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11423
11424 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_io__common::Operations, D>(
11429 self.rights.as_ref().map(<fidl_fuchsia_io__common::Operations as fidl::encoding::ValueTypeMarker>::borrow),
11430 encoder, offset + cur_offset, depth
11431 )?;
11432
11433 _prev_end_offset = cur_offset + envelope_size;
11434 if 6 > max_ordinal {
11435 return Ok(());
11436 }
11437
11438 let cur_offset: usize = (6 - 1) * envelope_size;
11441
11442 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11444
11445 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
11450 self.subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
11451 encoder, offset + cur_offset, depth
11452 )?;
11453
11454 _prev_end_offset = cur_offset + envelope_size;
11455 if 7 > max_ordinal {
11456 return Ok(());
11457 }
11458
11459 let cur_offset: usize = (7 - 1) * envelope_size;
11462
11463 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11465
11466 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
11471 self.availability
11472 .as_ref()
11473 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
11474 encoder,
11475 offset + cur_offset,
11476 depth,
11477 )?;
11478
11479 _prev_end_offset = cur_offset + envelope_size;
11480 if 8 > max_ordinal {
11481 return Ok(());
11482 }
11483
11484 let cur_offset: usize = (8 - 1) * envelope_size;
11487
11488 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11490
11491 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
11496 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
11497 encoder, offset + cur_offset, depth
11498 )?;
11499
11500 _prev_end_offset = cur_offset + envelope_size;
11501
11502 Ok(())
11503 }
11504 }
11505
11506 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeDirectory {
11507 #[inline(always)]
11508 fn new_empty() -> Self {
11509 Self::default()
11510 }
11511
11512 unsafe fn decode(
11513 &mut self,
11514 decoder: &mut fidl::encoding::Decoder<'_, D>,
11515 offset: usize,
11516 mut depth: fidl::encoding::Depth,
11517 ) -> fidl::Result<()> {
11518 decoder.debug_check_bounds::<Self>(offset);
11519 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11520 None => return Err(fidl::Error::NotNullable),
11521 Some(len) => len,
11522 };
11523 if len == 0 {
11525 return Ok(());
11526 };
11527 depth.increment()?;
11528 let envelope_size = 8;
11529 let bytes_len = len * envelope_size;
11530 let offset = decoder.out_of_line_offset(bytes_len)?;
11531 let mut _next_ordinal_to_read = 0;
11533 let mut next_offset = offset;
11534 let end_offset = offset + bytes_len;
11535 _next_ordinal_to_read += 1;
11536 if next_offset >= end_offset {
11537 return Ok(());
11538 }
11539
11540 while _next_ordinal_to_read < 1 {
11542 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11543 _next_ordinal_to_read += 1;
11544 next_offset += envelope_size;
11545 }
11546
11547 let next_out_of_line = decoder.next_out_of_line();
11548 let handles_before = decoder.remaining_handles();
11549 if let Some((inlined, num_bytes, num_handles)) =
11550 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11551 {
11552 let member_inline_size =
11553 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11554 if inlined != (member_inline_size <= 4) {
11555 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11556 }
11557 let inner_offset;
11558 let mut inner_depth = depth.clone();
11559 if inlined {
11560 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11561 inner_offset = next_offset;
11562 } else {
11563 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11564 inner_depth.increment()?;
11565 }
11566 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
11567 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
11568 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11569 {
11570 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11571 }
11572 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11573 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11574 }
11575 }
11576
11577 next_offset += envelope_size;
11578 _next_ordinal_to_read += 1;
11579 if next_offset >= end_offset {
11580 return Ok(());
11581 }
11582
11583 while _next_ordinal_to_read < 2 {
11585 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11586 _next_ordinal_to_read += 1;
11587 next_offset += envelope_size;
11588 }
11589
11590 let next_out_of_line = decoder.next_out_of_line();
11591 let handles_before = decoder.remaining_handles();
11592 if let Some((inlined, num_bytes, num_handles)) =
11593 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11594 {
11595 let member_inline_size =
11596 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11597 decoder.context,
11598 );
11599 if inlined != (member_inline_size <= 4) {
11600 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11601 }
11602 let inner_offset;
11603 let mut inner_depth = depth.clone();
11604 if inlined {
11605 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11606 inner_offset = next_offset;
11607 } else {
11608 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11609 inner_depth.increment()?;
11610 }
11611 let val_ref = self
11612 .source_name
11613 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
11614 fidl::decode!(
11615 fidl::encoding::BoundedString<100>,
11616 D,
11617 val_ref,
11618 decoder,
11619 inner_offset,
11620 inner_depth
11621 )?;
11622 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11623 {
11624 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11625 }
11626 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11627 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11628 }
11629 }
11630
11631 next_offset += envelope_size;
11632 _next_ordinal_to_read += 1;
11633 if next_offset >= end_offset {
11634 return Ok(());
11635 }
11636
11637 while _next_ordinal_to_read < 3 {
11639 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11640 _next_ordinal_to_read += 1;
11641 next_offset += envelope_size;
11642 }
11643
11644 let next_out_of_line = decoder.next_out_of_line();
11645 let handles_before = decoder.remaining_handles();
11646 if let Some((inlined, num_bytes, num_handles)) =
11647 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11648 {
11649 let member_inline_size =
11650 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11651 if inlined != (member_inline_size <= 4) {
11652 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11653 }
11654 let inner_offset;
11655 let mut inner_depth = depth.clone();
11656 if inlined {
11657 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11658 inner_offset = next_offset;
11659 } else {
11660 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11661 inner_depth.increment()?;
11662 }
11663 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
11664 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
11665 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11666 {
11667 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11668 }
11669 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11670 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11671 }
11672 }
11673
11674 next_offset += envelope_size;
11675 _next_ordinal_to_read += 1;
11676 if next_offset >= end_offset {
11677 return Ok(());
11678 }
11679
11680 while _next_ordinal_to_read < 4 {
11682 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11683 _next_ordinal_to_read += 1;
11684 next_offset += envelope_size;
11685 }
11686
11687 let next_out_of_line = decoder.next_out_of_line();
11688 let handles_before = decoder.remaining_handles();
11689 if let Some((inlined, num_bytes, num_handles)) =
11690 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11691 {
11692 let member_inline_size =
11693 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11694 decoder.context,
11695 );
11696 if inlined != (member_inline_size <= 4) {
11697 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11698 }
11699 let inner_offset;
11700 let mut inner_depth = depth.clone();
11701 if inlined {
11702 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11703 inner_offset = next_offset;
11704 } else {
11705 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11706 inner_depth.increment()?;
11707 }
11708 let val_ref = self
11709 .target_name
11710 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
11711 fidl::decode!(
11712 fidl::encoding::BoundedString<100>,
11713 D,
11714 val_ref,
11715 decoder,
11716 inner_offset,
11717 inner_depth
11718 )?;
11719 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11720 {
11721 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11722 }
11723 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11724 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11725 }
11726 }
11727
11728 next_offset += envelope_size;
11729 _next_ordinal_to_read += 1;
11730 if next_offset >= end_offset {
11731 return Ok(());
11732 }
11733
11734 while _next_ordinal_to_read < 5 {
11736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11737 _next_ordinal_to_read += 1;
11738 next_offset += envelope_size;
11739 }
11740
11741 let next_out_of_line = decoder.next_out_of_line();
11742 let handles_before = decoder.remaining_handles();
11743 if let Some((inlined, num_bytes, num_handles)) =
11744 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11745 {
11746 let member_inline_size = <fidl_fuchsia_io__common::Operations as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11747 if inlined != (member_inline_size <= 4) {
11748 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11749 }
11750 let inner_offset;
11751 let mut inner_depth = depth.clone();
11752 if inlined {
11753 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11754 inner_offset = next_offset;
11755 } else {
11756 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11757 inner_depth.increment()?;
11758 }
11759 let val_ref = self.rights.get_or_insert_with(|| {
11760 fidl::new_empty!(fidl_fuchsia_io__common::Operations, D)
11761 });
11762 fidl::decode!(
11763 fidl_fuchsia_io__common::Operations,
11764 D,
11765 val_ref,
11766 decoder,
11767 inner_offset,
11768 inner_depth
11769 )?;
11770 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11771 {
11772 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11773 }
11774 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11775 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11776 }
11777 }
11778
11779 next_offset += envelope_size;
11780 _next_ordinal_to_read += 1;
11781 if next_offset >= end_offset {
11782 return Ok(());
11783 }
11784
11785 while _next_ordinal_to_read < 6 {
11787 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11788 _next_ordinal_to_read += 1;
11789 next_offset += envelope_size;
11790 }
11791
11792 let next_out_of_line = decoder.next_out_of_line();
11793 let handles_before = decoder.remaining_handles();
11794 if let Some((inlined, num_bytes, num_handles)) =
11795 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11796 {
11797 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11798 if inlined != (member_inline_size <= 4) {
11799 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11800 }
11801 let inner_offset;
11802 let mut inner_depth = depth.clone();
11803 if inlined {
11804 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11805 inner_offset = next_offset;
11806 } else {
11807 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11808 inner_depth.increment()?;
11809 }
11810 let val_ref = self.subdir.get_or_insert_with(|| {
11811 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
11812 });
11813 fidl::decode!(
11814 fidl::encoding::BoundedString<1024>,
11815 D,
11816 val_ref,
11817 decoder,
11818 inner_offset,
11819 inner_depth
11820 )?;
11821 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11822 {
11823 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11824 }
11825 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11826 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11827 }
11828 }
11829
11830 next_offset += envelope_size;
11831 _next_ordinal_to_read += 1;
11832 if next_offset >= end_offset {
11833 return Ok(());
11834 }
11835
11836 while _next_ordinal_to_read < 7 {
11838 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11839 _next_ordinal_to_read += 1;
11840 next_offset += envelope_size;
11841 }
11842
11843 let next_out_of_line = decoder.next_out_of_line();
11844 let handles_before = decoder.remaining_handles();
11845 if let Some((inlined, num_bytes, num_handles)) =
11846 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11847 {
11848 let member_inline_size =
11849 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11850 if inlined != (member_inline_size <= 4) {
11851 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11852 }
11853 let inner_offset;
11854 let mut inner_depth = depth.clone();
11855 if inlined {
11856 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11857 inner_offset = next_offset;
11858 } else {
11859 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11860 inner_depth.increment()?;
11861 }
11862 let val_ref =
11863 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
11864 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
11865 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11866 {
11867 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11868 }
11869 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11870 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11871 }
11872 }
11873
11874 next_offset += envelope_size;
11875 _next_ordinal_to_read += 1;
11876 if next_offset >= end_offset {
11877 return Ok(());
11878 }
11879
11880 while _next_ordinal_to_read < 8 {
11882 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11883 _next_ordinal_to_read += 1;
11884 next_offset += envelope_size;
11885 }
11886
11887 let next_out_of_line = decoder.next_out_of_line();
11888 let handles_before = decoder.remaining_handles();
11889 if let Some((inlined, num_bytes, num_handles)) =
11890 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11891 {
11892 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11893 if inlined != (member_inline_size <= 4) {
11894 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11895 }
11896 let inner_offset;
11897 let mut inner_depth = depth.clone();
11898 if inlined {
11899 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11900 inner_offset = next_offset;
11901 } else {
11902 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11903 inner_depth.increment()?;
11904 }
11905 let val_ref = self.source_dictionary.get_or_insert_with(|| {
11906 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
11907 });
11908 fidl::decode!(
11909 fidl::encoding::BoundedString<1024>,
11910 D,
11911 val_ref,
11912 decoder,
11913 inner_offset,
11914 inner_depth
11915 )?;
11916 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11917 {
11918 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11919 }
11920 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11921 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11922 }
11923 }
11924
11925 next_offset += envelope_size;
11926
11927 while next_offset < end_offset {
11929 _next_ordinal_to_read += 1;
11930 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11931 next_offset += envelope_size;
11932 }
11933
11934 Ok(())
11935 }
11936 }
11937
11938 impl ExposeProtocol {
11939 #[inline(always)]
11940 fn max_ordinal_present(&self) -> u64 {
11941 if let Some(_) = self.source_dictionary {
11942 return 6;
11943 }
11944 if let Some(_) = self.availability {
11945 return 5;
11946 }
11947 if let Some(_) = self.target_name {
11948 return 4;
11949 }
11950 if let Some(_) = self.target {
11951 return 3;
11952 }
11953 if let Some(_) = self.source_name {
11954 return 2;
11955 }
11956 if let Some(_) = self.source {
11957 return 1;
11958 }
11959 0
11960 }
11961 }
11962
11963 impl fidl::encoding::ValueTypeMarker for ExposeProtocol {
11964 type Borrowed<'a> = &'a Self;
11965 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11966 value
11967 }
11968 }
11969
11970 unsafe impl fidl::encoding::TypeMarker for ExposeProtocol {
11971 type Owned = Self;
11972
11973 #[inline(always)]
11974 fn inline_align(_context: fidl::encoding::Context) -> usize {
11975 8
11976 }
11977
11978 #[inline(always)]
11979 fn inline_size(_context: fidl::encoding::Context) -> usize {
11980 16
11981 }
11982 }
11983
11984 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeProtocol, D>
11985 for &ExposeProtocol
11986 {
11987 unsafe fn encode(
11988 self,
11989 encoder: &mut fidl::encoding::Encoder<'_, D>,
11990 offset: usize,
11991 mut depth: fidl::encoding::Depth,
11992 ) -> fidl::Result<()> {
11993 encoder.debug_check_bounds::<ExposeProtocol>(offset);
11994 let max_ordinal: u64 = self.max_ordinal_present();
11996 encoder.write_num(max_ordinal, offset);
11997 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11998 if max_ordinal == 0 {
12000 return Ok(());
12001 }
12002 depth.increment()?;
12003 let envelope_size = 8;
12004 let bytes_len = max_ordinal as usize * envelope_size;
12005 #[allow(unused_variables)]
12006 let offset = encoder.out_of_line_offset(bytes_len);
12007 let mut _prev_end_offset: usize = 0;
12008 if 1 > max_ordinal {
12009 return Ok(());
12010 }
12011
12012 let cur_offset: usize = (1 - 1) * envelope_size;
12015
12016 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12018
12019 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
12024 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
12025 encoder,
12026 offset + cur_offset,
12027 depth,
12028 )?;
12029
12030 _prev_end_offset = cur_offset + envelope_size;
12031 if 2 > max_ordinal {
12032 return Ok(());
12033 }
12034
12035 let cur_offset: usize = (2 - 1) * envelope_size;
12038
12039 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12041
12042 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
12047 self.source_name.as_ref().map(
12048 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
12049 ),
12050 encoder,
12051 offset + cur_offset,
12052 depth,
12053 )?;
12054
12055 _prev_end_offset = cur_offset + envelope_size;
12056 if 3 > max_ordinal {
12057 return Ok(());
12058 }
12059
12060 let cur_offset: usize = (3 - 1) * envelope_size;
12063
12064 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12066
12067 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
12072 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
12073 encoder,
12074 offset + cur_offset,
12075 depth,
12076 )?;
12077
12078 _prev_end_offset = cur_offset + envelope_size;
12079 if 4 > max_ordinal {
12080 return Ok(());
12081 }
12082
12083 let cur_offset: usize = (4 - 1) * envelope_size;
12086
12087 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12089
12090 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
12095 self.target_name.as_ref().map(
12096 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
12097 ),
12098 encoder,
12099 offset + cur_offset,
12100 depth,
12101 )?;
12102
12103 _prev_end_offset = cur_offset + envelope_size;
12104 if 5 > max_ordinal {
12105 return Ok(());
12106 }
12107
12108 let cur_offset: usize = (5 - 1) * envelope_size;
12111
12112 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12114
12115 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
12120 self.availability
12121 .as_ref()
12122 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
12123 encoder,
12124 offset + cur_offset,
12125 depth,
12126 )?;
12127
12128 _prev_end_offset = cur_offset + envelope_size;
12129 if 6 > max_ordinal {
12130 return Ok(());
12131 }
12132
12133 let cur_offset: usize = (6 - 1) * envelope_size;
12136
12137 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12139
12140 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
12145 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
12146 encoder, offset + cur_offset, depth
12147 )?;
12148
12149 _prev_end_offset = cur_offset + envelope_size;
12150
12151 Ok(())
12152 }
12153 }
12154
12155 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeProtocol {
12156 #[inline(always)]
12157 fn new_empty() -> Self {
12158 Self::default()
12159 }
12160
12161 unsafe fn decode(
12162 &mut self,
12163 decoder: &mut fidl::encoding::Decoder<'_, D>,
12164 offset: usize,
12165 mut depth: fidl::encoding::Depth,
12166 ) -> fidl::Result<()> {
12167 decoder.debug_check_bounds::<Self>(offset);
12168 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12169 None => return Err(fidl::Error::NotNullable),
12170 Some(len) => len,
12171 };
12172 if len == 0 {
12174 return Ok(());
12175 };
12176 depth.increment()?;
12177 let envelope_size = 8;
12178 let bytes_len = len * envelope_size;
12179 let offset = decoder.out_of_line_offset(bytes_len)?;
12180 let mut _next_ordinal_to_read = 0;
12182 let mut next_offset = offset;
12183 let end_offset = offset + bytes_len;
12184 _next_ordinal_to_read += 1;
12185 if next_offset >= end_offset {
12186 return Ok(());
12187 }
12188
12189 while _next_ordinal_to_read < 1 {
12191 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12192 _next_ordinal_to_read += 1;
12193 next_offset += envelope_size;
12194 }
12195
12196 let next_out_of_line = decoder.next_out_of_line();
12197 let handles_before = decoder.remaining_handles();
12198 if let Some((inlined, num_bytes, num_handles)) =
12199 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12200 {
12201 let member_inline_size =
12202 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12203 if inlined != (member_inline_size <= 4) {
12204 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12205 }
12206 let inner_offset;
12207 let mut inner_depth = depth.clone();
12208 if inlined {
12209 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12210 inner_offset = next_offset;
12211 } else {
12212 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12213 inner_depth.increment()?;
12214 }
12215 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
12216 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
12217 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12218 {
12219 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12220 }
12221 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12222 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12223 }
12224 }
12225
12226 next_offset += envelope_size;
12227 _next_ordinal_to_read += 1;
12228 if next_offset >= end_offset {
12229 return Ok(());
12230 }
12231
12232 while _next_ordinal_to_read < 2 {
12234 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12235 _next_ordinal_to_read += 1;
12236 next_offset += envelope_size;
12237 }
12238
12239 let next_out_of_line = decoder.next_out_of_line();
12240 let handles_before = decoder.remaining_handles();
12241 if let Some((inlined, num_bytes, num_handles)) =
12242 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12243 {
12244 let member_inline_size =
12245 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
12246 decoder.context,
12247 );
12248 if inlined != (member_inline_size <= 4) {
12249 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12250 }
12251 let inner_offset;
12252 let mut inner_depth = depth.clone();
12253 if inlined {
12254 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12255 inner_offset = next_offset;
12256 } else {
12257 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12258 inner_depth.increment()?;
12259 }
12260 let val_ref = self
12261 .source_name
12262 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
12263 fidl::decode!(
12264 fidl::encoding::BoundedString<100>,
12265 D,
12266 val_ref,
12267 decoder,
12268 inner_offset,
12269 inner_depth
12270 )?;
12271 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12272 {
12273 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12274 }
12275 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12276 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12277 }
12278 }
12279
12280 next_offset += envelope_size;
12281 _next_ordinal_to_read += 1;
12282 if next_offset >= end_offset {
12283 return Ok(());
12284 }
12285
12286 while _next_ordinal_to_read < 3 {
12288 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12289 _next_ordinal_to_read += 1;
12290 next_offset += envelope_size;
12291 }
12292
12293 let next_out_of_line = decoder.next_out_of_line();
12294 let handles_before = decoder.remaining_handles();
12295 if let Some((inlined, num_bytes, num_handles)) =
12296 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12297 {
12298 let member_inline_size =
12299 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12300 if inlined != (member_inline_size <= 4) {
12301 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12302 }
12303 let inner_offset;
12304 let mut inner_depth = depth.clone();
12305 if inlined {
12306 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12307 inner_offset = next_offset;
12308 } else {
12309 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12310 inner_depth.increment()?;
12311 }
12312 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
12313 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
12314 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12315 {
12316 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12317 }
12318 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12319 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12320 }
12321 }
12322
12323 next_offset += envelope_size;
12324 _next_ordinal_to_read += 1;
12325 if next_offset >= end_offset {
12326 return Ok(());
12327 }
12328
12329 while _next_ordinal_to_read < 4 {
12331 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12332 _next_ordinal_to_read += 1;
12333 next_offset += envelope_size;
12334 }
12335
12336 let next_out_of_line = decoder.next_out_of_line();
12337 let handles_before = decoder.remaining_handles();
12338 if let Some((inlined, num_bytes, num_handles)) =
12339 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12340 {
12341 let member_inline_size =
12342 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
12343 decoder.context,
12344 );
12345 if inlined != (member_inline_size <= 4) {
12346 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12347 }
12348 let inner_offset;
12349 let mut inner_depth = depth.clone();
12350 if inlined {
12351 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12352 inner_offset = next_offset;
12353 } else {
12354 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12355 inner_depth.increment()?;
12356 }
12357 let val_ref = self
12358 .target_name
12359 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
12360 fidl::decode!(
12361 fidl::encoding::BoundedString<100>,
12362 D,
12363 val_ref,
12364 decoder,
12365 inner_offset,
12366 inner_depth
12367 )?;
12368 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12369 {
12370 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12371 }
12372 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12373 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12374 }
12375 }
12376
12377 next_offset += envelope_size;
12378 _next_ordinal_to_read += 1;
12379 if next_offset >= end_offset {
12380 return Ok(());
12381 }
12382
12383 while _next_ordinal_to_read < 5 {
12385 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12386 _next_ordinal_to_read += 1;
12387 next_offset += envelope_size;
12388 }
12389
12390 let next_out_of_line = decoder.next_out_of_line();
12391 let handles_before = decoder.remaining_handles();
12392 if let Some((inlined, num_bytes, num_handles)) =
12393 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12394 {
12395 let member_inline_size =
12396 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12397 if inlined != (member_inline_size <= 4) {
12398 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12399 }
12400 let inner_offset;
12401 let mut inner_depth = depth.clone();
12402 if inlined {
12403 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12404 inner_offset = next_offset;
12405 } else {
12406 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12407 inner_depth.increment()?;
12408 }
12409 let val_ref =
12410 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
12411 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
12412 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12413 {
12414 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12415 }
12416 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12417 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12418 }
12419 }
12420
12421 next_offset += envelope_size;
12422 _next_ordinal_to_read += 1;
12423 if next_offset >= end_offset {
12424 return Ok(());
12425 }
12426
12427 while _next_ordinal_to_read < 6 {
12429 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12430 _next_ordinal_to_read += 1;
12431 next_offset += envelope_size;
12432 }
12433
12434 let next_out_of_line = decoder.next_out_of_line();
12435 let handles_before = decoder.remaining_handles();
12436 if let Some((inlined, num_bytes, num_handles)) =
12437 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12438 {
12439 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12440 if inlined != (member_inline_size <= 4) {
12441 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12442 }
12443 let inner_offset;
12444 let mut inner_depth = depth.clone();
12445 if inlined {
12446 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12447 inner_offset = next_offset;
12448 } else {
12449 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12450 inner_depth.increment()?;
12451 }
12452 let val_ref = self.source_dictionary.get_or_insert_with(|| {
12453 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
12454 });
12455 fidl::decode!(
12456 fidl::encoding::BoundedString<1024>,
12457 D,
12458 val_ref,
12459 decoder,
12460 inner_offset,
12461 inner_depth
12462 )?;
12463 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12464 {
12465 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12466 }
12467 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12468 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12469 }
12470 }
12471
12472 next_offset += envelope_size;
12473
12474 while next_offset < end_offset {
12476 _next_ordinal_to_read += 1;
12477 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12478 next_offset += envelope_size;
12479 }
12480
12481 Ok(())
12482 }
12483 }
12484
12485 impl ExposeResolver {
12486 #[inline(always)]
12487 fn max_ordinal_present(&self) -> u64 {
12488 if let Some(_) = self.source_dictionary {
12489 return 6;
12490 }
12491 if let Some(_) = self.target_name {
12492 return 4;
12493 }
12494 if let Some(_) = self.target {
12495 return 3;
12496 }
12497 if let Some(_) = self.source_name {
12498 return 2;
12499 }
12500 if let Some(_) = self.source {
12501 return 1;
12502 }
12503 0
12504 }
12505 }
12506
12507 impl fidl::encoding::ValueTypeMarker for ExposeResolver {
12508 type Borrowed<'a> = &'a Self;
12509 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12510 value
12511 }
12512 }
12513
12514 unsafe impl fidl::encoding::TypeMarker for ExposeResolver {
12515 type Owned = Self;
12516
12517 #[inline(always)]
12518 fn inline_align(_context: fidl::encoding::Context) -> usize {
12519 8
12520 }
12521
12522 #[inline(always)]
12523 fn inline_size(_context: fidl::encoding::Context) -> usize {
12524 16
12525 }
12526 }
12527
12528 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeResolver, D>
12529 for &ExposeResolver
12530 {
12531 unsafe fn encode(
12532 self,
12533 encoder: &mut fidl::encoding::Encoder<'_, D>,
12534 offset: usize,
12535 mut depth: fidl::encoding::Depth,
12536 ) -> fidl::Result<()> {
12537 encoder.debug_check_bounds::<ExposeResolver>(offset);
12538 let max_ordinal: u64 = self.max_ordinal_present();
12540 encoder.write_num(max_ordinal, offset);
12541 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12542 if max_ordinal == 0 {
12544 return Ok(());
12545 }
12546 depth.increment()?;
12547 let envelope_size = 8;
12548 let bytes_len = max_ordinal as usize * envelope_size;
12549 #[allow(unused_variables)]
12550 let offset = encoder.out_of_line_offset(bytes_len);
12551 let mut _prev_end_offset: usize = 0;
12552 if 1 > max_ordinal {
12553 return Ok(());
12554 }
12555
12556 let cur_offset: usize = (1 - 1) * envelope_size;
12559
12560 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12562
12563 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
12568 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
12569 encoder,
12570 offset + cur_offset,
12571 depth,
12572 )?;
12573
12574 _prev_end_offset = cur_offset + envelope_size;
12575 if 2 > max_ordinal {
12576 return Ok(());
12577 }
12578
12579 let cur_offset: usize = (2 - 1) * envelope_size;
12582
12583 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12585
12586 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
12591 self.source_name.as_ref().map(
12592 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
12593 ),
12594 encoder,
12595 offset + cur_offset,
12596 depth,
12597 )?;
12598
12599 _prev_end_offset = cur_offset + envelope_size;
12600 if 3 > max_ordinal {
12601 return Ok(());
12602 }
12603
12604 let cur_offset: usize = (3 - 1) * envelope_size;
12607
12608 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12610
12611 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
12616 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
12617 encoder,
12618 offset + cur_offset,
12619 depth,
12620 )?;
12621
12622 _prev_end_offset = cur_offset + envelope_size;
12623 if 4 > max_ordinal {
12624 return Ok(());
12625 }
12626
12627 let cur_offset: usize = (4 - 1) * envelope_size;
12630
12631 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12633
12634 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
12639 self.target_name.as_ref().map(
12640 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
12641 ),
12642 encoder,
12643 offset + cur_offset,
12644 depth,
12645 )?;
12646
12647 _prev_end_offset = cur_offset + envelope_size;
12648 if 6 > max_ordinal {
12649 return Ok(());
12650 }
12651
12652 let cur_offset: usize = (6 - 1) * envelope_size;
12655
12656 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12658
12659 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
12664 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
12665 encoder, offset + cur_offset, depth
12666 )?;
12667
12668 _prev_end_offset = cur_offset + envelope_size;
12669
12670 Ok(())
12671 }
12672 }
12673
12674 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeResolver {
12675 #[inline(always)]
12676 fn new_empty() -> Self {
12677 Self::default()
12678 }
12679
12680 unsafe fn decode(
12681 &mut self,
12682 decoder: &mut fidl::encoding::Decoder<'_, D>,
12683 offset: usize,
12684 mut depth: fidl::encoding::Depth,
12685 ) -> fidl::Result<()> {
12686 decoder.debug_check_bounds::<Self>(offset);
12687 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12688 None => return Err(fidl::Error::NotNullable),
12689 Some(len) => len,
12690 };
12691 if len == 0 {
12693 return Ok(());
12694 };
12695 depth.increment()?;
12696 let envelope_size = 8;
12697 let bytes_len = len * envelope_size;
12698 let offset = decoder.out_of_line_offset(bytes_len)?;
12699 let mut _next_ordinal_to_read = 0;
12701 let mut next_offset = offset;
12702 let end_offset = offset + bytes_len;
12703 _next_ordinal_to_read += 1;
12704 if next_offset >= end_offset {
12705 return Ok(());
12706 }
12707
12708 while _next_ordinal_to_read < 1 {
12710 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12711 _next_ordinal_to_read += 1;
12712 next_offset += envelope_size;
12713 }
12714
12715 let next_out_of_line = decoder.next_out_of_line();
12716 let handles_before = decoder.remaining_handles();
12717 if let Some((inlined, num_bytes, num_handles)) =
12718 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12719 {
12720 let member_inline_size =
12721 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12722 if inlined != (member_inline_size <= 4) {
12723 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12724 }
12725 let inner_offset;
12726 let mut inner_depth = depth.clone();
12727 if inlined {
12728 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12729 inner_offset = next_offset;
12730 } else {
12731 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12732 inner_depth.increment()?;
12733 }
12734 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
12735 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
12736 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12737 {
12738 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12739 }
12740 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12741 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12742 }
12743 }
12744
12745 next_offset += envelope_size;
12746 _next_ordinal_to_read += 1;
12747 if next_offset >= end_offset {
12748 return Ok(());
12749 }
12750
12751 while _next_ordinal_to_read < 2 {
12753 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12754 _next_ordinal_to_read += 1;
12755 next_offset += envelope_size;
12756 }
12757
12758 let next_out_of_line = decoder.next_out_of_line();
12759 let handles_before = decoder.remaining_handles();
12760 if let Some((inlined, num_bytes, num_handles)) =
12761 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12762 {
12763 let member_inline_size =
12764 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
12765 decoder.context,
12766 );
12767 if inlined != (member_inline_size <= 4) {
12768 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12769 }
12770 let inner_offset;
12771 let mut inner_depth = depth.clone();
12772 if inlined {
12773 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12774 inner_offset = next_offset;
12775 } else {
12776 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12777 inner_depth.increment()?;
12778 }
12779 let val_ref = self
12780 .source_name
12781 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
12782 fidl::decode!(
12783 fidl::encoding::BoundedString<100>,
12784 D,
12785 val_ref,
12786 decoder,
12787 inner_offset,
12788 inner_depth
12789 )?;
12790 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12791 {
12792 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12793 }
12794 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12795 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12796 }
12797 }
12798
12799 next_offset += envelope_size;
12800 _next_ordinal_to_read += 1;
12801 if next_offset >= end_offset {
12802 return Ok(());
12803 }
12804
12805 while _next_ordinal_to_read < 3 {
12807 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12808 _next_ordinal_to_read += 1;
12809 next_offset += envelope_size;
12810 }
12811
12812 let next_out_of_line = decoder.next_out_of_line();
12813 let handles_before = decoder.remaining_handles();
12814 if let Some((inlined, num_bytes, num_handles)) =
12815 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12816 {
12817 let member_inline_size =
12818 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12819 if inlined != (member_inline_size <= 4) {
12820 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12821 }
12822 let inner_offset;
12823 let mut inner_depth = depth.clone();
12824 if inlined {
12825 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12826 inner_offset = next_offset;
12827 } else {
12828 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12829 inner_depth.increment()?;
12830 }
12831 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
12832 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
12833 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12834 {
12835 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12836 }
12837 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12838 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12839 }
12840 }
12841
12842 next_offset += envelope_size;
12843 _next_ordinal_to_read += 1;
12844 if next_offset >= end_offset {
12845 return Ok(());
12846 }
12847
12848 while _next_ordinal_to_read < 4 {
12850 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12851 _next_ordinal_to_read += 1;
12852 next_offset += envelope_size;
12853 }
12854
12855 let next_out_of_line = decoder.next_out_of_line();
12856 let handles_before = decoder.remaining_handles();
12857 if let Some((inlined, num_bytes, num_handles)) =
12858 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12859 {
12860 let member_inline_size =
12861 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
12862 decoder.context,
12863 );
12864 if inlined != (member_inline_size <= 4) {
12865 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12866 }
12867 let inner_offset;
12868 let mut inner_depth = depth.clone();
12869 if inlined {
12870 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12871 inner_offset = next_offset;
12872 } else {
12873 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12874 inner_depth.increment()?;
12875 }
12876 let val_ref = self
12877 .target_name
12878 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
12879 fidl::decode!(
12880 fidl::encoding::BoundedString<100>,
12881 D,
12882 val_ref,
12883 decoder,
12884 inner_offset,
12885 inner_depth
12886 )?;
12887 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12888 {
12889 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12890 }
12891 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12892 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12893 }
12894 }
12895
12896 next_offset += envelope_size;
12897 _next_ordinal_to_read += 1;
12898 if next_offset >= end_offset {
12899 return Ok(());
12900 }
12901
12902 while _next_ordinal_to_read < 6 {
12904 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12905 _next_ordinal_to_read += 1;
12906 next_offset += envelope_size;
12907 }
12908
12909 let next_out_of_line = decoder.next_out_of_line();
12910 let handles_before = decoder.remaining_handles();
12911 if let Some((inlined, num_bytes, num_handles)) =
12912 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12913 {
12914 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12915 if inlined != (member_inline_size <= 4) {
12916 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12917 }
12918 let inner_offset;
12919 let mut inner_depth = depth.clone();
12920 if inlined {
12921 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12922 inner_offset = next_offset;
12923 } else {
12924 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12925 inner_depth.increment()?;
12926 }
12927 let val_ref = self.source_dictionary.get_or_insert_with(|| {
12928 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
12929 });
12930 fidl::decode!(
12931 fidl::encoding::BoundedString<1024>,
12932 D,
12933 val_ref,
12934 decoder,
12935 inner_offset,
12936 inner_depth
12937 )?;
12938 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12939 {
12940 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12941 }
12942 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12943 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12944 }
12945 }
12946
12947 next_offset += envelope_size;
12948
12949 while next_offset < end_offset {
12951 _next_ordinal_to_read += 1;
12952 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12953 next_offset += envelope_size;
12954 }
12955
12956 Ok(())
12957 }
12958 }
12959
12960 impl ExposeRunner {
12961 #[inline(always)]
12962 fn max_ordinal_present(&self) -> u64 {
12963 if let Some(_) = self.source_dictionary {
12964 return 6;
12965 }
12966 if let Some(_) = self.target_name {
12967 return 4;
12968 }
12969 if let Some(_) = self.target {
12970 return 3;
12971 }
12972 if let Some(_) = self.source_name {
12973 return 2;
12974 }
12975 if let Some(_) = self.source {
12976 return 1;
12977 }
12978 0
12979 }
12980 }
12981
12982 impl fidl::encoding::ValueTypeMarker for ExposeRunner {
12983 type Borrowed<'a> = &'a Self;
12984 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12985 value
12986 }
12987 }
12988
12989 unsafe impl fidl::encoding::TypeMarker for ExposeRunner {
12990 type Owned = Self;
12991
12992 #[inline(always)]
12993 fn inline_align(_context: fidl::encoding::Context) -> usize {
12994 8
12995 }
12996
12997 #[inline(always)]
12998 fn inline_size(_context: fidl::encoding::Context) -> usize {
12999 16
13000 }
13001 }
13002
13003 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeRunner, D>
13004 for &ExposeRunner
13005 {
13006 unsafe fn encode(
13007 self,
13008 encoder: &mut fidl::encoding::Encoder<'_, D>,
13009 offset: usize,
13010 mut depth: fidl::encoding::Depth,
13011 ) -> fidl::Result<()> {
13012 encoder.debug_check_bounds::<ExposeRunner>(offset);
13013 let max_ordinal: u64 = self.max_ordinal_present();
13015 encoder.write_num(max_ordinal, offset);
13016 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13017 if max_ordinal == 0 {
13019 return Ok(());
13020 }
13021 depth.increment()?;
13022 let envelope_size = 8;
13023 let bytes_len = max_ordinal as usize * envelope_size;
13024 #[allow(unused_variables)]
13025 let offset = encoder.out_of_line_offset(bytes_len);
13026 let mut _prev_end_offset: usize = 0;
13027 if 1 > max_ordinal {
13028 return Ok(());
13029 }
13030
13031 let cur_offset: usize = (1 - 1) * envelope_size;
13034
13035 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13037
13038 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
13043 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
13044 encoder,
13045 offset + cur_offset,
13046 depth,
13047 )?;
13048
13049 _prev_end_offset = cur_offset + envelope_size;
13050 if 2 > max_ordinal {
13051 return Ok(());
13052 }
13053
13054 let cur_offset: usize = (2 - 1) * envelope_size;
13057
13058 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13060
13061 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
13066 self.source_name.as_ref().map(
13067 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
13068 ),
13069 encoder,
13070 offset + cur_offset,
13071 depth,
13072 )?;
13073
13074 _prev_end_offset = cur_offset + envelope_size;
13075 if 3 > max_ordinal {
13076 return Ok(());
13077 }
13078
13079 let cur_offset: usize = (3 - 1) * envelope_size;
13082
13083 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13085
13086 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
13091 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
13092 encoder,
13093 offset + cur_offset,
13094 depth,
13095 )?;
13096
13097 _prev_end_offset = cur_offset + envelope_size;
13098 if 4 > max_ordinal {
13099 return Ok(());
13100 }
13101
13102 let cur_offset: usize = (4 - 1) * envelope_size;
13105
13106 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13108
13109 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
13114 self.target_name.as_ref().map(
13115 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
13116 ),
13117 encoder,
13118 offset + cur_offset,
13119 depth,
13120 )?;
13121
13122 _prev_end_offset = cur_offset + envelope_size;
13123 if 6 > max_ordinal {
13124 return Ok(());
13125 }
13126
13127 let cur_offset: usize = (6 - 1) * envelope_size;
13130
13131 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13133
13134 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
13139 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
13140 encoder, offset + cur_offset, depth
13141 )?;
13142
13143 _prev_end_offset = cur_offset + envelope_size;
13144
13145 Ok(())
13146 }
13147 }
13148
13149 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeRunner {
13150 #[inline(always)]
13151 fn new_empty() -> Self {
13152 Self::default()
13153 }
13154
13155 unsafe fn decode(
13156 &mut self,
13157 decoder: &mut fidl::encoding::Decoder<'_, D>,
13158 offset: usize,
13159 mut depth: fidl::encoding::Depth,
13160 ) -> fidl::Result<()> {
13161 decoder.debug_check_bounds::<Self>(offset);
13162 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13163 None => return Err(fidl::Error::NotNullable),
13164 Some(len) => len,
13165 };
13166 if len == 0 {
13168 return Ok(());
13169 };
13170 depth.increment()?;
13171 let envelope_size = 8;
13172 let bytes_len = len * envelope_size;
13173 let offset = decoder.out_of_line_offset(bytes_len)?;
13174 let mut _next_ordinal_to_read = 0;
13176 let mut next_offset = offset;
13177 let end_offset = offset + bytes_len;
13178 _next_ordinal_to_read += 1;
13179 if next_offset >= end_offset {
13180 return Ok(());
13181 }
13182
13183 while _next_ordinal_to_read < 1 {
13185 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13186 _next_ordinal_to_read += 1;
13187 next_offset += envelope_size;
13188 }
13189
13190 let next_out_of_line = decoder.next_out_of_line();
13191 let handles_before = decoder.remaining_handles();
13192 if let Some((inlined, num_bytes, num_handles)) =
13193 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13194 {
13195 let member_inline_size =
13196 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13197 if inlined != (member_inline_size <= 4) {
13198 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13199 }
13200 let inner_offset;
13201 let mut inner_depth = depth.clone();
13202 if inlined {
13203 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13204 inner_offset = next_offset;
13205 } else {
13206 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13207 inner_depth.increment()?;
13208 }
13209 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
13210 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
13211 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13212 {
13213 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13214 }
13215 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13216 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13217 }
13218 }
13219
13220 next_offset += envelope_size;
13221 _next_ordinal_to_read += 1;
13222 if next_offset >= end_offset {
13223 return Ok(());
13224 }
13225
13226 while _next_ordinal_to_read < 2 {
13228 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13229 _next_ordinal_to_read += 1;
13230 next_offset += envelope_size;
13231 }
13232
13233 let next_out_of_line = decoder.next_out_of_line();
13234 let handles_before = decoder.remaining_handles();
13235 if let Some((inlined, num_bytes, num_handles)) =
13236 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13237 {
13238 let member_inline_size =
13239 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13240 decoder.context,
13241 );
13242 if inlined != (member_inline_size <= 4) {
13243 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13244 }
13245 let inner_offset;
13246 let mut inner_depth = depth.clone();
13247 if inlined {
13248 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13249 inner_offset = next_offset;
13250 } else {
13251 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13252 inner_depth.increment()?;
13253 }
13254 let val_ref = self
13255 .source_name
13256 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
13257 fidl::decode!(
13258 fidl::encoding::BoundedString<100>,
13259 D,
13260 val_ref,
13261 decoder,
13262 inner_offset,
13263 inner_depth
13264 )?;
13265 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13266 {
13267 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13268 }
13269 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13270 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13271 }
13272 }
13273
13274 next_offset += envelope_size;
13275 _next_ordinal_to_read += 1;
13276 if next_offset >= end_offset {
13277 return Ok(());
13278 }
13279
13280 while _next_ordinal_to_read < 3 {
13282 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13283 _next_ordinal_to_read += 1;
13284 next_offset += envelope_size;
13285 }
13286
13287 let next_out_of_line = decoder.next_out_of_line();
13288 let handles_before = decoder.remaining_handles();
13289 if let Some((inlined, num_bytes, num_handles)) =
13290 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13291 {
13292 let member_inline_size =
13293 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13294 if inlined != (member_inline_size <= 4) {
13295 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13296 }
13297 let inner_offset;
13298 let mut inner_depth = depth.clone();
13299 if inlined {
13300 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13301 inner_offset = next_offset;
13302 } else {
13303 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13304 inner_depth.increment()?;
13305 }
13306 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
13307 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
13308 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13309 {
13310 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13311 }
13312 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13313 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13314 }
13315 }
13316
13317 next_offset += envelope_size;
13318 _next_ordinal_to_read += 1;
13319 if next_offset >= end_offset {
13320 return Ok(());
13321 }
13322
13323 while _next_ordinal_to_read < 4 {
13325 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13326 _next_ordinal_to_read += 1;
13327 next_offset += envelope_size;
13328 }
13329
13330 let next_out_of_line = decoder.next_out_of_line();
13331 let handles_before = decoder.remaining_handles();
13332 if let Some((inlined, num_bytes, num_handles)) =
13333 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13334 {
13335 let member_inline_size =
13336 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13337 decoder.context,
13338 );
13339 if inlined != (member_inline_size <= 4) {
13340 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13341 }
13342 let inner_offset;
13343 let mut inner_depth = depth.clone();
13344 if inlined {
13345 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13346 inner_offset = next_offset;
13347 } else {
13348 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13349 inner_depth.increment()?;
13350 }
13351 let val_ref = self
13352 .target_name
13353 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
13354 fidl::decode!(
13355 fidl::encoding::BoundedString<100>,
13356 D,
13357 val_ref,
13358 decoder,
13359 inner_offset,
13360 inner_depth
13361 )?;
13362 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13363 {
13364 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13365 }
13366 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13367 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13368 }
13369 }
13370
13371 next_offset += envelope_size;
13372 _next_ordinal_to_read += 1;
13373 if next_offset >= end_offset {
13374 return Ok(());
13375 }
13376
13377 while _next_ordinal_to_read < 6 {
13379 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13380 _next_ordinal_to_read += 1;
13381 next_offset += envelope_size;
13382 }
13383
13384 let next_out_of_line = decoder.next_out_of_line();
13385 let handles_before = decoder.remaining_handles();
13386 if let Some((inlined, num_bytes, num_handles)) =
13387 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13388 {
13389 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13390 if inlined != (member_inline_size <= 4) {
13391 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13392 }
13393 let inner_offset;
13394 let mut inner_depth = depth.clone();
13395 if inlined {
13396 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13397 inner_offset = next_offset;
13398 } else {
13399 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13400 inner_depth.increment()?;
13401 }
13402 let val_ref = self.source_dictionary.get_or_insert_with(|| {
13403 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
13404 });
13405 fidl::decode!(
13406 fidl::encoding::BoundedString<1024>,
13407 D,
13408 val_ref,
13409 decoder,
13410 inner_offset,
13411 inner_depth
13412 )?;
13413 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13414 {
13415 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13416 }
13417 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13418 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13419 }
13420 }
13421
13422 next_offset += envelope_size;
13423
13424 while next_offset < end_offset {
13426 _next_ordinal_to_read += 1;
13427 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13428 next_offset += envelope_size;
13429 }
13430
13431 Ok(())
13432 }
13433 }
13434
13435 impl ExposeService {
13436 #[inline(always)]
13437 fn max_ordinal_present(&self) -> u64 {
13438 if let Some(_) = self.source_dictionary {
13439 return 6;
13440 }
13441 if let Some(_) = self.availability {
13442 return 5;
13443 }
13444 if let Some(_) = self.target_name {
13445 return 4;
13446 }
13447 if let Some(_) = self.target {
13448 return 3;
13449 }
13450 if let Some(_) = self.source_name {
13451 return 2;
13452 }
13453 if let Some(_) = self.source {
13454 return 1;
13455 }
13456 0
13457 }
13458 }
13459
13460 impl fidl::encoding::ValueTypeMarker for ExposeService {
13461 type Borrowed<'a> = &'a Self;
13462 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13463 value
13464 }
13465 }
13466
13467 unsafe impl fidl::encoding::TypeMarker for ExposeService {
13468 type Owned = Self;
13469
13470 #[inline(always)]
13471 fn inline_align(_context: fidl::encoding::Context) -> usize {
13472 8
13473 }
13474
13475 #[inline(always)]
13476 fn inline_size(_context: fidl::encoding::Context) -> usize {
13477 16
13478 }
13479 }
13480
13481 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeService, D>
13482 for &ExposeService
13483 {
13484 unsafe fn encode(
13485 self,
13486 encoder: &mut fidl::encoding::Encoder<'_, D>,
13487 offset: usize,
13488 mut depth: fidl::encoding::Depth,
13489 ) -> fidl::Result<()> {
13490 encoder.debug_check_bounds::<ExposeService>(offset);
13491 let max_ordinal: u64 = self.max_ordinal_present();
13493 encoder.write_num(max_ordinal, offset);
13494 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13495 if max_ordinal == 0 {
13497 return Ok(());
13498 }
13499 depth.increment()?;
13500 let envelope_size = 8;
13501 let bytes_len = max_ordinal as usize * envelope_size;
13502 #[allow(unused_variables)]
13503 let offset = encoder.out_of_line_offset(bytes_len);
13504 let mut _prev_end_offset: usize = 0;
13505 if 1 > max_ordinal {
13506 return Ok(());
13507 }
13508
13509 let cur_offset: usize = (1 - 1) * envelope_size;
13512
13513 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13515
13516 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
13521 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
13522 encoder,
13523 offset + cur_offset,
13524 depth,
13525 )?;
13526
13527 _prev_end_offset = cur_offset + envelope_size;
13528 if 2 > max_ordinal {
13529 return Ok(());
13530 }
13531
13532 let cur_offset: usize = (2 - 1) * envelope_size;
13535
13536 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13538
13539 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
13544 self.source_name.as_ref().map(
13545 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
13546 ),
13547 encoder,
13548 offset + cur_offset,
13549 depth,
13550 )?;
13551
13552 _prev_end_offset = cur_offset + envelope_size;
13553 if 3 > max_ordinal {
13554 return Ok(());
13555 }
13556
13557 let cur_offset: usize = (3 - 1) * envelope_size;
13560
13561 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13563
13564 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
13569 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
13570 encoder,
13571 offset + cur_offset,
13572 depth,
13573 )?;
13574
13575 _prev_end_offset = cur_offset + envelope_size;
13576 if 4 > max_ordinal {
13577 return Ok(());
13578 }
13579
13580 let cur_offset: usize = (4 - 1) * envelope_size;
13583
13584 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13586
13587 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
13592 self.target_name.as_ref().map(
13593 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
13594 ),
13595 encoder,
13596 offset + cur_offset,
13597 depth,
13598 )?;
13599
13600 _prev_end_offset = cur_offset + envelope_size;
13601 if 5 > max_ordinal {
13602 return Ok(());
13603 }
13604
13605 let cur_offset: usize = (5 - 1) * envelope_size;
13608
13609 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13611
13612 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
13617 self.availability
13618 .as_ref()
13619 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
13620 encoder,
13621 offset + cur_offset,
13622 depth,
13623 )?;
13624
13625 _prev_end_offset = cur_offset + envelope_size;
13626 if 6 > max_ordinal {
13627 return Ok(());
13628 }
13629
13630 let cur_offset: usize = (6 - 1) * envelope_size;
13633
13634 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13636
13637 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
13642 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
13643 encoder, offset + cur_offset, depth
13644 )?;
13645
13646 _prev_end_offset = cur_offset + envelope_size;
13647
13648 Ok(())
13649 }
13650 }
13651
13652 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeService {
13653 #[inline(always)]
13654 fn new_empty() -> Self {
13655 Self::default()
13656 }
13657
13658 unsafe fn decode(
13659 &mut self,
13660 decoder: &mut fidl::encoding::Decoder<'_, D>,
13661 offset: usize,
13662 mut depth: fidl::encoding::Depth,
13663 ) -> fidl::Result<()> {
13664 decoder.debug_check_bounds::<Self>(offset);
13665 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13666 None => return Err(fidl::Error::NotNullable),
13667 Some(len) => len,
13668 };
13669 if len == 0 {
13671 return Ok(());
13672 };
13673 depth.increment()?;
13674 let envelope_size = 8;
13675 let bytes_len = len * envelope_size;
13676 let offset = decoder.out_of_line_offset(bytes_len)?;
13677 let mut _next_ordinal_to_read = 0;
13679 let mut next_offset = offset;
13680 let end_offset = offset + bytes_len;
13681 _next_ordinal_to_read += 1;
13682 if next_offset >= end_offset {
13683 return Ok(());
13684 }
13685
13686 while _next_ordinal_to_read < 1 {
13688 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13689 _next_ordinal_to_read += 1;
13690 next_offset += envelope_size;
13691 }
13692
13693 let next_out_of_line = decoder.next_out_of_line();
13694 let handles_before = decoder.remaining_handles();
13695 if let Some((inlined, num_bytes, num_handles)) =
13696 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13697 {
13698 let member_inline_size =
13699 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13700 if inlined != (member_inline_size <= 4) {
13701 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13702 }
13703 let inner_offset;
13704 let mut inner_depth = depth.clone();
13705 if inlined {
13706 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13707 inner_offset = next_offset;
13708 } else {
13709 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13710 inner_depth.increment()?;
13711 }
13712 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
13713 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
13714 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13715 {
13716 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13717 }
13718 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13719 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13720 }
13721 }
13722
13723 next_offset += envelope_size;
13724 _next_ordinal_to_read += 1;
13725 if next_offset >= end_offset {
13726 return Ok(());
13727 }
13728
13729 while _next_ordinal_to_read < 2 {
13731 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13732 _next_ordinal_to_read += 1;
13733 next_offset += envelope_size;
13734 }
13735
13736 let next_out_of_line = decoder.next_out_of_line();
13737 let handles_before = decoder.remaining_handles();
13738 if let Some((inlined, num_bytes, num_handles)) =
13739 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13740 {
13741 let member_inline_size =
13742 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13743 decoder.context,
13744 );
13745 if inlined != (member_inline_size <= 4) {
13746 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13747 }
13748 let inner_offset;
13749 let mut inner_depth = depth.clone();
13750 if inlined {
13751 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13752 inner_offset = next_offset;
13753 } else {
13754 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13755 inner_depth.increment()?;
13756 }
13757 let val_ref = self
13758 .source_name
13759 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
13760 fidl::decode!(
13761 fidl::encoding::BoundedString<100>,
13762 D,
13763 val_ref,
13764 decoder,
13765 inner_offset,
13766 inner_depth
13767 )?;
13768 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13769 {
13770 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13771 }
13772 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13773 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13774 }
13775 }
13776
13777 next_offset += envelope_size;
13778 _next_ordinal_to_read += 1;
13779 if next_offset >= end_offset {
13780 return Ok(());
13781 }
13782
13783 while _next_ordinal_to_read < 3 {
13785 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13786 _next_ordinal_to_read += 1;
13787 next_offset += envelope_size;
13788 }
13789
13790 let next_out_of_line = decoder.next_out_of_line();
13791 let handles_before = decoder.remaining_handles();
13792 if let Some((inlined, num_bytes, num_handles)) =
13793 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13794 {
13795 let member_inline_size =
13796 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13797 if inlined != (member_inline_size <= 4) {
13798 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13799 }
13800 let inner_offset;
13801 let mut inner_depth = depth.clone();
13802 if inlined {
13803 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13804 inner_offset = next_offset;
13805 } else {
13806 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13807 inner_depth.increment()?;
13808 }
13809 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
13810 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
13811 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13812 {
13813 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13814 }
13815 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13816 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13817 }
13818 }
13819
13820 next_offset += envelope_size;
13821 _next_ordinal_to_read += 1;
13822 if next_offset >= end_offset {
13823 return Ok(());
13824 }
13825
13826 while _next_ordinal_to_read < 4 {
13828 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13829 _next_ordinal_to_read += 1;
13830 next_offset += envelope_size;
13831 }
13832
13833 let next_out_of_line = decoder.next_out_of_line();
13834 let handles_before = decoder.remaining_handles();
13835 if let Some((inlined, num_bytes, num_handles)) =
13836 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13837 {
13838 let member_inline_size =
13839 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13840 decoder.context,
13841 );
13842 if inlined != (member_inline_size <= 4) {
13843 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13844 }
13845 let inner_offset;
13846 let mut inner_depth = depth.clone();
13847 if inlined {
13848 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13849 inner_offset = next_offset;
13850 } else {
13851 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13852 inner_depth.increment()?;
13853 }
13854 let val_ref = self
13855 .target_name
13856 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
13857 fidl::decode!(
13858 fidl::encoding::BoundedString<100>,
13859 D,
13860 val_ref,
13861 decoder,
13862 inner_offset,
13863 inner_depth
13864 )?;
13865 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13866 {
13867 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13868 }
13869 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13870 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13871 }
13872 }
13873
13874 next_offset += envelope_size;
13875 _next_ordinal_to_read += 1;
13876 if next_offset >= end_offset {
13877 return Ok(());
13878 }
13879
13880 while _next_ordinal_to_read < 5 {
13882 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13883 _next_ordinal_to_read += 1;
13884 next_offset += envelope_size;
13885 }
13886
13887 let next_out_of_line = decoder.next_out_of_line();
13888 let handles_before = decoder.remaining_handles();
13889 if let Some((inlined, num_bytes, num_handles)) =
13890 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13891 {
13892 let member_inline_size =
13893 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13894 if inlined != (member_inline_size <= 4) {
13895 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13896 }
13897 let inner_offset;
13898 let mut inner_depth = depth.clone();
13899 if inlined {
13900 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13901 inner_offset = next_offset;
13902 } else {
13903 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13904 inner_depth.increment()?;
13905 }
13906 let val_ref =
13907 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
13908 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
13909 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13910 {
13911 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13912 }
13913 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13914 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13915 }
13916 }
13917
13918 next_offset += envelope_size;
13919 _next_ordinal_to_read += 1;
13920 if next_offset >= end_offset {
13921 return Ok(());
13922 }
13923
13924 while _next_ordinal_to_read < 6 {
13926 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13927 _next_ordinal_to_read += 1;
13928 next_offset += envelope_size;
13929 }
13930
13931 let next_out_of_line = decoder.next_out_of_line();
13932 let handles_before = decoder.remaining_handles();
13933 if let Some((inlined, num_bytes, num_handles)) =
13934 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13935 {
13936 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13937 if inlined != (member_inline_size <= 4) {
13938 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13939 }
13940 let inner_offset;
13941 let mut inner_depth = depth.clone();
13942 if inlined {
13943 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13944 inner_offset = next_offset;
13945 } else {
13946 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13947 inner_depth.increment()?;
13948 }
13949 let val_ref = self.source_dictionary.get_or_insert_with(|| {
13950 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
13951 });
13952 fidl::decode!(
13953 fidl::encoding::BoundedString<1024>,
13954 D,
13955 val_ref,
13956 decoder,
13957 inner_offset,
13958 inner_depth
13959 )?;
13960 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13961 {
13962 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13963 }
13964 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13965 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13966 }
13967 }
13968
13969 next_offset += envelope_size;
13970
13971 while next_offset < end_offset {
13973 _next_ordinal_to_read += 1;
13974 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13975 next_offset += envelope_size;
13976 }
13977
13978 Ok(())
13979 }
13980 }
13981
13982 impl OfferConfiguration {
13983 #[inline(always)]
13984 fn max_ordinal_present(&self) -> u64 {
13985 if let Some(_) = self.source_dictionary {
13986 return 6;
13987 }
13988 if let Some(_) = self.availability {
13989 return 5;
13990 }
13991 if let Some(_) = self.target_name {
13992 return 4;
13993 }
13994 if let Some(_) = self.target {
13995 return 3;
13996 }
13997 if let Some(_) = self.source_name {
13998 return 2;
13999 }
14000 if let Some(_) = self.source {
14001 return 1;
14002 }
14003 0
14004 }
14005 }
14006
14007 impl fidl::encoding::ValueTypeMarker for OfferConfiguration {
14008 type Borrowed<'a> = &'a Self;
14009 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14010 value
14011 }
14012 }
14013
14014 unsafe impl fidl::encoding::TypeMarker for OfferConfiguration {
14015 type Owned = Self;
14016
14017 #[inline(always)]
14018 fn inline_align(_context: fidl::encoding::Context) -> usize {
14019 8
14020 }
14021
14022 #[inline(always)]
14023 fn inline_size(_context: fidl::encoding::Context) -> usize {
14024 16
14025 }
14026 }
14027
14028 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferConfiguration, D>
14029 for &OfferConfiguration
14030 {
14031 unsafe fn encode(
14032 self,
14033 encoder: &mut fidl::encoding::Encoder<'_, D>,
14034 offset: usize,
14035 mut depth: fidl::encoding::Depth,
14036 ) -> fidl::Result<()> {
14037 encoder.debug_check_bounds::<OfferConfiguration>(offset);
14038 let max_ordinal: u64 = self.max_ordinal_present();
14040 encoder.write_num(max_ordinal, offset);
14041 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14042 if max_ordinal == 0 {
14044 return Ok(());
14045 }
14046 depth.increment()?;
14047 let envelope_size = 8;
14048 let bytes_len = max_ordinal as usize * envelope_size;
14049 #[allow(unused_variables)]
14050 let offset = encoder.out_of_line_offset(bytes_len);
14051 let mut _prev_end_offset: usize = 0;
14052 if 1 > max_ordinal {
14053 return Ok(());
14054 }
14055
14056 let cur_offset: usize = (1 - 1) * envelope_size;
14059
14060 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14062
14063 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
14068 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
14069 encoder,
14070 offset + cur_offset,
14071 depth,
14072 )?;
14073
14074 _prev_end_offset = cur_offset + envelope_size;
14075 if 2 > max_ordinal {
14076 return Ok(());
14077 }
14078
14079 let cur_offset: usize = (2 - 1) * envelope_size;
14082
14083 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14085
14086 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
14091 self.source_name.as_ref().map(
14092 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
14093 ),
14094 encoder,
14095 offset + cur_offset,
14096 depth,
14097 )?;
14098
14099 _prev_end_offset = cur_offset + envelope_size;
14100 if 3 > max_ordinal {
14101 return Ok(());
14102 }
14103
14104 let cur_offset: usize = (3 - 1) * envelope_size;
14107
14108 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14110
14111 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
14116 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
14117 encoder,
14118 offset + cur_offset,
14119 depth,
14120 )?;
14121
14122 _prev_end_offset = cur_offset + envelope_size;
14123 if 4 > max_ordinal {
14124 return Ok(());
14125 }
14126
14127 let cur_offset: usize = (4 - 1) * envelope_size;
14130
14131 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14133
14134 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
14139 self.target_name.as_ref().map(
14140 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
14141 ),
14142 encoder,
14143 offset + cur_offset,
14144 depth,
14145 )?;
14146
14147 _prev_end_offset = cur_offset + envelope_size;
14148 if 5 > max_ordinal {
14149 return Ok(());
14150 }
14151
14152 let cur_offset: usize = (5 - 1) * envelope_size;
14155
14156 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14158
14159 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
14164 self.availability
14165 .as_ref()
14166 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
14167 encoder,
14168 offset + cur_offset,
14169 depth,
14170 )?;
14171
14172 _prev_end_offset = cur_offset + envelope_size;
14173 if 6 > max_ordinal {
14174 return Ok(());
14175 }
14176
14177 let cur_offset: usize = (6 - 1) * envelope_size;
14180
14181 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14183
14184 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
14189 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
14190 encoder, offset + cur_offset, depth
14191 )?;
14192
14193 _prev_end_offset = cur_offset + envelope_size;
14194
14195 Ok(())
14196 }
14197 }
14198
14199 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferConfiguration {
14200 #[inline(always)]
14201 fn new_empty() -> Self {
14202 Self::default()
14203 }
14204
14205 unsafe fn decode(
14206 &mut self,
14207 decoder: &mut fidl::encoding::Decoder<'_, D>,
14208 offset: usize,
14209 mut depth: fidl::encoding::Depth,
14210 ) -> fidl::Result<()> {
14211 decoder.debug_check_bounds::<Self>(offset);
14212 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14213 None => return Err(fidl::Error::NotNullable),
14214 Some(len) => len,
14215 };
14216 if len == 0 {
14218 return Ok(());
14219 };
14220 depth.increment()?;
14221 let envelope_size = 8;
14222 let bytes_len = len * envelope_size;
14223 let offset = decoder.out_of_line_offset(bytes_len)?;
14224 let mut _next_ordinal_to_read = 0;
14226 let mut next_offset = offset;
14227 let end_offset = offset + bytes_len;
14228 _next_ordinal_to_read += 1;
14229 if next_offset >= end_offset {
14230 return Ok(());
14231 }
14232
14233 while _next_ordinal_to_read < 1 {
14235 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14236 _next_ordinal_to_read += 1;
14237 next_offset += envelope_size;
14238 }
14239
14240 let next_out_of_line = decoder.next_out_of_line();
14241 let handles_before = decoder.remaining_handles();
14242 if let Some((inlined, num_bytes, num_handles)) =
14243 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14244 {
14245 let member_inline_size =
14246 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14247 if inlined != (member_inline_size <= 4) {
14248 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14249 }
14250 let inner_offset;
14251 let mut inner_depth = depth.clone();
14252 if inlined {
14253 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14254 inner_offset = next_offset;
14255 } else {
14256 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14257 inner_depth.increment()?;
14258 }
14259 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
14260 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
14261 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14262 {
14263 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14264 }
14265 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14266 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14267 }
14268 }
14269
14270 next_offset += envelope_size;
14271 _next_ordinal_to_read += 1;
14272 if next_offset >= end_offset {
14273 return Ok(());
14274 }
14275
14276 while _next_ordinal_to_read < 2 {
14278 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14279 _next_ordinal_to_read += 1;
14280 next_offset += envelope_size;
14281 }
14282
14283 let next_out_of_line = decoder.next_out_of_line();
14284 let handles_before = decoder.remaining_handles();
14285 if let Some((inlined, num_bytes, num_handles)) =
14286 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14287 {
14288 let member_inline_size =
14289 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
14290 decoder.context,
14291 );
14292 if inlined != (member_inline_size <= 4) {
14293 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14294 }
14295 let inner_offset;
14296 let mut inner_depth = depth.clone();
14297 if inlined {
14298 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14299 inner_offset = next_offset;
14300 } else {
14301 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14302 inner_depth.increment()?;
14303 }
14304 let val_ref = self
14305 .source_name
14306 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
14307 fidl::decode!(
14308 fidl::encoding::BoundedString<100>,
14309 D,
14310 val_ref,
14311 decoder,
14312 inner_offset,
14313 inner_depth
14314 )?;
14315 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14316 {
14317 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14318 }
14319 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14320 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14321 }
14322 }
14323
14324 next_offset += envelope_size;
14325 _next_ordinal_to_read += 1;
14326 if next_offset >= end_offset {
14327 return Ok(());
14328 }
14329
14330 while _next_ordinal_to_read < 3 {
14332 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14333 _next_ordinal_to_read += 1;
14334 next_offset += envelope_size;
14335 }
14336
14337 let next_out_of_line = decoder.next_out_of_line();
14338 let handles_before = decoder.remaining_handles();
14339 if let Some((inlined, num_bytes, num_handles)) =
14340 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14341 {
14342 let member_inline_size =
14343 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14344 if inlined != (member_inline_size <= 4) {
14345 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14346 }
14347 let inner_offset;
14348 let mut inner_depth = depth.clone();
14349 if inlined {
14350 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14351 inner_offset = next_offset;
14352 } else {
14353 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14354 inner_depth.increment()?;
14355 }
14356 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
14357 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
14358 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14359 {
14360 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14361 }
14362 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14363 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14364 }
14365 }
14366
14367 next_offset += envelope_size;
14368 _next_ordinal_to_read += 1;
14369 if next_offset >= end_offset {
14370 return Ok(());
14371 }
14372
14373 while _next_ordinal_to_read < 4 {
14375 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14376 _next_ordinal_to_read += 1;
14377 next_offset += envelope_size;
14378 }
14379
14380 let next_out_of_line = decoder.next_out_of_line();
14381 let handles_before = decoder.remaining_handles();
14382 if let Some((inlined, num_bytes, num_handles)) =
14383 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14384 {
14385 let member_inline_size =
14386 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
14387 decoder.context,
14388 );
14389 if inlined != (member_inline_size <= 4) {
14390 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14391 }
14392 let inner_offset;
14393 let mut inner_depth = depth.clone();
14394 if inlined {
14395 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14396 inner_offset = next_offset;
14397 } else {
14398 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14399 inner_depth.increment()?;
14400 }
14401 let val_ref = self
14402 .target_name
14403 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
14404 fidl::decode!(
14405 fidl::encoding::BoundedString<100>,
14406 D,
14407 val_ref,
14408 decoder,
14409 inner_offset,
14410 inner_depth
14411 )?;
14412 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14413 {
14414 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14415 }
14416 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14417 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14418 }
14419 }
14420
14421 next_offset += envelope_size;
14422 _next_ordinal_to_read += 1;
14423 if next_offset >= end_offset {
14424 return Ok(());
14425 }
14426
14427 while _next_ordinal_to_read < 5 {
14429 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14430 _next_ordinal_to_read += 1;
14431 next_offset += envelope_size;
14432 }
14433
14434 let next_out_of_line = decoder.next_out_of_line();
14435 let handles_before = decoder.remaining_handles();
14436 if let Some((inlined, num_bytes, num_handles)) =
14437 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14438 {
14439 let member_inline_size =
14440 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14441 if inlined != (member_inline_size <= 4) {
14442 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14443 }
14444 let inner_offset;
14445 let mut inner_depth = depth.clone();
14446 if inlined {
14447 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14448 inner_offset = next_offset;
14449 } else {
14450 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14451 inner_depth.increment()?;
14452 }
14453 let val_ref =
14454 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
14455 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
14456 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14457 {
14458 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14459 }
14460 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14461 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14462 }
14463 }
14464
14465 next_offset += envelope_size;
14466 _next_ordinal_to_read += 1;
14467 if next_offset >= end_offset {
14468 return Ok(());
14469 }
14470
14471 while _next_ordinal_to_read < 6 {
14473 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14474 _next_ordinal_to_read += 1;
14475 next_offset += envelope_size;
14476 }
14477
14478 let next_out_of_line = decoder.next_out_of_line();
14479 let handles_before = decoder.remaining_handles();
14480 if let Some((inlined, num_bytes, num_handles)) =
14481 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14482 {
14483 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14484 if inlined != (member_inline_size <= 4) {
14485 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14486 }
14487 let inner_offset;
14488 let mut inner_depth = depth.clone();
14489 if inlined {
14490 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14491 inner_offset = next_offset;
14492 } else {
14493 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14494 inner_depth.increment()?;
14495 }
14496 let val_ref = self.source_dictionary.get_or_insert_with(|| {
14497 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
14498 });
14499 fidl::decode!(
14500 fidl::encoding::BoundedString<1024>,
14501 D,
14502 val_ref,
14503 decoder,
14504 inner_offset,
14505 inner_depth
14506 )?;
14507 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14508 {
14509 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14510 }
14511 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14512 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14513 }
14514 }
14515
14516 next_offset += envelope_size;
14517
14518 while next_offset < end_offset {
14520 _next_ordinal_to_read += 1;
14521 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14522 next_offset += envelope_size;
14523 }
14524
14525 Ok(())
14526 }
14527 }
14528
14529 impl OfferDictionary {
14530 #[inline(always)]
14531 fn max_ordinal_present(&self) -> u64 {
14532 if let Some(_) = self.source_dictionary {
14533 return 7;
14534 }
14535 if let Some(_) = self.availability {
14536 return 6;
14537 }
14538 if let Some(_) = self.dependency_type {
14539 return 5;
14540 }
14541 if let Some(_) = self.target_name {
14542 return 4;
14543 }
14544 if let Some(_) = self.target {
14545 return 3;
14546 }
14547 if let Some(_) = self.source_name {
14548 return 2;
14549 }
14550 if let Some(_) = self.source {
14551 return 1;
14552 }
14553 0
14554 }
14555 }
14556
14557 impl fidl::encoding::ValueTypeMarker for OfferDictionary {
14558 type Borrowed<'a> = &'a Self;
14559 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14560 value
14561 }
14562 }
14563
14564 unsafe impl fidl::encoding::TypeMarker for OfferDictionary {
14565 type Owned = Self;
14566
14567 #[inline(always)]
14568 fn inline_align(_context: fidl::encoding::Context) -> usize {
14569 8
14570 }
14571
14572 #[inline(always)]
14573 fn inline_size(_context: fidl::encoding::Context) -> usize {
14574 16
14575 }
14576 }
14577
14578 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferDictionary, D>
14579 for &OfferDictionary
14580 {
14581 unsafe fn encode(
14582 self,
14583 encoder: &mut fidl::encoding::Encoder<'_, D>,
14584 offset: usize,
14585 mut depth: fidl::encoding::Depth,
14586 ) -> fidl::Result<()> {
14587 encoder.debug_check_bounds::<OfferDictionary>(offset);
14588 let max_ordinal: u64 = self.max_ordinal_present();
14590 encoder.write_num(max_ordinal, offset);
14591 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14592 if max_ordinal == 0 {
14594 return Ok(());
14595 }
14596 depth.increment()?;
14597 let envelope_size = 8;
14598 let bytes_len = max_ordinal as usize * envelope_size;
14599 #[allow(unused_variables)]
14600 let offset = encoder.out_of_line_offset(bytes_len);
14601 let mut _prev_end_offset: usize = 0;
14602 if 1 > max_ordinal {
14603 return Ok(());
14604 }
14605
14606 let cur_offset: usize = (1 - 1) * envelope_size;
14609
14610 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14612
14613 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
14618 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
14619 encoder,
14620 offset + cur_offset,
14621 depth,
14622 )?;
14623
14624 _prev_end_offset = cur_offset + envelope_size;
14625 if 2 > max_ordinal {
14626 return Ok(());
14627 }
14628
14629 let cur_offset: usize = (2 - 1) * envelope_size;
14632
14633 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14635
14636 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
14641 self.source_name.as_ref().map(
14642 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
14643 ),
14644 encoder,
14645 offset + cur_offset,
14646 depth,
14647 )?;
14648
14649 _prev_end_offset = cur_offset + envelope_size;
14650 if 3 > max_ordinal {
14651 return Ok(());
14652 }
14653
14654 let cur_offset: usize = (3 - 1) * envelope_size;
14657
14658 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14660
14661 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
14666 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
14667 encoder,
14668 offset + cur_offset,
14669 depth,
14670 )?;
14671
14672 _prev_end_offset = cur_offset + envelope_size;
14673 if 4 > max_ordinal {
14674 return Ok(());
14675 }
14676
14677 let cur_offset: usize = (4 - 1) * envelope_size;
14680
14681 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14683
14684 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
14689 self.target_name.as_ref().map(
14690 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
14691 ),
14692 encoder,
14693 offset + cur_offset,
14694 depth,
14695 )?;
14696
14697 _prev_end_offset = cur_offset + envelope_size;
14698 if 5 > max_ordinal {
14699 return Ok(());
14700 }
14701
14702 let cur_offset: usize = (5 - 1) * envelope_size;
14705
14706 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14708
14709 fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
14714 self.dependency_type
14715 .as_ref()
14716 .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
14717 encoder,
14718 offset + cur_offset,
14719 depth,
14720 )?;
14721
14722 _prev_end_offset = cur_offset + envelope_size;
14723 if 6 > max_ordinal {
14724 return Ok(());
14725 }
14726
14727 let cur_offset: usize = (6 - 1) * envelope_size;
14730
14731 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14733
14734 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
14739 self.availability
14740 .as_ref()
14741 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
14742 encoder,
14743 offset + cur_offset,
14744 depth,
14745 )?;
14746
14747 _prev_end_offset = cur_offset + envelope_size;
14748 if 7 > max_ordinal {
14749 return Ok(());
14750 }
14751
14752 let cur_offset: usize = (7 - 1) * envelope_size;
14755
14756 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14758
14759 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
14764 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
14765 encoder, offset + cur_offset, depth
14766 )?;
14767
14768 _prev_end_offset = cur_offset + envelope_size;
14769
14770 Ok(())
14771 }
14772 }
14773
14774 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferDictionary {
14775 #[inline(always)]
14776 fn new_empty() -> Self {
14777 Self::default()
14778 }
14779
14780 unsafe fn decode(
14781 &mut self,
14782 decoder: &mut fidl::encoding::Decoder<'_, D>,
14783 offset: usize,
14784 mut depth: fidl::encoding::Depth,
14785 ) -> fidl::Result<()> {
14786 decoder.debug_check_bounds::<Self>(offset);
14787 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14788 None => return Err(fidl::Error::NotNullable),
14789 Some(len) => len,
14790 };
14791 if len == 0 {
14793 return Ok(());
14794 };
14795 depth.increment()?;
14796 let envelope_size = 8;
14797 let bytes_len = len * envelope_size;
14798 let offset = decoder.out_of_line_offset(bytes_len)?;
14799 let mut _next_ordinal_to_read = 0;
14801 let mut next_offset = offset;
14802 let end_offset = offset + bytes_len;
14803 _next_ordinal_to_read += 1;
14804 if next_offset >= end_offset {
14805 return Ok(());
14806 }
14807
14808 while _next_ordinal_to_read < 1 {
14810 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14811 _next_ordinal_to_read += 1;
14812 next_offset += envelope_size;
14813 }
14814
14815 let next_out_of_line = decoder.next_out_of_line();
14816 let handles_before = decoder.remaining_handles();
14817 if let Some((inlined, num_bytes, num_handles)) =
14818 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14819 {
14820 let member_inline_size =
14821 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14822 if inlined != (member_inline_size <= 4) {
14823 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14824 }
14825 let inner_offset;
14826 let mut inner_depth = depth.clone();
14827 if inlined {
14828 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14829 inner_offset = next_offset;
14830 } else {
14831 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14832 inner_depth.increment()?;
14833 }
14834 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
14835 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
14836 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14837 {
14838 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14839 }
14840 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14841 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14842 }
14843 }
14844
14845 next_offset += envelope_size;
14846 _next_ordinal_to_read += 1;
14847 if next_offset >= end_offset {
14848 return Ok(());
14849 }
14850
14851 while _next_ordinal_to_read < 2 {
14853 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14854 _next_ordinal_to_read += 1;
14855 next_offset += envelope_size;
14856 }
14857
14858 let next_out_of_line = decoder.next_out_of_line();
14859 let handles_before = decoder.remaining_handles();
14860 if let Some((inlined, num_bytes, num_handles)) =
14861 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14862 {
14863 let member_inline_size =
14864 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
14865 decoder.context,
14866 );
14867 if inlined != (member_inline_size <= 4) {
14868 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14869 }
14870 let inner_offset;
14871 let mut inner_depth = depth.clone();
14872 if inlined {
14873 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14874 inner_offset = next_offset;
14875 } else {
14876 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14877 inner_depth.increment()?;
14878 }
14879 let val_ref = self
14880 .source_name
14881 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
14882 fidl::decode!(
14883 fidl::encoding::BoundedString<100>,
14884 D,
14885 val_ref,
14886 decoder,
14887 inner_offset,
14888 inner_depth
14889 )?;
14890 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14891 {
14892 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14893 }
14894 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14895 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14896 }
14897 }
14898
14899 next_offset += envelope_size;
14900 _next_ordinal_to_read += 1;
14901 if next_offset >= end_offset {
14902 return Ok(());
14903 }
14904
14905 while _next_ordinal_to_read < 3 {
14907 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14908 _next_ordinal_to_read += 1;
14909 next_offset += envelope_size;
14910 }
14911
14912 let next_out_of_line = decoder.next_out_of_line();
14913 let handles_before = decoder.remaining_handles();
14914 if let Some((inlined, num_bytes, num_handles)) =
14915 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14916 {
14917 let member_inline_size =
14918 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14919 if inlined != (member_inline_size <= 4) {
14920 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14921 }
14922 let inner_offset;
14923 let mut inner_depth = depth.clone();
14924 if inlined {
14925 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14926 inner_offset = next_offset;
14927 } else {
14928 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14929 inner_depth.increment()?;
14930 }
14931 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
14932 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
14933 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14934 {
14935 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14936 }
14937 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14938 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14939 }
14940 }
14941
14942 next_offset += envelope_size;
14943 _next_ordinal_to_read += 1;
14944 if next_offset >= end_offset {
14945 return Ok(());
14946 }
14947
14948 while _next_ordinal_to_read < 4 {
14950 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14951 _next_ordinal_to_read += 1;
14952 next_offset += envelope_size;
14953 }
14954
14955 let next_out_of_line = decoder.next_out_of_line();
14956 let handles_before = decoder.remaining_handles();
14957 if let Some((inlined, num_bytes, num_handles)) =
14958 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14959 {
14960 let member_inline_size =
14961 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
14962 decoder.context,
14963 );
14964 if inlined != (member_inline_size <= 4) {
14965 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14966 }
14967 let inner_offset;
14968 let mut inner_depth = depth.clone();
14969 if inlined {
14970 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14971 inner_offset = next_offset;
14972 } else {
14973 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14974 inner_depth.increment()?;
14975 }
14976 let val_ref = self
14977 .target_name
14978 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
14979 fidl::decode!(
14980 fidl::encoding::BoundedString<100>,
14981 D,
14982 val_ref,
14983 decoder,
14984 inner_offset,
14985 inner_depth
14986 )?;
14987 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14988 {
14989 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14990 }
14991 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14992 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14993 }
14994 }
14995
14996 next_offset += envelope_size;
14997 _next_ordinal_to_read += 1;
14998 if next_offset >= end_offset {
14999 return Ok(());
15000 }
15001
15002 while _next_ordinal_to_read < 5 {
15004 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15005 _next_ordinal_to_read += 1;
15006 next_offset += envelope_size;
15007 }
15008
15009 let next_out_of_line = decoder.next_out_of_line();
15010 let handles_before = decoder.remaining_handles();
15011 if let Some((inlined, num_bytes, num_handles)) =
15012 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15013 {
15014 let member_inline_size =
15015 <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15016 if inlined != (member_inline_size <= 4) {
15017 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15018 }
15019 let inner_offset;
15020 let mut inner_depth = depth.clone();
15021 if inlined {
15022 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15023 inner_offset = next_offset;
15024 } else {
15025 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15026 inner_depth.increment()?;
15027 }
15028 let val_ref =
15029 self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
15030 fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
15031 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15032 {
15033 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15034 }
15035 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15036 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15037 }
15038 }
15039
15040 next_offset += envelope_size;
15041 _next_ordinal_to_read += 1;
15042 if next_offset >= end_offset {
15043 return Ok(());
15044 }
15045
15046 while _next_ordinal_to_read < 6 {
15048 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15049 _next_ordinal_to_read += 1;
15050 next_offset += envelope_size;
15051 }
15052
15053 let next_out_of_line = decoder.next_out_of_line();
15054 let handles_before = decoder.remaining_handles();
15055 if let Some((inlined, num_bytes, num_handles)) =
15056 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15057 {
15058 let member_inline_size =
15059 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15060 if inlined != (member_inline_size <= 4) {
15061 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15062 }
15063 let inner_offset;
15064 let mut inner_depth = depth.clone();
15065 if inlined {
15066 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15067 inner_offset = next_offset;
15068 } else {
15069 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15070 inner_depth.increment()?;
15071 }
15072 let val_ref =
15073 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
15074 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
15075 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15076 {
15077 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15078 }
15079 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15080 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15081 }
15082 }
15083
15084 next_offset += envelope_size;
15085 _next_ordinal_to_read += 1;
15086 if next_offset >= end_offset {
15087 return Ok(());
15088 }
15089
15090 while _next_ordinal_to_read < 7 {
15092 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15093 _next_ordinal_to_read += 1;
15094 next_offset += envelope_size;
15095 }
15096
15097 let next_out_of_line = decoder.next_out_of_line();
15098 let handles_before = decoder.remaining_handles();
15099 if let Some((inlined, num_bytes, num_handles)) =
15100 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15101 {
15102 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15103 if inlined != (member_inline_size <= 4) {
15104 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15105 }
15106 let inner_offset;
15107 let mut inner_depth = depth.clone();
15108 if inlined {
15109 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15110 inner_offset = next_offset;
15111 } else {
15112 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15113 inner_depth.increment()?;
15114 }
15115 let val_ref = self.source_dictionary.get_or_insert_with(|| {
15116 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
15117 });
15118 fidl::decode!(
15119 fidl::encoding::BoundedString<1024>,
15120 D,
15121 val_ref,
15122 decoder,
15123 inner_offset,
15124 inner_depth
15125 )?;
15126 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15127 {
15128 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15129 }
15130 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15131 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15132 }
15133 }
15134
15135 next_offset += envelope_size;
15136
15137 while next_offset < end_offset {
15139 _next_ordinal_to_read += 1;
15140 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15141 next_offset += envelope_size;
15142 }
15143
15144 Ok(())
15145 }
15146 }
15147
15148 impl OfferDirectory {
15149 #[inline(always)]
15150 fn max_ordinal_present(&self) -> u64 {
15151 if let Some(_) = self.source_dictionary {
15152 return 9;
15153 }
15154 if let Some(_) = self.availability {
15155 return 8;
15156 }
15157 if let Some(_) = self.dependency_type {
15158 return 7;
15159 }
15160 if let Some(_) = self.subdir {
15161 return 6;
15162 }
15163 if let Some(_) = self.rights {
15164 return 5;
15165 }
15166 if let Some(_) = self.target_name {
15167 return 4;
15168 }
15169 if let Some(_) = self.target {
15170 return 3;
15171 }
15172 if let Some(_) = self.source_name {
15173 return 2;
15174 }
15175 if let Some(_) = self.source {
15176 return 1;
15177 }
15178 0
15179 }
15180 }
15181
15182 impl fidl::encoding::ValueTypeMarker for OfferDirectory {
15183 type Borrowed<'a> = &'a Self;
15184 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15185 value
15186 }
15187 }
15188
15189 unsafe impl fidl::encoding::TypeMarker for OfferDirectory {
15190 type Owned = Self;
15191
15192 #[inline(always)]
15193 fn inline_align(_context: fidl::encoding::Context) -> usize {
15194 8
15195 }
15196
15197 #[inline(always)]
15198 fn inline_size(_context: fidl::encoding::Context) -> usize {
15199 16
15200 }
15201 }
15202
15203 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferDirectory, D>
15204 for &OfferDirectory
15205 {
15206 unsafe fn encode(
15207 self,
15208 encoder: &mut fidl::encoding::Encoder<'_, D>,
15209 offset: usize,
15210 mut depth: fidl::encoding::Depth,
15211 ) -> fidl::Result<()> {
15212 encoder.debug_check_bounds::<OfferDirectory>(offset);
15213 let max_ordinal: u64 = self.max_ordinal_present();
15215 encoder.write_num(max_ordinal, offset);
15216 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15217 if max_ordinal == 0 {
15219 return Ok(());
15220 }
15221 depth.increment()?;
15222 let envelope_size = 8;
15223 let bytes_len = max_ordinal as usize * envelope_size;
15224 #[allow(unused_variables)]
15225 let offset = encoder.out_of_line_offset(bytes_len);
15226 let mut _prev_end_offset: usize = 0;
15227 if 1 > max_ordinal {
15228 return Ok(());
15229 }
15230
15231 let cur_offset: usize = (1 - 1) * envelope_size;
15234
15235 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15237
15238 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
15243 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
15244 encoder,
15245 offset + cur_offset,
15246 depth,
15247 )?;
15248
15249 _prev_end_offset = cur_offset + envelope_size;
15250 if 2 > max_ordinal {
15251 return Ok(());
15252 }
15253
15254 let cur_offset: usize = (2 - 1) * envelope_size;
15257
15258 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15260
15261 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
15266 self.source_name.as_ref().map(
15267 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
15268 ),
15269 encoder,
15270 offset + cur_offset,
15271 depth,
15272 )?;
15273
15274 _prev_end_offset = cur_offset + envelope_size;
15275 if 3 > max_ordinal {
15276 return Ok(());
15277 }
15278
15279 let cur_offset: usize = (3 - 1) * envelope_size;
15282
15283 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15285
15286 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
15291 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
15292 encoder,
15293 offset + cur_offset,
15294 depth,
15295 )?;
15296
15297 _prev_end_offset = cur_offset + envelope_size;
15298 if 4 > max_ordinal {
15299 return Ok(());
15300 }
15301
15302 let cur_offset: usize = (4 - 1) * envelope_size;
15305
15306 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15308
15309 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
15314 self.target_name.as_ref().map(
15315 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
15316 ),
15317 encoder,
15318 offset + cur_offset,
15319 depth,
15320 )?;
15321
15322 _prev_end_offset = cur_offset + envelope_size;
15323 if 5 > max_ordinal {
15324 return Ok(());
15325 }
15326
15327 let cur_offset: usize = (5 - 1) * envelope_size;
15330
15331 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15333
15334 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_io__common::Operations, D>(
15339 self.rights.as_ref().map(<fidl_fuchsia_io__common::Operations as fidl::encoding::ValueTypeMarker>::borrow),
15340 encoder, offset + cur_offset, depth
15341 )?;
15342
15343 _prev_end_offset = cur_offset + envelope_size;
15344 if 6 > max_ordinal {
15345 return Ok(());
15346 }
15347
15348 let cur_offset: usize = (6 - 1) * envelope_size;
15351
15352 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15354
15355 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
15360 self.subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
15361 encoder, offset + cur_offset, depth
15362 )?;
15363
15364 _prev_end_offset = cur_offset + envelope_size;
15365 if 7 > max_ordinal {
15366 return Ok(());
15367 }
15368
15369 let cur_offset: usize = (7 - 1) * envelope_size;
15372
15373 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15375
15376 fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
15381 self.dependency_type
15382 .as_ref()
15383 .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
15384 encoder,
15385 offset + cur_offset,
15386 depth,
15387 )?;
15388
15389 _prev_end_offset = cur_offset + envelope_size;
15390 if 8 > max_ordinal {
15391 return Ok(());
15392 }
15393
15394 let cur_offset: usize = (8 - 1) * envelope_size;
15397
15398 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15400
15401 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
15406 self.availability
15407 .as_ref()
15408 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
15409 encoder,
15410 offset + cur_offset,
15411 depth,
15412 )?;
15413
15414 _prev_end_offset = cur_offset + envelope_size;
15415 if 9 > max_ordinal {
15416 return Ok(());
15417 }
15418
15419 let cur_offset: usize = (9 - 1) * envelope_size;
15422
15423 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15425
15426 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
15431 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
15432 encoder, offset + cur_offset, depth
15433 )?;
15434
15435 _prev_end_offset = cur_offset + envelope_size;
15436
15437 Ok(())
15438 }
15439 }
15440
15441 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferDirectory {
15442 #[inline(always)]
15443 fn new_empty() -> Self {
15444 Self::default()
15445 }
15446
15447 unsafe fn decode(
15448 &mut self,
15449 decoder: &mut fidl::encoding::Decoder<'_, D>,
15450 offset: usize,
15451 mut depth: fidl::encoding::Depth,
15452 ) -> fidl::Result<()> {
15453 decoder.debug_check_bounds::<Self>(offset);
15454 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15455 None => return Err(fidl::Error::NotNullable),
15456 Some(len) => len,
15457 };
15458 if len == 0 {
15460 return Ok(());
15461 };
15462 depth.increment()?;
15463 let envelope_size = 8;
15464 let bytes_len = len * envelope_size;
15465 let offset = decoder.out_of_line_offset(bytes_len)?;
15466 let mut _next_ordinal_to_read = 0;
15468 let mut next_offset = offset;
15469 let end_offset = offset + bytes_len;
15470 _next_ordinal_to_read += 1;
15471 if next_offset >= end_offset {
15472 return Ok(());
15473 }
15474
15475 while _next_ordinal_to_read < 1 {
15477 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15478 _next_ordinal_to_read += 1;
15479 next_offset += envelope_size;
15480 }
15481
15482 let next_out_of_line = decoder.next_out_of_line();
15483 let handles_before = decoder.remaining_handles();
15484 if let Some((inlined, num_bytes, num_handles)) =
15485 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15486 {
15487 let member_inline_size =
15488 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15489 if inlined != (member_inline_size <= 4) {
15490 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15491 }
15492 let inner_offset;
15493 let mut inner_depth = depth.clone();
15494 if inlined {
15495 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15496 inner_offset = next_offset;
15497 } else {
15498 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15499 inner_depth.increment()?;
15500 }
15501 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
15502 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
15503 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15504 {
15505 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15506 }
15507 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15508 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15509 }
15510 }
15511
15512 next_offset += envelope_size;
15513 _next_ordinal_to_read += 1;
15514 if next_offset >= end_offset {
15515 return Ok(());
15516 }
15517
15518 while _next_ordinal_to_read < 2 {
15520 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15521 _next_ordinal_to_read += 1;
15522 next_offset += envelope_size;
15523 }
15524
15525 let next_out_of_line = decoder.next_out_of_line();
15526 let handles_before = decoder.remaining_handles();
15527 if let Some((inlined, num_bytes, num_handles)) =
15528 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15529 {
15530 let member_inline_size =
15531 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
15532 decoder.context,
15533 );
15534 if inlined != (member_inline_size <= 4) {
15535 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15536 }
15537 let inner_offset;
15538 let mut inner_depth = depth.clone();
15539 if inlined {
15540 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15541 inner_offset = next_offset;
15542 } else {
15543 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15544 inner_depth.increment()?;
15545 }
15546 let val_ref = self
15547 .source_name
15548 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
15549 fidl::decode!(
15550 fidl::encoding::BoundedString<100>,
15551 D,
15552 val_ref,
15553 decoder,
15554 inner_offset,
15555 inner_depth
15556 )?;
15557 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15558 {
15559 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15560 }
15561 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15562 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15563 }
15564 }
15565
15566 next_offset += envelope_size;
15567 _next_ordinal_to_read += 1;
15568 if next_offset >= end_offset {
15569 return Ok(());
15570 }
15571
15572 while _next_ordinal_to_read < 3 {
15574 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15575 _next_ordinal_to_read += 1;
15576 next_offset += envelope_size;
15577 }
15578
15579 let next_out_of_line = decoder.next_out_of_line();
15580 let handles_before = decoder.remaining_handles();
15581 if let Some((inlined, num_bytes, num_handles)) =
15582 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15583 {
15584 let member_inline_size =
15585 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15586 if inlined != (member_inline_size <= 4) {
15587 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15588 }
15589 let inner_offset;
15590 let mut inner_depth = depth.clone();
15591 if inlined {
15592 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15593 inner_offset = next_offset;
15594 } else {
15595 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15596 inner_depth.increment()?;
15597 }
15598 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
15599 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
15600 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15601 {
15602 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15603 }
15604 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15605 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15606 }
15607 }
15608
15609 next_offset += envelope_size;
15610 _next_ordinal_to_read += 1;
15611 if next_offset >= end_offset {
15612 return Ok(());
15613 }
15614
15615 while _next_ordinal_to_read < 4 {
15617 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15618 _next_ordinal_to_read += 1;
15619 next_offset += envelope_size;
15620 }
15621
15622 let next_out_of_line = decoder.next_out_of_line();
15623 let handles_before = decoder.remaining_handles();
15624 if let Some((inlined, num_bytes, num_handles)) =
15625 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15626 {
15627 let member_inline_size =
15628 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
15629 decoder.context,
15630 );
15631 if inlined != (member_inline_size <= 4) {
15632 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15633 }
15634 let inner_offset;
15635 let mut inner_depth = depth.clone();
15636 if inlined {
15637 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15638 inner_offset = next_offset;
15639 } else {
15640 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15641 inner_depth.increment()?;
15642 }
15643 let val_ref = self
15644 .target_name
15645 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
15646 fidl::decode!(
15647 fidl::encoding::BoundedString<100>,
15648 D,
15649 val_ref,
15650 decoder,
15651 inner_offset,
15652 inner_depth
15653 )?;
15654 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15655 {
15656 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15657 }
15658 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15659 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15660 }
15661 }
15662
15663 next_offset += envelope_size;
15664 _next_ordinal_to_read += 1;
15665 if next_offset >= end_offset {
15666 return Ok(());
15667 }
15668
15669 while _next_ordinal_to_read < 5 {
15671 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15672 _next_ordinal_to_read += 1;
15673 next_offset += envelope_size;
15674 }
15675
15676 let next_out_of_line = decoder.next_out_of_line();
15677 let handles_before = decoder.remaining_handles();
15678 if let Some((inlined, num_bytes, num_handles)) =
15679 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15680 {
15681 let member_inline_size = <fidl_fuchsia_io__common::Operations as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15682 if inlined != (member_inline_size <= 4) {
15683 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15684 }
15685 let inner_offset;
15686 let mut inner_depth = depth.clone();
15687 if inlined {
15688 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15689 inner_offset = next_offset;
15690 } else {
15691 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15692 inner_depth.increment()?;
15693 }
15694 let val_ref = self.rights.get_or_insert_with(|| {
15695 fidl::new_empty!(fidl_fuchsia_io__common::Operations, D)
15696 });
15697 fidl::decode!(
15698 fidl_fuchsia_io__common::Operations,
15699 D,
15700 val_ref,
15701 decoder,
15702 inner_offset,
15703 inner_depth
15704 )?;
15705 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15706 {
15707 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15708 }
15709 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15710 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15711 }
15712 }
15713
15714 next_offset += envelope_size;
15715 _next_ordinal_to_read += 1;
15716 if next_offset >= end_offset {
15717 return Ok(());
15718 }
15719
15720 while _next_ordinal_to_read < 6 {
15722 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15723 _next_ordinal_to_read += 1;
15724 next_offset += envelope_size;
15725 }
15726
15727 let next_out_of_line = decoder.next_out_of_line();
15728 let handles_before = decoder.remaining_handles();
15729 if let Some((inlined, num_bytes, num_handles)) =
15730 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15731 {
15732 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15733 if inlined != (member_inline_size <= 4) {
15734 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15735 }
15736 let inner_offset;
15737 let mut inner_depth = depth.clone();
15738 if inlined {
15739 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15740 inner_offset = next_offset;
15741 } else {
15742 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15743 inner_depth.increment()?;
15744 }
15745 let val_ref = self.subdir.get_or_insert_with(|| {
15746 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
15747 });
15748 fidl::decode!(
15749 fidl::encoding::BoundedString<1024>,
15750 D,
15751 val_ref,
15752 decoder,
15753 inner_offset,
15754 inner_depth
15755 )?;
15756 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15757 {
15758 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15759 }
15760 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15761 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15762 }
15763 }
15764
15765 next_offset += envelope_size;
15766 _next_ordinal_to_read += 1;
15767 if next_offset >= end_offset {
15768 return Ok(());
15769 }
15770
15771 while _next_ordinal_to_read < 7 {
15773 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15774 _next_ordinal_to_read += 1;
15775 next_offset += envelope_size;
15776 }
15777
15778 let next_out_of_line = decoder.next_out_of_line();
15779 let handles_before = decoder.remaining_handles();
15780 if let Some((inlined, num_bytes, num_handles)) =
15781 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15782 {
15783 let member_inline_size =
15784 <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15785 if inlined != (member_inline_size <= 4) {
15786 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15787 }
15788 let inner_offset;
15789 let mut inner_depth = depth.clone();
15790 if inlined {
15791 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15792 inner_offset = next_offset;
15793 } else {
15794 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15795 inner_depth.increment()?;
15796 }
15797 let val_ref =
15798 self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
15799 fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
15800 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15801 {
15802 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15803 }
15804 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15805 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15806 }
15807 }
15808
15809 next_offset += envelope_size;
15810 _next_ordinal_to_read += 1;
15811 if next_offset >= end_offset {
15812 return Ok(());
15813 }
15814
15815 while _next_ordinal_to_read < 8 {
15817 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15818 _next_ordinal_to_read += 1;
15819 next_offset += envelope_size;
15820 }
15821
15822 let next_out_of_line = decoder.next_out_of_line();
15823 let handles_before = decoder.remaining_handles();
15824 if let Some((inlined, num_bytes, num_handles)) =
15825 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15826 {
15827 let member_inline_size =
15828 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15829 if inlined != (member_inline_size <= 4) {
15830 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15831 }
15832 let inner_offset;
15833 let mut inner_depth = depth.clone();
15834 if inlined {
15835 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15836 inner_offset = next_offset;
15837 } else {
15838 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15839 inner_depth.increment()?;
15840 }
15841 let val_ref =
15842 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
15843 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
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 _next_ordinal_to_read += 1;
15855 if next_offset >= end_offset {
15856 return Ok(());
15857 }
15858
15859 while _next_ordinal_to_read < 9 {
15861 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15862 _next_ordinal_to_read += 1;
15863 next_offset += envelope_size;
15864 }
15865
15866 let next_out_of_line = decoder.next_out_of_line();
15867 let handles_before = decoder.remaining_handles();
15868 if let Some((inlined, num_bytes, num_handles)) =
15869 fidl::encoding::decode_envelope_header(decoder, next_offset)?
15870 {
15871 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15872 if inlined != (member_inline_size <= 4) {
15873 return Err(fidl::Error::InvalidInlineBitInEnvelope);
15874 }
15875 let inner_offset;
15876 let mut inner_depth = depth.clone();
15877 if inlined {
15878 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15879 inner_offset = next_offset;
15880 } else {
15881 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15882 inner_depth.increment()?;
15883 }
15884 let val_ref = self.source_dictionary.get_or_insert_with(|| {
15885 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
15886 });
15887 fidl::decode!(
15888 fidl::encoding::BoundedString<1024>,
15889 D,
15890 val_ref,
15891 decoder,
15892 inner_offset,
15893 inner_depth
15894 )?;
15895 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15896 {
15897 return Err(fidl::Error::InvalidNumBytesInEnvelope);
15898 }
15899 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15900 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15901 }
15902 }
15903
15904 next_offset += envelope_size;
15905
15906 while next_offset < end_offset {
15908 _next_ordinal_to_read += 1;
15909 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15910 next_offset += envelope_size;
15911 }
15912
15913 Ok(())
15914 }
15915 }
15916
15917 impl OfferEventStream {
15918 #[inline(always)]
15919 fn max_ordinal_present(&self) -> u64 {
15920 if let Some(_) = self.availability {
15921 return 7;
15922 }
15923 if let Some(_) = self.target_name {
15924 return 5;
15925 }
15926 if let Some(_) = self.target {
15927 return 4;
15928 }
15929 if let Some(_) = self.scope {
15930 return 3;
15931 }
15932 if let Some(_) = self.source_name {
15933 return 2;
15934 }
15935 if let Some(_) = self.source {
15936 return 1;
15937 }
15938 0
15939 }
15940 }
15941
15942 impl fidl::encoding::ValueTypeMarker for OfferEventStream {
15943 type Borrowed<'a> = &'a Self;
15944 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15945 value
15946 }
15947 }
15948
15949 unsafe impl fidl::encoding::TypeMarker for OfferEventStream {
15950 type Owned = Self;
15951
15952 #[inline(always)]
15953 fn inline_align(_context: fidl::encoding::Context) -> usize {
15954 8
15955 }
15956
15957 #[inline(always)]
15958 fn inline_size(_context: fidl::encoding::Context) -> usize {
15959 16
15960 }
15961 }
15962
15963 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferEventStream, D>
15964 for &OfferEventStream
15965 {
15966 unsafe fn encode(
15967 self,
15968 encoder: &mut fidl::encoding::Encoder<'_, D>,
15969 offset: usize,
15970 mut depth: fidl::encoding::Depth,
15971 ) -> fidl::Result<()> {
15972 encoder.debug_check_bounds::<OfferEventStream>(offset);
15973 let max_ordinal: u64 = self.max_ordinal_present();
15975 encoder.write_num(max_ordinal, offset);
15976 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15977 if max_ordinal == 0 {
15979 return Ok(());
15980 }
15981 depth.increment()?;
15982 let envelope_size = 8;
15983 let bytes_len = max_ordinal as usize * envelope_size;
15984 #[allow(unused_variables)]
15985 let offset = encoder.out_of_line_offset(bytes_len);
15986 let mut _prev_end_offset: usize = 0;
15987 if 1 > max_ordinal {
15988 return Ok(());
15989 }
15990
15991 let cur_offset: usize = (1 - 1) * envelope_size;
15994
15995 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15997
15998 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
16003 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
16004 encoder,
16005 offset + cur_offset,
16006 depth,
16007 )?;
16008
16009 _prev_end_offset = cur_offset + envelope_size;
16010 if 2 > max_ordinal {
16011 return Ok(());
16012 }
16013
16014 let cur_offset: usize = (2 - 1) * envelope_size;
16017
16018 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16020
16021 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
16026 self.source_name.as_ref().map(
16027 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
16028 ),
16029 encoder,
16030 offset + cur_offset,
16031 depth,
16032 )?;
16033
16034 _prev_end_offset = cur_offset + envelope_size;
16035 if 3 > max_ordinal {
16036 return Ok(());
16037 }
16038
16039 let cur_offset: usize = (3 - 1) * envelope_size;
16042
16043 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16045
16046 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Ref>, D>(
16051 self.scope.as_ref().map(<fidl::encoding::UnboundedVector<Ref> as fidl::encoding::ValueTypeMarker>::borrow),
16052 encoder, offset + cur_offset, depth
16053 )?;
16054
16055 _prev_end_offset = cur_offset + envelope_size;
16056 if 4 > max_ordinal {
16057 return Ok(());
16058 }
16059
16060 let cur_offset: usize = (4 - 1) * envelope_size;
16063
16064 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16066
16067 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
16072 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
16073 encoder,
16074 offset + cur_offset,
16075 depth,
16076 )?;
16077
16078 _prev_end_offset = cur_offset + envelope_size;
16079 if 5 > max_ordinal {
16080 return Ok(());
16081 }
16082
16083 let cur_offset: usize = (5 - 1) * envelope_size;
16086
16087 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16089
16090 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
16095 self.target_name.as_ref().map(
16096 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
16097 ),
16098 encoder,
16099 offset + cur_offset,
16100 depth,
16101 )?;
16102
16103 _prev_end_offset = cur_offset + envelope_size;
16104 if 7 > max_ordinal {
16105 return Ok(());
16106 }
16107
16108 let cur_offset: usize = (7 - 1) * envelope_size;
16111
16112 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16114
16115 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
16120 self.availability
16121 .as_ref()
16122 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
16123 encoder,
16124 offset + cur_offset,
16125 depth,
16126 )?;
16127
16128 _prev_end_offset = cur_offset + envelope_size;
16129
16130 Ok(())
16131 }
16132 }
16133
16134 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferEventStream {
16135 #[inline(always)]
16136 fn new_empty() -> Self {
16137 Self::default()
16138 }
16139
16140 unsafe fn decode(
16141 &mut self,
16142 decoder: &mut fidl::encoding::Decoder<'_, D>,
16143 offset: usize,
16144 mut depth: fidl::encoding::Depth,
16145 ) -> fidl::Result<()> {
16146 decoder.debug_check_bounds::<Self>(offset);
16147 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
16148 None => return Err(fidl::Error::NotNullable),
16149 Some(len) => len,
16150 };
16151 if len == 0 {
16153 return Ok(());
16154 };
16155 depth.increment()?;
16156 let envelope_size = 8;
16157 let bytes_len = len * envelope_size;
16158 let offset = decoder.out_of_line_offset(bytes_len)?;
16159 let mut _next_ordinal_to_read = 0;
16161 let mut next_offset = offset;
16162 let end_offset = offset + bytes_len;
16163 _next_ordinal_to_read += 1;
16164 if next_offset >= end_offset {
16165 return Ok(());
16166 }
16167
16168 while _next_ordinal_to_read < 1 {
16170 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16171 _next_ordinal_to_read += 1;
16172 next_offset += envelope_size;
16173 }
16174
16175 let next_out_of_line = decoder.next_out_of_line();
16176 let handles_before = decoder.remaining_handles();
16177 if let Some((inlined, num_bytes, num_handles)) =
16178 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16179 {
16180 let member_inline_size =
16181 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16182 if inlined != (member_inline_size <= 4) {
16183 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16184 }
16185 let inner_offset;
16186 let mut inner_depth = depth.clone();
16187 if inlined {
16188 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16189 inner_offset = next_offset;
16190 } else {
16191 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16192 inner_depth.increment()?;
16193 }
16194 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
16195 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
16196 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16197 {
16198 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16199 }
16200 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16201 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16202 }
16203 }
16204
16205 next_offset += envelope_size;
16206 _next_ordinal_to_read += 1;
16207 if next_offset >= end_offset {
16208 return Ok(());
16209 }
16210
16211 while _next_ordinal_to_read < 2 {
16213 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16214 _next_ordinal_to_read += 1;
16215 next_offset += envelope_size;
16216 }
16217
16218 let next_out_of_line = decoder.next_out_of_line();
16219 let handles_before = decoder.remaining_handles();
16220 if let Some((inlined, num_bytes, num_handles)) =
16221 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16222 {
16223 let member_inline_size =
16224 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
16225 decoder.context,
16226 );
16227 if inlined != (member_inline_size <= 4) {
16228 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16229 }
16230 let inner_offset;
16231 let mut inner_depth = depth.clone();
16232 if inlined {
16233 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16234 inner_offset = next_offset;
16235 } else {
16236 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16237 inner_depth.increment()?;
16238 }
16239 let val_ref = self
16240 .source_name
16241 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
16242 fidl::decode!(
16243 fidl::encoding::BoundedString<100>,
16244 D,
16245 val_ref,
16246 decoder,
16247 inner_offset,
16248 inner_depth
16249 )?;
16250 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16251 {
16252 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16253 }
16254 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16255 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16256 }
16257 }
16258
16259 next_offset += envelope_size;
16260 _next_ordinal_to_read += 1;
16261 if next_offset >= end_offset {
16262 return Ok(());
16263 }
16264
16265 while _next_ordinal_to_read < 3 {
16267 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16268 _next_ordinal_to_read += 1;
16269 next_offset += envelope_size;
16270 }
16271
16272 let next_out_of_line = decoder.next_out_of_line();
16273 let handles_before = decoder.remaining_handles();
16274 if let Some((inlined, num_bytes, num_handles)) =
16275 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16276 {
16277 let member_inline_size = <fidl::encoding::UnboundedVector<Ref> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16278 if inlined != (member_inline_size <= 4) {
16279 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16280 }
16281 let inner_offset;
16282 let mut inner_depth = depth.clone();
16283 if inlined {
16284 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16285 inner_offset = next_offset;
16286 } else {
16287 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16288 inner_depth.increment()?;
16289 }
16290 let val_ref = self.scope.get_or_insert_with(|| {
16291 fidl::new_empty!(fidl::encoding::UnboundedVector<Ref>, D)
16292 });
16293 fidl::decode!(
16294 fidl::encoding::UnboundedVector<Ref>,
16295 D,
16296 val_ref,
16297 decoder,
16298 inner_offset,
16299 inner_depth
16300 )?;
16301 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16302 {
16303 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16304 }
16305 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16306 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16307 }
16308 }
16309
16310 next_offset += envelope_size;
16311 _next_ordinal_to_read += 1;
16312 if next_offset >= end_offset {
16313 return Ok(());
16314 }
16315
16316 while _next_ordinal_to_read < 4 {
16318 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16319 _next_ordinal_to_read += 1;
16320 next_offset += envelope_size;
16321 }
16322
16323 let next_out_of_line = decoder.next_out_of_line();
16324 let handles_before = decoder.remaining_handles();
16325 if let Some((inlined, num_bytes, num_handles)) =
16326 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16327 {
16328 let member_inline_size =
16329 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16330 if inlined != (member_inline_size <= 4) {
16331 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16332 }
16333 let inner_offset;
16334 let mut inner_depth = depth.clone();
16335 if inlined {
16336 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16337 inner_offset = next_offset;
16338 } else {
16339 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16340 inner_depth.increment()?;
16341 }
16342 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
16343 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
16344 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16345 {
16346 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16347 }
16348 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16349 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16350 }
16351 }
16352
16353 next_offset += envelope_size;
16354 _next_ordinal_to_read += 1;
16355 if next_offset >= end_offset {
16356 return Ok(());
16357 }
16358
16359 while _next_ordinal_to_read < 5 {
16361 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16362 _next_ordinal_to_read += 1;
16363 next_offset += envelope_size;
16364 }
16365
16366 let next_out_of_line = decoder.next_out_of_line();
16367 let handles_before = decoder.remaining_handles();
16368 if let Some((inlined, num_bytes, num_handles)) =
16369 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16370 {
16371 let member_inline_size =
16372 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
16373 decoder.context,
16374 );
16375 if inlined != (member_inline_size <= 4) {
16376 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16377 }
16378 let inner_offset;
16379 let mut inner_depth = depth.clone();
16380 if inlined {
16381 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16382 inner_offset = next_offset;
16383 } else {
16384 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16385 inner_depth.increment()?;
16386 }
16387 let val_ref = self
16388 .target_name
16389 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
16390 fidl::decode!(
16391 fidl::encoding::BoundedString<100>,
16392 D,
16393 val_ref,
16394 decoder,
16395 inner_offset,
16396 inner_depth
16397 )?;
16398 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16399 {
16400 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16401 }
16402 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16403 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16404 }
16405 }
16406
16407 next_offset += envelope_size;
16408 _next_ordinal_to_read += 1;
16409 if next_offset >= end_offset {
16410 return Ok(());
16411 }
16412
16413 while _next_ordinal_to_read < 7 {
16415 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16416 _next_ordinal_to_read += 1;
16417 next_offset += envelope_size;
16418 }
16419
16420 let next_out_of_line = decoder.next_out_of_line();
16421 let handles_before = decoder.remaining_handles();
16422 if let Some((inlined, num_bytes, num_handles)) =
16423 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16424 {
16425 let member_inline_size =
16426 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16427 if inlined != (member_inline_size <= 4) {
16428 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16429 }
16430 let inner_offset;
16431 let mut inner_depth = depth.clone();
16432 if inlined {
16433 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16434 inner_offset = next_offset;
16435 } else {
16436 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16437 inner_depth.increment()?;
16438 }
16439 let val_ref =
16440 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
16441 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
16442 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16443 {
16444 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16445 }
16446 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16447 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16448 }
16449 }
16450
16451 next_offset += envelope_size;
16452
16453 while next_offset < end_offset {
16455 _next_ordinal_to_read += 1;
16456 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16457 next_offset += envelope_size;
16458 }
16459
16460 Ok(())
16461 }
16462 }
16463
16464 impl OfferProtocol {
16465 #[inline(always)]
16466 fn max_ordinal_present(&self) -> u64 {
16467 if let Some(_) = self.source_dictionary {
16468 return 7;
16469 }
16470 if let Some(_) = self.availability {
16471 return 6;
16472 }
16473 if let Some(_) = self.dependency_type {
16474 return 5;
16475 }
16476 if let Some(_) = self.target_name {
16477 return 4;
16478 }
16479 if let Some(_) = self.target {
16480 return 3;
16481 }
16482 if let Some(_) = self.source_name {
16483 return 2;
16484 }
16485 if let Some(_) = self.source {
16486 return 1;
16487 }
16488 0
16489 }
16490 }
16491
16492 impl fidl::encoding::ValueTypeMarker for OfferProtocol {
16493 type Borrowed<'a> = &'a Self;
16494 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16495 value
16496 }
16497 }
16498
16499 unsafe impl fidl::encoding::TypeMarker for OfferProtocol {
16500 type Owned = Self;
16501
16502 #[inline(always)]
16503 fn inline_align(_context: fidl::encoding::Context) -> usize {
16504 8
16505 }
16506
16507 #[inline(always)]
16508 fn inline_size(_context: fidl::encoding::Context) -> usize {
16509 16
16510 }
16511 }
16512
16513 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferProtocol, D>
16514 for &OfferProtocol
16515 {
16516 unsafe fn encode(
16517 self,
16518 encoder: &mut fidl::encoding::Encoder<'_, D>,
16519 offset: usize,
16520 mut depth: fidl::encoding::Depth,
16521 ) -> fidl::Result<()> {
16522 encoder.debug_check_bounds::<OfferProtocol>(offset);
16523 let max_ordinal: u64 = self.max_ordinal_present();
16525 encoder.write_num(max_ordinal, offset);
16526 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
16527 if max_ordinal == 0 {
16529 return Ok(());
16530 }
16531 depth.increment()?;
16532 let envelope_size = 8;
16533 let bytes_len = max_ordinal as usize * envelope_size;
16534 #[allow(unused_variables)]
16535 let offset = encoder.out_of_line_offset(bytes_len);
16536 let mut _prev_end_offset: usize = 0;
16537 if 1 > max_ordinal {
16538 return Ok(());
16539 }
16540
16541 let cur_offset: usize = (1 - 1) * envelope_size;
16544
16545 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16547
16548 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
16553 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
16554 encoder,
16555 offset + cur_offset,
16556 depth,
16557 )?;
16558
16559 _prev_end_offset = cur_offset + envelope_size;
16560 if 2 > max_ordinal {
16561 return Ok(());
16562 }
16563
16564 let cur_offset: usize = (2 - 1) * envelope_size;
16567
16568 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16570
16571 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
16576 self.source_name.as_ref().map(
16577 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
16578 ),
16579 encoder,
16580 offset + cur_offset,
16581 depth,
16582 )?;
16583
16584 _prev_end_offset = cur_offset + envelope_size;
16585 if 3 > max_ordinal {
16586 return Ok(());
16587 }
16588
16589 let cur_offset: usize = (3 - 1) * envelope_size;
16592
16593 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16595
16596 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
16601 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
16602 encoder,
16603 offset + cur_offset,
16604 depth,
16605 )?;
16606
16607 _prev_end_offset = cur_offset + envelope_size;
16608 if 4 > max_ordinal {
16609 return Ok(());
16610 }
16611
16612 let cur_offset: usize = (4 - 1) * envelope_size;
16615
16616 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16618
16619 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
16624 self.target_name.as_ref().map(
16625 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
16626 ),
16627 encoder,
16628 offset + cur_offset,
16629 depth,
16630 )?;
16631
16632 _prev_end_offset = cur_offset + envelope_size;
16633 if 5 > max_ordinal {
16634 return Ok(());
16635 }
16636
16637 let cur_offset: usize = (5 - 1) * envelope_size;
16640
16641 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16643
16644 fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
16649 self.dependency_type
16650 .as_ref()
16651 .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
16652 encoder,
16653 offset + cur_offset,
16654 depth,
16655 )?;
16656
16657 _prev_end_offset = cur_offset + envelope_size;
16658 if 6 > max_ordinal {
16659 return Ok(());
16660 }
16661
16662 let cur_offset: usize = (6 - 1) * envelope_size;
16665
16666 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16668
16669 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
16674 self.availability
16675 .as_ref()
16676 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
16677 encoder,
16678 offset + cur_offset,
16679 depth,
16680 )?;
16681
16682 _prev_end_offset = cur_offset + envelope_size;
16683 if 7 > max_ordinal {
16684 return Ok(());
16685 }
16686
16687 let cur_offset: usize = (7 - 1) * envelope_size;
16690
16691 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16693
16694 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
16699 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
16700 encoder, offset + cur_offset, depth
16701 )?;
16702
16703 _prev_end_offset = cur_offset + envelope_size;
16704
16705 Ok(())
16706 }
16707 }
16708
16709 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferProtocol {
16710 #[inline(always)]
16711 fn new_empty() -> Self {
16712 Self::default()
16713 }
16714
16715 unsafe fn decode(
16716 &mut self,
16717 decoder: &mut fidl::encoding::Decoder<'_, D>,
16718 offset: usize,
16719 mut depth: fidl::encoding::Depth,
16720 ) -> fidl::Result<()> {
16721 decoder.debug_check_bounds::<Self>(offset);
16722 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
16723 None => return Err(fidl::Error::NotNullable),
16724 Some(len) => len,
16725 };
16726 if len == 0 {
16728 return Ok(());
16729 };
16730 depth.increment()?;
16731 let envelope_size = 8;
16732 let bytes_len = len * envelope_size;
16733 let offset = decoder.out_of_line_offset(bytes_len)?;
16734 let mut _next_ordinal_to_read = 0;
16736 let mut next_offset = offset;
16737 let end_offset = offset + bytes_len;
16738 _next_ordinal_to_read += 1;
16739 if next_offset >= end_offset {
16740 return Ok(());
16741 }
16742
16743 while _next_ordinal_to_read < 1 {
16745 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16746 _next_ordinal_to_read += 1;
16747 next_offset += envelope_size;
16748 }
16749
16750 let next_out_of_line = decoder.next_out_of_line();
16751 let handles_before = decoder.remaining_handles();
16752 if let Some((inlined, num_bytes, num_handles)) =
16753 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16754 {
16755 let member_inline_size =
16756 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16757 if inlined != (member_inline_size <= 4) {
16758 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16759 }
16760 let inner_offset;
16761 let mut inner_depth = depth.clone();
16762 if inlined {
16763 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16764 inner_offset = next_offset;
16765 } else {
16766 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16767 inner_depth.increment()?;
16768 }
16769 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
16770 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
16771 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16772 {
16773 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16774 }
16775 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16776 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16777 }
16778 }
16779
16780 next_offset += envelope_size;
16781 _next_ordinal_to_read += 1;
16782 if next_offset >= end_offset {
16783 return Ok(());
16784 }
16785
16786 while _next_ordinal_to_read < 2 {
16788 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16789 _next_ordinal_to_read += 1;
16790 next_offset += envelope_size;
16791 }
16792
16793 let next_out_of_line = decoder.next_out_of_line();
16794 let handles_before = decoder.remaining_handles();
16795 if let Some((inlined, num_bytes, num_handles)) =
16796 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16797 {
16798 let member_inline_size =
16799 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
16800 decoder.context,
16801 );
16802 if inlined != (member_inline_size <= 4) {
16803 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16804 }
16805 let inner_offset;
16806 let mut inner_depth = depth.clone();
16807 if inlined {
16808 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16809 inner_offset = next_offset;
16810 } else {
16811 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16812 inner_depth.increment()?;
16813 }
16814 let val_ref = self
16815 .source_name
16816 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
16817 fidl::decode!(
16818 fidl::encoding::BoundedString<100>,
16819 D,
16820 val_ref,
16821 decoder,
16822 inner_offset,
16823 inner_depth
16824 )?;
16825 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16826 {
16827 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16828 }
16829 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16830 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16831 }
16832 }
16833
16834 next_offset += envelope_size;
16835 _next_ordinal_to_read += 1;
16836 if next_offset >= end_offset {
16837 return Ok(());
16838 }
16839
16840 while _next_ordinal_to_read < 3 {
16842 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16843 _next_ordinal_to_read += 1;
16844 next_offset += envelope_size;
16845 }
16846
16847 let next_out_of_line = decoder.next_out_of_line();
16848 let handles_before = decoder.remaining_handles();
16849 if let Some((inlined, num_bytes, num_handles)) =
16850 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16851 {
16852 let member_inline_size =
16853 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16854 if inlined != (member_inline_size <= 4) {
16855 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16856 }
16857 let inner_offset;
16858 let mut inner_depth = depth.clone();
16859 if inlined {
16860 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16861 inner_offset = next_offset;
16862 } else {
16863 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16864 inner_depth.increment()?;
16865 }
16866 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
16867 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
16868 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16869 {
16870 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16871 }
16872 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16873 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16874 }
16875 }
16876
16877 next_offset += envelope_size;
16878 _next_ordinal_to_read += 1;
16879 if next_offset >= end_offset {
16880 return Ok(());
16881 }
16882
16883 while _next_ordinal_to_read < 4 {
16885 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16886 _next_ordinal_to_read += 1;
16887 next_offset += envelope_size;
16888 }
16889
16890 let next_out_of_line = decoder.next_out_of_line();
16891 let handles_before = decoder.remaining_handles();
16892 if let Some((inlined, num_bytes, num_handles)) =
16893 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16894 {
16895 let member_inline_size =
16896 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
16897 decoder.context,
16898 );
16899 if inlined != (member_inline_size <= 4) {
16900 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16901 }
16902 let inner_offset;
16903 let mut inner_depth = depth.clone();
16904 if inlined {
16905 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16906 inner_offset = next_offset;
16907 } else {
16908 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16909 inner_depth.increment()?;
16910 }
16911 let val_ref = self
16912 .target_name
16913 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
16914 fidl::decode!(
16915 fidl::encoding::BoundedString<100>,
16916 D,
16917 val_ref,
16918 decoder,
16919 inner_offset,
16920 inner_depth
16921 )?;
16922 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16923 {
16924 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16925 }
16926 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16927 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16928 }
16929 }
16930
16931 next_offset += envelope_size;
16932 _next_ordinal_to_read += 1;
16933 if next_offset >= end_offset {
16934 return Ok(());
16935 }
16936
16937 while _next_ordinal_to_read < 5 {
16939 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16940 _next_ordinal_to_read += 1;
16941 next_offset += envelope_size;
16942 }
16943
16944 let next_out_of_line = decoder.next_out_of_line();
16945 let handles_before = decoder.remaining_handles();
16946 if let Some((inlined, num_bytes, num_handles)) =
16947 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16948 {
16949 let member_inline_size =
16950 <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16951 if inlined != (member_inline_size <= 4) {
16952 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16953 }
16954 let inner_offset;
16955 let mut inner_depth = depth.clone();
16956 if inlined {
16957 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16958 inner_offset = next_offset;
16959 } else {
16960 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16961 inner_depth.increment()?;
16962 }
16963 let val_ref =
16964 self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
16965 fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
16966 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16967 {
16968 return Err(fidl::Error::InvalidNumBytesInEnvelope);
16969 }
16970 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16971 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16972 }
16973 }
16974
16975 next_offset += envelope_size;
16976 _next_ordinal_to_read += 1;
16977 if next_offset >= end_offset {
16978 return Ok(());
16979 }
16980
16981 while _next_ordinal_to_read < 6 {
16983 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16984 _next_ordinal_to_read += 1;
16985 next_offset += envelope_size;
16986 }
16987
16988 let next_out_of_line = decoder.next_out_of_line();
16989 let handles_before = decoder.remaining_handles();
16990 if let Some((inlined, num_bytes, num_handles)) =
16991 fidl::encoding::decode_envelope_header(decoder, next_offset)?
16992 {
16993 let member_inline_size =
16994 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16995 if inlined != (member_inline_size <= 4) {
16996 return Err(fidl::Error::InvalidInlineBitInEnvelope);
16997 }
16998 let inner_offset;
16999 let mut inner_depth = depth.clone();
17000 if inlined {
17001 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17002 inner_offset = next_offset;
17003 } else {
17004 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17005 inner_depth.increment()?;
17006 }
17007 let val_ref =
17008 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
17009 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
17010 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17011 {
17012 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17013 }
17014 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17015 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17016 }
17017 }
17018
17019 next_offset += envelope_size;
17020 _next_ordinal_to_read += 1;
17021 if next_offset >= end_offset {
17022 return Ok(());
17023 }
17024
17025 while _next_ordinal_to_read < 7 {
17027 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17028 _next_ordinal_to_read += 1;
17029 next_offset += envelope_size;
17030 }
17031
17032 let next_out_of_line = decoder.next_out_of_line();
17033 let handles_before = decoder.remaining_handles();
17034 if let Some((inlined, num_bytes, num_handles)) =
17035 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17036 {
17037 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17038 if inlined != (member_inline_size <= 4) {
17039 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17040 }
17041 let inner_offset;
17042 let mut inner_depth = depth.clone();
17043 if inlined {
17044 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17045 inner_offset = next_offset;
17046 } else {
17047 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17048 inner_depth.increment()?;
17049 }
17050 let val_ref = self.source_dictionary.get_or_insert_with(|| {
17051 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
17052 });
17053 fidl::decode!(
17054 fidl::encoding::BoundedString<1024>,
17055 D,
17056 val_ref,
17057 decoder,
17058 inner_offset,
17059 inner_depth
17060 )?;
17061 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17062 {
17063 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17064 }
17065 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17066 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17067 }
17068 }
17069
17070 next_offset += envelope_size;
17071
17072 while next_offset < end_offset {
17074 _next_ordinal_to_read += 1;
17075 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17076 next_offset += envelope_size;
17077 }
17078
17079 Ok(())
17080 }
17081 }
17082
17083 impl OfferResolver {
17084 #[inline(always)]
17085 fn max_ordinal_present(&self) -> u64 {
17086 if let Some(_) = self.source_dictionary {
17087 return 5;
17088 }
17089 if let Some(_) = self.target_name {
17090 return 4;
17091 }
17092 if let Some(_) = self.target {
17093 return 3;
17094 }
17095 if let Some(_) = self.source_name {
17096 return 2;
17097 }
17098 if let Some(_) = self.source {
17099 return 1;
17100 }
17101 0
17102 }
17103 }
17104
17105 impl fidl::encoding::ValueTypeMarker for OfferResolver {
17106 type Borrowed<'a> = &'a Self;
17107 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
17108 value
17109 }
17110 }
17111
17112 unsafe impl fidl::encoding::TypeMarker for OfferResolver {
17113 type Owned = Self;
17114
17115 #[inline(always)]
17116 fn inline_align(_context: fidl::encoding::Context) -> usize {
17117 8
17118 }
17119
17120 #[inline(always)]
17121 fn inline_size(_context: fidl::encoding::Context) -> usize {
17122 16
17123 }
17124 }
17125
17126 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferResolver, D>
17127 for &OfferResolver
17128 {
17129 unsafe fn encode(
17130 self,
17131 encoder: &mut fidl::encoding::Encoder<'_, D>,
17132 offset: usize,
17133 mut depth: fidl::encoding::Depth,
17134 ) -> fidl::Result<()> {
17135 encoder.debug_check_bounds::<OfferResolver>(offset);
17136 let max_ordinal: u64 = self.max_ordinal_present();
17138 encoder.write_num(max_ordinal, offset);
17139 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
17140 if max_ordinal == 0 {
17142 return Ok(());
17143 }
17144 depth.increment()?;
17145 let envelope_size = 8;
17146 let bytes_len = max_ordinal as usize * envelope_size;
17147 #[allow(unused_variables)]
17148 let offset = encoder.out_of_line_offset(bytes_len);
17149 let mut _prev_end_offset: usize = 0;
17150 if 1 > max_ordinal {
17151 return Ok(());
17152 }
17153
17154 let cur_offset: usize = (1 - 1) * envelope_size;
17157
17158 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17160
17161 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
17166 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
17167 encoder,
17168 offset + cur_offset,
17169 depth,
17170 )?;
17171
17172 _prev_end_offset = cur_offset + envelope_size;
17173 if 2 > max_ordinal {
17174 return Ok(());
17175 }
17176
17177 let cur_offset: usize = (2 - 1) * envelope_size;
17180
17181 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17183
17184 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
17189 self.source_name.as_ref().map(
17190 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
17191 ),
17192 encoder,
17193 offset + cur_offset,
17194 depth,
17195 )?;
17196
17197 _prev_end_offset = cur_offset + envelope_size;
17198 if 3 > max_ordinal {
17199 return Ok(());
17200 }
17201
17202 let cur_offset: usize = (3 - 1) * envelope_size;
17205
17206 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17208
17209 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
17214 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
17215 encoder,
17216 offset + cur_offset,
17217 depth,
17218 )?;
17219
17220 _prev_end_offset = cur_offset + envelope_size;
17221 if 4 > max_ordinal {
17222 return Ok(());
17223 }
17224
17225 let cur_offset: usize = (4 - 1) * envelope_size;
17228
17229 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17231
17232 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
17237 self.target_name.as_ref().map(
17238 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
17239 ),
17240 encoder,
17241 offset + cur_offset,
17242 depth,
17243 )?;
17244
17245 _prev_end_offset = cur_offset + envelope_size;
17246 if 5 > max_ordinal {
17247 return Ok(());
17248 }
17249
17250 let cur_offset: usize = (5 - 1) * envelope_size;
17253
17254 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17256
17257 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
17262 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
17263 encoder, offset + cur_offset, depth
17264 )?;
17265
17266 _prev_end_offset = cur_offset + envelope_size;
17267
17268 Ok(())
17269 }
17270 }
17271
17272 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferResolver {
17273 #[inline(always)]
17274 fn new_empty() -> Self {
17275 Self::default()
17276 }
17277
17278 unsafe fn decode(
17279 &mut self,
17280 decoder: &mut fidl::encoding::Decoder<'_, D>,
17281 offset: usize,
17282 mut depth: fidl::encoding::Depth,
17283 ) -> fidl::Result<()> {
17284 decoder.debug_check_bounds::<Self>(offset);
17285 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
17286 None => return Err(fidl::Error::NotNullable),
17287 Some(len) => len,
17288 };
17289 if len == 0 {
17291 return Ok(());
17292 };
17293 depth.increment()?;
17294 let envelope_size = 8;
17295 let bytes_len = len * envelope_size;
17296 let offset = decoder.out_of_line_offset(bytes_len)?;
17297 let mut _next_ordinal_to_read = 0;
17299 let mut next_offset = offset;
17300 let end_offset = offset + bytes_len;
17301 _next_ordinal_to_read += 1;
17302 if next_offset >= end_offset {
17303 return Ok(());
17304 }
17305
17306 while _next_ordinal_to_read < 1 {
17308 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17309 _next_ordinal_to_read += 1;
17310 next_offset += envelope_size;
17311 }
17312
17313 let next_out_of_line = decoder.next_out_of_line();
17314 let handles_before = decoder.remaining_handles();
17315 if let Some((inlined, num_bytes, num_handles)) =
17316 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17317 {
17318 let member_inline_size =
17319 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17320 if inlined != (member_inline_size <= 4) {
17321 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17322 }
17323 let inner_offset;
17324 let mut inner_depth = depth.clone();
17325 if inlined {
17326 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17327 inner_offset = next_offset;
17328 } else {
17329 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17330 inner_depth.increment()?;
17331 }
17332 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
17333 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
17334 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17335 {
17336 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17337 }
17338 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17339 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17340 }
17341 }
17342
17343 next_offset += envelope_size;
17344 _next_ordinal_to_read += 1;
17345 if next_offset >= end_offset {
17346 return Ok(());
17347 }
17348
17349 while _next_ordinal_to_read < 2 {
17351 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17352 _next_ordinal_to_read += 1;
17353 next_offset += envelope_size;
17354 }
17355
17356 let next_out_of_line = decoder.next_out_of_line();
17357 let handles_before = decoder.remaining_handles();
17358 if let Some((inlined, num_bytes, num_handles)) =
17359 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17360 {
17361 let member_inline_size =
17362 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
17363 decoder.context,
17364 );
17365 if inlined != (member_inline_size <= 4) {
17366 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17367 }
17368 let inner_offset;
17369 let mut inner_depth = depth.clone();
17370 if inlined {
17371 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17372 inner_offset = next_offset;
17373 } else {
17374 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17375 inner_depth.increment()?;
17376 }
17377 let val_ref = self
17378 .source_name
17379 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
17380 fidl::decode!(
17381 fidl::encoding::BoundedString<100>,
17382 D,
17383 val_ref,
17384 decoder,
17385 inner_offset,
17386 inner_depth
17387 )?;
17388 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17389 {
17390 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17391 }
17392 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17393 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17394 }
17395 }
17396
17397 next_offset += envelope_size;
17398 _next_ordinal_to_read += 1;
17399 if next_offset >= end_offset {
17400 return Ok(());
17401 }
17402
17403 while _next_ordinal_to_read < 3 {
17405 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17406 _next_ordinal_to_read += 1;
17407 next_offset += envelope_size;
17408 }
17409
17410 let next_out_of_line = decoder.next_out_of_line();
17411 let handles_before = decoder.remaining_handles();
17412 if let Some((inlined, num_bytes, num_handles)) =
17413 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17414 {
17415 let member_inline_size =
17416 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17417 if inlined != (member_inline_size <= 4) {
17418 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17419 }
17420 let inner_offset;
17421 let mut inner_depth = depth.clone();
17422 if inlined {
17423 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17424 inner_offset = next_offset;
17425 } else {
17426 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17427 inner_depth.increment()?;
17428 }
17429 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
17430 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
17431 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17432 {
17433 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17434 }
17435 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17436 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17437 }
17438 }
17439
17440 next_offset += envelope_size;
17441 _next_ordinal_to_read += 1;
17442 if next_offset >= end_offset {
17443 return Ok(());
17444 }
17445
17446 while _next_ordinal_to_read < 4 {
17448 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17449 _next_ordinal_to_read += 1;
17450 next_offset += envelope_size;
17451 }
17452
17453 let next_out_of_line = decoder.next_out_of_line();
17454 let handles_before = decoder.remaining_handles();
17455 if let Some((inlined, num_bytes, num_handles)) =
17456 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17457 {
17458 let member_inline_size =
17459 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
17460 decoder.context,
17461 );
17462 if inlined != (member_inline_size <= 4) {
17463 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17464 }
17465 let inner_offset;
17466 let mut inner_depth = depth.clone();
17467 if inlined {
17468 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17469 inner_offset = next_offset;
17470 } else {
17471 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17472 inner_depth.increment()?;
17473 }
17474 let val_ref = self
17475 .target_name
17476 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
17477 fidl::decode!(
17478 fidl::encoding::BoundedString<100>,
17479 D,
17480 val_ref,
17481 decoder,
17482 inner_offset,
17483 inner_depth
17484 )?;
17485 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17486 {
17487 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17488 }
17489 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17490 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17491 }
17492 }
17493
17494 next_offset += envelope_size;
17495 _next_ordinal_to_read += 1;
17496 if next_offset >= end_offset {
17497 return Ok(());
17498 }
17499
17500 while _next_ordinal_to_read < 5 {
17502 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17503 _next_ordinal_to_read += 1;
17504 next_offset += envelope_size;
17505 }
17506
17507 let next_out_of_line = decoder.next_out_of_line();
17508 let handles_before = decoder.remaining_handles();
17509 if let Some((inlined, num_bytes, num_handles)) =
17510 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17511 {
17512 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17513 if inlined != (member_inline_size <= 4) {
17514 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17515 }
17516 let inner_offset;
17517 let mut inner_depth = depth.clone();
17518 if inlined {
17519 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17520 inner_offset = next_offset;
17521 } else {
17522 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17523 inner_depth.increment()?;
17524 }
17525 let val_ref = self.source_dictionary.get_or_insert_with(|| {
17526 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
17527 });
17528 fidl::decode!(
17529 fidl::encoding::BoundedString<1024>,
17530 D,
17531 val_ref,
17532 decoder,
17533 inner_offset,
17534 inner_depth
17535 )?;
17536 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17537 {
17538 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17539 }
17540 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17541 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17542 }
17543 }
17544
17545 next_offset += envelope_size;
17546
17547 while next_offset < end_offset {
17549 _next_ordinal_to_read += 1;
17550 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17551 next_offset += envelope_size;
17552 }
17553
17554 Ok(())
17555 }
17556 }
17557
17558 impl OfferRunner {
17559 #[inline(always)]
17560 fn max_ordinal_present(&self) -> u64 {
17561 if let Some(_) = self.source_dictionary {
17562 return 5;
17563 }
17564 if let Some(_) = self.target_name {
17565 return 4;
17566 }
17567 if let Some(_) = self.target {
17568 return 3;
17569 }
17570 if let Some(_) = self.source_name {
17571 return 2;
17572 }
17573 if let Some(_) = self.source {
17574 return 1;
17575 }
17576 0
17577 }
17578 }
17579
17580 impl fidl::encoding::ValueTypeMarker for OfferRunner {
17581 type Borrowed<'a> = &'a Self;
17582 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
17583 value
17584 }
17585 }
17586
17587 unsafe impl fidl::encoding::TypeMarker for OfferRunner {
17588 type Owned = Self;
17589
17590 #[inline(always)]
17591 fn inline_align(_context: fidl::encoding::Context) -> usize {
17592 8
17593 }
17594
17595 #[inline(always)]
17596 fn inline_size(_context: fidl::encoding::Context) -> usize {
17597 16
17598 }
17599 }
17600
17601 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferRunner, D>
17602 for &OfferRunner
17603 {
17604 unsafe fn encode(
17605 self,
17606 encoder: &mut fidl::encoding::Encoder<'_, D>,
17607 offset: usize,
17608 mut depth: fidl::encoding::Depth,
17609 ) -> fidl::Result<()> {
17610 encoder.debug_check_bounds::<OfferRunner>(offset);
17611 let max_ordinal: u64 = self.max_ordinal_present();
17613 encoder.write_num(max_ordinal, offset);
17614 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
17615 if max_ordinal == 0 {
17617 return Ok(());
17618 }
17619 depth.increment()?;
17620 let envelope_size = 8;
17621 let bytes_len = max_ordinal as usize * envelope_size;
17622 #[allow(unused_variables)]
17623 let offset = encoder.out_of_line_offset(bytes_len);
17624 let mut _prev_end_offset: usize = 0;
17625 if 1 > max_ordinal {
17626 return Ok(());
17627 }
17628
17629 let cur_offset: usize = (1 - 1) * envelope_size;
17632
17633 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17635
17636 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
17641 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
17642 encoder,
17643 offset + cur_offset,
17644 depth,
17645 )?;
17646
17647 _prev_end_offset = cur_offset + envelope_size;
17648 if 2 > max_ordinal {
17649 return Ok(());
17650 }
17651
17652 let cur_offset: usize = (2 - 1) * envelope_size;
17655
17656 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17658
17659 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
17664 self.source_name.as_ref().map(
17665 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
17666 ),
17667 encoder,
17668 offset + cur_offset,
17669 depth,
17670 )?;
17671
17672 _prev_end_offset = cur_offset + envelope_size;
17673 if 3 > max_ordinal {
17674 return Ok(());
17675 }
17676
17677 let cur_offset: usize = (3 - 1) * envelope_size;
17680
17681 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17683
17684 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
17689 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
17690 encoder,
17691 offset + cur_offset,
17692 depth,
17693 )?;
17694
17695 _prev_end_offset = cur_offset + envelope_size;
17696 if 4 > max_ordinal {
17697 return Ok(());
17698 }
17699
17700 let cur_offset: usize = (4 - 1) * envelope_size;
17703
17704 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17706
17707 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
17712 self.target_name.as_ref().map(
17713 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
17714 ),
17715 encoder,
17716 offset + cur_offset,
17717 depth,
17718 )?;
17719
17720 _prev_end_offset = cur_offset + envelope_size;
17721 if 5 > max_ordinal {
17722 return Ok(());
17723 }
17724
17725 let cur_offset: usize = (5 - 1) * envelope_size;
17728
17729 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17731
17732 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
17737 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
17738 encoder, offset + cur_offset, depth
17739 )?;
17740
17741 _prev_end_offset = cur_offset + envelope_size;
17742
17743 Ok(())
17744 }
17745 }
17746
17747 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferRunner {
17748 #[inline(always)]
17749 fn new_empty() -> Self {
17750 Self::default()
17751 }
17752
17753 unsafe fn decode(
17754 &mut self,
17755 decoder: &mut fidl::encoding::Decoder<'_, D>,
17756 offset: usize,
17757 mut depth: fidl::encoding::Depth,
17758 ) -> fidl::Result<()> {
17759 decoder.debug_check_bounds::<Self>(offset);
17760 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
17761 None => return Err(fidl::Error::NotNullable),
17762 Some(len) => len,
17763 };
17764 if len == 0 {
17766 return Ok(());
17767 };
17768 depth.increment()?;
17769 let envelope_size = 8;
17770 let bytes_len = len * envelope_size;
17771 let offset = decoder.out_of_line_offset(bytes_len)?;
17772 let mut _next_ordinal_to_read = 0;
17774 let mut next_offset = offset;
17775 let end_offset = offset + bytes_len;
17776 _next_ordinal_to_read += 1;
17777 if next_offset >= end_offset {
17778 return Ok(());
17779 }
17780
17781 while _next_ordinal_to_read < 1 {
17783 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17784 _next_ordinal_to_read += 1;
17785 next_offset += envelope_size;
17786 }
17787
17788 let next_out_of_line = decoder.next_out_of_line();
17789 let handles_before = decoder.remaining_handles();
17790 if let Some((inlined, num_bytes, num_handles)) =
17791 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17792 {
17793 let member_inline_size =
17794 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17795 if inlined != (member_inline_size <= 4) {
17796 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17797 }
17798 let inner_offset;
17799 let mut inner_depth = depth.clone();
17800 if inlined {
17801 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17802 inner_offset = next_offset;
17803 } else {
17804 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17805 inner_depth.increment()?;
17806 }
17807 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
17808 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
17809 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17810 {
17811 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17812 }
17813 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17814 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17815 }
17816 }
17817
17818 next_offset += envelope_size;
17819 _next_ordinal_to_read += 1;
17820 if next_offset >= end_offset {
17821 return Ok(());
17822 }
17823
17824 while _next_ordinal_to_read < 2 {
17826 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17827 _next_ordinal_to_read += 1;
17828 next_offset += envelope_size;
17829 }
17830
17831 let next_out_of_line = decoder.next_out_of_line();
17832 let handles_before = decoder.remaining_handles();
17833 if let Some((inlined, num_bytes, num_handles)) =
17834 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17835 {
17836 let member_inline_size =
17837 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
17838 decoder.context,
17839 );
17840 if inlined != (member_inline_size <= 4) {
17841 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17842 }
17843 let inner_offset;
17844 let mut inner_depth = depth.clone();
17845 if inlined {
17846 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17847 inner_offset = next_offset;
17848 } else {
17849 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17850 inner_depth.increment()?;
17851 }
17852 let val_ref = self
17853 .source_name
17854 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
17855 fidl::decode!(
17856 fidl::encoding::BoundedString<100>,
17857 D,
17858 val_ref,
17859 decoder,
17860 inner_offset,
17861 inner_depth
17862 )?;
17863 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17864 {
17865 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17866 }
17867 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17868 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17869 }
17870 }
17871
17872 next_offset += envelope_size;
17873 _next_ordinal_to_read += 1;
17874 if next_offset >= end_offset {
17875 return Ok(());
17876 }
17877
17878 while _next_ordinal_to_read < 3 {
17880 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17881 _next_ordinal_to_read += 1;
17882 next_offset += envelope_size;
17883 }
17884
17885 let next_out_of_line = decoder.next_out_of_line();
17886 let handles_before = decoder.remaining_handles();
17887 if let Some((inlined, num_bytes, num_handles)) =
17888 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17889 {
17890 let member_inline_size =
17891 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17892 if inlined != (member_inline_size <= 4) {
17893 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17894 }
17895 let inner_offset;
17896 let mut inner_depth = depth.clone();
17897 if inlined {
17898 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17899 inner_offset = next_offset;
17900 } else {
17901 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17902 inner_depth.increment()?;
17903 }
17904 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
17905 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
17906 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17907 {
17908 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17909 }
17910 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17911 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17912 }
17913 }
17914
17915 next_offset += envelope_size;
17916 _next_ordinal_to_read += 1;
17917 if next_offset >= end_offset {
17918 return Ok(());
17919 }
17920
17921 while _next_ordinal_to_read < 4 {
17923 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17924 _next_ordinal_to_read += 1;
17925 next_offset += envelope_size;
17926 }
17927
17928 let next_out_of_line = decoder.next_out_of_line();
17929 let handles_before = decoder.remaining_handles();
17930 if let Some((inlined, num_bytes, num_handles)) =
17931 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17932 {
17933 let member_inline_size =
17934 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
17935 decoder.context,
17936 );
17937 if inlined != (member_inline_size <= 4) {
17938 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17939 }
17940 let inner_offset;
17941 let mut inner_depth = depth.clone();
17942 if inlined {
17943 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17944 inner_offset = next_offset;
17945 } else {
17946 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17947 inner_depth.increment()?;
17948 }
17949 let val_ref = self
17950 .target_name
17951 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
17952 fidl::decode!(
17953 fidl::encoding::BoundedString<100>,
17954 D,
17955 val_ref,
17956 decoder,
17957 inner_offset,
17958 inner_depth
17959 )?;
17960 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17961 {
17962 return Err(fidl::Error::InvalidNumBytesInEnvelope);
17963 }
17964 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17965 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17966 }
17967 }
17968
17969 next_offset += envelope_size;
17970 _next_ordinal_to_read += 1;
17971 if next_offset >= end_offset {
17972 return Ok(());
17973 }
17974
17975 while _next_ordinal_to_read < 5 {
17977 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17978 _next_ordinal_to_read += 1;
17979 next_offset += envelope_size;
17980 }
17981
17982 let next_out_of_line = decoder.next_out_of_line();
17983 let handles_before = decoder.remaining_handles();
17984 if let Some((inlined, num_bytes, num_handles)) =
17985 fidl::encoding::decode_envelope_header(decoder, next_offset)?
17986 {
17987 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17988 if inlined != (member_inline_size <= 4) {
17989 return Err(fidl::Error::InvalidInlineBitInEnvelope);
17990 }
17991 let inner_offset;
17992 let mut inner_depth = depth.clone();
17993 if inlined {
17994 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17995 inner_offset = next_offset;
17996 } else {
17997 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17998 inner_depth.increment()?;
17999 }
18000 let val_ref = self.source_dictionary.get_or_insert_with(|| {
18001 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
18002 });
18003 fidl::decode!(
18004 fidl::encoding::BoundedString<1024>,
18005 D,
18006 val_ref,
18007 decoder,
18008 inner_offset,
18009 inner_depth
18010 )?;
18011 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18012 {
18013 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18014 }
18015 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18016 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18017 }
18018 }
18019
18020 next_offset += envelope_size;
18021
18022 while next_offset < end_offset {
18024 _next_ordinal_to_read += 1;
18025 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18026 next_offset += envelope_size;
18027 }
18028
18029 Ok(())
18030 }
18031 }
18032
18033 impl OfferService {
18034 #[inline(always)]
18035 fn max_ordinal_present(&self) -> u64 {
18036 if let Some(_) = self.dependency_type {
18037 return 9;
18038 }
18039 if let Some(_) = self.source_dictionary {
18040 return 8;
18041 }
18042 if let Some(_) = self.availability {
18043 return 7;
18044 }
18045 if let Some(_) = self.renamed_instances {
18046 return 6;
18047 }
18048 if let Some(_) = self.source_instance_filter {
18049 return 5;
18050 }
18051 if let Some(_) = self.target_name {
18052 return 4;
18053 }
18054 if let Some(_) = self.target {
18055 return 3;
18056 }
18057 if let Some(_) = self.source_name {
18058 return 2;
18059 }
18060 if let Some(_) = self.source {
18061 return 1;
18062 }
18063 0
18064 }
18065 }
18066
18067 impl fidl::encoding::ValueTypeMarker for OfferService {
18068 type Borrowed<'a> = &'a Self;
18069 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18070 value
18071 }
18072 }
18073
18074 unsafe impl fidl::encoding::TypeMarker for OfferService {
18075 type Owned = Self;
18076
18077 #[inline(always)]
18078 fn inline_align(_context: fidl::encoding::Context) -> usize {
18079 8
18080 }
18081
18082 #[inline(always)]
18083 fn inline_size(_context: fidl::encoding::Context) -> usize {
18084 16
18085 }
18086 }
18087
18088 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferService, D>
18089 for &OfferService
18090 {
18091 unsafe fn encode(
18092 self,
18093 encoder: &mut fidl::encoding::Encoder<'_, D>,
18094 offset: usize,
18095 mut depth: fidl::encoding::Depth,
18096 ) -> fidl::Result<()> {
18097 encoder.debug_check_bounds::<OfferService>(offset);
18098 let max_ordinal: u64 = self.max_ordinal_present();
18100 encoder.write_num(max_ordinal, offset);
18101 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18102 if max_ordinal == 0 {
18104 return Ok(());
18105 }
18106 depth.increment()?;
18107 let envelope_size = 8;
18108 let bytes_len = max_ordinal as usize * envelope_size;
18109 #[allow(unused_variables)]
18110 let offset = encoder.out_of_line_offset(bytes_len);
18111 let mut _prev_end_offset: usize = 0;
18112 if 1 > max_ordinal {
18113 return Ok(());
18114 }
18115
18116 let cur_offset: usize = (1 - 1) * envelope_size;
18119
18120 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18122
18123 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
18128 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
18129 encoder,
18130 offset + cur_offset,
18131 depth,
18132 )?;
18133
18134 _prev_end_offset = cur_offset + envelope_size;
18135 if 2 > max_ordinal {
18136 return Ok(());
18137 }
18138
18139 let cur_offset: usize = (2 - 1) * envelope_size;
18142
18143 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18145
18146 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
18151 self.source_name.as_ref().map(
18152 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
18153 ),
18154 encoder,
18155 offset + cur_offset,
18156 depth,
18157 )?;
18158
18159 _prev_end_offset = cur_offset + envelope_size;
18160 if 3 > max_ordinal {
18161 return Ok(());
18162 }
18163
18164 let cur_offset: usize = (3 - 1) * envelope_size;
18167
18168 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18170
18171 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
18176 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
18177 encoder,
18178 offset + cur_offset,
18179 depth,
18180 )?;
18181
18182 _prev_end_offset = cur_offset + envelope_size;
18183 if 4 > max_ordinal {
18184 return Ok(());
18185 }
18186
18187 let cur_offset: usize = (4 - 1) * envelope_size;
18190
18191 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18193
18194 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
18199 self.target_name.as_ref().map(
18200 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
18201 ),
18202 encoder,
18203 offset + cur_offset,
18204 depth,
18205 )?;
18206
18207 _prev_end_offset = cur_offset + envelope_size;
18208 if 5 > max_ordinal {
18209 return Ok(());
18210 }
18211
18212 let cur_offset: usize = (5 - 1) * envelope_size;
18215
18216 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18218
18219 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<100>>, D>(
18224 self.source_instance_filter.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<100>> as fidl::encoding::ValueTypeMarker>::borrow),
18225 encoder, offset + cur_offset, depth
18226 )?;
18227
18228 _prev_end_offset = cur_offset + envelope_size;
18229 if 6 > max_ordinal {
18230 return Ok(());
18231 }
18232
18233 let cur_offset: usize = (6 - 1) * envelope_size;
18236
18237 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18239
18240 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<NameMapping>, D>(
18245 self.renamed_instances.as_ref().map(<fidl::encoding::UnboundedVector<NameMapping> as fidl::encoding::ValueTypeMarker>::borrow),
18246 encoder, offset + cur_offset, depth
18247 )?;
18248
18249 _prev_end_offset = cur_offset + envelope_size;
18250 if 7 > max_ordinal {
18251 return Ok(());
18252 }
18253
18254 let cur_offset: usize = (7 - 1) * envelope_size;
18257
18258 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18260
18261 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
18266 self.availability
18267 .as_ref()
18268 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
18269 encoder,
18270 offset + cur_offset,
18271 depth,
18272 )?;
18273
18274 _prev_end_offset = cur_offset + envelope_size;
18275 if 8 > max_ordinal {
18276 return Ok(());
18277 }
18278
18279 let cur_offset: usize = (8 - 1) * envelope_size;
18282
18283 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18285
18286 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
18291 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
18292 encoder, offset + cur_offset, depth
18293 )?;
18294
18295 _prev_end_offset = cur_offset + envelope_size;
18296 if 9 > max_ordinal {
18297 return Ok(());
18298 }
18299
18300 let cur_offset: usize = (9 - 1) * envelope_size;
18303
18304 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18306
18307 fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
18312 self.dependency_type
18313 .as_ref()
18314 .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
18315 encoder,
18316 offset + cur_offset,
18317 depth,
18318 )?;
18319
18320 _prev_end_offset = cur_offset + envelope_size;
18321
18322 Ok(())
18323 }
18324 }
18325
18326 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferService {
18327 #[inline(always)]
18328 fn new_empty() -> Self {
18329 Self::default()
18330 }
18331
18332 unsafe fn decode(
18333 &mut self,
18334 decoder: &mut fidl::encoding::Decoder<'_, D>,
18335 offset: usize,
18336 mut depth: fidl::encoding::Depth,
18337 ) -> fidl::Result<()> {
18338 decoder.debug_check_bounds::<Self>(offset);
18339 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18340 None => return Err(fidl::Error::NotNullable),
18341 Some(len) => len,
18342 };
18343 if len == 0 {
18345 return Ok(());
18346 };
18347 depth.increment()?;
18348 let envelope_size = 8;
18349 let bytes_len = len * envelope_size;
18350 let offset = decoder.out_of_line_offset(bytes_len)?;
18351 let mut _next_ordinal_to_read = 0;
18353 let mut next_offset = offset;
18354 let end_offset = offset + bytes_len;
18355 _next_ordinal_to_read += 1;
18356 if next_offset >= end_offset {
18357 return Ok(());
18358 }
18359
18360 while _next_ordinal_to_read < 1 {
18362 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18363 _next_ordinal_to_read += 1;
18364 next_offset += envelope_size;
18365 }
18366
18367 let next_out_of_line = decoder.next_out_of_line();
18368 let handles_before = decoder.remaining_handles();
18369 if let Some((inlined, num_bytes, num_handles)) =
18370 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18371 {
18372 let member_inline_size =
18373 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18374 if inlined != (member_inline_size <= 4) {
18375 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18376 }
18377 let inner_offset;
18378 let mut inner_depth = depth.clone();
18379 if inlined {
18380 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18381 inner_offset = next_offset;
18382 } else {
18383 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18384 inner_depth.increment()?;
18385 }
18386 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
18387 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
18388 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18389 {
18390 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18391 }
18392 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18393 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18394 }
18395 }
18396
18397 next_offset += envelope_size;
18398 _next_ordinal_to_read += 1;
18399 if next_offset >= end_offset {
18400 return Ok(());
18401 }
18402
18403 while _next_ordinal_to_read < 2 {
18405 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18406 _next_ordinal_to_read += 1;
18407 next_offset += envelope_size;
18408 }
18409
18410 let next_out_of_line = decoder.next_out_of_line();
18411 let handles_before = decoder.remaining_handles();
18412 if let Some((inlined, num_bytes, num_handles)) =
18413 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18414 {
18415 let member_inline_size =
18416 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
18417 decoder.context,
18418 );
18419 if inlined != (member_inline_size <= 4) {
18420 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18421 }
18422 let inner_offset;
18423 let mut inner_depth = depth.clone();
18424 if inlined {
18425 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18426 inner_offset = next_offset;
18427 } else {
18428 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18429 inner_depth.increment()?;
18430 }
18431 let val_ref = self
18432 .source_name
18433 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
18434 fidl::decode!(
18435 fidl::encoding::BoundedString<100>,
18436 D,
18437 val_ref,
18438 decoder,
18439 inner_offset,
18440 inner_depth
18441 )?;
18442 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18443 {
18444 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18445 }
18446 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18447 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18448 }
18449 }
18450
18451 next_offset += envelope_size;
18452 _next_ordinal_to_read += 1;
18453 if next_offset >= end_offset {
18454 return Ok(());
18455 }
18456
18457 while _next_ordinal_to_read < 3 {
18459 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18460 _next_ordinal_to_read += 1;
18461 next_offset += envelope_size;
18462 }
18463
18464 let next_out_of_line = decoder.next_out_of_line();
18465 let handles_before = decoder.remaining_handles();
18466 if let Some((inlined, num_bytes, num_handles)) =
18467 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18468 {
18469 let member_inline_size =
18470 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18471 if inlined != (member_inline_size <= 4) {
18472 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18473 }
18474 let inner_offset;
18475 let mut inner_depth = depth.clone();
18476 if inlined {
18477 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18478 inner_offset = next_offset;
18479 } else {
18480 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18481 inner_depth.increment()?;
18482 }
18483 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
18484 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
18485 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18486 {
18487 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18488 }
18489 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18490 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18491 }
18492 }
18493
18494 next_offset += envelope_size;
18495 _next_ordinal_to_read += 1;
18496 if next_offset >= end_offset {
18497 return Ok(());
18498 }
18499
18500 while _next_ordinal_to_read < 4 {
18502 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18503 _next_ordinal_to_read += 1;
18504 next_offset += envelope_size;
18505 }
18506
18507 let next_out_of_line = decoder.next_out_of_line();
18508 let handles_before = decoder.remaining_handles();
18509 if let Some((inlined, num_bytes, num_handles)) =
18510 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18511 {
18512 let member_inline_size =
18513 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
18514 decoder.context,
18515 );
18516 if inlined != (member_inline_size <= 4) {
18517 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18518 }
18519 let inner_offset;
18520 let mut inner_depth = depth.clone();
18521 if inlined {
18522 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18523 inner_offset = next_offset;
18524 } else {
18525 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18526 inner_depth.increment()?;
18527 }
18528 let val_ref = self
18529 .target_name
18530 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
18531 fidl::decode!(
18532 fidl::encoding::BoundedString<100>,
18533 D,
18534 val_ref,
18535 decoder,
18536 inner_offset,
18537 inner_depth
18538 )?;
18539 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18540 {
18541 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18542 }
18543 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18544 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18545 }
18546 }
18547
18548 next_offset += envelope_size;
18549 _next_ordinal_to_read += 1;
18550 if next_offset >= end_offset {
18551 return Ok(());
18552 }
18553
18554 while _next_ordinal_to_read < 5 {
18556 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18557 _next_ordinal_to_read += 1;
18558 next_offset += envelope_size;
18559 }
18560
18561 let next_out_of_line = decoder.next_out_of_line();
18562 let handles_before = decoder.remaining_handles();
18563 if let Some((inlined, num_bytes, num_handles)) =
18564 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18565 {
18566 let member_inline_size = <fidl::encoding::UnboundedVector<
18567 fidl::encoding::BoundedString<100>,
18568 > as fidl::encoding::TypeMarker>::inline_size(
18569 decoder.context
18570 );
18571 if inlined != (member_inline_size <= 4) {
18572 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18573 }
18574 let inner_offset;
18575 let mut inner_depth = depth.clone();
18576 if inlined {
18577 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18578 inner_offset = next_offset;
18579 } else {
18580 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18581 inner_depth.increment()?;
18582 }
18583 let val_ref = self.source_instance_filter.get_or_insert_with(|| {
18584 fidl::new_empty!(
18585 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<100>>,
18586 D
18587 )
18588 });
18589 fidl::decode!(
18590 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<100>>,
18591 D,
18592 val_ref,
18593 decoder,
18594 inner_offset,
18595 inner_depth
18596 )?;
18597 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18598 {
18599 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18600 }
18601 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18602 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18603 }
18604 }
18605
18606 next_offset += envelope_size;
18607 _next_ordinal_to_read += 1;
18608 if next_offset >= end_offset {
18609 return Ok(());
18610 }
18611
18612 while _next_ordinal_to_read < 6 {
18614 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18615 _next_ordinal_to_read += 1;
18616 next_offset += envelope_size;
18617 }
18618
18619 let next_out_of_line = decoder.next_out_of_line();
18620 let handles_before = decoder.remaining_handles();
18621 if let Some((inlined, num_bytes, num_handles)) =
18622 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18623 {
18624 let member_inline_size = <fidl::encoding::UnboundedVector<NameMapping> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18625 if inlined != (member_inline_size <= 4) {
18626 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18627 }
18628 let inner_offset;
18629 let mut inner_depth = depth.clone();
18630 if inlined {
18631 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18632 inner_offset = next_offset;
18633 } else {
18634 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18635 inner_depth.increment()?;
18636 }
18637 let val_ref = self.renamed_instances.get_or_insert_with(|| {
18638 fidl::new_empty!(fidl::encoding::UnboundedVector<NameMapping>, D)
18639 });
18640 fidl::decode!(
18641 fidl::encoding::UnboundedVector<NameMapping>,
18642 D,
18643 val_ref,
18644 decoder,
18645 inner_offset,
18646 inner_depth
18647 )?;
18648 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18649 {
18650 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18651 }
18652 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18653 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18654 }
18655 }
18656
18657 next_offset += envelope_size;
18658 _next_ordinal_to_read += 1;
18659 if next_offset >= end_offset {
18660 return Ok(());
18661 }
18662
18663 while _next_ordinal_to_read < 7 {
18665 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18666 _next_ordinal_to_read += 1;
18667 next_offset += envelope_size;
18668 }
18669
18670 let next_out_of_line = decoder.next_out_of_line();
18671 let handles_before = decoder.remaining_handles();
18672 if let Some((inlined, num_bytes, num_handles)) =
18673 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18674 {
18675 let member_inline_size =
18676 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18677 if inlined != (member_inline_size <= 4) {
18678 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18679 }
18680 let inner_offset;
18681 let mut inner_depth = depth.clone();
18682 if inlined {
18683 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18684 inner_offset = next_offset;
18685 } else {
18686 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18687 inner_depth.increment()?;
18688 }
18689 let val_ref =
18690 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
18691 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
18692 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18693 {
18694 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18695 }
18696 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18697 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18698 }
18699 }
18700
18701 next_offset += envelope_size;
18702 _next_ordinal_to_read += 1;
18703 if next_offset >= end_offset {
18704 return Ok(());
18705 }
18706
18707 while _next_ordinal_to_read < 8 {
18709 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18710 _next_ordinal_to_read += 1;
18711 next_offset += envelope_size;
18712 }
18713
18714 let next_out_of_line = decoder.next_out_of_line();
18715 let handles_before = decoder.remaining_handles();
18716 if let Some((inlined, num_bytes, num_handles)) =
18717 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18718 {
18719 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18720 if inlined != (member_inline_size <= 4) {
18721 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18722 }
18723 let inner_offset;
18724 let mut inner_depth = depth.clone();
18725 if inlined {
18726 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18727 inner_offset = next_offset;
18728 } else {
18729 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18730 inner_depth.increment()?;
18731 }
18732 let val_ref = self.source_dictionary.get_or_insert_with(|| {
18733 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
18734 });
18735 fidl::decode!(
18736 fidl::encoding::BoundedString<1024>,
18737 D,
18738 val_ref,
18739 decoder,
18740 inner_offset,
18741 inner_depth
18742 )?;
18743 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18744 {
18745 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18746 }
18747 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18748 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18749 }
18750 }
18751
18752 next_offset += envelope_size;
18753 _next_ordinal_to_read += 1;
18754 if next_offset >= end_offset {
18755 return Ok(());
18756 }
18757
18758 while _next_ordinal_to_read < 9 {
18760 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18761 _next_ordinal_to_read += 1;
18762 next_offset += envelope_size;
18763 }
18764
18765 let next_out_of_line = decoder.next_out_of_line();
18766 let handles_before = decoder.remaining_handles();
18767 if let Some((inlined, num_bytes, num_handles)) =
18768 fidl::encoding::decode_envelope_header(decoder, next_offset)?
18769 {
18770 let member_inline_size =
18771 <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18772 if inlined != (member_inline_size <= 4) {
18773 return Err(fidl::Error::InvalidInlineBitInEnvelope);
18774 }
18775 let inner_offset;
18776 let mut inner_depth = depth.clone();
18777 if inlined {
18778 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18779 inner_offset = next_offset;
18780 } else {
18781 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18782 inner_depth.increment()?;
18783 }
18784 let val_ref =
18785 self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
18786 fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
18787 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18788 {
18789 return Err(fidl::Error::InvalidNumBytesInEnvelope);
18790 }
18791 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18792 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18793 }
18794 }
18795
18796 next_offset += envelope_size;
18797
18798 while next_offset < end_offset {
18800 _next_ordinal_to_read += 1;
18801 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18802 next_offset += envelope_size;
18803 }
18804
18805 Ok(())
18806 }
18807 }
18808
18809 impl OfferStorage {
18810 #[inline(always)]
18811 fn max_ordinal_present(&self) -> u64 {
18812 if let Some(_) = self.availability {
18813 return 5;
18814 }
18815 if let Some(_) = self.target_name {
18816 return 4;
18817 }
18818 if let Some(_) = self.target {
18819 return 3;
18820 }
18821 if let Some(_) = self.source {
18822 return 2;
18823 }
18824 if let Some(_) = self.source_name {
18825 return 1;
18826 }
18827 0
18828 }
18829 }
18830
18831 impl fidl::encoding::ValueTypeMarker for OfferStorage {
18832 type Borrowed<'a> = &'a Self;
18833 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18834 value
18835 }
18836 }
18837
18838 unsafe impl fidl::encoding::TypeMarker for OfferStorage {
18839 type Owned = Self;
18840
18841 #[inline(always)]
18842 fn inline_align(_context: fidl::encoding::Context) -> usize {
18843 8
18844 }
18845
18846 #[inline(always)]
18847 fn inline_size(_context: fidl::encoding::Context) -> usize {
18848 16
18849 }
18850 }
18851
18852 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferStorage, D>
18853 for &OfferStorage
18854 {
18855 unsafe fn encode(
18856 self,
18857 encoder: &mut fidl::encoding::Encoder<'_, D>,
18858 offset: usize,
18859 mut depth: fidl::encoding::Depth,
18860 ) -> fidl::Result<()> {
18861 encoder.debug_check_bounds::<OfferStorage>(offset);
18862 let max_ordinal: u64 = self.max_ordinal_present();
18864 encoder.write_num(max_ordinal, offset);
18865 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18866 if max_ordinal == 0 {
18868 return Ok(());
18869 }
18870 depth.increment()?;
18871 let envelope_size = 8;
18872 let bytes_len = max_ordinal as usize * envelope_size;
18873 #[allow(unused_variables)]
18874 let offset = encoder.out_of_line_offset(bytes_len);
18875 let mut _prev_end_offset: usize = 0;
18876 if 1 > max_ordinal {
18877 return Ok(());
18878 }
18879
18880 let cur_offset: usize = (1 - 1) * envelope_size;
18883
18884 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18886
18887 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
18892 self.source_name.as_ref().map(
18893 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
18894 ),
18895 encoder,
18896 offset + cur_offset,
18897 depth,
18898 )?;
18899
18900 _prev_end_offset = cur_offset + envelope_size;
18901 if 2 > max_ordinal {
18902 return Ok(());
18903 }
18904
18905 let cur_offset: usize = (2 - 1) * envelope_size;
18908
18909 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18911
18912 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
18917 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
18918 encoder,
18919 offset + cur_offset,
18920 depth,
18921 )?;
18922
18923 _prev_end_offset = cur_offset + envelope_size;
18924 if 3 > max_ordinal {
18925 return Ok(());
18926 }
18927
18928 let cur_offset: usize = (3 - 1) * envelope_size;
18931
18932 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18934
18935 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
18940 self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
18941 encoder,
18942 offset + cur_offset,
18943 depth,
18944 )?;
18945
18946 _prev_end_offset = cur_offset + envelope_size;
18947 if 4 > max_ordinal {
18948 return Ok(());
18949 }
18950
18951 let cur_offset: usize = (4 - 1) * envelope_size;
18954
18955 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18957
18958 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
18963 self.target_name.as_ref().map(
18964 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
18965 ),
18966 encoder,
18967 offset + cur_offset,
18968 depth,
18969 )?;
18970
18971 _prev_end_offset = cur_offset + envelope_size;
18972 if 5 > max_ordinal {
18973 return Ok(());
18974 }
18975
18976 let cur_offset: usize = (5 - 1) * envelope_size;
18979
18980 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18982
18983 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
18988 self.availability
18989 .as_ref()
18990 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
18991 encoder,
18992 offset + cur_offset,
18993 depth,
18994 )?;
18995
18996 _prev_end_offset = cur_offset + envelope_size;
18997
18998 Ok(())
18999 }
19000 }
19001
19002 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferStorage {
19003 #[inline(always)]
19004 fn new_empty() -> Self {
19005 Self::default()
19006 }
19007
19008 unsafe fn decode(
19009 &mut self,
19010 decoder: &mut fidl::encoding::Decoder<'_, D>,
19011 offset: usize,
19012 mut depth: fidl::encoding::Depth,
19013 ) -> fidl::Result<()> {
19014 decoder.debug_check_bounds::<Self>(offset);
19015 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19016 None => return Err(fidl::Error::NotNullable),
19017 Some(len) => len,
19018 };
19019 if len == 0 {
19021 return Ok(());
19022 };
19023 depth.increment()?;
19024 let envelope_size = 8;
19025 let bytes_len = len * envelope_size;
19026 let offset = decoder.out_of_line_offset(bytes_len)?;
19027 let mut _next_ordinal_to_read = 0;
19029 let mut next_offset = offset;
19030 let end_offset = offset + bytes_len;
19031 _next_ordinal_to_read += 1;
19032 if next_offset >= end_offset {
19033 return Ok(());
19034 }
19035
19036 while _next_ordinal_to_read < 1 {
19038 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19039 _next_ordinal_to_read += 1;
19040 next_offset += envelope_size;
19041 }
19042
19043 let next_out_of_line = decoder.next_out_of_line();
19044 let handles_before = decoder.remaining_handles();
19045 if let Some((inlined, num_bytes, num_handles)) =
19046 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19047 {
19048 let member_inline_size =
19049 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
19050 decoder.context,
19051 );
19052 if inlined != (member_inline_size <= 4) {
19053 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19054 }
19055 let inner_offset;
19056 let mut inner_depth = depth.clone();
19057 if inlined {
19058 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19059 inner_offset = next_offset;
19060 } else {
19061 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19062 inner_depth.increment()?;
19063 }
19064 let val_ref = self
19065 .source_name
19066 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
19067 fidl::decode!(
19068 fidl::encoding::BoundedString<100>,
19069 D,
19070 val_ref,
19071 decoder,
19072 inner_offset,
19073 inner_depth
19074 )?;
19075 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19076 {
19077 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19078 }
19079 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19080 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19081 }
19082 }
19083
19084 next_offset += envelope_size;
19085 _next_ordinal_to_read += 1;
19086 if next_offset >= end_offset {
19087 return Ok(());
19088 }
19089
19090 while _next_ordinal_to_read < 2 {
19092 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19093 _next_ordinal_to_read += 1;
19094 next_offset += envelope_size;
19095 }
19096
19097 let next_out_of_line = decoder.next_out_of_line();
19098 let handles_before = decoder.remaining_handles();
19099 if let Some((inlined, num_bytes, num_handles)) =
19100 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19101 {
19102 let member_inline_size =
19103 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19104 if inlined != (member_inline_size <= 4) {
19105 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19106 }
19107 let inner_offset;
19108 let mut inner_depth = depth.clone();
19109 if inlined {
19110 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19111 inner_offset = next_offset;
19112 } else {
19113 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19114 inner_depth.increment()?;
19115 }
19116 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
19117 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
19118 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19119 {
19120 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19121 }
19122 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19123 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19124 }
19125 }
19126
19127 next_offset += envelope_size;
19128 _next_ordinal_to_read += 1;
19129 if next_offset >= end_offset {
19130 return Ok(());
19131 }
19132
19133 while _next_ordinal_to_read < 3 {
19135 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19136 _next_ordinal_to_read += 1;
19137 next_offset += envelope_size;
19138 }
19139
19140 let next_out_of_line = decoder.next_out_of_line();
19141 let handles_before = decoder.remaining_handles();
19142 if let Some((inlined, num_bytes, num_handles)) =
19143 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19144 {
19145 let member_inline_size =
19146 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19147 if inlined != (member_inline_size <= 4) {
19148 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19149 }
19150 let inner_offset;
19151 let mut inner_depth = depth.clone();
19152 if inlined {
19153 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19154 inner_offset = next_offset;
19155 } else {
19156 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19157 inner_depth.increment()?;
19158 }
19159 let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
19160 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
19161 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19162 {
19163 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19164 }
19165 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19166 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19167 }
19168 }
19169
19170 next_offset += envelope_size;
19171 _next_ordinal_to_read += 1;
19172 if next_offset >= end_offset {
19173 return Ok(());
19174 }
19175
19176 while _next_ordinal_to_read < 4 {
19178 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19179 _next_ordinal_to_read += 1;
19180 next_offset += envelope_size;
19181 }
19182
19183 let next_out_of_line = decoder.next_out_of_line();
19184 let handles_before = decoder.remaining_handles();
19185 if let Some((inlined, num_bytes, num_handles)) =
19186 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19187 {
19188 let member_inline_size =
19189 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
19190 decoder.context,
19191 );
19192 if inlined != (member_inline_size <= 4) {
19193 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19194 }
19195 let inner_offset;
19196 let mut inner_depth = depth.clone();
19197 if inlined {
19198 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19199 inner_offset = next_offset;
19200 } else {
19201 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19202 inner_depth.increment()?;
19203 }
19204 let val_ref = self
19205 .target_name
19206 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
19207 fidl::decode!(
19208 fidl::encoding::BoundedString<100>,
19209 D,
19210 val_ref,
19211 decoder,
19212 inner_offset,
19213 inner_depth
19214 )?;
19215 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19216 {
19217 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19218 }
19219 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19220 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19221 }
19222 }
19223
19224 next_offset += envelope_size;
19225 _next_ordinal_to_read += 1;
19226 if next_offset >= end_offset {
19227 return Ok(());
19228 }
19229
19230 while _next_ordinal_to_read < 5 {
19232 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19233 _next_ordinal_to_read += 1;
19234 next_offset += envelope_size;
19235 }
19236
19237 let next_out_of_line = decoder.next_out_of_line();
19238 let handles_before = decoder.remaining_handles();
19239 if let Some((inlined, num_bytes, num_handles)) =
19240 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19241 {
19242 let member_inline_size =
19243 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19244 if inlined != (member_inline_size <= 4) {
19245 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19246 }
19247 let inner_offset;
19248 let mut inner_depth = depth.clone();
19249 if inlined {
19250 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19251 inner_offset = next_offset;
19252 } else {
19253 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19254 inner_depth.increment()?;
19255 }
19256 let val_ref =
19257 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
19258 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
19259 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19260 {
19261 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19262 }
19263 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19264 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19265 }
19266 }
19267
19268 next_offset += envelope_size;
19269
19270 while next_offset < end_offset {
19272 _next_ordinal_to_read += 1;
19273 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19274 next_offset += envelope_size;
19275 }
19276
19277 Ok(())
19278 }
19279 }
19280
19281 impl Program {
19282 #[inline(always)]
19283 fn max_ordinal_present(&self) -> u64 {
19284 if let Some(_) = self.info {
19285 return 2;
19286 }
19287 if let Some(_) = self.runner {
19288 return 1;
19289 }
19290 0
19291 }
19292 }
19293
19294 impl fidl::encoding::ValueTypeMarker for Program {
19295 type Borrowed<'a> = &'a Self;
19296 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19297 value
19298 }
19299 }
19300
19301 unsafe impl fidl::encoding::TypeMarker for Program {
19302 type Owned = Self;
19303
19304 #[inline(always)]
19305 fn inline_align(_context: fidl::encoding::Context) -> usize {
19306 8
19307 }
19308
19309 #[inline(always)]
19310 fn inline_size(_context: fidl::encoding::Context) -> usize {
19311 16
19312 }
19313 }
19314
19315 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Program, D> for &Program {
19316 unsafe fn encode(
19317 self,
19318 encoder: &mut fidl::encoding::Encoder<'_, D>,
19319 offset: usize,
19320 mut depth: fidl::encoding::Depth,
19321 ) -> fidl::Result<()> {
19322 encoder.debug_check_bounds::<Program>(offset);
19323 let max_ordinal: u64 = self.max_ordinal_present();
19325 encoder.write_num(max_ordinal, offset);
19326 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19327 if max_ordinal == 0 {
19329 return Ok(());
19330 }
19331 depth.increment()?;
19332 let envelope_size = 8;
19333 let bytes_len = max_ordinal as usize * envelope_size;
19334 #[allow(unused_variables)]
19335 let offset = encoder.out_of_line_offset(bytes_len);
19336 let mut _prev_end_offset: usize = 0;
19337 if 1 > max_ordinal {
19338 return Ok(());
19339 }
19340
19341 let cur_offset: usize = (1 - 1) * envelope_size;
19344
19345 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19347
19348 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
19353 self.runner.as_ref().map(
19354 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
19355 ),
19356 encoder,
19357 offset + cur_offset,
19358 depth,
19359 )?;
19360
19361 _prev_end_offset = cur_offset + envelope_size;
19362 if 2 > max_ordinal {
19363 return Ok(());
19364 }
19365
19366 let cur_offset: usize = (2 - 1) * envelope_size;
19369
19370 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19372
19373 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_data__common::Dictionary, D>(
19378 self.info.as_ref().map(<fidl_fuchsia_data__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow),
19379 encoder, offset + cur_offset, depth
19380 )?;
19381
19382 _prev_end_offset = cur_offset + envelope_size;
19383
19384 Ok(())
19385 }
19386 }
19387
19388 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Program {
19389 #[inline(always)]
19390 fn new_empty() -> Self {
19391 Self::default()
19392 }
19393
19394 unsafe fn decode(
19395 &mut self,
19396 decoder: &mut fidl::encoding::Decoder<'_, D>,
19397 offset: usize,
19398 mut depth: fidl::encoding::Depth,
19399 ) -> fidl::Result<()> {
19400 decoder.debug_check_bounds::<Self>(offset);
19401 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19402 None => return Err(fidl::Error::NotNullable),
19403 Some(len) => len,
19404 };
19405 if len == 0 {
19407 return Ok(());
19408 };
19409 depth.increment()?;
19410 let envelope_size = 8;
19411 let bytes_len = len * envelope_size;
19412 let offset = decoder.out_of_line_offset(bytes_len)?;
19413 let mut _next_ordinal_to_read = 0;
19415 let mut next_offset = offset;
19416 let end_offset = offset + bytes_len;
19417 _next_ordinal_to_read += 1;
19418 if next_offset >= end_offset {
19419 return Ok(());
19420 }
19421
19422 while _next_ordinal_to_read < 1 {
19424 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19425 _next_ordinal_to_read += 1;
19426 next_offset += envelope_size;
19427 }
19428
19429 let next_out_of_line = decoder.next_out_of_line();
19430 let handles_before = decoder.remaining_handles();
19431 if let Some((inlined, num_bytes, num_handles)) =
19432 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19433 {
19434 let member_inline_size =
19435 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
19436 decoder.context,
19437 );
19438 if inlined != (member_inline_size <= 4) {
19439 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19440 }
19441 let inner_offset;
19442 let mut inner_depth = depth.clone();
19443 if inlined {
19444 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19445 inner_offset = next_offset;
19446 } else {
19447 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19448 inner_depth.increment()?;
19449 }
19450 let val_ref = self
19451 .runner
19452 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
19453 fidl::decode!(
19454 fidl::encoding::BoundedString<100>,
19455 D,
19456 val_ref,
19457 decoder,
19458 inner_offset,
19459 inner_depth
19460 )?;
19461 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19462 {
19463 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19464 }
19465 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19466 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19467 }
19468 }
19469
19470 next_offset += envelope_size;
19471 _next_ordinal_to_read += 1;
19472 if next_offset >= end_offset {
19473 return Ok(());
19474 }
19475
19476 while _next_ordinal_to_read < 2 {
19478 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19479 _next_ordinal_to_read += 1;
19480 next_offset += envelope_size;
19481 }
19482
19483 let next_out_of_line = decoder.next_out_of_line();
19484 let handles_before = decoder.remaining_handles();
19485 if let Some((inlined, num_bytes, num_handles)) =
19486 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19487 {
19488 let member_inline_size = <fidl_fuchsia_data__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19489 if inlined != (member_inline_size <= 4) {
19490 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19491 }
19492 let inner_offset;
19493 let mut inner_depth = depth.clone();
19494 if inlined {
19495 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19496 inner_offset = next_offset;
19497 } else {
19498 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19499 inner_depth.increment()?;
19500 }
19501 let val_ref = self.info.get_or_insert_with(|| {
19502 fidl::new_empty!(fidl_fuchsia_data__common::Dictionary, D)
19503 });
19504 fidl::decode!(
19505 fidl_fuchsia_data__common::Dictionary,
19506 D,
19507 val_ref,
19508 decoder,
19509 inner_offset,
19510 inner_depth
19511 )?;
19512 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19513 {
19514 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19515 }
19516 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19517 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19518 }
19519 }
19520
19521 next_offset += envelope_size;
19522
19523 while next_offset < end_offset {
19525 _next_ordinal_to_read += 1;
19526 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19527 next_offset += envelope_size;
19528 }
19529
19530 Ok(())
19531 }
19532 }
19533
19534 impl Protocol {
19535 #[inline(always)]
19536 fn max_ordinal_present(&self) -> u64 {
19537 if let Some(_) = self.delivery {
19538 return 3;
19539 }
19540 if let Some(_) = self.source_path {
19541 return 2;
19542 }
19543 if let Some(_) = self.name {
19544 return 1;
19545 }
19546 0
19547 }
19548 }
19549
19550 impl fidl::encoding::ValueTypeMarker for Protocol {
19551 type Borrowed<'a> = &'a Self;
19552 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19553 value
19554 }
19555 }
19556
19557 unsafe impl fidl::encoding::TypeMarker for Protocol {
19558 type Owned = Self;
19559
19560 #[inline(always)]
19561 fn inline_align(_context: fidl::encoding::Context) -> usize {
19562 8
19563 }
19564
19565 #[inline(always)]
19566 fn inline_size(_context: fidl::encoding::Context) -> usize {
19567 16
19568 }
19569 }
19570
19571 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Protocol, D> for &Protocol {
19572 unsafe fn encode(
19573 self,
19574 encoder: &mut fidl::encoding::Encoder<'_, D>,
19575 offset: usize,
19576 mut depth: fidl::encoding::Depth,
19577 ) -> fidl::Result<()> {
19578 encoder.debug_check_bounds::<Protocol>(offset);
19579 let max_ordinal: u64 = self.max_ordinal_present();
19581 encoder.write_num(max_ordinal, offset);
19582 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19583 if max_ordinal == 0 {
19585 return Ok(());
19586 }
19587 depth.increment()?;
19588 let envelope_size = 8;
19589 let bytes_len = max_ordinal as usize * envelope_size;
19590 #[allow(unused_variables)]
19591 let offset = encoder.out_of_line_offset(bytes_len);
19592 let mut _prev_end_offset: usize = 0;
19593 if 1 > max_ordinal {
19594 return Ok(());
19595 }
19596
19597 let cur_offset: usize = (1 - 1) * envelope_size;
19600
19601 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19603
19604 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
19609 self.name.as_ref().map(
19610 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
19611 ),
19612 encoder,
19613 offset + cur_offset,
19614 depth,
19615 )?;
19616
19617 _prev_end_offset = cur_offset + envelope_size;
19618 if 2 > max_ordinal {
19619 return Ok(());
19620 }
19621
19622 let cur_offset: usize = (2 - 1) * envelope_size;
19625
19626 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19628
19629 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
19634 self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
19635 encoder, offset + cur_offset, depth
19636 )?;
19637
19638 _prev_end_offset = cur_offset + envelope_size;
19639 if 3 > max_ordinal {
19640 return Ok(());
19641 }
19642
19643 let cur_offset: usize = (3 - 1) * envelope_size;
19646
19647 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19649
19650 fidl::encoding::encode_in_envelope_optional::<DeliveryType, D>(
19655 self.delivery
19656 .as_ref()
19657 .map(<DeliveryType as fidl::encoding::ValueTypeMarker>::borrow),
19658 encoder,
19659 offset + cur_offset,
19660 depth,
19661 )?;
19662
19663 _prev_end_offset = cur_offset + envelope_size;
19664
19665 Ok(())
19666 }
19667 }
19668
19669 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Protocol {
19670 #[inline(always)]
19671 fn new_empty() -> Self {
19672 Self::default()
19673 }
19674
19675 unsafe fn decode(
19676 &mut self,
19677 decoder: &mut fidl::encoding::Decoder<'_, D>,
19678 offset: usize,
19679 mut depth: fidl::encoding::Depth,
19680 ) -> fidl::Result<()> {
19681 decoder.debug_check_bounds::<Self>(offset);
19682 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19683 None => return Err(fidl::Error::NotNullable),
19684 Some(len) => len,
19685 };
19686 if len == 0 {
19688 return Ok(());
19689 };
19690 depth.increment()?;
19691 let envelope_size = 8;
19692 let bytes_len = len * envelope_size;
19693 let offset = decoder.out_of_line_offset(bytes_len)?;
19694 let mut _next_ordinal_to_read = 0;
19696 let mut next_offset = offset;
19697 let end_offset = offset + bytes_len;
19698 _next_ordinal_to_read += 1;
19699 if next_offset >= end_offset {
19700 return Ok(());
19701 }
19702
19703 while _next_ordinal_to_read < 1 {
19705 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19706 _next_ordinal_to_read += 1;
19707 next_offset += envelope_size;
19708 }
19709
19710 let next_out_of_line = decoder.next_out_of_line();
19711 let handles_before = decoder.remaining_handles();
19712 if let Some((inlined, num_bytes, num_handles)) =
19713 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19714 {
19715 let member_inline_size =
19716 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
19717 decoder.context,
19718 );
19719 if inlined != (member_inline_size <= 4) {
19720 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19721 }
19722 let inner_offset;
19723 let mut inner_depth = depth.clone();
19724 if inlined {
19725 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19726 inner_offset = next_offset;
19727 } else {
19728 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19729 inner_depth.increment()?;
19730 }
19731 let val_ref = self
19732 .name
19733 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
19734 fidl::decode!(
19735 fidl::encoding::BoundedString<100>,
19736 D,
19737 val_ref,
19738 decoder,
19739 inner_offset,
19740 inner_depth
19741 )?;
19742 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19743 {
19744 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19745 }
19746 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19747 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19748 }
19749 }
19750
19751 next_offset += envelope_size;
19752 _next_ordinal_to_read += 1;
19753 if next_offset >= end_offset {
19754 return Ok(());
19755 }
19756
19757 while _next_ordinal_to_read < 2 {
19759 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19760 _next_ordinal_to_read += 1;
19761 next_offset += envelope_size;
19762 }
19763
19764 let next_out_of_line = decoder.next_out_of_line();
19765 let handles_before = decoder.remaining_handles();
19766 if let Some((inlined, num_bytes, num_handles)) =
19767 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19768 {
19769 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19770 if inlined != (member_inline_size <= 4) {
19771 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19772 }
19773 let inner_offset;
19774 let mut inner_depth = depth.clone();
19775 if inlined {
19776 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19777 inner_offset = next_offset;
19778 } else {
19779 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19780 inner_depth.increment()?;
19781 }
19782 let val_ref = self.source_path.get_or_insert_with(|| {
19783 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
19784 });
19785 fidl::decode!(
19786 fidl::encoding::BoundedString<1024>,
19787 D,
19788 val_ref,
19789 decoder,
19790 inner_offset,
19791 inner_depth
19792 )?;
19793 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19794 {
19795 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19796 }
19797 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19798 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19799 }
19800 }
19801
19802 next_offset += envelope_size;
19803 _next_ordinal_to_read += 1;
19804 if next_offset >= end_offset {
19805 return Ok(());
19806 }
19807
19808 while _next_ordinal_to_read < 3 {
19810 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19811 _next_ordinal_to_read += 1;
19812 next_offset += envelope_size;
19813 }
19814
19815 let next_out_of_line = decoder.next_out_of_line();
19816 let handles_before = decoder.remaining_handles();
19817 if let Some((inlined, num_bytes, num_handles)) =
19818 fidl::encoding::decode_envelope_header(decoder, next_offset)?
19819 {
19820 let member_inline_size =
19821 <DeliveryType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19822 if inlined != (member_inline_size <= 4) {
19823 return Err(fidl::Error::InvalidInlineBitInEnvelope);
19824 }
19825 let inner_offset;
19826 let mut inner_depth = depth.clone();
19827 if inlined {
19828 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19829 inner_offset = next_offset;
19830 } else {
19831 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19832 inner_depth.increment()?;
19833 }
19834 let val_ref =
19835 self.delivery.get_or_insert_with(|| fidl::new_empty!(DeliveryType, D));
19836 fidl::decode!(DeliveryType, D, val_ref, decoder, inner_offset, inner_depth)?;
19837 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19838 {
19839 return Err(fidl::Error::InvalidNumBytesInEnvelope);
19840 }
19841 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19842 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19843 }
19844 }
19845
19846 next_offset += envelope_size;
19847
19848 while next_offset < end_offset {
19850 _next_ordinal_to_read += 1;
19851 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19852 next_offset += envelope_size;
19853 }
19854
19855 Ok(())
19856 }
19857 }
19858
19859 impl Resolver {
19860 #[inline(always)]
19861 fn max_ordinal_present(&self) -> u64 {
19862 if let Some(_) = self.source_path {
19863 return 2;
19864 }
19865 if let Some(_) = self.name {
19866 return 1;
19867 }
19868 0
19869 }
19870 }
19871
19872 impl fidl::encoding::ValueTypeMarker for Resolver {
19873 type Borrowed<'a> = &'a Self;
19874 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19875 value
19876 }
19877 }
19878
19879 unsafe impl fidl::encoding::TypeMarker for Resolver {
19880 type Owned = Self;
19881
19882 #[inline(always)]
19883 fn inline_align(_context: fidl::encoding::Context) -> usize {
19884 8
19885 }
19886
19887 #[inline(always)]
19888 fn inline_size(_context: fidl::encoding::Context) -> usize {
19889 16
19890 }
19891 }
19892
19893 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Resolver, D> for &Resolver {
19894 unsafe fn encode(
19895 self,
19896 encoder: &mut fidl::encoding::Encoder<'_, D>,
19897 offset: usize,
19898 mut depth: fidl::encoding::Depth,
19899 ) -> fidl::Result<()> {
19900 encoder.debug_check_bounds::<Resolver>(offset);
19901 let max_ordinal: u64 = self.max_ordinal_present();
19903 encoder.write_num(max_ordinal, offset);
19904 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19905 if max_ordinal == 0 {
19907 return Ok(());
19908 }
19909 depth.increment()?;
19910 let envelope_size = 8;
19911 let bytes_len = max_ordinal as usize * envelope_size;
19912 #[allow(unused_variables)]
19913 let offset = encoder.out_of_line_offset(bytes_len);
19914 let mut _prev_end_offset: usize = 0;
19915 if 1 > max_ordinal {
19916 return Ok(());
19917 }
19918
19919 let cur_offset: usize = (1 - 1) * envelope_size;
19922
19923 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19925
19926 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
19931 self.name.as_ref().map(
19932 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
19933 ),
19934 encoder,
19935 offset + cur_offset,
19936 depth,
19937 )?;
19938
19939 _prev_end_offset = cur_offset + envelope_size;
19940 if 2 > max_ordinal {
19941 return Ok(());
19942 }
19943
19944 let cur_offset: usize = (2 - 1) * envelope_size;
19947
19948 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19950
19951 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
19956 self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
19957 encoder, offset + cur_offset, depth
19958 )?;
19959
19960 _prev_end_offset = cur_offset + envelope_size;
19961
19962 Ok(())
19963 }
19964 }
19965
19966 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Resolver {
19967 #[inline(always)]
19968 fn new_empty() -> Self {
19969 Self::default()
19970 }
19971
19972 unsafe fn decode(
19973 &mut self,
19974 decoder: &mut fidl::encoding::Decoder<'_, D>,
19975 offset: usize,
19976 mut depth: fidl::encoding::Depth,
19977 ) -> fidl::Result<()> {
19978 decoder.debug_check_bounds::<Self>(offset);
19979 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19980 None => return Err(fidl::Error::NotNullable),
19981 Some(len) => len,
19982 };
19983 if len == 0 {
19985 return Ok(());
19986 };
19987 depth.increment()?;
19988 let envelope_size = 8;
19989 let bytes_len = len * envelope_size;
19990 let offset = decoder.out_of_line_offset(bytes_len)?;
19991 let mut _next_ordinal_to_read = 0;
19993 let mut next_offset = offset;
19994 let end_offset = offset + bytes_len;
19995 _next_ordinal_to_read += 1;
19996 if next_offset >= end_offset {
19997 return Ok(());
19998 }
19999
20000 while _next_ordinal_to_read < 1 {
20002 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20003 _next_ordinal_to_read += 1;
20004 next_offset += envelope_size;
20005 }
20006
20007 let next_out_of_line = decoder.next_out_of_line();
20008 let handles_before = decoder.remaining_handles();
20009 if let Some((inlined, num_bytes, num_handles)) =
20010 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20011 {
20012 let member_inline_size =
20013 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20014 decoder.context,
20015 );
20016 if inlined != (member_inline_size <= 4) {
20017 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20018 }
20019 let inner_offset;
20020 let mut inner_depth = depth.clone();
20021 if inlined {
20022 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20023 inner_offset = next_offset;
20024 } else {
20025 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20026 inner_depth.increment()?;
20027 }
20028 let val_ref = self
20029 .name
20030 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20031 fidl::decode!(
20032 fidl::encoding::BoundedString<100>,
20033 D,
20034 val_ref,
20035 decoder,
20036 inner_offset,
20037 inner_depth
20038 )?;
20039 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20040 {
20041 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20042 }
20043 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20044 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20045 }
20046 }
20047
20048 next_offset += envelope_size;
20049 _next_ordinal_to_read += 1;
20050 if next_offset >= end_offset {
20051 return Ok(());
20052 }
20053
20054 while _next_ordinal_to_read < 2 {
20056 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20057 _next_ordinal_to_read += 1;
20058 next_offset += envelope_size;
20059 }
20060
20061 let next_out_of_line = decoder.next_out_of_line();
20062 let handles_before = decoder.remaining_handles();
20063 if let Some((inlined, num_bytes, num_handles)) =
20064 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20065 {
20066 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20067 if inlined != (member_inline_size <= 4) {
20068 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20069 }
20070 let inner_offset;
20071 let mut inner_depth = depth.clone();
20072 if inlined {
20073 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20074 inner_offset = next_offset;
20075 } else {
20076 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20077 inner_depth.increment()?;
20078 }
20079 let val_ref = self.source_path.get_or_insert_with(|| {
20080 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
20081 });
20082 fidl::decode!(
20083 fidl::encoding::BoundedString<1024>,
20084 D,
20085 val_ref,
20086 decoder,
20087 inner_offset,
20088 inner_depth
20089 )?;
20090 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20091 {
20092 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20093 }
20094 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20095 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20096 }
20097 }
20098
20099 next_offset += envelope_size;
20100
20101 while next_offset < end_offset {
20103 _next_ordinal_to_read += 1;
20104 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20105 next_offset += envelope_size;
20106 }
20107
20108 Ok(())
20109 }
20110 }
20111
20112 impl ResolverRegistration {
20113 #[inline(always)]
20114 fn max_ordinal_present(&self) -> u64 {
20115 if let Some(_) = self.scheme {
20116 return 3;
20117 }
20118 if let Some(_) = self.source {
20119 return 2;
20120 }
20121 if let Some(_) = self.resolver {
20122 return 1;
20123 }
20124 0
20125 }
20126 }
20127
20128 impl fidl::encoding::ValueTypeMarker for ResolverRegistration {
20129 type Borrowed<'a> = &'a Self;
20130 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
20131 value
20132 }
20133 }
20134
20135 unsafe impl fidl::encoding::TypeMarker for ResolverRegistration {
20136 type Owned = Self;
20137
20138 #[inline(always)]
20139 fn inline_align(_context: fidl::encoding::Context) -> usize {
20140 8
20141 }
20142
20143 #[inline(always)]
20144 fn inline_size(_context: fidl::encoding::Context) -> usize {
20145 16
20146 }
20147 }
20148
20149 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolverRegistration, D>
20150 for &ResolverRegistration
20151 {
20152 unsafe fn encode(
20153 self,
20154 encoder: &mut fidl::encoding::Encoder<'_, D>,
20155 offset: usize,
20156 mut depth: fidl::encoding::Depth,
20157 ) -> fidl::Result<()> {
20158 encoder.debug_check_bounds::<ResolverRegistration>(offset);
20159 let max_ordinal: u64 = self.max_ordinal_present();
20161 encoder.write_num(max_ordinal, offset);
20162 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
20163 if max_ordinal == 0 {
20165 return Ok(());
20166 }
20167 depth.increment()?;
20168 let envelope_size = 8;
20169 let bytes_len = max_ordinal as usize * envelope_size;
20170 #[allow(unused_variables)]
20171 let offset = encoder.out_of_line_offset(bytes_len);
20172 let mut _prev_end_offset: usize = 0;
20173 if 1 > max_ordinal {
20174 return Ok(());
20175 }
20176
20177 let cur_offset: usize = (1 - 1) * envelope_size;
20180
20181 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20183
20184 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
20189 self.resolver.as_ref().map(
20190 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
20191 ),
20192 encoder,
20193 offset + cur_offset,
20194 depth,
20195 )?;
20196
20197 _prev_end_offset = cur_offset + envelope_size;
20198 if 2 > max_ordinal {
20199 return Ok(());
20200 }
20201
20202 let cur_offset: usize = (2 - 1) * envelope_size;
20205
20206 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20208
20209 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
20214 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
20215 encoder,
20216 offset + cur_offset,
20217 depth,
20218 )?;
20219
20220 _prev_end_offset = cur_offset + envelope_size;
20221 if 3 > max_ordinal {
20222 return Ok(());
20223 }
20224
20225 let cur_offset: usize = (3 - 1) * envelope_size;
20228
20229 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20231
20232 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
20237 self.scheme.as_ref().map(
20238 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
20239 ),
20240 encoder,
20241 offset + cur_offset,
20242 depth,
20243 )?;
20244
20245 _prev_end_offset = cur_offset + envelope_size;
20246
20247 Ok(())
20248 }
20249 }
20250
20251 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolverRegistration {
20252 #[inline(always)]
20253 fn new_empty() -> Self {
20254 Self::default()
20255 }
20256
20257 unsafe fn decode(
20258 &mut self,
20259 decoder: &mut fidl::encoding::Decoder<'_, D>,
20260 offset: usize,
20261 mut depth: fidl::encoding::Depth,
20262 ) -> fidl::Result<()> {
20263 decoder.debug_check_bounds::<Self>(offset);
20264 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
20265 None => return Err(fidl::Error::NotNullable),
20266 Some(len) => len,
20267 };
20268 if len == 0 {
20270 return Ok(());
20271 };
20272 depth.increment()?;
20273 let envelope_size = 8;
20274 let bytes_len = len * envelope_size;
20275 let offset = decoder.out_of_line_offset(bytes_len)?;
20276 let mut _next_ordinal_to_read = 0;
20278 let mut next_offset = offset;
20279 let end_offset = offset + bytes_len;
20280 _next_ordinal_to_read += 1;
20281 if next_offset >= end_offset {
20282 return Ok(());
20283 }
20284
20285 while _next_ordinal_to_read < 1 {
20287 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20288 _next_ordinal_to_read += 1;
20289 next_offset += envelope_size;
20290 }
20291
20292 let next_out_of_line = decoder.next_out_of_line();
20293 let handles_before = decoder.remaining_handles();
20294 if let Some((inlined, num_bytes, num_handles)) =
20295 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20296 {
20297 let member_inline_size =
20298 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20299 decoder.context,
20300 );
20301 if inlined != (member_inline_size <= 4) {
20302 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20303 }
20304 let inner_offset;
20305 let mut inner_depth = depth.clone();
20306 if inlined {
20307 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20308 inner_offset = next_offset;
20309 } else {
20310 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20311 inner_depth.increment()?;
20312 }
20313 let val_ref = self
20314 .resolver
20315 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20316 fidl::decode!(
20317 fidl::encoding::BoundedString<100>,
20318 D,
20319 val_ref,
20320 decoder,
20321 inner_offset,
20322 inner_depth
20323 )?;
20324 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20325 {
20326 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20327 }
20328 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20329 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20330 }
20331 }
20332
20333 next_offset += envelope_size;
20334 _next_ordinal_to_read += 1;
20335 if next_offset >= end_offset {
20336 return Ok(());
20337 }
20338
20339 while _next_ordinal_to_read < 2 {
20341 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20342 _next_ordinal_to_read += 1;
20343 next_offset += envelope_size;
20344 }
20345
20346 let next_out_of_line = decoder.next_out_of_line();
20347 let handles_before = decoder.remaining_handles();
20348 if let Some((inlined, num_bytes, num_handles)) =
20349 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20350 {
20351 let member_inline_size =
20352 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20353 if inlined != (member_inline_size <= 4) {
20354 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20355 }
20356 let inner_offset;
20357 let mut inner_depth = depth.clone();
20358 if inlined {
20359 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20360 inner_offset = next_offset;
20361 } else {
20362 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20363 inner_depth.increment()?;
20364 }
20365 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
20366 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
20367 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20368 {
20369 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20370 }
20371 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20372 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20373 }
20374 }
20375
20376 next_offset += envelope_size;
20377 _next_ordinal_to_read += 1;
20378 if next_offset >= end_offset {
20379 return Ok(());
20380 }
20381
20382 while _next_ordinal_to_read < 3 {
20384 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20385 _next_ordinal_to_read += 1;
20386 next_offset += envelope_size;
20387 }
20388
20389 let next_out_of_line = decoder.next_out_of_line();
20390 let handles_before = decoder.remaining_handles();
20391 if let Some((inlined, num_bytes, num_handles)) =
20392 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20393 {
20394 let member_inline_size =
20395 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20396 decoder.context,
20397 );
20398 if inlined != (member_inline_size <= 4) {
20399 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20400 }
20401 let inner_offset;
20402 let mut inner_depth = depth.clone();
20403 if inlined {
20404 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20405 inner_offset = next_offset;
20406 } else {
20407 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20408 inner_depth.increment()?;
20409 }
20410 let val_ref = self
20411 .scheme
20412 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20413 fidl::decode!(
20414 fidl::encoding::BoundedString<100>,
20415 D,
20416 val_ref,
20417 decoder,
20418 inner_offset,
20419 inner_depth
20420 )?;
20421 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20422 {
20423 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20424 }
20425 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20426 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20427 }
20428 }
20429
20430 next_offset += envelope_size;
20431
20432 while next_offset < end_offset {
20434 _next_ordinal_to_read += 1;
20435 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20436 next_offset += envelope_size;
20437 }
20438
20439 Ok(())
20440 }
20441 }
20442
20443 impl Runner {
20444 #[inline(always)]
20445 fn max_ordinal_present(&self) -> u64 {
20446 if let Some(_) = self.source_path {
20447 return 2;
20448 }
20449 if let Some(_) = self.name {
20450 return 1;
20451 }
20452 0
20453 }
20454 }
20455
20456 impl fidl::encoding::ValueTypeMarker for Runner {
20457 type Borrowed<'a> = &'a Self;
20458 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
20459 value
20460 }
20461 }
20462
20463 unsafe impl fidl::encoding::TypeMarker for Runner {
20464 type Owned = Self;
20465
20466 #[inline(always)]
20467 fn inline_align(_context: fidl::encoding::Context) -> usize {
20468 8
20469 }
20470
20471 #[inline(always)]
20472 fn inline_size(_context: fidl::encoding::Context) -> usize {
20473 16
20474 }
20475 }
20476
20477 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Runner, D> for &Runner {
20478 unsafe fn encode(
20479 self,
20480 encoder: &mut fidl::encoding::Encoder<'_, D>,
20481 offset: usize,
20482 mut depth: fidl::encoding::Depth,
20483 ) -> fidl::Result<()> {
20484 encoder.debug_check_bounds::<Runner>(offset);
20485 let max_ordinal: u64 = self.max_ordinal_present();
20487 encoder.write_num(max_ordinal, offset);
20488 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
20489 if max_ordinal == 0 {
20491 return Ok(());
20492 }
20493 depth.increment()?;
20494 let envelope_size = 8;
20495 let bytes_len = max_ordinal as usize * envelope_size;
20496 #[allow(unused_variables)]
20497 let offset = encoder.out_of_line_offset(bytes_len);
20498 let mut _prev_end_offset: usize = 0;
20499 if 1 > max_ordinal {
20500 return Ok(());
20501 }
20502
20503 let cur_offset: usize = (1 - 1) * envelope_size;
20506
20507 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20509
20510 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
20515 self.name.as_ref().map(
20516 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
20517 ),
20518 encoder,
20519 offset + cur_offset,
20520 depth,
20521 )?;
20522
20523 _prev_end_offset = cur_offset + envelope_size;
20524 if 2 > max_ordinal {
20525 return Ok(());
20526 }
20527
20528 let cur_offset: usize = (2 - 1) * envelope_size;
20531
20532 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20534
20535 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
20540 self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
20541 encoder, offset + cur_offset, depth
20542 )?;
20543
20544 _prev_end_offset = cur_offset + envelope_size;
20545
20546 Ok(())
20547 }
20548 }
20549
20550 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Runner {
20551 #[inline(always)]
20552 fn new_empty() -> Self {
20553 Self::default()
20554 }
20555
20556 unsafe fn decode(
20557 &mut self,
20558 decoder: &mut fidl::encoding::Decoder<'_, D>,
20559 offset: usize,
20560 mut depth: fidl::encoding::Depth,
20561 ) -> fidl::Result<()> {
20562 decoder.debug_check_bounds::<Self>(offset);
20563 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
20564 None => return Err(fidl::Error::NotNullable),
20565 Some(len) => len,
20566 };
20567 if len == 0 {
20569 return Ok(());
20570 };
20571 depth.increment()?;
20572 let envelope_size = 8;
20573 let bytes_len = len * envelope_size;
20574 let offset = decoder.out_of_line_offset(bytes_len)?;
20575 let mut _next_ordinal_to_read = 0;
20577 let mut next_offset = offset;
20578 let end_offset = offset + bytes_len;
20579 _next_ordinal_to_read += 1;
20580 if next_offset >= end_offset {
20581 return Ok(());
20582 }
20583
20584 while _next_ordinal_to_read < 1 {
20586 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20587 _next_ordinal_to_read += 1;
20588 next_offset += envelope_size;
20589 }
20590
20591 let next_out_of_line = decoder.next_out_of_line();
20592 let handles_before = decoder.remaining_handles();
20593 if let Some((inlined, num_bytes, num_handles)) =
20594 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20595 {
20596 let member_inline_size =
20597 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20598 decoder.context,
20599 );
20600 if inlined != (member_inline_size <= 4) {
20601 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20602 }
20603 let inner_offset;
20604 let mut inner_depth = depth.clone();
20605 if inlined {
20606 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20607 inner_offset = next_offset;
20608 } else {
20609 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20610 inner_depth.increment()?;
20611 }
20612 let val_ref = self
20613 .name
20614 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20615 fidl::decode!(
20616 fidl::encoding::BoundedString<100>,
20617 D,
20618 val_ref,
20619 decoder,
20620 inner_offset,
20621 inner_depth
20622 )?;
20623 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20624 {
20625 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20626 }
20627 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20628 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20629 }
20630 }
20631
20632 next_offset += envelope_size;
20633 _next_ordinal_to_read += 1;
20634 if next_offset >= end_offset {
20635 return Ok(());
20636 }
20637
20638 while _next_ordinal_to_read < 2 {
20640 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20641 _next_ordinal_to_read += 1;
20642 next_offset += envelope_size;
20643 }
20644
20645 let next_out_of_line = decoder.next_out_of_line();
20646 let handles_before = decoder.remaining_handles();
20647 if let Some((inlined, num_bytes, num_handles)) =
20648 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20649 {
20650 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20651 if inlined != (member_inline_size <= 4) {
20652 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20653 }
20654 let inner_offset;
20655 let mut inner_depth = depth.clone();
20656 if inlined {
20657 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20658 inner_offset = next_offset;
20659 } else {
20660 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20661 inner_depth.increment()?;
20662 }
20663 let val_ref = self.source_path.get_or_insert_with(|| {
20664 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
20665 });
20666 fidl::decode!(
20667 fidl::encoding::BoundedString<1024>,
20668 D,
20669 val_ref,
20670 decoder,
20671 inner_offset,
20672 inner_depth
20673 )?;
20674 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20675 {
20676 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20677 }
20678 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20679 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20680 }
20681 }
20682
20683 next_offset += envelope_size;
20684
20685 while next_offset < end_offset {
20687 _next_ordinal_to_read += 1;
20688 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20689 next_offset += envelope_size;
20690 }
20691
20692 Ok(())
20693 }
20694 }
20695
20696 impl RunnerRegistration {
20697 #[inline(always)]
20698 fn max_ordinal_present(&self) -> u64 {
20699 if let Some(_) = self.target_name {
20700 return 3;
20701 }
20702 if let Some(_) = self.source {
20703 return 2;
20704 }
20705 if let Some(_) = self.source_name {
20706 return 1;
20707 }
20708 0
20709 }
20710 }
20711
20712 impl fidl::encoding::ValueTypeMarker for RunnerRegistration {
20713 type Borrowed<'a> = &'a Self;
20714 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
20715 value
20716 }
20717 }
20718
20719 unsafe impl fidl::encoding::TypeMarker for RunnerRegistration {
20720 type Owned = Self;
20721
20722 #[inline(always)]
20723 fn inline_align(_context: fidl::encoding::Context) -> usize {
20724 8
20725 }
20726
20727 #[inline(always)]
20728 fn inline_size(_context: fidl::encoding::Context) -> usize {
20729 16
20730 }
20731 }
20732
20733 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RunnerRegistration, D>
20734 for &RunnerRegistration
20735 {
20736 unsafe fn encode(
20737 self,
20738 encoder: &mut fidl::encoding::Encoder<'_, D>,
20739 offset: usize,
20740 mut depth: fidl::encoding::Depth,
20741 ) -> fidl::Result<()> {
20742 encoder.debug_check_bounds::<RunnerRegistration>(offset);
20743 let max_ordinal: u64 = self.max_ordinal_present();
20745 encoder.write_num(max_ordinal, offset);
20746 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
20747 if max_ordinal == 0 {
20749 return Ok(());
20750 }
20751 depth.increment()?;
20752 let envelope_size = 8;
20753 let bytes_len = max_ordinal as usize * envelope_size;
20754 #[allow(unused_variables)]
20755 let offset = encoder.out_of_line_offset(bytes_len);
20756 let mut _prev_end_offset: usize = 0;
20757 if 1 > max_ordinal {
20758 return Ok(());
20759 }
20760
20761 let cur_offset: usize = (1 - 1) * envelope_size;
20764
20765 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20767
20768 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
20773 self.source_name.as_ref().map(
20774 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
20775 ),
20776 encoder,
20777 offset + cur_offset,
20778 depth,
20779 )?;
20780
20781 _prev_end_offset = cur_offset + envelope_size;
20782 if 2 > max_ordinal {
20783 return Ok(());
20784 }
20785
20786 let cur_offset: usize = (2 - 1) * envelope_size;
20789
20790 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20792
20793 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
20798 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
20799 encoder,
20800 offset + cur_offset,
20801 depth,
20802 )?;
20803
20804 _prev_end_offset = cur_offset + envelope_size;
20805 if 3 > max_ordinal {
20806 return Ok(());
20807 }
20808
20809 let cur_offset: usize = (3 - 1) * envelope_size;
20812
20813 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20815
20816 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
20821 self.target_name.as_ref().map(
20822 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
20823 ),
20824 encoder,
20825 offset + cur_offset,
20826 depth,
20827 )?;
20828
20829 _prev_end_offset = cur_offset + envelope_size;
20830
20831 Ok(())
20832 }
20833 }
20834
20835 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RunnerRegistration {
20836 #[inline(always)]
20837 fn new_empty() -> Self {
20838 Self::default()
20839 }
20840
20841 unsafe fn decode(
20842 &mut self,
20843 decoder: &mut fidl::encoding::Decoder<'_, D>,
20844 offset: usize,
20845 mut depth: fidl::encoding::Depth,
20846 ) -> fidl::Result<()> {
20847 decoder.debug_check_bounds::<Self>(offset);
20848 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
20849 None => return Err(fidl::Error::NotNullable),
20850 Some(len) => len,
20851 };
20852 if len == 0 {
20854 return Ok(());
20855 };
20856 depth.increment()?;
20857 let envelope_size = 8;
20858 let bytes_len = len * envelope_size;
20859 let offset = decoder.out_of_line_offset(bytes_len)?;
20860 let mut _next_ordinal_to_read = 0;
20862 let mut next_offset = offset;
20863 let end_offset = offset + bytes_len;
20864 _next_ordinal_to_read += 1;
20865 if next_offset >= end_offset {
20866 return Ok(());
20867 }
20868
20869 while _next_ordinal_to_read < 1 {
20871 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20872 _next_ordinal_to_read += 1;
20873 next_offset += envelope_size;
20874 }
20875
20876 let next_out_of_line = decoder.next_out_of_line();
20877 let handles_before = decoder.remaining_handles();
20878 if let Some((inlined, num_bytes, num_handles)) =
20879 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20880 {
20881 let member_inline_size =
20882 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20883 decoder.context,
20884 );
20885 if inlined != (member_inline_size <= 4) {
20886 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20887 }
20888 let inner_offset;
20889 let mut inner_depth = depth.clone();
20890 if inlined {
20891 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20892 inner_offset = next_offset;
20893 } else {
20894 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20895 inner_depth.increment()?;
20896 }
20897 let val_ref = self
20898 .source_name
20899 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20900 fidl::decode!(
20901 fidl::encoding::BoundedString<100>,
20902 D,
20903 val_ref,
20904 decoder,
20905 inner_offset,
20906 inner_depth
20907 )?;
20908 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20909 {
20910 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20911 }
20912 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20913 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20914 }
20915 }
20916
20917 next_offset += envelope_size;
20918 _next_ordinal_to_read += 1;
20919 if next_offset >= end_offset {
20920 return Ok(());
20921 }
20922
20923 while _next_ordinal_to_read < 2 {
20925 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20926 _next_ordinal_to_read += 1;
20927 next_offset += envelope_size;
20928 }
20929
20930 let next_out_of_line = decoder.next_out_of_line();
20931 let handles_before = decoder.remaining_handles();
20932 if let Some((inlined, num_bytes, num_handles)) =
20933 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20934 {
20935 let member_inline_size =
20936 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20937 if inlined != (member_inline_size <= 4) {
20938 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20939 }
20940 let inner_offset;
20941 let mut inner_depth = depth.clone();
20942 if inlined {
20943 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20944 inner_offset = next_offset;
20945 } else {
20946 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20947 inner_depth.increment()?;
20948 }
20949 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
20950 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
20951 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20952 {
20953 return Err(fidl::Error::InvalidNumBytesInEnvelope);
20954 }
20955 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20956 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20957 }
20958 }
20959
20960 next_offset += envelope_size;
20961 _next_ordinal_to_read += 1;
20962 if next_offset >= end_offset {
20963 return Ok(());
20964 }
20965
20966 while _next_ordinal_to_read < 3 {
20968 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20969 _next_ordinal_to_read += 1;
20970 next_offset += envelope_size;
20971 }
20972
20973 let next_out_of_line = decoder.next_out_of_line();
20974 let handles_before = decoder.remaining_handles();
20975 if let Some((inlined, num_bytes, num_handles)) =
20976 fidl::encoding::decode_envelope_header(decoder, next_offset)?
20977 {
20978 let member_inline_size =
20979 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20980 decoder.context,
20981 );
20982 if inlined != (member_inline_size <= 4) {
20983 return Err(fidl::Error::InvalidInlineBitInEnvelope);
20984 }
20985 let inner_offset;
20986 let mut inner_depth = depth.clone();
20987 if inlined {
20988 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20989 inner_offset = next_offset;
20990 } else {
20991 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20992 inner_depth.increment()?;
20993 }
20994 let val_ref = self
20995 .target_name
20996 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20997 fidl::decode!(
20998 fidl::encoding::BoundedString<100>,
20999 D,
21000 val_ref,
21001 decoder,
21002 inner_offset,
21003 inner_depth
21004 )?;
21005 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21006 {
21007 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21008 }
21009 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21010 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21011 }
21012 }
21013
21014 next_offset += envelope_size;
21015
21016 while next_offset < end_offset {
21018 _next_ordinal_to_read += 1;
21019 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21020 next_offset += envelope_size;
21021 }
21022
21023 Ok(())
21024 }
21025 }
21026
21027 impl Service {
21028 #[inline(always)]
21029 fn max_ordinal_present(&self) -> u64 {
21030 if let Some(_) = self.source_path {
21031 return 2;
21032 }
21033 if let Some(_) = self.name {
21034 return 1;
21035 }
21036 0
21037 }
21038 }
21039
21040 impl fidl::encoding::ValueTypeMarker for Service {
21041 type Borrowed<'a> = &'a Self;
21042 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21043 value
21044 }
21045 }
21046
21047 unsafe impl fidl::encoding::TypeMarker for Service {
21048 type Owned = Self;
21049
21050 #[inline(always)]
21051 fn inline_align(_context: fidl::encoding::Context) -> usize {
21052 8
21053 }
21054
21055 #[inline(always)]
21056 fn inline_size(_context: fidl::encoding::Context) -> usize {
21057 16
21058 }
21059 }
21060
21061 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Service, D> for &Service {
21062 unsafe fn encode(
21063 self,
21064 encoder: &mut fidl::encoding::Encoder<'_, D>,
21065 offset: usize,
21066 mut depth: fidl::encoding::Depth,
21067 ) -> fidl::Result<()> {
21068 encoder.debug_check_bounds::<Service>(offset);
21069 let max_ordinal: u64 = self.max_ordinal_present();
21071 encoder.write_num(max_ordinal, offset);
21072 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21073 if max_ordinal == 0 {
21075 return Ok(());
21076 }
21077 depth.increment()?;
21078 let envelope_size = 8;
21079 let bytes_len = max_ordinal as usize * envelope_size;
21080 #[allow(unused_variables)]
21081 let offset = encoder.out_of_line_offset(bytes_len);
21082 let mut _prev_end_offset: usize = 0;
21083 if 1 > max_ordinal {
21084 return Ok(());
21085 }
21086
21087 let cur_offset: usize = (1 - 1) * envelope_size;
21090
21091 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21093
21094 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
21099 self.name.as_ref().map(
21100 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
21101 ),
21102 encoder,
21103 offset + cur_offset,
21104 depth,
21105 )?;
21106
21107 _prev_end_offset = cur_offset + envelope_size;
21108 if 2 > max_ordinal {
21109 return Ok(());
21110 }
21111
21112 let cur_offset: usize = (2 - 1) * envelope_size;
21115
21116 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21118
21119 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
21124 self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
21125 encoder, offset + cur_offset, depth
21126 )?;
21127
21128 _prev_end_offset = cur_offset + envelope_size;
21129
21130 Ok(())
21131 }
21132 }
21133
21134 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Service {
21135 #[inline(always)]
21136 fn new_empty() -> Self {
21137 Self::default()
21138 }
21139
21140 unsafe fn decode(
21141 &mut self,
21142 decoder: &mut fidl::encoding::Decoder<'_, D>,
21143 offset: usize,
21144 mut depth: fidl::encoding::Depth,
21145 ) -> fidl::Result<()> {
21146 decoder.debug_check_bounds::<Self>(offset);
21147 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21148 None => return Err(fidl::Error::NotNullable),
21149 Some(len) => len,
21150 };
21151 if len == 0 {
21153 return Ok(());
21154 };
21155 depth.increment()?;
21156 let envelope_size = 8;
21157 let bytes_len = len * envelope_size;
21158 let offset = decoder.out_of_line_offset(bytes_len)?;
21159 let mut _next_ordinal_to_read = 0;
21161 let mut next_offset = offset;
21162 let end_offset = offset + bytes_len;
21163 _next_ordinal_to_read += 1;
21164 if next_offset >= end_offset {
21165 return Ok(());
21166 }
21167
21168 while _next_ordinal_to_read < 1 {
21170 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21171 _next_ordinal_to_read += 1;
21172 next_offset += envelope_size;
21173 }
21174
21175 let next_out_of_line = decoder.next_out_of_line();
21176 let handles_before = decoder.remaining_handles();
21177 if let Some((inlined, num_bytes, num_handles)) =
21178 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21179 {
21180 let member_inline_size =
21181 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
21182 decoder.context,
21183 );
21184 if inlined != (member_inline_size <= 4) {
21185 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21186 }
21187 let inner_offset;
21188 let mut inner_depth = depth.clone();
21189 if inlined {
21190 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21191 inner_offset = next_offset;
21192 } else {
21193 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21194 inner_depth.increment()?;
21195 }
21196 let val_ref = self
21197 .name
21198 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
21199 fidl::decode!(
21200 fidl::encoding::BoundedString<100>,
21201 D,
21202 val_ref,
21203 decoder,
21204 inner_offset,
21205 inner_depth
21206 )?;
21207 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21208 {
21209 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21210 }
21211 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21212 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21213 }
21214 }
21215
21216 next_offset += envelope_size;
21217 _next_ordinal_to_read += 1;
21218 if next_offset >= end_offset {
21219 return Ok(());
21220 }
21221
21222 while _next_ordinal_to_read < 2 {
21224 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21225 _next_ordinal_to_read += 1;
21226 next_offset += envelope_size;
21227 }
21228
21229 let next_out_of_line = decoder.next_out_of_line();
21230 let handles_before = decoder.remaining_handles();
21231 if let Some((inlined, num_bytes, num_handles)) =
21232 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21233 {
21234 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21235 if inlined != (member_inline_size <= 4) {
21236 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21237 }
21238 let inner_offset;
21239 let mut inner_depth = depth.clone();
21240 if inlined {
21241 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21242 inner_offset = next_offset;
21243 } else {
21244 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21245 inner_depth.increment()?;
21246 }
21247 let val_ref = self.source_path.get_or_insert_with(|| {
21248 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
21249 });
21250 fidl::decode!(
21251 fidl::encoding::BoundedString<1024>,
21252 D,
21253 val_ref,
21254 decoder,
21255 inner_offset,
21256 inner_depth
21257 )?;
21258 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21259 {
21260 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21261 }
21262 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21263 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21264 }
21265 }
21266
21267 next_offset += envelope_size;
21268
21269 while next_offset < end_offset {
21271 _next_ordinal_to_read += 1;
21272 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21273 next_offset += envelope_size;
21274 }
21275
21276 Ok(())
21277 }
21278 }
21279
21280 impl Storage {
21281 #[inline(always)]
21282 fn max_ordinal_present(&self) -> u64 {
21283 if let Some(_) = self.storage_id {
21284 return 5;
21285 }
21286 if let Some(_) = self.subdir {
21287 return 4;
21288 }
21289 if let Some(_) = self.backing_dir {
21290 return 3;
21291 }
21292 if let Some(_) = self.source {
21293 return 2;
21294 }
21295 if let Some(_) = self.name {
21296 return 1;
21297 }
21298 0
21299 }
21300 }
21301
21302 impl fidl::encoding::ValueTypeMarker for Storage {
21303 type Borrowed<'a> = &'a Self;
21304 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21305 value
21306 }
21307 }
21308
21309 unsafe impl fidl::encoding::TypeMarker for Storage {
21310 type Owned = Self;
21311
21312 #[inline(always)]
21313 fn inline_align(_context: fidl::encoding::Context) -> usize {
21314 8
21315 }
21316
21317 #[inline(always)]
21318 fn inline_size(_context: fidl::encoding::Context) -> usize {
21319 16
21320 }
21321 }
21322
21323 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Storage, D> for &Storage {
21324 unsafe fn encode(
21325 self,
21326 encoder: &mut fidl::encoding::Encoder<'_, D>,
21327 offset: usize,
21328 mut depth: fidl::encoding::Depth,
21329 ) -> fidl::Result<()> {
21330 encoder.debug_check_bounds::<Storage>(offset);
21331 let max_ordinal: u64 = self.max_ordinal_present();
21333 encoder.write_num(max_ordinal, offset);
21334 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21335 if max_ordinal == 0 {
21337 return Ok(());
21338 }
21339 depth.increment()?;
21340 let envelope_size = 8;
21341 let bytes_len = max_ordinal as usize * envelope_size;
21342 #[allow(unused_variables)]
21343 let offset = encoder.out_of_line_offset(bytes_len);
21344 let mut _prev_end_offset: usize = 0;
21345 if 1 > max_ordinal {
21346 return Ok(());
21347 }
21348
21349 let cur_offset: usize = (1 - 1) * envelope_size;
21352
21353 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21355
21356 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
21361 self.name.as_ref().map(
21362 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
21363 ),
21364 encoder,
21365 offset + cur_offset,
21366 depth,
21367 )?;
21368
21369 _prev_end_offset = cur_offset + envelope_size;
21370 if 2 > max_ordinal {
21371 return Ok(());
21372 }
21373
21374 let cur_offset: usize = (2 - 1) * envelope_size;
21377
21378 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21380
21381 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
21386 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
21387 encoder,
21388 offset + cur_offset,
21389 depth,
21390 )?;
21391
21392 _prev_end_offset = cur_offset + envelope_size;
21393 if 3 > max_ordinal {
21394 return Ok(());
21395 }
21396
21397 let cur_offset: usize = (3 - 1) * envelope_size;
21400
21401 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21403
21404 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
21409 self.backing_dir.as_ref().map(
21410 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
21411 ),
21412 encoder,
21413 offset + cur_offset,
21414 depth,
21415 )?;
21416
21417 _prev_end_offset = cur_offset + envelope_size;
21418 if 4 > max_ordinal {
21419 return Ok(());
21420 }
21421
21422 let cur_offset: usize = (4 - 1) * envelope_size;
21425
21426 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21428
21429 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
21434 self.subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
21435 encoder, offset + cur_offset, depth
21436 )?;
21437
21438 _prev_end_offset = cur_offset + envelope_size;
21439 if 5 > max_ordinal {
21440 return Ok(());
21441 }
21442
21443 let cur_offset: usize = (5 - 1) * envelope_size;
21446
21447 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21449
21450 fidl::encoding::encode_in_envelope_optional::<StorageId, D>(
21455 self.storage_id
21456 .as_ref()
21457 .map(<StorageId as fidl::encoding::ValueTypeMarker>::borrow),
21458 encoder,
21459 offset + cur_offset,
21460 depth,
21461 )?;
21462
21463 _prev_end_offset = cur_offset + envelope_size;
21464
21465 Ok(())
21466 }
21467 }
21468
21469 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Storage {
21470 #[inline(always)]
21471 fn new_empty() -> Self {
21472 Self::default()
21473 }
21474
21475 unsafe fn decode(
21476 &mut self,
21477 decoder: &mut fidl::encoding::Decoder<'_, D>,
21478 offset: usize,
21479 mut depth: fidl::encoding::Depth,
21480 ) -> fidl::Result<()> {
21481 decoder.debug_check_bounds::<Self>(offset);
21482 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21483 None => return Err(fidl::Error::NotNullable),
21484 Some(len) => len,
21485 };
21486 if len == 0 {
21488 return Ok(());
21489 };
21490 depth.increment()?;
21491 let envelope_size = 8;
21492 let bytes_len = len * envelope_size;
21493 let offset = decoder.out_of_line_offset(bytes_len)?;
21494 let mut _next_ordinal_to_read = 0;
21496 let mut next_offset = offset;
21497 let end_offset = offset + bytes_len;
21498 _next_ordinal_to_read += 1;
21499 if next_offset >= end_offset {
21500 return Ok(());
21501 }
21502
21503 while _next_ordinal_to_read < 1 {
21505 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21506 _next_ordinal_to_read += 1;
21507 next_offset += envelope_size;
21508 }
21509
21510 let next_out_of_line = decoder.next_out_of_line();
21511 let handles_before = decoder.remaining_handles();
21512 if let Some((inlined, num_bytes, num_handles)) =
21513 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21514 {
21515 let member_inline_size =
21516 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
21517 decoder.context,
21518 );
21519 if inlined != (member_inline_size <= 4) {
21520 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21521 }
21522 let inner_offset;
21523 let mut inner_depth = depth.clone();
21524 if inlined {
21525 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21526 inner_offset = next_offset;
21527 } else {
21528 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21529 inner_depth.increment()?;
21530 }
21531 let val_ref = self
21532 .name
21533 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
21534 fidl::decode!(
21535 fidl::encoding::BoundedString<100>,
21536 D,
21537 val_ref,
21538 decoder,
21539 inner_offset,
21540 inner_depth
21541 )?;
21542 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21543 {
21544 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21545 }
21546 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21547 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21548 }
21549 }
21550
21551 next_offset += envelope_size;
21552 _next_ordinal_to_read += 1;
21553 if next_offset >= end_offset {
21554 return Ok(());
21555 }
21556
21557 while _next_ordinal_to_read < 2 {
21559 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21560 _next_ordinal_to_read += 1;
21561 next_offset += envelope_size;
21562 }
21563
21564 let next_out_of_line = decoder.next_out_of_line();
21565 let handles_before = decoder.remaining_handles();
21566 if let Some((inlined, num_bytes, num_handles)) =
21567 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21568 {
21569 let member_inline_size =
21570 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21571 if inlined != (member_inline_size <= 4) {
21572 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21573 }
21574 let inner_offset;
21575 let mut inner_depth = depth.clone();
21576 if inlined {
21577 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21578 inner_offset = next_offset;
21579 } else {
21580 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21581 inner_depth.increment()?;
21582 }
21583 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
21584 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
21585 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21586 {
21587 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21588 }
21589 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21590 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21591 }
21592 }
21593
21594 next_offset += envelope_size;
21595 _next_ordinal_to_read += 1;
21596 if next_offset >= end_offset {
21597 return Ok(());
21598 }
21599
21600 while _next_ordinal_to_read < 3 {
21602 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21603 _next_ordinal_to_read += 1;
21604 next_offset += envelope_size;
21605 }
21606
21607 let next_out_of_line = decoder.next_out_of_line();
21608 let handles_before = decoder.remaining_handles();
21609 if let Some((inlined, num_bytes, num_handles)) =
21610 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21611 {
21612 let member_inline_size =
21613 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
21614 decoder.context,
21615 );
21616 if inlined != (member_inline_size <= 4) {
21617 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21618 }
21619 let inner_offset;
21620 let mut inner_depth = depth.clone();
21621 if inlined {
21622 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21623 inner_offset = next_offset;
21624 } else {
21625 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21626 inner_depth.increment()?;
21627 }
21628 let val_ref = self
21629 .backing_dir
21630 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
21631 fidl::decode!(
21632 fidl::encoding::BoundedString<100>,
21633 D,
21634 val_ref,
21635 decoder,
21636 inner_offset,
21637 inner_depth
21638 )?;
21639 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21640 {
21641 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21642 }
21643 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21644 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21645 }
21646 }
21647
21648 next_offset += envelope_size;
21649 _next_ordinal_to_read += 1;
21650 if next_offset >= end_offset {
21651 return Ok(());
21652 }
21653
21654 while _next_ordinal_to_read < 4 {
21656 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21657 _next_ordinal_to_read += 1;
21658 next_offset += envelope_size;
21659 }
21660
21661 let next_out_of_line = decoder.next_out_of_line();
21662 let handles_before = decoder.remaining_handles();
21663 if let Some((inlined, num_bytes, num_handles)) =
21664 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21665 {
21666 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21667 if inlined != (member_inline_size <= 4) {
21668 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21669 }
21670 let inner_offset;
21671 let mut inner_depth = depth.clone();
21672 if inlined {
21673 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21674 inner_offset = next_offset;
21675 } else {
21676 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21677 inner_depth.increment()?;
21678 }
21679 let val_ref = self.subdir.get_or_insert_with(|| {
21680 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
21681 });
21682 fidl::decode!(
21683 fidl::encoding::BoundedString<1024>,
21684 D,
21685 val_ref,
21686 decoder,
21687 inner_offset,
21688 inner_depth
21689 )?;
21690 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21691 {
21692 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21693 }
21694 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21695 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21696 }
21697 }
21698
21699 next_offset += envelope_size;
21700 _next_ordinal_to_read += 1;
21701 if next_offset >= end_offset {
21702 return Ok(());
21703 }
21704
21705 while _next_ordinal_to_read < 5 {
21707 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21708 _next_ordinal_to_read += 1;
21709 next_offset += envelope_size;
21710 }
21711
21712 let next_out_of_line = decoder.next_out_of_line();
21713 let handles_before = decoder.remaining_handles();
21714 if let Some((inlined, num_bytes, num_handles)) =
21715 fidl::encoding::decode_envelope_header(decoder, next_offset)?
21716 {
21717 let member_inline_size =
21718 <StorageId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21719 if inlined != (member_inline_size <= 4) {
21720 return Err(fidl::Error::InvalidInlineBitInEnvelope);
21721 }
21722 let inner_offset;
21723 let mut inner_depth = depth.clone();
21724 if inlined {
21725 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21726 inner_offset = next_offset;
21727 } else {
21728 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21729 inner_depth.increment()?;
21730 }
21731 let val_ref = self.storage_id.get_or_insert_with(|| fidl::new_empty!(StorageId, D));
21732 fidl::decode!(StorageId, D, val_ref, decoder, inner_offset, inner_depth)?;
21733 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21734 {
21735 return Err(fidl::Error::InvalidNumBytesInEnvelope);
21736 }
21737 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21738 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21739 }
21740 }
21741
21742 next_offset += envelope_size;
21743
21744 while next_offset < end_offset {
21746 _next_ordinal_to_read += 1;
21747 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21748 next_offset += envelope_size;
21749 }
21750
21751 Ok(())
21752 }
21753 }
21754
21755 impl UseConfiguration {
21756 #[inline(always)]
21757 fn max_ordinal_present(&self) -> u64 {
21758 if let Some(_) = self.source_dictionary {
21759 return 7;
21760 }
21761 if let Some(_) = self.default {
21762 return 6;
21763 }
21764 if let Some(_) = self.type_ {
21765 return 5;
21766 }
21767 if let Some(_) = self.availability {
21768 return 4;
21769 }
21770 if let Some(_) = self.target_name {
21771 return 3;
21772 }
21773 if let Some(_) = self.source_name {
21774 return 2;
21775 }
21776 if let Some(_) = self.source {
21777 return 1;
21778 }
21779 0
21780 }
21781 }
21782
21783 impl fidl::encoding::ValueTypeMarker for UseConfiguration {
21784 type Borrowed<'a> = &'a Self;
21785 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21786 value
21787 }
21788 }
21789
21790 unsafe impl fidl::encoding::TypeMarker for UseConfiguration {
21791 type Owned = Self;
21792
21793 #[inline(always)]
21794 fn inline_align(_context: fidl::encoding::Context) -> usize {
21795 8
21796 }
21797
21798 #[inline(always)]
21799 fn inline_size(_context: fidl::encoding::Context) -> usize {
21800 16
21801 }
21802 }
21803
21804 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseConfiguration, D>
21805 for &UseConfiguration
21806 {
21807 unsafe fn encode(
21808 self,
21809 encoder: &mut fidl::encoding::Encoder<'_, D>,
21810 offset: usize,
21811 mut depth: fidl::encoding::Depth,
21812 ) -> fidl::Result<()> {
21813 encoder.debug_check_bounds::<UseConfiguration>(offset);
21814 let max_ordinal: u64 = self.max_ordinal_present();
21816 encoder.write_num(max_ordinal, offset);
21817 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21818 if max_ordinal == 0 {
21820 return Ok(());
21821 }
21822 depth.increment()?;
21823 let envelope_size = 8;
21824 let bytes_len = max_ordinal as usize * envelope_size;
21825 #[allow(unused_variables)]
21826 let offset = encoder.out_of_line_offset(bytes_len);
21827 let mut _prev_end_offset: usize = 0;
21828 if 1 > max_ordinal {
21829 return Ok(());
21830 }
21831
21832 let cur_offset: usize = (1 - 1) * envelope_size;
21835
21836 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21838
21839 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
21844 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
21845 encoder,
21846 offset + cur_offset,
21847 depth,
21848 )?;
21849
21850 _prev_end_offset = cur_offset + envelope_size;
21851 if 2 > max_ordinal {
21852 return Ok(());
21853 }
21854
21855 let cur_offset: usize = (2 - 1) * envelope_size;
21858
21859 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21861
21862 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
21867 self.source_name.as_ref().map(
21868 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
21869 ),
21870 encoder,
21871 offset + cur_offset,
21872 depth,
21873 )?;
21874
21875 _prev_end_offset = cur_offset + envelope_size;
21876 if 3 > max_ordinal {
21877 return Ok(());
21878 }
21879
21880 let cur_offset: usize = (3 - 1) * envelope_size;
21883
21884 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21886
21887 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
21892 self.target_name.as_ref().map(
21893 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
21894 ),
21895 encoder,
21896 offset + cur_offset,
21897 depth,
21898 )?;
21899
21900 _prev_end_offset = cur_offset + envelope_size;
21901 if 4 > max_ordinal {
21902 return Ok(());
21903 }
21904
21905 let cur_offset: usize = (4 - 1) * envelope_size;
21908
21909 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21911
21912 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
21917 self.availability
21918 .as_ref()
21919 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
21920 encoder,
21921 offset + cur_offset,
21922 depth,
21923 )?;
21924
21925 _prev_end_offset = cur_offset + envelope_size;
21926 if 5 > max_ordinal {
21927 return Ok(());
21928 }
21929
21930 let cur_offset: usize = (5 - 1) * envelope_size;
21933
21934 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21936
21937 fidl::encoding::encode_in_envelope_optional::<ConfigType, D>(
21942 self.type_.as_ref().map(<ConfigType as fidl::encoding::ValueTypeMarker>::borrow),
21943 encoder,
21944 offset + cur_offset,
21945 depth,
21946 )?;
21947
21948 _prev_end_offset = cur_offset + envelope_size;
21949 if 6 > max_ordinal {
21950 return Ok(());
21951 }
21952
21953 let cur_offset: usize = (6 - 1) * envelope_size;
21956
21957 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21959
21960 fidl::encoding::encode_in_envelope_optional::<ConfigValue, D>(
21965 self.default.as_ref().map(<ConfigValue as fidl::encoding::ValueTypeMarker>::borrow),
21966 encoder,
21967 offset + cur_offset,
21968 depth,
21969 )?;
21970
21971 _prev_end_offset = cur_offset + envelope_size;
21972 if 7 > max_ordinal {
21973 return Ok(());
21974 }
21975
21976 let cur_offset: usize = (7 - 1) * envelope_size;
21979
21980 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21982
21983 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
21988 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
21989 encoder, offset + cur_offset, depth
21990 )?;
21991
21992 _prev_end_offset = cur_offset + envelope_size;
21993
21994 Ok(())
21995 }
21996 }
21997
21998 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseConfiguration {
21999 #[inline(always)]
22000 fn new_empty() -> Self {
22001 Self::default()
22002 }
22003
22004 unsafe fn decode(
22005 &mut self,
22006 decoder: &mut fidl::encoding::Decoder<'_, D>,
22007 offset: usize,
22008 mut depth: fidl::encoding::Depth,
22009 ) -> fidl::Result<()> {
22010 decoder.debug_check_bounds::<Self>(offset);
22011 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22012 None => return Err(fidl::Error::NotNullable),
22013 Some(len) => len,
22014 };
22015 if len == 0 {
22017 return Ok(());
22018 };
22019 depth.increment()?;
22020 let envelope_size = 8;
22021 let bytes_len = len * envelope_size;
22022 let offset = decoder.out_of_line_offset(bytes_len)?;
22023 let mut _next_ordinal_to_read = 0;
22025 let mut next_offset = offset;
22026 let end_offset = offset + bytes_len;
22027 _next_ordinal_to_read += 1;
22028 if next_offset >= end_offset {
22029 return Ok(());
22030 }
22031
22032 while _next_ordinal_to_read < 1 {
22034 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22035 _next_ordinal_to_read += 1;
22036 next_offset += envelope_size;
22037 }
22038
22039 let next_out_of_line = decoder.next_out_of_line();
22040 let handles_before = decoder.remaining_handles();
22041 if let Some((inlined, num_bytes, num_handles)) =
22042 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22043 {
22044 let member_inline_size =
22045 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22046 if inlined != (member_inline_size <= 4) {
22047 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22048 }
22049 let inner_offset;
22050 let mut inner_depth = depth.clone();
22051 if inlined {
22052 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22053 inner_offset = next_offset;
22054 } else {
22055 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22056 inner_depth.increment()?;
22057 }
22058 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
22059 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
22060 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22061 {
22062 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22063 }
22064 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22065 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22066 }
22067 }
22068
22069 next_offset += envelope_size;
22070 _next_ordinal_to_read += 1;
22071 if next_offset >= end_offset {
22072 return Ok(());
22073 }
22074
22075 while _next_ordinal_to_read < 2 {
22077 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22078 _next_ordinal_to_read += 1;
22079 next_offset += envelope_size;
22080 }
22081
22082 let next_out_of_line = decoder.next_out_of_line();
22083 let handles_before = decoder.remaining_handles();
22084 if let Some((inlined, num_bytes, num_handles)) =
22085 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22086 {
22087 let member_inline_size =
22088 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
22089 decoder.context,
22090 );
22091 if inlined != (member_inline_size <= 4) {
22092 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22093 }
22094 let inner_offset;
22095 let mut inner_depth = depth.clone();
22096 if inlined {
22097 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22098 inner_offset = next_offset;
22099 } else {
22100 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22101 inner_depth.increment()?;
22102 }
22103 let val_ref = self
22104 .source_name
22105 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
22106 fidl::decode!(
22107 fidl::encoding::BoundedString<100>,
22108 D,
22109 val_ref,
22110 decoder,
22111 inner_offset,
22112 inner_depth
22113 )?;
22114 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22115 {
22116 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22117 }
22118 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22119 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22120 }
22121 }
22122
22123 next_offset += envelope_size;
22124 _next_ordinal_to_read += 1;
22125 if next_offset >= end_offset {
22126 return Ok(());
22127 }
22128
22129 while _next_ordinal_to_read < 3 {
22131 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22132 _next_ordinal_to_read += 1;
22133 next_offset += envelope_size;
22134 }
22135
22136 let next_out_of_line = decoder.next_out_of_line();
22137 let handles_before = decoder.remaining_handles();
22138 if let Some((inlined, num_bytes, num_handles)) =
22139 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22140 {
22141 let member_inline_size =
22142 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
22143 decoder.context,
22144 );
22145 if inlined != (member_inline_size <= 4) {
22146 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22147 }
22148 let inner_offset;
22149 let mut inner_depth = depth.clone();
22150 if inlined {
22151 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22152 inner_offset = next_offset;
22153 } else {
22154 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22155 inner_depth.increment()?;
22156 }
22157 let val_ref = self
22158 .target_name
22159 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
22160 fidl::decode!(
22161 fidl::encoding::BoundedString<100>,
22162 D,
22163 val_ref,
22164 decoder,
22165 inner_offset,
22166 inner_depth
22167 )?;
22168 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22169 {
22170 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22171 }
22172 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22173 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22174 }
22175 }
22176
22177 next_offset += envelope_size;
22178 _next_ordinal_to_read += 1;
22179 if next_offset >= end_offset {
22180 return Ok(());
22181 }
22182
22183 while _next_ordinal_to_read < 4 {
22185 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22186 _next_ordinal_to_read += 1;
22187 next_offset += envelope_size;
22188 }
22189
22190 let next_out_of_line = decoder.next_out_of_line();
22191 let handles_before = decoder.remaining_handles();
22192 if let Some((inlined, num_bytes, num_handles)) =
22193 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22194 {
22195 let member_inline_size =
22196 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22197 if inlined != (member_inline_size <= 4) {
22198 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22199 }
22200 let inner_offset;
22201 let mut inner_depth = depth.clone();
22202 if inlined {
22203 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22204 inner_offset = next_offset;
22205 } else {
22206 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22207 inner_depth.increment()?;
22208 }
22209 let val_ref =
22210 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
22211 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
22212 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22213 {
22214 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22215 }
22216 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22217 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22218 }
22219 }
22220
22221 next_offset += envelope_size;
22222 _next_ordinal_to_read += 1;
22223 if next_offset >= end_offset {
22224 return Ok(());
22225 }
22226
22227 while _next_ordinal_to_read < 5 {
22229 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22230 _next_ordinal_to_read += 1;
22231 next_offset += envelope_size;
22232 }
22233
22234 let next_out_of_line = decoder.next_out_of_line();
22235 let handles_before = decoder.remaining_handles();
22236 if let Some((inlined, num_bytes, num_handles)) =
22237 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22238 {
22239 let member_inline_size =
22240 <ConfigType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22241 if inlined != (member_inline_size <= 4) {
22242 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22243 }
22244 let inner_offset;
22245 let mut inner_depth = depth.clone();
22246 if inlined {
22247 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22248 inner_offset = next_offset;
22249 } else {
22250 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22251 inner_depth.increment()?;
22252 }
22253 let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(ConfigType, D));
22254 fidl::decode!(ConfigType, D, val_ref, decoder, inner_offset, inner_depth)?;
22255 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22256 {
22257 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22258 }
22259 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22260 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22261 }
22262 }
22263
22264 next_offset += envelope_size;
22265 _next_ordinal_to_read += 1;
22266 if next_offset >= end_offset {
22267 return Ok(());
22268 }
22269
22270 while _next_ordinal_to_read < 6 {
22272 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22273 _next_ordinal_to_read += 1;
22274 next_offset += envelope_size;
22275 }
22276
22277 let next_out_of_line = decoder.next_out_of_line();
22278 let handles_before = decoder.remaining_handles();
22279 if let Some((inlined, num_bytes, num_handles)) =
22280 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22281 {
22282 let member_inline_size =
22283 <ConfigValue as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22284 if inlined != (member_inline_size <= 4) {
22285 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22286 }
22287 let inner_offset;
22288 let mut inner_depth = depth.clone();
22289 if inlined {
22290 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22291 inner_offset = next_offset;
22292 } else {
22293 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22294 inner_depth.increment()?;
22295 }
22296 let val_ref = self.default.get_or_insert_with(|| fidl::new_empty!(ConfigValue, D));
22297 fidl::decode!(ConfigValue, D, val_ref, decoder, inner_offset, inner_depth)?;
22298 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22299 {
22300 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22301 }
22302 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22303 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22304 }
22305 }
22306
22307 next_offset += envelope_size;
22308 _next_ordinal_to_read += 1;
22309 if next_offset >= end_offset {
22310 return Ok(());
22311 }
22312
22313 while _next_ordinal_to_read < 7 {
22315 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22316 _next_ordinal_to_read += 1;
22317 next_offset += envelope_size;
22318 }
22319
22320 let next_out_of_line = decoder.next_out_of_line();
22321 let handles_before = decoder.remaining_handles();
22322 if let Some((inlined, num_bytes, num_handles)) =
22323 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22324 {
22325 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22326 if inlined != (member_inline_size <= 4) {
22327 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22328 }
22329 let inner_offset;
22330 let mut inner_depth = depth.clone();
22331 if inlined {
22332 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22333 inner_offset = next_offset;
22334 } else {
22335 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22336 inner_depth.increment()?;
22337 }
22338 let val_ref = self.source_dictionary.get_or_insert_with(|| {
22339 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
22340 });
22341 fidl::decode!(
22342 fidl::encoding::BoundedString<1024>,
22343 D,
22344 val_ref,
22345 decoder,
22346 inner_offset,
22347 inner_depth
22348 )?;
22349 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22350 {
22351 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22352 }
22353 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22354 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22355 }
22356 }
22357
22358 next_offset += envelope_size;
22359
22360 while next_offset < end_offset {
22362 _next_ordinal_to_read += 1;
22363 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22364 next_offset += envelope_size;
22365 }
22366
22367 Ok(())
22368 }
22369 }
22370
22371 impl UseDirectory {
22372 #[inline(always)]
22373 fn max_ordinal_present(&self) -> u64 {
22374 if let Some(_) = self.source_dictionary {
22375 return 8;
22376 }
22377 if let Some(_) = self.availability {
22378 return 7;
22379 }
22380 if let Some(_) = self.dependency_type {
22381 return 6;
22382 }
22383 if let Some(_) = self.subdir {
22384 return 5;
22385 }
22386 if let Some(_) = self.rights {
22387 return 4;
22388 }
22389 if let Some(_) = self.target_path {
22390 return 3;
22391 }
22392 if let Some(_) = self.source_name {
22393 return 2;
22394 }
22395 if let Some(_) = self.source {
22396 return 1;
22397 }
22398 0
22399 }
22400 }
22401
22402 impl fidl::encoding::ValueTypeMarker for UseDirectory {
22403 type Borrowed<'a> = &'a Self;
22404 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22405 value
22406 }
22407 }
22408
22409 unsafe impl fidl::encoding::TypeMarker for UseDirectory {
22410 type Owned = Self;
22411
22412 #[inline(always)]
22413 fn inline_align(_context: fidl::encoding::Context) -> usize {
22414 8
22415 }
22416
22417 #[inline(always)]
22418 fn inline_size(_context: fidl::encoding::Context) -> usize {
22419 16
22420 }
22421 }
22422
22423 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseDirectory, D>
22424 for &UseDirectory
22425 {
22426 unsafe fn encode(
22427 self,
22428 encoder: &mut fidl::encoding::Encoder<'_, D>,
22429 offset: usize,
22430 mut depth: fidl::encoding::Depth,
22431 ) -> fidl::Result<()> {
22432 encoder.debug_check_bounds::<UseDirectory>(offset);
22433 let max_ordinal: u64 = self.max_ordinal_present();
22435 encoder.write_num(max_ordinal, offset);
22436 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
22437 if max_ordinal == 0 {
22439 return Ok(());
22440 }
22441 depth.increment()?;
22442 let envelope_size = 8;
22443 let bytes_len = max_ordinal as usize * envelope_size;
22444 #[allow(unused_variables)]
22445 let offset = encoder.out_of_line_offset(bytes_len);
22446 let mut _prev_end_offset: usize = 0;
22447 if 1 > max_ordinal {
22448 return Ok(());
22449 }
22450
22451 let cur_offset: usize = (1 - 1) * envelope_size;
22454
22455 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22457
22458 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
22463 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
22464 encoder,
22465 offset + cur_offset,
22466 depth,
22467 )?;
22468
22469 _prev_end_offset = cur_offset + envelope_size;
22470 if 2 > max_ordinal {
22471 return Ok(());
22472 }
22473
22474 let cur_offset: usize = (2 - 1) * envelope_size;
22477
22478 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22480
22481 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
22486 self.source_name.as_ref().map(
22487 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
22488 ),
22489 encoder,
22490 offset + cur_offset,
22491 depth,
22492 )?;
22493
22494 _prev_end_offset = cur_offset + envelope_size;
22495 if 3 > max_ordinal {
22496 return Ok(());
22497 }
22498
22499 let cur_offset: usize = (3 - 1) * envelope_size;
22502
22503 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22505
22506 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
22511 self.target_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
22512 encoder, offset + cur_offset, depth
22513 )?;
22514
22515 _prev_end_offset = cur_offset + envelope_size;
22516 if 4 > max_ordinal {
22517 return Ok(());
22518 }
22519
22520 let cur_offset: usize = (4 - 1) * envelope_size;
22523
22524 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22526
22527 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_io__common::Operations, D>(
22532 self.rights.as_ref().map(<fidl_fuchsia_io__common::Operations as fidl::encoding::ValueTypeMarker>::borrow),
22533 encoder, offset + cur_offset, depth
22534 )?;
22535
22536 _prev_end_offset = cur_offset + envelope_size;
22537 if 5 > max_ordinal {
22538 return Ok(());
22539 }
22540
22541 let cur_offset: usize = (5 - 1) * envelope_size;
22544
22545 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22547
22548 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
22553 self.subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
22554 encoder, offset + cur_offset, depth
22555 )?;
22556
22557 _prev_end_offset = cur_offset + envelope_size;
22558 if 6 > max_ordinal {
22559 return Ok(());
22560 }
22561
22562 let cur_offset: usize = (6 - 1) * envelope_size;
22565
22566 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22568
22569 fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
22574 self.dependency_type
22575 .as_ref()
22576 .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
22577 encoder,
22578 offset + cur_offset,
22579 depth,
22580 )?;
22581
22582 _prev_end_offset = cur_offset + envelope_size;
22583 if 7 > max_ordinal {
22584 return Ok(());
22585 }
22586
22587 let cur_offset: usize = (7 - 1) * envelope_size;
22590
22591 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22593
22594 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
22599 self.availability
22600 .as_ref()
22601 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
22602 encoder,
22603 offset + cur_offset,
22604 depth,
22605 )?;
22606
22607 _prev_end_offset = cur_offset + envelope_size;
22608 if 8 > max_ordinal {
22609 return Ok(());
22610 }
22611
22612 let cur_offset: usize = (8 - 1) * envelope_size;
22615
22616 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22618
22619 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
22624 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
22625 encoder, offset + cur_offset, depth
22626 )?;
22627
22628 _prev_end_offset = cur_offset + envelope_size;
22629
22630 Ok(())
22631 }
22632 }
22633
22634 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseDirectory {
22635 #[inline(always)]
22636 fn new_empty() -> Self {
22637 Self::default()
22638 }
22639
22640 unsafe fn decode(
22641 &mut self,
22642 decoder: &mut fidl::encoding::Decoder<'_, D>,
22643 offset: usize,
22644 mut depth: fidl::encoding::Depth,
22645 ) -> fidl::Result<()> {
22646 decoder.debug_check_bounds::<Self>(offset);
22647 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22648 None => return Err(fidl::Error::NotNullable),
22649 Some(len) => len,
22650 };
22651 if len == 0 {
22653 return Ok(());
22654 };
22655 depth.increment()?;
22656 let envelope_size = 8;
22657 let bytes_len = len * envelope_size;
22658 let offset = decoder.out_of_line_offset(bytes_len)?;
22659 let mut _next_ordinal_to_read = 0;
22661 let mut next_offset = offset;
22662 let end_offset = offset + bytes_len;
22663 _next_ordinal_to_read += 1;
22664 if next_offset >= end_offset {
22665 return Ok(());
22666 }
22667
22668 while _next_ordinal_to_read < 1 {
22670 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22671 _next_ordinal_to_read += 1;
22672 next_offset += envelope_size;
22673 }
22674
22675 let next_out_of_line = decoder.next_out_of_line();
22676 let handles_before = decoder.remaining_handles();
22677 if let Some((inlined, num_bytes, num_handles)) =
22678 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22679 {
22680 let member_inline_size =
22681 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22682 if inlined != (member_inline_size <= 4) {
22683 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22684 }
22685 let inner_offset;
22686 let mut inner_depth = depth.clone();
22687 if inlined {
22688 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22689 inner_offset = next_offset;
22690 } else {
22691 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22692 inner_depth.increment()?;
22693 }
22694 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
22695 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
22696 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22697 {
22698 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22699 }
22700 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22701 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22702 }
22703 }
22704
22705 next_offset += envelope_size;
22706 _next_ordinal_to_read += 1;
22707 if next_offset >= end_offset {
22708 return Ok(());
22709 }
22710
22711 while _next_ordinal_to_read < 2 {
22713 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22714 _next_ordinal_to_read += 1;
22715 next_offset += envelope_size;
22716 }
22717
22718 let next_out_of_line = decoder.next_out_of_line();
22719 let handles_before = decoder.remaining_handles();
22720 if let Some((inlined, num_bytes, num_handles)) =
22721 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22722 {
22723 let member_inline_size =
22724 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
22725 decoder.context,
22726 );
22727 if inlined != (member_inline_size <= 4) {
22728 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22729 }
22730 let inner_offset;
22731 let mut inner_depth = depth.clone();
22732 if inlined {
22733 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22734 inner_offset = next_offset;
22735 } else {
22736 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22737 inner_depth.increment()?;
22738 }
22739 let val_ref = self
22740 .source_name
22741 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
22742 fidl::decode!(
22743 fidl::encoding::BoundedString<100>,
22744 D,
22745 val_ref,
22746 decoder,
22747 inner_offset,
22748 inner_depth
22749 )?;
22750 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22751 {
22752 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22753 }
22754 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22755 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22756 }
22757 }
22758
22759 next_offset += envelope_size;
22760 _next_ordinal_to_read += 1;
22761 if next_offset >= end_offset {
22762 return Ok(());
22763 }
22764
22765 while _next_ordinal_to_read < 3 {
22767 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22768 _next_ordinal_to_read += 1;
22769 next_offset += envelope_size;
22770 }
22771
22772 let next_out_of_line = decoder.next_out_of_line();
22773 let handles_before = decoder.remaining_handles();
22774 if let Some((inlined, num_bytes, num_handles)) =
22775 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22776 {
22777 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22778 if inlined != (member_inline_size <= 4) {
22779 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22780 }
22781 let inner_offset;
22782 let mut inner_depth = depth.clone();
22783 if inlined {
22784 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22785 inner_offset = next_offset;
22786 } else {
22787 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22788 inner_depth.increment()?;
22789 }
22790 let val_ref = self.target_path.get_or_insert_with(|| {
22791 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
22792 });
22793 fidl::decode!(
22794 fidl::encoding::BoundedString<1024>,
22795 D,
22796 val_ref,
22797 decoder,
22798 inner_offset,
22799 inner_depth
22800 )?;
22801 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22802 {
22803 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22804 }
22805 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22806 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22807 }
22808 }
22809
22810 next_offset += envelope_size;
22811 _next_ordinal_to_read += 1;
22812 if next_offset >= end_offset {
22813 return Ok(());
22814 }
22815
22816 while _next_ordinal_to_read < 4 {
22818 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22819 _next_ordinal_to_read += 1;
22820 next_offset += envelope_size;
22821 }
22822
22823 let next_out_of_line = decoder.next_out_of_line();
22824 let handles_before = decoder.remaining_handles();
22825 if let Some((inlined, num_bytes, num_handles)) =
22826 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22827 {
22828 let member_inline_size = <fidl_fuchsia_io__common::Operations as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22829 if inlined != (member_inline_size <= 4) {
22830 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22831 }
22832 let inner_offset;
22833 let mut inner_depth = depth.clone();
22834 if inlined {
22835 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22836 inner_offset = next_offset;
22837 } else {
22838 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22839 inner_depth.increment()?;
22840 }
22841 let val_ref = self.rights.get_or_insert_with(|| {
22842 fidl::new_empty!(fidl_fuchsia_io__common::Operations, D)
22843 });
22844 fidl::decode!(
22845 fidl_fuchsia_io__common::Operations,
22846 D,
22847 val_ref,
22848 decoder,
22849 inner_offset,
22850 inner_depth
22851 )?;
22852 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22853 {
22854 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22855 }
22856 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22857 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22858 }
22859 }
22860
22861 next_offset += envelope_size;
22862 _next_ordinal_to_read += 1;
22863 if next_offset >= end_offset {
22864 return Ok(());
22865 }
22866
22867 while _next_ordinal_to_read < 5 {
22869 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22870 _next_ordinal_to_read += 1;
22871 next_offset += envelope_size;
22872 }
22873
22874 let next_out_of_line = decoder.next_out_of_line();
22875 let handles_before = decoder.remaining_handles();
22876 if let Some((inlined, num_bytes, num_handles)) =
22877 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22878 {
22879 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22880 if inlined != (member_inline_size <= 4) {
22881 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22882 }
22883 let inner_offset;
22884 let mut inner_depth = depth.clone();
22885 if inlined {
22886 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22887 inner_offset = next_offset;
22888 } else {
22889 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22890 inner_depth.increment()?;
22891 }
22892 let val_ref = self.subdir.get_or_insert_with(|| {
22893 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
22894 });
22895 fidl::decode!(
22896 fidl::encoding::BoundedString<1024>,
22897 D,
22898 val_ref,
22899 decoder,
22900 inner_offset,
22901 inner_depth
22902 )?;
22903 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22904 {
22905 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22906 }
22907 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22908 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22909 }
22910 }
22911
22912 next_offset += envelope_size;
22913 _next_ordinal_to_read += 1;
22914 if next_offset >= end_offset {
22915 return Ok(());
22916 }
22917
22918 while _next_ordinal_to_read < 6 {
22920 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22921 _next_ordinal_to_read += 1;
22922 next_offset += envelope_size;
22923 }
22924
22925 let next_out_of_line = decoder.next_out_of_line();
22926 let handles_before = decoder.remaining_handles();
22927 if let Some((inlined, num_bytes, num_handles)) =
22928 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22929 {
22930 let member_inline_size =
22931 <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22932 if inlined != (member_inline_size <= 4) {
22933 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22934 }
22935 let inner_offset;
22936 let mut inner_depth = depth.clone();
22937 if inlined {
22938 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22939 inner_offset = next_offset;
22940 } else {
22941 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22942 inner_depth.increment()?;
22943 }
22944 let val_ref =
22945 self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
22946 fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
22947 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22948 {
22949 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22950 }
22951 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22952 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22953 }
22954 }
22955
22956 next_offset += envelope_size;
22957 _next_ordinal_to_read += 1;
22958 if next_offset >= end_offset {
22959 return Ok(());
22960 }
22961
22962 while _next_ordinal_to_read < 7 {
22964 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22965 _next_ordinal_to_read += 1;
22966 next_offset += envelope_size;
22967 }
22968
22969 let next_out_of_line = decoder.next_out_of_line();
22970 let handles_before = decoder.remaining_handles();
22971 if let Some((inlined, num_bytes, num_handles)) =
22972 fidl::encoding::decode_envelope_header(decoder, next_offset)?
22973 {
22974 let member_inline_size =
22975 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22976 if inlined != (member_inline_size <= 4) {
22977 return Err(fidl::Error::InvalidInlineBitInEnvelope);
22978 }
22979 let inner_offset;
22980 let mut inner_depth = depth.clone();
22981 if inlined {
22982 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22983 inner_offset = next_offset;
22984 } else {
22985 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22986 inner_depth.increment()?;
22987 }
22988 let val_ref =
22989 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
22990 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
22991 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22992 {
22993 return Err(fidl::Error::InvalidNumBytesInEnvelope);
22994 }
22995 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22996 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22997 }
22998 }
22999
23000 next_offset += envelope_size;
23001 _next_ordinal_to_read += 1;
23002 if next_offset >= end_offset {
23003 return Ok(());
23004 }
23005
23006 while _next_ordinal_to_read < 8 {
23008 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23009 _next_ordinal_to_read += 1;
23010 next_offset += envelope_size;
23011 }
23012
23013 let next_out_of_line = decoder.next_out_of_line();
23014 let handles_before = decoder.remaining_handles();
23015 if let Some((inlined, num_bytes, num_handles)) =
23016 fidl::encoding::decode_envelope_header(decoder, next_offset)?
23017 {
23018 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23019 if inlined != (member_inline_size <= 4) {
23020 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23021 }
23022 let inner_offset;
23023 let mut inner_depth = depth.clone();
23024 if inlined {
23025 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23026 inner_offset = next_offset;
23027 } else {
23028 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23029 inner_depth.increment()?;
23030 }
23031 let val_ref = self.source_dictionary.get_or_insert_with(|| {
23032 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
23033 });
23034 fidl::decode!(
23035 fidl::encoding::BoundedString<1024>,
23036 D,
23037 val_ref,
23038 decoder,
23039 inner_offset,
23040 inner_depth
23041 )?;
23042 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23043 {
23044 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23045 }
23046 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23047 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23048 }
23049 }
23050
23051 next_offset += envelope_size;
23052
23053 while next_offset < end_offset {
23055 _next_ordinal_to_read += 1;
23056 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23057 next_offset += envelope_size;
23058 }
23059
23060 Ok(())
23061 }
23062 }
23063
23064 impl UseEventStream {
23065 #[inline(always)]
23066 fn max_ordinal_present(&self) -> u64 {
23067 if let Some(_) = self.filter {
23068 return 6;
23069 }
23070 if let Some(_) = self.availability {
23071 return 5;
23072 }
23073 if let Some(_) = self.target_path {
23074 return 4;
23075 }
23076 if let Some(_) = self.scope {
23077 return 3;
23078 }
23079 if let Some(_) = self.source {
23080 return 2;
23081 }
23082 if let Some(_) = self.source_name {
23083 return 1;
23084 }
23085 0
23086 }
23087 }
23088
23089 impl fidl::encoding::ValueTypeMarker for UseEventStream {
23090 type Borrowed<'a> = &'a Self;
23091 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23092 value
23093 }
23094 }
23095
23096 unsafe impl fidl::encoding::TypeMarker for UseEventStream {
23097 type Owned = Self;
23098
23099 #[inline(always)]
23100 fn inline_align(_context: fidl::encoding::Context) -> usize {
23101 8
23102 }
23103
23104 #[inline(always)]
23105 fn inline_size(_context: fidl::encoding::Context) -> usize {
23106 16
23107 }
23108 }
23109
23110 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseEventStream, D>
23111 for &UseEventStream
23112 {
23113 unsafe fn encode(
23114 self,
23115 encoder: &mut fidl::encoding::Encoder<'_, D>,
23116 offset: usize,
23117 mut depth: fidl::encoding::Depth,
23118 ) -> fidl::Result<()> {
23119 encoder.debug_check_bounds::<UseEventStream>(offset);
23120 let max_ordinal: u64 = self.max_ordinal_present();
23122 encoder.write_num(max_ordinal, offset);
23123 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
23124 if max_ordinal == 0 {
23126 return Ok(());
23127 }
23128 depth.increment()?;
23129 let envelope_size = 8;
23130 let bytes_len = max_ordinal as usize * envelope_size;
23131 #[allow(unused_variables)]
23132 let offset = encoder.out_of_line_offset(bytes_len);
23133 let mut _prev_end_offset: usize = 0;
23134 if 1 > max_ordinal {
23135 return Ok(());
23136 }
23137
23138 let cur_offset: usize = (1 - 1) * envelope_size;
23141
23142 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23144
23145 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
23150 self.source_name.as_ref().map(
23151 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
23152 ),
23153 encoder,
23154 offset + cur_offset,
23155 depth,
23156 )?;
23157
23158 _prev_end_offset = cur_offset + envelope_size;
23159 if 2 > max_ordinal {
23160 return Ok(());
23161 }
23162
23163 let cur_offset: usize = (2 - 1) * envelope_size;
23166
23167 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23169
23170 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
23175 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
23176 encoder,
23177 offset + cur_offset,
23178 depth,
23179 )?;
23180
23181 _prev_end_offset = cur_offset + envelope_size;
23182 if 3 > max_ordinal {
23183 return Ok(());
23184 }
23185
23186 let cur_offset: usize = (3 - 1) * envelope_size;
23189
23190 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23192
23193 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Ref>, D>(
23198 self.scope.as_ref().map(<fidl::encoding::UnboundedVector<Ref> as fidl::encoding::ValueTypeMarker>::borrow),
23199 encoder, offset + cur_offset, depth
23200 )?;
23201
23202 _prev_end_offset = cur_offset + envelope_size;
23203 if 4 > max_ordinal {
23204 return Ok(());
23205 }
23206
23207 let cur_offset: usize = (4 - 1) * envelope_size;
23210
23211 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23213
23214 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
23219 self.target_path.as_ref().map(
23220 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
23221 ),
23222 encoder,
23223 offset + cur_offset,
23224 depth,
23225 )?;
23226
23227 _prev_end_offset = cur_offset + envelope_size;
23228 if 5 > max_ordinal {
23229 return Ok(());
23230 }
23231
23232 let cur_offset: usize = (5 - 1) * envelope_size;
23235
23236 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23238
23239 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
23244 self.availability
23245 .as_ref()
23246 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
23247 encoder,
23248 offset + cur_offset,
23249 depth,
23250 )?;
23251
23252 _prev_end_offset = cur_offset + envelope_size;
23253 if 6 > max_ordinal {
23254 return Ok(());
23255 }
23256
23257 let cur_offset: usize = (6 - 1) * envelope_size;
23260
23261 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23263
23264 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_data__common::Dictionary, D>(
23269 self.filter.as_ref().map(<fidl_fuchsia_data__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow),
23270 encoder, offset + cur_offset, depth
23271 )?;
23272
23273 _prev_end_offset = cur_offset + envelope_size;
23274
23275 Ok(())
23276 }
23277 }
23278
23279 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseEventStream {
23280 #[inline(always)]
23281 fn new_empty() -> Self {
23282 Self::default()
23283 }
23284
23285 unsafe fn decode(
23286 &mut self,
23287 decoder: &mut fidl::encoding::Decoder<'_, D>,
23288 offset: usize,
23289 mut depth: fidl::encoding::Depth,
23290 ) -> fidl::Result<()> {
23291 decoder.debug_check_bounds::<Self>(offset);
23292 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
23293 None => return Err(fidl::Error::NotNullable),
23294 Some(len) => len,
23295 };
23296 if len == 0 {
23298 return Ok(());
23299 };
23300 depth.increment()?;
23301 let envelope_size = 8;
23302 let bytes_len = len * envelope_size;
23303 let offset = decoder.out_of_line_offset(bytes_len)?;
23304 let mut _next_ordinal_to_read = 0;
23306 let mut next_offset = offset;
23307 let end_offset = offset + bytes_len;
23308 _next_ordinal_to_read += 1;
23309 if next_offset >= end_offset {
23310 return Ok(());
23311 }
23312
23313 while _next_ordinal_to_read < 1 {
23315 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23316 _next_ordinal_to_read += 1;
23317 next_offset += envelope_size;
23318 }
23319
23320 let next_out_of_line = decoder.next_out_of_line();
23321 let handles_before = decoder.remaining_handles();
23322 if let Some((inlined, num_bytes, num_handles)) =
23323 fidl::encoding::decode_envelope_header(decoder, next_offset)?
23324 {
23325 let member_inline_size =
23326 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
23327 decoder.context,
23328 );
23329 if inlined != (member_inline_size <= 4) {
23330 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23331 }
23332 let inner_offset;
23333 let mut inner_depth = depth.clone();
23334 if inlined {
23335 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23336 inner_offset = next_offset;
23337 } else {
23338 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23339 inner_depth.increment()?;
23340 }
23341 let val_ref = self
23342 .source_name
23343 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
23344 fidl::decode!(
23345 fidl::encoding::BoundedString<100>,
23346 D,
23347 val_ref,
23348 decoder,
23349 inner_offset,
23350 inner_depth
23351 )?;
23352 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23353 {
23354 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23355 }
23356 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23357 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23358 }
23359 }
23360
23361 next_offset += envelope_size;
23362 _next_ordinal_to_read += 1;
23363 if next_offset >= end_offset {
23364 return Ok(());
23365 }
23366
23367 while _next_ordinal_to_read < 2 {
23369 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23370 _next_ordinal_to_read += 1;
23371 next_offset += envelope_size;
23372 }
23373
23374 let next_out_of_line = decoder.next_out_of_line();
23375 let handles_before = decoder.remaining_handles();
23376 if let Some((inlined, num_bytes, num_handles)) =
23377 fidl::encoding::decode_envelope_header(decoder, next_offset)?
23378 {
23379 let member_inline_size =
23380 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23381 if inlined != (member_inline_size <= 4) {
23382 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23383 }
23384 let inner_offset;
23385 let mut inner_depth = depth.clone();
23386 if inlined {
23387 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23388 inner_offset = next_offset;
23389 } else {
23390 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23391 inner_depth.increment()?;
23392 }
23393 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
23394 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
23395 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23396 {
23397 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23398 }
23399 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23400 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23401 }
23402 }
23403
23404 next_offset += envelope_size;
23405 _next_ordinal_to_read += 1;
23406 if next_offset >= end_offset {
23407 return Ok(());
23408 }
23409
23410 while _next_ordinal_to_read < 3 {
23412 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23413 _next_ordinal_to_read += 1;
23414 next_offset += envelope_size;
23415 }
23416
23417 let next_out_of_line = decoder.next_out_of_line();
23418 let handles_before = decoder.remaining_handles();
23419 if let Some((inlined, num_bytes, num_handles)) =
23420 fidl::encoding::decode_envelope_header(decoder, next_offset)?
23421 {
23422 let member_inline_size = <fidl::encoding::UnboundedVector<Ref> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23423 if inlined != (member_inline_size <= 4) {
23424 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23425 }
23426 let inner_offset;
23427 let mut inner_depth = depth.clone();
23428 if inlined {
23429 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23430 inner_offset = next_offset;
23431 } else {
23432 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23433 inner_depth.increment()?;
23434 }
23435 let val_ref = self.scope.get_or_insert_with(|| {
23436 fidl::new_empty!(fidl::encoding::UnboundedVector<Ref>, D)
23437 });
23438 fidl::decode!(
23439 fidl::encoding::UnboundedVector<Ref>,
23440 D,
23441 val_ref,
23442 decoder,
23443 inner_offset,
23444 inner_depth
23445 )?;
23446 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23447 {
23448 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23449 }
23450 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23451 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23452 }
23453 }
23454
23455 next_offset += envelope_size;
23456 _next_ordinal_to_read += 1;
23457 if next_offset >= end_offset {
23458 return Ok(());
23459 }
23460
23461 while _next_ordinal_to_read < 4 {
23463 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23464 _next_ordinal_to_read += 1;
23465 next_offset += envelope_size;
23466 }
23467
23468 let next_out_of_line = decoder.next_out_of_line();
23469 let handles_before = decoder.remaining_handles();
23470 if let Some((inlined, num_bytes, num_handles)) =
23471 fidl::encoding::decode_envelope_header(decoder, next_offset)?
23472 {
23473 let member_inline_size =
23474 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
23475 decoder.context,
23476 );
23477 if inlined != (member_inline_size <= 4) {
23478 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23479 }
23480 let inner_offset;
23481 let mut inner_depth = depth.clone();
23482 if inlined {
23483 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23484 inner_offset = next_offset;
23485 } else {
23486 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23487 inner_depth.increment()?;
23488 }
23489 let val_ref = self
23490 .target_path
23491 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
23492 fidl::decode!(
23493 fidl::encoding::BoundedString<100>,
23494 D,
23495 val_ref,
23496 decoder,
23497 inner_offset,
23498 inner_depth
23499 )?;
23500 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23501 {
23502 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23503 }
23504 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23505 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23506 }
23507 }
23508
23509 next_offset += envelope_size;
23510 _next_ordinal_to_read += 1;
23511 if next_offset >= end_offset {
23512 return Ok(());
23513 }
23514
23515 while _next_ordinal_to_read < 5 {
23517 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23518 _next_ordinal_to_read += 1;
23519 next_offset += envelope_size;
23520 }
23521
23522 let next_out_of_line = decoder.next_out_of_line();
23523 let handles_before = decoder.remaining_handles();
23524 if let Some((inlined, num_bytes, num_handles)) =
23525 fidl::encoding::decode_envelope_header(decoder, next_offset)?
23526 {
23527 let member_inline_size =
23528 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23529 if inlined != (member_inline_size <= 4) {
23530 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23531 }
23532 let inner_offset;
23533 let mut inner_depth = depth.clone();
23534 if inlined {
23535 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23536 inner_offset = next_offset;
23537 } else {
23538 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23539 inner_depth.increment()?;
23540 }
23541 let val_ref =
23542 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
23543 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
23544 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23545 {
23546 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23547 }
23548 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23549 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23550 }
23551 }
23552
23553 next_offset += envelope_size;
23554 _next_ordinal_to_read += 1;
23555 if next_offset >= end_offset {
23556 return Ok(());
23557 }
23558
23559 while _next_ordinal_to_read < 6 {
23561 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23562 _next_ordinal_to_read += 1;
23563 next_offset += envelope_size;
23564 }
23565
23566 let next_out_of_line = decoder.next_out_of_line();
23567 let handles_before = decoder.remaining_handles();
23568 if let Some((inlined, num_bytes, num_handles)) =
23569 fidl::encoding::decode_envelope_header(decoder, next_offset)?
23570 {
23571 let member_inline_size = <fidl_fuchsia_data__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23572 if inlined != (member_inline_size <= 4) {
23573 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23574 }
23575 let inner_offset;
23576 let mut inner_depth = depth.clone();
23577 if inlined {
23578 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23579 inner_offset = next_offset;
23580 } else {
23581 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23582 inner_depth.increment()?;
23583 }
23584 let val_ref = self.filter.get_or_insert_with(|| {
23585 fidl::new_empty!(fidl_fuchsia_data__common::Dictionary, D)
23586 });
23587 fidl::decode!(
23588 fidl_fuchsia_data__common::Dictionary,
23589 D,
23590 val_ref,
23591 decoder,
23592 inner_offset,
23593 inner_depth
23594 )?;
23595 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23596 {
23597 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23598 }
23599 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23600 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23601 }
23602 }
23603
23604 next_offset += envelope_size;
23605
23606 while next_offset < end_offset {
23608 _next_ordinal_to_read += 1;
23609 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23610 next_offset += envelope_size;
23611 }
23612
23613 Ok(())
23614 }
23615 }
23616
23617 impl UseProtocol {
23618 #[inline(always)]
23619 fn max_ordinal_present(&self) -> u64 {
23620 if let Some(_) = self.source_dictionary {
23621 return 6;
23622 }
23623 if let Some(_) = self.availability {
23624 return 5;
23625 }
23626 if let Some(_) = self.dependency_type {
23627 return 4;
23628 }
23629 if let Some(_) = self.target_path {
23630 return 3;
23631 }
23632 if let Some(_) = self.source_name {
23633 return 2;
23634 }
23635 if let Some(_) = self.source {
23636 return 1;
23637 }
23638 0
23639 }
23640 }
23641
23642 impl fidl::encoding::ValueTypeMarker for UseProtocol {
23643 type Borrowed<'a> = &'a Self;
23644 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23645 value
23646 }
23647 }
23648
23649 unsafe impl fidl::encoding::TypeMarker for UseProtocol {
23650 type Owned = Self;
23651
23652 #[inline(always)]
23653 fn inline_align(_context: fidl::encoding::Context) -> usize {
23654 8
23655 }
23656
23657 #[inline(always)]
23658 fn inline_size(_context: fidl::encoding::Context) -> usize {
23659 16
23660 }
23661 }
23662
23663 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseProtocol, D>
23664 for &UseProtocol
23665 {
23666 unsafe fn encode(
23667 self,
23668 encoder: &mut fidl::encoding::Encoder<'_, D>,
23669 offset: usize,
23670 mut depth: fidl::encoding::Depth,
23671 ) -> fidl::Result<()> {
23672 encoder.debug_check_bounds::<UseProtocol>(offset);
23673 let max_ordinal: u64 = self.max_ordinal_present();
23675 encoder.write_num(max_ordinal, offset);
23676 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
23677 if max_ordinal == 0 {
23679 return Ok(());
23680 }
23681 depth.increment()?;
23682 let envelope_size = 8;
23683 let bytes_len = max_ordinal as usize * envelope_size;
23684 #[allow(unused_variables)]
23685 let offset = encoder.out_of_line_offset(bytes_len);
23686 let mut _prev_end_offset: usize = 0;
23687 if 1 > max_ordinal {
23688 return Ok(());
23689 }
23690
23691 let cur_offset: usize = (1 - 1) * envelope_size;
23694
23695 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23697
23698 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
23703 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
23704 encoder,
23705 offset + cur_offset,
23706 depth,
23707 )?;
23708
23709 _prev_end_offset = cur_offset + envelope_size;
23710 if 2 > max_ordinal {
23711 return Ok(());
23712 }
23713
23714 let cur_offset: usize = (2 - 1) * envelope_size;
23717
23718 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23720
23721 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
23726 self.source_name.as_ref().map(
23727 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
23728 ),
23729 encoder,
23730 offset + cur_offset,
23731 depth,
23732 )?;
23733
23734 _prev_end_offset = cur_offset + envelope_size;
23735 if 3 > max_ordinal {
23736 return Ok(());
23737 }
23738
23739 let cur_offset: usize = (3 - 1) * envelope_size;
23742
23743 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23745
23746 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
23751 self.target_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
23752 encoder, offset + cur_offset, depth
23753 )?;
23754
23755 _prev_end_offset = cur_offset + envelope_size;
23756 if 4 > max_ordinal {
23757 return Ok(());
23758 }
23759
23760 let cur_offset: usize = (4 - 1) * envelope_size;
23763
23764 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23766
23767 fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
23772 self.dependency_type
23773 .as_ref()
23774 .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
23775 encoder,
23776 offset + cur_offset,
23777 depth,
23778 )?;
23779
23780 _prev_end_offset = cur_offset + envelope_size;
23781 if 5 > max_ordinal {
23782 return Ok(());
23783 }
23784
23785 let cur_offset: usize = (5 - 1) * envelope_size;
23788
23789 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23791
23792 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
23797 self.availability
23798 .as_ref()
23799 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
23800 encoder,
23801 offset + cur_offset,
23802 depth,
23803 )?;
23804
23805 _prev_end_offset = cur_offset + envelope_size;
23806 if 6 > max_ordinal {
23807 return Ok(());
23808 }
23809
23810 let cur_offset: usize = (6 - 1) * envelope_size;
23813
23814 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23816
23817 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
23822 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
23823 encoder, offset + cur_offset, depth
23824 )?;
23825
23826 _prev_end_offset = cur_offset + envelope_size;
23827
23828 Ok(())
23829 }
23830 }
23831
23832 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseProtocol {
23833 #[inline(always)]
23834 fn new_empty() -> Self {
23835 Self::default()
23836 }
23837
23838 unsafe fn decode(
23839 &mut self,
23840 decoder: &mut fidl::encoding::Decoder<'_, D>,
23841 offset: usize,
23842 mut depth: fidl::encoding::Depth,
23843 ) -> fidl::Result<()> {
23844 decoder.debug_check_bounds::<Self>(offset);
23845 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
23846 None => return Err(fidl::Error::NotNullable),
23847 Some(len) => len,
23848 };
23849 if len == 0 {
23851 return Ok(());
23852 };
23853 depth.increment()?;
23854 let envelope_size = 8;
23855 let bytes_len = len * envelope_size;
23856 let offset = decoder.out_of_line_offset(bytes_len)?;
23857 let mut _next_ordinal_to_read = 0;
23859 let mut next_offset = offset;
23860 let end_offset = offset + bytes_len;
23861 _next_ordinal_to_read += 1;
23862 if next_offset >= end_offset {
23863 return Ok(());
23864 }
23865
23866 while _next_ordinal_to_read < 1 {
23868 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23869 _next_ordinal_to_read += 1;
23870 next_offset += envelope_size;
23871 }
23872
23873 let next_out_of_line = decoder.next_out_of_line();
23874 let handles_before = decoder.remaining_handles();
23875 if let Some((inlined, num_bytes, num_handles)) =
23876 fidl::encoding::decode_envelope_header(decoder, next_offset)?
23877 {
23878 let member_inline_size =
23879 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23880 if inlined != (member_inline_size <= 4) {
23881 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23882 }
23883 let inner_offset;
23884 let mut inner_depth = depth.clone();
23885 if inlined {
23886 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23887 inner_offset = next_offset;
23888 } else {
23889 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23890 inner_depth.increment()?;
23891 }
23892 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
23893 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
23894 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23895 {
23896 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23897 }
23898 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23899 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23900 }
23901 }
23902
23903 next_offset += envelope_size;
23904 _next_ordinal_to_read += 1;
23905 if next_offset >= end_offset {
23906 return Ok(());
23907 }
23908
23909 while _next_ordinal_to_read < 2 {
23911 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23912 _next_ordinal_to_read += 1;
23913 next_offset += envelope_size;
23914 }
23915
23916 let next_out_of_line = decoder.next_out_of_line();
23917 let handles_before = decoder.remaining_handles();
23918 if let Some((inlined, num_bytes, num_handles)) =
23919 fidl::encoding::decode_envelope_header(decoder, next_offset)?
23920 {
23921 let member_inline_size =
23922 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
23923 decoder.context,
23924 );
23925 if inlined != (member_inline_size <= 4) {
23926 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23927 }
23928 let inner_offset;
23929 let mut inner_depth = depth.clone();
23930 if inlined {
23931 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23932 inner_offset = next_offset;
23933 } else {
23934 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23935 inner_depth.increment()?;
23936 }
23937 let val_ref = self
23938 .source_name
23939 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
23940 fidl::decode!(
23941 fidl::encoding::BoundedString<100>,
23942 D,
23943 val_ref,
23944 decoder,
23945 inner_offset,
23946 inner_depth
23947 )?;
23948 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23949 {
23950 return Err(fidl::Error::InvalidNumBytesInEnvelope);
23951 }
23952 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23953 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23954 }
23955 }
23956
23957 next_offset += envelope_size;
23958 _next_ordinal_to_read += 1;
23959 if next_offset >= end_offset {
23960 return Ok(());
23961 }
23962
23963 while _next_ordinal_to_read < 3 {
23965 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23966 _next_ordinal_to_read += 1;
23967 next_offset += envelope_size;
23968 }
23969
23970 let next_out_of_line = decoder.next_out_of_line();
23971 let handles_before = decoder.remaining_handles();
23972 if let Some((inlined, num_bytes, num_handles)) =
23973 fidl::encoding::decode_envelope_header(decoder, next_offset)?
23974 {
23975 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23976 if inlined != (member_inline_size <= 4) {
23977 return Err(fidl::Error::InvalidInlineBitInEnvelope);
23978 }
23979 let inner_offset;
23980 let mut inner_depth = depth.clone();
23981 if inlined {
23982 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23983 inner_offset = next_offset;
23984 } else {
23985 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23986 inner_depth.increment()?;
23987 }
23988 let val_ref = self.target_path.get_or_insert_with(|| {
23989 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
23990 });
23991 fidl::decode!(
23992 fidl::encoding::BoundedString<1024>,
23993 D,
23994 val_ref,
23995 decoder,
23996 inner_offset,
23997 inner_depth
23998 )?;
23999 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24000 {
24001 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24002 }
24003 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24004 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24005 }
24006 }
24007
24008 next_offset += envelope_size;
24009 _next_ordinal_to_read += 1;
24010 if next_offset >= end_offset {
24011 return Ok(());
24012 }
24013
24014 while _next_ordinal_to_read < 4 {
24016 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24017 _next_ordinal_to_read += 1;
24018 next_offset += envelope_size;
24019 }
24020
24021 let next_out_of_line = decoder.next_out_of_line();
24022 let handles_before = decoder.remaining_handles();
24023 if let Some((inlined, num_bytes, num_handles)) =
24024 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24025 {
24026 let member_inline_size =
24027 <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24028 if inlined != (member_inline_size <= 4) {
24029 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24030 }
24031 let inner_offset;
24032 let mut inner_depth = depth.clone();
24033 if inlined {
24034 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24035 inner_offset = next_offset;
24036 } else {
24037 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24038 inner_depth.increment()?;
24039 }
24040 let val_ref =
24041 self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
24042 fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
24043 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24044 {
24045 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24046 }
24047 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24048 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24049 }
24050 }
24051
24052 next_offset += envelope_size;
24053 _next_ordinal_to_read += 1;
24054 if next_offset >= end_offset {
24055 return Ok(());
24056 }
24057
24058 while _next_ordinal_to_read < 5 {
24060 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24061 _next_ordinal_to_read += 1;
24062 next_offset += envelope_size;
24063 }
24064
24065 let next_out_of_line = decoder.next_out_of_line();
24066 let handles_before = decoder.remaining_handles();
24067 if let Some((inlined, num_bytes, num_handles)) =
24068 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24069 {
24070 let member_inline_size =
24071 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24072 if inlined != (member_inline_size <= 4) {
24073 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24074 }
24075 let inner_offset;
24076 let mut inner_depth = depth.clone();
24077 if inlined {
24078 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24079 inner_offset = next_offset;
24080 } else {
24081 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24082 inner_depth.increment()?;
24083 }
24084 let val_ref =
24085 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
24086 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
24087 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24088 {
24089 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24090 }
24091 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24092 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24093 }
24094 }
24095
24096 next_offset += envelope_size;
24097 _next_ordinal_to_read += 1;
24098 if next_offset >= end_offset {
24099 return Ok(());
24100 }
24101
24102 while _next_ordinal_to_read < 6 {
24104 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24105 _next_ordinal_to_read += 1;
24106 next_offset += envelope_size;
24107 }
24108
24109 let next_out_of_line = decoder.next_out_of_line();
24110 let handles_before = decoder.remaining_handles();
24111 if let Some((inlined, num_bytes, num_handles)) =
24112 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24113 {
24114 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24115 if inlined != (member_inline_size <= 4) {
24116 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24117 }
24118 let inner_offset;
24119 let mut inner_depth = depth.clone();
24120 if inlined {
24121 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24122 inner_offset = next_offset;
24123 } else {
24124 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24125 inner_depth.increment()?;
24126 }
24127 let val_ref = self.source_dictionary.get_or_insert_with(|| {
24128 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
24129 });
24130 fidl::decode!(
24131 fidl::encoding::BoundedString<1024>,
24132 D,
24133 val_ref,
24134 decoder,
24135 inner_offset,
24136 inner_depth
24137 )?;
24138 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24139 {
24140 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24141 }
24142 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24143 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24144 }
24145 }
24146
24147 next_offset += envelope_size;
24148
24149 while next_offset < end_offset {
24151 _next_ordinal_to_read += 1;
24152 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24153 next_offset += envelope_size;
24154 }
24155
24156 Ok(())
24157 }
24158 }
24159
24160 impl UseRunner {
24161 #[inline(always)]
24162 fn max_ordinal_present(&self) -> u64 {
24163 if let Some(_) = self.source_dictionary {
24164 return 3;
24165 }
24166 if let Some(_) = self.source_name {
24167 return 2;
24168 }
24169 if let Some(_) = self.source {
24170 return 1;
24171 }
24172 0
24173 }
24174 }
24175
24176 impl fidl::encoding::ValueTypeMarker for UseRunner {
24177 type Borrowed<'a> = &'a Self;
24178 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24179 value
24180 }
24181 }
24182
24183 unsafe impl fidl::encoding::TypeMarker for UseRunner {
24184 type Owned = Self;
24185
24186 #[inline(always)]
24187 fn inline_align(_context: fidl::encoding::Context) -> usize {
24188 8
24189 }
24190
24191 #[inline(always)]
24192 fn inline_size(_context: fidl::encoding::Context) -> usize {
24193 16
24194 }
24195 }
24196
24197 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseRunner, D>
24198 for &UseRunner
24199 {
24200 unsafe fn encode(
24201 self,
24202 encoder: &mut fidl::encoding::Encoder<'_, D>,
24203 offset: usize,
24204 mut depth: fidl::encoding::Depth,
24205 ) -> fidl::Result<()> {
24206 encoder.debug_check_bounds::<UseRunner>(offset);
24207 let max_ordinal: u64 = self.max_ordinal_present();
24209 encoder.write_num(max_ordinal, offset);
24210 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
24211 if max_ordinal == 0 {
24213 return Ok(());
24214 }
24215 depth.increment()?;
24216 let envelope_size = 8;
24217 let bytes_len = max_ordinal as usize * envelope_size;
24218 #[allow(unused_variables)]
24219 let offset = encoder.out_of_line_offset(bytes_len);
24220 let mut _prev_end_offset: usize = 0;
24221 if 1 > max_ordinal {
24222 return Ok(());
24223 }
24224
24225 let cur_offset: usize = (1 - 1) * envelope_size;
24228
24229 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24231
24232 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
24237 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
24238 encoder,
24239 offset + cur_offset,
24240 depth,
24241 )?;
24242
24243 _prev_end_offset = cur_offset + envelope_size;
24244 if 2 > max_ordinal {
24245 return Ok(());
24246 }
24247
24248 let cur_offset: usize = (2 - 1) * envelope_size;
24251
24252 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24254
24255 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
24260 self.source_name.as_ref().map(
24261 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
24262 ),
24263 encoder,
24264 offset + cur_offset,
24265 depth,
24266 )?;
24267
24268 _prev_end_offset = cur_offset + envelope_size;
24269 if 3 > max_ordinal {
24270 return Ok(());
24271 }
24272
24273 let cur_offset: usize = (3 - 1) * envelope_size;
24276
24277 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24279
24280 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
24285 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
24286 encoder, offset + cur_offset, depth
24287 )?;
24288
24289 _prev_end_offset = cur_offset + envelope_size;
24290
24291 Ok(())
24292 }
24293 }
24294
24295 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseRunner {
24296 #[inline(always)]
24297 fn new_empty() -> Self {
24298 Self::default()
24299 }
24300
24301 unsafe fn decode(
24302 &mut self,
24303 decoder: &mut fidl::encoding::Decoder<'_, D>,
24304 offset: usize,
24305 mut depth: fidl::encoding::Depth,
24306 ) -> fidl::Result<()> {
24307 decoder.debug_check_bounds::<Self>(offset);
24308 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
24309 None => return Err(fidl::Error::NotNullable),
24310 Some(len) => len,
24311 };
24312 if len == 0 {
24314 return Ok(());
24315 };
24316 depth.increment()?;
24317 let envelope_size = 8;
24318 let bytes_len = len * envelope_size;
24319 let offset = decoder.out_of_line_offset(bytes_len)?;
24320 let mut _next_ordinal_to_read = 0;
24322 let mut next_offset = offset;
24323 let end_offset = offset + bytes_len;
24324 _next_ordinal_to_read += 1;
24325 if next_offset >= end_offset {
24326 return Ok(());
24327 }
24328
24329 while _next_ordinal_to_read < 1 {
24331 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24332 _next_ordinal_to_read += 1;
24333 next_offset += envelope_size;
24334 }
24335
24336 let next_out_of_line = decoder.next_out_of_line();
24337 let handles_before = decoder.remaining_handles();
24338 if let Some((inlined, num_bytes, num_handles)) =
24339 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24340 {
24341 let member_inline_size =
24342 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24343 if inlined != (member_inline_size <= 4) {
24344 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24345 }
24346 let inner_offset;
24347 let mut inner_depth = depth.clone();
24348 if inlined {
24349 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24350 inner_offset = next_offset;
24351 } else {
24352 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24353 inner_depth.increment()?;
24354 }
24355 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
24356 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
24357 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24358 {
24359 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24360 }
24361 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24362 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24363 }
24364 }
24365
24366 next_offset += envelope_size;
24367 _next_ordinal_to_read += 1;
24368 if next_offset >= end_offset {
24369 return Ok(());
24370 }
24371
24372 while _next_ordinal_to_read < 2 {
24374 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24375 _next_ordinal_to_read += 1;
24376 next_offset += envelope_size;
24377 }
24378
24379 let next_out_of_line = decoder.next_out_of_line();
24380 let handles_before = decoder.remaining_handles();
24381 if let Some((inlined, num_bytes, num_handles)) =
24382 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24383 {
24384 let member_inline_size =
24385 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
24386 decoder.context,
24387 );
24388 if inlined != (member_inline_size <= 4) {
24389 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24390 }
24391 let inner_offset;
24392 let mut inner_depth = depth.clone();
24393 if inlined {
24394 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24395 inner_offset = next_offset;
24396 } else {
24397 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24398 inner_depth.increment()?;
24399 }
24400 let val_ref = self
24401 .source_name
24402 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
24403 fidl::decode!(
24404 fidl::encoding::BoundedString<100>,
24405 D,
24406 val_ref,
24407 decoder,
24408 inner_offset,
24409 inner_depth
24410 )?;
24411 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24412 {
24413 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24414 }
24415 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24416 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24417 }
24418 }
24419
24420 next_offset += envelope_size;
24421 _next_ordinal_to_read += 1;
24422 if next_offset >= end_offset {
24423 return Ok(());
24424 }
24425
24426 while _next_ordinal_to_read < 3 {
24428 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24429 _next_ordinal_to_read += 1;
24430 next_offset += envelope_size;
24431 }
24432
24433 let next_out_of_line = decoder.next_out_of_line();
24434 let handles_before = decoder.remaining_handles();
24435 if let Some((inlined, num_bytes, num_handles)) =
24436 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24437 {
24438 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24439 if inlined != (member_inline_size <= 4) {
24440 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24441 }
24442 let inner_offset;
24443 let mut inner_depth = depth.clone();
24444 if inlined {
24445 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24446 inner_offset = next_offset;
24447 } else {
24448 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24449 inner_depth.increment()?;
24450 }
24451 let val_ref = self.source_dictionary.get_or_insert_with(|| {
24452 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
24453 });
24454 fidl::decode!(
24455 fidl::encoding::BoundedString<1024>,
24456 D,
24457 val_ref,
24458 decoder,
24459 inner_offset,
24460 inner_depth
24461 )?;
24462 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24463 {
24464 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24465 }
24466 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24467 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24468 }
24469 }
24470
24471 next_offset += envelope_size;
24472
24473 while next_offset < end_offset {
24475 _next_ordinal_to_read += 1;
24476 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24477 next_offset += envelope_size;
24478 }
24479
24480 Ok(())
24481 }
24482 }
24483
24484 impl UseService {
24485 #[inline(always)]
24486 fn max_ordinal_present(&self) -> u64 {
24487 if let Some(_) = self.source_dictionary {
24488 return 6;
24489 }
24490 if let Some(_) = self.availability {
24491 return 5;
24492 }
24493 if let Some(_) = self.dependency_type {
24494 return 4;
24495 }
24496 if let Some(_) = self.target_path {
24497 return 3;
24498 }
24499 if let Some(_) = self.source_name {
24500 return 2;
24501 }
24502 if let Some(_) = self.source {
24503 return 1;
24504 }
24505 0
24506 }
24507 }
24508
24509 impl fidl::encoding::ValueTypeMarker for UseService {
24510 type Borrowed<'a> = &'a Self;
24511 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24512 value
24513 }
24514 }
24515
24516 unsafe impl fidl::encoding::TypeMarker for UseService {
24517 type Owned = Self;
24518
24519 #[inline(always)]
24520 fn inline_align(_context: fidl::encoding::Context) -> usize {
24521 8
24522 }
24523
24524 #[inline(always)]
24525 fn inline_size(_context: fidl::encoding::Context) -> usize {
24526 16
24527 }
24528 }
24529
24530 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseService, D>
24531 for &UseService
24532 {
24533 unsafe fn encode(
24534 self,
24535 encoder: &mut fidl::encoding::Encoder<'_, D>,
24536 offset: usize,
24537 mut depth: fidl::encoding::Depth,
24538 ) -> fidl::Result<()> {
24539 encoder.debug_check_bounds::<UseService>(offset);
24540 let max_ordinal: u64 = self.max_ordinal_present();
24542 encoder.write_num(max_ordinal, offset);
24543 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
24544 if max_ordinal == 0 {
24546 return Ok(());
24547 }
24548 depth.increment()?;
24549 let envelope_size = 8;
24550 let bytes_len = max_ordinal as usize * envelope_size;
24551 #[allow(unused_variables)]
24552 let offset = encoder.out_of_line_offset(bytes_len);
24553 let mut _prev_end_offset: usize = 0;
24554 if 1 > max_ordinal {
24555 return Ok(());
24556 }
24557
24558 let cur_offset: usize = (1 - 1) * envelope_size;
24561
24562 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24564
24565 fidl::encoding::encode_in_envelope_optional::<Ref, D>(
24570 self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
24571 encoder,
24572 offset + cur_offset,
24573 depth,
24574 )?;
24575
24576 _prev_end_offset = cur_offset + envelope_size;
24577 if 2 > max_ordinal {
24578 return Ok(());
24579 }
24580
24581 let cur_offset: usize = (2 - 1) * envelope_size;
24584
24585 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24587
24588 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
24593 self.source_name.as_ref().map(
24594 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
24595 ),
24596 encoder,
24597 offset + cur_offset,
24598 depth,
24599 )?;
24600
24601 _prev_end_offset = cur_offset + envelope_size;
24602 if 3 > max_ordinal {
24603 return Ok(());
24604 }
24605
24606 let cur_offset: usize = (3 - 1) * envelope_size;
24609
24610 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24612
24613 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
24618 self.target_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
24619 encoder, offset + cur_offset, depth
24620 )?;
24621
24622 _prev_end_offset = cur_offset + envelope_size;
24623 if 4 > max_ordinal {
24624 return Ok(());
24625 }
24626
24627 let cur_offset: usize = (4 - 1) * envelope_size;
24630
24631 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24633
24634 fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
24639 self.dependency_type
24640 .as_ref()
24641 .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
24642 encoder,
24643 offset + cur_offset,
24644 depth,
24645 )?;
24646
24647 _prev_end_offset = cur_offset + envelope_size;
24648 if 5 > max_ordinal {
24649 return Ok(());
24650 }
24651
24652 let cur_offset: usize = (5 - 1) * envelope_size;
24655
24656 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24658
24659 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
24664 self.availability
24665 .as_ref()
24666 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
24667 encoder,
24668 offset + cur_offset,
24669 depth,
24670 )?;
24671
24672 _prev_end_offset = cur_offset + envelope_size;
24673 if 6 > max_ordinal {
24674 return Ok(());
24675 }
24676
24677 let cur_offset: usize = (6 - 1) * envelope_size;
24680
24681 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24683
24684 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
24689 self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
24690 encoder, offset + cur_offset, depth
24691 )?;
24692
24693 _prev_end_offset = cur_offset + envelope_size;
24694
24695 Ok(())
24696 }
24697 }
24698
24699 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseService {
24700 #[inline(always)]
24701 fn new_empty() -> Self {
24702 Self::default()
24703 }
24704
24705 unsafe fn decode(
24706 &mut self,
24707 decoder: &mut fidl::encoding::Decoder<'_, D>,
24708 offset: usize,
24709 mut depth: fidl::encoding::Depth,
24710 ) -> fidl::Result<()> {
24711 decoder.debug_check_bounds::<Self>(offset);
24712 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
24713 None => return Err(fidl::Error::NotNullable),
24714 Some(len) => len,
24715 };
24716 if len == 0 {
24718 return Ok(());
24719 };
24720 depth.increment()?;
24721 let envelope_size = 8;
24722 let bytes_len = len * envelope_size;
24723 let offset = decoder.out_of_line_offset(bytes_len)?;
24724 let mut _next_ordinal_to_read = 0;
24726 let mut next_offset = offset;
24727 let end_offset = offset + bytes_len;
24728 _next_ordinal_to_read += 1;
24729 if next_offset >= end_offset {
24730 return Ok(());
24731 }
24732
24733 while _next_ordinal_to_read < 1 {
24735 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24736 _next_ordinal_to_read += 1;
24737 next_offset += envelope_size;
24738 }
24739
24740 let next_out_of_line = decoder.next_out_of_line();
24741 let handles_before = decoder.remaining_handles();
24742 if let Some((inlined, num_bytes, num_handles)) =
24743 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24744 {
24745 let member_inline_size =
24746 <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24747 if inlined != (member_inline_size <= 4) {
24748 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24749 }
24750 let inner_offset;
24751 let mut inner_depth = depth.clone();
24752 if inlined {
24753 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24754 inner_offset = next_offset;
24755 } else {
24756 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24757 inner_depth.increment()?;
24758 }
24759 let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
24760 fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
24761 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24762 {
24763 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24764 }
24765 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24766 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24767 }
24768 }
24769
24770 next_offset += envelope_size;
24771 _next_ordinal_to_read += 1;
24772 if next_offset >= end_offset {
24773 return Ok(());
24774 }
24775
24776 while _next_ordinal_to_read < 2 {
24778 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24779 _next_ordinal_to_read += 1;
24780 next_offset += envelope_size;
24781 }
24782
24783 let next_out_of_line = decoder.next_out_of_line();
24784 let handles_before = decoder.remaining_handles();
24785 if let Some((inlined, num_bytes, num_handles)) =
24786 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24787 {
24788 let member_inline_size =
24789 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
24790 decoder.context,
24791 );
24792 if inlined != (member_inline_size <= 4) {
24793 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24794 }
24795 let inner_offset;
24796 let mut inner_depth = depth.clone();
24797 if inlined {
24798 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24799 inner_offset = next_offset;
24800 } else {
24801 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24802 inner_depth.increment()?;
24803 }
24804 let val_ref = self
24805 .source_name
24806 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
24807 fidl::decode!(
24808 fidl::encoding::BoundedString<100>,
24809 D,
24810 val_ref,
24811 decoder,
24812 inner_offset,
24813 inner_depth
24814 )?;
24815 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24816 {
24817 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24818 }
24819 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24820 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24821 }
24822 }
24823
24824 next_offset += envelope_size;
24825 _next_ordinal_to_read += 1;
24826 if next_offset >= end_offset {
24827 return Ok(());
24828 }
24829
24830 while _next_ordinal_to_read < 3 {
24832 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24833 _next_ordinal_to_read += 1;
24834 next_offset += envelope_size;
24835 }
24836
24837 let next_out_of_line = decoder.next_out_of_line();
24838 let handles_before = decoder.remaining_handles();
24839 if let Some((inlined, num_bytes, num_handles)) =
24840 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24841 {
24842 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24843 if inlined != (member_inline_size <= 4) {
24844 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24845 }
24846 let inner_offset;
24847 let mut inner_depth = depth.clone();
24848 if inlined {
24849 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24850 inner_offset = next_offset;
24851 } else {
24852 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24853 inner_depth.increment()?;
24854 }
24855 let val_ref = self.target_path.get_or_insert_with(|| {
24856 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
24857 });
24858 fidl::decode!(
24859 fidl::encoding::BoundedString<1024>,
24860 D,
24861 val_ref,
24862 decoder,
24863 inner_offset,
24864 inner_depth
24865 )?;
24866 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24867 {
24868 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24869 }
24870 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24871 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24872 }
24873 }
24874
24875 next_offset += envelope_size;
24876 _next_ordinal_to_read += 1;
24877 if next_offset >= end_offset {
24878 return Ok(());
24879 }
24880
24881 while _next_ordinal_to_read < 4 {
24883 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24884 _next_ordinal_to_read += 1;
24885 next_offset += envelope_size;
24886 }
24887
24888 let next_out_of_line = decoder.next_out_of_line();
24889 let handles_before = decoder.remaining_handles();
24890 if let Some((inlined, num_bytes, num_handles)) =
24891 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24892 {
24893 let member_inline_size =
24894 <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24895 if inlined != (member_inline_size <= 4) {
24896 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24897 }
24898 let inner_offset;
24899 let mut inner_depth = depth.clone();
24900 if inlined {
24901 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24902 inner_offset = next_offset;
24903 } else {
24904 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24905 inner_depth.increment()?;
24906 }
24907 let val_ref =
24908 self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
24909 fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
24910 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24911 {
24912 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24913 }
24914 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24915 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24916 }
24917 }
24918
24919 next_offset += envelope_size;
24920 _next_ordinal_to_read += 1;
24921 if next_offset >= end_offset {
24922 return Ok(());
24923 }
24924
24925 while _next_ordinal_to_read < 5 {
24927 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24928 _next_ordinal_to_read += 1;
24929 next_offset += envelope_size;
24930 }
24931
24932 let next_out_of_line = decoder.next_out_of_line();
24933 let handles_before = decoder.remaining_handles();
24934 if let Some((inlined, num_bytes, num_handles)) =
24935 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24936 {
24937 let member_inline_size =
24938 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24939 if inlined != (member_inline_size <= 4) {
24940 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24941 }
24942 let inner_offset;
24943 let mut inner_depth = depth.clone();
24944 if inlined {
24945 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24946 inner_offset = next_offset;
24947 } else {
24948 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24949 inner_depth.increment()?;
24950 }
24951 let val_ref =
24952 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
24953 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
24954 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24955 {
24956 return Err(fidl::Error::InvalidNumBytesInEnvelope);
24957 }
24958 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24959 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24960 }
24961 }
24962
24963 next_offset += envelope_size;
24964 _next_ordinal_to_read += 1;
24965 if next_offset >= end_offset {
24966 return Ok(());
24967 }
24968
24969 while _next_ordinal_to_read < 6 {
24971 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24972 _next_ordinal_to_read += 1;
24973 next_offset += envelope_size;
24974 }
24975
24976 let next_out_of_line = decoder.next_out_of_line();
24977 let handles_before = decoder.remaining_handles();
24978 if let Some((inlined, num_bytes, num_handles)) =
24979 fidl::encoding::decode_envelope_header(decoder, next_offset)?
24980 {
24981 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24982 if inlined != (member_inline_size <= 4) {
24983 return Err(fidl::Error::InvalidInlineBitInEnvelope);
24984 }
24985 let inner_offset;
24986 let mut inner_depth = depth.clone();
24987 if inlined {
24988 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24989 inner_offset = next_offset;
24990 } else {
24991 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24992 inner_depth.increment()?;
24993 }
24994 let val_ref = self.source_dictionary.get_or_insert_with(|| {
24995 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
24996 });
24997 fidl::decode!(
24998 fidl::encoding::BoundedString<1024>,
24999 D,
25000 val_ref,
25001 decoder,
25002 inner_offset,
25003 inner_depth
25004 )?;
25005 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
25006 {
25007 return Err(fidl::Error::InvalidNumBytesInEnvelope);
25008 }
25009 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25010 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25011 }
25012 }
25013
25014 next_offset += envelope_size;
25015
25016 while next_offset < end_offset {
25018 _next_ordinal_to_read += 1;
25019 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
25020 next_offset += envelope_size;
25021 }
25022
25023 Ok(())
25024 }
25025 }
25026
25027 impl UseStorage {
25028 #[inline(always)]
25029 fn max_ordinal_present(&self) -> u64 {
25030 if let Some(_) = self.availability {
25031 return 3;
25032 }
25033 if let Some(_) = self.target_path {
25034 return 2;
25035 }
25036 if let Some(_) = self.source_name {
25037 return 1;
25038 }
25039 0
25040 }
25041 }
25042
25043 impl fidl::encoding::ValueTypeMarker for UseStorage {
25044 type Borrowed<'a> = &'a Self;
25045 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
25046 value
25047 }
25048 }
25049
25050 unsafe impl fidl::encoding::TypeMarker for UseStorage {
25051 type Owned = Self;
25052
25053 #[inline(always)]
25054 fn inline_align(_context: fidl::encoding::Context) -> usize {
25055 8
25056 }
25057
25058 #[inline(always)]
25059 fn inline_size(_context: fidl::encoding::Context) -> usize {
25060 16
25061 }
25062 }
25063
25064 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseStorage, D>
25065 for &UseStorage
25066 {
25067 unsafe fn encode(
25068 self,
25069 encoder: &mut fidl::encoding::Encoder<'_, D>,
25070 offset: usize,
25071 mut depth: fidl::encoding::Depth,
25072 ) -> fidl::Result<()> {
25073 encoder.debug_check_bounds::<UseStorage>(offset);
25074 let max_ordinal: u64 = self.max_ordinal_present();
25076 encoder.write_num(max_ordinal, offset);
25077 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
25078 if max_ordinal == 0 {
25080 return Ok(());
25081 }
25082 depth.increment()?;
25083 let envelope_size = 8;
25084 let bytes_len = max_ordinal as usize * envelope_size;
25085 #[allow(unused_variables)]
25086 let offset = encoder.out_of_line_offset(bytes_len);
25087 let mut _prev_end_offset: usize = 0;
25088 if 1 > max_ordinal {
25089 return Ok(());
25090 }
25091
25092 let cur_offset: usize = (1 - 1) * envelope_size;
25095
25096 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
25098
25099 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
25104 self.source_name.as_ref().map(
25105 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
25106 ),
25107 encoder,
25108 offset + cur_offset,
25109 depth,
25110 )?;
25111
25112 _prev_end_offset = cur_offset + envelope_size;
25113 if 2 > max_ordinal {
25114 return Ok(());
25115 }
25116
25117 let cur_offset: usize = (2 - 1) * envelope_size;
25120
25121 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
25123
25124 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
25129 self.target_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
25130 encoder, offset + cur_offset, depth
25131 )?;
25132
25133 _prev_end_offset = cur_offset + envelope_size;
25134 if 3 > max_ordinal {
25135 return Ok(());
25136 }
25137
25138 let cur_offset: usize = (3 - 1) * envelope_size;
25141
25142 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
25144
25145 fidl::encoding::encode_in_envelope_optional::<Availability, D>(
25150 self.availability
25151 .as_ref()
25152 .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
25153 encoder,
25154 offset + cur_offset,
25155 depth,
25156 )?;
25157
25158 _prev_end_offset = cur_offset + envelope_size;
25159
25160 Ok(())
25161 }
25162 }
25163
25164 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseStorage {
25165 #[inline(always)]
25166 fn new_empty() -> Self {
25167 Self::default()
25168 }
25169
25170 unsafe fn decode(
25171 &mut self,
25172 decoder: &mut fidl::encoding::Decoder<'_, D>,
25173 offset: usize,
25174 mut depth: fidl::encoding::Depth,
25175 ) -> fidl::Result<()> {
25176 decoder.debug_check_bounds::<Self>(offset);
25177 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
25178 None => return Err(fidl::Error::NotNullable),
25179 Some(len) => len,
25180 };
25181 if len == 0 {
25183 return Ok(());
25184 };
25185 depth.increment()?;
25186 let envelope_size = 8;
25187 let bytes_len = len * envelope_size;
25188 let offset = decoder.out_of_line_offset(bytes_len)?;
25189 let mut _next_ordinal_to_read = 0;
25191 let mut next_offset = offset;
25192 let end_offset = offset + bytes_len;
25193 _next_ordinal_to_read += 1;
25194 if next_offset >= end_offset {
25195 return Ok(());
25196 }
25197
25198 while _next_ordinal_to_read < 1 {
25200 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
25201 _next_ordinal_to_read += 1;
25202 next_offset += envelope_size;
25203 }
25204
25205 let next_out_of_line = decoder.next_out_of_line();
25206 let handles_before = decoder.remaining_handles();
25207 if let Some((inlined, num_bytes, num_handles)) =
25208 fidl::encoding::decode_envelope_header(decoder, next_offset)?
25209 {
25210 let member_inline_size =
25211 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
25212 decoder.context,
25213 );
25214 if inlined != (member_inline_size <= 4) {
25215 return Err(fidl::Error::InvalidInlineBitInEnvelope);
25216 }
25217 let inner_offset;
25218 let mut inner_depth = depth.clone();
25219 if inlined {
25220 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
25221 inner_offset = next_offset;
25222 } else {
25223 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25224 inner_depth.increment()?;
25225 }
25226 let val_ref = self
25227 .source_name
25228 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
25229 fidl::decode!(
25230 fidl::encoding::BoundedString<100>,
25231 D,
25232 val_ref,
25233 decoder,
25234 inner_offset,
25235 inner_depth
25236 )?;
25237 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
25238 {
25239 return Err(fidl::Error::InvalidNumBytesInEnvelope);
25240 }
25241 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25242 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25243 }
25244 }
25245
25246 next_offset += envelope_size;
25247 _next_ordinal_to_read += 1;
25248 if next_offset >= end_offset {
25249 return Ok(());
25250 }
25251
25252 while _next_ordinal_to_read < 2 {
25254 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
25255 _next_ordinal_to_read += 1;
25256 next_offset += envelope_size;
25257 }
25258
25259 let next_out_of_line = decoder.next_out_of_line();
25260 let handles_before = decoder.remaining_handles();
25261 if let Some((inlined, num_bytes, num_handles)) =
25262 fidl::encoding::decode_envelope_header(decoder, next_offset)?
25263 {
25264 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
25265 if inlined != (member_inline_size <= 4) {
25266 return Err(fidl::Error::InvalidInlineBitInEnvelope);
25267 }
25268 let inner_offset;
25269 let mut inner_depth = depth.clone();
25270 if inlined {
25271 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
25272 inner_offset = next_offset;
25273 } else {
25274 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25275 inner_depth.increment()?;
25276 }
25277 let val_ref = self.target_path.get_or_insert_with(|| {
25278 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
25279 });
25280 fidl::decode!(
25281 fidl::encoding::BoundedString<1024>,
25282 D,
25283 val_ref,
25284 decoder,
25285 inner_offset,
25286 inner_depth
25287 )?;
25288 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
25289 {
25290 return Err(fidl::Error::InvalidNumBytesInEnvelope);
25291 }
25292 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25293 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25294 }
25295 }
25296
25297 next_offset += envelope_size;
25298 _next_ordinal_to_read += 1;
25299 if next_offset >= end_offset {
25300 return Ok(());
25301 }
25302
25303 while _next_ordinal_to_read < 3 {
25305 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
25306 _next_ordinal_to_read += 1;
25307 next_offset += envelope_size;
25308 }
25309
25310 let next_out_of_line = decoder.next_out_of_line();
25311 let handles_before = decoder.remaining_handles();
25312 if let Some((inlined, num_bytes, num_handles)) =
25313 fidl::encoding::decode_envelope_header(decoder, next_offset)?
25314 {
25315 let member_inline_size =
25316 <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
25317 if inlined != (member_inline_size <= 4) {
25318 return Err(fidl::Error::InvalidInlineBitInEnvelope);
25319 }
25320 let inner_offset;
25321 let mut inner_depth = depth.clone();
25322 if inlined {
25323 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
25324 inner_offset = next_offset;
25325 } else {
25326 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25327 inner_depth.increment()?;
25328 }
25329 let val_ref =
25330 self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
25331 fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
25332 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
25333 {
25334 return Err(fidl::Error::InvalidNumBytesInEnvelope);
25335 }
25336 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25337 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25338 }
25339 }
25340
25341 next_offset += envelope_size;
25342
25343 while next_offset < end_offset {
25345 _next_ordinal_to_read += 1;
25346 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
25347 next_offset += envelope_size;
25348 }
25349
25350 Ok(())
25351 }
25352 }
25353
25354 impl fidl::encoding::ValueTypeMarker for Capability {
25355 type Borrowed<'a> = &'a Self;
25356 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
25357 value
25358 }
25359 }
25360
25361 unsafe impl fidl::encoding::TypeMarker for Capability {
25362 type Owned = Self;
25363
25364 #[inline(always)]
25365 fn inline_align(_context: fidl::encoding::Context) -> usize {
25366 8
25367 }
25368
25369 #[inline(always)]
25370 fn inline_size(_context: fidl::encoding::Context) -> usize {
25371 16
25372 }
25373 }
25374
25375 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Capability, D>
25376 for &Capability
25377 {
25378 #[inline]
25379 unsafe fn encode(
25380 self,
25381 encoder: &mut fidl::encoding::Encoder<'_, D>,
25382 offset: usize,
25383 _depth: fidl::encoding::Depth,
25384 ) -> fidl::Result<()> {
25385 encoder.debug_check_bounds::<Capability>(offset);
25386 encoder.write_num::<u64>(self.ordinal(), offset);
25387 match self {
25388 Capability::Service(ref val) => fidl::encoding::encode_in_envelope::<Service, D>(
25389 <Service as fidl::encoding::ValueTypeMarker>::borrow(val),
25390 encoder,
25391 offset + 8,
25392 _depth,
25393 ),
25394 Capability::Protocol(ref val) => fidl::encoding::encode_in_envelope::<Protocol, D>(
25395 <Protocol as fidl::encoding::ValueTypeMarker>::borrow(val),
25396 encoder,
25397 offset + 8,
25398 _depth,
25399 ),
25400 Capability::Directory(ref val) => {
25401 fidl::encoding::encode_in_envelope::<Directory, D>(
25402 <Directory as fidl::encoding::ValueTypeMarker>::borrow(val),
25403 encoder,
25404 offset + 8,
25405 _depth,
25406 )
25407 }
25408 Capability::Storage(ref val) => fidl::encoding::encode_in_envelope::<Storage, D>(
25409 <Storage as fidl::encoding::ValueTypeMarker>::borrow(val),
25410 encoder,
25411 offset + 8,
25412 _depth,
25413 ),
25414 Capability::Runner(ref val) => fidl::encoding::encode_in_envelope::<Runner, D>(
25415 <Runner as fidl::encoding::ValueTypeMarker>::borrow(val),
25416 encoder,
25417 offset + 8,
25418 _depth,
25419 ),
25420 Capability::Resolver(ref val) => fidl::encoding::encode_in_envelope::<Resolver, D>(
25421 <Resolver as fidl::encoding::ValueTypeMarker>::borrow(val),
25422 encoder,
25423 offset + 8,
25424 _depth,
25425 ),
25426 Capability::EventStream(ref val) => {
25427 fidl::encoding::encode_in_envelope::<EventStream, D>(
25428 <EventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
25429 encoder,
25430 offset + 8,
25431 _depth,
25432 )
25433 }
25434 Capability::Dictionary(ref val) => {
25435 fidl::encoding::encode_in_envelope::<Dictionary, D>(
25436 <Dictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
25437 encoder,
25438 offset + 8,
25439 _depth,
25440 )
25441 }
25442 Capability::Config(ref val) => {
25443 fidl::encoding::encode_in_envelope::<Configuration, D>(
25444 <Configuration as fidl::encoding::ValueTypeMarker>::borrow(val),
25445 encoder,
25446 offset + 8,
25447 _depth,
25448 )
25449 }
25450 Capability::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
25451 }
25452 }
25453 }
25454
25455 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Capability {
25456 #[inline(always)]
25457 fn new_empty() -> Self {
25458 Self::__SourceBreaking { unknown_ordinal: 0 }
25459 }
25460
25461 #[inline]
25462 unsafe fn decode(
25463 &mut self,
25464 decoder: &mut fidl::encoding::Decoder<'_, D>,
25465 offset: usize,
25466 mut depth: fidl::encoding::Depth,
25467 ) -> fidl::Result<()> {
25468 decoder.debug_check_bounds::<Self>(offset);
25469 #[allow(unused_variables)]
25470 let next_out_of_line = decoder.next_out_of_line();
25471 let handles_before = decoder.remaining_handles();
25472 let (ordinal, inlined, num_bytes, num_handles) =
25473 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
25474
25475 let member_inline_size = match ordinal {
25476 1 => <Service as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25477 2 => <Protocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25478 3 => <Directory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25479 4 => <Storage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25480 5 => <Runner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25481 6 => <Resolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25482 8 => <EventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25483 9 => <Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25484 10 => <Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25485 0 => return Err(fidl::Error::UnknownUnionTag),
25486 _ => num_bytes as usize,
25487 };
25488
25489 if inlined != (member_inline_size <= 4) {
25490 return Err(fidl::Error::InvalidInlineBitInEnvelope);
25491 }
25492 let _inner_offset;
25493 if inlined {
25494 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
25495 _inner_offset = offset + 8;
25496 } else {
25497 depth.increment()?;
25498 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25499 }
25500 match ordinal {
25501 1 => {
25502 #[allow(irrefutable_let_patterns)]
25503 if let Capability::Service(_) = self {
25504 } else {
25506 *self = Capability::Service(fidl::new_empty!(Service, D));
25508 }
25509 #[allow(irrefutable_let_patterns)]
25510 if let Capability::Service(ref mut val) = self {
25511 fidl::decode!(Service, D, val, decoder, _inner_offset, depth)?;
25512 } else {
25513 unreachable!()
25514 }
25515 }
25516 2 => {
25517 #[allow(irrefutable_let_patterns)]
25518 if let Capability::Protocol(_) = self {
25519 } else {
25521 *self = Capability::Protocol(fidl::new_empty!(Protocol, D));
25523 }
25524 #[allow(irrefutable_let_patterns)]
25525 if let Capability::Protocol(ref mut val) = self {
25526 fidl::decode!(Protocol, D, val, decoder, _inner_offset, depth)?;
25527 } else {
25528 unreachable!()
25529 }
25530 }
25531 3 => {
25532 #[allow(irrefutable_let_patterns)]
25533 if let Capability::Directory(_) = self {
25534 } else {
25536 *self = Capability::Directory(fidl::new_empty!(Directory, D));
25538 }
25539 #[allow(irrefutable_let_patterns)]
25540 if let Capability::Directory(ref mut val) = self {
25541 fidl::decode!(Directory, D, val, decoder, _inner_offset, depth)?;
25542 } else {
25543 unreachable!()
25544 }
25545 }
25546 4 => {
25547 #[allow(irrefutable_let_patterns)]
25548 if let Capability::Storage(_) = self {
25549 } else {
25551 *self = Capability::Storage(fidl::new_empty!(Storage, D));
25553 }
25554 #[allow(irrefutable_let_patterns)]
25555 if let Capability::Storage(ref mut val) = self {
25556 fidl::decode!(Storage, D, val, decoder, _inner_offset, depth)?;
25557 } else {
25558 unreachable!()
25559 }
25560 }
25561 5 => {
25562 #[allow(irrefutable_let_patterns)]
25563 if let Capability::Runner(_) = self {
25564 } else {
25566 *self = Capability::Runner(fidl::new_empty!(Runner, D));
25568 }
25569 #[allow(irrefutable_let_patterns)]
25570 if let Capability::Runner(ref mut val) = self {
25571 fidl::decode!(Runner, D, val, decoder, _inner_offset, depth)?;
25572 } else {
25573 unreachable!()
25574 }
25575 }
25576 6 => {
25577 #[allow(irrefutable_let_patterns)]
25578 if let Capability::Resolver(_) = self {
25579 } else {
25581 *self = Capability::Resolver(fidl::new_empty!(Resolver, D));
25583 }
25584 #[allow(irrefutable_let_patterns)]
25585 if let Capability::Resolver(ref mut val) = self {
25586 fidl::decode!(Resolver, D, val, decoder, _inner_offset, depth)?;
25587 } else {
25588 unreachable!()
25589 }
25590 }
25591 8 => {
25592 #[allow(irrefutable_let_patterns)]
25593 if let Capability::EventStream(_) = self {
25594 } else {
25596 *self = Capability::EventStream(fidl::new_empty!(EventStream, D));
25598 }
25599 #[allow(irrefutable_let_patterns)]
25600 if let Capability::EventStream(ref mut val) = self {
25601 fidl::decode!(EventStream, D, val, decoder, _inner_offset, depth)?;
25602 } else {
25603 unreachable!()
25604 }
25605 }
25606 9 => {
25607 #[allow(irrefutable_let_patterns)]
25608 if let Capability::Dictionary(_) = self {
25609 } else {
25611 *self = Capability::Dictionary(fidl::new_empty!(Dictionary, D));
25613 }
25614 #[allow(irrefutable_let_patterns)]
25615 if let Capability::Dictionary(ref mut val) = self {
25616 fidl::decode!(Dictionary, D, val, decoder, _inner_offset, depth)?;
25617 } else {
25618 unreachable!()
25619 }
25620 }
25621 10 => {
25622 #[allow(irrefutable_let_patterns)]
25623 if let Capability::Config(_) = self {
25624 } else {
25626 *self = Capability::Config(fidl::new_empty!(Configuration, D));
25628 }
25629 #[allow(irrefutable_let_patterns)]
25630 if let Capability::Config(ref mut val) = self {
25631 fidl::decode!(Configuration, D, val, decoder, _inner_offset, depth)?;
25632 } else {
25633 unreachable!()
25634 }
25635 }
25636 #[allow(deprecated)]
25637 ordinal => {
25638 for _ in 0..num_handles {
25639 decoder.drop_next_handle()?;
25640 }
25641 *self = Capability::__SourceBreaking { unknown_ordinal: ordinal };
25642 }
25643 }
25644 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
25645 return Err(fidl::Error::InvalidNumBytesInEnvelope);
25646 }
25647 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25648 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25649 }
25650 Ok(())
25651 }
25652 }
25653
25654 impl fidl::encoding::ValueTypeMarker for ConfigChecksum {
25655 type Borrowed<'a> = &'a Self;
25656 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
25657 value
25658 }
25659 }
25660
25661 unsafe impl fidl::encoding::TypeMarker for ConfigChecksum {
25662 type Owned = Self;
25663
25664 #[inline(always)]
25665 fn inline_align(_context: fidl::encoding::Context) -> usize {
25666 8
25667 }
25668
25669 #[inline(always)]
25670 fn inline_size(_context: fidl::encoding::Context) -> usize {
25671 16
25672 }
25673 }
25674
25675 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigChecksum, D>
25676 for &ConfigChecksum
25677 {
25678 #[inline]
25679 unsafe fn encode(
25680 self,
25681 encoder: &mut fidl::encoding::Encoder<'_, D>,
25682 offset: usize,
25683 _depth: fidl::encoding::Depth,
25684 ) -> fidl::Result<()> {
25685 encoder.debug_check_bounds::<ConfigChecksum>(offset);
25686 encoder.write_num::<u64>(self.ordinal(), offset);
25687 match self {
25688 ConfigChecksum::Sha256(ref val) => fidl::encoding::encode_in_envelope::<
25689 fidl::encoding::Array<u8, 32>,
25690 D,
25691 >(
25692 <fidl::encoding::Array<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(val),
25693 encoder,
25694 offset + 8,
25695 _depth,
25696 ),
25697 ConfigChecksum::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
25698 }
25699 }
25700 }
25701
25702 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigChecksum {
25703 #[inline(always)]
25704 fn new_empty() -> Self {
25705 Self::__SourceBreaking { unknown_ordinal: 0 }
25706 }
25707
25708 #[inline]
25709 unsafe fn decode(
25710 &mut self,
25711 decoder: &mut fidl::encoding::Decoder<'_, D>,
25712 offset: usize,
25713 mut depth: fidl::encoding::Depth,
25714 ) -> fidl::Result<()> {
25715 decoder.debug_check_bounds::<Self>(offset);
25716 #[allow(unused_variables)]
25717 let next_out_of_line = decoder.next_out_of_line();
25718 let handles_before = decoder.remaining_handles();
25719 let (ordinal, inlined, num_bytes, num_handles) =
25720 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
25721
25722 let member_inline_size = match ordinal {
25723 1 => <fidl::encoding::Array<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
25724 decoder.context,
25725 ),
25726 0 => return Err(fidl::Error::UnknownUnionTag),
25727 _ => num_bytes as usize,
25728 };
25729
25730 if inlined != (member_inline_size <= 4) {
25731 return Err(fidl::Error::InvalidInlineBitInEnvelope);
25732 }
25733 let _inner_offset;
25734 if inlined {
25735 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
25736 _inner_offset = offset + 8;
25737 } else {
25738 depth.increment()?;
25739 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25740 }
25741 match ordinal {
25742 1 => {
25743 #[allow(irrefutable_let_patterns)]
25744 if let ConfigChecksum::Sha256(_) = self {
25745 } else {
25747 *self = ConfigChecksum::Sha256(
25749 fidl::new_empty!(fidl::encoding::Array<u8, 32>, D),
25750 );
25751 }
25752 #[allow(irrefutable_let_patterns)]
25753 if let ConfigChecksum::Sha256(ref mut val) = self {
25754 fidl::decode!(fidl::encoding::Array<u8, 32>, D, val, decoder, _inner_offset, depth)?;
25755 } else {
25756 unreachable!()
25757 }
25758 }
25759 #[allow(deprecated)]
25760 ordinal => {
25761 for _ in 0..num_handles {
25762 decoder.drop_next_handle()?;
25763 }
25764 *self = ConfigChecksum::__SourceBreaking { unknown_ordinal: ordinal };
25765 }
25766 }
25767 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
25768 return Err(fidl::Error::InvalidNumBytesInEnvelope);
25769 }
25770 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25771 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25772 }
25773 Ok(())
25774 }
25775 }
25776
25777 impl fidl::encoding::ValueTypeMarker for ConfigSingleValue {
25778 type Borrowed<'a> = &'a Self;
25779 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
25780 value
25781 }
25782 }
25783
25784 unsafe impl fidl::encoding::TypeMarker for ConfigSingleValue {
25785 type Owned = Self;
25786
25787 #[inline(always)]
25788 fn inline_align(_context: fidl::encoding::Context) -> usize {
25789 8
25790 }
25791
25792 #[inline(always)]
25793 fn inline_size(_context: fidl::encoding::Context) -> usize {
25794 16
25795 }
25796 }
25797
25798 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigSingleValue, D>
25799 for &ConfigSingleValue
25800 {
25801 #[inline]
25802 unsafe fn encode(
25803 self,
25804 encoder: &mut fidl::encoding::Encoder<'_, D>,
25805 offset: usize,
25806 _depth: fidl::encoding::Depth,
25807 ) -> fidl::Result<()> {
25808 encoder.debug_check_bounds::<ConfigSingleValue>(offset);
25809 encoder.write_num::<u64>(self.ordinal(), offset);
25810 match self {
25811 ConfigSingleValue::Bool(ref val) => fidl::encoding::encode_in_envelope::<bool, D>(
25812 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
25813 encoder,
25814 offset + 8,
25815 _depth,
25816 ),
25817 ConfigSingleValue::Uint8(ref val) => fidl::encoding::encode_in_envelope::<u8, D>(
25818 <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
25819 encoder,
25820 offset + 8,
25821 _depth,
25822 ),
25823 ConfigSingleValue::Uint16(ref val) => fidl::encoding::encode_in_envelope::<u16, D>(
25824 <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
25825 encoder,
25826 offset + 8,
25827 _depth,
25828 ),
25829 ConfigSingleValue::Uint32(ref val) => fidl::encoding::encode_in_envelope::<u32, D>(
25830 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
25831 encoder,
25832 offset + 8,
25833 _depth,
25834 ),
25835 ConfigSingleValue::Uint64(ref val) => fidl::encoding::encode_in_envelope::<u64, D>(
25836 <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
25837 encoder,
25838 offset + 8,
25839 _depth,
25840 ),
25841 ConfigSingleValue::Int8(ref val) => fidl::encoding::encode_in_envelope::<i8, D>(
25842 <i8 as fidl::encoding::ValueTypeMarker>::borrow(val),
25843 encoder,
25844 offset + 8,
25845 _depth,
25846 ),
25847 ConfigSingleValue::Int16(ref val) => fidl::encoding::encode_in_envelope::<i16, D>(
25848 <i16 as fidl::encoding::ValueTypeMarker>::borrow(val),
25849 encoder,
25850 offset + 8,
25851 _depth,
25852 ),
25853 ConfigSingleValue::Int32(ref val) => fidl::encoding::encode_in_envelope::<i32, D>(
25854 <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
25855 encoder,
25856 offset + 8,
25857 _depth,
25858 ),
25859 ConfigSingleValue::Int64(ref val) => fidl::encoding::encode_in_envelope::<i64, D>(
25860 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
25861 encoder,
25862 offset + 8,
25863 _depth,
25864 ),
25865 ConfigSingleValue::String(ref val) => fidl::encoding::encode_in_envelope::<
25866 fidl::encoding::UnboundedString,
25867 D,
25868 >(
25869 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
25870 val,
25871 ),
25872 encoder,
25873 offset + 8,
25874 _depth,
25875 ),
25876 ConfigSingleValue::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
25877 }
25878 }
25879 }
25880
25881 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigSingleValue {
25882 #[inline(always)]
25883 fn new_empty() -> Self {
25884 Self::__SourceBreaking { unknown_ordinal: 0 }
25885 }
25886
25887 #[inline]
25888 unsafe fn decode(
25889 &mut self,
25890 decoder: &mut fidl::encoding::Decoder<'_, D>,
25891 offset: usize,
25892 mut depth: fidl::encoding::Depth,
25893 ) -> fidl::Result<()> {
25894 decoder.debug_check_bounds::<Self>(offset);
25895 #[allow(unused_variables)]
25896 let next_out_of_line = decoder.next_out_of_line();
25897 let handles_before = decoder.remaining_handles();
25898 let (ordinal, inlined, num_bytes, num_handles) =
25899 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
25900
25901 let member_inline_size = match ordinal {
25902 1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25903 2 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25904 3 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25905 4 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25906 5 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25907 6 => <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25908 7 => <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25909 8 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25910 9 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25911 10 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
25912 decoder.context,
25913 ),
25914 0 => return Err(fidl::Error::UnknownUnionTag),
25915 _ => num_bytes as usize,
25916 };
25917
25918 if inlined != (member_inline_size <= 4) {
25919 return Err(fidl::Error::InvalidInlineBitInEnvelope);
25920 }
25921 let _inner_offset;
25922 if inlined {
25923 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
25924 _inner_offset = offset + 8;
25925 } else {
25926 depth.increment()?;
25927 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25928 }
25929 match ordinal {
25930 1 => {
25931 #[allow(irrefutable_let_patterns)]
25932 if let ConfigSingleValue::Bool(_) = self {
25933 } else {
25935 *self = ConfigSingleValue::Bool(fidl::new_empty!(bool, D));
25937 }
25938 #[allow(irrefutable_let_patterns)]
25939 if let ConfigSingleValue::Bool(ref mut val) = self {
25940 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
25941 } else {
25942 unreachable!()
25943 }
25944 }
25945 2 => {
25946 #[allow(irrefutable_let_patterns)]
25947 if let ConfigSingleValue::Uint8(_) = self {
25948 } else {
25950 *self = ConfigSingleValue::Uint8(fidl::new_empty!(u8, D));
25952 }
25953 #[allow(irrefutable_let_patterns)]
25954 if let ConfigSingleValue::Uint8(ref mut val) = self {
25955 fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
25956 } else {
25957 unreachable!()
25958 }
25959 }
25960 3 => {
25961 #[allow(irrefutable_let_patterns)]
25962 if let ConfigSingleValue::Uint16(_) = self {
25963 } else {
25965 *self = ConfigSingleValue::Uint16(fidl::new_empty!(u16, D));
25967 }
25968 #[allow(irrefutable_let_patterns)]
25969 if let ConfigSingleValue::Uint16(ref mut val) = self {
25970 fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
25971 } else {
25972 unreachable!()
25973 }
25974 }
25975 4 => {
25976 #[allow(irrefutable_let_patterns)]
25977 if let ConfigSingleValue::Uint32(_) = self {
25978 } else {
25980 *self = ConfigSingleValue::Uint32(fidl::new_empty!(u32, D));
25982 }
25983 #[allow(irrefutable_let_patterns)]
25984 if let ConfigSingleValue::Uint32(ref mut val) = self {
25985 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
25986 } else {
25987 unreachable!()
25988 }
25989 }
25990 5 => {
25991 #[allow(irrefutable_let_patterns)]
25992 if let ConfigSingleValue::Uint64(_) = self {
25993 } else {
25995 *self = ConfigSingleValue::Uint64(fidl::new_empty!(u64, D));
25997 }
25998 #[allow(irrefutable_let_patterns)]
25999 if let ConfigSingleValue::Uint64(ref mut val) = self {
26000 fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
26001 } else {
26002 unreachable!()
26003 }
26004 }
26005 6 => {
26006 #[allow(irrefutable_let_patterns)]
26007 if let ConfigSingleValue::Int8(_) = self {
26008 } else {
26010 *self = ConfigSingleValue::Int8(fidl::new_empty!(i8, D));
26012 }
26013 #[allow(irrefutable_let_patterns)]
26014 if let ConfigSingleValue::Int8(ref mut val) = self {
26015 fidl::decode!(i8, D, val, decoder, _inner_offset, depth)?;
26016 } else {
26017 unreachable!()
26018 }
26019 }
26020 7 => {
26021 #[allow(irrefutable_let_patterns)]
26022 if let ConfigSingleValue::Int16(_) = self {
26023 } else {
26025 *self = ConfigSingleValue::Int16(fidl::new_empty!(i16, D));
26027 }
26028 #[allow(irrefutable_let_patterns)]
26029 if let ConfigSingleValue::Int16(ref mut val) = self {
26030 fidl::decode!(i16, D, val, decoder, _inner_offset, depth)?;
26031 } else {
26032 unreachable!()
26033 }
26034 }
26035 8 => {
26036 #[allow(irrefutable_let_patterns)]
26037 if let ConfigSingleValue::Int32(_) = self {
26038 } else {
26040 *self = ConfigSingleValue::Int32(fidl::new_empty!(i32, D));
26042 }
26043 #[allow(irrefutable_let_patterns)]
26044 if let ConfigSingleValue::Int32(ref mut val) = self {
26045 fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
26046 } else {
26047 unreachable!()
26048 }
26049 }
26050 9 => {
26051 #[allow(irrefutable_let_patterns)]
26052 if let ConfigSingleValue::Int64(_) = self {
26053 } else {
26055 *self = ConfigSingleValue::Int64(fidl::new_empty!(i64, D));
26057 }
26058 #[allow(irrefutable_let_patterns)]
26059 if let ConfigSingleValue::Int64(ref mut val) = self {
26060 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
26061 } else {
26062 unreachable!()
26063 }
26064 }
26065 10 => {
26066 #[allow(irrefutable_let_patterns)]
26067 if let ConfigSingleValue::String(_) = self {
26068 } else {
26070 *self = ConfigSingleValue::String(fidl::new_empty!(
26072 fidl::encoding::UnboundedString,
26073 D
26074 ));
26075 }
26076 #[allow(irrefutable_let_patterns)]
26077 if let ConfigSingleValue::String(ref mut val) = self {
26078 fidl::decode!(
26079 fidl::encoding::UnboundedString,
26080 D,
26081 val,
26082 decoder,
26083 _inner_offset,
26084 depth
26085 )?;
26086 } else {
26087 unreachable!()
26088 }
26089 }
26090 #[allow(deprecated)]
26091 ordinal => {
26092 for _ in 0..num_handles {
26093 decoder.drop_next_handle()?;
26094 }
26095 *self = ConfigSingleValue::__SourceBreaking { unknown_ordinal: ordinal };
26096 }
26097 }
26098 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
26099 return Err(fidl::Error::InvalidNumBytesInEnvelope);
26100 }
26101 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
26102 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
26103 }
26104 Ok(())
26105 }
26106 }
26107
26108 impl fidl::encoding::ValueTypeMarker for ConfigValue {
26109 type Borrowed<'a> = &'a Self;
26110 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
26111 value
26112 }
26113 }
26114
26115 unsafe impl fidl::encoding::TypeMarker for ConfigValue {
26116 type Owned = Self;
26117
26118 #[inline(always)]
26119 fn inline_align(_context: fidl::encoding::Context) -> usize {
26120 8
26121 }
26122
26123 #[inline(always)]
26124 fn inline_size(_context: fidl::encoding::Context) -> usize {
26125 16
26126 }
26127 }
26128
26129 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigValue, D>
26130 for &ConfigValue
26131 {
26132 #[inline]
26133 unsafe fn encode(
26134 self,
26135 encoder: &mut fidl::encoding::Encoder<'_, D>,
26136 offset: usize,
26137 _depth: fidl::encoding::Depth,
26138 ) -> fidl::Result<()> {
26139 encoder.debug_check_bounds::<ConfigValue>(offset);
26140 encoder.write_num::<u64>(self.ordinal(), offset);
26141 match self {
26142 ConfigValue::Single(ref val) => {
26143 fidl::encoding::encode_in_envelope::<ConfigSingleValue, D>(
26144 <ConfigSingleValue as fidl::encoding::ValueTypeMarker>::borrow(val),
26145 encoder,
26146 offset + 8,
26147 _depth,
26148 )
26149 }
26150 ConfigValue::Vector(ref val) => {
26151 fidl::encoding::encode_in_envelope::<ConfigVectorValue, D>(
26152 <ConfigVectorValue as fidl::encoding::ValueTypeMarker>::borrow(val),
26153 encoder,
26154 offset + 8,
26155 _depth,
26156 )
26157 }
26158 ConfigValue::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
26159 }
26160 }
26161 }
26162
26163 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigValue {
26164 #[inline(always)]
26165 fn new_empty() -> Self {
26166 Self::__SourceBreaking { unknown_ordinal: 0 }
26167 }
26168
26169 #[inline]
26170 unsafe fn decode(
26171 &mut self,
26172 decoder: &mut fidl::encoding::Decoder<'_, D>,
26173 offset: usize,
26174 mut depth: fidl::encoding::Depth,
26175 ) -> fidl::Result<()> {
26176 decoder.debug_check_bounds::<Self>(offset);
26177 #[allow(unused_variables)]
26178 let next_out_of_line = decoder.next_out_of_line();
26179 let handles_before = decoder.remaining_handles();
26180 let (ordinal, inlined, num_bytes, num_handles) =
26181 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
26182
26183 let member_inline_size = match ordinal {
26184 1 => {
26185 <ConfigSingleValue as fidl::encoding::TypeMarker>::inline_size(decoder.context)
26186 }
26187 2 => {
26188 <ConfigVectorValue as fidl::encoding::TypeMarker>::inline_size(decoder.context)
26189 }
26190 0 => return Err(fidl::Error::UnknownUnionTag),
26191 _ => num_bytes as usize,
26192 };
26193
26194 if inlined != (member_inline_size <= 4) {
26195 return Err(fidl::Error::InvalidInlineBitInEnvelope);
26196 }
26197 let _inner_offset;
26198 if inlined {
26199 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
26200 _inner_offset = offset + 8;
26201 } else {
26202 depth.increment()?;
26203 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
26204 }
26205 match ordinal {
26206 1 => {
26207 #[allow(irrefutable_let_patterns)]
26208 if let ConfigValue::Single(_) = self {
26209 } else {
26211 *self = ConfigValue::Single(fidl::new_empty!(ConfigSingleValue, D));
26213 }
26214 #[allow(irrefutable_let_patterns)]
26215 if let ConfigValue::Single(ref mut val) = self {
26216 fidl::decode!(ConfigSingleValue, D, val, decoder, _inner_offset, depth)?;
26217 } else {
26218 unreachable!()
26219 }
26220 }
26221 2 => {
26222 #[allow(irrefutable_let_patterns)]
26223 if let ConfigValue::Vector(_) = self {
26224 } else {
26226 *self = ConfigValue::Vector(fidl::new_empty!(ConfigVectorValue, D));
26228 }
26229 #[allow(irrefutable_let_patterns)]
26230 if let ConfigValue::Vector(ref mut val) = self {
26231 fidl::decode!(ConfigVectorValue, D, val, decoder, _inner_offset, depth)?;
26232 } else {
26233 unreachable!()
26234 }
26235 }
26236 #[allow(deprecated)]
26237 ordinal => {
26238 for _ in 0..num_handles {
26239 decoder.drop_next_handle()?;
26240 }
26241 *self = ConfigValue::__SourceBreaking { unknown_ordinal: ordinal };
26242 }
26243 }
26244 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
26245 return Err(fidl::Error::InvalidNumBytesInEnvelope);
26246 }
26247 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
26248 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
26249 }
26250 Ok(())
26251 }
26252 }
26253
26254 impl fidl::encoding::ValueTypeMarker for ConfigValueSource {
26255 type Borrowed<'a> = &'a Self;
26256 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
26257 value
26258 }
26259 }
26260
26261 unsafe impl fidl::encoding::TypeMarker for ConfigValueSource {
26262 type Owned = Self;
26263
26264 #[inline(always)]
26265 fn inline_align(_context: fidl::encoding::Context) -> usize {
26266 8
26267 }
26268
26269 #[inline(always)]
26270 fn inline_size(_context: fidl::encoding::Context) -> usize {
26271 16
26272 }
26273 }
26274
26275 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigValueSource, D>
26276 for &ConfigValueSource
26277 {
26278 #[inline]
26279 unsafe fn encode(
26280 self,
26281 encoder: &mut fidl::encoding::Encoder<'_, D>,
26282 offset: usize,
26283 _depth: fidl::encoding::Depth,
26284 ) -> fidl::Result<()> {
26285 encoder.debug_check_bounds::<ConfigValueSource>(offset);
26286 encoder.write_num::<u64>(self.ordinal(), offset);
26287 match self {
26288 ConfigValueSource::PackagePath(ref val) => fidl::encoding::encode_in_envelope::<
26289 fidl::encoding::UnboundedString,
26290 D,
26291 >(
26292 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
26293 val,
26294 ),
26295 encoder,
26296 offset + 8,
26297 _depth,
26298 ),
26299 ConfigValueSource::Capabilities(ref val) => {
26300 fidl::encoding::encode_in_envelope::<ConfigSourceCapabilities, D>(
26301 <ConfigSourceCapabilities as fidl::encoding::ValueTypeMarker>::borrow(val),
26302 encoder,
26303 offset + 8,
26304 _depth,
26305 )
26306 }
26307 ConfigValueSource::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
26308 }
26309 }
26310 }
26311
26312 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigValueSource {
26313 #[inline(always)]
26314 fn new_empty() -> Self {
26315 Self::__SourceBreaking { unknown_ordinal: 0 }
26316 }
26317
26318 #[inline]
26319 unsafe fn decode(
26320 &mut self,
26321 decoder: &mut fidl::encoding::Decoder<'_, D>,
26322 offset: usize,
26323 mut depth: fidl::encoding::Depth,
26324 ) -> fidl::Result<()> {
26325 decoder.debug_check_bounds::<Self>(offset);
26326 #[allow(unused_variables)]
26327 let next_out_of_line = decoder.next_out_of_line();
26328 let handles_before = decoder.remaining_handles();
26329 let (ordinal, inlined, num_bytes, num_handles) =
26330 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
26331
26332 let member_inline_size = match ordinal {
26333 1 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
26334 decoder.context,
26335 ),
26336 2 => <ConfigSourceCapabilities as fidl::encoding::TypeMarker>::inline_size(
26337 decoder.context,
26338 ),
26339 0 => return Err(fidl::Error::UnknownUnionTag),
26340 _ => num_bytes as usize,
26341 };
26342
26343 if inlined != (member_inline_size <= 4) {
26344 return Err(fidl::Error::InvalidInlineBitInEnvelope);
26345 }
26346 let _inner_offset;
26347 if inlined {
26348 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
26349 _inner_offset = offset + 8;
26350 } else {
26351 depth.increment()?;
26352 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
26353 }
26354 match ordinal {
26355 1 => {
26356 #[allow(irrefutable_let_patterns)]
26357 if let ConfigValueSource::PackagePath(_) = self {
26358 } else {
26360 *self = ConfigValueSource::PackagePath(fidl::new_empty!(
26362 fidl::encoding::UnboundedString,
26363 D
26364 ));
26365 }
26366 #[allow(irrefutable_let_patterns)]
26367 if let ConfigValueSource::PackagePath(ref mut val) = self {
26368 fidl::decode!(
26369 fidl::encoding::UnboundedString,
26370 D,
26371 val,
26372 decoder,
26373 _inner_offset,
26374 depth
26375 )?;
26376 } else {
26377 unreachable!()
26378 }
26379 }
26380 2 => {
26381 #[allow(irrefutable_let_patterns)]
26382 if let ConfigValueSource::Capabilities(_) = self {
26383 } else {
26385 *self = ConfigValueSource::Capabilities(fidl::new_empty!(
26387 ConfigSourceCapabilities,
26388 D
26389 ));
26390 }
26391 #[allow(irrefutable_let_patterns)]
26392 if let ConfigValueSource::Capabilities(ref mut val) = self {
26393 fidl::decode!(
26394 ConfigSourceCapabilities,
26395 D,
26396 val,
26397 decoder,
26398 _inner_offset,
26399 depth
26400 )?;
26401 } else {
26402 unreachable!()
26403 }
26404 }
26405 #[allow(deprecated)]
26406 ordinal => {
26407 for _ in 0..num_handles {
26408 decoder.drop_next_handle()?;
26409 }
26410 *self = ConfigValueSource::__SourceBreaking { unknown_ordinal: ordinal };
26411 }
26412 }
26413 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
26414 return Err(fidl::Error::InvalidNumBytesInEnvelope);
26415 }
26416 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
26417 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
26418 }
26419 Ok(())
26420 }
26421 }
26422
26423 impl fidl::encoding::ValueTypeMarker for ConfigVectorValue {
26424 type Borrowed<'a> = &'a Self;
26425 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
26426 value
26427 }
26428 }
26429
26430 unsafe impl fidl::encoding::TypeMarker for ConfigVectorValue {
26431 type Owned = Self;
26432
26433 #[inline(always)]
26434 fn inline_align(_context: fidl::encoding::Context) -> usize {
26435 8
26436 }
26437
26438 #[inline(always)]
26439 fn inline_size(_context: fidl::encoding::Context) -> usize {
26440 16
26441 }
26442 }
26443
26444 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigVectorValue, D>
26445 for &ConfigVectorValue
26446 {
26447 #[inline]
26448 unsafe fn encode(
26449 self,
26450 encoder: &mut fidl::encoding::Encoder<'_, D>,
26451 offset: usize,
26452 _depth: fidl::encoding::Depth,
26453 ) -> fidl::Result<()> {
26454 encoder.debug_check_bounds::<ConfigVectorValue>(offset);
26455 encoder.write_num::<u64>(self.ordinal(), offset);
26456 match self {
26457 ConfigVectorValue::BoolVector(ref val) => {
26458 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<bool>, D>(
26459 <fidl::encoding::UnboundedVector<bool> as fidl::encoding::ValueTypeMarker>::borrow(val),
26460 encoder, offset + 8, _depth
26461 )
26462 }
26463 ConfigVectorValue::Uint8Vector(ref val) => {
26464 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u8>, D>(
26465 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(val),
26466 encoder, offset + 8, _depth
26467 )
26468 }
26469 ConfigVectorValue::Uint16Vector(ref val) => {
26470 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u16>, D>(
26471 <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(val),
26472 encoder, offset + 8, _depth
26473 )
26474 }
26475 ConfigVectorValue::Uint32Vector(ref val) => {
26476 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u32>, D>(
26477 <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(val),
26478 encoder, offset + 8, _depth
26479 )
26480 }
26481 ConfigVectorValue::Uint64Vector(ref val) => {
26482 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u64>, D>(
26483 <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(val),
26484 encoder, offset + 8, _depth
26485 )
26486 }
26487 ConfigVectorValue::Int8Vector(ref val) => {
26488 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<i8>, D>(
26489 <fidl::encoding::UnboundedVector<i8> as fidl::encoding::ValueTypeMarker>::borrow(val),
26490 encoder, offset + 8, _depth
26491 )
26492 }
26493 ConfigVectorValue::Int16Vector(ref val) => {
26494 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<i16>, D>(
26495 <fidl::encoding::UnboundedVector<i16> as fidl::encoding::ValueTypeMarker>::borrow(val),
26496 encoder, offset + 8, _depth
26497 )
26498 }
26499 ConfigVectorValue::Int32Vector(ref val) => {
26500 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<i32>, D>(
26501 <fidl::encoding::UnboundedVector<i32> as fidl::encoding::ValueTypeMarker>::borrow(val),
26502 encoder, offset + 8, _depth
26503 )
26504 }
26505 ConfigVectorValue::Int64Vector(ref val) => {
26506 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<i64>, D>(
26507 <fidl::encoding::UnboundedVector<i64> as fidl::encoding::ValueTypeMarker>::borrow(val),
26508 encoder, offset + 8, _depth
26509 )
26510 }
26511 ConfigVectorValue::StringVector(ref val) => {
26512 fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>, D>(
26513 <fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(val),
26514 encoder, offset + 8, _depth
26515 )
26516 }
26517 ConfigVectorValue::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
26518 }
26519 }
26520 }
26521
26522 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigVectorValue {
26523 #[inline(always)]
26524 fn new_empty() -> Self {
26525 Self::__SourceBreaking { unknown_ordinal: 0 }
26526 }
26527
26528 #[inline]
26529 unsafe fn decode(
26530 &mut self,
26531 decoder: &mut fidl::encoding::Decoder<'_, D>,
26532 offset: usize,
26533 mut depth: fidl::encoding::Depth,
26534 ) -> fidl::Result<()> {
26535 decoder.debug_check_bounds::<Self>(offset);
26536 #[allow(unused_variables)]
26537 let next_out_of_line = decoder.next_out_of_line();
26538 let handles_before = decoder.remaining_handles();
26539 let (ordinal, inlined, num_bytes, num_handles) =
26540 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
26541
26542 let member_inline_size = match ordinal {
26543 1 => <fidl::encoding::UnboundedVector<bool> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26544 2 => <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26545 3 => <fidl::encoding::UnboundedVector<u16> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26546 4 => <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26547 5 => <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26548 6 => <fidl::encoding::UnboundedVector<i8> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26549 7 => <fidl::encoding::UnboundedVector<i16> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26550 8 => <fidl::encoding::UnboundedVector<i32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26551 9 => <fidl::encoding::UnboundedVector<i64> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26552 10 => <fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26553 0 => return Err(fidl::Error::UnknownUnionTag),
26554 _ => num_bytes as usize,
26555 };
26556
26557 if inlined != (member_inline_size <= 4) {
26558 return Err(fidl::Error::InvalidInlineBitInEnvelope);
26559 }
26560 let _inner_offset;
26561 if inlined {
26562 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
26563 _inner_offset = offset + 8;
26564 } else {
26565 depth.increment()?;
26566 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
26567 }
26568 match ordinal {
26569 1 => {
26570 #[allow(irrefutable_let_patterns)]
26571 if let ConfigVectorValue::BoolVector(_) = self {
26572 } else {
26574 *self = ConfigVectorValue::BoolVector(fidl::new_empty!(
26576 fidl::encoding::UnboundedVector<bool>,
26577 D
26578 ));
26579 }
26580 #[allow(irrefutable_let_patterns)]
26581 if let ConfigVectorValue::BoolVector(ref mut val) = self {
26582 fidl::decode!(
26583 fidl::encoding::UnboundedVector<bool>,
26584 D,
26585 val,
26586 decoder,
26587 _inner_offset,
26588 depth
26589 )?;
26590 } else {
26591 unreachable!()
26592 }
26593 }
26594 2 => {
26595 #[allow(irrefutable_let_patterns)]
26596 if let ConfigVectorValue::Uint8Vector(_) = self {
26597 } else {
26599 *self = ConfigVectorValue::Uint8Vector(fidl::new_empty!(
26601 fidl::encoding::UnboundedVector<u8>,
26602 D
26603 ));
26604 }
26605 #[allow(irrefutable_let_patterns)]
26606 if let ConfigVectorValue::Uint8Vector(ref mut val) = self {
26607 fidl::decode!(
26608 fidl::encoding::UnboundedVector<u8>,
26609 D,
26610 val,
26611 decoder,
26612 _inner_offset,
26613 depth
26614 )?;
26615 } else {
26616 unreachable!()
26617 }
26618 }
26619 3 => {
26620 #[allow(irrefutable_let_patterns)]
26621 if let ConfigVectorValue::Uint16Vector(_) = self {
26622 } else {
26624 *self = ConfigVectorValue::Uint16Vector(fidl::new_empty!(
26626 fidl::encoding::UnboundedVector<u16>,
26627 D
26628 ));
26629 }
26630 #[allow(irrefutable_let_patterns)]
26631 if let ConfigVectorValue::Uint16Vector(ref mut val) = self {
26632 fidl::decode!(
26633 fidl::encoding::UnboundedVector<u16>,
26634 D,
26635 val,
26636 decoder,
26637 _inner_offset,
26638 depth
26639 )?;
26640 } else {
26641 unreachable!()
26642 }
26643 }
26644 4 => {
26645 #[allow(irrefutable_let_patterns)]
26646 if let ConfigVectorValue::Uint32Vector(_) = self {
26647 } else {
26649 *self = ConfigVectorValue::Uint32Vector(fidl::new_empty!(
26651 fidl::encoding::UnboundedVector<u32>,
26652 D
26653 ));
26654 }
26655 #[allow(irrefutable_let_patterns)]
26656 if let ConfigVectorValue::Uint32Vector(ref mut val) = self {
26657 fidl::decode!(
26658 fidl::encoding::UnboundedVector<u32>,
26659 D,
26660 val,
26661 decoder,
26662 _inner_offset,
26663 depth
26664 )?;
26665 } else {
26666 unreachable!()
26667 }
26668 }
26669 5 => {
26670 #[allow(irrefutable_let_patterns)]
26671 if let ConfigVectorValue::Uint64Vector(_) = self {
26672 } else {
26674 *self = ConfigVectorValue::Uint64Vector(fidl::new_empty!(
26676 fidl::encoding::UnboundedVector<u64>,
26677 D
26678 ));
26679 }
26680 #[allow(irrefutable_let_patterns)]
26681 if let ConfigVectorValue::Uint64Vector(ref mut val) = self {
26682 fidl::decode!(
26683 fidl::encoding::UnboundedVector<u64>,
26684 D,
26685 val,
26686 decoder,
26687 _inner_offset,
26688 depth
26689 )?;
26690 } else {
26691 unreachable!()
26692 }
26693 }
26694 6 => {
26695 #[allow(irrefutable_let_patterns)]
26696 if let ConfigVectorValue::Int8Vector(_) = self {
26697 } else {
26699 *self = ConfigVectorValue::Int8Vector(fidl::new_empty!(
26701 fidl::encoding::UnboundedVector<i8>,
26702 D
26703 ));
26704 }
26705 #[allow(irrefutable_let_patterns)]
26706 if let ConfigVectorValue::Int8Vector(ref mut val) = self {
26707 fidl::decode!(
26708 fidl::encoding::UnboundedVector<i8>,
26709 D,
26710 val,
26711 decoder,
26712 _inner_offset,
26713 depth
26714 )?;
26715 } else {
26716 unreachable!()
26717 }
26718 }
26719 7 => {
26720 #[allow(irrefutable_let_patterns)]
26721 if let ConfigVectorValue::Int16Vector(_) = self {
26722 } else {
26724 *self = ConfigVectorValue::Int16Vector(fidl::new_empty!(
26726 fidl::encoding::UnboundedVector<i16>,
26727 D
26728 ));
26729 }
26730 #[allow(irrefutable_let_patterns)]
26731 if let ConfigVectorValue::Int16Vector(ref mut val) = self {
26732 fidl::decode!(
26733 fidl::encoding::UnboundedVector<i16>,
26734 D,
26735 val,
26736 decoder,
26737 _inner_offset,
26738 depth
26739 )?;
26740 } else {
26741 unreachable!()
26742 }
26743 }
26744 8 => {
26745 #[allow(irrefutable_let_patterns)]
26746 if let ConfigVectorValue::Int32Vector(_) = self {
26747 } else {
26749 *self = ConfigVectorValue::Int32Vector(fidl::new_empty!(
26751 fidl::encoding::UnboundedVector<i32>,
26752 D
26753 ));
26754 }
26755 #[allow(irrefutable_let_patterns)]
26756 if let ConfigVectorValue::Int32Vector(ref mut val) = self {
26757 fidl::decode!(
26758 fidl::encoding::UnboundedVector<i32>,
26759 D,
26760 val,
26761 decoder,
26762 _inner_offset,
26763 depth
26764 )?;
26765 } else {
26766 unreachable!()
26767 }
26768 }
26769 9 => {
26770 #[allow(irrefutable_let_patterns)]
26771 if let ConfigVectorValue::Int64Vector(_) = self {
26772 } else {
26774 *self = ConfigVectorValue::Int64Vector(fidl::new_empty!(
26776 fidl::encoding::UnboundedVector<i64>,
26777 D
26778 ));
26779 }
26780 #[allow(irrefutable_let_patterns)]
26781 if let ConfigVectorValue::Int64Vector(ref mut val) = self {
26782 fidl::decode!(
26783 fidl::encoding::UnboundedVector<i64>,
26784 D,
26785 val,
26786 decoder,
26787 _inner_offset,
26788 depth
26789 )?;
26790 } else {
26791 unreachable!()
26792 }
26793 }
26794 10 => {
26795 #[allow(irrefutable_let_patterns)]
26796 if let ConfigVectorValue::StringVector(_) = self {
26797 } else {
26799 *self = ConfigVectorValue::StringVector(fidl::new_empty!(
26801 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
26802 D
26803 ));
26804 }
26805 #[allow(irrefutable_let_patterns)]
26806 if let ConfigVectorValue::StringVector(ref mut val) = self {
26807 fidl::decode!(
26808 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
26809 D,
26810 val,
26811 decoder,
26812 _inner_offset,
26813 depth
26814 )?;
26815 } else {
26816 unreachable!()
26817 }
26818 }
26819 #[allow(deprecated)]
26820 ordinal => {
26821 for _ in 0..num_handles {
26822 decoder.drop_next_handle()?;
26823 }
26824 *self = ConfigVectorValue::__SourceBreaking { unknown_ordinal: ordinal };
26825 }
26826 }
26827 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
26828 return Err(fidl::Error::InvalidNumBytesInEnvelope);
26829 }
26830 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
26831 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
26832 }
26833 Ok(())
26834 }
26835 }
26836
26837 impl fidl::encoding::ValueTypeMarker for DebugRegistration {
26838 type Borrowed<'a> = &'a Self;
26839 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
26840 value
26841 }
26842 }
26843
26844 unsafe impl fidl::encoding::TypeMarker for DebugRegistration {
26845 type Owned = Self;
26846
26847 #[inline(always)]
26848 fn inline_align(_context: fidl::encoding::Context) -> usize {
26849 8
26850 }
26851
26852 #[inline(always)]
26853 fn inline_size(_context: fidl::encoding::Context) -> usize {
26854 16
26855 }
26856 }
26857
26858 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DebugRegistration, D>
26859 for &DebugRegistration
26860 {
26861 #[inline]
26862 unsafe fn encode(
26863 self,
26864 encoder: &mut fidl::encoding::Encoder<'_, D>,
26865 offset: usize,
26866 _depth: fidl::encoding::Depth,
26867 ) -> fidl::Result<()> {
26868 encoder.debug_check_bounds::<DebugRegistration>(offset);
26869 encoder.write_num::<u64>(self.ordinal(), offset);
26870 match self {
26871 DebugRegistration::Protocol(ref val) => {
26872 fidl::encoding::encode_in_envelope::<DebugProtocolRegistration, D>(
26873 <DebugProtocolRegistration as fidl::encoding::ValueTypeMarker>::borrow(val),
26874 encoder,
26875 offset + 8,
26876 _depth,
26877 )
26878 }
26879 DebugRegistration::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
26880 }
26881 }
26882 }
26883
26884 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DebugRegistration {
26885 #[inline(always)]
26886 fn new_empty() -> Self {
26887 Self::__SourceBreaking { unknown_ordinal: 0 }
26888 }
26889
26890 #[inline]
26891 unsafe fn decode(
26892 &mut self,
26893 decoder: &mut fidl::encoding::Decoder<'_, D>,
26894 offset: usize,
26895 mut depth: fidl::encoding::Depth,
26896 ) -> fidl::Result<()> {
26897 decoder.debug_check_bounds::<Self>(offset);
26898 #[allow(unused_variables)]
26899 let next_out_of_line = decoder.next_out_of_line();
26900 let handles_before = decoder.remaining_handles();
26901 let (ordinal, inlined, num_bytes, num_handles) =
26902 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
26903
26904 let member_inline_size = match ordinal {
26905 1 => <DebugProtocolRegistration as fidl::encoding::TypeMarker>::inline_size(
26906 decoder.context,
26907 ),
26908 0 => return Err(fidl::Error::UnknownUnionTag),
26909 _ => num_bytes as usize,
26910 };
26911
26912 if inlined != (member_inline_size <= 4) {
26913 return Err(fidl::Error::InvalidInlineBitInEnvelope);
26914 }
26915 let _inner_offset;
26916 if inlined {
26917 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
26918 _inner_offset = offset + 8;
26919 } else {
26920 depth.increment()?;
26921 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
26922 }
26923 match ordinal {
26924 1 => {
26925 #[allow(irrefutable_let_patterns)]
26926 if let DebugRegistration::Protocol(_) = self {
26927 } else {
26929 *self = DebugRegistration::Protocol(fidl::new_empty!(
26931 DebugProtocolRegistration,
26932 D
26933 ));
26934 }
26935 #[allow(irrefutable_let_patterns)]
26936 if let DebugRegistration::Protocol(ref mut val) = self {
26937 fidl::decode!(
26938 DebugProtocolRegistration,
26939 D,
26940 val,
26941 decoder,
26942 _inner_offset,
26943 depth
26944 )?;
26945 } else {
26946 unreachable!()
26947 }
26948 }
26949 #[allow(deprecated)]
26950 ordinal => {
26951 for _ in 0..num_handles {
26952 decoder.drop_next_handle()?;
26953 }
26954 *self = DebugRegistration::__SourceBreaking { unknown_ordinal: ordinal };
26955 }
26956 }
26957 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
26958 return Err(fidl::Error::InvalidNumBytesInEnvelope);
26959 }
26960 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
26961 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
26962 }
26963 Ok(())
26964 }
26965 }
26966
26967 impl fidl::encoding::ValueTypeMarker for Expose {
26968 type Borrowed<'a> = &'a Self;
26969 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
26970 value
26971 }
26972 }
26973
26974 unsafe impl fidl::encoding::TypeMarker for Expose {
26975 type Owned = Self;
26976
26977 #[inline(always)]
26978 fn inline_align(_context: fidl::encoding::Context) -> usize {
26979 8
26980 }
26981
26982 #[inline(always)]
26983 fn inline_size(_context: fidl::encoding::Context) -> usize {
26984 16
26985 }
26986 }
26987
26988 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Expose, D> for &Expose {
26989 #[inline]
26990 unsafe fn encode(
26991 self,
26992 encoder: &mut fidl::encoding::Encoder<'_, D>,
26993 offset: usize,
26994 _depth: fidl::encoding::Depth,
26995 ) -> fidl::Result<()> {
26996 encoder.debug_check_bounds::<Expose>(offset);
26997 encoder.write_num::<u64>(self.ordinal(), offset);
26998 match self {
26999 Expose::Service(ref val) => fidl::encoding::encode_in_envelope::<ExposeService, D>(
27000 <ExposeService as fidl::encoding::ValueTypeMarker>::borrow(val),
27001 encoder,
27002 offset + 8,
27003 _depth,
27004 ),
27005 Expose::Protocol(ref val) => {
27006 fidl::encoding::encode_in_envelope::<ExposeProtocol, D>(
27007 <ExposeProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
27008 encoder,
27009 offset + 8,
27010 _depth,
27011 )
27012 }
27013 Expose::Directory(ref val) => {
27014 fidl::encoding::encode_in_envelope::<ExposeDirectory, D>(
27015 <ExposeDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
27016 encoder,
27017 offset + 8,
27018 _depth,
27019 )
27020 }
27021 Expose::Runner(ref val) => fidl::encoding::encode_in_envelope::<ExposeRunner, D>(
27022 <ExposeRunner as fidl::encoding::ValueTypeMarker>::borrow(val),
27023 encoder,
27024 offset + 8,
27025 _depth,
27026 ),
27027 Expose::Resolver(ref val) => {
27028 fidl::encoding::encode_in_envelope::<ExposeResolver, D>(
27029 <ExposeResolver as fidl::encoding::ValueTypeMarker>::borrow(val),
27030 encoder,
27031 offset + 8,
27032 _depth,
27033 )
27034 }
27035 Expose::Dictionary(ref val) => {
27036 fidl::encoding::encode_in_envelope::<ExposeDictionary, D>(
27037 <ExposeDictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
27038 encoder,
27039 offset + 8,
27040 _depth,
27041 )
27042 }
27043 Expose::Config(ref val) => {
27044 fidl::encoding::encode_in_envelope::<ExposeConfiguration, D>(
27045 <ExposeConfiguration as fidl::encoding::ValueTypeMarker>::borrow(val),
27046 encoder,
27047 offset + 8,
27048 _depth,
27049 )
27050 }
27051 Expose::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
27052 }
27053 }
27054 }
27055
27056 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Expose {
27057 #[inline(always)]
27058 fn new_empty() -> Self {
27059 Self::__SourceBreaking { unknown_ordinal: 0 }
27060 }
27061
27062 #[inline]
27063 unsafe fn decode(
27064 &mut self,
27065 decoder: &mut fidl::encoding::Decoder<'_, D>,
27066 offset: usize,
27067 mut depth: fidl::encoding::Depth,
27068 ) -> fidl::Result<()> {
27069 decoder.debug_check_bounds::<Self>(offset);
27070 #[allow(unused_variables)]
27071 let next_out_of_line = decoder.next_out_of_line();
27072 let handles_before = decoder.remaining_handles();
27073 let (ordinal, inlined, num_bytes, num_handles) =
27074 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
27075
27076 let member_inline_size = match ordinal {
27077 1 => <ExposeService as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27078 2 => <ExposeProtocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27079 3 => <ExposeDirectory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27080 4 => <ExposeRunner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27081 5 => <ExposeResolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27082 7 => <ExposeDictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27083 8 => <ExposeConfiguration as fidl::encoding::TypeMarker>::inline_size(
27084 decoder.context,
27085 ),
27086 0 => return Err(fidl::Error::UnknownUnionTag),
27087 _ => num_bytes as usize,
27088 };
27089
27090 if inlined != (member_inline_size <= 4) {
27091 return Err(fidl::Error::InvalidInlineBitInEnvelope);
27092 }
27093 let _inner_offset;
27094 if inlined {
27095 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
27096 _inner_offset = offset + 8;
27097 } else {
27098 depth.increment()?;
27099 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
27100 }
27101 match ordinal {
27102 1 => {
27103 #[allow(irrefutable_let_patterns)]
27104 if let Expose::Service(_) = self {
27105 } else {
27107 *self = Expose::Service(fidl::new_empty!(ExposeService, D));
27109 }
27110 #[allow(irrefutable_let_patterns)]
27111 if let Expose::Service(ref mut val) = self {
27112 fidl::decode!(ExposeService, D, val, decoder, _inner_offset, depth)?;
27113 } else {
27114 unreachable!()
27115 }
27116 }
27117 2 => {
27118 #[allow(irrefutable_let_patterns)]
27119 if let Expose::Protocol(_) = self {
27120 } else {
27122 *self = Expose::Protocol(fidl::new_empty!(ExposeProtocol, D));
27124 }
27125 #[allow(irrefutable_let_patterns)]
27126 if let Expose::Protocol(ref mut val) = self {
27127 fidl::decode!(ExposeProtocol, D, val, decoder, _inner_offset, depth)?;
27128 } else {
27129 unreachable!()
27130 }
27131 }
27132 3 => {
27133 #[allow(irrefutable_let_patterns)]
27134 if let Expose::Directory(_) = self {
27135 } else {
27137 *self = Expose::Directory(fidl::new_empty!(ExposeDirectory, D));
27139 }
27140 #[allow(irrefutable_let_patterns)]
27141 if let Expose::Directory(ref mut val) = self {
27142 fidl::decode!(ExposeDirectory, D, val, decoder, _inner_offset, depth)?;
27143 } else {
27144 unreachable!()
27145 }
27146 }
27147 4 => {
27148 #[allow(irrefutable_let_patterns)]
27149 if let Expose::Runner(_) = self {
27150 } else {
27152 *self = Expose::Runner(fidl::new_empty!(ExposeRunner, D));
27154 }
27155 #[allow(irrefutable_let_patterns)]
27156 if let Expose::Runner(ref mut val) = self {
27157 fidl::decode!(ExposeRunner, D, val, decoder, _inner_offset, depth)?;
27158 } else {
27159 unreachable!()
27160 }
27161 }
27162 5 => {
27163 #[allow(irrefutable_let_patterns)]
27164 if let Expose::Resolver(_) = self {
27165 } else {
27167 *self = Expose::Resolver(fidl::new_empty!(ExposeResolver, D));
27169 }
27170 #[allow(irrefutable_let_patterns)]
27171 if let Expose::Resolver(ref mut val) = self {
27172 fidl::decode!(ExposeResolver, D, val, decoder, _inner_offset, depth)?;
27173 } else {
27174 unreachable!()
27175 }
27176 }
27177 7 => {
27178 #[allow(irrefutable_let_patterns)]
27179 if let Expose::Dictionary(_) = self {
27180 } else {
27182 *self = Expose::Dictionary(fidl::new_empty!(ExposeDictionary, D));
27184 }
27185 #[allow(irrefutable_let_patterns)]
27186 if let Expose::Dictionary(ref mut val) = self {
27187 fidl::decode!(ExposeDictionary, D, val, decoder, _inner_offset, depth)?;
27188 } else {
27189 unreachable!()
27190 }
27191 }
27192 8 => {
27193 #[allow(irrefutable_let_patterns)]
27194 if let Expose::Config(_) = self {
27195 } else {
27197 *self = Expose::Config(fidl::new_empty!(ExposeConfiguration, D));
27199 }
27200 #[allow(irrefutable_let_patterns)]
27201 if let Expose::Config(ref mut val) = self {
27202 fidl::decode!(ExposeConfiguration, D, val, decoder, _inner_offset, depth)?;
27203 } else {
27204 unreachable!()
27205 }
27206 }
27207 #[allow(deprecated)]
27208 ordinal => {
27209 for _ in 0..num_handles {
27210 decoder.drop_next_handle()?;
27211 }
27212 *self = Expose::__SourceBreaking { unknown_ordinal: ordinal };
27213 }
27214 }
27215 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
27216 return Err(fidl::Error::InvalidNumBytesInEnvelope);
27217 }
27218 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
27219 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
27220 }
27221 Ok(())
27222 }
27223 }
27224
27225 impl fidl::encoding::ValueTypeMarker for LayoutConstraint {
27226 type Borrowed<'a> = &'a Self;
27227 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
27228 value
27229 }
27230 }
27231
27232 unsafe impl fidl::encoding::TypeMarker for LayoutConstraint {
27233 type Owned = Self;
27234
27235 #[inline(always)]
27236 fn inline_align(_context: fidl::encoding::Context) -> usize {
27237 8
27238 }
27239
27240 #[inline(always)]
27241 fn inline_size(_context: fidl::encoding::Context) -> usize {
27242 16
27243 }
27244 }
27245
27246 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LayoutConstraint, D>
27247 for &LayoutConstraint
27248 {
27249 #[inline]
27250 unsafe fn encode(
27251 self,
27252 encoder: &mut fidl::encoding::Encoder<'_, D>,
27253 offset: usize,
27254 _depth: fidl::encoding::Depth,
27255 ) -> fidl::Result<()> {
27256 encoder.debug_check_bounds::<LayoutConstraint>(offset);
27257 encoder.write_num::<u64>(self.ordinal(), offset);
27258 match self {
27259 LayoutConstraint::MaxSize(ref val) => fidl::encoding::encode_in_envelope::<u32, D>(
27260 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
27261 encoder,
27262 offset + 8,
27263 _depth,
27264 ),
27265 LayoutConstraint::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
27266 }
27267 }
27268 }
27269
27270 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LayoutConstraint {
27271 #[inline(always)]
27272 fn new_empty() -> Self {
27273 Self::__SourceBreaking { unknown_ordinal: 0 }
27274 }
27275
27276 #[inline]
27277 unsafe fn decode(
27278 &mut self,
27279 decoder: &mut fidl::encoding::Decoder<'_, D>,
27280 offset: usize,
27281 mut depth: fidl::encoding::Depth,
27282 ) -> fidl::Result<()> {
27283 decoder.debug_check_bounds::<Self>(offset);
27284 #[allow(unused_variables)]
27285 let next_out_of_line = decoder.next_out_of_line();
27286 let handles_before = decoder.remaining_handles();
27287 let (ordinal, inlined, num_bytes, num_handles) =
27288 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
27289
27290 let member_inline_size = match ordinal {
27291 1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27292 0 => return Err(fidl::Error::UnknownUnionTag),
27293 _ => num_bytes as usize,
27294 };
27295
27296 if inlined != (member_inline_size <= 4) {
27297 return Err(fidl::Error::InvalidInlineBitInEnvelope);
27298 }
27299 let _inner_offset;
27300 if inlined {
27301 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
27302 _inner_offset = offset + 8;
27303 } else {
27304 depth.increment()?;
27305 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
27306 }
27307 match ordinal {
27308 1 => {
27309 #[allow(irrefutable_let_patterns)]
27310 if let LayoutConstraint::MaxSize(_) = self {
27311 } else {
27313 *self = LayoutConstraint::MaxSize(fidl::new_empty!(u32, D));
27315 }
27316 #[allow(irrefutable_let_patterns)]
27317 if let LayoutConstraint::MaxSize(ref mut val) = self {
27318 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
27319 } else {
27320 unreachable!()
27321 }
27322 }
27323 #[allow(deprecated)]
27324 ordinal => {
27325 for _ in 0..num_handles {
27326 decoder.drop_next_handle()?;
27327 }
27328 *self = LayoutConstraint::__SourceBreaking { unknown_ordinal: ordinal };
27329 }
27330 }
27331 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
27332 return Err(fidl::Error::InvalidNumBytesInEnvelope);
27333 }
27334 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
27335 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
27336 }
27337 Ok(())
27338 }
27339 }
27340
27341 impl fidl::encoding::ValueTypeMarker for LayoutParameter {
27342 type Borrowed<'a> = &'a Self;
27343 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
27344 value
27345 }
27346 }
27347
27348 unsafe impl fidl::encoding::TypeMarker for LayoutParameter {
27349 type Owned = Self;
27350
27351 #[inline(always)]
27352 fn inline_align(_context: fidl::encoding::Context) -> usize {
27353 8
27354 }
27355
27356 #[inline(always)]
27357 fn inline_size(_context: fidl::encoding::Context) -> usize {
27358 16
27359 }
27360 }
27361
27362 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LayoutParameter, D>
27363 for &LayoutParameter
27364 {
27365 #[inline]
27366 unsafe fn encode(
27367 self,
27368 encoder: &mut fidl::encoding::Encoder<'_, D>,
27369 offset: usize,
27370 _depth: fidl::encoding::Depth,
27371 ) -> fidl::Result<()> {
27372 encoder.debug_check_bounds::<LayoutParameter>(offset);
27373 encoder.write_num::<u64>(self.ordinal(), offset);
27374 match self {
27375 LayoutParameter::NestedType(ref val) => {
27376 fidl::encoding::encode_in_envelope::<ConfigType, D>(
27377 <ConfigType as fidl::encoding::ValueTypeMarker>::borrow(val),
27378 encoder,
27379 offset + 8,
27380 _depth,
27381 )
27382 }
27383 LayoutParameter::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
27384 }
27385 }
27386 }
27387
27388 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LayoutParameter {
27389 #[inline(always)]
27390 fn new_empty() -> Self {
27391 Self::__SourceBreaking { unknown_ordinal: 0 }
27392 }
27393
27394 #[inline]
27395 unsafe fn decode(
27396 &mut self,
27397 decoder: &mut fidl::encoding::Decoder<'_, D>,
27398 offset: usize,
27399 mut depth: fidl::encoding::Depth,
27400 ) -> fidl::Result<()> {
27401 decoder.debug_check_bounds::<Self>(offset);
27402 #[allow(unused_variables)]
27403 let next_out_of_line = decoder.next_out_of_line();
27404 let handles_before = decoder.remaining_handles();
27405 let (ordinal, inlined, num_bytes, num_handles) =
27406 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
27407
27408 let member_inline_size = match ordinal {
27409 1 => <ConfigType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27410 0 => return Err(fidl::Error::UnknownUnionTag),
27411 _ => num_bytes as usize,
27412 };
27413
27414 if inlined != (member_inline_size <= 4) {
27415 return Err(fidl::Error::InvalidInlineBitInEnvelope);
27416 }
27417 let _inner_offset;
27418 if inlined {
27419 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
27420 _inner_offset = offset + 8;
27421 } else {
27422 depth.increment()?;
27423 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
27424 }
27425 match ordinal {
27426 1 => {
27427 #[allow(irrefutable_let_patterns)]
27428 if let LayoutParameter::NestedType(_) = self {
27429 } else {
27431 *self = LayoutParameter::NestedType(fidl::new_empty!(ConfigType, D));
27433 }
27434 #[allow(irrefutable_let_patterns)]
27435 if let LayoutParameter::NestedType(ref mut val) = self {
27436 fidl::decode!(ConfigType, D, val, decoder, _inner_offset, depth)?;
27437 } else {
27438 unreachable!()
27439 }
27440 }
27441 #[allow(deprecated)]
27442 ordinal => {
27443 for _ in 0..num_handles {
27444 decoder.drop_next_handle()?;
27445 }
27446 *self = LayoutParameter::__SourceBreaking { unknown_ordinal: ordinal };
27447 }
27448 }
27449 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
27450 return Err(fidl::Error::InvalidNumBytesInEnvelope);
27451 }
27452 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
27453 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
27454 }
27455 Ok(())
27456 }
27457 }
27458
27459 impl fidl::encoding::ValueTypeMarker for Offer {
27460 type Borrowed<'a> = &'a Self;
27461 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
27462 value
27463 }
27464 }
27465
27466 unsafe impl fidl::encoding::TypeMarker for Offer {
27467 type Owned = Self;
27468
27469 #[inline(always)]
27470 fn inline_align(_context: fidl::encoding::Context) -> usize {
27471 8
27472 }
27473
27474 #[inline(always)]
27475 fn inline_size(_context: fidl::encoding::Context) -> usize {
27476 16
27477 }
27478 }
27479
27480 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Offer, D> for &Offer {
27481 #[inline]
27482 unsafe fn encode(
27483 self,
27484 encoder: &mut fidl::encoding::Encoder<'_, D>,
27485 offset: usize,
27486 _depth: fidl::encoding::Depth,
27487 ) -> fidl::Result<()> {
27488 encoder.debug_check_bounds::<Offer>(offset);
27489 encoder.write_num::<u64>(self.ordinal(), offset);
27490 match self {
27491 Offer::Service(ref val) => fidl::encoding::encode_in_envelope::<OfferService, D>(
27492 <OfferService as fidl::encoding::ValueTypeMarker>::borrow(val),
27493 encoder,
27494 offset + 8,
27495 _depth,
27496 ),
27497 Offer::Protocol(ref val) => fidl::encoding::encode_in_envelope::<OfferProtocol, D>(
27498 <OfferProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
27499 encoder,
27500 offset + 8,
27501 _depth,
27502 ),
27503 Offer::Directory(ref val) => {
27504 fidl::encoding::encode_in_envelope::<OfferDirectory, D>(
27505 <OfferDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
27506 encoder,
27507 offset + 8,
27508 _depth,
27509 )
27510 }
27511 Offer::Storage(ref val) => fidl::encoding::encode_in_envelope::<OfferStorage, D>(
27512 <OfferStorage as fidl::encoding::ValueTypeMarker>::borrow(val),
27513 encoder,
27514 offset + 8,
27515 _depth,
27516 ),
27517 Offer::Runner(ref val) => fidl::encoding::encode_in_envelope::<OfferRunner, D>(
27518 <OfferRunner as fidl::encoding::ValueTypeMarker>::borrow(val),
27519 encoder,
27520 offset + 8,
27521 _depth,
27522 ),
27523 Offer::Resolver(ref val) => fidl::encoding::encode_in_envelope::<OfferResolver, D>(
27524 <OfferResolver as fidl::encoding::ValueTypeMarker>::borrow(val),
27525 encoder,
27526 offset + 8,
27527 _depth,
27528 ),
27529 Offer::EventStream(ref val) => {
27530 fidl::encoding::encode_in_envelope::<OfferEventStream, D>(
27531 <OfferEventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
27532 encoder,
27533 offset + 8,
27534 _depth,
27535 )
27536 }
27537 Offer::Dictionary(ref val) => {
27538 fidl::encoding::encode_in_envelope::<OfferDictionary, D>(
27539 <OfferDictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
27540 encoder,
27541 offset + 8,
27542 _depth,
27543 )
27544 }
27545 Offer::Config(ref val) => {
27546 fidl::encoding::encode_in_envelope::<OfferConfiguration, D>(
27547 <OfferConfiguration as fidl::encoding::ValueTypeMarker>::borrow(val),
27548 encoder,
27549 offset + 8,
27550 _depth,
27551 )
27552 }
27553 Offer::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
27554 }
27555 }
27556 }
27557
27558 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Offer {
27559 #[inline(always)]
27560 fn new_empty() -> Self {
27561 Self::__SourceBreaking { unknown_ordinal: 0 }
27562 }
27563
27564 #[inline]
27565 unsafe fn decode(
27566 &mut self,
27567 decoder: &mut fidl::encoding::Decoder<'_, D>,
27568 offset: usize,
27569 mut depth: fidl::encoding::Depth,
27570 ) -> fidl::Result<()> {
27571 decoder.debug_check_bounds::<Self>(offset);
27572 #[allow(unused_variables)]
27573 let next_out_of_line = decoder.next_out_of_line();
27574 let handles_before = decoder.remaining_handles();
27575 let (ordinal, inlined, num_bytes, num_handles) =
27576 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
27577
27578 let member_inline_size = match ordinal {
27579 1 => <OfferService as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27580 2 => <OfferProtocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27581 3 => <OfferDirectory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27582 4 => <OfferStorage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27583 5 => <OfferRunner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27584 6 => <OfferResolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27585 8 => <OfferEventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27586 9 => <OfferDictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27587 10 => {
27588 <OfferConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context)
27589 }
27590 0 => return Err(fidl::Error::UnknownUnionTag),
27591 _ => num_bytes as usize,
27592 };
27593
27594 if inlined != (member_inline_size <= 4) {
27595 return Err(fidl::Error::InvalidInlineBitInEnvelope);
27596 }
27597 let _inner_offset;
27598 if inlined {
27599 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
27600 _inner_offset = offset + 8;
27601 } else {
27602 depth.increment()?;
27603 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
27604 }
27605 match ordinal {
27606 1 => {
27607 #[allow(irrefutable_let_patterns)]
27608 if let Offer::Service(_) = self {
27609 } else {
27611 *self = Offer::Service(fidl::new_empty!(OfferService, D));
27613 }
27614 #[allow(irrefutable_let_patterns)]
27615 if let Offer::Service(ref mut val) = self {
27616 fidl::decode!(OfferService, D, val, decoder, _inner_offset, depth)?;
27617 } else {
27618 unreachable!()
27619 }
27620 }
27621 2 => {
27622 #[allow(irrefutable_let_patterns)]
27623 if let Offer::Protocol(_) = self {
27624 } else {
27626 *self = Offer::Protocol(fidl::new_empty!(OfferProtocol, D));
27628 }
27629 #[allow(irrefutable_let_patterns)]
27630 if let Offer::Protocol(ref mut val) = self {
27631 fidl::decode!(OfferProtocol, D, val, decoder, _inner_offset, depth)?;
27632 } else {
27633 unreachable!()
27634 }
27635 }
27636 3 => {
27637 #[allow(irrefutable_let_patterns)]
27638 if let Offer::Directory(_) = self {
27639 } else {
27641 *self = Offer::Directory(fidl::new_empty!(OfferDirectory, D));
27643 }
27644 #[allow(irrefutable_let_patterns)]
27645 if let Offer::Directory(ref mut val) = self {
27646 fidl::decode!(OfferDirectory, D, val, decoder, _inner_offset, depth)?;
27647 } else {
27648 unreachable!()
27649 }
27650 }
27651 4 => {
27652 #[allow(irrefutable_let_patterns)]
27653 if let Offer::Storage(_) = self {
27654 } else {
27656 *self = Offer::Storage(fidl::new_empty!(OfferStorage, D));
27658 }
27659 #[allow(irrefutable_let_patterns)]
27660 if let Offer::Storage(ref mut val) = self {
27661 fidl::decode!(OfferStorage, D, val, decoder, _inner_offset, depth)?;
27662 } else {
27663 unreachable!()
27664 }
27665 }
27666 5 => {
27667 #[allow(irrefutable_let_patterns)]
27668 if let Offer::Runner(_) = self {
27669 } else {
27671 *self = Offer::Runner(fidl::new_empty!(OfferRunner, D));
27673 }
27674 #[allow(irrefutable_let_patterns)]
27675 if let Offer::Runner(ref mut val) = self {
27676 fidl::decode!(OfferRunner, D, val, decoder, _inner_offset, depth)?;
27677 } else {
27678 unreachable!()
27679 }
27680 }
27681 6 => {
27682 #[allow(irrefutable_let_patterns)]
27683 if let Offer::Resolver(_) = self {
27684 } else {
27686 *self = Offer::Resolver(fidl::new_empty!(OfferResolver, D));
27688 }
27689 #[allow(irrefutable_let_patterns)]
27690 if let Offer::Resolver(ref mut val) = self {
27691 fidl::decode!(OfferResolver, D, val, decoder, _inner_offset, depth)?;
27692 } else {
27693 unreachable!()
27694 }
27695 }
27696 8 => {
27697 #[allow(irrefutable_let_patterns)]
27698 if let Offer::EventStream(_) = self {
27699 } else {
27701 *self = Offer::EventStream(fidl::new_empty!(OfferEventStream, D));
27703 }
27704 #[allow(irrefutable_let_patterns)]
27705 if let Offer::EventStream(ref mut val) = self {
27706 fidl::decode!(OfferEventStream, D, val, decoder, _inner_offset, depth)?;
27707 } else {
27708 unreachable!()
27709 }
27710 }
27711 9 => {
27712 #[allow(irrefutable_let_patterns)]
27713 if let Offer::Dictionary(_) = self {
27714 } else {
27716 *self = Offer::Dictionary(fidl::new_empty!(OfferDictionary, D));
27718 }
27719 #[allow(irrefutable_let_patterns)]
27720 if let Offer::Dictionary(ref mut val) = self {
27721 fidl::decode!(OfferDictionary, D, val, decoder, _inner_offset, depth)?;
27722 } else {
27723 unreachable!()
27724 }
27725 }
27726 10 => {
27727 #[allow(irrefutable_let_patterns)]
27728 if let Offer::Config(_) = self {
27729 } else {
27731 *self = Offer::Config(fidl::new_empty!(OfferConfiguration, D));
27733 }
27734 #[allow(irrefutable_let_patterns)]
27735 if let Offer::Config(ref mut val) = self {
27736 fidl::decode!(OfferConfiguration, D, val, decoder, _inner_offset, depth)?;
27737 } else {
27738 unreachable!()
27739 }
27740 }
27741 #[allow(deprecated)]
27742 ordinal => {
27743 for _ in 0..num_handles {
27744 decoder.drop_next_handle()?;
27745 }
27746 *self = Offer::__SourceBreaking { unknown_ordinal: ordinal };
27747 }
27748 }
27749 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
27750 return Err(fidl::Error::InvalidNumBytesInEnvelope);
27751 }
27752 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
27753 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
27754 }
27755 Ok(())
27756 }
27757 }
27758
27759 impl fidl::encoding::ValueTypeMarker for Ref {
27760 type Borrowed<'a> = &'a Self;
27761 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
27762 value
27763 }
27764 }
27765
27766 unsafe impl fidl::encoding::TypeMarker for Ref {
27767 type Owned = Self;
27768
27769 #[inline(always)]
27770 fn inline_align(_context: fidl::encoding::Context) -> usize {
27771 8
27772 }
27773
27774 #[inline(always)]
27775 fn inline_size(_context: fidl::encoding::Context) -> usize {
27776 16
27777 }
27778 }
27779
27780 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Ref, D> for &Ref {
27781 #[inline]
27782 unsafe fn encode(
27783 self,
27784 encoder: &mut fidl::encoding::Encoder<'_, D>,
27785 offset: usize,
27786 _depth: fidl::encoding::Depth,
27787 ) -> fidl::Result<()> {
27788 encoder.debug_check_bounds::<Ref>(offset);
27789 encoder.write_num::<u64>(self.ordinal(), offset);
27790 match self {
27791 Ref::Parent(ref val) => fidl::encoding::encode_in_envelope::<ParentRef, D>(
27792 <ParentRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27793 encoder,
27794 offset + 8,
27795 _depth,
27796 ),
27797 Ref::Self_(ref val) => fidl::encoding::encode_in_envelope::<SelfRef, D>(
27798 <SelfRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27799 encoder,
27800 offset + 8,
27801 _depth,
27802 ),
27803 Ref::Child(ref val) => fidl::encoding::encode_in_envelope::<ChildRef, D>(
27804 <ChildRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27805 encoder,
27806 offset + 8,
27807 _depth,
27808 ),
27809 Ref::Collection(ref val) => fidl::encoding::encode_in_envelope::<CollectionRef, D>(
27810 <CollectionRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27811 encoder,
27812 offset + 8,
27813 _depth,
27814 ),
27815 Ref::Framework(ref val) => fidl::encoding::encode_in_envelope::<FrameworkRef, D>(
27816 <FrameworkRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27817 encoder,
27818 offset + 8,
27819 _depth,
27820 ),
27821 Ref::Capability(ref val) => fidl::encoding::encode_in_envelope::<CapabilityRef, D>(
27822 <CapabilityRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27823 encoder,
27824 offset + 8,
27825 _depth,
27826 ),
27827 Ref::Debug(ref val) => fidl::encoding::encode_in_envelope::<DebugRef, D>(
27828 <DebugRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27829 encoder,
27830 offset + 8,
27831 _depth,
27832 ),
27833 Ref::VoidType(ref val) => fidl::encoding::encode_in_envelope::<VoidRef, D>(
27834 <VoidRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27835 encoder,
27836 offset + 8,
27837 _depth,
27838 ),
27839 Ref::Environment(ref val) => {
27840 fidl::encoding::encode_in_envelope::<EnvironmentRef, D>(
27841 <EnvironmentRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27842 encoder,
27843 offset + 8,
27844 _depth,
27845 )
27846 }
27847 Ref::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
27848 }
27849 }
27850 }
27851
27852 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Ref {
27853 #[inline(always)]
27854 fn new_empty() -> Self {
27855 Self::__SourceBreaking { unknown_ordinal: 0 }
27856 }
27857
27858 #[inline]
27859 unsafe fn decode(
27860 &mut self,
27861 decoder: &mut fidl::encoding::Decoder<'_, D>,
27862 offset: usize,
27863 mut depth: fidl::encoding::Depth,
27864 ) -> fidl::Result<()> {
27865 decoder.debug_check_bounds::<Self>(offset);
27866 #[allow(unused_variables)]
27867 let next_out_of_line = decoder.next_out_of_line();
27868 let handles_before = decoder.remaining_handles();
27869 let (ordinal, inlined, num_bytes, num_handles) =
27870 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
27871
27872 let member_inline_size = match ordinal {
27873 1 => <ParentRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27874 2 => <SelfRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27875 3 => <ChildRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27876 4 => <CollectionRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27877 5 => <FrameworkRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27878 6 => <CapabilityRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27879 7 => <DebugRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27880 8 => <VoidRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27881 9 => <EnvironmentRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27882 0 => return Err(fidl::Error::UnknownUnionTag),
27883 _ => num_bytes as usize,
27884 };
27885
27886 if inlined != (member_inline_size <= 4) {
27887 return Err(fidl::Error::InvalidInlineBitInEnvelope);
27888 }
27889 let _inner_offset;
27890 if inlined {
27891 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
27892 _inner_offset = offset + 8;
27893 } else {
27894 depth.increment()?;
27895 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
27896 }
27897 match ordinal {
27898 1 => {
27899 #[allow(irrefutable_let_patterns)]
27900 if let Ref::Parent(_) = self {
27901 } else {
27903 *self = Ref::Parent(fidl::new_empty!(ParentRef, D));
27905 }
27906 #[allow(irrefutable_let_patterns)]
27907 if let Ref::Parent(ref mut val) = self {
27908 fidl::decode!(ParentRef, D, val, decoder, _inner_offset, depth)?;
27909 } else {
27910 unreachable!()
27911 }
27912 }
27913 2 => {
27914 #[allow(irrefutable_let_patterns)]
27915 if let Ref::Self_(_) = self {
27916 } else {
27918 *self = Ref::Self_(fidl::new_empty!(SelfRef, D));
27920 }
27921 #[allow(irrefutable_let_patterns)]
27922 if let Ref::Self_(ref mut val) = self {
27923 fidl::decode!(SelfRef, D, val, decoder, _inner_offset, depth)?;
27924 } else {
27925 unreachable!()
27926 }
27927 }
27928 3 => {
27929 #[allow(irrefutable_let_patterns)]
27930 if let Ref::Child(_) = self {
27931 } else {
27933 *self = Ref::Child(fidl::new_empty!(ChildRef, D));
27935 }
27936 #[allow(irrefutable_let_patterns)]
27937 if let Ref::Child(ref mut val) = self {
27938 fidl::decode!(ChildRef, D, val, decoder, _inner_offset, depth)?;
27939 } else {
27940 unreachable!()
27941 }
27942 }
27943 4 => {
27944 #[allow(irrefutable_let_patterns)]
27945 if let Ref::Collection(_) = self {
27946 } else {
27948 *self = Ref::Collection(fidl::new_empty!(CollectionRef, D));
27950 }
27951 #[allow(irrefutable_let_patterns)]
27952 if let Ref::Collection(ref mut val) = self {
27953 fidl::decode!(CollectionRef, D, val, decoder, _inner_offset, depth)?;
27954 } else {
27955 unreachable!()
27956 }
27957 }
27958 5 => {
27959 #[allow(irrefutable_let_patterns)]
27960 if let Ref::Framework(_) = self {
27961 } else {
27963 *self = Ref::Framework(fidl::new_empty!(FrameworkRef, D));
27965 }
27966 #[allow(irrefutable_let_patterns)]
27967 if let Ref::Framework(ref mut val) = self {
27968 fidl::decode!(FrameworkRef, D, val, decoder, _inner_offset, depth)?;
27969 } else {
27970 unreachable!()
27971 }
27972 }
27973 6 => {
27974 #[allow(irrefutable_let_patterns)]
27975 if let Ref::Capability(_) = self {
27976 } else {
27978 *self = Ref::Capability(fidl::new_empty!(CapabilityRef, D));
27980 }
27981 #[allow(irrefutable_let_patterns)]
27982 if let Ref::Capability(ref mut val) = self {
27983 fidl::decode!(CapabilityRef, D, val, decoder, _inner_offset, depth)?;
27984 } else {
27985 unreachable!()
27986 }
27987 }
27988 7 => {
27989 #[allow(irrefutable_let_patterns)]
27990 if let Ref::Debug(_) = self {
27991 } else {
27993 *self = Ref::Debug(fidl::new_empty!(DebugRef, D));
27995 }
27996 #[allow(irrefutable_let_patterns)]
27997 if let Ref::Debug(ref mut val) = self {
27998 fidl::decode!(DebugRef, D, val, decoder, _inner_offset, depth)?;
27999 } else {
28000 unreachable!()
28001 }
28002 }
28003 8 => {
28004 #[allow(irrefutable_let_patterns)]
28005 if let Ref::VoidType(_) = self {
28006 } else {
28008 *self = Ref::VoidType(fidl::new_empty!(VoidRef, D));
28010 }
28011 #[allow(irrefutable_let_patterns)]
28012 if let Ref::VoidType(ref mut val) = self {
28013 fidl::decode!(VoidRef, D, val, decoder, _inner_offset, depth)?;
28014 } else {
28015 unreachable!()
28016 }
28017 }
28018 9 => {
28019 #[allow(irrefutable_let_patterns)]
28020 if let Ref::Environment(_) = self {
28021 } else {
28023 *self = Ref::Environment(fidl::new_empty!(EnvironmentRef, D));
28025 }
28026 #[allow(irrefutable_let_patterns)]
28027 if let Ref::Environment(ref mut val) = self {
28028 fidl::decode!(EnvironmentRef, D, val, decoder, _inner_offset, depth)?;
28029 } else {
28030 unreachable!()
28031 }
28032 }
28033 #[allow(deprecated)]
28034 ordinal => {
28035 for _ in 0..num_handles {
28036 decoder.drop_next_handle()?;
28037 }
28038 *self = Ref::__SourceBreaking { unknown_ordinal: ordinal };
28039 }
28040 }
28041 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
28042 return Err(fidl::Error::InvalidNumBytesInEnvelope);
28043 }
28044 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
28045 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
28046 }
28047 Ok(())
28048 }
28049 }
28050
28051 impl fidl::encoding::ValueTypeMarker for Use {
28052 type Borrowed<'a> = &'a Self;
28053 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
28054 value
28055 }
28056 }
28057
28058 unsafe impl fidl::encoding::TypeMarker for Use {
28059 type Owned = Self;
28060
28061 #[inline(always)]
28062 fn inline_align(_context: fidl::encoding::Context) -> usize {
28063 8
28064 }
28065
28066 #[inline(always)]
28067 fn inline_size(_context: fidl::encoding::Context) -> usize {
28068 16
28069 }
28070 }
28071
28072 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Use, D> for &Use {
28073 #[inline]
28074 unsafe fn encode(
28075 self,
28076 encoder: &mut fidl::encoding::Encoder<'_, D>,
28077 offset: usize,
28078 _depth: fidl::encoding::Depth,
28079 ) -> fidl::Result<()> {
28080 encoder.debug_check_bounds::<Use>(offset);
28081 encoder.write_num::<u64>(self.ordinal(), offset);
28082 match self {
28083 Use::Service(ref val) => fidl::encoding::encode_in_envelope::<UseService, D>(
28084 <UseService as fidl::encoding::ValueTypeMarker>::borrow(val),
28085 encoder,
28086 offset + 8,
28087 _depth,
28088 ),
28089 Use::Protocol(ref val) => fidl::encoding::encode_in_envelope::<UseProtocol, D>(
28090 <UseProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
28091 encoder,
28092 offset + 8,
28093 _depth,
28094 ),
28095 Use::Directory(ref val) => fidl::encoding::encode_in_envelope::<UseDirectory, D>(
28096 <UseDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
28097 encoder,
28098 offset + 8,
28099 _depth,
28100 ),
28101 Use::Storage(ref val) => fidl::encoding::encode_in_envelope::<UseStorage, D>(
28102 <UseStorage as fidl::encoding::ValueTypeMarker>::borrow(val),
28103 encoder,
28104 offset + 8,
28105 _depth,
28106 ),
28107 Use::EventStream(ref val) => {
28108 fidl::encoding::encode_in_envelope::<UseEventStream, D>(
28109 <UseEventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
28110 encoder,
28111 offset + 8,
28112 _depth,
28113 )
28114 }
28115 Use::Runner(ref val) => fidl::encoding::encode_in_envelope::<UseRunner, D>(
28116 <UseRunner as fidl::encoding::ValueTypeMarker>::borrow(val),
28117 encoder,
28118 offset + 8,
28119 _depth,
28120 ),
28121 Use::Config(ref val) => fidl::encoding::encode_in_envelope::<UseConfiguration, D>(
28122 <UseConfiguration as fidl::encoding::ValueTypeMarker>::borrow(val),
28123 encoder,
28124 offset + 8,
28125 _depth,
28126 ),
28127 Use::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
28128 }
28129 }
28130 }
28131
28132 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Use {
28133 #[inline(always)]
28134 fn new_empty() -> Self {
28135 Self::__SourceBreaking { unknown_ordinal: 0 }
28136 }
28137
28138 #[inline]
28139 unsafe fn decode(
28140 &mut self,
28141 decoder: &mut fidl::encoding::Decoder<'_, D>,
28142 offset: usize,
28143 mut depth: fidl::encoding::Depth,
28144 ) -> fidl::Result<()> {
28145 decoder.debug_check_bounds::<Self>(offset);
28146 #[allow(unused_variables)]
28147 let next_out_of_line = decoder.next_out_of_line();
28148 let handles_before = decoder.remaining_handles();
28149 let (ordinal, inlined, num_bytes, num_handles) =
28150 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
28151
28152 let member_inline_size = match ordinal {
28153 1 => <UseService as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28154 2 => <UseProtocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28155 3 => <UseDirectory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28156 4 => <UseStorage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28157 7 => <UseEventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28158 8 => <UseRunner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28159 9 => <UseConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28160 0 => return Err(fidl::Error::UnknownUnionTag),
28161 _ => num_bytes as usize,
28162 };
28163
28164 if inlined != (member_inline_size <= 4) {
28165 return Err(fidl::Error::InvalidInlineBitInEnvelope);
28166 }
28167 let _inner_offset;
28168 if inlined {
28169 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
28170 _inner_offset = offset + 8;
28171 } else {
28172 depth.increment()?;
28173 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
28174 }
28175 match ordinal {
28176 1 => {
28177 #[allow(irrefutable_let_patterns)]
28178 if let Use::Service(_) = self {
28179 } else {
28181 *self = Use::Service(fidl::new_empty!(UseService, D));
28183 }
28184 #[allow(irrefutable_let_patterns)]
28185 if let Use::Service(ref mut val) = self {
28186 fidl::decode!(UseService, D, val, decoder, _inner_offset, depth)?;
28187 } else {
28188 unreachable!()
28189 }
28190 }
28191 2 => {
28192 #[allow(irrefutable_let_patterns)]
28193 if let Use::Protocol(_) = self {
28194 } else {
28196 *self = Use::Protocol(fidl::new_empty!(UseProtocol, D));
28198 }
28199 #[allow(irrefutable_let_patterns)]
28200 if let Use::Protocol(ref mut val) = self {
28201 fidl::decode!(UseProtocol, D, val, decoder, _inner_offset, depth)?;
28202 } else {
28203 unreachable!()
28204 }
28205 }
28206 3 => {
28207 #[allow(irrefutable_let_patterns)]
28208 if let Use::Directory(_) = self {
28209 } else {
28211 *self = Use::Directory(fidl::new_empty!(UseDirectory, D));
28213 }
28214 #[allow(irrefutable_let_patterns)]
28215 if let Use::Directory(ref mut val) = self {
28216 fidl::decode!(UseDirectory, D, val, decoder, _inner_offset, depth)?;
28217 } else {
28218 unreachable!()
28219 }
28220 }
28221 4 => {
28222 #[allow(irrefutable_let_patterns)]
28223 if let Use::Storage(_) = self {
28224 } else {
28226 *self = Use::Storage(fidl::new_empty!(UseStorage, D));
28228 }
28229 #[allow(irrefutable_let_patterns)]
28230 if let Use::Storage(ref mut val) = self {
28231 fidl::decode!(UseStorage, D, val, decoder, _inner_offset, depth)?;
28232 } else {
28233 unreachable!()
28234 }
28235 }
28236 7 => {
28237 #[allow(irrefutable_let_patterns)]
28238 if let Use::EventStream(_) = self {
28239 } else {
28241 *self = Use::EventStream(fidl::new_empty!(UseEventStream, D));
28243 }
28244 #[allow(irrefutable_let_patterns)]
28245 if let Use::EventStream(ref mut val) = self {
28246 fidl::decode!(UseEventStream, D, val, decoder, _inner_offset, depth)?;
28247 } else {
28248 unreachable!()
28249 }
28250 }
28251 8 => {
28252 #[allow(irrefutable_let_patterns)]
28253 if let Use::Runner(_) = self {
28254 } else {
28256 *self = Use::Runner(fidl::new_empty!(UseRunner, D));
28258 }
28259 #[allow(irrefutable_let_patterns)]
28260 if let Use::Runner(ref mut val) = self {
28261 fidl::decode!(UseRunner, D, val, decoder, _inner_offset, depth)?;
28262 } else {
28263 unreachable!()
28264 }
28265 }
28266 9 => {
28267 #[allow(irrefutable_let_patterns)]
28268 if let Use::Config(_) = self {
28269 } else {
28271 *self = Use::Config(fidl::new_empty!(UseConfiguration, D));
28273 }
28274 #[allow(irrefutable_let_patterns)]
28275 if let Use::Config(ref mut val) = self {
28276 fidl::decode!(UseConfiguration, D, val, decoder, _inner_offset, depth)?;
28277 } else {
28278 unreachable!()
28279 }
28280 }
28281 #[allow(deprecated)]
28282 ordinal => {
28283 for _ in 0..num_handles {
28284 decoder.drop_next_handle()?;
28285 }
28286 *self = Use::__SourceBreaking { unknown_ordinal: ordinal };
28287 }
28288 }
28289 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
28290 return Err(fidl::Error::InvalidNumBytesInEnvelope);
28291 }
28292 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
28293 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
28294 }
28295 Ok(())
28296 }
28297 }
28298}