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 AllowlistEntryMoniker = String;
24
25pub type InstanceId = String;
27
28pub type Moniker = String;
29
30pub const MAX_ALLOWLIST_SIZE: u64 = 128;
33
34#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
36#[repr(u8)]
37pub enum BuiltinBootResolver {
38 None = 1,
40 Boot = 2,
43}
44
45impl BuiltinBootResolver {
46 #[inline]
47 pub fn from_primitive(prim: u8) -> Option<Self> {
48 match prim {
49 1 => Some(Self::None),
50 2 => Some(Self::Boot),
51 _ => None,
52 }
53 }
54
55 #[inline]
56 pub const fn into_primitive(self) -> u8 {
57 self as u8
58 }
59}
60
61#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
63#[repr(u8)]
64pub enum LogDestination {
65 Syslog = 1,
67 Klog = 2,
69}
70
71impl LogDestination {
72 #[inline]
73 pub fn from_primitive(prim: u8) -> Option<Self> {
74 match prim {
75 1 => Some(Self::Syslog),
76 2 => Some(Self::Klog),
77 _ => None,
78 }
79 }
80
81 #[inline]
82 pub const fn into_primitive(self) -> u8 {
83 self as u8
84 }
85}
86
87#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
89#[repr(u8)]
90pub enum RealmBuilderResolverAndRunner {
91 None = 1,
93 Namespace = 2,
96}
97
98impl RealmBuilderResolverAndRunner {
99 #[inline]
100 pub fn from_primitive(prim: u8) -> Option<Self> {
101 match prim {
102 1 => Some(Self::None),
103 2 => Some(Self::Namespace),
104 _ => None,
105 }
106 }
107
108 #[inline]
109 pub const fn into_primitive(self) -> u8 {
110 self as u8
111 }
112}
113
114#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
117#[repr(u8)]
118pub enum TraceProvider {
119 Namespace = 1,
121 RootExposed = 2,
124}
125
126impl TraceProvider {
127 #[inline]
128 pub fn from_primitive(prim: u8) -> Option<Self> {
129 match prim {
130 1 => Some(Self::Namespace),
131 2 => Some(Self::RootExposed),
132 _ => None,
133 }
134 }
135
136 #[inline]
137 pub const fn into_primitive(self) -> u8 {
138 self as u8
139 }
140}
141
142#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
144#[repr(u8)]
145pub enum VmexSource {
146 SystemResource = 1,
148 Namespace = 2,
151}
152
153impl VmexSource {
154 #[inline]
155 pub fn from_primitive(prim: u8) -> Option<Self> {
156 match prim {
157 1 => Some(Self::SystemResource),
158 2 => Some(Self::Namespace),
159 _ => None,
160 }
161 }
162
163 #[inline]
164 pub const fn into_primitive(self) -> u8 {
165 self as u8
166 }
167}
168
169#[derive(Clone, Debug, Default, PartialEq)]
171pub struct AbiRevisionPolicy {
172 pub allowlist: Option<Vec<String>>,
177 #[doc(hidden)]
178 pub __source_breaking: fidl::marker::SourceBreaking,
179}
180
181impl fidl::Persistable for AbiRevisionPolicy {}
182
183#[derive(Clone, Debug, Default, PartialEq)]
184pub struct AllowlistedDirectory {
185 #[doc(hidden)]
186 pub __source_breaking: fidl::marker::SourceBreaking,
187}
188
189impl fidl::Persistable for AllowlistedDirectory {}
190
191#[derive(Clone, Debug, Default, PartialEq)]
192pub struct AllowlistedProtocol {
193 #[doc(hidden)]
194 pub __source_breaking: fidl::marker::SourceBreaking,
195}
196
197impl fidl::Persistable for AllowlistedProtocol {}
198
199#[derive(Clone, Debug, Default, PartialEq)]
200pub struct AllowlistedResolver {
201 #[doc(hidden)]
202 pub __source_breaking: fidl::marker::SourceBreaking,
203}
204
205impl fidl::Persistable for AllowlistedResolver {}
206
207#[derive(Clone, Debug, Default, PartialEq)]
208pub struct AllowlistedRunner {
209 #[doc(hidden)]
210 pub __source_breaking: fidl::marker::SourceBreaking,
211}
212
213impl fidl::Persistable for AllowlistedRunner {}
214
215#[derive(Clone, Debug, Default, PartialEq)]
216pub struct AllowlistedService {
217 #[doc(hidden)]
218 pub __source_breaking: fidl::marker::SourceBreaking,
219}
220
221impl fidl::Persistable for AllowlistedService {}
222
223#[derive(Clone, Debug, Default, PartialEq)]
224pub struct AllowlistedStorage {
225 #[doc(hidden)]
226 pub __source_breaking: fidl::marker::SourceBreaking,
227}
228
229impl fidl::Persistable for AllowlistedStorage {}
230
231#[derive(Clone, Debug, Default, PartialEq)]
232pub struct AnonymizedAggregate {
233 pub capability: Option<AggregateCapability>,
234 pub moniker: Option<String>,
235 pub members: Option<Vec<AggregateMember>>,
236 pub sources: Option<Sources>,
237 pub instances: Option<Vec<fidl_fuchsia_sys2__common::ServiceInstance>>,
238 #[doc(hidden)]
239 pub __source_breaking: fidl::marker::SourceBreaking,
240}
241
242impl fidl::Persistable for AnonymizedAggregate {}
243
244#[derive(Clone, Debug, Default, PartialEq)]
245pub struct Builtin {
246 pub capability: Option<InternalCapability>,
247 #[doc(hidden)]
248 pub __source_breaking: fidl::marker::SourceBreaking,
249}
250
251impl fidl::Persistable for Builtin {}
252
253#[derive(Clone, Debug, Default, PartialEq)]
254pub struct Capability {
255 pub source_capability: Option<ComponentCapability>,
256 pub moniker: Option<String>,
257 #[doc(hidden)]
258 pub __source_breaking: fidl::marker::SourceBreaking,
259}
260
261impl fidl::Persistable for Capability {}
262
263#[derive(Clone, Debug, Default, PartialEq)]
266pub struct CapabilityAllowlistEntry {
267 pub source_moniker: Option<String>,
270 pub source_name: Option<String>,
272 pub capability: Option<AllowlistedCapability>,
275 pub target_monikers: Option<Vec<String>>,
278 pub source: Option<fidl_fuchsia_component_decl__common::Ref>,
280 #[doc(hidden)]
281 pub __source_breaking: fidl::marker::SourceBreaking,
282}
283
284impl fidl::Persistable for CapabilityAllowlistEntry {}
285
286#[derive(Clone, Debug, Default, PartialEq)]
289pub struct CapabilityPolicyAllowlists {
290 pub allowlist: Option<Vec<CapabilityAllowlistEntry>>,
291 #[doc(hidden)]
292 pub __source_breaking: fidl::marker::SourceBreaking,
293}
294
295impl fidl::Persistable for CapabilityPolicyAllowlists {}
296
297#[derive(Clone, Debug, Default, PartialEq)]
299pub struct ChildPolicyAllowlists {
300 pub reboot_on_terminate: Option<Vec<String>>,
303 #[doc(hidden)]
304 pub __source_breaking: fidl::marker::SourceBreaking,
305}
306
307impl fidl::Persistable for ChildPolicyAllowlists {}
308
309#[derive(Clone, Debug, Default, PartialEq)]
310pub struct Component {
311 pub capability: Option<ComponentCapability>,
312 pub moniker: Option<String>,
313 #[doc(hidden)]
314 pub __source_breaking: fidl::marker::SourceBreaking,
315}
316
317impl fidl::Persistable for Component {}
318
319#[derive(Clone, Debug, Default, PartialEq)]
321pub struct ComponentIdIndex {
322 pub instances: Option<Vec<InstanceIdEntry>>,
326 #[doc(hidden)]
327 pub __source_breaking: fidl::marker::SourceBreaking,
328}
329
330impl fidl::Persistable for ComponentIdIndex {}
331
332#[derive(Clone, Debug, Default, PartialEq)]
333pub struct Config {
334 pub debug: Option<bool>,
342 pub list_children_batch_size: Option<u32>,
344 pub security_policy: Option<SecurityPolicy>,
346 pub namespace_capabilities: Option<Vec<fidl_fuchsia_component_decl__common::Capability>>,
348 pub use_builtin_process_launcher: Option<bool>,
357 pub maintain_utc_clock: Option<bool>,
361 pub num_threads: Option<u8>,
364 pub root_component_url: Option<String>,
368 pub component_id_index_path: Option<String>,
371 pub log_destination: Option<LogDestination>,
373 pub log_all_events: Option<bool>,
375 pub builtin_boot_resolver: Option<BuiltinBootResolver>,
378 pub realm_builder_resolver_and_runner: Option<RealmBuilderResolverAndRunner>,
382 pub builtin_capabilities: Option<Vec<fidl_fuchsia_component_decl__common::Capability>>,
384 pub enable_introspection: Option<bool>,
387 pub abi_revision_policy: Option<AbiRevisionPolicy>,
390 pub vmex_source: Option<VmexSource>,
393 pub health_check: Option<HealthCheck>,
395 pub trace_provider: Option<TraceProvider>,
398 #[doc(hidden)]
399 pub __source_breaking: fidl::marker::SourceBreaking,
400}
401
402impl fidl::Persistable for Config {}
403
404#[derive(Clone, Debug, Default, PartialEq)]
407pub struct DebugRegistrationAllowlistEntry {
408 pub name: Option<String>,
410 pub debug: Option<AllowlistedDebugRegistration>,
413 pub moniker: Option<String>,
416 pub environment_name: Option<String>,
418 #[doc(hidden)]
419 pub __source_breaking: fidl::marker::SourceBreaking,
420}
421
422impl fidl::Persistable for DebugRegistrationAllowlistEntry {}
423
424#[derive(Clone, Debug, Default, PartialEq)]
426pub struct DebugRegistrationPolicyAllowlists {
427 pub allowlist: Option<Vec<DebugRegistrationAllowlistEntry>>,
428 #[doc(hidden)]
429 pub __source_breaking: fidl::marker::SourceBreaking,
430}
431
432impl fidl::Persistable for DebugRegistrationPolicyAllowlists {}
433
434#[derive(Clone, Debug, Default, PartialEq)]
435pub struct Environment {
436 pub capability: Option<ComponentCapability>,
437 pub moniker: Option<String>,
438 #[doc(hidden)]
439 pub __source_breaking: fidl::marker::SourceBreaking,
440}
441
442impl fidl::Persistable for Environment {}
443
444#[derive(Clone, Debug, Default, PartialEq)]
445pub struct EnvironmentSource {
446 pub source_name: Option<String>,
447 pub source: Option<fidl_fuchsia_component_decl__common::Ref>,
448 #[doc(hidden)]
449 pub __source_breaking: fidl::marker::SourceBreaking,
450}
451
452impl fidl::Persistable for EnvironmentSource {}
453
454#[derive(Clone, Debug, Default, PartialEq)]
455pub struct FilteredAggregateProvider {
456 pub capability: Option<AggregateCapability>,
457 pub moniker: Option<String>,
458 pub offer_service_decls: Option<Vec<fidl_fuchsia_component_decl__common::OfferService>>,
459 pub sources: Option<Sources>,
460 #[doc(hidden)]
461 pub __source_breaking: fidl::marker::SourceBreaking,
462}
463
464impl fidl::Persistable for FilteredAggregateProvider {}
465
466#[derive(Clone, Debug, Default, PartialEq)]
467pub struct FilteredProvider {
468 pub capability: Option<AggregateCapability>,
469 pub moniker: Option<String>,
470 pub service_capability: Option<ComponentCapability>,
471 pub offer_service_decl: Option<fidl_fuchsia_component_decl__common::OfferService>,
472 #[doc(hidden)]
473 pub __source_breaking: fidl::marker::SourceBreaking,
474}
475
476impl fidl::Persistable for FilteredProvider {}
477
478#[derive(Clone, Debug, Default, PartialEq)]
479pub struct Framework {
480 pub capability: Option<InternalCapability>,
481 pub moniker: Option<String>,
482 #[doc(hidden)]
483 pub __source_breaking: fidl::marker::SourceBreaking,
484}
485
486impl fidl::Persistable for Framework {}
487
488#[derive(Clone, Debug, Default, PartialEq)]
490pub struct HealthCheck {
491 pub monikers: Option<Vec<String>>,
493 #[doc(hidden)]
494 pub __source_breaking: fidl::marker::SourceBreaking,
495}
496
497impl fidl::Persistable for HealthCheck {}
498
499#[derive(Clone, Debug, Default, PartialEq)]
500pub struct InstanceIdEntry {
501 pub instance_id: Option<String>,
504 pub moniker: Option<String>,
506 #[doc(hidden)]
507 pub __source_breaking: fidl::marker::SourceBreaking,
508}
509
510impl fidl::Persistable for InstanceIdEntry {}
511
512#[derive(Clone, Debug, Default, PartialEq)]
514pub struct JobPolicyAllowlists {
515 pub ambient_mark_vmo_exec: Option<Vec<String>>,
522 pub main_process_critical: Option<Vec<String>>,
528 pub create_raw_processes: Option<Vec<String>>,
534 #[doc(hidden)]
535 pub __source_breaking: fidl::marker::SourceBreaking,
536}
537
538impl fidl::Persistable for JobPolicyAllowlists {}
539
540#[derive(Clone, Debug, Default, PartialEq)]
541pub struct Namespace {
542 pub capability: Option<ComponentCapability>,
543 #[doc(hidden)]
544 pub __source_breaking: fidl::marker::SourceBreaking,
545}
546
547impl fidl::Persistable for Namespace {}
548
549#[derive(Clone, Debug, Default, PartialEq)]
551pub struct SecurityPolicy {
552 pub job_policy: Option<JobPolicyAllowlists>,
554 pub capability_policy: Option<CapabilityPolicyAllowlists>,
556 pub debug_registration_policy: Option<DebugRegistrationPolicyAllowlists>,
558 pub child_policy: Option<ChildPolicyAllowlists>,
560 #[doc(hidden)]
561 pub __source_breaking: fidl::marker::SourceBreaking,
562}
563
564impl fidl::Persistable for SecurityPolicy {}
565
566#[derive(Clone, Debug, Default, PartialEq)]
567pub struct Sources {
568 pub framework: Option<bool>,
569 pub builtin: Option<bool>,
570 pub capability: Option<bool>,
571 pub collection: Option<bool>,
572 pub namespace: Option<bool>,
573 pub component: Option<bool>,
574 pub capability_type: Option<String>,
575 #[doc(hidden)]
576 pub __source_breaking: fidl::marker::SourceBreaking,
577}
578
579impl fidl::Persistable for Sources {}
580
581#[derive(Clone, Debug, Default, PartialEq)]
582pub struct Void {
583 pub capability: Option<InternalCapability>,
584 pub moniker: Option<String>,
585 #[doc(hidden)]
586 pub __source_breaking: fidl::marker::SourceBreaking,
587}
588
589impl fidl::Persistable for Void {}
590
591#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
592pub enum AggregateCapability {
593 Service(String),
594}
595
596impl AggregateCapability {
597 #[inline]
598 pub fn ordinal(&self) -> u64 {
599 match *self {
600 Self::Service(_) => 1,
601 }
602 }
603}
604
605impl fidl::Persistable for AggregateCapability {}
606
607#[derive(Clone, Debug, PartialEq)]
608pub enum AggregateMember {
609 Child(fidl_fuchsia_component_decl__common::ChildRef),
610 Collection(String),
611 Parent(fidl_fuchsia_component_decl__common::ParentRef),
612 Self_(fidl_fuchsia_component_decl__common::SelfRef),
613}
614
615impl AggregateMember {
616 #[inline]
617 pub fn ordinal(&self) -> u64 {
618 match *self {
619 Self::Child(_) => 1,
620 Self::Collection(_) => 2,
621 Self::Parent(_) => 3,
622 Self::Self_(_) => 4,
623 }
624 }
625}
626
627impl fidl::Persistable for AggregateMember {}
628
629#[derive(Clone, Debug)]
631pub enum AllowlistedCapability {
632 Directory(AllowlistedDirectory),
633 Protocol(AllowlistedProtocol),
634 Service(AllowlistedService),
635 Storage(AllowlistedStorage),
636 Runner(AllowlistedRunner),
637 Resolver(AllowlistedResolver),
638 #[doc(hidden)]
639 __SourceBreaking {
640 unknown_ordinal: u64,
641 },
642}
643
644#[macro_export]
646macro_rules! AllowlistedCapabilityUnknown {
647 () => {
648 _
649 };
650}
651
652impl PartialEq for AllowlistedCapability {
654 fn eq(&self, other: &Self) -> bool {
655 match (self, other) {
656 (Self::Directory(x), Self::Directory(y)) => *x == *y,
657 (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
658 (Self::Service(x), Self::Service(y)) => *x == *y,
659 (Self::Storage(x), Self::Storage(y)) => *x == *y,
660 (Self::Runner(x), Self::Runner(y)) => *x == *y,
661 (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
662 _ => false,
663 }
664 }
665}
666
667impl AllowlistedCapability {
668 #[inline]
669 pub fn ordinal(&self) -> u64 {
670 match *self {
671 Self::Directory(_) => 1,
672 Self::Protocol(_) => 3,
673 Self::Service(_) => 4,
674 Self::Storage(_) => 5,
675 Self::Runner(_) => 6,
676 Self::Resolver(_) => 7,
677 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
678 }
679 }
680
681 #[inline]
682 pub fn unknown_variant_for_testing() -> Self {
683 Self::__SourceBreaking { unknown_ordinal: 0 }
684 }
685
686 #[inline]
687 pub fn is_unknown(&self) -> bool {
688 match self {
689 Self::__SourceBreaking { .. } => true,
690 _ => false,
691 }
692 }
693}
694
695impl fidl::Persistable for AllowlistedCapability {}
696
697#[derive(Clone, Debug)]
699pub enum AllowlistedDebugRegistration {
700 Protocol(AllowlistedProtocol),
701 #[doc(hidden)]
702 __SourceBreaking {
703 unknown_ordinal: u64,
704 },
705}
706
707#[macro_export]
709macro_rules! AllowlistedDebugRegistrationUnknown {
710 () => {
711 _
712 };
713}
714
715impl PartialEq for AllowlistedDebugRegistration {
717 fn eq(&self, other: &Self) -> bool {
718 match (self, other) {
719 (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
720 _ => false,
721 }
722 }
723}
724
725impl AllowlistedDebugRegistration {
726 #[inline]
727 pub fn ordinal(&self) -> u64 {
728 match *self {
729 Self::Protocol(_) => 1,
730 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
731 }
732 }
733
734 #[inline]
735 pub fn unknown_variant_for_testing() -> Self {
736 Self::__SourceBreaking { unknown_ordinal: 0 }
737 }
738
739 #[inline]
740 pub fn is_unknown(&self) -> bool {
741 match self {
742 Self::__SourceBreaking { .. } => true,
743 _ => false,
744 }
745 }
746}
747
748impl fidl::Persistable for AllowlistedDebugRegistration {}
749
750#[derive(Clone, Debug, PartialEq)]
751pub enum CapabilitySource {
752 Component(Component),
753 Framework(Framework),
754 Builtin(Builtin),
755 Namespace(Namespace),
756 Capability(Capability),
757 AnonymizedAggregate(AnonymizedAggregate),
758 FilteredProvider(FilteredProvider),
759 FilteredAggregateProvider(FilteredAggregateProvider),
760 Environment(Environment),
761 Void(Void),
762}
763
764impl CapabilitySource {
765 #[inline]
766 pub fn ordinal(&self) -> u64 {
767 match *self {
768 Self::Component(_) => 1,
769 Self::Framework(_) => 2,
770 Self::Builtin(_) => 3,
771 Self::Namespace(_) => 4,
772 Self::Capability(_) => 5,
773 Self::AnonymizedAggregate(_) => 6,
774 Self::FilteredProvider(_) => 7,
775 Self::FilteredAggregateProvider(_) => 8,
776 Self::Environment(_) => 9,
777 Self::Void(_) => 10,
778 }
779 }
780}
781
782impl fidl::Persistable for CapabilitySource {}
783
784#[derive(Clone, Debug, PartialEq)]
785pub enum ComponentCapability {
786 Use_(fidl_fuchsia_component_decl__common::Use),
787 Offer(fidl_fuchsia_component_decl__common::Offer),
788 Expose(fidl_fuchsia_component_decl__common::Expose),
789 Config(fidl_fuchsia_component_decl__common::Configuration),
790 Dictionary(fidl_fuchsia_component_decl__common::Dictionary),
791 Directory(fidl_fuchsia_component_decl__common::Directory),
792 Environment(EnvironmentCapability),
793 EventStream(fidl_fuchsia_component_decl__common::EventStream),
794 Protocol(fidl_fuchsia_component_decl__common::Protocol),
795 Resolver(fidl_fuchsia_component_decl__common::Resolver),
796 Runner(fidl_fuchsia_component_decl__common::Runner),
797 Service(fidl_fuchsia_component_decl__common::Service),
798 Storage(fidl_fuchsia_component_decl__common::Storage),
799}
800
801impl ComponentCapability {
802 #[inline]
803 pub fn ordinal(&self) -> u64 {
804 match *self {
805 Self::Use_(_) => 1,
806 Self::Offer(_) => 2,
807 Self::Expose(_) => 3,
808 Self::Config(_) => 4,
809 Self::Dictionary(_) => 5,
810 Self::Directory(_) => 6,
811 Self::Environment(_) => 7,
812 Self::EventStream(_) => 8,
813 Self::Protocol(_) => 9,
814 Self::Resolver(_) => 10,
815 Self::Runner(_) => 11,
816 Self::Service(_) => 12,
817 Self::Storage(_) => 13,
818 }
819 }
820}
821
822impl fidl::Persistable for ComponentCapability {}
823
824#[derive(Clone, Debug, PartialEq)]
825pub enum EnvironmentCapability {
826 Runner(EnvironmentSource),
827 Resolver(EnvironmentSource),
828 Debug(EnvironmentSource),
829}
830
831impl EnvironmentCapability {
832 #[inline]
833 pub fn ordinal(&self) -> u64 {
834 match *self {
835 Self::Runner(_) => 1,
836 Self::Resolver(_) => 2,
837 Self::Debug(_) => 3,
838 }
839 }
840}
841
842impl fidl::Persistable for EnvironmentCapability {}
843
844#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
845pub enum InternalCapability {
846 Config(String),
847 Dictionary(String),
848 Directory(String),
849 EventStream(String),
850 Protocol(String),
851 Resolver(String),
852 Runner(String),
853 Service(String),
854 Storage(String),
855}
856
857impl InternalCapability {
858 #[inline]
859 pub fn ordinal(&self) -> u64 {
860 match *self {
861 Self::Config(_) => 1,
862 Self::Dictionary(_) => 2,
863 Self::Directory(_) => 3,
864 Self::EventStream(_) => 4,
865 Self::Protocol(_) => 5,
866 Self::Resolver(_) => 6,
867 Self::Runner(_) => 7,
868 Self::Service(_) => 8,
869 Self::Storage(_) => 9,
870 }
871 }
872}
873
874impl fidl::Persistable for InternalCapability {}
875
876pub mod component_sandbox_retriever_ordinals {
877 pub const GET_MY_SANDBOX: u64 = 0x61ca075fb9860e84;
878}
879
880mod internal {
881 use super::*;
882 unsafe impl fidl::encoding::TypeMarker for BuiltinBootResolver {
883 type Owned = Self;
884
885 #[inline(always)]
886 fn inline_align(_context: fidl::encoding::Context) -> usize {
887 std::mem::align_of::<u8>()
888 }
889
890 #[inline(always)]
891 fn inline_size(_context: fidl::encoding::Context) -> usize {
892 std::mem::size_of::<u8>()
893 }
894
895 #[inline(always)]
896 fn encode_is_copy() -> bool {
897 true
898 }
899
900 #[inline(always)]
901 fn decode_is_copy() -> bool {
902 false
903 }
904 }
905
906 impl fidl::encoding::ValueTypeMarker for BuiltinBootResolver {
907 type Borrowed<'a> = Self;
908 #[inline(always)]
909 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
910 *value
911 }
912 }
913
914 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
915 for BuiltinBootResolver
916 {
917 #[inline]
918 unsafe fn encode(
919 self,
920 encoder: &mut fidl::encoding::Encoder<'_, D>,
921 offset: usize,
922 _depth: fidl::encoding::Depth,
923 ) -> fidl::Result<()> {
924 encoder.debug_check_bounds::<Self>(offset);
925 encoder.write_num(self.into_primitive(), offset);
926 Ok(())
927 }
928 }
929
930 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BuiltinBootResolver {
931 #[inline(always)]
932 fn new_empty() -> Self {
933 Self::None
934 }
935
936 #[inline]
937 unsafe fn decode(
938 &mut self,
939 decoder: &mut fidl::encoding::Decoder<'_, D>,
940 offset: usize,
941 _depth: fidl::encoding::Depth,
942 ) -> fidl::Result<()> {
943 decoder.debug_check_bounds::<Self>(offset);
944 let prim = decoder.read_num::<u8>(offset);
945
946 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
947 Ok(())
948 }
949 }
950 unsafe impl fidl::encoding::TypeMarker for LogDestination {
951 type Owned = Self;
952
953 #[inline(always)]
954 fn inline_align(_context: fidl::encoding::Context) -> usize {
955 std::mem::align_of::<u8>()
956 }
957
958 #[inline(always)]
959 fn inline_size(_context: fidl::encoding::Context) -> usize {
960 std::mem::size_of::<u8>()
961 }
962
963 #[inline(always)]
964 fn encode_is_copy() -> bool {
965 true
966 }
967
968 #[inline(always)]
969 fn decode_is_copy() -> bool {
970 false
971 }
972 }
973
974 impl fidl::encoding::ValueTypeMarker for LogDestination {
975 type Borrowed<'a> = Self;
976 #[inline(always)]
977 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
978 *value
979 }
980 }
981
982 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LogDestination {
983 #[inline]
984 unsafe fn encode(
985 self,
986 encoder: &mut fidl::encoding::Encoder<'_, D>,
987 offset: usize,
988 _depth: fidl::encoding::Depth,
989 ) -> fidl::Result<()> {
990 encoder.debug_check_bounds::<Self>(offset);
991 encoder.write_num(self.into_primitive(), offset);
992 Ok(())
993 }
994 }
995
996 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LogDestination {
997 #[inline(always)]
998 fn new_empty() -> Self {
999 Self::Syslog
1000 }
1001
1002 #[inline]
1003 unsafe fn decode(
1004 &mut self,
1005 decoder: &mut fidl::encoding::Decoder<'_, D>,
1006 offset: usize,
1007 _depth: fidl::encoding::Depth,
1008 ) -> fidl::Result<()> {
1009 decoder.debug_check_bounds::<Self>(offset);
1010 let prim = decoder.read_num::<u8>(offset);
1011
1012 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1013 Ok(())
1014 }
1015 }
1016 unsafe impl fidl::encoding::TypeMarker for RealmBuilderResolverAndRunner {
1017 type Owned = Self;
1018
1019 #[inline(always)]
1020 fn inline_align(_context: fidl::encoding::Context) -> usize {
1021 std::mem::align_of::<u8>()
1022 }
1023
1024 #[inline(always)]
1025 fn inline_size(_context: fidl::encoding::Context) -> usize {
1026 std::mem::size_of::<u8>()
1027 }
1028
1029 #[inline(always)]
1030 fn encode_is_copy() -> bool {
1031 true
1032 }
1033
1034 #[inline(always)]
1035 fn decode_is_copy() -> bool {
1036 false
1037 }
1038 }
1039
1040 impl fidl::encoding::ValueTypeMarker for RealmBuilderResolverAndRunner {
1041 type Borrowed<'a> = Self;
1042 #[inline(always)]
1043 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1044 *value
1045 }
1046 }
1047
1048 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1049 for RealmBuilderResolverAndRunner
1050 {
1051 #[inline]
1052 unsafe fn encode(
1053 self,
1054 encoder: &mut fidl::encoding::Encoder<'_, D>,
1055 offset: usize,
1056 _depth: fidl::encoding::Depth,
1057 ) -> fidl::Result<()> {
1058 encoder.debug_check_bounds::<Self>(offset);
1059 encoder.write_num(self.into_primitive(), offset);
1060 Ok(())
1061 }
1062 }
1063
1064 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1065 for RealmBuilderResolverAndRunner
1066 {
1067 #[inline(always)]
1068 fn new_empty() -> Self {
1069 Self::None
1070 }
1071
1072 #[inline]
1073 unsafe fn decode(
1074 &mut self,
1075 decoder: &mut fidl::encoding::Decoder<'_, D>,
1076 offset: usize,
1077 _depth: fidl::encoding::Depth,
1078 ) -> fidl::Result<()> {
1079 decoder.debug_check_bounds::<Self>(offset);
1080 let prim = decoder.read_num::<u8>(offset);
1081
1082 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1083 Ok(())
1084 }
1085 }
1086 unsafe impl fidl::encoding::TypeMarker for TraceProvider {
1087 type Owned = Self;
1088
1089 #[inline(always)]
1090 fn inline_align(_context: fidl::encoding::Context) -> usize {
1091 std::mem::align_of::<u8>()
1092 }
1093
1094 #[inline(always)]
1095 fn inline_size(_context: fidl::encoding::Context) -> usize {
1096 std::mem::size_of::<u8>()
1097 }
1098
1099 #[inline(always)]
1100 fn encode_is_copy() -> bool {
1101 true
1102 }
1103
1104 #[inline(always)]
1105 fn decode_is_copy() -> bool {
1106 false
1107 }
1108 }
1109
1110 impl fidl::encoding::ValueTypeMarker for TraceProvider {
1111 type Borrowed<'a> = Self;
1112 #[inline(always)]
1113 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1114 *value
1115 }
1116 }
1117
1118 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TraceProvider {
1119 #[inline]
1120 unsafe fn encode(
1121 self,
1122 encoder: &mut fidl::encoding::Encoder<'_, D>,
1123 offset: usize,
1124 _depth: fidl::encoding::Depth,
1125 ) -> fidl::Result<()> {
1126 encoder.debug_check_bounds::<Self>(offset);
1127 encoder.write_num(self.into_primitive(), offset);
1128 Ok(())
1129 }
1130 }
1131
1132 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TraceProvider {
1133 #[inline(always)]
1134 fn new_empty() -> Self {
1135 Self::Namespace
1136 }
1137
1138 #[inline]
1139 unsafe fn decode(
1140 &mut self,
1141 decoder: &mut fidl::encoding::Decoder<'_, D>,
1142 offset: usize,
1143 _depth: fidl::encoding::Depth,
1144 ) -> fidl::Result<()> {
1145 decoder.debug_check_bounds::<Self>(offset);
1146 let prim = decoder.read_num::<u8>(offset);
1147
1148 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1149 Ok(())
1150 }
1151 }
1152 unsafe impl fidl::encoding::TypeMarker for VmexSource {
1153 type Owned = Self;
1154
1155 #[inline(always)]
1156 fn inline_align(_context: fidl::encoding::Context) -> usize {
1157 std::mem::align_of::<u8>()
1158 }
1159
1160 #[inline(always)]
1161 fn inline_size(_context: fidl::encoding::Context) -> usize {
1162 std::mem::size_of::<u8>()
1163 }
1164
1165 #[inline(always)]
1166 fn encode_is_copy() -> bool {
1167 true
1168 }
1169
1170 #[inline(always)]
1171 fn decode_is_copy() -> bool {
1172 false
1173 }
1174 }
1175
1176 impl fidl::encoding::ValueTypeMarker for VmexSource {
1177 type Borrowed<'a> = Self;
1178 #[inline(always)]
1179 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1180 *value
1181 }
1182 }
1183
1184 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for VmexSource {
1185 #[inline]
1186 unsafe fn encode(
1187 self,
1188 encoder: &mut fidl::encoding::Encoder<'_, D>,
1189 offset: usize,
1190 _depth: fidl::encoding::Depth,
1191 ) -> fidl::Result<()> {
1192 encoder.debug_check_bounds::<Self>(offset);
1193 encoder.write_num(self.into_primitive(), offset);
1194 Ok(())
1195 }
1196 }
1197
1198 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VmexSource {
1199 #[inline(always)]
1200 fn new_empty() -> Self {
1201 Self::SystemResource
1202 }
1203
1204 #[inline]
1205 unsafe fn decode(
1206 &mut self,
1207 decoder: &mut fidl::encoding::Decoder<'_, D>,
1208 offset: usize,
1209 _depth: fidl::encoding::Depth,
1210 ) -> fidl::Result<()> {
1211 decoder.debug_check_bounds::<Self>(offset);
1212 let prim = decoder.read_num::<u8>(offset);
1213
1214 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1215 Ok(())
1216 }
1217 }
1218
1219 impl AbiRevisionPolicy {
1220 #[inline(always)]
1221 fn max_ordinal_present(&self) -> u64 {
1222 if let Some(_) = self.allowlist {
1223 return 1;
1224 }
1225 0
1226 }
1227 }
1228
1229 impl fidl::encoding::ValueTypeMarker for AbiRevisionPolicy {
1230 type Borrowed<'a> = &'a Self;
1231 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1232 value
1233 }
1234 }
1235
1236 unsafe impl fidl::encoding::TypeMarker for AbiRevisionPolicy {
1237 type Owned = Self;
1238
1239 #[inline(always)]
1240 fn inline_align(_context: fidl::encoding::Context) -> usize {
1241 8
1242 }
1243
1244 #[inline(always)]
1245 fn inline_size(_context: fidl::encoding::Context) -> usize {
1246 16
1247 }
1248 }
1249
1250 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AbiRevisionPolicy, D>
1251 for &AbiRevisionPolicy
1252 {
1253 unsafe fn encode(
1254 self,
1255 encoder: &mut fidl::encoding::Encoder<'_, D>,
1256 offset: usize,
1257 mut depth: fidl::encoding::Depth,
1258 ) -> fidl::Result<()> {
1259 encoder.debug_check_bounds::<AbiRevisionPolicy>(offset);
1260 let max_ordinal: u64 = self.max_ordinal_present();
1262 encoder.write_num(max_ordinal, offset);
1263 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1264 if max_ordinal == 0 {
1266 return Ok(());
1267 }
1268 depth.increment()?;
1269 let envelope_size = 8;
1270 let bytes_len = max_ordinal as usize * envelope_size;
1271 #[allow(unused_variables)]
1272 let offset = encoder.out_of_line_offset(bytes_len);
1273 let mut _prev_end_offset: usize = 0;
1274 if 1 > max_ordinal {
1275 return Ok(());
1276 }
1277
1278 let cur_offset: usize = (1 - 1) * envelope_size;
1281
1282 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1284
1285 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
1290 self.allowlist.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
1291 encoder, offset + cur_offset, depth
1292 )?;
1293
1294 _prev_end_offset = cur_offset + envelope_size;
1295
1296 Ok(())
1297 }
1298 }
1299
1300 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AbiRevisionPolicy {
1301 #[inline(always)]
1302 fn new_empty() -> Self {
1303 Self::default()
1304 }
1305
1306 unsafe fn decode(
1307 &mut self,
1308 decoder: &mut fidl::encoding::Decoder<'_, D>,
1309 offset: usize,
1310 mut depth: fidl::encoding::Depth,
1311 ) -> fidl::Result<()> {
1312 decoder.debug_check_bounds::<Self>(offset);
1313 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1314 None => return Err(fidl::Error::NotNullable),
1315 Some(len) => len,
1316 };
1317 if len == 0 {
1319 return Ok(());
1320 };
1321 depth.increment()?;
1322 let envelope_size = 8;
1323 let bytes_len = len * envelope_size;
1324 let offset = decoder.out_of_line_offset(bytes_len)?;
1325 let mut _next_ordinal_to_read = 0;
1327 let mut next_offset = offset;
1328 let end_offset = offset + bytes_len;
1329 _next_ordinal_to_read += 1;
1330 if next_offset >= end_offset {
1331 return Ok(());
1332 }
1333
1334 while _next_ordinal_to_read < 1 {
1336 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1337 _next_ordinal_to_read += 1;
1338 next_offset += envelope_size;
1339 }
1340
1341 let next_out_of_line = decoder.next_out_of_line();
1342 let handles_before = decoder.remaining_handles();
1343 if let Some((inlined, num_bytes, num_handles)) =
1344 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1345 {
1346 let member_inline_size = <fidl::encoding::Vector<
1347 fidl::encoding::BoundedString<4096>,
1348 128,
1349 > as fidl::encoding::TypeMarker>::inline_size(
1350 decoder.context
1351 );
1352 if inlined != (member_inline_size <= 4) {
1353 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1354 }
1355 let inner_offset;
1356 let mut inner_depth = depth.clone();
1357 if inlined {
1358 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1359 inner_offset = next_offset;
1360 } else {
1361 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1362 inner_depth.increment()?;
1363 }
1364 let val_ref = self.allowlist.get_or_insert_with(|| {
1365 fidl::new_empty!(
1366 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
1367 D
1368 )
1369 });
1370 fidl::decode!(
1371 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
1372 D,
1373 val_ref,
1374 decoder,
1375 inner_offset,
1376 inner_depth
1377 )?;
1378 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1379 {
1380 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1381 }
1382 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1383 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1384 }
1385 }
1386
1387 next_offset += envelope_size;
1388
1389 while next_offset < end_offset {
1391 _next_ordinal_to_read += 1;
1392 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1393 next_offset += envelope_size;
1394 }
1395
1396 Ok(())
1397 }
1398 }
1399
1400 impl AllowlistedDirectory {
1401 #[inline(always)]
1402 fn max_ordinal_present(&self) -> u64 {
1403 0
1404 }
1405 }
1406
1407 impl fidl::encoding::ValueTypeMarker for AllowlistedDirectory {
1408 type Borrowed<'a> = &'a Self;
1409 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1410 value
1411 }
1412 }
1413
1414 unsafe impl fidl::encoding::TypeMarker for AllowlistedDirectory {
1415 type Owned = Self;
1416
1417 #[inline(always)]
1418 fn inline_align(_context: fidl::encoding::Context) -> usize {
1419 8
1420 }
1421
1422 #[inline(always)]
1423 fn inline_size(_context: fidl::encoding::Context) -> usize {
1424 16
1425 }
1426 }
1427
1428 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedDirectory, D>
1429 for &AllowlistedDirectory
1430 {
1431 unsafe fn encode(
1432 self,
1433 encoder: &mut fidl::encoding::Encoder<'_, D>,
1434 offset: usize,
1435 mut depth: fidl::encoding::Depth,
1436 ) -> fidl::Result<()> {
1437 encoder.debug_check_bounds::<AllowlistedDirectory>(offset);
1438 let max_ordinal: u64 = self.max_ordinal_present();
1440 encoder.write_num(max_ordinal, offset);
1441 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1442 if max_ordinal == 0 {
1444 return Ok(());
1445 }
1446 depth.increment()?;
1447 let envelope_size = 8;
1448 let bytes_len = max_ordinal as usize * envelope_size;
1449 #[allow(unused_variables)]
1450 let offset = encoder.out_of_line_offset(bytes_len);
1451 let mut _prev_end_offset: usize = 0;
1452
1453 Ok(())
1454 }
1455 }
1456
1457 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedDirectory {
1458 #[inline(always)]
1459 fn new_empty() -> Self {
1460 Self::default()
1461 }
1462
1463 unsafe fn decode(
1464 &mut self,
1465 decoder: &mut fidl::encoding::Decoder<'_, D>,
1466 offset: usize,
1467 mut depth: fidl::encoding::Depth,
1468 ) -> fidl::Result<()> {
1469 decoder.debug_check_bounds::<Self>(offset);
1470 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1471 None => return Err(fidl::Error::NotNullable),
1472 Some(len) => len,
1473 };
1474 if len == 0 {
1476 return Ok(());
1477 };
1478 depth.increment()?;
1479 let envelope_size = 8;
1480 let bytes_len = len * envelope_size;
1481 let offset = decoder.out_of_line_offset(bytes_len)?;
1482 let mut _next_ordinal_to_read = 0;
1484 let mut next_offset = offset;
1485 let end_offset = offset + bytes_len;
1486
1487 while next_offset < end_offset {
1489 _next_ordinal_to_read += 1;
1490 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1491 next_offset += envelope_size;
1492 }
1493
1494 Ok(())
1495 }
1496 }
1497
1498 impl AllowlistedProtocol {
1499 #[inline(always)]
1500 fn max_ordinal_present(&self) -> u64 {
1501 0
1502 }
1503 }
1504
1505 impl fidl::encoding::ValueTypeMarker for AllowlistedProtocol {
1506 type Borrowed<'a> = &'a Self;
1507 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1508 value
1509 }
1510 }
1511
1512 unsafe impl fidl::encoding::TypeMarker for AllowlistedProtocol {
1513 type Owned = Self;
1514
1515 #[inline(always)]
1516 fn inline_align(_context: fidl::encoding::Context) -> usize {
1517 8
1518 }
1519
1520 #[inline(always)]
1521 fn inline_size(_context: fidl::encoding::Context) -> usize {
1522 16
1523 }
1524 }
1525
1526 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedProtocol, D>
1527 for &AllowlistedProtocol
1528 {
1529 unsafe fn encode(
1530 self,
1531 encoder: &mut fidl::encoding::Encoder<'_, D>,
1532 offset: usize,
1533 mut depth: fidl::encoding::Depth,
1534 ) -> fidl::Result<()> {
1535 encoder.debug_check_bounds::<AllowlistedProtocol>(offset);
1536 let max_ordinal: u64 = self.max_ordinal_present();
1538 encoder.write_num(max_ordinal, offset);
1539 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1540 if max_ordinal == 0 {
1542 return Ok(());
1543 }
1544 depth.increment()?;
1545 let envelope_size = 8;
1546 let bytes_len = max_ordinal as usize * envelope_size;
1547 #[allow(unused_variables)]
1548 let offset = encoder.out_of_line_offset(bytes_len);
1549 let mut _prev_end_offset: usize = 0;
1550
1551 Ok(())
1552 }
1553 }
1554
1555 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedProtocol {
1556 #[inline(always)]
1557 fn new_empty() -> Self {
1558 Self::default()
1559 }
1560
1561 unsafe fn decode(
1562 &mut self,
1563 decoder: &mut fidl::encoding::Decoder<'_, D>,
1564 offset: usize,
1565 mut depth: fidl::encoding::Depth,
1566 ) -> fidl::Result<()> {
1567 decoder.debug_check_bounds::<Self>(offset);
1568 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1569 None => return Err(fidl::Error::NotNullable),
1570 Some(len) => len,
1571 };
1572 if len == 0 {
1574 return Ok(());
1575 };
1576 depth.increment()?;
1577 let envelope_size = 8;
1578 let bytes_len = len * envelope_size;
1579 let offset = decoder.out_of_line_offset(bytes_len)?;
1580 let mut _next_ordinal_to_read = 0;
1582 let mut next_offset = offset;
1583 let end_offset = offset + bytes_len;
1584
1585 while next_offset < end_offset {
1587 _next_ordinal_to_read += 1;
1588 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1589 next_offset += envelope_size;
1590 }
1591
1592 Ok(())
1593 }
1594 }
1595
1596 impl AllowlistedResolver {
1597 #[inline(always)]
1598 fn max_ordinal_present(&self) -> u64 {
1599 0
1600 }
1601 }
1602
1603 impl fidl::encoding::ValueTypeMarker for AllowlistedResolver {
1604 type Borrowed<'a> = &'a Self;
1605 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1606 value
1607 }
1608 }
1609
1610 unsafe impl fidl::encoding::TypeMarker for AllowlistedResolver {
1611 type Owned = Self;
1612
1613 #[inline(always)]
1614 fn inline_align(_context: fidl::encoding::Context) -> usize {
1615 8
1616 }
1617
1618 #[inline(always)]
1619 fn inline_size(_context: fidl::encoding::Context) -> usize {
1620 16
1621 }
1622 }
1623
1624 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedResolver, D>
1625 for &AllowlistedResolver
1626 {
1627 unsafe fn encode(
1628 self,
1629 encoder: &mut fidl::encoding::Encoder<'_, D>,
1630 offset: usize,
1631 mut depth: fidl::encoding::Depth,
1632 ) -> fidl::Result<()> {
1633 encoder.debug_check_bounds::<AllowlistedResolver>(offset);
1634 let max_ordinal: u64 = self.max_ordinal_present();
1636 encoder.write_num(max_ordinal, offset);
1637 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1638 if max_ordinal == 0 {
1640 return Ok(());
1641 }
1642 depth.increment()?;
1643 let envelope_size = 8;
1644 let bytes_len = max_ordinal as usize * envelope_size;
1645 #[allow(unused_variables)]
1646 let offset = encoder.out_of_line_offset(bytes_len);
1647 let mut _prev_end_offset: usize = 0;
1648
1649 Ok(())
1650 }
1651 }
1652
1653 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedResolver {
1654 #[inline(always)]
1655 fn new_empty() -> Self {
1656 Self::default()
1657 }
1658
1659 unsafe fn decode(
1660 &mut self,
1661 decoder: &mut fidl::encoding::Decoder<'_, D>,
1662 offset: usize,
1663 mut depth: fidl::encoding::Depth,
1664 ) -> fidl::Result<()> {
1665 decoder.debug_check_bounds::<Self>(offset);
1666 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1667 None => return Err(fidl::Error::NotNullable),
1668 Some(len) => len,
1669 };
1670 if len == 0 {
1672 return Ok(());
1673 };
1674 depth.increment()?;
1675 let envelope_size = 8;
1676 let bytes_len = len * envelope_size;
1677 let offset = decoder.out_of_line_offset(bytes_len)?;
1678 let mut _next_ordinal_to_read = 0;
1680 let mut next_offset = offset;
1681 let end_offset = offset + bytes_len;
1682
1683 while next_offset < end_offset {
1685 _next_ordinal_to_read += 1;
1686 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1687 next_offset += envelope_size;
1688 }
1689
1690 Ok(())
1691 }
1692 }
1693
1694 impl AllowlistedRunner {
1695 #[inline(always)]
1696 fn max_ordinal_present(&self) -> u64 {
1697 0
1698 }
1699 }
1700
1701 impl fidl::encoding::ValueTypeMarker for AllowlistedRunner {
1702 type Borrowed<'a> = &'a Self;
1703 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1704 value
1705 }
1706 }
1707
1708 unsafe impl fidl::encoding::TypeMarker for AllowlistedRunner {
1709 type Owned = Self;
1710
1711 #[inline(always)]
1712 fn inline_align(_context: fidl::encoding::Context) -> usize {
1713 8
1714 }
1715
1716 #[inline(always)]
1717 fn inline_size(_context: fidl::encoding::Context) -> usize {
1718 16
1719 }
1720 }
1721
1722 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedRunner, D>
1723 for &AllowlistedRunner
1724 {
1725 unsafe fn encode(
1726 self,
1727 encoder: &mut fidl::encoding::Encoder<'_, D>,
1728 offset: usize,
1729 mut depth: fidl::encoding::Depth,
1730 ) -> fidl::Result<()> {
1731 encoder.debug_check_bounds::<AllowlistedRunner>(offset);
1732 let max_ordinal: u64 = self.max_ordinal_present();
1734 encoder.write_num(max_ordinal, offset);
1735 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1736 if max_ordinal == 0 {
1738 return Ok(());
1739 }
1740 depth.increment()?;
1741 let envelope_size = 8;
1742 let bytes_len = max_ordinal as usize * envelope_size;
1743 #[allow(unused_variables)]
1744 let offset = encoder.out_of_line_offset(bytes_len);
1745 let mut _prev_end_offset: usize = 0;
1746
1747 Ok(())
1748 }
1749 }
1750
1751 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedRunner {
1752 #[inline(always)]
1753 fn new_empty() -> Self {
1754 Self::default()
1755 }
1756
1757 unsafe fn decode(
1758 &mut self,
1759 decoder: &mut fidl::encoding::Decoder<'_, D>,
1760 offset: usize,
1761 mut depth: fidl::encoding::Depth,
1762 ) -> fidl::Result<()> {
1763 decoder.debug_check_bounds::<Self>(offset);
1764 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1765 None => return Err(fidl::Error::NotNullable),
1766 Some(len) => len,
1767 };
1768 if len == 0 {
1770 return Ok(());
1771 };
1772 depth.increment()?;
1773 let envelope_size = 8;
1774 let bytes_len = len * envelope_size;
1775 let offset = decoder.out_of_line_offset(bytes_len)?;
1776 let mut _next_ordinal_to_read = 0;
1778 let mut next_offset = offset;
1779 let end_offset = offset + bytes_len;
1780
1781 while next_offset < end_offset {
1783 _next_ordinal_to_read += 1;
1784 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1785 next_offset += envelope_size;
1786 }
1787
1788 Ok(())
1789 }
1790 }
1791
1792 impl AllowlistedService {
1793 #[inline(always)]
1794 fn max_ordinal_present(&self) -> u64 {
1795 0
1796 }
1797 }
1798
1799 impl fidl::encoding::ValueTypeMarker for AllowlistedService {
1800 type Borrowed<'a> = &'a Self;
1801 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1802 value
1803 }
1804 }
1805
1806 unsafe impl fidl::encoding::TypeMarker for AllowlistedService {
1807 type Owned = Self;
1808
1809 #[inline(always)]
1810 fn inline_align(_context: fidl::encoding::Context) -> usize {
1811 8
1812 }
1813
1814 #[inline(always)]
1815 fn inline_size(_context: fidl::encoding::Context) -> usize {
1816 16
1817 }
1818 }
1819
1820 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedService, D>
1821 for &AllowlistedService
1822 {
1823 unsafe fn encode(
1824 self,
1825 encoder: &mut fidl::encoding::Encoder<'_, D>,
1826 offset: usize,
1827 mut depth: fidl::encoding::Depth,
1828 ) -> fidl::Result<()> {
1829 encoder.debug_check_bounds::<AllowlistedService>(offset);
1830 let max_ordinal: u64 = self.max_ordinal_present();
1832 encoder.write_num(max_ordinal, offset);
1833 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1834 if max_ordinal == 0 {
1836 return Ok(());
1837 }
1838 depth.increment()?;
1839 let envelope_size = 8;
1840 let bytes_len = max_ordinal as usize * envelope_size;
1841 #[allow(unused_variables)]
1842 let offset = encoder.out_of_line_offset(bytes_len);
1843 let mut _prev_end_offset: usize = 0;
1844
1845 Ok(())
1846 }
1847 }
1848
1849 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedService {
1850 #[inline(always)]
1851 fn new_empty() -> Self {
1852 Self::default()
1853 }
1854
1855 unsafe fn decode(
1856 &mut self,
1857 decoder: &mut fidl::encoding::Decoder<'_, D>,
1858 offset: usize,
1859 mut depth: fidl::encoding::Depth,
1860 ) -> fidl::Result<()> {
1861 decoder.debug_check_bounds::<Self>(offset);
1862 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1863 None => return Err(fidl::Error::NotNullable),
1864 Some(len) => len,
1865 };
1866 if len == 0 {
1868 return Ok(());
1869 };
1870 depth.increment()?;
1871 let envelope_size = 8;
1872 let bytes_len = len * envelope_size;
1873 let offset = decoder.out_of_line_offset(bytes_len)?;
1874 let mut _next_ordinal_to_read = 0;
1876 let mut next_offset = offset;
1877 let end_offset = offset + bytes_len;
1878
1879 while next_offset < end_offset {
1881 _next_ordinal_to_read += 1;
1882 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1883 next_offset += envelope_size;
1884 }
1885
1886 Ok(())
1887 }
1888 }
1889
1890 impl AllowlistedStorage {
1891 #[inline(always)]
1892 fn max_ordinal_present(&self) -> u64 {
1893 0
1894 }
1895 }
1896
1897 impl fidl::encoding::ValueTypeMarker for AllowlistedStorage {
1898 type Borrowed<'a> = &'a Self;
1899 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1900 value
1901 }
1902 }
1903
1904 unsafe impl fidl::encoding::TypeMarker for AllowlistedStorage {
1905 type Owned = Self;
1906
1907 #[inline(always)]
1908 fn inline_align(_context: fidl::encoding::Context) -> usize {
1909 8
1910 }
1911
1912 #[inline(always)]
1913 fn inline_size(_context: fidl::encoding::Context) -> usize {
1914 16
1915 }
1916 }
1917
1918 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedStorage, D>
1919 for &AllowlistedStorage
1920 {
1921 unsafe fn encode(
1922 self,
1923 encoder: &mut fidl::encoding::Encoder<'_, D>,
1924 offset: usize,
1925 mut depth: fidl::encoding::Depth,
1926 ) -> fidl::Result<()> {
1927 encoder.debug_check_bounds::<AllowlistedStorage>(offset);
1928 let max_ordinal: u64 = self.max_ordinal_present();
1930 encoder.write_num(max_ordinal, offset);
1931 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1932 if max_ordinal == 0 {
1934 return Ok(());
1935 }
1936 depth.increment()?;
1937 let envelope_size = 8;
1938 let bytes_len = max_ordinal as usize * envelope_size;
1939 #[allow(unused_variables)]
1940 let offset = encoder.out_of_line_offset(bytes_len);
1941 let mut _prev_end_offset: usize = 0;
1942
1943 Ok(())
1944 }
1945 }
1946
1947 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedStorage {
1948 #[inline(always)]
1949 fn new_empty() -> Self {
1950 Self::default()
1951 }
1952
1953 unsafe fn decode(
1954 &mut self,
1955 decoder: &mut fidl::encoding::Decoder<'_, D>,
1956 offset: usize,
1957 mut depth: fidl::encoding::Depth,
1958 ) -> fidl::Result<()> {
1959 decoder.debug_check_bounds::<Self>(offset);
1960 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1961 None => return Err(fidl::Error::NotNullable),
1962 Some(len) => len,
1963 };
1964 if len == 0 {
1966 return Ok(());
1967 };
1968 depth.increment()?;
1969 let envelope_size = 8;
1970 let bytes_len = len * envelope_size;
1971 let offset = decoder.out_of_line_offset(bytes_len)?;
1972 let mut _next_ordinal_to_read = 0;
1974 let mut next_offset = offset;
1975 let end_offset = offset + bytes_len;
1976
1977 while next_offset < end_offset {
1979 _next_ordinal_to_read += 1;
1980 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1981 next_offset += envelope_size;
1982 }
1983
1984 Ok(())
1985 }
1986 }
1987
1988 impl AnonymizedAggregate {
1989 #[inline(always)]
1990 fn max_ordinal_present(&self) -> u64 {
1991 if let Some(_) = self.instances {
1992 return 5;
1993 }
1994 if let Some(_) = self.sources {
1995 return 4;
1996 }
1997 if let Some(_) = self.members {
1998 return 3;
1999 }
2000 if let Some(_) = self.moniker {
2001 return 2;
2002 }
2003 if let Some(_) = self.capability {
2004 return 1;
2005 }
2006 0
2007 }
2008 }
2009
2010 impl fidl::encoding::ValueTypeMarker for AnonymizedAggregate {
2011 type Borrowed<'a> = &'a Self;
2012 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2013 value
2014 }
2015 }
2016
2017 unsafe impl fidl::encoding::TypeMarker for AnonymizedAggregate {
2018 type Owned = Self;
2019
2020 #[inline(always)]
2021 fn inline_align(_context: fidl::encoding::Context) -> usize {
2022 8
2023 }
2024
2025 #[inline(always)]
2026 fn inline_size(_context: fidl::encoding::Context) -> usize {
2027 16
2028 }
2029 }
2030
2031 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AnonymizedAggregate, D>
2032 for &AnonymizedAggregate
2033 {
2034 unsafe fn encode(
2035 self,
2036 encoder: &mut fidl::encoding::Encoder<'_, D>,
2037 offset: usize,
2038 mut depth: fidl::encoding::Depth,
2039 ) -> fidl::Result<()> {
2040 encoder.debug_check_bounds::<AnonymizedAggregate>(offset);
2041 let max_ordinal: u64 = self.max_ordinal_present();
2043 encoder.write_num(max_ordinal, offset);
2044 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2045 if max_ordinal == 0 {
2047 return Ok(());
2048 }
2049 depth.increment()?;
2050 let envelope_size = 8;
2051 let bytes_len = max_ordinal as usize * envelope_size;
2052 #[allow(unused_variables)]
2053 let offset = encoder.out_of_line_offset(bytes_len);
2054 let mut _prev_end_offset: usize = 0;
2055 if 1 > max_ordinal {
2056 return Ok(());
2057 }
2058
2059 let cur_offset: usize = (1 - 1) * envelope_size;
2062
2063 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2065
2066 fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
2071 self.capability
2072 .as_ref()
2073 .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
2074 encoder,
2075 offset + cur_offset,
2076 depth,
2077 )?;
2078
2079 _prev_end_offset = cur_offset + envelope_size;
2080 if 2 > max_ordinal {
2081 return Ok(());
2082 }
2083
2084 let cur_offset: usize = (2 - 1) * envelope_size;
2087
2088 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2090
2091 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2096 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2097 encoder, offset + cur_offset, depth
2098 )?;
2099
2100 _prev_end_offset = cur_offset + envelope_size;
2101 if 3 > max_ordinal {
2102 return Ok(());
2103 }
2104
2105 let cur_offset: usize = (3 - 1) * envelope_size;
2108
2109 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2111
2112 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<AggregateMember>, D>(
2117 self.members.as_ref().map(<fidl::encoding::UnboundedVector<AggregateMember> as fidl::encoding::ValueTypeMarker>::borrow),
2118 encoder, offset + cur_offset, depth
2119 )?;
2120
2121 _prev_end_offset = cur_offset + envelope_size;
2122 if 4 > max_ordinal {
2123 return Ok(());
2124 }
2125
2126 let cur_offset: usize = (4 - 1) * envelope_size;
2129
2130 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2132
2133 fidl::encoding::encode_in_envelope_optional::<Sources, D>(
2138 self.sources.as_ref().map(<Sources as fidl::encoding::ValueTypeMarker>::borrow),
2139 encoder,
2140 offset + cur_offset,
2141 depth,
2142 )?;
2143
2144 _prev_end_offset = cur_offset + envelope_size;
2145 if 5 > max_ordinal {
2146 return Ok(());
2147 }
2148
2149 let cur_offset: usize = (5 - 1) * envelope_size;
2152
2153 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2155
2156 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>, D>(
2161 self.instances.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance> as fidl::encoding::ValueTypeMarker>::borrow),
2162 encoder, offset + cur_offset, depth
2163 )?;
2164
2165 _prev_end_offset = cur_offset + envelope_size;
2166
2167 Ok(())
2168 }
2169 }
2170
2171 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AnonymizedAggregate {
2172 #[inline(always)]
2173 fn new_empty() -> Self {
2174 Self::default()
2175 }
2176
2177 unsafe fn decode(
2178 &mut self,
2179 decoder: &mut fidl::encoding::Decoder<'_, D>,
2180 offset: usize,
2181 mut depth: fidl::encoding::Depth,
2182 ) -> fidl::Result<()> {
2183 decoder.debug_check_bounds::<Self>(offset);
2184 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2185 None => return Err(fidl::Error::NotNullable),
2186 Some(len) => len,
2187 };
2188 if len == 0 {
2190 return Ok(());
2191 };
2192 depth.increment()?;
2193 let envelope_size = 8;
2194 let bytes_len = len * envelope_size;
2195 let offset = decoder.out_of_line_offset(bytes_len)?;
2196 let mut _next_ordinal_to_read = 0;
2198 let mut next_offset = offset;
2199 let end_offset = offset + bytes_len;
2200 _next_ordinal_to_read += 1;
2201 if next_offset >= end_offset {
2202 return Ok(());
2203 }
2204
2205 while _next_ordinal_to_read < 1 {
2207 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2208 _next_ordinal_to_read += 1;
2209 next_offset += envelope_size;
2210 }
2211
2212 let next_out_of_line = decoder.next_out_of_line();
2213 let handles_before = decoder.remaining_handles();
2214 if let Some((inlined, num_bytes, num_handles)) =
2215 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2216 {
2217 let member_inline_size =
2218 <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
2219 decoder.context,
2220 );
2221 if inlined != (member_inline_size <= 4) {
2222 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2223 }
2224 let inner_offset;
2225 let mut inner_depth = depth.clone();
2226 if inlined {
2227 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2228 inner_offset = next_offset;
2229 } else {
2230 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2231 inner_depth.increment()?;
2232 }
2233 let val_ref =
2234 self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
2235 fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2236 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2237 {
2238 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2239 }
2240 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2241 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2242 }
2243 }
2244
2245 next_offset += envelope_size;
2246 _next_ordinal_to_read += 1;
2247 if next_offset >= end_offset {
2248 return Ok(());
2249 }
2250
2251 while _next_ordinal_to_read < 2 {
2253 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2254 _next_ordinal_to_read += 1;
2255 next_offset += envelope_size;
2256 }
2257
2258 let next_out_of_line = decoder.next_out_of_line();
2259 let handles_before = decoder.remaining_handles();
2260 if let Some((inlined, num_bytes, num_handles)) =
2261 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2262 {
2263 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2264 if inlined != (member_inline_size <= 4) {
2265 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2266 }
2267 let inner_offset;
2268 let mut inner_depth = depth.clone();
2269 if inlined {
2270 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2271 inner_offset = next_offset;
2272 } else {
2273 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2274 inner_depth.increment()?;
2275 }
2276 let val_ref = self.moniker.get_or_insert_with(|| {
2277 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
2278 });
2279 fidl::decode!(
2280 fidl::encoding::BoundedString<4096>,
2281 D,
2282 val_ref,
2283 decoder,
2284 inner_offset,
2285 inner_depth
2286 )?;
2287 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2288 {
2289 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2290 }
2291 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2292 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2293 }
2294 }
2295
2296 next_offset += envelope_size;
2297 _next_ordinal_to_read += 1;
2298 if next_offset >= end_offset {
2299 return Ok(());
2300 }
2301
2302 while _next_ordinal_to_read < 3 {
2304 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2305 _next_ordinal_to_read += 1;
2306 next_offset += envelope_size;
2307 }
2308
2309 let next_out_of_line = decoder.next_out_of_line();
2310 let handles_before = decoder.remaining_handles();
2311 if let Some((inlined, num_bytes, num_handles)) =
2312 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2313 {
2314 let member_inline_size = <fidl::encoding::UnboundedVector<AggregateMember> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2315 if inlined != (member_inline_size <= 4) {
2316 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2317 }
2318 let inner_offset;
2319 let mut inner_depth = depth.clone();
2320 if inlined {
2321 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2322 inner_offset = next_offset;
2323 } else {
2324 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2325 inner_depth.increment()?;
2326 }
2327 let val_ref = self.members.get_or_insert_with(|| {
2328 fidl::new_empty!(fidl::encoding::UnboundedVector<AggregateMember>, D)
2329 });
2330 fidl::decode!(
2331 fidl::encoding::UnboundedVector<AggregateMember>,
2332 D,
2333 val_ref,
2334 decoder,
2335 inner_offset,
2336 inner_depth
2337 )?;
2338 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2339 {
2340 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2341 }
2342 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2343 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2344 }
2345 }
2346
2347 next_offset += envelope_size;
2348 _next_ordinal_to_read += 1;
2349 if next_offset >= end_offset {
2350 return Ok(());
2351 }
2352
2353 while _next_ordinal_to_read < 4 {
2355 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2356 _next_ordinal_to_read += 1;
2357 next_offset += envelope_size;
2358 }
2359
2360 let next_out_of_line = decoder.next_out_of_line();
2361 let handles_before = decoder.remaining_handles();
2362 if let Some((inlined, num_bytes, num_handles)) =
2363 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2364 {
2365 let member_inline_size =
2366 <Sources as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2367 if inlined != (member_inline_size <= 4) {
2368 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2369 }
2370 let inner_offset;
2371 let mut inner_depth = depth.clone();
2372 if inlined {
2373 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2374 inner_offset = next_offset;
2375 } else {
2376 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2377 inner_depth.increment()?;
2378 }
2379 let val_ref = self.sources.get_or_insert_with(|| fidl::new_empty!(Sources, D));
2380 fidl::decode!(Sources, D, val_ref, decoder, inner_offset, inner_depth)?;
2381 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2382 {
2383 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2384 }
2385 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2386 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2387 }
2388 }
2389
2390 next_offset += envelope_size;
2391 _next_ordinal_to_read += 1;
2392 if next_offset >= end_offset {
2393 return Ok(());
2394 }
2395
2396 while _next_ordinal_to_read < 5 {
2398 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2399 _next_ordinal_to_read += 1;
2400 next_offset += envelope_size;
2401 }
2402
2403 let next_out_of_line = decoder.next_out_of_line();
2404 let handles_before = decoder.remaining_handles();
2405 if let Some((inlined, num_bytes, num_handles)) =
2406 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2407 {
2408 let member_inline_size = <fidl::encoding::UnboundedVector<
2409 fidl_fuchsia_sys2__common::ServiceInstance,
2410 > as fidl::encoding::TypeMarker>::inline_size(
2411 decoder.context
2412 );
2413 if inlined != (member_inline_size <= 4) {
2414 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2415 }
2416 let inner_offset;
2417 let mut inner_depth = depth.clone();
2418 if inlined {
2419 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2420 inner_offset = next_offset;
2421 } else {
2422 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2423 inner_depth.increment()?;
2424 }
2425 let val_ref = self.instances.get_or_insert_with(|| {
2426 fidl::new_empty!(
2427 fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>,
2428 D
2429 )
2430 });
2431 fidl::decode!(
2432 fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>,
2433 D,
2434 val_ref,
2435 decoder,
2436 inner_offset,
2437 inner_depth
2438 )?;
2439 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2440 {
2441 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2442 }
2443 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2444 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2445 }
2446 }
2447
2448 next_offset += envelope_size;
2449
2450 while next_offset < end_offset {
2452 _next_ordinal_to_read += 1;
2453 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2454 next_offset += envelope_size;
2455 }
2456
2457 Ok(())
2458 }
2459 }
2460
2461 impl Builtin {
2462 #[inline(always)]
2463 fn max_ordinal_present(&self) -> u64 {
2464 if let Some(_) = self.capability {
2465 return 1;
2466 }
2467 0
2468 }
2469 }
2470
2471 impl fidl::encoding::ValueTypeMarker for Builtin {
2472 type Borrowed<'a> = &'a Self;
2473 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2474 value
2475 }
2476 }
2477
2478 unsafe impl fidl::encoding::TypeMarker for Builtin {
2479 type Owned = Self;
2480
2481 #[inline(always)]
2482 fn inline_align(_context: fidl::encoding::Context) -> usize {
2483 8
2484 }
2485
2486 #[inline(always)]
2487 fn inline_size(_context: fidl::encoding::Context) -> usize {
2488 16
2489 }
2490 }
2491
2492 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Builtin, D> for &Builtin {
2493 unsafe fn encode(
2494 self,
2495 encoder: &mut fidl::encoding::Encoder<'_, D>,
2496 offset: usize,
2497 mut depth: fidl::encoding::Depth,
2498 ) -> fidl::Result<()> {
2499 encoder.debug_check_bounds::<Builtin>(offset);
2500 let max_ordinal: u64 = self.max_ordinal_present();
2502 encoder.write_num(max_ordinal, offset);
2503 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2504 if max_ordinal == 0 {
2506 return Ok(());
2507 }
2508 depth.increment()?;
2509 let envelope_size = 8;
2510 let bytes_len = max_ordinal as usize * envelope_size;
2511 #[allow(unused_variables)]
2512 let offset = encoder.out_of_line_offset(bytes_len);
2513 let mut _prev_end_offset: usize = 0;
2514 if 1 > max_ordinal {
2515 return Ok(());
2516 }
2517
2518 let cur_offset: usize = (1 - 1) * envelope_size;
2521
2522 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2524
2525 fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
2530 self.capability
2531 .as_ref()
2532 .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
2533 encoder,
2534 offset + cur_offset,
2535 depth,
2536 )?;
2537
2538 _prev_end_offset = cur_offset + envelope_size;
2539
2540 Ok(())
2541 }
2542 }
2543
2544 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Builtin {
2545 #[inline(always)]
2546 fn new_empty() -> Self {
2547 Self::default()
2548 }
2549
2550 unsafe fn decode(
2551 &mut self,
2552 decoder: &mut fidl::encoding::Decoder<'_, D>,
2553 offset: usize,
2554 mut depth: fidl::encoding::Depth,
2555 ) -> fidl::Result<()> {
2556 decoder.debug_check_bounds::<Self>(offset);
2557 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2558 None => return Err(fidl::Error::NotNullable),
2559 Some(len) => len,
2560 };
2561 if len == 0 {
2563 return Ok(());
2564 };
2565 depth.increment()?;
2566 let envelope_size = 8;
2567 let bytes_len = len * envelope_size;
2568 let offset = decoder.out_of_line_offset(bytes_len)?;
2569 let mut _next_ordinal_to_read = 0;
2571 let mut next_offset = offset;
2572 let end_offset = offset + bytes_len;
2573 _next_ordinal_to_read += 1;
2574 if next_offset >= end_offset {
2575 return Ok(());
2576 }
2577
2578 while _next_ordinal_to_read < 1 {
2580 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2581 _next_ordinal_to_read += 1;
2582 next_offset += envelope_size;
2583 }
2584
2585 let next_out_of_line = decoder.next_out_of_line();
2586 let handles_before = decoder.remaining_handles();
2587 if let Some((inlined, num_bytes, num_handles)) =
2588 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2589 {
2590 let member_inline_size =
2591 <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
2592 decoder.context,
2593 );
2594 if inlined != (member_inline_size <= 4) {
2595 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2596 }
2597 let inner_offset;
2598 let mut inner_depth = depth.clone();
2599 if inlined {
2600 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2601 inner_offset = next_offset;
2602 } else {
2603 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2604 inner_depth.increment()?;
2605 }
2606 let val_ref =
2607 self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
2608 fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2609 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2610 {
2611 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2612 }
2613 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2614 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2615 }
2616 }
2617
2618 next_offset += envelope_size;
2619
2620 while next_offset < end_offset {
2622 _next_ordinal_to_read += 1;
2623 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2624 next_offset += envelope_size;
2625 }
2626
2627 Ok(())
2628 }
2629 }
2630
2631 impl Capability {
2632 #[inline(always)]
2633 fn max_ordinal_present(&self) -> u64 {
2634 if let Some(_) = self.moniker {
2635 return 2;
2636 }
2637 if let Some(_) = self.source_capability {
2638 return 1;
2639 }
2640 0
2641 }
2642 }
2643
2644 impl fidl::encoding::ValueTypeMarker for Capability {
2645 type Borrowed<'a> = &'a Self;
2646 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2647 value
2648 }
2649 }
2650
2651 unsafe impl fidl::encoding::TypeMarker for Capability {
2652 type Owned = Self;
2653
2654 #[inline(always)]
2655 fn inline_align(_context: fidl::encoding::Context) -> usize {
2656 8
2657 }
2658
2659 #[inline(always)]
2660 fn inline_size(_context: fidl::encoding::Context) -> usize {
2661 16
2662 }
2663 }
2664
2665 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Capability, D>
2666 for &Capability
2667 {
2668 unsafe fn encode(
2669 self,
2670 encoder: &mut fidl::encoding::Encoder<'_, D>,
2671 offset: usize,
2672 mut depth: fidl::encoding::Depth,
2673 ) -> fidl::Result<()> {
2674 encoder.debug_check_bounds::<Capability>(offset);
2675 let max_ordinal: u64 = self.max_ordinal_present();
2677 encoder.write_num(max_ordinal, offset);
2678 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2679 if max_ordinal == 0 {
2681 return Ok(());
2682 }
2683 depth.increment()?;
2684 let envelope_size = 8;
2685 let bytes_len = max_ordinal as usize * envelope_size;
2686 #[allow(unused_variables)]
2687 let offset = encoder.out_of_line_offset(bytes_len);
2688 let mut _prev_end_offset: usize = 0;
2689 if 1 > max_ordinal {
2690 return Ok(());
2691 }
2692
2693 let cur_offset: usize = (1 - 1) * envelope_size;
2696
2697 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2699
2700 fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
2705 self.source_capability
2706 .as_ref()
2707 .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
2708 encoder,
2709 offset + cur_offset,
2710 depth,
2711 )?;
2712
2713 _prev_end_offset = cur_offset + envelope_size;
2714 if 2 > max_ordinal {
2715 return Ok(());
2716 }
2717
2718 let cur_offset: usize = (2 - 1) * envelope_size;
2721
2722 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2724
2725 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2730 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2731 encoder, offset + cur_offset, depth
2732 )?;
2733
2734 _prev_end_offset = cur_offset + envelope_size;
2735
2736 Ok(())
2737 }
2738 }
2739
2740 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Capability {
2741 #[inline(always)]
2742 fn new_empty() -> Self {
2743 Self::default()
2744 }
2745
2746 unsafe fn decode(
2747 &mut self,
2748 decoder: &mut fidl::encoding::Decoder<'_, D>,
2749 offset: usize,
2750 mut depth: fidl::encoding::Depth,
2751 ) -> fidl::Result<()> {
2752 decoder.debug_check_bounds::<Self>(offset);
2753 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2754 None => return Err(fidl::Error::NotNullable),
2755 Some(len) => len,
2756 };
2757 if len == 0 {
2759 return Ok(());
2760 };
2761 depth.increment()?;
2762 let envelope_size = 8;
2763 let bytes_len = len * envelope_size;
2764 let offset = decoder.out_of_line_offset(bytes_len)?;
2765 let mut _next_ordinal_to_read = 0;
2767 let mut next_offset = offset;
2768 let end_offset = offset + bytes_len;
2769 _next_ordinal_to_read += 1;
2770 if next_offset >= end_offset {
2771 return Ok(());
2772 }
2773
2774 while _next_ordinal_to_read < 1 {
2776 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2777 _next_ordinal_to_read += 1;
2778 next_offset += envelope_size;
2779 }
2780
2781 let next_out_of_line = decoder.next_out_of_line();
2782 let handles_before = decoder.remaining_handles();
2783 if let Some((inlined, num_bytes, num_handles)) =
2784 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2785 {
2786 let member_inline_size =
2787 <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
2788 decoder.context,
2789 );
2790 if inlined != (member_inline_size <= 4) {
2791 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2792 }
2793 let inner_offset;
2794 let mut inner_depth = depth.clone();
2795 if inlined {
2796 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2797 inner_offset = next_offset;
2798 } else {
2799 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2800 inner_depth.increment()?;
2801 }
2802 let val_ref = self
2803 .source_capability
2804 .get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
2805 fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2806 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2807 {
2808 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2809 }
2810 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2811 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2812 }
2813 }
2814
2815 next_offset += envelope_size;
2816 _next_ordinal_to_read += 1;
2817 if next_offset >= end_offset {
2818 return Ok(());
2819 }
2820
2821 while _next_ordinal_to_read < 2 {
2823 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2824 _next_ordinal_to_read += 1;
2825 next_offset += envelope_size;
2826 }
2827
2828 let next_out_of_line = decoder.next_out_of_line();
2829 let handles_before = decoder.remaining_handles();
2830 if let Some((inlined, num_bytes, num_handles)) =
2831 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2832 {
2833 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2834 if inlined != (member_inline_size <= 4) {
2835 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2836 }
2837 let inner_offset;
2838 let mut inner_depth = depth.clone();
2839 if inlined {
2840 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2841 inner_offset = next_offset;
2842 } else {
2843 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2844 inner_depth.increment()?;
2845 }
2846 let val_ref = self.moniker.get_or_insert_with(|| {
2847 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
2848 });
2849 fidl::decode!(
2850 fidl::encoding::BoundedString<4096>,
2851 D,
2852 val_ref,
2853 decoder,
2854 inner_offset,
2855 inner_depth
2856 )?;
2857 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2858 {
2859 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2860 }
2861 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2862 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2863 }
2864 }
2865
2866 next_offset += envelope_size;
2867
2868 while next_offset < end_offset {
2870 _next_ordinal_to_read += 1;
2871 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2872 next_offset += envelope_size;
2873 }
2874
2875 Ok(())
2876 }
2877 }
2878
2879 impl CapabilityAllowlistEntry {
2880 #[inline(always)]
2881 fn max_ordinal_present(&self) -> u64 {
2882 if let Some(_) = self.source {
2883 return 5;
2884 }
2885 if let Some(_) = self.target_monikers {
2886 return 4;
2887 }
2888 if let Some(_) = self.capability {
2889 return 3;
2890 }
2891 if let Some(_) = self.source_name {
2892 return 2;
2893 }
2894 if let Some(_) = self.source_moniker {
2895 return 1;
2896 }
2897 0
2898 }
2899 }
2900
2901 impl fidl::encoding::ValueTypeMarker for CapabilityAllowlistEntry {
2902 type Borrowed<'a> = &'a Self;
2903 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2904 value
2905 }
2906 }
2907
2908 unsafe impl fidl::encoding::TypeMarker for CapabilityAllowlistEntry {
2909 type Owned = Self;
2910
2911 #[inline(always)]
2912 fn inline_align(_context: fidl::encoding::Context) -> usize {
2913 8
2914 }
2915
2916 #[inline(always)]
2917 fn inline_size(_context: fidl::encoding::Context) -> usize {
2918 16
2919 }
2920 }
2921
2922 unsafe impl<D: fidl::encoding::ResourceDialect>
2923 fidl::encoding::Encode<CapabilityAllowlistEntry, D> for &CapabilityAllowlistEntry
2924 {
2925 unsafe fn encode(
2926 self,
2927 encoder: &mut fidl::encoding::Encoder<'_, D>,
2928 offset: usize,
2929 mut depth: fidl::encoding::Depth,
2930 ) -> fidl::Result<()> {
2931 encoder.debug_check_bounds::<CapabilityAllowlistEntry>(offset);
2932 let max_ordinal: u64 = self.max_ordinal_present();
2934 encoder.write_num(max_ordinal, offset);
2935 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2936 if max_ordinal == 0 {
2938 return Ok(());
2939 }
2940 depth.increment()?;
2941 let envelope_size = 8;
2942 let bytes_len = max_ordinal as usize * envelope_size;
2943 #[allow(unused_variables)]
2944 let offset = encoder.out_of_line_offset(bytes_len);
2945 let mut _prev_end_offset: usize = 0;
2946 if 1 > max_ordinal {
2947 return Ok(());
2948 }
2949
2950 let cur_offset: usize = (1 - 1) * envelope_size;
2953
2954 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2956
2957 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2962 self.source_moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2963 encoder, offset + cur_offset, depth
2964 )?;
2965
2966 _prev_end_offset = cur_offset + envelope_size;
2967 if 2 > max_ordinal {
2968 return Ok(());
2969 }
2970
2971 let cur_offset: usize = (2 - 1) * envelope_size;
2974
2975 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2977
2978 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
2983 self.source_name.as_ref().map(
2984 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
2985 ),
2986 encoder,
2987 offset + cur_offset,
2988 depth,
2989 )?;
2990
2991 _prev_end_offset = cur_offset + envelope_size;
2992 if 3 > max_ordinal {
2993 return Ok(());
2994 }
2995
2996 let cur_offset: usize = (3 - 1) * envelope_size;
2999
3000 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3002
3003 fidl::encoding::encode_in_envelope_optional::<AllowlistedCapability, D>(
3008 self.capability
3009 .as_ref()
3010 .map(<AllowlistedCapability as fidl::encoding::ValueTypeMarker>::borrow),
3011 encoder,
3012 offset + cur_offset,
3013 depth,
3014 )?;
3015
3016 _prev_end_offset = cur_offset + envelope_size;
3017 if 4 > max_ordinal {
3018 return Ok(());
3019 }
3020
3021 let cur_offset: usize = (4 - 1) * envelope_size;
3024
3025 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3027
3028 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
3033 self.target_monikers.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3034 encoder, offset + cur_offset, depth
3035 )?;
3036
3037 _prev_end_offset = cur_offset + envelope_size;
3038 if 5 > max_ordinal {
3039 return Ok(());
3040 }
3041
3042 let cur_offset: usize = (5 - 1) * envelope_size;
3045
3046 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3048
3049 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Ref, D>(
3054 self.source.as_ref().map(<fidl_fuchsia_component_decl__common::Ref as fidl::encoding::ValueTypeMarker>::borrow),
3055 encoder, offset + cur_offset, depth
3056 )?;
3057
3058 _prev_end_offset = cur_offset + envelope_size;
3059
3060 Ok(())
3061 }
3062 }
3063
3064 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3065 for CapabilityAllowlistEntry
3066 {
3067 #[inline(always)]
3068 fn new_empty() -> Self {
3069 Self::default()
3070 }
3071
3072 unsafe fn decode(
3073 &mut self,
3074 decoder: &mut fidl::encoding::Decoder<'_, D>,
3075 offset: usize,
3076 mut depth: fidl::encoding::Depth,
3077 ) -> fidl::Result<()> {
3078 decoder.debug_check_bounds::<Self>(offset);
3079 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3080 None => return Err(fidl::Error::NotNullable),
3081 Some(len) => len,
3082 };
3083 if len == 0 {
3085 return Ok(());
3086 };
3087 depth.increment()?;
3088 let envelope_size = 8;
3089 let bytes_len = len * envelope_size;
3090 let offset = decoder.out_of_line_offset(bytes_len)?;
3091 let mut _next_ordinal_to_read = 0;
3093 let mut next_offset = offset;
3094 let end_offset = offset + bytes_len;
3095 _next_ordinal_to_read += 1;
3096 if next_offset >= end_offset {
3097 return Ok(());
3098 }
3099
3100 while _next_ordinal_to_read < 1 {
3102 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3103 _next_ordinal_to_read += 1;
3104 next_offset += envelope_size;
3105 }
3106
3107 let next_out_of_line = decoder.next_out_of_line();
3108 let handles_before = decoder.remaining_handles();
3109 if let Some((inlined, num_bytes, num_handles)) =
3110 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3111 {
3112 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3113 if inlined != (member_inline_size <= 4) {
3114 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3115 }
3116 let inner_offset;
3117 let mut inner_depth = depth.clone();
3118 if inlined {
3119 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3120 inner_offset = next_offset;
3121 } else {
3122 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3123 inner_depth.increment()?;
3124 }
3125 let val_ref = self.source_moniker.get_or_insert_with(|| {
3126 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
3127 });
3128 fidl::decode!(
3129 fidl::encoding::BoundedString<4096>,
3130 D,
3131 val_ref,
3132 decoder,
3133 inner_offset,
3134 inner_depth
3135 )?;
3136 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3137 {
3138 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3139 }
3140 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3141 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3142 }
3143 }
3144
3145 next_offset += envelope_size;
3146 _next_ordinal_to_read += 1;
3147 if next_offset >= end_offset {
3148 return Ok(());
3149 }
3150
3151 while _next_ordinal_to_read < 2 {
3153 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3154 _next_ordinal_to_read += 1;
3155 next_offset += envelope_size;
3156 }
3157
3158 let next_out_of_line = decoder.next_out_of_line();
3159 let handles_before = decoder.remaining_handles();
3160 if let Some((inlined, num_bytes, num_handles)) =
3161 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3162 {
3163 let member_inline_size =
3164 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3165 decoder.context,
3166 );
3167 if inlined != (member_inline_size <= 4) {
3168 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3169 }
3170 let inner_offset;
3171 let mut inner_depth = depth.clone();
3172 if inlined {
3173 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3174 inner_offset = next_offset;
3175 } else {
3176 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3177 inner_depth.increment()?;
3178 }
3179 let val_ref = self
3180 .source_name
3181 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3182 fidl::decode!(
3183 fidl::encoding::BoundedString<255>,
3184 D,
3185 val_ref,
3186 decoder,
3187 inner_offset,
3188 inner_depth
3189 )?;
3190 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3191 {
3192 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3193 }
3194 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3195 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3196 }
3197 }
3198
3199 next_offset += envelope_size;
3200 _next_ordinal_to_read += 1;
3201 if next_offset >= end_offset {
3202 return Ok(());
3203 }
3204
3205 while _next_ordinal_to_read < 3 {
3207 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3208 _next_ordinal_to_read += 1;
3209 next_offset += envelope_size;
3210 }
3211
3212 let next_out_of_line = decoder.next_out_of_line();
3213 let handles_before = decoder.remaining_handles();
3214 if let Some((inlined, num_bytes, num_handles)) =
3215 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3216 {
3217 let member_inline_size =
3218 <AllowlistedCapability as fidl::encoding::TypeMarker>::inline_size(
3219 decoder.context,
3220 );
3221 if inlined != (member_inline_size <= 4) {
3222 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3223 }
3224 let inner_offset;
3225 let mut inner_depth = depth.clone();
3226 if inlined {
3227 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3228 inner_offset = next_offset;
3229 } else {
3230 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3231 inner_depth.increment()?;
3232 }
3233 let val_ref = self
3234 .capability
3235 .get_or_insert_with(|| fidl::new_empty!(AllowlistedCapability, D));
3236 fidl::decode!(
3237 AllowlistedCapability,
3238 D,
3239 val_ref,
3240 decoder,
3241 inner_offset,
3242 inner_depth
3243 )?;
3244 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3245 {
3246 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3247 }
3248 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3249 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3250 }
3251 }
3252
3253 next_offset += envelope_size;
3254 _next_ordinal_to_read += 1;
3255 if next_offset >= end_offset {
3256 return Ok(());
3257 }
3258
3259 while _next_ordinal_to_read < 4 {
3261 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3262 _next_ordinal_to_read += 1;
3263 next_offset += envelope_size;
3264 }
3265
3266 let next_out_of_line = decoder.next_out_of_line();
3267 let handles_before = decoder.remaining_handles();
3268 if let Some((inlined, num_bytes, num_handles)) =
3269 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3270 {
3271 let member_inline_size = <fidl::encoding::Vector<
3272 fidl::encoding::BoundedString<4096>,
3273 128,
3274 > as fidl::encoding::TypeMarker>::inline_size(
3275 decoder.context
3276 );
3277 if inlined != (member_inline_size <= 4) {
3278 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3279 }
3280 let inner_offset;
3281 let mut inner_depth = depth.clone();
3282 if inlined {
3283 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3284 inner_offset = next_offset;
3285 } else {
3286 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3287 inner_depth.increment()?;
3288 }
3289 let val_ref = self.target_monikers.get_or_insert_with(|| {
3290 fidl::new_empty!(
3291 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3292 D
3293 )
3294 });
3295 fidl::decode!(
3296 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3297 D,
3298 val_ref,
3299 decoder,
3300 inner_offset,
3301 inner_depth
3302 )?;
3303 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3304 {
3305 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3306 }
3307 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3308 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3309 }
3310 }
3311
3312 next_offset += envelope_size;
3313 _next_ordinal_to_read += 1;
3314 if next_offset >= end_offset {
3315 return Ok(());
3316 }
3317
3318 while _next_ordinal_to_read < 5 {
3320 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3321 _next_ordinal_to_read += 1;
3322 next_offset += envelope_size;
3323 }
3324
3325 let next_out_of_line = decoder.next_out_of_line();
3326 let handles_before = decoder.remaining_handles();
3327 if let Some((inlined, num_bytes, num_handles)) =
3328 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3329 {
3330 let member_inline_size = <fidl_fuchsia_component_decl__common::Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3331 if inlined != (member_inline_size <= 4) {
3332 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3333 }
3334 let inner_offset;
3335 let mut inner_depth = depth.clone();
3336 if inlined {
3337 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3338 inner_offset = next_offset;
3339 } else {
3340 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3341 inner_depth.increment()?;
3342 }
3343 let val_ref = self.source.get_or_insert_with(|| {
3344 fidl::new_empty!(fidl_fuchsia_component_decl__common::Ref, D)
3345 });
3346 fidl::decode!(
3347 fidl_fuchsia_component_decl__common::Ref,
3348 D,
3349 val_ref,
3350 decoder,
3351 inner_offset,
3352 inner_depth
3353 )?;
3354 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3355 {
3356 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3357 }
3358 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3359 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3360 }
3361 }
3362
3363 next_offset += envelope_size;
3364
3365 while next_offset < end_offset {
3367 _next_ordinal_to_read += 1;
3368 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3369 next_offset += envelope_size;
3370 }
3371
3372 Ok(())
3373 }
3374 }
3375
3376 impl CapabilityPolicyAllowlists {
3377 #[inline(always)]
3378 fn max_ordinal_present(&self) -> u64 {
3379 if let Some(_) = self.allowlist {
3380 return 1;
3381 }
3382 0
3383 }
3384 }
3385
3386 impl fidl::encoding::ValueTypeMarker for CapabilityPolicyAllowlists {
3387 type Borrowed<'a> = &'a Self;
3388 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3389 value
3390 }
3391 }
3392
3393 unsafe impl fidl::encoding::TypeMarker for CapabilityPolicyAllowlists {
3394 type Owned = Self;
3395
3396 #[inline(always)]
3397 fn inline_align(_context: fidl::encoding::Context) -> usize {
3398 8
3399 }
3400
3401 #[inline(always)]
3402 fn inline_size(_context: fidl::encoding::Context) -> usize {
3403 16
3404 }
3405 }
3406
3407 unsafe impl<D: fidl::encoding::ResourceDialect>
3408 fidl::encoding::Encode<CapabilityPolicyAllowlists, D> for &CapabilityPolicyAllowlists
3409 {
3410 unsafe fn encode(
3411 self,
3412 encoder: &mut fidl::encoding::Encoder<'_, D>,
3413 offset: usize,
3414 mut depth: fidl::encoding::Depth,
3415 ) -> fidl::Result<()> {
3416 encoder.debug_check_bounds::<CapabilityPolicyAllowlists>(offset);
3417 let max_ordinal: u64 = self.max_ordinal_present();
3419 encoder.write_num(max_ordinal, offset);
3420 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3421 if max_ordinal == 0 {
3423 return Ok(());
3424 }
3425 depth.increment()?;
3426 let envelope_size = 8;
3427 let bytes_len = max_ordinal as usize * envelope_size;
3428 #[allow(unused_variables)]
3429 let offset = encoder.out_of_line_offset(bytes_len);
3430 let mut _prev_end_offset: usize = 0;
3431 if 1 > max_ordinal {
3432 return Ok(());
3433 }
3434
3435 let cur_offset: usize = (1 - 1) * envelope_size;
3438
3439 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3441
3442 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D>(
3447 self.allowlist.as_ref().map(<fidl::encoding::Vector<CapabilityAllowlistEntry, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3448 encoder, offset + cur_offset, depth
3449 )?;
3450
3451 _prev_end_offset = cur_offset + envelope_size;
3452
3453 Ok(())
3454 }
3455 }
3456
3457 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3458 for CapabilityPolicyAllowlists
3459 {
3460 #[inline(always)]
3461 fn new_empty() -> Self {
3462 Self::default()
3463 }
3464
3465 unsafe fn decode(
3466 &mut self,
3467 decoder: &mut fidl::encoding::Decoder<'_, D>,
3468 offset: usize,
3469 mut depth: fidl::encoding::Depth,
3470 ) -> fidl::Result<()> {
3471 decoder.debug_check_bounds::<Self>(offset);
3472 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3473 None => return Err(fidl::Error::NotNullable),
3474 Some(len) => len,
3475 };
3476 if len == 0 {
3478 return Ok(());
3479 };
3480 depth.increment()?;
3481 let envelope_size = 8;
3482 let bytes_len = len * envelope_size;
3483 let offset = decoder.out_of_line_offset(bytes_len)?;
3484 let mut _next_ordinal_to_read = 0;
3486 let mut next_offset = offset;
3487 let end_offset = offset + bytes_len;
3488 _next_ordinal_to_read += 1;
3489 if next_offset >= end_offset {
3490 return Ok(());
3491 }
3492
3493 while _next_ordinal_to_read < 1 {
3495 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3496 _next_ordinal_to_read += 1;
3497 next_offset += envelope_size;
3498 }
3499
3500 let next_out_of_line = decoder.next_out_of_line();
3501 let handles_before = decoder.remaining_handles();
3502 if let Some((inlined, num_bytes, num_handles)) =
3503 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3504 {
3505 let member_inline_size = <fidl::encoding::Vector<CapabilityAllowlistEntry, 128> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3506 if inlined != (member_inline_size <= 4) {
3507 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3508 }
3509 let inner_offset;
3510 let mut inner_depth = depth.clone();
3511 if inlined {
3512 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3513 inner_offset = next_offset;
3514 } else {
3515 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3516 inner_depth.increment()?;
3517 }
3518 let val_ref = self.allowlist.get_or_insert_with(
3519 || fidl::new_empty!(fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D),
3520 );
3521 fidl::decode!(fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
3522 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3523 {
3524 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3525 }
3526 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3527 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3528 }
3529 }
3530
3531 next_offset += envelope_size;
3532
3533 while next_offset < end_offset {
3535 _next_ordinal_to_read += 1;
3536 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3537 next_offset += envelope_size;
3538 }
3539
3540 Ok(())
3541 }
3542 }
3543
3544 impl ChildPolicyAllowlists {
3545 #[inline(always)]
3546 fn max_ordinal_present(&self) -> u64 {
3547 if let Some(_) = self.reboot_on_terminate {
3548 return 1;
3549 }
3550 0
3551 }
3552 }
3553
3554 impl fidl::encoding::ValueTypeMarker for ChildPolicyAllowlists {
3555 type Borrowed<'a> = &'a Self;
3556 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3557 value
3558 }
3559 }
3560
3561 unsafe impl fidl::encoding::TypeMarker for ChildPolicyAllowlists {
3562 type Owned = Self;
3563
3564 #[inline(always)]
3565 fn inline_align(_context: fidl::encoding::Context) -> usize {
3566 8
3567 }
3568
3569 #[inline(always)]
3570 fn inline_size(_context: fidl::encoding::Context) -> usize {
3571 16
3572 }
3573 }
3574
3575 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChildPolicyAllowlists, D>
3576 for &ChildPolicyAllowlists
3577 {
3578 unsafe fn encode(
3579 self,
3580 encoder: &mut fidl::encoding::Encoder<'_, D>,
3581 offset: usize,
3582 mut depth: fidl::encoding::Depth,
3583 ) -> fidl::Result<()> {
3584 encoder.debug_check_bounds::<ChildPolicyAllowlists>(offset);
3585 let max_ordinal: u64 = self.max_ordinal_present();
3587 encoder.write_num(max_ordinal, offset);
3588 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3589 if max_ordinal == 0 {
3591 return Ok(());
3592 }
3593 depth.increment()?;
3594 let envelope_size = 8;
3595 let bytes_len = max_ordinal as usize * envelope_size;
3596 #[allow(unused_variables)]
3597 let offset = encoder.out_of_line_offset(bytes_len);
3598 let mut _prev_end_offset: usize = 0;
3599 if 1 > max_ordinal {
3600 return Ok(());
3601 }
3602
3603 let cur_offset: usize = (1 - 1) * envelope_size;
3606
3607 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3609
3610 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
3615 self.reboot_on_terminate.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3616 encoder, offset + cur_offset, depth
3617 )?;
3618
3619 _prev_end_offset = cur_offset + envelope_size;
3620
3621 Ok(())
3622 }
3623 }
3624
3625 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildPolicyAllowlists {
3626 #[inline(always)]
3627 fn new_empty() -> Self {
3628 Self::default()
3629 }
3630
3631 unsafe fn decode(
3632 &mut self,
3633 decoder: &mut fidl::encoding::Decoder<'_, D>,
3634 offset: usize,
3635 mut depth: fidl::encoding::Depth,
3636 ) -> fidl::Result<()> {
3637 decoder.debug_check_bounds::<Self>(offset);
3638 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3639 None => return Err(fidl::Error::NotNullable),
3640 Some(len) => len,
3641 };
3642 if len == 0 {
3644 return Ok(());
3645 };
3646 depth.increment()?;
3647 let envelope_size = 8;
3648 let bytes_len = len * envelope_size;
3649 let offset = decoder.out_of_line_offset(bytes_len)?;
3650 let mut _next_ordinal_to_read = 0;
3652 let mut next_offset = offset;
3653 let end_offset = offset + bytes_len;
3654 _next_ordinal_to_read += 1;
3655 if next_offset >= end_offset {
3656 return Ok(());
3657 }
3658
3659 while _next_ordinal_to_read < 1 {
3661 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3662 _next_ordinal_to_read += 1;
3663 next_offset += envelope_size;
3664 }
3665
3666 let next_out_of_line = decoder.next_out_of_line();
3667 let handles_before = decoder.remaining_handles();
3668 if let Some((inlined, num_bytes, num_handles)) =
3669 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3670 {
3671 let member_inline_size = <fidl::encoding::Vector<
3672 fidl::encoding::BoundedString<4096>,
3673 128,
3674 > as fidl::encoding::TypeMarker>::inline_size(
3675 decoder.context
3676 );
3677 if inlined != (member_inline_size <= 4) {
3678 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3679 }
3680 let inner_offset;
3681 let mut inner_depth = depth.clone();
3682 if inlined {
3683 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3684 inner_offset = next_offset;
3685 } else {
3686 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3687 inner_depth.increment()?;
3688 }
3689 let val_ref = self.reboot_on_terminate.get_or_insert_with(|| {
3690 fidl::new_empty!(
3691 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3692 D
3693 )
3694 });
3695 fidl::decode!(
3696 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3697 D,
3698 val_ref,
3699 decoder,
3700 inner_offset,
3701 inner_depth
3702 )?;
3703 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3704 {
3705 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3706 }
3707 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3708 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3709 }
3710 }
3711
3712 next_offset += envelope_size;
3713
3714 while next_offset < end_offset {
3716 _next_ordinal_to_read += 1;
3717 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3718 next_offset += envelope_size;
3719 }
3720
3721 Ok(())
3722 }
3723 }
3724
3725 impl Component {
3726 #[inline(always)]
3727 fn max_ordinal_present(&self) -> u64 {
3728 if let Some(_) = self.moniker {
3729 return 2;
3730 }
3731 if let Some(_) = self.capability {
3732 return 1;
3733 }
3734 0
3735 }
3736 }
3737
3738 impl fidl::encoding::ValueTypeMarker for Component {
3739 type Borrowed<'a> = &'a Self;
3740 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3741 value
3742 }
3743 }
3744
3745 unsafe impl fidl::encoding::TypeMarker for Component {
3746 type Owned = Self;
3747
3748 #[inline(always)]
3749 fn inline_align(_context: fidl::encoding::Context) -> usize {
3750 8
3751 }
3752
3753 #[inline(always)]
3754 fn inline_size(_context: fidl::encoding::Context) -> usize {
3755 16
3756 }
3757 }
3758
3759 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Component, D>
3760 for &Component
3761 {
3762 unsafe fn encode(
3763 self,
3764 encoder: &mut fidl::encoding::Encoder<'_, D>,
3765 offset: usize,
3766 mut depth: fidl::encoding::Depth,
3767 ) -> fidl::Result<()> {
3768 encoder.debug_check_bounds::<Component>(offset);
3769 let max_ordinal: u64 = self.max_ordinal_present();
3771 encoder.write_num(max_ordinal, offset);
3772 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3773 if max_ordinal == 0 {
3775 return Ok(());
3776 }
3777 depth.increment()?;
3778 let envelope_size = 8;
3779 let bytes_len = max_ordinal as usize * envelope_size;
3780 #[allow(unused_variables)]
3781 let offset = encoder.out_of_line_offset(bytes_len);
3782 let mut _prev_end_offset: usize = 0;
3783 if 1 > max_ordinal {
3784 return Ok(());
3785 }
3786
3787 let cur_offset: usize = (1 - 1) * envelope_size;
3790
3791 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3793
3794 fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
3799 self.capability
3800 .as_ref()
3801 .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
3802 encoder,
3803 offset + cur_offset,
3804 depth,
3805 )?;
3806
3807 _prev_end_offset = cur_offset + envelope_size;
3808 if 2 > max_ordinal {
3809 return Ok(());
3810 }
3811
3812 let cur_offset: usize = (2 - 1) * envelope_size;
3815
3816 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3818
3819 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
3824 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
3825 encoder, offset + cur_offset, depth
3826 )?;
3827
3828 _prev_end_offset = cur_offset + envelope_size;
3829
3830 Ok(())
3831 }
3832 }
3833
3834 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Component {
3835 #[inline(always)]
3836 fn new_empty() -> Self {
3837 Self::default()
3838 }
3839
3840 unsafe fn decode(
3841 &mut self,
3842 decoder: &mut fidl::encoding::Decoder<'_, D>,
3843 offset: usize,
3844 mut depth: fidl::encoding::Depth,
3845 ) -> fidl::Result<()> {
3846 decoder.debug_check_bounds::<Self>(offset);
3847 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3848 None => return Err(fidl::Error::NotNullable),
3849 Some(len) => len,
3850 };
3851 if len == 0 {
3853 return Ok(());
3854 };
3855 depth.increment()?;
3856 let envelope_size = 8;
3857 let bytes_len = len * envelope_size;
3858 let offset = decoder.out_of_line_offset(bytes_len)?;
3859 let mut _next_ordinal_to_read = 0;
3861 let mut next_offset = offset;
3862 let end_offset = offset + bytes_len;
3863 _next_ordinal_to_read += 1;
3864 if next_offset >= end_offset {
3865 return Ok(());
3866 }
3867
3868 while _next_ordinal_to_read < 1 {
3870 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3871 _next_ordinal_to_read += 1;
3872 next_offset += envelope_size;
3873 }
3874
3875 let next_out_of_line = decoder.next_out_of_line();
3876 let handles_before = decoder.remaining_handles();
3877 if let Some((inlined, num_bytes, num_handles)) =
3878 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3879 {
3880 let member_inline_size =
3881 <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
3882 decoder.context,
3883 );
3884 if inlined != (member_inline_size <= 4) {
3885 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3886 }
3887 let inner_offset;
3888 let mut inner_depth = depth.clone();
3889 if inlined {
3890 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3891 inner_offset = next_offset;
3892 } else {
3893 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3894 inner_depth.increment()?;
3895 }
3896 let val_ref =
3897 self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
3898 fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
3899 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3900 {
3901 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3902 }
3903 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3904 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3905 }
3906 }
3907
3908 next_offset += envelope_size;
3909 _next_ordinal_to_read += 1;
3910 if next_offset >= end_offset {
3911 return Ok(());
3912 }
3913
3914 while _next_ordinal_to_read < 2 {
3916 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3917 _next_ordinal_to_read += 1;
3918 next_offset += envelope_size;
3919 }
3920
3921 let next_out_of_line = decoder.next_out_of_line();
3922 let handles_before = decoder.remaining_handles();
3923 if let Some((inlined, num_bytes, num_handles)) =
3924 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3925 {
3926 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3927 if inlined != (member_inline_size <= 4) {
3928 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3929 }
3930 let inner_offset;
3931 let mut inner_depth = depth.clone();
3932 if inlined {
3933 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3934 inner_offset = next_offset;
3935 } else {
3936 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3937 inner_depth.increment()?;
3938 }
3939 let val_ref = self.moniker.get_or_insert_with(|| {
3940 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
3941 });
3942 fidl::decode!(
3943 fidl::encoding::BoundedString<4096>,
3944 D,
3945 val_ref,
3946 decoder,
3947 inner_offset,
3948 inner_depth
3949 )?;
3950 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3951 {
3952 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3953 }
3954 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3955 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3956 }
3957 }
3958
3959 next_offset += envelope_size;
3960
3961 while next_offset < end_offset {
3963 _next_ordinal_to_read += 1;
3964 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3965 next_offset += envelope_size;
3966 }
3967
3968 Ok(())
3969 }
3970 }
3971
3972 impl ComponentIdIndex {
3973 #[inline(always)]
3974 fn max_ordinal_present(&self) -> u64 {
3975 if let Some(_) = self.instances {
3976 return 2;
3977 }
3978 0
3979 }
3980 }
3981
3982 impl fidl::encoding::ValueTypeMarker for ComponentIdIndex {
3983 type Borrowed<'a> = &'a Self;
3984 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3985 value
3986 }
3987 }
3988
3989 unsafe impl fidl::encoding::TypeMarker for ComponentIdIndex {
3990 type Owned = Self;
3991
3992 #[inline(always)]
3993 fn inline_align(_context: fidl::encoding::Context) -> usize {
3994 8
3995 }
3996
3997 #[inline(always)]
3998 fn inline_size(_context: fidl::encoding::Context) -> usize {
3999 16
4000 }
4001 }
4002
4003 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentIdIndex, D>
4004 for &ComponentIdIndex
4005 {
4006 unsafe fn encode(
4007 self,
4008 encoder: &mut fidl::encoding::Encoder<'_, D>,
4009 offset: usize,
4010 mut depth: fidl::encoding::Depth,
4011 ) -> fidl::Result<()> {
4012 encoder.debug_check_bounds::<ComponentIdIndex>(offset);
4013 let max_ordinal: u64 = self.max_ordinal_present();
4015 encoder.write_num(max_ordinal, offset);
4016 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4017 if max_ordinal == 0 {
4019 return Ok(());
4020 }
4021 depth.increment()?;
4022 let envelope_size = 8;
4023 let bytes_len = max_ordinal as usize * envelope_size;
4024 #[allow(unused_variables)]
4025 let offset = encoder.out_of_line_offset(bytes_len);
4026 let mut _prev_end_offset: usize = 0;
4027 if 2 > max_ordinal {
4028 return Ok(());
4029 }
4030
4031 let cur_offset: usize = (2 - 1) * envelope_size;
4034
4035 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4037
4038 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<InstanceIdEntry, 1024>, D>(
4043 self.instances.as_ref().map(<fidl::encoding::Vector<InstanceIdEntry, 1024> as fidl::encoding::ValueTypeMarker>::borrow),
4044 encoder, offset + cur_offset, depth
4045 )?;
4046
4047 _prev_end_offset = cur_offset + envelope_size;
4048
4049 Ok(())
4050 }
4051 }
4052
4053 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentIdIndex {
4054 #[inline(always)]
4055 fn new_empty() -> Self {
4056 Self::default()
4057 }
4058
4059 unsafe fn decode(
4060 &mut self,
4061 decoder: &mut fidl::encoding::Decoder<'_, D>,
4062 offset: usize,
4063 mut depth: fidl::encoding::Depth,
4064 ) -> fidl::Result<()> {
4065 decoder.debug_check_bounds::<Self>(offset);
4066 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4067 None => return Err(fidl::Error::NotNullable),
4068 Some(len) => len,
4069 };
4070 if len == 0 {
4072 return Ok(());
4073 };
4074 depth.increment()?;
4075 let envelope_size = 8;
4076 let bytes_len = len * envelope_size;
4077 let offset = decoder.out_of_line_offset(bytes_len)?;
4078 let mut _next_ordinal_to_read = 0;
4080 let mut next_offset = offset;
4081 let end_offset = offset + bytes_len;
4082 _next_ordinal_to_read += 1;
4083 if next_offset >= end_offset {
4084 return Ok(());
4085 }
4086
4087 while _next_ordinal_to_read < 2 {
4089 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4090 _next_ordinal_to_read += 1;
4091 next_offset += envelope_size;
4092 }
4093
4094 let next_out_of_line = decoder.next_out_of_line();
4095 let handles_before = decoder.remaining_handles();
4096 if let Some((inlined, num_bytes, num_handles)) =
4097 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4098 {
4099 let member_inline_size = <fidl::encoding::Vector<InstanceIdEntry, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4100 if inlined != (member_inline_size <= 4) {
4101 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4102 }
4103 let inner_offset;
4104 let mut inner_depth = depth.clone();
4105 if inlined {
4106 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4107 inner_offset = next_offset;
4108 } else {
4109 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4110 inner_depth.increment()?;
4111 }
4112 let val_ref = self.instances.get_or_insert_with(
4113 || fidl::new_empty!(fidl::encoding::Vector<InstanceIdEntry, 1024>, D),
4114 );
4115 fidl::decode!(fidl::encoding::Vector<InstanceIdEntry, 1024>, D, val_ref, decoder, inner_offset, inner_depth)?;
4116 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4117 {
4118 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4119 }
4120 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4121 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4122 }
4123 }
4124
4125 next_offset += envelope_size;
4126
4127 while next_offset < end_offset {
4129 _next_ordinal_to_read += 1;
4130 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4131 next_offset += envelope_size;
4132 }
4133
4134 Ok(())
4135 }
4136 }
4137
4138 impl Config {
4139 #[inline(always)]
4140 fn max_ordinal_present(&self) -> u64 {
4141 if let Some(_) = self.trace_provider {
4142 return 22;
4143 }
4144 if let Some(_) = self.health_check {
4145 return 21;
4146 }
4147 if let Some(_) = self.vmex_source {
4148 return 20;
4149 }
4150 if let Some(_) = self.abi_revision_policy {
4151 return 19;
4152 }
4153 if let Some(_) = self.enable_introspection {
4154 return 18;
4155 }
4156 if let Some(_) = self.builtin_capabilities {
4157 return 17;
4158 }
4159 if let Some(_) = self.realm_builder_resolver_and_runner {
4160 return 16;
4161 }
4162 if let Some(_) = self.builtin_boot_resolver {
4163 return 14;
4164 }
4165 if let Some(_) = self.log_all_events {
4166 return 13;
4167 }
4168 if let Some(_) = self.log_destination {
4169 return 12;
4170 }
4171 if let Some(_) = self.component_id_index_path {
4172 return 11;
4173 }
4174 if let Some(_) = self.root_component_url {
4175 return 10;
4176 }
4177 if let Some(_) = self.num_threads {
4178 return 7;
4179 }
4180 if let Some(_) = self.maintain_utc_clock {
4181 return 6;
4182 }
4183 if let Some(_) = self.use_builtin_process_launcher {
4184 return 5;
4185 }
4186 if let Some(_) = self.namespace_capabilities {
4187 return 4;
4188 }
4189 if let Some(_) = self.security_policy {
4190 return 3;
4191 }
4192 if let Some(_) = self.list_children_batch_size {
4193 return 2;
4194 }
4195 if let Some(_) = self.debug {
4196 return 1;
4197 }
4198 0
4199 }
4200 }
4201
4202 impl fidl::encoding::ValueTypeMarker for Config {
4203 type Borrowed<'a> = &'a Self;
4204 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4205 value
4206 }
4207 }
4208
4209 unsafe impl fidl::encoding::TypeMarker for Config {
4210 type Owned = Self;
4211
4212 #[inline(always)]
4213 fn inline_align(_context: fidl::encoding::Context) -> usize {
4214 8
4215 }
4216
4217 #[inline(always)]
4218 fn inline_size(_context: fidl::encoding::Context) -> usize {
4219 16
4220 }
4221 }
4222
4223 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Config, D> for &Config {
4224 unsafe fn encode(
4225 self,
4226 encoder: &mut fidl::encoding::Encoder<'_, D>,
4227 offset: usize,
4228 mut depth: fidl::encoding::Depth,
4229 ) -> fidl::Result<()> {
4230 encoder.debug_check_bounds::<Config>(offset);
4231 let max_ordinal: u64 = self.max_ordinal_present();
4233 encoder.write_num(max_ordinal, offset);
4234 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4235 if max_ordinal == 0 {
4237 return Ok(());
4238 }
4239 depth.increment()?;
4240 let envelope_size = 8;
4241 let bytes_len = max_ordinal as usize * envelope_size;
4242 #[allow(unused_variables)]
4243 let offset = encoder.out_of_line_offset(bytes_len);
4244 let mut _prev_end_offset: usize = 0;
4245 if 1 > max_ordinal {
4246 return Ok(());
4247 }
4248
4249 let cur_offset: usize = (1 - 1) * envelope_size;
4252
4253 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4255
4256 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4261 self.debug.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4262 encoder,
4263 offset + cur_offset,
4264 depth,
4265 )?;
4266
4267 _prev_end_offset = cur_offset + envelope_size;
4268 if 2 > max_ordinal {
4269 return Ok(());
4270 }
4271
4272 let cur_offset: usize = (2 - 1) * envelope_size;
4275
4276 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4278
4279 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4284 self.list_children_batch_size
4285 .as_ref()
4286 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4287 encoder,
4288 offset + cur_offset,
4289 depth,
4290 )?;
4291
4292 _prev_end_offset = cur_offset + envelope_size;
4293 if 3 > max_ordinal {
4294 return Ok(());
4295 }
4296
4297 let cur_offset: usize = (3 - 1) * envelope_size;
4300
4301 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4303
4304 fidl::encoding::encode_in_envelope_optional::<SecurityPolicy, D>(
4309 self.security_policy
4310 .as_ref()
4311 .map(<SecurityPolicy as fidl::encoding::ValueTypeMarker>::borrow),
4312 encoder,
4313 offset + cur_offset,
4314 depth,
4315 )?;
4316
4317 _prev_end_offset = cur_offset + envelope_size;
4318 if 4 > max_ordinal {
4319 return Ok(());
4320 }
4321
4322 let cur_offset: usize = (4 - 1) * envelope_size;
4325
4326 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4328
4329 fidl::encoding::encode_in_envelope_optional::<
4334 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Capability>,
4335 D,
4336 >(
4337 self.namespace_capabilities.as_ref().map(
4338 <fidl::encoding::UnboundedVector<
4339 fidl_fuchsia_component_decl__common::Capability,
4340 > as fidl::encoding::ValueTypeMarker>::borrow,
4341 ),
4342 encoder,
4343 offset + cur_offset,
4344 depth,
4345 )?;
4346
4347 _prev_end_offset = cur_offset + envelope_size;
4348 if 5 > max_ordinal {
4349 return Ok(());
4350 }
4351
4352 let cur_offset: usize = (5 - 1) * envelope_size;
4355
4356 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4358
4359 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4364 self.use_builtin_process_launcher
4365 .as_ref()
4366 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4367 encoder,
4368 offset + cur_offset,
4369 depth,
4370 )?;
4371
4372 _prev_end_offset = cur_offset + envelope_size;
4373 if 6 > max_ordinal {
4374 return Ok(());
4375 }
4376
4377 let cur_offset: usize = (6 - 1) * envelope_size;
4380
4381 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4383
4384 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4389 self.maintain_utc_clock
4390 .as_ref()
4391 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4392 encoder,
4393 offset + cur_offset,
4394 depth,
4395 )?;
4396
4397 _prev_end_offset = cur_offset + envelope_size;
4398 if 7 > max_ordinal {
4399 return Ok(());
4400 }
4401
4402 let cur_offset: usize = (7 - 1) * envelope_size;
4405
4406 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4408
4409 fidl::encoding::encode_in_envelope_optional::<u8, D>(
4414 self.num_threads.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4415 encoder,
4416 offset + cur_offset,
4417 depth,
4418 )?;
4419
4420 _prev_end_offset = cur_offset + envelope_size;
4421 if 10 > max_ordinal {
4422 return Ok(());
4423 }
4424
4425 let cur_offset: usize = (10 - 1) * envelope_size;
4428
4429 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4431
4432 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
4437 self.root_component_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
4438 encoder, offset + cur_offset, depth
4439 )?;
4440
4441 _prev_end_offset = cur_offset + envelope_size;
4442 if 11 > max_ordinal {
4443 return Ok(());
4444 }
4445
4446 let cur_offset: usize = (11 - 1) * envelope_size;
4449
4450 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4452
4453 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
4458 self.component_id_index_path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
4459 encoder, offset + cur_offset, depth
4460 )?;
4461
4462 _prev_end_offset = cur_offset + envelope_size;
4463 if 12 > max_ordinal {
4464 return Ok(());
4465 }
4466
4467 let cur_offset: usize = (12 - 1) * envelope_size;
4470
4471 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4473
4474 fidl::encoding::encode_in_envelope_optional::<LogDestination, D>(
4479 self.log_destination
4480 .as_ref()
4481 .map(<LogDestination as fidl::encoding::ValueTypeMarker>::borrow),
4482 encoder,
4483 offset + cur_offset,
4484 depth,
4485 )?;
4486
4487 _prev_end_offset = cur_offset + envelope_size;
4488 if 13 > max_ordinal {
4489 return Ok(());
4490 }
4491
4492 let cur_offset: usize = (13 - 1) * envelope_size;
4495
4496 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4498
4499 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4504 self.log_all_events.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4505 encoder,
4506 offset + cur_offset,
4507 depth,
4508 )?;
4509
4510 _prev_end_offset = cur_offset + envelope_size;
4511 if 14 > max_ordinal {
4512 return Ok(());
4513 }
4514
4515 let cur_offset: usize = (14 - 1) * envelope_size;
4518
4519 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4521
4522 fidl::encoding::encode_in_envelope_optional::<BuiltinBootResolver, D>(
4527 self.builtin_boot_resolver
4528 .as_ref()
4529 .map(<BuiltinBootResolver as fidl::encoding::ValueTypeMarker>::borrow),
4530 encoder,
4531 offset + cur_offset,
4532 depth,
4533 )?;
4534
4535 _prev_end_offset = cur_offset + envelope_size;
4536 if 16 > max_ordinal {
4537 return Ok(());
4538 }
4539
4540 let cur_offset: usize = (16 - 1) * envelope_size;
4543
4544 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4546
4547 fidl::encoding::encode_in_envelope_optional::<RealmBuilderResolverAndRunner, D>(
4552 self.realm_builder_resolver_and_runner.as_ref().map(
4553 <RealmBuilderResolverAndRunner as fidl::encoding::ValueTypeMarker>::borrow,
4554 ),
4555 encoder,
4556 offset + cur_offset,
4557 depth,
4558 )?;
4559
4560 _prev_end_offset = cur_offset + envelope_size;
4561 if 17 > max_ordinal {
4562 return Ok(());
4563 }
4564
4565 let cur_offset: usize = (17 - 1) * envelope_size;
4568
4569 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4571
4572 fidl::encoding::encode_in_envelope_optional::<
4577 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Capability>,
4578 D,
4579 >(
4580 self.builtin_capabilities.as_ref().map(
4581 <fidl::encoding::UnboundedVector<
4582 fidl_fuchsia_component_decl__common::Capability,
4583 > as fidl::encoding::ValueTypeMarker>::borrow,
4584 ),
4585 encoder,
4586 offset + cur_offset,
4587 depth,
4588 )?;
4589
4590 _prev_end_offset = cur_offset + envelope_size;
4591 if 18 > max_ordinal {
4592 return Ok(());
4593 }
4594
4595 let cur_offset: usize = (18 - 1) * envelope_size;
4598
4599 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4601
4602 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4607 self.enable_introspection
4608 .as_ref()
4609 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4610 encoder,
4611 offset + cur_offset,
4612 depth,
4613 )?;
4614
4615 _prev_end_offset = cur_offset + envelope_size;
4616 if 19 > max_ordinal {
4617 return Ok(());
4618 }
4619
4620 let cur_offset: usize = (19 - 1) * envelope_size;
4623
4624 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4626
4627 fidl::encoding::encode_in_envelope_optional::<AbiRevisionPolicy, D>(
4632 self.abi_revision_policy
4633 .as_ref()
4634 .map(<AbiRevisionPolicy as fidl::encoding::ValueTypeMarker>::borrow),
4635 encoder,
4636 offset + cur_offset,
4637 depth,
4638 )?;
4639
4640 _prev_end_offset = cur_offset + envelope_size;
4641 if 20 > max_ordinal {
4642 return Ok(());
4643 }
4644
4645 let cur_offset: usize = (20 - 1) * envelope_size;
4648
4649 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4651
4652 fidl::encoding::encode_in_envelope_optional::<VmexSource, D>(
4657 self.vmex_source
4658 .as_ref()
4659 .map(<VmexSource as fidl::encoding::ValueTypeMarker>::borrow),
4660 encoder,
4661 offset + cur_offset,
4662 depth,
4663 )?;
4664
4665 _prev_end_offset = cur_offset + envelope_size;
4666 if 21 > max_ordinal {
4667 return Ok(());
4668 }
4669
4670 let cur_offset: usize = (21 - 1) * envelope_size;
4673
4674 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4676
4677 fidl::encoding::encode_in_envelope_optional::<HealthCheck, D>(
4682 self.health_check
4683 .as_ref()
4684 .map(<HealthCheck as fidl::encoding::ValueTypeMarker>::borrow),
4685 encoder,
4686 offset + cur_offset,
4687 depth,
4688 )?;
4689
4690 _prev_end_offset = cur_offset + envelope_size;
4691 if 22 > max_ordinal {
4692 return Ok(());
4693 }
4694
4695 let cur_offset: usize = (22 - 1) * envelope_size;
4698
4699 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4701
4702 fidl::encoding::encode_in_envelope_optional::<TraceProvider, D>(
4707 self.trace_provider
4708 .as_ref()
4709 .map(<TraceProvider as fidl::encoding::ValueTypeMarker>::borrow),
4710 encoder,
4711 offset + cur_offset,
4712 depth,
4713 )?;
4714
4715 _prev_end_offset = cur_offset + envelope_size;
4716
4717 Ok(())
4718 }
4719 }
4720
4721 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Config {
4722 #[inline(always)]
4723 fn new_empty() -> Self {
4724 Self::default()
4725 }
4726
4727 unsafe fn decode(
4728 &mut self,
4729 decoder: &mut fidl::encoding::Decoder<'_, D>,
4730 offset: usize,
4731 mut depth: fidl::encoding::Depth,
4732 ) -> fidl::Result<()> {
4733 decoder.debug_check_bounds::<Self>(offset);
4734 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4735 None => return Err(fidl::Error::NotNullable),
4736 Some(len) => len,
4737 };
4738 if len == 0 {
4740 return Ok(());
4741 };
4742 depth.increment()?;
4743 let envelope_size = 8;
4744 let bytes_len = len * envelope_size;
4745 let offset = decoder.out_of_line_offset(bytes_len)?;
4746 let mut _next_ordinal_to_read = 0;
4748 let mut next_offset = offset;
4749 let end_offset = offset + bytes_len;
4750 _next_ordinal_to_read += 1;
4751 if next_offset >= end_offset {
4752 return Ok(());
4753 }
4754
4755 while _next_ordinal_to_read < 1 {
4757 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4758 _next_ordinal_to_read += 1;
4759 next_offset += envelope_size;
4760 }
4761
4762 let next_out_of_line = decoder.next_out_of_line();
4763 let handles_before = decoder.remaining_handles();
4764 if let Some((inlined, num_bytes, num_handles)) =
4765 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4766 {
4767 let member_inline_size =
4768 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4769 if inlined != (member_inline_size <= 4) {
4770 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4771 }
4772 let inner_offset;
4773 let mut inner_depth = depth.clone();
4774 if inlined {
4775 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4776 inner_offset = next_offset;
4777 } else {
4778 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4779 inner_depth.increment()?;
4780 }
4781 let val_ref = self.debug.get_or_insert_with(|| fidl::new_empty!(bool, D));
4782 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4783 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4784 {
4785 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4786 }
4787 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4788 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4789 }
4790 }
4791
4792 next_offset += envelope_size;
4793 _next_ordinal_to_read += 1;
4794 if next_offset >= end_offset {
4795 return Ok(());
4796 }
4797
4798 while _next_ordinal_to_read < 2 {
4800 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4801 _next_ordinal_to_read += 1;
4802 next_offset += envelope_size;
4803 }
4804
4805 let next_out_of_line = decoder.next_out_of_line();
4806 let handles_before = decoder.remaining_handles();
4807 if let Some((inlined, num_bytes, num_handles)) =
4808 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4809 {
4810 let member_inline_size =
4811 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4812 if inlined != (member_inline_size <= 4) {
4813 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4814 }
4815 let inner_offset;
4816 let mut inner_depth = depth.clone();
4817 if inlined {
4818 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4819 inner_offset = next_offset;
4820 } else {
4821 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4822 inner_depth.increment()?;
4823 }
4824 let val_ref =
4825 self.list_children_batch_size.get_or_insert_with(|| fidl::new_empty!(u32, D));
4826 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4827 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4828 {
4829 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4830 }
4831 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4832 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4833 }
4834 }
4835
4836 next_offset += envelope_size;
4837 _next_ordinal_to_read += 1;
4838 if next_offset >= end_offset {
4839 return Ok(());
4840 }
4841
4842 while _next_ordinal_to_read < 3 {
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 =
4855 <SecurityPolicy as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4856 if inlined != (member_inline_size <= 4) {
4857 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4858 }
4859 let inner_offset;
4860 let mut inner_depth = depth.clone();
4861 if inlined {
4862 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4863 inner_offset = next_offset;
4864 } else {
4865 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4866 inner_depth.increment()?;
4867 }
4868 let val_ref =
4869 self.security_policy.get_or_insert_with(|| fidl::new_empty!(SecurityPolicy, D));
4870 fidl::decode!(SecurityPolicy, D, val_ref, decoder, inner_offset, inner_depth)?;
4871 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4872 {
4873 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4874 }
4875 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4876 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4877 }
4878 }
4879
4880 next_offset += envelope_size;
4881 _next_ordinal_to_read += 1;
4882 if next_offset >= end_offset {
4883 return Ok(());
4884 }
4885
4886 while _next_ordinal_to_read < 4 {
4888 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4889 _next_ordinal_to_read += 1;
4890 next_offset += envelope_size;
4891 }
4892
4893 let next_out_of_line = decoder.next_out_of_line();
4894 let handles_before = decoder.remaining_handles();
4895 if let Some((inlined, num_bytes, num_handles)) =
4896 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4897 {
4898 let member_inline_size = <fidl::encoding::UnboundedVector<
4899 fidl_fuchsia_component_decl__common::Capability,
4900 > as fidl::encoding::TypeMarker>::inline_size(
4901 decoder.context
4902 );
4903 if inlined != (member_inline_size <= 4) {
4904 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4905 }
4906 let inner_offset;
4907 let mut inner_depth = depth.clone();
4908 if inlined {
4909 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4910 inner_offset = next_offset;
4911 } else {
4912 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4913 inner_depth.increment()?;
4914 }
4915 let val_ref = self.namespace_capabilities.get_or_insert_with(|| {
4916 fidl::new_empty!(
4917 fidl::encoding::UnboundedVector<
4918 fidl_fuchsia_component_decl__common::Capability,
4919 >,
4920 D
4921 )
4922 });
4923 fidl::decode!(
4924 fidl::encoding::UnboundedVector<
4925 fidl_fuchsia_component_decl__common::Capability,
4926 >,
4927 D,
4928 val_ref,
4929 decoder,
4930 inner_offset,
4931 inner_depth
4932 )?;
4933 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4934 {
4935 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4936 }
4937 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4938 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4939 }
4940 }
4941
4942 next_offset += envelope_size;
4943 _next_ordinal_to_read += 1;
4944 if next_offset >= end_offset {
4945 return Ok(());
4946 }
4947
4948 while _next_ordinal_to_read < 5 {
4950 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4951 _next_ordinal_to_read += 1;
4952 next_offset += envelope_size;
4953 }
4954
4955 let next_out_of_line = decoder.next_out_of_line();
4956 let handles_before = decoder.remaining_handles();
4957 if let Some((inlined, num_bytes, num_handles)) =
4958 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4959 {
4960 let member_inline_size =
4961 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4962 if inlined != (member_inline_size <= 4) {
4963 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4964 }
4965 let inner_offset;
4966 let mut inner_depth = depth.clone();
4967 if inlined {
4968 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4969 inner_offset = next_offset;
4970 } else {
4971 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4972 inner_depth.increment()?;
4973 }
4974 let val_ref = self
4975 .use_builtin_process_launcher
4976 .get_or_insert_with(|| fidl::new_empty!(bool, D));
4977 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4978 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4979 {
4980 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4981 }
4982 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4983 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4984 }
4985 }
4986
4987 next_offset += envelope_size;
4988 _next_ordinal_to_read += 1;
4989 if next_offset >= end_offset {
4990 return Ok(());
4991 }
4992
4993 while _next_ordinal_to_read < 6 {
4995 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4996 _next_ordinal_to_read += 1;
4997 next_offset += envelope_size;
4998 }
4999
5000 let next_out_of_line = decoder.next_out_of_line();
5001 let handles_before = decoder.remaining_handles();
5002 if let Some((inlined, num_bytes, num_handles)) =
5003 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5004 {
5005 let member_inline_size =
5006 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5007 if inlined != (member_inline_size <= 4) {
5008 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5009 }
5010 let inner_offset;
5011 let mut inner_depth = depth.clone();
5012 if inlined {
5013 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5014 inner_offset = next_offset;
5015 } else {
5016 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5017 inner_depth.increment()?;
5018 }
5019 let val_ref =
5020 self.maintain_utc_clock.get_or_insert_with(|| fidl::new_empty!(bool, D));
5021 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5022 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5023 {
5024 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5025 }
5026 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5027 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5028 }
5029 }
5030
5031 next_offset += envelope_size;
5032 _next_ordinal_to_read += 1;
5033 if next_offset >= end_offset {
5034 return Ok(());
5035 }
5036
5037 while _next_ordinal_to_read < 7 {
5039 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5040 _next_ordinal_to_read += 1;
5041 next_offset += envelope_size;
5042 }
5043
5044 let next_out_of_line = decoder.next_out_of_line();
5045 let handles_before = decoder.remaining_handles();
5046 if let Some((inlined, num_bytes, num_handles)) =
5047 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5048 {
5049 let member_inline_size =
5050 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5051 if inlined != (member_inline_size <= 4) {
5052 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5053 }
5054 let inner_offset;
5055 let mut inner_depth = depth.clone();
5056 if inlined {
5057 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5058 inner_offset = next_offset;
5059 } else {
5060 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5061 inner_depth.increment()?;
5062 }
5063 let val_ref = self.num_threads.get_or_insert_with(|| fidl::new_empty!(u8, D));
5064 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
5065 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5066 {
5067 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5068 }
5069 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5070 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5071 }
5072 }
5073
5074 next_offset += envelope_size;
5075 _next_ordinal_to_read += 1;
5076 if next_offset >= end_offset {
5077 return Ok(());
5078 }
5079
5080 while _next_ordinal_to_read < 10 {
5082 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5083 _next_ordinal_to_read += 1;
5084 next_offset += envelope_size;
5085 }
5086
5087 let next_out_of_line = decoder.next_out_of_line();
5088 let handles_before = decoder.remaining_handles();
5089 if let Some((inlined, num_bytes, num_handles)) =
5090 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5091 {
5092 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5093 if inlined != (member_inline_size <= 4) {
5094 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5095 }
5096 let inner_offset;
5097 let mut inner_depth = depth.clone();
5098 if inlined {
5099 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5100 inner_offset = next_offset;
5101 } else {
5102 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5103 inner_depth.increment()?;
5104 }
5105 let val_ref = self.root_component_url.get_or_insert_with(|| {
5106 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
5107 });
5108 fidl::decode!(
5109 fidl::encoding::BoundedString<4096>,
5110 D,
5111 val_ref,
5112 decoder,
5113 inner_offset,
5114 inner_depth
5115 )?;
5116 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5117 {
5118 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5119 }
5120 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5121 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5122 }
5123 }
5124
5125 next_offset += envelope_size;
5126 _next_ordinal_to_read += 1;
5127 if next_offset >= end_offset {
5128 return Ok(());
5129 }
5130
5131 while _next_ordinal_to_read < 11 {
5133 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5134 _next_ordinal_to_read += 1;
5135 next_offset += envelope_size;
5136 }
5137
5138 let next_out_of_line = decoder.next_out_of_line();
5139 let handles_before = decoder.remaining_handles();
5140 if let Some((inlined, num_bytes, num_handles)) =
5141 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5142 {
5143 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5144 if inlined != (member_inline_size <= 4) {
5145 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5146 }
5147 let inner_offset;
5148 let mut inner_depth = depth.clone();
5149 if inlined {
5150 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5151 inner_offset = next_offset;
5152 } else {
5153 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5154 inner_depth.increment()?;
5155 }
5156 let val_ref = self.component_id_index_path.get_or_insert_with(|| {
5157 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
5158 });
5159 fidl::decode!(
5160 fidl::encoding::BoundedString<4095>,
5161 D,
5162 val_ref,
5163 decoder,
5164 inner_offset,
5165 inner_depth
5166 )?;
5167 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5168 {
5169 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5170 }
5171 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5172 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5173 }
5174 }
5175
5176 next_offset += envelope_size;
5177 _next_ordinal_to_read += 1;
5178 if next_offset >= end_offset {
5179 return Ok(());
5180 }
5181
5182 while _next_ordinal_to_read < 12 {
5184 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5185 _next_ordinal_to_read += 1;
5186 next_offset += envelope_size;
5187 }
5188
5189 let next_out_of_line = decoder.next_out_of_line();
5190 let handles_before = decoder.remaining_handles();
5191 if let Some((inlined, num_bytes, num_handles)) =
5192 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5193 {
5194 let member_inline_size =
5195 <LogDestination as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5196 if inlined != (member_inline_size <= 4) {
5197 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5198 }
5199 let inner_offset;
5200 let mut inner_depth = depth.clone();
5201 if inlined {
5202 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5203 inner_offset = next_offset;
5204 } else {
5205 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5206 inner_depth.increment()?;
5207 }
5208 let val_ref =
5209 self.log_destination.get_or_insert_with(|| fidl::new_empty!(LogDestination, D));
5210 fidl::decode!(LogDestination, D, val_ref, decoder, inner_offset, inner_depth)?;
5211 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5212 {
5213 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5214 }
5215 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5216 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5217 }
5218 }
5219
5220 next_offset += envelope_size;
5221 _next_ordinal_to_read += 1;
5222 if next_offset >= end_offset {
5223 return Ok(());
5224 }
5225
5226 while _next_ordinal_to_read < 13 {
5228 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5229 _next_ordinal_to_read += 1;
5230 next_offset += envelope_size;
5231 }
5232
5233 let next_out_of_line = decoder.next_out_of_line();
5234 let handles_before = decoder.remaining_handles();
5235 if let Some((inlined, num_bytes, num_handles)) =
5236 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5237 {
5238 let member_inline_size =
5239 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5240 if inlined != (member_inline_size <= 4) {
5241 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5242 }
5243 let inner_offset;
5244 let mut inner_depth = depth.clone();
5245 if inlined {
5246 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5247 inner_offset = next_offset;
5248 } else {
5249 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5250 inner_depth.increment()?;
5251 }
5252 let val_ref = self.log_all_events.get_or_insert_with(|| fidl::new_empty!(bool, D));
5253 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5254 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5255 {
5256 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5257 }
5258 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5259 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5260 }
5261 }
5262
5263 next_offset += envelope_size;
5264 _next_ordinal_to_read += 1;
5265 if next_offset >= end_offset {
5266 return Ok(());
5267 }
5268
5269 while _next_ordinal_to_read < 14 {
5271 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5272 _next_ordinal_to_read += 1;
5273 next_offset += envelope_size;
5274 }
5275
5276 let next_out_of_line = decoder.next_out_of_line();
5277 let handles_before = decoder.remaining_handles();
5278 if let Some((inlined, num_bytes, num_handles)) =
5279 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5280 {
5281 let member_inline_size =
5282 <BuiltinBootResolver as fidl::encoding::TypeMarker>::inline_size(
5283 decoder.context,
5284 );
5285 if inlined != (member_inline_size <= 4) {
5286 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5287 }
5288 let inner_offset;
5289 let mut inner_depth = depth.clone();
5290 if inlined {
5291 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5292 inner_offset = next_offset;
5293 } else {
5294 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5295 inner_depth.increment()?;
5296 }
5297 let val_ref = self
5298 .builtin_boot_resolver
5299 .get_or_insert_with(|| fidl::new_empty!(BuiltinBootResolver, D));
5300 fidl::decode!(BuiltinBootResolver, D, val_ref, decoder, inner_offset, inner_depth)?;
5301 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5302 {
5303 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5304 }
5305 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5306 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5307 }
5308 }
5309
5310 next_offset += envelope_size;
5311 _next_ordinal_to_read += 1;
5312 if next_offset >= end_offset {
5313 return Ok(());
5314 }
5315
5316 while _next_ordinal_to_read < 16 {
5318 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5319 _next_ordinal_to_read += 1;
5320 next_offset += envelope_size;
5321 }
5322
5323 let next_out_of_line = decoder.next_out_of_line();
5324 let handles_before = decoder.remaining_handles();
5325 if let Some((inlined, num_bytes, num_handles)) =
5326 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5327 {
5328 let member_inline_size =
5329 <RealmBuilderResolverAndRunner as fidl::encoding::TypeMarker>::inline_size(
5330 decoder.context,
5331 );
5332 if inlined != (member_inline_size <= 4) {
5333 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5334 }
5335 let inner_offset;
5336 let mut inner_depth = depth.clone();
5337 if inlined {
5338 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5339 inner_offset = next_offset;
5340 } else {
5341 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5342 inner_depth.increment()?;
5343 }
5344 let val_ref = self
5345 .realm_builder_resolver_and_runner
5346 .get_or_insert_with(|| fidl::new_empty!(RealmBuilderResolverAndRunner, D));
5347 fidl::decode!(
5348 RealmBuilderResolverAndRunner,
5349 D,
5350 val_ref,
5351 decoder,
5352 inner_offset,
5353 inner_depth
5354 )?;
5355 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5356 {
5357 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5358 }
5359 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5360 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5361 }
5362 }
5363
5364 next_offset += envelope_size;
5365 _next_ordinal_to_read += 1;
5366 if next_offset >= end_offset {
5367 return Ok(());
5368 }
5369
5370 while _next_ordinal_to_read < 17 {
5372 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5373 _next_ordinal_to_read += 1;
5374 next_offset += envelope_size;
5375 }
5376
5377 let next_out_of_line = decoder.next_out_of_line();
5378 let handles_before = decoder.remaining_handles();
5379 if let Some((inlined, num_bytes, num_handles)) =
5380 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5381 {
5382 let member_inline_size = <fidl::encoding::UnboundedVector<
5383 fidl_fuchsia_component_decl__common::Capability,
5384 > as fidl::encoding::TypeMarker>::inline_size(
5385 decoder.context
5386 );
5387 if inlined != (member_inline_size <= 4) {
5388 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5389 }
5390 let inner_offset;
5391 let mut inner_depth = depth.clone();
5392 if inlined {
5393 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5394 inner_offset = next_offset;
5395 } else {
5396 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5397 inner_depth.increment()?;
5398 }
5399 let val_ref = self.builtin_capabilities.get_or_insert_with(|| {
5400 fidl::new_empty!(
5401 fidl::encoding::UnboundedVector<
5402 fidl_fuchsia_component_decl__common::Capability,
5403 >,
5404 D
5405 )
5406 });
5407 fidl::decode!(
5408 fidl::encoding::UnboundedVector<
5409 fidl_fuchsia_component_decl__common::Capability,
5410 >,
5411 D,
5412 val_ref,
5413 decoder,
5414 inner_offset,
5415 inner_depth
5416 )?;
5417 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5418 {
5419 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5420 }
5421 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5422 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5423 }
5424 }
5425
5426 next_offset += envelope_size;
5427 _next_ordinal_to_read += 1;
5428 if next_offset >= end_offset {
5429 return Ok(());
5430 }
5431
5432 while _next_ordinal_to_read < 18 {
5434 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5435 _next_ordinal_to_read += 1;
5436 next_offset += envelope_size;
5437 }
5438
5439 let next_out_of_line = decoder.next_out_of_line();
5440 let handles_before = decoder.remaining_handles();
5441 if let Some((inlined, num_bytes, num_handles)) =
5442 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5443 {
5444 let member_inline_size =
5445 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5446 if inlined != (member_inline_size <= 4) {
5447 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5448 }
5449 let inner_offset;
5450 let mut inner_depth = depth.clone();
5451 if inlined {
5452 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5453 inner_offset = next_offset;
5454 } else {
5455 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5456 inner_depth.increment()?;
5457 }
5458 let val_ref =
5459 self.enable_introspection.get_or_insert_with(|| fidl::new_empty!(bool, D));
5460 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5461 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5462 {
5463 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5464 }
5465 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5466 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5467 }
5468 }
5469
5470 next_offset += envelope_size;
5471 _next_ordinal_to_read += 1;
5472 if next_offset >= end_offset {
5473 return Ok(());
5474 }
5475
5476 while _next_ordinal_to_read < 19 {
5478 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5479 _next_ordinal_to_read += 1;
5480 next_offset += envelope_size;
5481 }
5482
5483 let next_out_of_line = decoder.next_out_of_line();
5484 let handles_before = decoder.remaining_handles();
5485 if let Some((inlined, num_bytes, num_handles)) =
5486 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5487 {
5488 let member_inline_size =
5489 <AbiRevisionPolicy as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5490 if inlined != (member_inline_size <= 4) {
5491 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5492 }
5493 let inner_offset;
5494 let mut inner_depth = depth.clone();
5495 if inlined {
5496 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5497 inner_offset = next_offset;
5498 } else {
5499 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5500 inner_depth.increment()?;
5501 }
5502 let val_ref = self
5503 .abi_revision_policy
5504 .get_or_insert_with(|| fidl::new_empty!(AbiRevisionPolicy, D));
5505 fidl::decode!(AbiRevisionPolicy, D, val_ref, decoder, inner_offset, inner_depth)?;
5506 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5507 {
5508 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5509 }
5510 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5511 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5512 }
5513 }
5514
5515 next_offset += envelope_size;
5516 _next_ordinal_to_read += 1;
5517 if next_offset >= end_offset {
5518 return Ok(());
5519 }
5520
5521 while _next_ordinal_to_read < 20 {
5523 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5524 _next_ordinal_to_read += 1;
5525 next_offset += envelope_size;
5526 }
5527
5528 let next_out_of_line = decoder.next_out_of_line();
5529 let handles_before = decoder.remaining_handles();
5530 if let Some((inlined, num_bytes, num_handles)) =
5531 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5532 {
5533 let member_inline_size =
5534 <VmexSource as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5535 if inlined != (member_inline_size <= 4) {
5536 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5537 }
5538 let inner_offset;
5539 let mut inner_depth = depth.clone();
5540 if inlined {
5541 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5542 inner_offset = next_offset;
5543 } else {
5544 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5545 inner_depth.increment()?;
5546 }
5547 let val_ref =
5548 self.vmex_source.get_or_insert_with(|| fidl::new_empty!(VmexSource, D));
5549 fidl::decode!(VmexSource, D, val_ref, decoder, inner_offset, inner_depth)?;
5550 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5551 {
5552 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5553 }
5554 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5555 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5556 }
5557 }
5558
5559 next_offset += envelope_size;
5560 _next_ordinal_to_read += 1;
5561 if next_offset >= end_offset {
5562 return Ok(());
5563 }
5564
5565 while _next_ordinal_to_read < 21 {
5567 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5568 _next_ordinal_to_read += 1;
5569 next_offset += envelope_size;
5570 }
5571
5572 let next_out_of_line = decoder.next_out_of_line();
5573 let handles_before = decoder.remaining_handles();
5574 if let Some((inlined, num_bytes, num_handles)) =
5575 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5576 {
5577 let member_inline_size =
5578 <HealthCheck as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5579 if inlined != (member_inline_size <= 4) {
5580 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5581 }
5582 let inner_offset;
5583 let mut inner_depth = depth.clone();
5584 if inlined {
5585 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5586 inner_offset = next_offset;
5587 } else {
5588 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5589 inner_depth.increment()?;
5590 }
5591 let val_ref =
5592 self.health_check.get_or_insert_with(|| fidl::new_empty!(HealthCheck, D));
5593 fidl::decode!(HealthCheck, D, val_ref, decoder, inner_offset, inner_depth)?;
5594 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5595 {
5596 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5597 }
5598 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5599 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5600 }
5601 }
5602
5603 next_offset += envelope_size;
5604 _next_ordinal_to_read += 1;
5605 if next_offset >= end_offset {
5606 return Ok(());
5607 }
5608
5609 while _next_ordinal_to_read < 22 {
5611 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5612 _next_ordinal_to_read += 1;
5613 next_offset += envelope_size;
5614 }
5615
5616 let next_out_of_line = decoder.next_out_of_line();
5617 let handles_before = decoder.remaining_handles();
5618 if let Some((inlined, num_bytes, num_handles)) =
5619 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5620 {
5621 let member_inline_size =
5622 <TraceProvider as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5623 if inlined != (member_inline_size <= 4) {
5624 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5625 }
5626 let inner_offset;
5627 let mut inner_depth = depth.clone();
5628 if inlined {
5629 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5630 inner_offset = next_offset;
5631 } else {
5632 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5633 inner_depth.increment()?;
5634 }
5635 let val_ref =
5636 self.trace_provider.get_or_insert_with(|| fidl::new_empty!(TraceProvider, D));
5637 fidl::decode!(TraceProvider, D, val_ref, decoder, inner_offset, inner_depth)?;
5638 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5639 {
5640 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5641 }
5642 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5643 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5644 }
5645 }
5646
5647 next_offset += envelope_size;
5648
5649 while next_offset < end_offset {
5651 _next_ordinal_to_read += 1;
5652 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5653 next_offset += envelope_size;
5654 }
5655
5656 Ok(())
5657 }
5658 }
5659
5660 impl DebugRegistrationAllowlistEntry {
5661 #[inline(always)]
5662 fn max_ordinal_present(&self) -> u64 {
5663 if let Some(_) = self.environment_name {
5664 return 4;
5665 }
5666 if let Some(_) = self.moniker {
5667 return 3;
5668 }
5669 if let Some(_) = self.debug {
5670 return 2;
5671 }
5672 if let Some(_) = self.name {
5673 return 1;
5674 }
5675 0
5676 }
5677 }
5678
5679 impl fidl::encoding::ValueTypeMarker for DebugRegistrationAllowlistEntry {
5680 type Borrowed<'a> = &'a Self;
5681 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5682 value
5683 }
5684 }
5685
5686 unsafe impl fidl::encoding::TypeMarker for DebugRegistrationAllowlistEntry {
5687 type Owned = Self;
5688
5689 #[inline(always)]
5690 fn inline_align(_context: fidl::encoding::Context) -> usize {
5691 8
5692 }
5693
5694 #[inline(always)]
5695 fn inline_size(_context: fidl::encoding::Context) -> usize {
5696 16
5697 }
5698 }
5699
5700 unsafe impl<D: fidl::encoding::ResourceDialect>
5701 fidl::encoding::Encode<DebugRegistrationAllowlistEntry, D>
5702 for &DebugRegistrationAllowlistEntry
5703 {
5704 unsafe fn encode(
5705 self,
5706 encoder: &mut fidl::encoding::Encoder<'_, D>,
5707 offset: usize,
5708 mut depth: fidl::encoding::Depth,
5709 ) -> fidl::Result<()> {
5710 encoder.debug_check_bounds::<DebugRegistrationAllowlistEntry>(offset);
5711 let max_ordinal: u64 = self.max_ordinal_present();
5713 encoder.write_num(max_ordinal, offset);
5714 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5715 if max_ordinal == 0 {
5717 return Ok(());
5718 }
5719 depth.increment()?;
5720 let envelope_size = 8;
5721 let bytes_len = max_ordinal as usize * envelope_size;
5722 #[allow(unused_variables)]
5723 let offset = encoder.out_of_line_offset(bytes_len);
5724 let mut _prev_end_offset: usize = 0;
5725 if 1 > max_ordinal {
5726 return Ok(());
5727 }
5728
5729 let cur_offset: usize = (1 - 1) * envelope_size;
5732
5733 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5735
5736 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5741 self.name.as_ref().map(
5742 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5743 ),
5744 encoder,
5745 offset + cur_offset,
5746 depth,
5747 )?;
5748
5749 _prev_end_offset = cur_offset + envelope_size;
5750 if 2 > max_ordinal {
5751 return Ok(());
5752 }
5753
5754 let cur_offset: usize = (2 - 1) * envelope_size;
5757
5758 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5760
5761 fidl::encoding::encode_in_envelope_optional::<AllowlistedDebugRegistration, D>(
5766 self.debug
5767 .as_ref()
5768 .map(<AllowlistedDebugRegistration as fidl::encoding::ValueTypeMarker>::borrow),
5769 encoder,
5770 offset + cur_offset,
5771 depth,
5772 )?;
5773
5774 _prev_end_offset = cur_offset + envelope_size;
5775 if 3 > max_ordinal {
5776 return Ok(());
5777 }
5778
5779 let cur_offset: usize = (3 - 1) * envelope_size;
5782
5783 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5785
5786 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
5791 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
5792 encoder, offset + cur_offset, depth
5793 )?;
5794
5795 _prev_end_offset = cur_offset + envelope_size;
5796 if 4 > max_ordinal {
5797 return Ok(());
5798 }
5799
5800 let cur_offset: usize = (4 - 1) * envelope_size;
5803
5804 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5806
5807 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5812 self.environment_name.as_ref().map(
5813 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5814 ),
5815 encoder,
5816 offset + cur_offset,
5817 depth,
5818 )?;
5819
5820 _prev_end_offset = cur_offset + envelope_size;
5821
5822 Ok(())
5823 }
5824 }
5825
5826 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5827 for DebugRegistrationAllowlistEntry
5828 {
5829 #[inline(always)]
5830 fn new_empty() -> Self {
5831 Self::default()
5832 }
5833
5834 unsafe fn decode(
5835 &mut self,
5836 decoder: &mut fidl::encoding::Decoder<'_, D>,
5837 offset: usize,
5838 mut depth: fidl::encoding::Depth,
5839 ) -> fidl::Result<()> {
5840 decoder.debug_check_bounds::<Self>(offset);
5841 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5842 None => return Err(fidl::Error::NotNullable),
5843 Some(len) => len,
5844 };
5845 if len == 0 {
5847 return Ok(());
5848 };
5849 depth.increment()?;
5850 let envelope_size = 8;
5851 let bytes_len = len * envelope_size;
5852 let offset = decoder.out_of_line_offset(bytes_len)?;
5853 let mut _next_ordinal_to_read = 0;
5855 let mut next_offset = offset;
5856 let end_offset = offset + bytes_len;
5857 _next_ordinal_to_read += 1;
5858 if next_offset >= end_offset {
5859 return Ok(());
5860 }
5861
5862 while _next_ordinal_to_read < 1 {
5864 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5865 _next_ordinal_to_read += 1;
5866 next_offset += envelope_size;
5867 }
5868
5869 let next_out_of_line = decoder.next_out_of_line();
5870 let handles_before = decoder.remaining_handles();
5871 if let Some((inlined, num_bytes, num_handles)) =
5872 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5873 {
5874 let member_inline_size =
5875 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5876 decoder.context,
5877 );
5878 if inlined != (member_inline_size <= 4) {
5879 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5880 }
5881 let inner_offset;
5882 let mut inner_depth = depth.clone();
5883 if inlined {
5884 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5885 inner_offset = next_offset;
5886 } else {
5887 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5888 inner_depth.increment()?;
5889 }
5890 let val_ref = self
5891 .name
5892 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5893 fidl::decode!(
5894 fidl::encoding::BoundedString<255>,
5895 D,
5896 val_ref,
5897 decoder,
5898 inner_offset,
5899 inner_depth
5900 )?;
5901 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5902 {
5903 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5904 }
5905 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5906 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5907 }
5908 }
5909
5910 next_offset += envelope_size;
5911 _next_ordinal_to_read += 1;
5912 if next_offset >= end_offset {
5913 return Ok(());
5914 }
5915
5916 while _next_ordinal_to_read < 2 {
5918 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5919 _next_ordinal_to_read += 1;
5920 next_offset += envelope_size;
5921 }
5922
5923 let next_out_of_line = decoder.next_out_of_line();
5924 let handles_before = decoder.remaining_handles();
5925 if let Some((inlined, num_bytes, num_handles)) =
5926 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5927 {
5928 let member_inline_size =
5929 <AllowlistedDebugRegistration as fidl::encoding::TypeMarker>::inline_size(
5930 decoder.context,
5931 );
5932 if inlined != (member_inline_size <= 4) {
5933 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5934 }
5935 let inner_offset;
5936 let mut inner_depth = depth.clone();
5937 if inlined {
5938 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5939 inner_offset = next_offset;
5940 } else {
5941 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5942 inner_depth.increment()?;
5943 }
5944 let val_ref = self
5945 .debug
5946 .get_or_insert_with(|| fidl::new_empty!(AllowlistedDebugRegistration, D));
5947 fidl::decode!(
5948 AllowlistedDebugRegistration,
5949 D,
5950 val_ref,
5951 decoder,
5952 inner_offset,
5953 inner_depth
5954 )?;
5955 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5956 {
5957 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5958 }
5959 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5960 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5961 }
5962 }
5963
5964 next_offset += envelope_size;
5965 _next_ordinal_to_read += 1;
5966 if next_offset >= end_offset {
5967 return Ok(());
5968 }
5969
5970 while _next_ordinal_to_read < 3 {
5972 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5973 _next_ordinal_to_read += 1;
5974 next_offset += envelope_size;
5975 }
5976
5977 let next_out_of_line = decoder.next_out_of_line();
5978 let handles_before = decoder.remaining_handles();
5979 if let Some((inlined, num_bytes, num_handles)) =
5980 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5981 {
5982 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5983 if inlined != (member_inline_size <= 4) {
5984 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5985 }
5986 let inner_offset;
5987 let mut inner_depth = depth.clone();
5988 if inlined {
5989 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5990 inner_offset = next_offset;
5991 } else {
5992 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5993 inner_depth.increment()?;
5994 }
5995 let val_ref = self.moniker.get_or_insert_with(|| {
5996 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
5997 });
5998 fidl::decode!(
5999 fidl::encoding::BoundedString<4096>,
6000 D,
6001 val_ref,
6002 decoder,
6003 inner_offset,
6004 inner_depth
6005 )?;
6006 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6007 {
6008 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6009 }
6010 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6011 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6012 }
6013 }
6014
6015 next_offset += envelope_size;
6016 _next_ordinal_to_read += 1;
6017 if next_offset >= end_offset {
6018 return Ok(());
6019 }
6020
6021 while _next_ordinal_to_read < 4 {
6023 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6024 _next_ordinal_to_read += 1;
6025 next_offset += envelope_size;
6026 }
6027
6028 let next_out_of_line = decoder.next_out_of_line();
6029 let handles_before = decoder.remaining_handles();
6030 if let Some((inlined, num_bytes, num_handles)) =
6031 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6032 {
6033 let member_inline_size =
6034 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6035 decoder.context,
6036 );
6037 if inlined != (member_inline_size <= 4) {
6038 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6039 }
6040 let inner_offset;
6041 let mut inner_depth = depth.clone();
6042 if inlined {
6043 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6044 inner_offset = next_offset;
6045 } else {
6046 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6047 inner_depth.increment()?;
6048 }
6049 let val_ref = self
6050 .environment_name
6051 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6052 fidl::decode!(
6053 fidl::encoding::BoundedString<255>,
6054 D,
6055 val_ref,
6056 decoder,
6057 inner_offset,
6058 inner_depth
6059 )?;
6060 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6061 {
6062 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6063 }
6064 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6065 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6066 }
6067 }
6068
6069 next_offset += envelope_size;
6070
6071 while next_offset < end_offset {
6073 _next_ordinal_to_read += 1;
6074 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6075 next_offset += envelope_size;
6076 }
6077
6078 Ok(())
6079 }
6080 }
6081
6082 impl DebugRegistrationPolicyAllowlists {
6083 #[inline(always)]
6084 fn max_ordinal_present(&self) -> u64 {
6085 if let Some(_) = self.allowlist {
6086 return 1;
6087 }
6088 0
6089 }
6090 }
6091
6092 impl fidl::encoding::ValueTypeMarker for DebugRegistrationPolicyAllowlists {
6093 type Borrowed<'a> = &'a Self;
6094 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6095 value
6096 }
6097 }
6098
6099 unsafe impl fidl::encoding::TypeMarker for DebugRegistrationPolicyAllowlists {
6100 type Owned = Self;
6101
6102 #[inline(always)]
6103 fn inline_align(_context: fidl::encoding::Context) -> usize {
6104 8
6105 }
6106
6107 #[inline(always)]
6108 fn inline_size(_context: fidl::encoding::Context) -> usize {
6109 16
6110 }
6111 }
6112
6113 unsafe impl<D: fidl::encoding::ResourceDialect>
6114 fidl::encoding::Encode<DebugRegistrationPolicyAllowlists, D>
6115 for &DebugRegistrationPolicyAllowlists
6116 {
6117 unsafe fn encode(
6118 self,
6119 encoder: &mut fidl::encoding::Encoder<'_, D>,
6120 offset: usize,
6121 mut depth: fidl::encoding::Depth,
6122 ) -> fidl::Result<()> {
6123 encoder.debug_check_bounds::<DebugRegistrationPolicyAllowlists>(offset);
6124 let max_ordinal: u64 = self.max_ordinal_present();
6126 encoder.write_num(max_ordinal, offset);
6127 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6128 if max_ordinal == 0 {
6130 return Ok(());
6131 }
6132 depth.increment()?;
6133 let envelope_size = 8;
6134 let bytes_len = max_ordinal as usize * envelope_size;
6135 #[allow(unused_variables)]
6136 let offset = encoder.out_of_line_offset(bytes_len);
6137 let mut _prev_end_offset: usize = 0;
6138 if 1 > max_ordinal {
6139 return Ok(());
6140 }
6141
6142 let cur_offset: usize = (1 - 1) * envelope_size;
6145
6146 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6148
6149 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D>(
6154 self.allowlist.as_ref().map(<fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128> as fidl::encoding::ValueTypeMarker>::borrow),
6155 encoder, offset + cur_offset, depth
6156 )?;
6157
6158 _prev_end_offset = cur_offset + envelope_size;
6159
6160 Ok(())
6161 }
6162 }
6163
6164 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6165 for DebugRegistrationPolicyAllowlists
6166 {
6167 #[inline(always)]
6168 fn new_empty() -> Self {
6169 Self::default()
6170 }
6171
6172 unsafe fn decode(
6173 &mut self,
6174 decoder: &mut fidl::encoding::Decoder<'_, D>,
6175 offset: usize,
6176 mut depth: fidl::encoding::Depth,
6177 ) -> fidl::Result<()> {
6178 decoder.debug_check_bounds::<Self>(offset);
6179 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6180 None => return Err(fidl::Error::NotNullable),
6181 Some(len) => len,
6182 };
6183 if len == 0 {
6185 return Ok(());
6186 };
6187 depth.increment()?;
6188 let envelope_size = 8;
6189 let bytes_len = len * envelope_size;
6190 let offset = decoder.out_of_line_offset(bytes_len)?;
6191 let mut _next_ordinal_to_read = 0;
6193 let mut next_offset = offset;
6194 let end_offset = offset + bytes_len;
6195 _next_ordinal_to_read += 1;
6196 if next_offset >= end_offset {
6197 return Ok(());
6198 }
6199
6200 while _next_ordinal_to_read < 1 {
6202 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6203 _next_ordinal_to_read += 1;
6204 next_offset += envelope_size;
6205 }
6206
6207 let next_out_of_line = decoder.next_out_of_line();
6208 let handles_before = decoder.remaining_handles();
6209 if let Some((inlined, num_bytes, num_handles)) =
6210 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6211 {
6212 let member_inline_size = <fidl::encoding::Vector<
6213 DebugRegistrationAllowlistEntry,
6214 128,
6215 > as fidl::encoding::TypeMarker>::inline_size(
6216 decoder.context
6217 );
6218 if inlined != (member_inline_size <= 4) {
6219 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6220 }
6221 let inner_offset;
6222 let mut inner_depth = depth.clone();
6223 if inlined {
6224 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6225 inner_offset = next_offset;
6226 } else {
6227 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6228 inner_depth.increment()?;
6229 }
6230 let val_ref =
6231 self.allowlist.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D));
6232 fidl::decode!(fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
6233 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6234 {
6235 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6236 }
6237 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6238 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6239 }
6240 }
6241
6242 next_offset += envelope_size;
6243
6244 while next_offset < end_offset {
6246 _next_ordinal_to_read += 1;
6247 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6248 next_offset += envelope_size;
6249 }
6250
6251 Ok(())
6252 }
6253 }
6254
6255 impl Environment {
6256 #[inline(always)]
6257 fn max_ordinal_present(&self) -> u64 {
6258 if let Some(_) = self.moniker {
6259 return 2;
6260 }
6261 if let Some(_) = self.capability {
6262 return 1;
6263 }
6264 0
6265 }
6266 }
6267
6268 impl fidl::encoding::ValueTypeMarker for Environment {
6269 type Borrowed<'a> = &'a Self;
6270 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6271 value
6272 }
6273 }
6274
6275 unsafe impl fidl::encoding::TypeMarker for Environment {
6276 type Owned = Self;
6277
6278 #[inline(always)]
6279 fn inline_align(_context: fidl::encoding::Context) -> usize {
6280 8
6281 }
6282
6283 #[inline(always)]
6284 fn inline_size(_context: fidl::encoding::Context) -> usize {
6285 16
6286 }
6287 }
6288
6289 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Environment, D>
6290 for &Environment
6291 {
6292 unsafe fn encode(
6293 self,
6294 encoder: &mut fidl::encoding::Encoder<'_, D>,
6295 offset: usize,
6296 mut depth: fidl::encoding::Depth,
6297 ) -> fidl::Result<()> {
6298 encoder.debug_check_bounds::<Environment>(offset);
6299 let max_ordinal: u64 = self.max_ordinal_present();
6301 encoder.write_num(max_ordinal, offset);
6302 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6303 if max_ordinal == 0 {
6305 return Ok(());
6306 }
6307 depth.increment()?;
6308 let envelope_size = 8;
6309 let bytes_len = max_ordinal as usize * envelope_size;
6310 #[allow(unused_variables)]
6311 let offset = encoder.out_of_line_offset(bytes_len);
6312 let mut _prev_end_offset: usize = 0;
6313 if 1 > max_ordinal {
6314 return Ok(());
6315 }
6316
6317 let cur_offset: usize = (1 - 1) * envelope_size;
6320
6321 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6323
6324 fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
6329 self.capability
6330 .as_ref()
6331 .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
6332 encoder,
6333 offset + cur_offset,
6334 depth,
6335 )?;
6336
6337 _prev_end_offset = cur_offset + envelope_size;
6338 if 2 > max_ordinal {
6339 return Ok(());
6340 }
6341
6342 let cur_offset: usize = (2 - 1) * envelope_size;
6345
6346 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6348
6349 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6354 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6355 encoder, offset + cur_offset, depth
6356 )?;
6357
6358 _prev_end_offset = cur_offset + envelope_size;
6359
6360 Ok(())
6361 }
6362 }
6363
6364 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Environment {
6365 #[inline(always)]
6366 fn new_empty() -> Self {
6367 Self::default()
6368 }
6369
6370 unsafe fn decode(
6371 &mut self,
6372 decoder: &mut fidl::encoding::Decoder<'_, D>,
6373 offset: usize,
6374 mut depth: fidl::encoding::Depth,
6375 ) -> fidl::Result<()> {
6376 decoder.debug_check_bounds::<Self>(offset);
6377 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6378 None => return Err(fidl::Error::NotNullable),
6379 Some(len) => len,
6380 };
6381 if len == 0 {
6383 return Ok(());
6384 };
6385 depth.increment()?;
6386 let envelope_size = 8;
6387 let bytes_len = len * envelope_size;
6388 let offset = decoder.out_of_line_offset(bytes_len)?;
6389 let mut _next_ordinal_to_read = 0;
6391 let mut next_offset = offset;
6392 let end_offset = offset + bytes_len;
6393 _next_ordinal_to_read += 1;
6394 if next_offset >= end_offset {
6395 return Ok(());
6396 }
6397
6398 while _next_ordinal_to_read < 1 {
6400 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6401 _next_ordinal_to_read += 1;
6402 next_offset += envelope_size;
6403 }
6404
6405 let next_out_of_line = decoder.next_out_of_line();
6406 let handles_before = decoder.remaining_handles();
6407 if let Some((inlined, num_bytes, num_handles)) =
6408 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6409 {
6410 let member_inline_size =
6411 <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
6412 decoder.context,
6413 );
6414 if inlined != (member_inline_size <= 4) {
6415 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6416 }
6417 let inner_offset;
6418 let mut inner_depth = depth.clone();
6419 if inlined {
6420 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6421 inner_offset = next_offset;
6422 } else {
6423 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6424 inner_depth.increment()?;
6425 }
6426 let val_ref =
6427 self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
6428 fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
6429 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6430 {
6431 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6432 }
6433 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6434 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6435 }
6436 }
6437
6438 next_offset += envelope_size;
6439 _next_ordinal_to_read += 1;
6440 if next_offset >= end_offset {
6441 return Ok(());
6442 }
6443
6444 while _next_ordinal_to_read < 2 {
6446 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6447 _next_ordinal_to_read += 1;
6448 next_offset += envelope_size;
6449 }
6450
6451 let next_out_of_line = decoder.next_out_of_line();
6452 let handles_before = decoder.remaining_handles();
6453 if let Some((inlined, num_bytes, num_handles)) =
6454 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6455 {
6456 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6457 if inlined != (member_inline_size <= 4) {
6458 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6459 }
6460 let inner_offset;
6461 let mut inner_depth = depth.clone();
6462 if inlined {
6463 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6464 inner_offset = next_offset;
6465 } else {
6466 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6467 inner_depth.increment()?;
6468 }
6469 let val_ref = self.moniker.get_or_insert_with(|| {
6470 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6471 });
6472 fidl::decode!(
6473 fidl::encoding::BoundedString<4096>,
6474 D,
6475 val_ref,
6476 decoder,
6477 inner_offset,
6478 inner_depth
6479 )?;
6480 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6481 {
6482 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6483 }
6484 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6485 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6486 }
6487 }
6488
6489 next_offset += envelope_size;
6490
6491 while next_offset < end_offset {
6493 _next_ordinal_to_read += 1;
6494 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6495 next_offset += envelope_size;
6496 }
6497
6498 Ok(())
6499 }
6500 }
6501
6502 impl EnvironmentSource {
6503 #[inline(always)]
6504 fn max_ordinal_present(&self) -> u64 {
6505 if let Some(_) = self.source {
6506 return 2;
6507 }
6508 if let Some(_) = self.source_name {
6509 return 1;
6510 }
6511 0
6512 }
6513 }
6514
6515 impl fidl::encoding::ValueTypeMarker for EnvironmentSource {
6516 type Borrowed<'a> = &'a Self;
6517 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6518 value
6519 }
6520 }
6521
6522 unsafe impl fidl::encoding::TypeMarker for EnvironmentSource {
6523 type Owned = Self;
6524
6525 #[inline(always)]
6526 fn inline_align(_context: fidl::encoding::Context) -> usize {
6527 8
6528 }
6529
6530 #[inline(always)]
6531 fn inline_size(_context: fidl::encoding::Context) -> usize {
6532 16
6533 }
6534 }
6535
6536 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnvironmentSource, D>
6537 for &EnvironmentSource
6538 {
6539 unsafe fn encode(
6540 self,
6541 encoder: &mut fidl::encoding::Encoder<'_, D>,
6542 offset: usize,
6543 mut depth: fidl::encoding::Depth,
6544 ) -> fidl::Result<()> {
6545 encoder.debug_check_bounds::<EnvironmentSource>(offset);
6546 let max_ordinal: u64 = self.max_ordinal_present();
6548 encoder.write_num(max_ordinal, offset);
6549 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6550 if max_ordinal == 0 {
6552 return Ok(());
6553 }
6554 depth.increment()?;
6555 let envelope_size = 8;
6556 let bytes_len = max_ordinal as usize * envelope_size;
6557 #[allow(unused_variables)]
6558 let offset = encoder.out_of_line_offset(bytes_len);
6559 let mut _prev_end_offset: usize = 0;
6560 if 1 > max_ordinal {
6561 return Ok(());
6562 }
6563
6564 let cur_offset: usize = (1 - 1) * envelope_size;
6567
6568 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6570
6571 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
6576 self.source_name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
6577 encoder, offset + cur_offset, depth
6578 )?;
6579
6580 _prev_end_offset = cur_offset + envelope_size;
6581 if 2 > max_ordinal {
6582 return Ok(());
6583 }
6584
6585 let cur_offset: usize = (2 - 1) * envelope_size;
6588
6589 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6591
6592 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Ref, D>(
6597 self.source.as_ref().map(<fidl_fuchsia_component_decl__common::Ref as fidl::encoding::ValueTypeMarker>::borrow),
6598 encoder, offset + cur_offset, depth
6599 )?;
6600
6601 _prev_end_offset = cur_offset + envelope_size;
6602
6603 Ok(())
6604 }
6605 }
6606
6607 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentSource {
6608 #[inline(always)]
6609 fn new_empty() -> Self {
6610 Self::default()
6611 }
6612
6613 unsafe fn decode(
6614 &mut self,
6615 decoder: &mut fidl::encoding::Decoder<'_, D>,
6616 offset: usize,
6617 mut depth: fidl::encoding::Depth,
6618 ) -> fidl::Result<()> {
6619 decoder.debug_check_bounds::<Self>(offset);
6620 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6621 None => return Err(fidl::Error::NotNullable),
6622 Some(len) => len,
6623 };
6624 if len == 0 {
6626 return Ok(());
6627 };
6628 depth.increment()?;
6629 let envelope_size = 8;
6630 let bytes_len = len * envelope_size;
6631 let offset = decoder.out_of_line_offset(bytes_len)?;
6632 let mut _next_ordinal_to_read = 0;
6634 let mut next_offset = offset;
6635 let end_offset = offset + bytes_len;
6636 _next_ordinal_to_read += 1;
6637 if next_offset >= end_offset {
6638 return Ok(());
6639 }
6640
6641 while _next_ordinal_to_read < 1 {
6643 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6644 _next_ordinal_to_read += 1;
6645 next_offset += envelope_size;
6646 }
6647
6648 let next_out_of_line = decoder.next_out_of_line();
6649 let handles_before = decoder.remaining_handles();
6650 if let Some((inlined, num_bytes, num_handles)) =
6651 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6652 {
6653 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6654 if inlined != (member_inline_size <= 4) {
6655 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6656 }
6657 let inner_offset;
6658 let mut inner_depth = depth.clone();
6659 if inlined {
6660 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6661 inner_offset = next_offset;
6662 } else {
6663 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6664 inner_depth.increment()?;
6665 }
6666 let val_ref = self.source_name.get_or_insert_with(|| {
6667 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
6668 });
6669 fidl::decode!(
6670 fidl::encoding::BoundedString<1024>,
6671 D,
6672 val_ref,
6673 decoder,
6674 inner_offset,
6675 inner_depth
6676 )?;
6677 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6678 {
6679 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6680 }
6681 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6682 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6683 }
6684 }
6685
6686 next_offset += envelope_size;
6687 _next_ordinal_to_read += 1;
6688 if next_offset >= end_offset {
6689 return Ok(());
6690 }
6691
6692 while _next_ordinal_to_read < 2 {
6694 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6695 _next_ordinal_to_read += 1;
6696 next_offset += envelope_size;
6697 }
6698
6699 let next_out_of_line = decoder.next_out_of_line();
6700 let handles_before = decoder.remaining_handles();
6701 if let Some((inlined, num_bytes, num_handles)) =
6702 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6703 {
6704 let member_inline_size = <fidl_fuchsia_component_decl__common::Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6705 if inlined != (member_inline_size <= 4) {
6706 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6707 }
6708 let inner_offset;
6709 let mut inner_depth = depth.clone();
6710 if inlined {
6711 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6712 inner_offset = next_offset;
6713 } else {
6714 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6715 inner_depth.increment()?;
6716 }
6717 let val_ref = self.source.get_or_insert_with(|| {
6718 fidl::new_empty!(fidl_fuchsia_component_decl__common::Ref, D)
6719 });
6720 fidl::decode!(
6721 fidl_fuchsia_component_decl__common::Ref,
6722 D,
6723 val_ref,
6724 decoder,
6725 inner_offset,
6726 inner_depth
6727 )?;
6728 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6729 {
6730 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6731 }
6732 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6733 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6734 }
6735 }
6736
6737 next_offset += envelope_size;
6738
6739 while next_offset < end_offset {
6741 _next_ordinal_to_read += 1;
6742 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6743 next_offset += envelope_size;
6744 }
6745
6746 Ok(())
6747 }
6748 }
6749
6750 impl FilteredAggregateProvider {
6751 #[inline(always)]
6752 fn max_ordinal_present(&self) -> u64 {
6753 if let Some(_) = self.sources {
6754 return 4;
6755 }
6756 if let Some(_) = self.offer_service_decls {
6757 return 3;
6758 }
6759 if let Some(_) = self.moniker {
6760 return 2;
6761 }
6762 if let Some(_) = self.capability {
6763 return 1;
6764 }
6765 0
6766 }
6767 }
6768
6769 impl fidl::encoding::ValueTypeMarker for FilteredAggregateProvider {
6770 type Borrowed<'a> = &'a Self;
6771 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6772 value
6773 }
6774 }
6775
6776 unsafe impl fidl::encoding::TypeMarker for FilteredAggregateProvider {
6777 type Owned = Self;
6778
6779 #[inline(always)]
6780 fn inline_align(_context: fidl::encoding::Context) -> usize {
6781 8
6782 }
6783
6784 #[inline(always)]
6785 fn inline_size(_context: fidl::encoding::Context) -> usize {
6786 16
6787 }
6788 }
6789
6790 unsafe impl<D: fidl::encoding::ResourceDialect>
6791 fidl::encoding::Encode<FilteredAggregateProvider, D> for &FilteredAggregateProvider
6792 {
6793 unsafe fn encode(
6794 self,
6795 encoder: &mut fidl::encoding::Encoder<'_, D>,
6796 offset: usize,
6797 mut depth: fidl::encoding::Depth,
6798 ) -> fidl::Result<()> {
6799 encoder.debug_check_bounds::<FilteredAggregateProvider>(offset);
6800 let max_ordinal: u64 = self.max_ordinal_present();
6802 encoder.write_num(max_ordinal, offset);
6803 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6804 if max_ordinal == 0 {
6806 return Ok(());
6807 }
6808 depth.increment()?;
6809 let envelope_size = 8;
6810 let bytes_len = max_ordinal as usize * envelope_size;
6811 #[allow(unused_variables)]
6812 let offset = encoder.out_of_line_offset(bytes_len);
6813 let mut _prev_end_offset: usize = 0;
6814 if 1 > max_ordinal {
6815 return Ok(());
6816 }
6817
6818 let cur_offset: usize = (1 - 1) * envelope_size;
6821
6822 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6824
6825 fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
6830 self.capability
6831 .as_ref()
6832 .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
6833 encoder,
6834 offset + cur_offset,
6835 depth,
6836 )?;
6837
6838 _prev_end_offset = cur_offset + envelope_size;
6839 if 2 > max_ordinal {
6840 return Ok(());
6841 }
6842
6843 let cur_offset: usize = (2 - 1) * envelope_size;
6846
6847 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6849
6850 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6855 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6856 encoder, offset + cur_offset, depth
6857 )?;
6858
6859 _prev_end_offset = cur_offset + envelope_size;
6860 if 3 > max_ordinal {
6861 return Ok(());
6862 }
6863
6864 let cur_offset: usize = (3 - 1) * envelope_size;
6867
6868 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6870
6871 fidl::encoding::encode_in_envelope_optional::<
6876 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::OfferService>,
6877 D,
6878 >(
6879 self.offer_service_decls.as_ref().map(
6880 <fidl::encoding::UnboundedVector<
6881 fidl_fuchsia_component_decl__common::OfferService,
6882 > as fidl::encoding::ValueTypeMarker>::borrow,
6883 ),
6884 encoder,
6885 offset + cur_offset,
6886 depth,
6887 )?;
6888
6889 _prev_end_offset = cur_offset + envelope_size;
6890 if 4 > max_ordinal {
6891 return Ok(());
6892 }
6893
6894 let cur_offset: usize = (4 - 1) * envelope_size;
6897
6898 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6900
6901 fidl::encoding::encode_in_envelope_optional::<Sources, D>(
6906 self.sources.as_ref().map(<Sources as fidl::encoding::ValueTypeMarker>::borrow),
6907 encoder,
6908 offset + cur_offset,
6909 depth,
6910 )?;
6911
6912 _prev_end_offset = cur_offset + envelope_size;
6913
6914 Ok(())
6915 }
6916 }
6917
6918 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6919 for FilteredAggregateProvider
6920 {
6921 #[inline(always)]
6922 fn new_empty() -> Self {
6923 Self::default()
6924 }
6925
6926 unsafe fn decode(
6927 &mut self,
6928 decoder: &mut fidl::encoding::Decoder<'_, D>,
6929 offset: usize,
6930 mut depth: fidl::encoding::Depth,
6931 ) -> fidl::Result<()> {
6932 decoder.debug_check_bounds::<Self>(offset);
6933 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6934 None => return Err(fidl::Error::NotNullable),
6935 Some(len) => len,
6936 };
6937 if len == 0 {
6939 return Ok(());
6940 };
6941 depth.increment()?;
6942 let envelope_size = 8;
6943 let bytes_len = len * envelope_size;
6944 let offset = decoder.out_of_line_offset(bytes_len)?;
6945 let mut _next_ordinal_to_read = 0;
6947 let mut next_offset = offset;
6948 let end_offset = offset + bytes_len;
6949 _next_ordinal_to_read += 1;
6950 if next_offset >= end_offset {
6951 return Ok(());
6952 }
6953
6954 while _next_ordinal_to_read < 1 {
6956 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6957 _next_ordinal_to_read += 1;
6958 next_offset += envelope_size;
6959 }
6960
6961 let next_out_of_line = decoder.next_out_of_line();
6962 let handles_before = decoder.remaining_handles();
6963 if let Some((inlined, num_bytes, num_handles)) =
6964 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6965 {
6966 let member_inline_size =
6967 <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
6968 decoder.context,
6969 );
6970 if inlined != (member_inline_size <= 4) {
6971 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6972 }
6973 let inner_offset;
6974 let mut inner_depth = depth.clone();
6975 if inlined {
6976 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6977 inner_offset = next_offset;
6978 } else {
6979 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6980 inner_depth.increment()?;
6981 }
6982 let val_ref =
6983 self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
6984 fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
6985 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6986 {
6987 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6988 }
6989 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6990 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6991 }
6992 }
6993
6994 next_offset += envelope_size;
6995 _next_ordinal_to_read += 1;
6996 if next_offset >= end_offset {
6997 return Ok(());
6998 }
6999
7000 while _next_ordinal_to_read < 2 {
7002 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7003 _next_ordinal_to_read += 1;
7004 next_offset += envelope_size;
7005 }
7006
7007 let next_out_of_line = decoder.next_out_of_line();
7008 let handles_before = decoder.remaining_handles();
7009 if let Some((inlined, num_bytes, num_handles)) =
7010 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7011 {
7012 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7013 if inlined != (member_inline_size <= 4) {
7014 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7015 }
7016 let inner_offset;
7017 let mut inner_depth = depth.clone();
7018 if inlined {
7019 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7020 inner_offset = next_offset;
7021 } else {
7022 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7023 inner_depth.increment()?;
7024 }
7025 let val_ref = self.moniker.get_or_insert_with(|| {
7026 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7027 });
7028 fidl::decode!(
7029 fidl::encoding::BoundedString<4096>,
7030 D,
7031 val_ref,
7032 decoder,
7033 inner_offset,
7034 inner_depth
7035 )?;
7036 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7037 {
7038 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7039 }
7040 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7041 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7042 }
7043 }
7044
7045 next_offset += envelope_size;
7046 _next_ordinal_to_read += 1;
7047 if next_offset >= end_offset {
7048 return Ok(());
7049 }
7050
7051 while _next_ordinal_to_read < 3 {
7053 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7054 _next_ordinal_to_read += 1;
7055 next_offset += envelope_size;
7056 }
7057
7058 let next_out_of_line = decoder.next_out_of_line();
7059 let handles_before = decoder.remaining_handles();
7060 if let Some((inlined, num_bytes, num_handles)) =
7061 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7062 {
7063 let member_inline_size = <fidl::encoding::UnboundedVector<
7064 fidl_fuchsia_component_decl__common::OfferService,
7065 > as fidl::encoding::TypeMarker>::inline_size(
7066 decoder.context
7067 );
7068 if inlined != (member_inline_size <= 4) {
7069 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7070 }
7071 let inner_offset;
7072 let mut inner_depth = depth.clone();
7073 if inlined {
7074 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7075 inner_offset = next_offset;
7076 } else {
7077 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7078 inner_depth.increment()?;
7079 }
7080 let val_ref = self.offer_service_decls.get_or_insert_with(|| {
7081 fidl::new_empty!(
7082 fidl::encoding::UnboundedVector<
7083 fidl_fuchsia_component_decl__common::OfferService,
7084 >,
7085 D
7086 )
7087 });
7088 fidl::decode!(
7089 fidl::encoding::UnboundedVector<
7090 fidl_fuchsia_component_decl__common::OfferService,
7091 >,
7092 D,
7093 val_ref,
7094 decoder,
7095 inner_offset,
7096 inner_depth
7097 )?;
7098 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7099 {
7100 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7101 }
7102 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7103 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7104 }
7105 }
7106
7107 next_offset += envelope_size;
7108 _next_ordinal_to_read += 1;
7109 if next_offset >= end_offset {
7110 return Ok(());
7111 }
7112
7113 while _next_ordinal_to_read < 4 {
7115 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7116 _next_ordinal_to_read += 1;
7117 next_offset += envelope_size;
7118 }
7119
7120 let next_out_of_line = decoder.next_out_of_line();
7121 let handles_before = decoder.remaining_handles();
7122 if let Some((inlined, num_bytes, num_handles)) =
7123 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7124 {
7125 let member_inline_size =
7126 <Sources as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7127 if inlined != (member_inline_size <= 4) {
7128 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7129 }
7130 let inner_offset;
7131 let mut inner_depth = depth.clone();
7132 if inlined {
7133 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7134 inner_offset = next_offset;
7135 } else {
7136 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7137 inner_depth.increment()?;
7138 }
7139 let val_ref = self.sources.get_or_insert_with(|| fidl::new_empty!(Sources, D));
7140 fidl::decode!(Sources, D, val_ref, decoder, inner_offset, inner_depth)?;
7141 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7142 {
7143 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7144 }
7145 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7146 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7147 }
7148 }
7149
7150 next_offset += envelope_size;
7151
7152 while next_offset < end_offset {
7154 _next_ordinal_to_read += 1;
7155 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7156 next_offset += envelope_size;
7157 }
7158
7159 Ok(())
7160 }
7161 }
7162
7163 impl FilteredProvider {
7164 #[inline(always)]
7165 fn max_ordinal_present(&self) -> u64 {
7166 if let Some(_) = self.offer_service_decl {
7167 return 4;
7168 }
7169 if let Some(_) = self.service_capability {
7170 return 3;
7171 }
7172 if let Some(_) = self.moniker {
7173 return 2;
7174 }
7175 if let Some(_) = self.capability {
7176 return 1;
7177 }
7178 0
7179 }
7180 }
7181
7182 impl fidl::encoding::ValueTypeMarker for FilteredProvider {
7183 type Borrowed<'a> = &'a Self;
7184 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7185 value
7186 }
7187 }
7188
7189 unsafe impl fidl::encoding::TypeMarker for FilteredProvider {
7190 type Owned = Self;
7191
7192 #[inline(always)]
7193 fn inline_align(_context: fidl::encoding::Context) -> usize {
7194 8
7195 }
7196
7197 #[inline(always)]
7198 fn inline_size(_context: fidl::encoding::Context) -> usize {
7199 16
7200 }
7201 }
7202
7203 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FilteredProvider, D>
7204 for &FilteredProvider
7205 {
7206 unsafe fn encode(
7207 self,
7208 encoder: &mut fidl::encoding::Encoder<'_, D>,
7209 offset: usize,
7210 mut depth: fidl::encoding::Depth,
7211 ) -> fidl::Result<()> {
7212 encoder.debug_check_bounds::<FilteredProvider>(offset);
7213 let max_ordinal: u64 = self.max_ordinal_present();
7215 encoder.write_num(max_ordinal, offset);
7216 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7217 if max_ordinal == 0 {
7219 return Ok(());
7220 }
7221 depth.increment()?;
7222 let envelope_size = 8;
7223 let bytes_len = max_ordinal as usize * envelope_size;
7224 #[allow(unused_variables)]
7225 let offset = encoder.out_of_line_offset(bytes_len);
7226 let mut _prev_end_offset: usize = 0;
7227 if 1 > max_ordinal {
7228 return Ok(());
7229 }
7230
7231 let cur_offset: usize = (1 - 1) * envelope_size;
7234
7235 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7237
7238 fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
7243 self.capability
7244 .as_ref()
7245 .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
7246 encoder,
7247 offset + cur_offset,
7248 depth,
7249 )?;
7250
7251 _prev_end_offset = cur_offset + envelope_size;
7252 if 2 > max_ordinal {
7253 return Ok(());
7254 }
7255
7256 let cur_offset: usize = (2 - 1) * envelope_size;
7259
7260 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7262
7263 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
7268 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
7269 encoder, offset + cur_offset, depth
7270 )?;
7271
7272 _prev_end_offset = cur_offset + envelope_size;
7273 if 3 > max_ordinal {
7274 return Ok(());
7275 }
7276
7277 let cur_offset: usize = (3 - 1) * envelope_size;
7280
7281 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7283
7284 fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
7289 self.service_capability
7290 .as_ref()
7291 .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
7292 encoder,
7293 offset + cur_offset,
7294 depth,
7295 )?;
7296
7297 _prev_end_offset = cur_offset + envelope_size;
7298 if 4 > max_ordinal {
7299 return Ok(());
7300 }
7301
7302 let cur_offset: usize = (4 - 1) * envelope_size;
7305
7306 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7308
7309 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::OfferService, D>(
7314 self.offer_service_decl.as_ref().map(<fidl_fuchsia_component_decl__common::OfferService as fidl::encoding::ValueTypeMarker>::borrow),
7315 encoder, offset + cur_offset, depth
7316 )?;
7317
7318 _prev_end_offset = cur_offset + envelope_size;
7319
7320 Ok(())
7321 }
7322 }
7323
7324 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FilteredProvider {
7325 #[inline(always)]
7326 fn new_empty() -> Self {
7327 Self::default()
7328 }
7329
7330 unsafe fn decode(
7331 &mut self,
7332 decoder: &mut fidl::encoding::Decoder<'_, D>,
7333 offset: usize,
7334 mut depth: fidl::encoding::Depth,
7335 ) -> fidl::Result<()> {
7336 decoder.debug_check_bounds::<Self>(offset);
7337 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7338 None => return Err(fidl::Error::NotNullable),
7339 Some(len) => len,
7340 };
7341 if len == 0 {
7343 return Ok(());
7344 };
7345 depth.increment()?;
7346 let envelope_size = 8;
7347 let bytes_len = len * envelope_size;
7348 let offset = decoder.out_of_line_offset(bytes_len)?;
7349 let mut _next_ordinal_to_read = 0;
7351 let mut next_offset = offset;
7352 let end_offset = offset + bytes_len;
7353 _next_ordinal_to_read += 1;
7354 if next_offset >= end_offset {
7355 return Ok(());
7356 }
7357
7358 while _next_ordinal_to_read < 1 {
7360 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7361 _next_ordinal_to_read += 1;
7362 next_offset += envelope_size;
7363 }
7364
7365 let next_out_of_line = decoder.next_out_of_line();
7366 let handles_before = decoder.remaining_handles();
7367 if let Some((inlined, num_bytes, num_handles)) =
7368 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7369 {
7370 let member_inline_size =
7371 <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
7372 decoder.context,
7373 );
7374 if inlined != (member_inline_size <= 4) {
7375 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7376 }
7377 let inner_offset;
7378 let mut inner_depth = depth.clone();
7379 if inlined {
7380 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7381 inner_offset = next_offset;
7382 } else {
7383 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7384 inner_depth.increment()?;
7385 }
7386 let val_ref =
7387 self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
7388 fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7389 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7390 {
7391 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7392 }
7393 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7394 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7395 }
7396 }
7397
7398 next_offset += envelope_size;
7399 _next_ordinal_to_read += 1;
7400 if next_offset >= end_offset {
7401 return Ok(());
7402 }
7403
7404 while _next_ordinal_to_read < 2 {
7406 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7407 _next_ordinal_to_read += 1;
7408 next_offset += envelope_size;
7409 }
7410
7411 let next_out_of_line = decoder.next_out_of_line();
7412 let handles_before = decoder.remaining_handles();
7413 if let Some((inlined, num_bytes, num_handles)) =
7414 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7415 {
7416 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7417 if inlined != (member_inline_size <= 4) {
7418 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7419 }
7420 let inner_offset;
7421 let mut inner_depth = depth.clone();
7422 if inlined {
7423 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7424 inner_offset = next_offset;
7425 } else {
7426 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7427 inner_depth.increment()?;
7428 }
7429 let val_ref = self.moniker.get_or_insert_with(|| {
7430 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7431 });
7432 fidl::decode!(
7433 fidl::encoding::BoundedString<4096>,
7434 D,
7435 val_ref,
7436 decoder,
7437 inner_offset,
7438 inner_depth
7439 )?;
7440 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7441 {
7442 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7443 }
7444 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7445 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7446 }
7447 }
7448
7449 next_offset += envelope_size;
7450 _next_ordinal_to_read += 1;
7451 if next_offset >= end_offset {
7452 return Ok(());
7453 }
7454
7455 while _next_ordinal_to_read < 3 {
7457 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7458 _next_ordinal_to_read += 1;
7459 next_offset += envelope_size;
7460 }
7461
7462 let next_out_of_line = decoder.next_out_of_line();
7463 let handles_before = decoder.remaining_handles();
7464 if let Some((inlined, num_bytes, num_handles)) =
7465 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7466 {
7467 let member_inline_size =
7468 <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
7469 decoder.context,
7470 );
7471 if inlined != (member_inline_size <= 4) {
7472 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7473 }
7474 let inner_offset;
7475 let mut inner_depth = depth.clone();
7476 if inlined {
7477 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7478 inner_offset = next_offset;
7479 } else {
7480 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7481 inner_depth.increment()?;
7482 }
7483 let val_ref = self
7484 .service_capability
7485 .get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
7486 fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7487 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7488 {
7489 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7490 }
7491 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7492 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7493 }
7494 }
7495
7496 next_offset += envelope_size;
7497 _next_ordinal_to_read += 1;
7498 if next_offset >= end_offset {
7499 return Ok(());
7500 }
7501
7502 while _next_ordinal_to_read < 4 {
7504 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7505 _next_ordinal_to_read += 1;
7506 next_offset += envelope_size;
7507 }
7508
7509 let next_out_of_line = decoder.next_out_of_line();
7510 let handles_before = decoder.remaining_handles();
7511 if let Some((inlined, num_bytes, num_handles)) =
7512 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7513 {
7514 let member_inline_size = <fidl_fuchsia_component_decl__common::OfferService as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7515 if inlined != (member_inline_size <= 4) {
7516 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7517 }
7518 let inner_offset;
7519 let mut inner_depth = depth.clone();
7520 if inlined {
7521 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7522 inner_offset = next_offset;
7523 } else {
7524 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7525 inner_depth.increment()?;
7526 }
7527 let val_ref = self.offer_service_decl.get_or_insert_with(|| {
7528 fidl::new_empty!(fidl_fuchsia_component_decl__common::OfferService, D)
7529 });
7530 fidl::decode!(
7531 fidl_fuchsia_component_decl__common::OfferService,
7532 D,
7533 val_ref,
7534 decoder,
7535 inner_offset,
7536 inner_depth
7537 )?;
7538 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7539 {
7540 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7541 }
7542 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7543 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7544 }
7545 }
7546
7547 next_offset += envelope_size;
7548
7549 while next_offset < end_offset {
7551 _next_ordinal_to_read += 1;
7552 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7553 next_offset += envelope_size;
7554 }
7555
7556 Ok(())
7557 }
7558 }
7559
7560 impl Framework {
7561 #[inline(always)]
7562 fn max_ordinal_present(&self) -> u64 {
7563 if let Some(_) = self.moniker {
7564 return 2;
7565 }
7566 if let Some(_) = self.capability {
7567 return 1;
7568 }
7569 0
7570 }
7571 }
7572
7573 impl fidl::encoding::ValueTypeMarker for Framework {
7574 type Borrowed<'a> = &'a Self;
7575 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7576 value
7577 }
7578 }
7579
7580 unsafe impl fidl::encoding::TypeMarker for Framework {
7581 type Owned = Self;
7582
7583 #[inline(always)]
7584 fn inline_align(_context: fidl::encoding::Context) -> usize {
7585 8
7586 }
7587
7588 #[inline(always)]
7589 fn inline_size(_context: fidl::encoding::Context) -> usize {
7590 16
7591 }
7592 }
7593
7594 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Framework, D>
7595 for &Framework
7596 {
7597 unsafe fn encode(
7598 self,
7599 encoder: &mut fidl::encoding::Encoder<'_, D>,
7600 offset: usize,
7601 mut depth: fidl::encoding::Depth,
7602 ) -> fidl::Result<()> {
7603 encoder.debug_check_bounds::<Framework>(offset);
7604 let max_ordinal: u64 = self.max_ordinal_present();
7606 encoder.write_num(max_ordinal, offset);
7607 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7608 if max_ordinal == 0 {
7610 return Ok(());
7611 }
7612 depth.increment()?;
7613 let envelope_size = 8;
7614 let bytes_len = max_ordinal as usize * envelope_size;
7615 #[allow(unused_variables)]
7616 let offset = encoder.out_of_line_offset(bytes_len);
7617 let mut _prev_end_offset: usize = 0;
7618 if 1 > max_ordinal {
7619 return Ok(());
7620 }
7621
7622 let cur_offset: usize = (1 - 1) * envelope_size;
7625
7626 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7628
7629 fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
7634 self.capability
7635 .as_ref()
7636 .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
7637 encoder,
7638 offset + cur_offset,
7639 depth,
7640 )?;
7641
7642 _prev_end_offset = cur_offset + envelope_size;
7643 if 2 > max_ordinal {
7644 return Ok(());
7645 }
7646
7647 let cur_offset: usize = (2 - 1) * envelope_size;
7650
7651 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7653
7654 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
7659 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
7660 encoder, offset + cur_offset, depth
7661 )?;
7662
7663 _prev_end_offset = cur_offset + envelope_size;
7664
7665 Ok(())
7666 }
7667 }
7668
7669 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Framework {
7670 #[inline(always)]
7671 fn new_empty() -> Self {
7672 Self::default()
7673 }
7674
7675 unsafe fn decode(
7676 &mut self,
7677 decoder: &mut fidl::encoding::Decoder<'_, D>,
7678 offset: usize,
7679 mut depth: fidl::encoding::Depth,
7680 ) -> fidl::Result<()> {
7681 decoder.debug_check_bounds::<Self>(offset);
7682 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7683 None => return Err(fidl::Error::NotNullable),
7684 Some(len) => len,
7685 };
7686 if len == 0 {
7688 return Ok(());
7689 };
7690 depth.increment()?;
7691 let envelope_size = 8;
7692 let bytes_len = len * envelope_size;
7693 let offset = decoder.out_of_line_offset(bytes_len)?;
7694 let mut _next_ordinal_to_read = 0;
7696 let mut next_offset = offset;
7697 let end_offset = offset + bytes_len;
7698 _next_ordinal_to_read += 1;
7699 if next_offset >= end_offset {
7700 return Ok(());
7701 }
7702
7703 while _next_ordinal_to_read < 1 {
7705 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7706 _next_ordinal_to_read += 1;
7707 next_offset += envelope_size;
7708 }
7709
7710 let next_out_of_line = decoder.next_out_of_line();
7711 let handles_before = decoder.remaining_handles();
7712 if let Some((inlined, num_bytes, num_handles)) =
7713 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7714 {
7715 let member_inline_size =
7716 <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
7717 decoder.context,
7718 );
7719 if inlined != (member_inline_size <= 4) {
7720 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7721 }
7722 let inner_offset;
7723 let mut inner_depth = depth.clone();
7724 if inlined {
7725 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7726 inner_offset = next_offset;
7727 } else {
7728 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7729 inner_depth.increment()?;
7730 }
7731 let val_ref =
7732 self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
7733 fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7734 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7735 {
7736 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7737 }
7738 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7739 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7740 }
7741 }
7742
7743 next_offset += envelope_size;
7744 _next_ordinal_to_read += 1;
7745 if next_offset >= end_offset {
7746 return Ok(());
7747 }
7748
7749 while _next_ordinal_to_read < 2 {
7751 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7752 _next_ordinal_to_read += 1;
7753 next_offset += envelope_size;
7754 }
7755
7756 let next_out_of_line = decoder.next_out_of_line();
7757 let handles_before = decoder.remaining_handles();
7758 if let Some((inlined, num_bytes, num_handles)) =
7759 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7760 {
7761 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7762 if inlined != (member_inline_size <= 4) {
7763 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7764 }
7765 let inner_offset;
7766 let mut inner_depth = depth.clone();
7767 if inlined {
7768 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7769 inner_offset = next_offset;
7770 } else {
7771 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7772 inner_depth.increment()?;
7773 }
7774 let val_ref = self.moniker.get_or_insert_with(|| {
7775 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7776 });
7777 fidl::decode!(
7778 fidl::encoding::BoundedString<4096>,
7779 D,
7780 val_ref,
7781 decoder,
7782 inner_offset,
7783 inner_depth
7784 )?;
7785 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7786 {
7787 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7788 }
7789 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7790 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7791 }
7792 }
7793
7794 next_offset += envelope_size;
7795
7796 while next_offset < end_offset {
7798 _next_ordinal_to_read += 1;
7799 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7800 next_offset += envelope_size;
7801 }
7802
7803 Ok(())
7804 }
7805 }
7806
7807 impl HealthCheck {
7808 #[inline(always)]
7809 fn max_ordinal_present(&self) -> u64 {
7810 if let Some(_) = self.monikers {
7811 return 1;
7812 }
7813 0
7814 }
7815 }
7816
7817 impl fidl::encoding::ValueTypeMarker for HealthCheck {
7818 type Borrowed<'a> = &'a Self;
7819 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7820 value
7821 }
7822 }
7823
7824 unsafe impl fidl::encoding::TypeMarker for HealthCheck {
7825 type Owned = Self;
7826
7827 #[inline(always)]
7828 fn inline_align(_context: fidl::encoding::Context) -> usize {
7829 8
7830 }
7831
7832 #[inline(always)]
7833 fn inline_size(_context: fidl::encoding::Context) -> usize {
7834 16
7835 }
7836 }
7837
7838 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HealthCheck, D>
7839 for &HealthCheck
7840 {
7841 unsafe fn encode(
7842 self,
7843 encoder: &mut fidl::encoding::Encoder<'_, D>,
7844 offset: usize,
7845 mut depth: fidl::encoding::Depth,
7846 ) -> fidl::Result<()> {
7847 encoder.debug_check_bounds::<HealthCheck>(offset);
7848 let max_ordinal: u64 = self.max_ordinal_present();
7850 encoder.write_num(max_ordinal, offset);
7851 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7852 if max_ordinal == 0 {
7854 return Ok(());
7855 }
7856 depth.increment()?;
7857 let envelope_size = 8;
7858 let bytes_len = max_ordinal as usize * envelope_size;
7859 #[allow(unused_variables)]
7860 let offset = encoder.out_of_line_offset(bytes_len);
7861 let mut _prev_end_offset: usize = 0;
7862 if 1 > max_ordinal {
7863 return Ok(());
7864 }
7865
7866 let cur_offset: usize = (1 - 1) * envelope_size;
7869
7870 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7872
7873 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>, D>(
7878 self.monikers.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>> as fidl::encoding::ValueTypeMarker>::borrow),
7879 encoder, offset + cur_offset, depth
7880 )?;
7881
7882 _prev_end_offset = cur_offset + envelope_size;
7883
7884 Ok(())
7885 }
7886 }
7887
7888 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HealthCheck {
7889 #[inline(always)]
7890 fn new_empty() -> Self {
7891 Self::default()
7892 }
7893
7894 unsafe fn decode(
7895 &mut self,
7896 decoder: &mut fidl::encoding::Decoder<'_, D>,
7897 offset: usize,
7898 mut depth: fidl::encoding::Depth,
7899 ) -> fidl::Result<()> {
7900 decoder.debug_check_bounds::<Self>(offset);
7901 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7902 None => return Err(fidl::Error::NotNullable),
7903 Some(len) => len,
7904 };
7905 if len == 0 {
7907 return Ok(());
7908 };
7909 depth.increment()?;
7910 let envelope_size = 8;
7911 let bytes_len = len * envelope_size;
7912 let offset = decoder.out_of_line_offset(bytes_len)?;
7913 let mut _next_ordinal_to_read = 0;
7915 let mut next_offset = offset;
7916 let end_offset = offset + bytes_len;
7917 _next_ordinal_to_read += 1;
7918 if next_offset >= end_offset {
7919 return Ok(());
7920 }
7921
7922 while _next_ordinal_to_read < 1 {
7924 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7925 _next_ordinal_to_read += 1;
7926 next_offset += envelope_size;
7927 }
7928
7929 let next_out_of_line = decoder.next_out_of_line();
7930 let handles_before = decoder.remaining_handles();
7931 if let Some((inlined, num_bytes, num_handles)) =
7932 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7933 {
7934 let member_inline_size = <fidl::encoding::UnboundedVector<
7935 fidl::encoding::BoundedString<255>,
7936 > as fidl::encoding::TypeMarker>::inline_size(
7937 decoder.context
7938 );
7939 if inlined != (member_inline_size <= 4) {
7940 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7941 }
7942 let inner_offset;
7943 let mut inner_depth = depth.clone();
7944 if inlined {
7945 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7946 inner_offset = next_offset;
7947 } else {
7948 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7949 inner_depth.increment()?;
7950 }
7951 let val_ref = self.monikers.get_or_insert_with(|| {
7952 fidl::new_empty!(
7953 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>,
7954 D
7955 )
7956 });
7957 fidl::decode!(
7958 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>,
7959 D,
7960 val_ref,
7961 decoder,
7962 inner_offset,
7963 inner_depth
7964 )?;
7965 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7966 {
7967 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7968 }
7969 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7970 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7971 }
7972 }
7973
7974 next_offset += envelope_size;
7975
7976 while next_offset < end_offset {
7978 _next_ordinal_to_read += 1;
7979 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7980 next_offset += envelope_size;
7981 }
7982
7983 Ok(())
7984 }
7985 }
7986
7987 impl InstanceIdEntry {
7988 #[inline(always)]
7989 fn max_ordinal_present(&self) -> u64 {
7990 if let Some(_) = self.moniker {
7991 return 3;
7992 }
7993 if let Some(_) = self.instance_id {
7994 return 1;
7995 }
7996 0
7997 }
7998 }
7999
8000 impl fidl::encoding::ValueTypeMarker for InstanceIdEntry {
8001 type Borrowed<'a> = &'a Self;
8002 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8003 value
8004 }
8005 }
8006
8007 unsafe impl fidl::encoding::TypeMarker for InstanceIdEntry {
8008 type Owned = Self;
8009
8010 #[inline(always)]
8011 fn inline_align(_context: fidl::encoding::Context) -> usize {
8012 8
8013 }
8014
8015 #[inline(always)]
8016 fn inline_size(_context: fidl::encoding::Context) -> usize {
8017 16
8018 }
8019 }
8020
8021 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InstanceIdEntry, D>
8022 for &InstanceIdEntry
8023 {
8024 unsafe fn encode(
8025 self,
8026 encoder: &mut fidl::encoding::Encoder<'_, D>,
8027 offset: usize,
8028 mut depth: fidl::encoding::Depth,
8029 ) -> fidl::Result<()> {
8030 encoder.debug_check_bounds::<InstanceIdEntry>(offset);
8031 let max_ordinal: u64 = self.max_ordinal_present();
8033 encoder.write_num(max_ordinal, offset);
8034 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8035 if max_ordinal == 0 {
8037 return Ok(());
8038 }
8039 depth.increment()?;
8040 let envelope_size = 8;
8041 let bytes_len = max_ordinal as usize * envelope_size;
8042 #[allow(unused_variables)]
8043 let offset = encoder.out_of_line_offset(bytes_len);
8044 let mut _prev_end_offset: usize = 0;
8045 if 1 > max_ordinal {
8046 return Ok(());
8047 }
8048
8049 let cur_offset: usize = (1 - 1) * envelope_size;
8052
8053 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8055
8056 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
8061 self.instance_id.as_ref().map(
8062 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
8063 ),
8064 encoder,
8065 offset + cur_offset,
8066 depth,
8067 )?;
8068
8069 _prev_end_offset = cur_offset + envelope_size;
8070 if 3 > max_ordinal {
8071 return Ok(());
8072 }
8073
8074 let cur_offset: usize = (3 - 1) * envelope_size;
8077
8078 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8080
8081 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
8086 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
8087 encoder, offset + cur_offset, depth
8088 )?;
8089
8090 _prev_end_offset = cur_offset + envelope_size;
8091
8092 Ok(())
8093 }
8094 }
8095
8096 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InstanceIdEntry {
8097 #[inline(always)]
8098 fn new_empty() -> Self {
8099 Self::default()
8100 }
8101
8102 unsafe fn decode(
8103 &mut self,
8104 decoder: &mut fidl::encoding::Decoder<'_, D>,
8105 offset: usize,
8106 mut depth: fidl::encoding::Depth,
8107 ) -> fidl::Result<()> {
8108 decoder.debug_check_bounds::<Self>(offset);
8109 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8110 None => return Err(fidl::Error::NotNullable),
8111 Some(len) => len,
8112 };
8113 if len == 0 {
8115 return Ok(());
8116 };
8117 depth.increment()?;
8118 let envelope_size = 8;
8119 let bytes_len = len * envelope_size;
8120 let offset = decoder.out_of_line_offset(bytes_len)?;
8121 let mut _next_ordinal_to_read = 0;
8123 let mut next_offset = offset;
8124 let end_offset = offset + bytes_len;
8125 _next_ordinal_to_read += 1;
8126 if next_offset >= end_offset {
8127 return Ok(());
8128 }
8129
8130 while _next_ordinal_to_read < 1 {
8132 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8133 _next_ordinal_to_read += 1;
8134 next_offset += envelope_size;
8135 }
8136
8137 let next_out_of_line = decoder.next_out_of_line();
8138 let handles_before = decoder.remaining_handles();
8139 if let Some((inlined, num_bytes, num_handles)) =
8140 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8141 {
8142 let member_inline_size =
8143 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
8144 decoder.context,
8145 );
8146 if inlined != (member_inline_size <= 4) {
8147 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8148 }
8149 let inner_offset;
8150 let mut inner_depth = depth.clone();
8151 if inlined {
8152 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8153 inner_offset = next_offset;
8154 } else {
8155 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8156 inner_depth.increment()?;
8157 }
8158 let val_ref = self
8159 .instance_id
8160 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
8161 fidl::decode!(
8162 fidl::encoding::BoundedString<64>,
8163 D,
8164 val_ref,
8165 decoder,
8166 inner_offset,
8167 inner_depth
8168 )?;
8169 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8170 {
8171 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8172 }
8173 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8174 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8175 }
8176 }
8177
8178 next_offset += envelope_size;
8179 _next_ordinal_to_read += 1;
8180 if next_offset >= end_offset {
8181 return Ok(());
8182 }
8183
8184 while _next_ordinal_to_read < 3 {
8186 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8187 _next_ordinal_to_read += 1;
8188 next_offset += envelope_size;
8189 }
8190
8191 let next_out_of_line = decoder.next_out_of_line();
8192 let handles_before = decoder.remaining_handles();
8193 if let Some((inlined, num_bytes, num_handles)) =
8194 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8195 {
8196 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8197 if inlined != (member_inline_size <= 4) {
8198 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8199 }
8200 let inner_offset;
8201 let mut inner_depth = depth.clone();
8202 if inlined {
8203 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8204 inner_offset = next_offset;
8205 } else {
8206 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8207 inner_depth.increment()?;
8208 }
8209 let val_ref = self.moniker.get_or_insert_with(|| {
8210 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
8211 });
8212 fidl::decode!(
8213 fidl::encoding::BoundedString<4096>,
8214 D,
8215 val_ref,
8216 decoder,
8217 inner_offset,
8218 inner_depth
8219 )?;
8220 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8221 {
8222 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8223 }
8224 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8225 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8226 }
8227 }
8228
8229 next_offset += envelope_size;
8230
8231 while next_offset < end_offset {
8233 _next_ordinal_to_read += 1;
8234 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8235 next_offset += envelope_size;
8236 }
8237
8238 Ok(())
8239 }
8240 }
8241
8242 impl JobPolicyAllowlists {
8243 #[inline(always)]
8244 fn max_ordinal_present(&self) -> u64 {
8245 if let Some(_) = self.create_raw_processes {
8246 return 3;
8247 }
8248 if let Some(_) = self.main_process_critical {
8249 return 2;
8250 }
8251 if let Some(_) = self.ambient_mark_vmo_exec {
8252 return 1;
8253 }
8254 0
8255 }
8256 }
8257
8258 impl fidl::encoding::ValueTypeMarker for JobPolicyAllowlists {
8259 type Borrowed<'a> = &'a Self;
8260 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8261 value
8262 }
8263 }
8264
8265 unsafe impl fidl::encoding::TypeMarker for JobPolicyAllowlists {
8266 type Owned = Self;
8267
8268 #[inline(always)]
8269 fn inline_align(_context: fidl::encoding::Context) -> usize {
8270 8
8271 }
8272
8273 #[inline(always)]
8274 fn inline_size(_context: fidl::encoding::Context) -> usize {
8275 16
8276 }
8277 }
8278
8279 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<JobPolicyAllowlists, D>
8280 for &JobPolicyAllowlists
8281 {
8282 unsafe fn encode(
8283 self,
8284 encoder: &mut fidl::encoding::Encoder<'_, D>,
8285 offset: usize,
8286 mut depth: fidl::encoding::Depth,
8287 ) -> fidl::Result<()> {
8288 encoder.debug_check_bounds::<JobPolicyAllowlists>(offset);
8289 let max_ordinal: u64 = self.max_ordinal_present();
8291 encoder.write_num(max_ordinal, offset);
8292 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8293 if max_ordinal == 0 {
8295 return Ok(());
8296 }
8297 depth.increment()?;
8298 let envelope_size = 8;
8299 let bytes_len = max_ordinal as usize * envelope_size;
8300 #[allow(unused_variables)]
8301 let offset = encoder.out_of_line_offset(bytes_len);
8302 let mut _prev_end_offset: usize = 0;
8303 if 1 > max_ordinal {
8304 return Ok(());
8305 }
8306
8307 let cur_offset: usize = (1 - 1) * envelope_size;
8310
8311 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8313
8314 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
8319 self.ambient_mark_vmo_exec.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
8320 encoder, offset + cur_offset, depth
8321 )?;
8322
8323 _prev_end_offset = cur_offset + envelope_size;
8324 if 2 > max_ordinal {
8325 return Ok(());
8326 }
8327
8328 let cur_offset: usize = (2 - 1) * envelope_size;
8331
8332 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8334
8335 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
8340 self.main_process_critical.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
8341 encoder, offset + cur_offset, depth
8342 )?;
8343
8344 _prev_end_offset = cur_offset + envelope_size;
8345 if 3 > max_ordinal {
8346 return Ok(());
8347 }
8348
8349 let cur_offset: usize = (3 - 1) * envelope_size;
8352
8353 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8355
8356 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
8361 self.create_raw_processes.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
8362 encoder, offset + cur_offset, depth
8363 )?;
8364
8365 _prev_end_offset = cur_offset + envelope_size;
8366
8367 Ok(())
8368 }
8369 }
8370
8371 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for JobPolicyAllowlists {
8372 #[inline(always)]
8373 fn new_empty() -> Self {
8374 Self::default()
8375 }
8376
8377 unsafe fn decode(
8378 &mut self,
8379 decoder: &mut fidl::encoding::Decoder<'_, D>,
8380 offset: usize,
8381 mut depth: fidl::encoding::Depth,
8382 ) -> fidl::Result<()> {
8383 decoder.debug_check_bounds::<Self>(offset);
8384 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8385 None => return Err(fidl::Error::NotNullable),
8386 Some(len) => len,
8387 };
8388 if len == 0 {
8390 return Ok(());
8391 };
8392 depth.increment()?;
8393 let envelope_size = 8;
8394 let bytes_len = len * envelope_size;
8395 let offset = decoder.out_of_line_offset(bytes_len)?;
8396 let mut _next_ordinal_to_read = 0;
8398 let mut next_offset = offset;
8399 let end_offset = offset + bytes_len;
8400 _next_ordinal_to_read += 1;
8401 if next_offset >= end_offset {
8402 return Ok(());
8403 }
8404
8405 while _next_ordinal_to_read < 1 {
8407 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8408 _next_ordinal_to_read += 1;
8409 next_offset += envelope_size;
8410 }
8411
8412 let next_out_of_line = decoder.next_out_of_line();
8413 let handles_before = decoder.remaining_handles();
8414 if let Some((inlined, num_bytes, num_handles)) =
8415 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8416 {
8417 let member_inline_size = <fidl::encoding::Vector<
8418 fidl::encoding::BoundedString<4096>,
8419 128,
8420 > as fidl::encoding::TypeMarker>::inline_size(
8421 decoder.context
8422 );
8423 if inlined != (member_inline_size <= 4) {
8424 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8425 }
8426 let inner_offset;
8427 let mut inner_depth = depth.clone();
8428 if inlined {
8429 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8430 inner_offset = next_offset;
8431 } else {
8432 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8433 inner_depth.increment()?;
8434 }
8435 let val_ref = self.ambient_mark_vmo_exec.get_or_insert_with(|| {
8436 fidl::new_empty!(
8437 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8438 D
8439 )
8440 });
8441 fidl::decode!(
8442 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8443 D,
8444 val_ref,
8445 decoder,
8446 inner_offset,
8447 inner_depth
8448 )?;
8449 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8450 {
8451 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8452 }
8453 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8454 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8455 }
8456 }
8457
8458 next_offset += envelope_size;
8459 _next_ordinal_to_read += 1;
8460 if next_offset >= end_offset {
8461 return Ok(());
8462 }
8463
8464 while _next_ordinal_to_read < 2 {
8466 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8467 _next_ordinal_to_read += 1;
8468 next_offset += envelope_size;
8469 }
8470
8471 let next_out_of_line = decoder.next_out_of_line();
8472 let handles_before = decoder.remaining_handles();
8473 if let Some((inlined, num_bytes, num_handles)) =
8474 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8475 {
8476 let member_inline_size = <fidl::encoding::Vector<
8477 fidl::encoding::BoundedString<4096>,
8478 128,
8479 > as fidl::encoding::TypeMarker>::inline_size(
8480 decoder.context
8481 );
8482 if inlined != (member_inline_size <= 4) {
8483 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8484 }
8485 let inner_offset;
8486 let mut inner_depth = depth.clone();
8487 if inlined {
8488 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8489 inner_offset = next_offset;
8490 } else {
8491 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8492 inner_depth.increment()?;
8493 }
8494 let val_ref = self.main_process_critical.get_or_insert_with(|| {
8495 fidl::new_empty!(
8496 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8497 D
8498 )
8499 });
8500 fidl::decode!(
8501 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8502 D,
8503 val_ref,
8504 decoder,
8505 inner_offset,
8506 inner_depth
8507 )?;
8508 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8509 {
8510 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8511 }
8512 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8513 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8514 }
8515 }
8516
8517 next_offset += envelope_size;
8518 _next_ordinal_to_read += 1;
8519 if next_offset >= end_offset {
8520 return Ok(());
8521 }
8522
8523 while _next_ordinal_to_read < 3 {
8525 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8526 _next_ordinal_to_read += 1;
8527 next_offset += envelope_size;
8528 }
8529
8530 let next_out_of_line = decoder.next_out_of_line();
8531 let handles_before = decoder.remaining_handles();
8532 if let Some((inlined, num_bytes, num_handles)) =
8533 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8534 {
8535 let member_inline_size = <fidl::encoding::Vector<
8536 fidl::encoding::BoundedString<4096>,
8537 128,
8538 > as fidl::encoding::TypeMarker>::inline_size(
8539 decoder.context
8540 );
8541 if inlined != (member_inline_size <= 4) {
8542 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8543 }
8544 let inner_offset;
8545 let mut inner_depth = depth.clone();
8546 if inlined {
8547 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8548 inner_offset = next_offset;
8549 } else {
8550 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8551 inner_depth.increment()?;
8552 }
8553 let val_ref = self.create_raw_processes.get_or_insert_with(|| {
8554 fidl::new_empty!(
8555 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8556 D
8557 )
8558 });
8559 fidl::decode!(
8560 fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8561 D,
8562 val_ref,
8563 decoder,
8564 inner_offset,
8565 inner_depth
8566 )?;
8567 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8568 {
8569 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8570 }
8571 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8572 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8573 }
8574 }
8575
8576 next_offset += envelope_size;
8577
8578 while next_offset < end_offset {
8580 _next_ordinal_to_read += 1;
8581 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8582 next_offset += envelope_size;
8583 }
8584
8585 Ok(())
8586 }
8587 }
8588
8589 impl Namespace {
8590 #[inline(always)]
8591 fn max_ordinal_present(&self) -> u64 {
8592 if let Some(_) = self.capability {
8593 return 1;
8594 }
8595 0
8596 }
8597 }
8598
8599 impl fidl::encoding::ValueTypeMarker for Namespace {
8600 type Borrowed<'a> = &'a Self;
8601 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8602 value
8603 }
8604 }
8605
8606 unsafe impl fidl::encoding::TypeMarker for Namespace {
8607 type Owned = Self;
8608
8609 #[inline(always)]
8610 fn inline_align(_context: fidl::encoding::Context) -> usize {
8611 8
8612 }
8613
8614 #[inline(always)]
8615 fn inline_size(_context: fidl::encoding::Context) -> usize {
8616 16
8617 }
8618 }
8619
8620 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Namespace, D>
8621 for &Namespace
8622 {
8623 unsafe fn encode(
8624 self,
8625 encoder: &mut fidl::encoding::Encoder<'_, D>,
8626 offset: usize,
8627 mut depth: fidl::encoding::Depth,
8628 ) -> fidl::Result<()> {
8629 encoder.debug_check_bounds::<Namespace>(offset);
8630 let max_ordinal: u64 = self.max_ordinal_present();
8632 encoder.write_num(max_ordinal, offset);
8633 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8634 if max_ordinal == 0 {
8636 return Ok(());
8637 }
8638 depth.increment()?;
8639 let envelope_size = 8;
8640 let bytes_len = max_ordinal as usize * envelope_size;
8641 #[allow(unused_variables)]
8642 let offset = encoder.out_of_line_offset(bytes_len);
8643 let mut _prev_end_offset: usize = 0;
8644 if 1 > max_ordinal {
8645 return Ok(());
8646 }
8647
8648 let cur_offset: usize = (1 - 1) * envelope_size;
8651
8652 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8654
8655 fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
8660 self.capability
8661 .as_ref()
8662 .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
8663 encoder,
8664 offset + cur_offset,
8665 depth,
8666 )?;
8667
8668 _prev_end_offset = cur_offset + envelope_size;
8669
8670 Ok(())
8671 }
8672 }
8673
8674 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Namespace {
8675 #[inline(always)]
8676 fn new_empty() -> Self {
8677 Self::default()
8678 }
8679
8680 unsafe fn decode(
8681 &mut self,
8682 decoder: &mut fidl::encoding::Decoder<'_, D>,
8683 offset: usize,
8684 mut depth: fidl::encoding::Depth,
8685 ) -> fidl::Result<()> {
8686 decoder.debug_check_bounds::<Self>(offset);
8687 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8688 None => return Err(fidl::Error::NotNullable),
8689 Some(len) => len,
8690 };
8691 if len == 0 {
8693 return Ok(());
8694 };
8695 depth.increment()?;
8696 let envelope_size = 8;
8697 let bytes_len = len * envelope_size;
8698 let offset = decoder.out_of_line_offset(bytes_len)?;
8699 let mut _next_ordinal_to_read = 0;
8701 let mut next_offset = offset;
8702 let end_offset = offset + bytes_len;
8703 _next_ordinal_to_read += 1;
8704 if next_offset >= end_offset {
8705 return Ok(());
8706 }
8707
8708 while _next_ordinal_to_read < 1 {
8710 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8711 _next_ordinal_to_read += 1;
8712 next_offset += envelope_size;
8713 }
8714
8715 let next_out_of_line = decoder.next_out_of_line();
8716 let handles_before = decoder.remaining_handles();
8717 if let Some((inlined, num_bytes, num_handles)) =
8718 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8719 {
8720 let member_inline_size =
8721 <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
8722 decoder.context,
8723 );
8724 if inlined != (member_inline_size <= 4) {
8725 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8726 }
8727 let inner_offset;
8728 let mut inner_depth = depth.clone();
8729 if inlined {
8730 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8731 inner_offset = next_offset;
8732 } else {
8733 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8734 inner_depth.increment()?;
8735 }
8736 let val_ref =
8737 self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
8738 fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
8739 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8740 {
8741 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8742 }
8743 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8744 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8745 }
8746 }
8747
8748 next_offset += envelope_size;
8749
8750 while next_offset < end_offset {
8752 _next_ordinal_to_read += 1;
8753 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8754 next_offset += envelope_size;
8755 }
8756
8757 Ok(())
8758 }
8759 }
8760
8761 impl SecurityPolicy {
8762 #[inline(always)]
8763 fn max_ordinal_present(&self) -> u64 {
8764 if let Some(_) = self.child_policy {
8765 return 4;
8766 }
8767 if let Some(_) = self.debug_registration_policy {
8768 return 3;
8769 }
8770 if let Some(_) = self.capability_policy {
8771 return 2;
8772 }
8773 if let Some(_) = self.job_policy {
8774 return 1;
8775 }
8776 0
8777 }
8778 }
8779
8780 impl fidl::encoding::ValueTypeMarker for SecurityPolicy {
8781 type Borrowed<'a> = &'a Self;
8782 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8783 value
8784 }
8785 }
8786
8787 unsafe impl fidl::encoding::TypeMarker for SecurityPolicy {
8788 type Owned = Self;
8789
8790 #[inline(always)]
8791 fn inline_align(_context: fidl::encoding::Context) -> usize {
8792 8
8793 }
8794
8795 #[inline(always)]
8796 fn inline_size(_context: fidl::encoding::Context) -> usize {
8797 16
8798 }
8799 }
8800
8801 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecurityPolicy, D>
8802 for &SecurityPolicy
8803 {
8804 unsafe fn encode(
8805 self,
8806 encoder: &mut fidl::encoding::Encoder<'_, D>,
8807 offset: usize,
8808 mut depth: fidl::encoding::Depth,
8809 ) -> fidl::Result<()> {
8810 encoder.debug_check_bounds::<SecurityPolicy>(offset);
8811 let max_ordinal: u64 = self.max_ordinal_present();
8813 encoder.write_num(max_ordinal, offset);
8814 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8815 if max_ordinal == 0 {
8817 return Ok(());
8818 }
8819 depth.increment()?;
8820 let envelope_size = 8;
8821 let bytes_len = max_ordinal as usize * envelope_size;
8822 #[allow(unused_variables)]
8823 let offset = encoder.out_of_line_offset(bytes_len);
8824 let mut _prev_end_offset: usize = 0;
8825 if 1 > max_ordinal {
8826 return Ok(());
8827 }
8828
8829 let cur_offset: usize = (1 - 1) * envelope_size;
8832
8833 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8835
8836 fidl::encoding::encode_in_envelope_optional::<JobPolicyAllowlists, D>(
8841 self.job_policy
8842 .as_ref()
8843 .map(<JobPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
8844 encoder,
8845 offset + cur_offset,
8846 depth,
8847 )?;
8848
8849 _prev_end_offset = cur_offset + envelope_size;
8850 if 2 > max_ordinal {
8851 return Ok(());
8852 }
8853
8854 let cur_offset: usize = (2 - 1) * envelope_size;
8857
8858 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8860
8861 fidl::encoding::encode_in_envelope_optional::<CapabilityPolicyAllowlists, D>(
8866 self.capability_policy
8867 .as_ref()
8868 .map(<CapabilityPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
8869 encoder,
8870 offset + cur_offset,
8871 depth,
8872 )?;
8873
8874 _prev_end_offset = cur_offset + envelope_size;
8875 if 3 > max_ordinal {
8876 return Ok(());
8877 }
8878
8879 let cur_offset: usize = (3 - 1) * envelope_size;
8882
8883 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8885
8886 fidl::encoding::encode_in_envelope_optional::<DebugRegistrationPolicyAllowlists, D>(
8891 self.debug_registration_policy.as_ref().map(
8892 <DebugRegistrationPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow,
8893 ),
8894 encoder,
8895 offset + cur_offset,
8896 depth,
8897 )?;
8898
8899 _prev_end_offset = cur_offset + envelope_size;
8900 if 4 > max_ordinal {
8901 return Ok(());
8902 }
8903
8904 let cur_offset: usize = (4 - 1) * envelope_size;
8907
8908 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8910
8911 fidl::encoding::encode_in_envelope_optional::<ChildPolicyAllowlists, D>(
8916 self.child_policy
8917 .as_ref()
8918 .map(<ChildPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
8919 encoder,
8920 offset + cur_offset,
8921 depth,
8922 )?;
8923
8924 _prev_end_offset = cur_offset + envelope_size;
8925
8926 Ok(())
8927 }
8928 }
8929
8930 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecurityPolicy {
8931 #[inline(always)]
8932 fn new_empty() -> Self {
8933 Self::default()
8934 }
8935
8936 unsafe fn decode(
8937 &mut self,
8938 decoder: &mut fidl::encoding::Decoder<'_, D>,
8939 offset: usize,
8940 mut depth: fidl::encoding::Depth,
8941 ) -> fidl::Result<()> {
8942 decoder.debug_check_bounds::<Self>(offset);
8943 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8944 None => return Err(fidl::Error::NotNullable),
8945 Some(len) => len,
8946 };
8947 if len == 0 {
8949 return Ok(());
8950 };
8951 depth.increment()?;
8952 let envelope_size = 8;
8953 let bytes_len = len * envelope_size;
8954 let offset = decoder.out_of_line_offset(bytes_len)?;
8955 let mut _next_ordinal_to_read = 0;
8957 let mut next_offset = offset;
8958 let end_offset = offset + bytes_len;
8959 _next_ordinal_to_read += 1;
8960 if next_offset >= end_offset {
8961 return Ok(());
8962 }
8963
8964 while _next_ordinal_to_read < 1 {
8966 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8967 _next_ordinal_to_read += 1;
8968 next_offset += envelope_size;
8969 }
8970
8971 let next_out_of_line = decoder.next_out_of_line();
8972 let handles_before = decoder.remaining_handles();
8973 if let Some((inlined, num_bytes, num_handles)) =
8974 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8975 {
8976 let member_inline_size =
8977 <JobPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
8978 decoder.context,
8979 );
8980 if inlined != (member_inline_size <= 4) {
8981 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8982 }
8983 let inner_offset;
8984 let mut inner_depth = depth.clone();
8985 if inlined {
8986 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8987 inner_offset = next_offset;
8988 } else {
8989 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8990 inner_depth.increment()?;
8991 }
8992 let val_ref =
8993 self.job_policy.get_or_insert_with(|| fidl::new_empty!(JobPolicyAllowlists, D));
8994 fidl::decode!(JobPolicyAllowlists, D, val_ref, decoder, inner_offset, inner_depth)?;
8995 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8996 {
8997 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8998 }
8999 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9000 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9001 }
9002 }
9003
9004 next_offset += envelope_size;
9005 _next_ordinal_to_read += 1;
9006 if next_offset >= end_offset {
9007 return Ok(());
9008 }
9009
9010 while _next_ordinal_to_read < 2 {
9012 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9013 _next_ordinal_to_read += 1;
9014 next_offset += envelope_size;
9015 }
9016
9017 let next_out_of_line = decoder.next_out_of_line();
9018 let handles_before = decoder.remaining_handles();
9019 if let Some((inlined, num_bytes, num_handles)) =
9020 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9021 {
9022 let member_inline_size =
9023 <CapabilityPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
9024 decoder.context,
9025 );
9026 if inlined != (member_inline_size <= 4) {
9027 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9028 }
9029 let inner_offset;
9030 let mut inner_depth = depth.clone();
9031 if inlined {
9032 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9033 inner_offset = next_offset;
9034 } else {
9035 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9036 inner_depth.increment()?;
9037 }
9038 let val_ref = self
9039 .capability_policy
9040 .get_or_insert_with(|| fidl::new_empty!(CapabilityPolicyAllowlists, D));
9041 fidl::decode!(
9042 CapabilityPolicyAllowlists,
9043 D,
9044 val_ref,
9045 decoder,
9046 inner_offset,
9047 inner_depth
9048 )?;
9049 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9050 {
9051 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9052 }
9053 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9054 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9055 }
9056 }
9057
9058 next_offset += envelope_size;
9059 _next_ordinal_to_read += 1;
9060 if next_offset >= end_offset {
9061 return Ok(());
9062 }
9063
9064 while _next_ordinal_to_read < 3 {
9066 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9067 _next_ordinal_to_read += 1;
9068 next_offset += envelope_size;
9069 }
9070
9071 let next_out_of_line = decoder.next_out_of_line();
9072 let handles_before = decoder.remaining_handles();
9073 if let Some((inlined, num_bytes, num_handles)) =
9074 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9075 {
9076 let member_inline_size =
9077 <DebugRegistrationPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
9078 decoder.context,
9079 );
9080 if inlined != (member_inline_size <= 4) {
9081 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9082 }
9083 let inner_offset;
9084 let mut inner_depth = depth.clone();
9085 if inlined {
9086 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9087 inner_offset = next_offset;
9088 } else {
9089 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9090 inner_depth.increment()?;
9091 }
9092 let val_ref = self
9093 .debug_registration_policy
9094 .get_or_insert_with(|| fidl::new_empty!(DebugRegistrationPolicyAllowlists, D));
9095 fidl::decode!(
9096 DebugRegistrationPolicyAllowlists,
9097 D,
9098 val_ref,
9099 decoder,
9100 inner_offset,
9101 inner_depth
9102 )?;
9103 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9104 {
9105 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9106 }
9107 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9108 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9109 }
9110 }
9111
9112 next_offset += envelope_size;
9113 _next_ordinal_to_read += 1;
9114 if next_offset >= end_offset {
9115 return Ok(());
9116 }
9117
9118 while _next_ordinal_to_read < 4 {
9120 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9121 _next_ordinal_to_read += 1;
9122 next_offset += envelope_size;
9123 }
9124
9125 let next_out_of_line = decoder.next_out_of_line();
9126 let handles_before = decoder.remaining_handles();
9127 if let Some((inlined, num_bytes, num_handles)) =
9128 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9129 {
9130 let member_inline_size =
9131 <ChildPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
9132 decoder.context,
9133 );
9134 if inlined != (member_inline_size <= 4) {
9135 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9136 }
9137 let inner_offset;
9138 let mut inner_depth = depth.clone();
9139 if inlined {
9140 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9141 inner_offset = next_offset;
9142 } else {
9143 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9144 inner_depth.increment()?;
9145 }
9146 let val_ref = self
9147 .child_policy
9148 .get_or_insert_with(|| fidl::new_empty!(ChildPolicyAllowlists, D));
9149 fidl::decode!(
9150 ChildPolicyAllowlists,
9151 D,
9152 val_ref,
9153 decoder,
9154 inner_offset,
9155 inner_depth
9156 )?;
9157 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9158 {
9159 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9160 }
9161 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9162 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9163 }
9164 }
9165
9166 next_offset += envelope_size;
9167
9168 while next_offset < end_offset {
9170 _next_ordinal_to_read += 1;
9171 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9172 next_offset += envelope_size;
9173 }
9174
9175 Ok(())
9176 }
9177 }
9178
9179 impl Sources {
9180 #[inline(always)]
9181 fn max_ordinal_present(&self) -> u64 {
9182 if let Some(_) = self.capability_type {
9183 return 7;
9184 }
9185 if let Some(_) = self.component {
9186 return 6;
9187 }
9188 if let Some(_) = self.namespace {
9189 return 5;
9190 }
9191 if let Some(_) = self.collection {
9192 return 4;
9193 }
9194 if let Some(_) = self.capability {
9195 return 3;
9196 }
9197 if let Some(_) = self.builtin {
9198 return 2;
9199 }
9200 if let Some(_) = self.framework {
9201 return 1;
9202 }
9203 0
9204 }
9205 }
9206
9207 impl fidl::encoding::ValueTypeMarker for Sources {
9208 type Borrowed<'a> = &'a Self;
9209 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9210 value
9211 }
9212 }
9213
9214 unsafe impl fidl::encoding::TypeMarker for Sources {
9215 type Owned = Self;
9216
9217 #[inline(always)]
9218 fn inline_align(_context: fidl::encoding::Context) -> usize {
9219 8
9220 }
9221
9222 #[inline(always)]
9223 fn inline_size(_context: fidl::encoding::Context) -> usize {
9224 16
9225 }
9226 }
9227
9228 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Sources, D> for &Sources {
9229 unsafe fn encode(
9230 self,
9231 encoder: &mut fidl::encoding::Encoder<'_, D>,
9232 offset: usize,
9233 mut depth: fidl::encoding::Depth,
9234 ) -> fidl::Result<()> {
9235 encoder.debug_check_bounds::<Sources>(offset);
9236 let max_ordinal: u64 = self.max_ordinal_present();
9238 encoder.write_num(max_ordinal, offset);
9239 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9240 if max_ordinal == 0 {
9242 return Ok(());
9243 }
9244 depth.increment()?;
9245 let envelope_size = 8;
9246 let bytes_len = max_ordinal as usize * envelope_size;
9247 #[allow(unused_variables)]
9248 let offset = encoder.out_of_line_offset(bytes_len);
9249 let mut _prev_end_offset: usize = 0;
9250 if 1 > max_ordinal {
9251 return Ok(());
9252 }
9253
9254 let cur_offset: usize = (1 - 1) * envelope_size;
9257
9258 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9260
9261 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9266 self.framework.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9267 encoder,
9268 offset + cur_offset,
9269 depth,
9270 )?;
9271
9272 _prev_end_offset = cur_offset + envelope_size;
9273 if 2 > max_ordinal {
9274 return Ok(());
9275 }
9276
9277 let cur_offset: usize = (2 - 1) * envelope_size;
9280
9281 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9283
9284 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9289 self.builtin.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9290 encoder,
9291 offset + cur_offset,
9292 depth,
9293 )?;
9294
9295 _prev_end_offset = cur_offset + envelope_size;
9296 if 3 > max_ordinal {
9297 return Ok(());
9298 }
9299
9300 let cur_offset: usize = (3 - 1) * envelope_size;
9303
9304 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9306
9307 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9312 self.capability.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9313 encoder,
9314 offset + cur_offset,
9315 depth,
9316 )?;
9317
9318 _prev_end_offset = cur_offset + envelope_size;
9319 if 4 > max_ordinal {
9320 return Ok(());
9321 }
9322
9323 let cur_offset: usize = (4 - 1) * envelope_size;
9326
9327 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9329
9330 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9335 self.collection.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9336 encoder,
9337 offset + cur_offset,
9338 depth,
9339 )?;
9340
9341 _prev_end_offset = cur_offset + envelope_size;
9342 if 5 > max_ordinal {
9343 return Ok(());
9344 }
9345
9346 let cur_offset: usize = (5 - 1) * envelope_size;
9349
9350 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9352
9353 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9358 self.namespace.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9359 encoder,
9360 offset + cur_offset,
9361 depth,
9362 )?;
9363
9364 _prev_end_offset = cur_offset + envelope_size;
9365 if 6 > max_ordinal {
9366 return Ok(());
9367 }
9368
9369 let cur_offset: usize = (6 - 1) * envelope_size;
9372
9373 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9375
9376 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9381 self.component.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9382 encoder,
9383 offset + cur_offset,
9384 depth,
9385 )?;
9386
9387 _prev_end_offset = cur_offset + envelope_size;
9388 if 7 > max_ordinal {
9389 return Ok(());
9390 }
9391
9392 let cur_offset: usize = (7 - 1) * envelope_size;
9395
9396 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9398
9399 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
9404 self.capability_type.as_ref().map(
9405 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
9406 ),
9407 encoder,
9408 offset + cur_offset,
9409 depth,
9410 )?;
9411
9412 _prev_end_offset = cur_offset + envelope_size;
9413
9414 Ok(())
9415 }
9416 }
9417
9418 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Sources {
9419 #[inline(always)]
9420 fn new_empty() -> Self {
9421 Self::default()
9422 }
9423
9424 unsafe fn decode(
9425 &mut self,
9426 decoder: &mut fidl::encoding::Decoder<'_, D>,
9427 offset: usize,
9428 mut depth: fidl::encoding::Depth,
9429 ) -> fidl::Result<()> {
9430 decoder.debug_check_bounds::<Self>(offset);
9431 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9432 None => return Err(fidl::Error::NotNullable),
9433 Some(len) => len,
9434 };
9435 if len == 0 {
9437 return Ok(());
9438 };
9439 depth.increment()?;
9440 let envelope_size = 8;
9441 let bytes_len = len * envelope_size;
9442 let offset = decoder.out_of_line_offset(bytes_len)?;
9443 let mut _next_ordinal_to_read = 0;
9445 let mut next_offset = offset;
9446 let end_offset = offset + bytes_len;
9447 _next_ordinal_to_read += 1;
9448 if next_offset >= end_offset {
9449 return Ok(());
9450 }
9451
9452 while _next_ordinal_to_read < 1 {
9454 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9455 _next_ordinal_to_read += 1;
9456 next_offset += envelope_size;
9457 }
9458
9459 let next_out_of_line = decoder.next_out_of_line();
9460 let handles_before = decoder.remaining_handles();
9461 if let Some((inlined, num_bytes, num_handles)) =
9462 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9463 {
9464 let member_inline_size =
9465 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9466 if inlined != (member_inline_size <= 4) {
9467 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9468 }
9469 let inner_offset;
9470 let mut inner_depth = depth.clone();
9471 if inlined {
9472 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9473 inner_offset = next_offset;
9474 } else {
9475 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9476 inner_depth.increment()?;
9477 }
9478 let val_ref = self.framework.get_or_insert_with(|| fidl::new_empty!(bool, D));
9479 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9480 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9481 {
9482 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9483 }
9484 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9485 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9486 }
9487 }
9488
9489 next_offset += envelope_size;
9490 _next_ordinal_to_read += 1;
9491 if next_offset >= end_offset {
9492 return Ok(());
9493 }
9494
9495 while _next_ordinal_to_read < 2 {
9497 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9498 _next_ordinal_to_read += 1;
9499 next_offset += envelope_size;
9500 }
9501
9502 let next_out_of_line = decoder.next_out_of_line();
9503 let handles_before = decoder.remaining_handles();
9504 if let Some((inlined, num_bytes, num_handles)) =
9505 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9506 {
9507 let member_inline_size =
9508 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9509 if inlined != (member_inline_size <= 4) {
9510 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9511 }
9512 let inner_offset;
9513 let mut inner_depth = depth.clone();
9514 if inlined {
9515 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9516 inner_offset = next_offset;
9517 } else {
9518 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9519 inner_depth.increment()?;
9520 }
9521 let val_ref = self.builtin.get_or_insert_with(|| fidl::new_empty!(bool, D));
9522 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 3 {
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 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9552 if inlined != (member_inline_size <= 4) {
9553 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9554 }
9555 let inner_offset;
9556 let mut inner_depth = depth.clone();
9557 if inlined {
9558 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9559 inner_offset = next_offset;
9560 } else {
9561 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9562 inner_depth.increment()?;
9563 }
9564 let val_ref = self.capability.get_or_insert_with(|| fidl::new_empty!(bool, D));
9565 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9566 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9567 {
9568 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9569 }
9570 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9571 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9572 }
9573 }
9574
9575 next_offset += envelope_size;
9576 _next_ordinal_to_read += 1;
9577 if next_offset >= end_offset {
9578 return Ok(());
9579 }
9580
9581 while _next_ordinal_to_read < 4 {
9583 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9584 _next_ordinal_to_read += 1;
9585 next_offset += envelope_size;
9586 }
9587
9588 let next_out_of_line = decoder.next_out_of_line();
9589 let handles_before = decoder.remaining_handles();
9590 if let Some((inlined, num_bytes, num_handles)) =
9591 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9592 {
9593 let member_inline_size =
9594 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9595 if inlined != (member_inline_size <= 4) {
9596 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9597 }
9598 let inner_offset;
9599 let mut inner_depth = depth.clone();
9600 if inlined {
9601 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9602 inner_offset = next_offset;
9603 } else {
9604 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9605 inner_depth.increment()?;
9606 }
9607 let val_ref = self.collection.get_or_insert_with(|| fidl::new_empty!(bool, D));
9608 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9609 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9610 {
9611 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9612 }
9613 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9614 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9615 }
9616 }
9617
9618 next_offset += envelope_size;
9619 _next_ordinal_to_read += 1;
9620 if next_offset >= end_offset {
9621 return Ok(());
9622 }
9623
9624 while _next_ordinal_to_read < 5 {
9626 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9627 _next_ordinal_to_read += 1;
9628 next_offset += envelope_size;
9629 }
9630
9631 let next_out_of_line = decoder.next_out_of_line();
9632 let handles_before = decoder.remaining_handles();
9633 if let Some((inlined, num_bytes, num_handles)) =
9634 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9635 {
9636 let member_inline_size =
9637 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9638 if inlined != (member_inline_size <= 4) {
9639 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9640 }
9641 let inner_offset;
9642 let mut inner_depth = depth.clone();
9643 if inlined {
9644 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9645 inner_offset = next_offset;
9646 } else {
9647 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9648 inner_depth.increment()?;
9649 }
9650 let val_ref = self.namespace.get_or_insert_with(|| fidl::new_empty!(bool, D));
9651 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9652 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9653 {
9654 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9655 }
9656 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9657 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9658 }
9659 }
9660
9661 next_offset += envelope_size;
9662 _next_ordinal_to_read += 1;
9663 if next_offset >= end_offset {
9664 return Ok(());
9665 }
9666
9667 while _next_ordinal_to_read < 6 {
9669 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9670 _next_ordinal_to_read += 1;
9671 next_offset += envelope_size;
9672 }
9673
9674 let next_out_of_line = decoder.next_out_of_line();
9675 let handles_before = decoder.remaining_handles();
9676 if let Some((inlined, num_bytes, num_handles)) =
9677 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9678 {
9679 let member_inline_size =
9680 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9681 if inlined != (member_inline_size <= 4) {
9682 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9683 }
9684 let inner_offset;
9685 let mut inner_depth = depth.clone();
9686 if inlined {
9687 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9688 inner_offset = next_offset;
9689 } else {
9690 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9691 inner_depth.increment()?;
9692 }
9693 let val_ref = self.component.get_or_insert_with(|| fidl::new_empty!(bool, D));
9694 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9695 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9696 {
9697 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9698 }
9699 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9700 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9701 }
9702 }
9703
9704 next_offset += envelope_size;
9705 _next_ordinal_to_read += 1;
9706 if next_offset >= end_offset {
9707 return Ok(());
9708 }
9709
9710 while _next_ordinal_to_read < 7 {
9712 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9713 _next_ordinal_to_read += 1;
9714 next_offset += envelope_size;
9715 }
9716
9717 let next_out_of_line = decoder.next_out_of_line();
9718 let handles_before = decoder.remaining_handles();
9719 if let Some((inlined, num_bytes, num_handles)) =
9720 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9721 {
9722 let member_inline_size =
9723 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
9724 decoder.context,
9725 );
9726 if inlined != (member_inline_size <= 4) {
9727 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9728 }
9729 let inner_offset;
9730 let mut inner_depth = depth.clone();
9731 if inlined {
9732 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9733 inner_offset = next_offset;
9734 } else {
9735 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9736 inner_depth.increment()?;
9737 }
9738 let val_ref = self
9739 .capability_type
9740 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
9741 fidl::decode!(
9742 fidl::encoding::BoundedString<100>,
9743 D,
9744 val_ref,
9745 decoder,
9746 inner_offset,
9747 inner_depth
9748 )?;
9749 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9750 {
9751 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9752 }
9753 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9754 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9755 }
9756 }
9757
9758 next_offset += envelope_size;
9759
9760 while next_offset < end_offset {
9762 _next_ordinal_to_read += 1;
9763 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9764 next_offset += envelope_size;
9765 }
9766
9767 Ok(())
9768 }
9769 }
9770
9771 impl Void {
9772 #[inline(always)]
9773 fn max_ordinal_present(&self) -> u64 {
9774 if let Some(_) = self.moniker {
9775 return 2;
9776 }
9777 if let Some(_) = self.capability {
9778 return 1;
9779 }
9780 0
9781 }
9782 }
9783
9784 impl fidl::encoding::ValueTypeMarker for Void {
9785 type Borrowed<'a> = &'a Self;
9786 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9787 value
9788 }
9789 }
9790
9791 unsafe impl fidl::encoding::TypeMarker for Void {
9792 type Owned = Self;
9793
9794 #[inline(always)]
9795 fn inline_align(_context: fidl::encoding::Context) -> usize {
9796 8
9797 }
9798
9799 #[inline(always)]
9800 fn inline_size(_context: fidl::encoding::Context) -> usize {
9801 16
9802 }
9803 }
9804
9805 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Void, D> for &Void {
9806 unsafe fn encode(
9807 self,
9808 encoder: &mut fidl::encoding::Encoder<'_, D>,
9809 offset: usize,
9810 mut depth: fidl::encoding::Depth,
9811 ) -> fidl::Result<()> {
9812 encoder.debug_check_bounds::<Void>(offset);
9813 let max_ordinal: u64 = self.max_ordinal_present();
9815 encoder.write_num(max_ordinal, offset);
9816 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9817 if max_ordinal == 0 {
9819 return Ok(());
9820 }
9821 depth.increment()?;
9822 let envelope_size = 8;
9823 let bytes_len = max_ordinal as usize * envelope_size;
9824 #[allow(unused_variables)]
9825 let offset = encoder.out_of_line_offset(bytes_len);
9826 let mut _prev_end_offset: usize = 0;
9827 if 1 > max_ordinal {
9828 return Ok(());
9829 }
9830
9831 let cur_offset: usize = (1 - 1) * envelope_size;
9834
9835 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9837
9838 fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
9843 self.capability
9844 .as_ref()
9845 .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
9846 encoder,
9847 offset + cur_offset,
9848 depth,
9849 )?;
9850
9851 _prev_end_offset = cur_offset + envelope_size;
9852 if 2 > max_ordinal {
9853 return Ok(());
9854 }
9855
9856 let cur_offset: usize = (2 - 1) * envelope_size;
9859
9860 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9862
9863 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
9868 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
9869 encoder, offset + cur_offset, depth
9870 )?;
9871
9872 _prev_end_offset = cur_offset + envelope_size;
9873
9874 Ok(())
9875 }
9876 }
9877
9878 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Void {
9879 #[inline(always)]
9880 fn new_empty() -> Self {
9881 Self::default()
9882 }
9883
9884 unsafe fn decode(
9885 &mut self,
9886 decoder: &mut fidl::encoding::Decoder<'_, D>,
9887 offset: usize,
9888 mut depth: fidl::encoding::Depth,
9889 ) -> fidl::Result<()> {
9890 decoder.debug_check_bounds::<Self>(offset);
9891 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9892 None => return Err(fidl::Error::NotNullable),
9893 Some(len) => len,
9894 };
9895 if len == 0 {
9897 return Ok(());
9898 };
9899 depth.increment()?;
9900 let envelope_size = 8;
9901 let bytes_len = len * envelope_size;
9902 let offset = decoder.out_of_line_offset(bytes_len)?;
9903 let mut _next_ordinal_to_read = 0;
9905 let mut next_offset = offset;
9906 let end_offset = offset + bytes_len;
9907 _next_ordinal_to_read += 1;
9908 if next_offset >= end_offset {
9909 return Ok(());
9910 }
9911
9912 while _next_ordinal_to_read < 1 {
9914 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9915 _next_ordinal_to_read += 1;
9916 next_offset += envelope_size;
9917 }
9918
9919 let next_out_of_line = decoder.next_out_of_line();
9920 let handles_before = decoder.remaining_handles();
9921 if let Some((inlined, num_bytes, num_handles)) =
9922 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9923 {
9924 let member_inline_size =
9925 <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
9926 decoder.context,
9927 );
9928 if inlined != (member_inline_size <= 4) {
9929 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9930 }
9931 let inner_offset;
9932 let mut inner_depth = depth.clone();
9933 if inlined {
9934 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9935 inner_offset = next_offset;
9936 } else {
9937 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9938 inner_depth.increment()?;
9939 }
9940 let val_ref =
9941 self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
9942 fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
9943 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9944 {
9945 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9946 }
9947 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9948 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9949 }
9950 }
9951
9952 next_offset += envelope_size;
9953 _next_ordinal_to_read += 1;
9954 if next_offset >= end_offset {
9955 return Ok(());
9956 }
9957
9958 while _next_ordinal_to_read < 2 {
9960 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9961 _next_ordinal_to_read += 1;
9962 next_offset += envelope_size;
9963 }
9964
9965 let next_out_of_line = decoder.next_out_of_line();
9966 let handles_before = decoder.remaining_handles();
9967 if let Some((inlined, num_bytes, num_handles)) =
9968 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9969 {
9970 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9971 if inlined != (member_inline_size <= 4) {
9972 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9973 }
9974 let inner_offset;
9975 let mut inner_depth = depth.clone();
9976 if inlined {
9977 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9978 inner_offset = next_offset;
9979 } else {
9980 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9981 inner_depth.increment()?;
9982 }
9983 let val_ref = self.moniker.get_or_insert_with(|| {
9984 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
9985 });
9986 fidl::decode!(
9987 fidl::encoding::BoundedString<4096>,
9988 D,
9989 val_ref,
9990 decoder,
9991 inner_offset,
9992 inner_depth
9993 )?;
9994 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9995 {
9996 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9997 }
9998 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9999 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10000 }
10001 }
10002
10003 next_offset += envelope_size;
10004
10005 while next_offset < end_offset {
10007 _next_ordinal_to_read += 1;
10008 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10009 next_offset += envelope_size;
10010 }
10011
10012 Ok(())
10013 }
10014 }
10015
10016 impl fidl::encoding::ValueTypeMarker for AggregateCapability {
10017 type Borrowed<'a> = &'a Self;
10018 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10019 value
10020 }
10021 }
10022
10023 unsafe impl fidl::encoding::TypeMarker for AggregateCapability {
10024 type Owned = Self;
10025
10026 #[inline(always)]
10027 fn inline_align(_context: fidl::encoding::Context) -> usize {
10028 8
10029 }
10030
10031 #[inline(always)]
10032 fn inline_size(_context: fidl::encoding::Context) -> usize {
10033 16
10034 }
10035 }
10036
10037 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AggregateCapability, D>
10038 for &AggregateCapability
10039 {
10040 #[inline]
10041 unsafe fn encode(
10042 self,
10043 encoder: &mut fidl::encoding::Encoder<'_, D>,
10044 offset: usize,
10045 _depth: fidl::encoding::Depth,
10046 ) -> fidl::Result<()> {
10047 encoder.debug_check_bounds::<AggregateCapability>(offset);
10048 encoder.write_num::<u64>(self.ordinal(), offset);
10049 match self {
10050 AggregateCapability::Service(ref val) => fidl::encoding::encode_in_envelope::<
10051 fidl::encoding::BoundedString<100>,
10052 D,
10053 >(
10054 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
10055 val,
10056 ),
10057 encoder,
10058 offset + 8,
10059 _depth,
10060 ),
10061 }
10062 }
10063 }
10064
10065 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AggregateCapability {
10066 #[inline(always)]
10067 fn new_empty() -> Self {
10068 Self::Service(fidl::new_empty!(fidl::encoding::BoundedString<100>, D))
10069 }
10070
10071 #[inline]
10072 unsafe fn decode(
10073 &mut self,
10074 decoder: &mut fidl::encoding::Decoder<'_, D>,
10075 offset: usize,
10076 mut depth: fidl::encoding::Depth,
10077 ) -> fidl::Result<()> {
10078 decoder.debug_check_bounds::<Self>(offset);
10079 #[allow(unused_variables)]
10080 let next_out_of_line = decoder.next_out_of_line();
10081 let handles_before = decoder.remaining_handles();
10082 let (ordinal, inlined, num_bytes, num_handles) =
10083 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10084
10085 let member_inline_size = match ordinal {
10086 1 => {
10087 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
10088 decoder.context,
10089 )
10090 }
10091 _ => return Err(fidl::Error::UnknownUnionTag),
10092 };
10093
10094 if inlined != (member_inline_size <= 4) {
10095 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10096 }
10097 let _inner_offset;
10098 if inlined {
10099 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10100 _inner_offset = offset + 8;
10101 } else {
10102 depth.increment()?;
10103 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10104 }
10105 match ordinal {
10106 1 => {
10107 #[allow(irrefutable_let_patterns)]
10108 if let AggregateCapability::Service(_) = self {
10109 } else {
10111 *self = AggregateCapability::Service(fidl::new_empty!(
10113 fidl::encoding::BoundedString<100>,
10114 D
10115 ));
10116 }
10117 #[allow(irrefutable_let_patterns)]
10118 if let AggregateCapability::Service(ref mut val) = self {
10119 fidl::decode!(
10120 fidl::encoding::BoundedString<100>,
10121 D,
10122 val,
10123 decoder,
10124 _inner_offset,
10125 depth
10126 )?;
10127 } else {
10128 unreachable!()
10129 }
10130 }
10131 ordinal => panic!("unexpected ordinal {:?}", ordinal),
10132 }
10133 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10134 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10135 }
10136 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10137 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10138 }
10139 Ok(())
10140 }
10141 }
10142
10143 impl fidl::encoding::ValueTypeMarker for AggregateMember {
10144 type Borrowed<'a> = &'a Self;
10145 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10146 value
10147 }
10148 }
10149
10150 unsafe impl fidl::encoding::TypeMarker for AggregateMember {
10151 type Owned = Self;
10152
10153 #[inline(always)]
10154 fn inline_align(_context: fidl::encoding::Context) -> usize {
10155 8
10156 }
10157
10158 #[inline(always)]
10159 fn inline_size(_context: fidl::encoding::Context) -> usize {
10160 16
10161 }
10162 }
10163
10164 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AggregateMember, D>
10165 for &AggregateMember
10166 {
10167 #[inline]
10168 unsafe fn encode(
10169 self,
10170 encoder: &mut fidl::encoding::Encoder<'_, D>,
10171 offset: usize,
10172 _depth: fidl::encoding::Depth,
10173 ) -> fidl::Result<()> {
10174 encoder.debug_check_bounds::<AggregateMember>(offset);
10175 encoder.write_num::<u64>(self.ordinal(), offset);
10176 match self {
10177 AggregateMember::Child(ref val) => {
10178 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::ChildRef, D>(
10179 <fidl_fuchsia_component_decl__common::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(val),
10180 encoder, offset + 8, _depth
10181 )
10182 }
10183 AggregateMember::Collection(ref val) => {
10184 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<100>, D>(
10185 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(val),
10186 encoder, offset + 8, _depth
10187 )
10188 }
10189 AggregateMember::Parent(ref val) => {
10190 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::ParentRef, D>(
10191 <fidl_fuchsia_component_decl__common::ParentRef as fidl::encoding::ValueTypeMarker>::borrow(val),
10192 encoder, offset + 8, _depth
10193 )
10194 }
10195 AggregateMember::Self_(ref val) => {
10196 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::SelfRef, D>(
10197 <fidl_fuchsia_component_decl__common::SelfRef as fidl::encoding::ValueTypeMarker>::borrow(val),
10198 encoder, offset + 8, _depth
10199 )
10200 }
10201 }
10202 }
10203 }
10204
10205 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AggregateMember {
10206 #[inline(always)]
10207 fn new_empty() -> Self {
10208 Self::Child(fidl::new_empty!(fidl_fuchsia_component_decl__common::ChildRef, D))
10209 }
10210
10211 #[inline]
10212 unsafe fn decode(
10213 &mut self,
10214 decoder: &mut fidl::encoding::Decoder<'_, D>,
10215 offset: usize,
10216 mut depth: fidl::encoding::Depth,
10217 ) -> fidl::Result<()> {
10218 decoder.debug_check_bounds::<Self>(offset);
10219 #[allow(unused_variables)]
10220 let next_out_of_line = decoder.next_out_of_line();
10221 let handles_before = decoder.remaining_handles();
10222 let (ordinal, inlined, num_bytes, num_handles) =
10223 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10224
10225 let member_inline_size = match ordinal {
10226 1 => <fidl_fuchsia_component_decl__common::ChildRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10227 2 => <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10228 3 => <fidl_fuchsia_component_decl__common::ParentRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10229 4 => <fidl_fuchsia_component_decl__common::SelfRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10230 _ => return Err(fidl::Error::UnknownUnionTag),
10231 };
10232
10233 if inlined != (member_inline_size <= 4) {
10234 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10235 }
10236 let _inner_offset;
10237 if inlined {
10238 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10239 _inner_offset = offset + 8;
10240 } else {
10241 depth.increment()?;
10242 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10243 }
10244 match ordinal {
10245 1 => {
10246 #[allow(irrefutable_let_patterns)]
10247 if let AggregateMember::Child(_) = self {
10248 } else {
10250 *self = AggregateMember::Child(fidl::new_empty!(
10252 fidl_fuchsia_component_decl__common::ChildRef,
10253 D
10254 ));
10255 }
10256 #[allow(irrefutable_let_patterns)]
10257 if let AggregateMember::Child(ref mut val) = self {
10258 fidl::decode!(
10259 fidl_fuchsia_component_decl__common::ChildRef,
10260 D,
10261 val,
10262 decoder,
10263 _inner_offset,
10264 depth
10265 )?;
10266 } else {
10267 unreachable!()
10268 }
10269 }
10270 2 => {
10271 #[allow(irrefutable_let_patterns)]
10272 if let AggregateMember::Collection(_) = self {
10273 } else {
10275 *self = AggregateMember::Collection(fidl::new_empty!(
10277 fidl::encoding::BoundedString<100>,
10278 D
10279 ));
10280 }
10281 #[allow(irrefutable_let_patterns)]
10282 if let AggregateMember::Collection(ref mut val) = self {
10283 fidl::decode!(
10284 fidl::encoding::BoundedString<100>,
10285 D,
10286 val,
10287 decoder,
10288 _inner_offset,
10289 depth
10290 )?;
10291 } else {
10292 unreachable!()
10293 }
10294 }
10295 3 => {
10296 #[allow(irrefutable_let_patterns)]
10297 if let AggregateMember::Parent(_) = self {
10298 } else {
10300 *self = AggregateMember::Parent(fidl::new_empty!(
10302 fidl_fuchsia_component_decl__common::ParentRef,
10303 D
10304 ));
10305 }
10306 #[allow(irrefutable_let_patterns)]
10307 if let AggregateMember::Parent(ref mut val) = self {
10308 fidl::decode!(
10309 fidl_fuchsia_component_decl__common::ParentRef,
10310 D,
10311 val,
10312 decoder,
10313 _inner_offset,
10314 depth
10315 )?;
10316 } else {
10317 unreachable!()
10318 }
10319 }
10320 4 => {
10321 #[allow(irrefutable_let_patterns)]
10322 if let AggregateMember::Self_(_) = self {
10323 } else {
10325 *self = AggregateMember::Self_(fidl::new_empty!(
10327 fidl_fuchsia_component_decl__common::SelfRef,
10328 D
10329 ));
10330 }
10331 #[allow(irrefutable_let_patterns)]
10332 if let AggregateMember::Self_(ref mut val) = self {
10333 fidl::decode!(
10334 fidl_fuchsia_component_decl__common::SelfRef,
10335 D,
10336 val,
10337 decoder,
10338 _inner_offset,
10339 depth
10340 )?;
10341 } else {
10342 unreachable!()
10343 }
10344 }
10345 ordinal => panic!("unexpected ordinal {:?}", ordinal),
10346 }
10347 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10348 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10349 }
10350 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10351 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10352 }
10353 Ok(())
10354 }
10355 }
10356
10357 impl fidl::encoding::ValueTypeMarker for AllowlistedCapability {
10358 type Borrowed<'a> = &'a Self;
10359 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10360 value
10361 }
10362 }
10363
10364 unsafe impl fidl::encoding::TypeMarker for AllowlistedCapability {
10365 type Owned = Self;
10366
10367 #[inline(always)]
10368 fn inline_align(_context: fidl::encoding::Context) -> usize {
10369 8
10370 }
10371
10372 #[inline(always)]
10373 fn inline_size(_context: fidl::encoding::Context) -> usize {
10374 16
10375 }
10376 }
10377
10378 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedCapability, D>
10379 for &AllowlistedCapability
10380 {
10381 #[inline]
10382 unsafe fn encode(
10383 self,
10384 encoder: &mut fidl::encoding::Encoder<'_, D>,
10385 offset: usize,
10386 _depth: fidl::encoding::Depth,
10387 ) -> fidl::Result<()> {
10388 encoder.debug_check_bounds::<AllowlistedCapability>(offset);
10389 encoder.write_num::<u64>(self.ordinal(), offset);
10390 match self {
10391 AllowlistedCapability::Directory(ref val) => {
10392 fidl::encoding::encode_in_envelope::<AllowlistedDirectory, D>(
10393 <AllowlistedDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
10394 encoder,
10395 offset + 8,
10396 _depth,
10397 )
10398 }
10399 AllowlistedCapability::Protocol(ref val) => {
10400 fidl::encoding::encode_in_envelope::<AllowlistedProtocol, D>(
10401 <AllowlistedProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
10402 encoder,
10403 offset + 8,
10404 _depth,
10405 )
10406 }
10407 AllowlistedCapability::Service(ref val) => {
10408 fidl::encoding::encode_in_envelope::<AllowlistedService, D>(
10409 <AllowlistedService as fidl::encoding::ValueTypeMarker>::borrow(val),
10410 encoder,
10411 offset + 8,
10412 _depth,
10413 )
10414 }
10415 AllowlistedCapability::Storage(ref val) => {
10416 fidl::encoding::encode_in_envelope::<AllowlistedStorage, D>(
10417 <AllowlistedStorage as fidl::encoding::ValueTypeMarker>::borrow(val),
10418 encoder,
10419 offset + 8,
10420 _depth,
10421 )
10422 }
10423 AllowlistedCapability::Runner(ref val) => {
10424 fidl::encoding::encode_in_envelope::<AllowlistedRunner, D>(
10425 <AllowlistedRunner as fidl::encoding::ValueTypeMarker>::borrow(val),
10426 encoder,
10427 offset + 8,
10428 _depth,
10429 )
10430 }
10431 AllowlistedCapability::Resolver(ref val) => {
10432 fidl::encoding::encode_in_envelope::<AllowlistedResolver, D>(
10433 <AllowlistedResolver as fidl::encoding::ValueTypeMarker>::borrow(val),
10434 encoder,
10435 offset + 8,
10436 _depth,
10437 )
10438 }
10439 AllowlistedCapability::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
10440 }
10441 }
10442 }
10443
10444 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedCapability {
10445 #[inline(always)]
10446 fn new_empty() -> Self {
10447 Self::__SourceBreaking { unknown_ordinal: 0 }
10448 }
10449
10450 #[inline]
10451 unsafe fn decode(
10452 &mut self,
10453 decoder: &mut fidl::encoding::Decoder<'_, D>,
10454 offset: usize,
10455 mut depth: fidl::encoding::Depth,
10456 ) -> fidl::Result<()> {
10457 decoder.debug_check_bounds::<Self>(offset);
10458 #[allow(unused_variables)]
10459 let next_out_of_line = decoder.next_out_of_line();
10460 let handles_before = decoder.remaining_handles();
10461 let (ordinal, inlined, num_bytes, num_handles) =
10462 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10463
10464 let member_inline_size = match ordinal {
10465 1 => <AllowlistedDirectory as fidl::encoding::TypeMarker>::inline_size(
10466 decoder.context,
10467 ),
10468 3 => <AllowlistedProtocol as fidl::encoding::TypeMarker>::inline_size(
10469 decoder.context,
10470 ),
10471 4 => {
10472 <AllowlistedService as fidl::encoding::TypeMarker>::inline_size(decoder.context)
10473 }
10474 5 => {
10475 <AllowlistedStorage as fidl::encoding::TypeMarker>::inline_size(decoder.context)
10476 }
10477 6 => {
10478 <AllowlistedRunner as fidl::encoding::TypeMarker>::inline_size(decoder.context)
10479 }
10480 7 => <AllowlistedResolver as fidl::encoding::TypeMarker>::inline_size(
10481 decoder.context,
10482 ),
10483 0 => return Err(fidl::Error::UnknownUnionTag),
10484 _ => num_bytes as usize,
10485 };
10486
10487 if inlined != (member_inline_size <= 4) {
10488 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10489 }
10490 let _inner_offset;
10491 if inlined {
10492 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10493 _inner_offset = offset + 8;
10494 } else {
10495 depth.increment()?;
10496 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10497 }
10498 match ordinal {
10499 1 => {
10500 #[allow(irrefutable_let_patterns)]
10501 if let AllowlistedCapability::Directory(_) = self {
10502 } else {
10504 *self = AllowlistedCapability::Directory(fidl::new_empty!(
10506 AllowlistedDirectory,
10507 D
10508 ));
10509 }
10510 #[allow(irrefutable_let_patterns)]
10511 if let AllowlistedCapability::Directory(ref mut val) = self {
10512 fidl::decode!(AllowlistedDirectory, D, val, decoder, _inner_offset, depth)?;
10513 } else {
10514 unreachable!()
10515 }
10516 }
10517 3 => {
10518 #[allow(irrefutable_let_patterns)]
10519 if let AllowlistedCapability::Protocol(_) = self {
10520 } else {
10522 *self = AllowlistedCapability::Protocol(fidl::new_empty!(
10524 AllowlistedProtocol,
10525 D
10526 ));
10527 }
10528 #[allow(irrefutable_let_patterns)]
10529 if let AllowlistedCapability::Protocol(ref mut val) = self {
10530 fidl::decode!(AllowlistedProtocol, D, val, decoder, _inner_offset, depth)?;
10531 } else {
10532 unreachable!()
10533 }
10534 }
10535 4 => {
10536 #[allow(irrefutable_let_patterns)]
10537 if let AllowlistedCapability::Service(_) = self {
10538 } else {
10540 *self =
10542 AllowlistedCapability::Service(fidl::new_empty!(AllowlistedService, D));
10543 }
10544 #[allow(irrefutable_let_patterns)]
10545 if let AllowlistedCapability::Service(ref mut val) = self {
10546 fidl::decode!(AllowlistedService, D, val, decoder, _inner_offset, depth)?;
10547 } else {
10548 unreachable!()
10549 }
10550 }
10551 5 => {
10552 #[allow(irrefutable_let_patterns)]
10553 if let AllowlistedCapability::Storage(_) = self {
10554 } else {
10556 *self =
10558 AllowlistedCapability::Storage(fidl::new_empty!(AllowlistedStorage, D));
10559 }
10560 #[allow(irrefutable_let_patterns)]
10561 if let AllowlistedCapability::Storage(ref mut val) = self {
10562 fidl::decode!(AllowlistedStorage, D, val, decoder, _inner_offset, depth)?;
10563 } else {
10564 unreachable!()
10565 }
10566 }
10567 6 => {
10568 #[allow(irrefutable_let_patterns)]
10569 if let AllowlistedCapability::Runner(_) = self {
10570 } else {
10572 *self =
10574 AllowlistedCapability::Runner(fidl::new_empty!(AllowlistedRunner, D));
10575 }
10576 #[allow(irrefutable_let_patterns)]
10577 if let AllowlistedCapability::Runner(ref mut val) = self {
10578 fidl::decode!(AllowlistedRunner, D, val, decoder, _inner_offset, depth)?;
10579 } else {
10580 unreachable!()
10581 }
10582 }
10583 7 => {
10584 #[allow(irrefutable_let_patterns)]
10585 if let AllowlistedCapability::Resolver(_) = self {
10586 } else {
10588 *self = AllowlistedCapability::Resolver(fidl::new_empty!(
10590 AllowlistedResolver,
10591 D
10592 ));
10593 }
10594 #[allow(irrefutable_let_patterns)]
10595 if let AllowlistedCapability::Resolver(ref mut val) = self {
10596 fidl::decode!(AllowlistedResolver, D, val, decoder, _inner_offset, depth)?;
10597 } else {
10598 unreachable!()
10599 }
10600 }
10601 #[allow(deprecated)]
10602 ordinal => {
10603 for _ in 0..num_handles {
10604 decoder.drop_next_handle()?;
10605 }
10606 *self = AllowlistedCapability::__SourceBreaking { unknown_ordinal: ordinal };
10607 }
10608 }
10609 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10610 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10611 }
10612 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10613 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10614 }
10615 Ok(())
10616 }
10617 }
10618
10619 impl fidl::encoding::ValueTypeMarker for AllowlistedDebugRegistration {
10620 type Borrowed<'a> = &'a Self;
10621 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10622 value
10623 }
10624 }
10625
10626 unsafe impl fidl::encoding::TypeMarker for AllowlistedDebugRegistration {
10627 type Owned = Self;
10628
10629 #[inline(always)]
10630 fn inline_align(_context: fidl::encoding::Context) -> usize {
10631 8
10632 }
10633
10634 #[inline(always)]
10635 fn inline_size(_context: fidl::encoding::Context) -> usize {
10636 16
10637 }
10638 }
10639
10640 unsafe impl<D: fidl::encoding::ResourceDialect>
10641 fidl::encoding::Encode<AllowlistedDebugRegistration, D> for &AllowlistedDebugRegistration
10642 {
10643 #[inline]
10644 unsafe fn encode(
10645 self,
10646 encoder: &mut fidl::encoding::Encoder<'_, D>,
10647 offset: usize,
10648 _depth: fidl::encoding::Depth,
10649 ) -> fidl::Result<()> {
10650 encoder.debug_check_bounds::<AllowlistedDebugRegistration>(offset);
10651 encoder.write_num::<u64>(self.ordinal(), offset);
10652 match self {
10653 AllowlistedDebugRegistration::Protocol(ref val) => {
10654 fidl::encoding::encode_in_envelope::<AllowlistedProtocol, D>(
10655 <AllowlistedProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
10656 encoder,
10657 offset + 8,
10658 _depth,
10659 )
10660 }
10661 AllowlistedDebugRegistration::__SourceBreaking { .. } => {
10662 Err(fidl::Error::UnknownUnionTag)
10663 }
10664 }
10665 }
10666 }
10667
10668 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10669 for AllowlistedDebugRegistration
10670 {
10671 #[inline(always)]
10672 fn new_empty() -> Self {
10673 Self::__SourceBreaking { unknown_ordinal: 0 }
10674 }
10675
10676 #[inline]
10677 unsafe fn decode(
10678 &mut self,
10679 decoder: &mut fidl::encoding::Decoder<'_, D>,
10680 offset: usize,
10681 mut depth: fidl::encoding::Depth,
10682 ) -> fidl::Result<()> {
10683 decoder.debug_check_bounds::<Self>(offset);
10684 #[allow(unused_variables)]
10685 let next_out_of_line = decoder.next_out_of_line();
10686 let handles_before = decoder.remaining_handles();
10687 let (ordinal, inlined, num_bytes, num_handles) =
10688 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10689
10690 let member_inline_size = match ordinal {
10691 1 => <AllowlistedProtocol as fidl::encoding::TypeMarker>::inline_size(
10692 decoder.context,
10693 ),
10694 0 => return Err(fidl::Error::UnknownUnionTag),
10695 _ => num_bytes as usize,
10696 };
10697
10698 if inlined != (member_inline_size <= 4) {
10699 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10700 }
10701 let _inner_offset;
10702 if inlined {
10703 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10704 _inner_offset = offset + 8;
10705 } else {
10706 depth.increment()?;
10707 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10708 }
10709 match ordinal {
10710 1 => {
10711 #[allow(irrefutable_let_patterns)]
10712 if let AllowlistedDebugRegistration::Protocol(_) = self {
10713 } else {
10715 *self = AllowlistedDebugRegistration::Protocol(fidl::new_empty!(
10717 AllowlistedProtocol,
10718 D
10719 ));
10720 }
10721 #[allow(irrefutable_let_patterns)]
10722 if let AllowlistedDebugRegistration::Protocol(ref mut val) = self {
10723 fidl::decode!(AllowlistedProtocol, D, val, decoder, _inner_offset, depth)?;
10724 } else {
10725 unreachable!()
10726 }
10727 }
10728 #[allow(deprecated)]
10729 ordinal => {
10730 for _ in 0..num_handles {
10731 decoder.drop_next_handle()?;
10732 }
10733 *self =
10734 AllowlistedDebugRegistration::__SourceBreaking { unknown_ordinal: ordinal };
10735 }
10736 }
10737 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10738 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10739 }
10740 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10741 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10742 }
10743 Ok(())
10744 }
10745 }
10746
10747 impl fidl::encoding::ValueTypeMarker for CapabilitySource {
10748 type Borrowed<'a> = &'a Self;
10749 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10750 value
10751 }
10752 }
10753
10754 unsafe impl fidl::encoding::TypeMarker for CapabilitySource {
10755 type Owned = Self;
10756
10757 #[inline(always)]
10758 fn inline_align(_context: fidl::encoding::Context) -> usize {
10759 8
10760 }
10761
10762 #[inline(always)]
10763 fn inline_size(_context: fidl::encoding::Context) -> usize {
10764 16
10765 }
10766 }
10767
10768 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CapabilitySource, D>
10769 for &CapabilitySource
10770 {
10771 #[inline]
10772 unsafe fn encode(
10773 self,
10774 encoder: &mut fidl::encoding::Encoder<'_, D>,
10775 offset: usize,
10776 _depth: fidl::encoding::Depth,
10777 ) -> fidl::Result<()> {
10778 encoder.debug_check_bounds::<CapabilitySource>(offset);
10779 encoder.write_num::<u64>(self.ordinal(), offset);
10780 match self {
10781 CapabilitySource::Component(ref val) => {
10782 fidl::encoding::encode_in_envelope::<Component, D>(
10783 <Component as fidl::encoding::ValueTypeMarker>::borrow(val),
10784 encoder,
10785 offset + 8,
10786 _depth,
10787 )
10788 }
10789 CapabilitySource::Framework(ref val) => {
10790 fidl::encoding::encode_in_envelope::<Framework, D>(
10791 <Framework as fidl::encoding::ValueTypeMarker>::borrow(val),
10792 encoder,
10793 offset + 8,
10794 _depth,
10795 )
10796 }
10797 CapabilitySource::Builtin(ref val) => {
10798 fidl::encoding::encode_in_envelope::<Builtin, D>(
10799 <Builtin as fidl::encoding::ValueTypeMarker>::borrow(val),
10800 encoder,
10801 offset + 8,
10802 _depth,
10803 )
10804 }
10805 CapabilitySource::Namespace(ref val) => {
10806 fidl::encoding::encode_in_envelope::<Namespace, D>(
10807 <Namespace as fidl::encoding::ValueTypeMarker>::borrow(val),
10808 encoder,
10809 offset + 8,
10810 _depth,
10811 )
10812 }
10813 CapabilitySource::Capability(ref val) => {
10814 fidl::encoding::encode_in_envelope::<Capability, D>(
10815 <Capability as fidl::encoding::ValueTypeMarker>::borrow(val),
10816 encoder,
10817 offset + 8,
10818 _depth,
10819 )
10820 }
10821 CapabilitySource::AnonymizedAggregate(ref val) => {
10822 fidl::encoding::encode_in_envelope::<AnonymizedAggregate, D>(
10823 <AnonymizedAggregate as fidl::encoding::ValueTypeMarker>::borrow(val),
10824 encoder,
10825 offset + 8,
10826 _depth,
10827 )
10828 }
10829 CapabilitySource::FilteredProvider(ref val) => {
10830 fidl::encoding::encode_in_envelope::<FilteredProvider, D>(
10831 <FilteredProvider as fidl::encoding::ValueTypeMarker>::borrow(val),
10832 encoder,
10833 offset + 8,
10834 _depth,
10835 )
10836 }
10837 CapabilitySource::FilteredAggregateProvider(ref val) => {
10838 fidl::encoding::encode_in_envelope::<FilteredAggregateProvider, D>(
10839 <FilteredAggregateProvider as fidl::encoding::ValueTypeMarker>::borrow(val),
10840 encoder,
10841 offset + 8,
10842 _depth,
10843 )
10844 }
10845 CapabilitySource::Environment(ref val) => {
10846 fidl::encoding::encode_in_envelope::<Environment, D>(
10847 <Environment as fidl::encoding::ValueTypeMarker>::borrow(val),
10848 encoder,
10849 offset + 8,
10850 _depth,
10851 )
10852 }
10853 CapabilitySource::Void(ref val) => fidl::encoding::encode_in_envelope::<Void, D>(
10854 <Void as fidl::encoding::ValueTypeMarker>::borrow(val),
10855 encoder,
10856 offset + 8,
10857 _depth,
10858 ),
10859 }
10860 }
10861 }
10862
10863 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CapabilitySource {
10864 #[inline(always)]
10865 fn new_empty() -> Self {
10866 Self::Component(fidl::new_empty!(Component, D))
10867 }
10868
10869 #[inline]
10870 unsafe fn decode(
10871 &mut self,
10872 decoder: &mut fidl::encoding::Decoder<'_, D>,
10873 offset: usize,
10874 mut depth: fidl::encoding::Depth,
10875 ) -> fidl::Result<()> {
10876 decoder.debug_check_bounds::<Self>(offset);
10877 #[allow(unused_variables)]
10878 let next_out_of_line = decoder.next_out_of_line();
10879 let handles_before = decoder.remaining_handles();
10880 let (ordinal, inlined, num_bytes, num_handles) =
10881 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10882
10883 let member_inline_size = match ordinal {
10884 1 => <Component as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10885 2 => <Framework as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10886 3 => <Builtin as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10887 4 => <Namespace as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10888 5 => <Capability as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10889 6 => <AnonymizedAggregate as fidl::encoding::TypeMarker>::inline_size(
10890 decoder.context,
10891 ),
10892 7 => <FilteredProvider as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10893 8 => <FilteredAggregateProvider as fidl::encoding::TypeMarker>::inline_size(
10894 decoder.context,
10895 ),
10896 9 => <Environment as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10897 10 => <Void as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10898 _ => return Err(fidl::Error::UnknownUnionTag),
10899 };
10900
10901 if inlined != (member_inline_size <= 4) {
10902 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10903 }
10904 let _inner_offset;
10905 if inlined {
10906 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10907 _inner_offset = offset + 8;
10908 } else {
10909 depth.increment()?;
10910 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10911 }
10912 match ordinal {
10913 1 => {
10914 #[allow(irrefutable_let_patterns)]
10915 if let CapabilitySource::Component(_) = self {
10916 } else {
10918 *self = CapabilitySource::Component(fidl::new_empty!(Component, D));
10920 }
10921 #[allow(irrefutable_let_patterns)]
10922 if let CapabilitySource::Component(ref mut val) = self {
10923 fidl::decode!(Component, D, val, decoder, _inner_offset, depth)?;
10924 } else {
10925 unreachable!()
10926 }
10927 }
10928 2 => {
10929 #[allow(irrefutable_let_patterns)]
10930 if let CapabilitySource::Framework(_) = self {
10931 } else {
10933 *self = CapabilitySource::Framework(fidl::new_empty!(Framework, D));
10935 }
10936 #[allow(irrefutable_let_patterns)]
10937 if let CapabilitySource::Framework(ref mut val) = self {
10938 fidl::decode!(Framework, D, val, decoder, _inner_offset, depth)?;
10939 } else {
10940 unreachable!()
10941 }
10942 }
10943 3 => {
10944 #[allow(irrefutable_let_patterns)]
10945 if let CapabilitySource::Builtin(_) = self {
10946 } else {
10948 *self = CapabilitySource::Builtin(fidl::new_empty!(Builtin, D));
10950 }
10951 #[allow(irrefutable_let_patterns)]
10952 if let CapabilitySource::Builtin(ref mut val) = self {
10953 fidl::decode!(Builtin, D, val, decoder, _inner_offset, depth)?;
10954 } else {
10955 unreachable!()
10956 }
10957 }
10958 4 => {
10959 #[allow(irrefutable_let_patterns)]
10960 if let CapabilitySource::Namespace(_) = self {
10961 } else {
10963 *self = CapabilitySource::Namespace(fidl::new_empty!(Namespace, D));
10965 }
10966 #[allow(irrefutable_let_patterns)]
10967 if let CapabilitySource::Namespace(ref mut val) = self {
10968 fidl::decode!(Namespace, D, val, decoder, _inner_offset, depth)?;
10969 } else {
10970 unreachable!()
10971 }
10972 }
10973 5 => {
10974 #[allow(irrefutable_let_patterns)]
10975 if let CapabilitySource::Capability(_) = self {
10976 } else {
10978 *self = CapabilitySource::Capability(fidl::new_empty!(Capability, D));
10980 }
10981 #[allow(irrefutable_let_patterns)]
10982 if let CapabilitySource::Capability(ref mut val) = self {
10983 fidl::decode!(Capability, D, val, decoder, _inner_offset, depth)?;
10984 } else {
10985 unreachable!()
10986 }
10987 }
10988 6 => {
10989 #[allow(irrefutable_let_patterns)]
10990 if let CapabilitySource::AnonymizedAggregate(_) = self {
10991 } else {
10993 *self = CapabilitySource::AnonymizedAggregate(fidl::new_empty!(
10995 AnonymizedAggregate,
10996 D
10997 ));
10998 }
10999 #[allow(irrefutable_let_patterns)]
11000 if let CapabilitySource::AnonymizedAggregate(ref mut val) = self {
11001 fidl::decode!(AnonymizedAggregate, D, val, decoder, _inner_offset, depth)?;
11002 } else {
11003 unreachable!()
11004 }
11005 }
11006 7 => {
11007 #[allow(irrefutable_let_patterns)]
11008 if let CapabilitySource::FilteredProvider(_) = self {
11009 } else {
11011 *self = CapabilitySource::FilteredProvider(fidl::new_empty!(
11013 FilteredProvider,
11014 D
11015 ));
11016 }
11017 #[allow(irrefutable_let_patterns)]
11018 if let CapabilitySource::FilteredProvider(ref mut val) = self {
11019 fidl::decode!(FilteredProvider, D, val, decoder, _inner_offset, depth)?;
11020 } else {
11021 unreachable!()
11022 }
11023 }
11024 8 => {
11025 #[allow(irrefutable_let_patterns)]
11026 if let CapabilitySource::FilteredAggregateProvider(_) = self {
11027 } else {
11029 *self = CapabilitySource::FilteredAggregateProvider(fidl::new_empty!(
11031 FilteredAggregateProvider,
11032 D
11033 ));
11034 }
11035 #[allow(irrefutable_let_patterns)]
11036 if let CapabilitySource::FilteredAggregateProvider(ref mut val) = self {
11037 fidl::decode!(
11038 FilteredAggregateProvider,
11039 D,
11040 val,
11041 decoder,
11042 _inner_offset,
11043 depth
11044 )?;
11045 } else {
11046 unreachable!()
11047 }
11048 }
11049 9 => {
11050 #[allow(irrefutable_let_patterns)]
11051 if let CapabilitySource::Environment(_) = self {
11052 } else {
11054 *self = CapabilitySource::Environment(fidl::new_empty!(Environment, D));
11056 }
11057 #[allow(irrefutable_let_patterns)]
11058 if let CapabilitySource::Environment(ref mut val) = self {
11059 fidl::decode!(Environment, D, val, decoder, _inner_offset, depth)?;
11060 } else {
11061 unreachable!()
11062 }
11063 }
11064 10 => {
11065 #[allow(irrefutable_let_patterns)]
11066 if let CapabilitySource::Void(_) = self {
11067 } else {
11069 *self = CapabilitySource::Void(fidl::new_empty!(Void, D));
11071 }
11072 #[allow(irrefutable_let_patterns)]
11073 if let CapabilitySource::Void(ref mut val) = self {
11074 fidl::decode!(Void, D, val, decoder, _inner_offset, depth)?;
11075 } else {
11076 unreachable!()
11077 }
11078 }
11079 ordinal => panic!("unexpected ordinal {:?}", ordinal),
11080 }
11081 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11082 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11083 }
11084 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11085 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11086 }
11087 Ok(())
11088 }
11089 }
11090
11091 impl fidl::encoding::ValueTypeMarker for ComponentCapability {
11092 type Borrowed<'a> = &'a Self;
11093 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11094 value
11095 }
11096 }
11097
11098 unsafe impl fidl::encoding::TypeMarker for ComponentCapability {
11099 type Owned = Self;
11100
11101 #[inline(always)]
11102 fn inline_align(_context: fidl::encoding::Context) -> usize {
11103 8
11104 }
11105
11106 #[inline(always)]
11107 fn inline_size(_context: fidl::encoding::Context) -> usize {
11108 16
11109 }
11110 }
11111
11112 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentCapability, D>
11113 for &ComponentCapability
11114 {
11115 #[inline]
11116 unsafe fn encode(
11117 self,
11118 encoder: &mut fidl::encoding::Encoder<'_, D>,
11119 offset: usize,
11120 _depth: fidl::encoding::Depth,
11121 ) -> fidl::Result<()> {
11122 encoder.debug_check_bounds::<ComponentCapability>(offset);
11123 encoder.write_num::<u64>(self.ordinal(), offset);
11124 match self {
11125 ComponentCapability::Use_(ref val) => {
11126 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Use, D>(
11127 <fidl_fuchsia_component_decl__common::Use as fidl::encoding::ValueTypeMarker>::borrow(val),
11128 encoder, offset + 8, _depth
11129 )
11130 }
11131 ComponentCapability::Offer(ref val) => {
11132 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Offer, D>(
11133 <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::ValueTypeMarker>::borrow(val),
11134 encoder, offset + 8, _depth
11135 )
11136 }
11137 ComponentCapability::Expose(ref val) => {
11138 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Expose, D>(
11139 <fidl_fuchsia_component_decl__common::Expose as fidl::encoding::ValueTypeMarker>::borrow(val),
11140 encoder, offset + 8, _depth
11141 )
11142 }
11143 ComponentCapability::Config(ref val) => {
11144 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Configuration, D>(
11145 <fidl_fuchsia_component_decl__common::Configuration as fidl::encoding::ValueTypeMarker>::borrow(val),
11146 encoder, offset + 8, _depth
11147 )
11148 }
11149 ComponentCapability::Dictionary(ref val) => {
11150 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Dictionary, D>(
11151 <fidl_fuchsia_component_decl__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
11152 encoder, offset + 8, _depth
11153 )
11154 }
11155 ComponentCapability::Directory(ref val) => {
11156 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Directory, D>(
11157 <fidl_fuchsia_component_decl__common::Directory as fidl::encoding::ValueTypeMarker>::borrow(val),
11158 encoder, offset + 8, _depth
11159 )
11160 }
11161 ComponentCapability::Environment(ref val) => {
11162 fidl::encoding::encode_in_envelope::<EnvironmentCapability, D>(
11163 <EnvironmentCapability as fidl::encoding::ValueTypeMarker>::borrow(val),
11164 encoder, offset + 8, _depth
11165 )
11166 }
11167 ComponentCapability::EventStream(ref val) => {
11168 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::EventStream, D>(
11169 <fidl_fuchsia_component_decl__common::EventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
11170 encoder, offset + 8, _depth
11171 )
11172 }
11173 ComponentCapability::Protocol(ref val) => {
11174 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Protocol, D>(
11175 <fidl_fuchsia_component_decl__common::Protocol as fidl::encoding::ValueTypeMarker>::borrow(val),
11176 encoder, offset + 8, _depth
11177 )
11178 }
11179 ComponentCapability::Resolver(ref val) => {
11180 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Resolver, D>(
11181 <fidl_fuchsia_component_decl__common::Resolver as fidl::encoding::ValueTypeMarker>::borrow(val),
11182 encoder, offset + 8, _depth
11183 )
11184 }
11185 ComponentCapability::Runner(ref val) => {
11186 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Runner, D>(
11187 <fidl_fuchsia_component_decl__common::Runner as fidl::encoding::ValueTypeMarker>::borrow(val),
11188 encoder, offset + 8, _depth
11189 )
11190 }
11191 ComponentCapability::Service(ref val) => {
11192 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Service, D>(
11193 <fidl_fuchsia_component_decl__common::Service as fidl::encoding::ValueTypeMarker>::borrow(val),
11194 encoder, offset + 8, _depth
11195 )
11196 }
11197 ComponentCapability::Storage(ref val) => {
11198 fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Storage, D>(
11199 <fidl_fuchsia_component_decl__common::Storage as fidl::encoding::ValueTypeMarker>::borrow(val),
11200 encoder, offset + 8, _depth
11201 )
11202 }
11203 }
11204 }
11205 }
11206
11207 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentCapability {
11208 #[inline(always)]
11209 fn new_empty() -> Self {
11210 Self::Use_(fidl::new_empty!(fidl_fuchsia_component_decl__common::Use, D))
11211 }
11212
11213 #[inline]
11214 unsafe fn decode(
11215 &mut self,
11216 decoder: &mut fidl::encoding::Decoder<'_, D>,
11217 offset: usize,
11218 mut depth: fidl::encoding::Depth,
11219 ) -> fidl::Result<()> {
11220 decoder.debug_check_bounds::<Self>(offset);
11221 #[allow(unused_variables)]
11222 let next_out_of_line = decoder.next_out_of_line();
11223 let handles_before = decoder.remaining_handles();
11224 let (ordinal, inlined, num_bytes, num_handles) =
11225 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11226
11227 let member_inline_size = match ordinal {
11228 1 => <fidl_fuchsia_component_decl__common::Use as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11229 2 => <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11230 3 => <fidl_fuchsia_component_decl__common::Expose as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11231 4 => <fidl_fuchsia_component_decl__common::Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11232 5 => <fidl_fuchsia_component_decl__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11233 6 => <fidl_fuchsia_component_decl__common::Directory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11234 7 => <EnvironmentCapability as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11235 8 => <fidl_fuchsia_component_decl__common::EventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11236 9 => <fidl_fuchsia_component_decl__common::Protocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11237 10 => <fidl_fuchsia_component_decl__common::Resolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11238 11 => <fidl_fuchsia_component_decl__common::Runner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11239 12 => <fidl_fuchsia_component_decl__common::Service as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11240 13 => <fidl_fuchsia_component_decl__common::Storage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11241 _ => return Err(fidl::Error::UnknownUnionTag),
11242 };
11243
11244 if inlined != (member_inline_size <= 4) {
11245 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11246 }
11247 let _inner_offset;
11248 if inlined {
11249 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11250 _inner_offset = offset + 8;
11251 } else {
11252 depth.increment()?;
11253 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11254 }
11255 match ordinal {
11256 1 => {
11257 #[allow(irrefutable_let_patterns)]
11258 if let ComponentCapability::Use_(_) = self {
11259 } else {
11261 *self = ComponentCapability::Use_(fidl::new_empty!(
11263 fidl_fuchsia_component_decl__common::Use,
11264 D
11265 ));
11266 }
11267 #[allow(irrefutable_let_patterns)]
11268 if let ComponentCapability::Use_(ref mut val) = self {
11269 fidl::decode!(
11270 fidl_fuchsia_component_decl__common::Use,
11271 D,
11272 val,
11273 decoder,
11274 _inner_offset,
11275 depth
11276 )?;
11277 } else {
11278 unreachable!()
11279 }
11280 }
11281 2 => {
11282 #[allow(irrefutable_let_patterns)]
11283 if let ComponentCapability::Offer(_) = self {
11284 } else {
11286 *self = ComponentCapability::Offer(fidl::new_empty!(
11288 fidl_fuchsia_component_decl__common::Offer,
11289 D
11290 ));
11291 }
11292 #[allow(irrefutable_let_patterns)]
11293 if let ComponentCapability::Offer(ref mut val) = self {
11294 fidl::decode!(
11295 fidl_fuchsia_component_decl__common::Offer,
11296 D,
11297 val,
11298 decoder,
11299 _inner_offset,
11300 depth
11301 )?;
11302 } else {
11303 unreachable!()
11304 }
11305 }
11306 3 => {
11307 #[allow(irrefutable_let_patterns)]
11308 if let ComponentCapability::Expose(_) = self {
11309 } else {
11311 *self = ComponentCapability::Expose(fidl::new_empty!(
11313 fidl_fuchsia_component_decl__common::Expose,
11314 D
11315 ));
11316 }
11317 #[allow(irrefutable_let_patterns)]
11318 if let ComponentCapability::Expose(ref mut val) = self {
11319 fidl::decode!(
11320 fidl_fuchsia_component_decl__common::Expose,
11321 D,
11322 val,
11323 decoder,
11324 _inner_offset,
11325 depth
11326 )?;
11327 } else {
11328 unreachable!()
11329 }
11330 }
11331 4 => {
11332 #[allow(irrefutable_let_patterns)]
11333 if let ComponentCapability::Config(_) = self {
11334 } else {
11336 *self = ComponentCapability::Config(fidl::new_empty!(
11338 fidl_fuchsia_component_decl__common::Configuration,
11339 D
11340 ));
11341 }
11342 #[allow(irrefutable_let_patterns)]
11343 if let ComponentCapability::Config(ref mut val) = self {
11344 fidl::decode!(
11345 fidl_fuchsia_component_decl__common::Configuration,
11346 D,
11347 val,
11348 decoder,
11349 _inner_offset,
11350 depth
11351 )?;
11352 } else {
11353 unreachable!()
11354 }
11355 }
11356 5 => {
11357 #[allow(irrefutable_let_patterns)]
11358 if let ComponentCapability::Dictionary(_) = self {
11359 } else {
11361 *self = ComponentCapability::Dictionary(fidl::new_empty!(
11363 fidl_fuchsia_component_decl__common::Dictionary,
11364 D
11365 ));
11366 }
11367 #[allow(irrefutable_let_patterns)]
11368 if let ComponentCapability::Dictionary(ref mut val) = self {
11369 fidl::decode!(
11370 fidl_fuchsia_component_decl__common::Dictionary,
11371 D,
11372 val,
11373 decoder,
11374 _inner_offset,
11375 depth
11376 )?;
11377 } else {
11378 unreachable!()
11379 }
11380 }
11381 6 => {
11382 #[allow(irrefutable_let_patterns)]
11383 if let ComponentCapability::Directory(_) = self {
11384 } else {
11386 *self = ComponentCapability::Directory(fidl::new_empty!(
11388 fidl_fuchsia_component_decl__common::Directory,
11389 D
11390 ));
11391 }
11392 #[allow(irrefutable_let_patterns)]
11393 if let ComponentCapability::Directory(ref mut val) = self {
11394 fidl::decode!(
11395 fidl_fuchsia_component_decl__common::Directory,
11396 D,
11397 val,
11398 decoder,
11399 _inner_offset,
11400 depth
11401 )?;
11402 } else {
11403 unreachable!()
11404 }
11405 }
11406 7 => {
11407 #[allow(irrefutable_let_patterns)]
11408 if let ComponentCapability::Environment(_) = self {
11409 } else {
11411 *self = ComponentCapability::Environment(fidl::new_empty!(
11413 EnvironmentCapability,
11414 D
11415 ));
11416 }
11417 #[allow(irrefutable_let_patterns)]
11418 if let ComponentCapability::Environment(ref mut val) = self {
11419 fidl::decode!(
11420 EnvironmentCapability,
11421 D,
11422 val,
11423 decoder,
11424 _inner_offset,
11425 depth
11426 )?;
11427 } else {
11428 unreachable!()
11429 }
11430 }
11431 8 => {
11432 #[allow(irrefutable_let_patterns)]
11433 if let ComponentCapability::EventStream(_) = self {
11434 } else {
11436 *self = ComponentCapability::EventStream(fidl::new_empty!(
11438 fidl_fuchsia_component_decl__common::EventStream,
11439 D
11440 ));
11441 }
11442 #[allow(irrefutable_let_patterns)]
11443 if let ComponentCapability::EventStream(ref mut val) = self {
11444 fidl::decode!(
11445 fidl_fuchsia_component_decl__common::EventStream,
11446 D,
11447 val,
11448 decoder,
11449 _inner_offset,
11450 depth
11451 )?;
11452 } else {
11453 unreachable!()
11454 }
11455 }
11456 9 => {
11457 #[allow(irrefutable_let_patterns)]
11458 if let ComponentCapability::Protocol(_) = self {
11459 } else {
11461 *self = ComponentCapability::Protocol(fidl::new_empty!(
11463 fidl_fuchsia_component_decl__common::Protocol,
11464 D
11465 ));
11466 }
11467 #[allow(irrefutable_let_patterns)]
11468 if let ComponentCapability::Protocol(ref mut val) = self {
11469 fidl::decode!(
11470 fidl_fuchsia_component_decl__common::Protocol,
11471 D,
11472 val,
11473 decoder,
11474 _inner_offset,
11475 depth
11476 )?;
11477 } else {
11478 unreachable!()
11479 }
11480 }
11481 10 => {
11482 #[allow(irrefutable_let_patterns)]
11483 if let ComponentCapability::Resolver(_) = self {
11484 } else {
11486 *self = ComponentCapability::Resolver(fidl::new_empty!(
11488 fidl_fuchsia_component_decl__common::Resolver,
11489 D
11490 ));
11491 }
11492 #[allow(irrefutable_let_patterns)]
11493 if let ComponentCapability::Resolver(ref mut val) = self {
11494 fidl::decode!(
11495 fidl_fuchsia_component_decl__common::Resolver,
11496 D,
11497 val,
11498 decoder,
11499 _inner_offset,
11500 depth
11501 )?;
11502 } else {
11503 unreachable!()
11504 }
11505 }
11506 11 => {
11507 #[allow(irrefutable_let_patterns)]
11508 if let ComponentCapability::Runner(_) = self {
11509 } else {
11511 *self = ComponentCapability::Runner(fidl::new_empty!(
11513 fidl_fuchsia_component_decl__common::Runner,
11514 D
11515 ));
11516 }
11517 #[allow(irrefutable_let_patterns)]
11518 if let ComponentCapability::Runner(ref mut val) = self {
11519 fidl::decode!(
11520 fidl_fuchsia_component_decl__common::Runner,
11521 D,
11522 val,
11523 decoder,
11524 _inner_offset,
11525 depth
11526 )?;
11527 } else {
11528 unreachable!()
11529 }
11530 }
11531 12 => {
11532 #[allow(irrefutable_let_patterns)]
11533 if let ComponentCapability::Service(_) = self {
11534 } else {
11536 *self = ComponentCapability::Service(fidl::new_empty!(
11538 fidl_fuchsia_component_decl__common::Service,
11539 D
11540 ));
11541 }
11542 #[allow(irrefutable_let_patterns)]
11543 if let ComponentCapability::Service(ref mut val) = self {
11544 fidl::decode!(
11545 fidl_fuchsia_component_decl__common::Service,
11546 D,
11547 val,
11548 decoder,
11549 _inner_offset,
11550 depth
11551 )?;
11552 } else {
11553 unreachable!()
11554 }
11555 }
11556 13 => {
11557 #[allow(irrefutable_let_patterns)]
11558 if let ComponentCapability::Storage(_) = self {
11559 } else {
11561 *self = ComponentCapability::Storage(fidl::new_empty!(
11563 fidl_fuchsia_component_decl__common::Storage,
11564 D
11565 ));
11566 }
11567 #[allow(irrefutable_let_patterns)]
11568 if let ComponentCapability::Storage(ref mut val) = self {
11569 fidl::decode!(
11570 fidl_fuchsia_component_decl__common::Storage,
11571 D,
11572 val,
11573 decoder,
11574 _inner_offset,
11575 depth
11576 )?;
11577 } else {
11578 unreachable!()
11579 }
11580 }
11581 ordinal => panic!("unexpected ordinal {:?}", ordinal),
11582 }
11583 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11584 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11585 }
11586 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11587 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11588 }
11589 Ok(())
11590 }
11591 }
11592
11593 impl fidl::encoding::ValueTypeMarker for EnvironmentCapability {
11594 type Borrowed<'a> = &'a Self;
11595 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11596 value
11597 }
11598 }
11599
11600 unsafe impl fidl::encoding::TypeMarker for EnvironmentCapability {
11601 type Owned = Self;
11602
11603 #[inline(always)]
11604 fn inline_align(_context: fidl::encoding::Context) -> usize {
11605 8
11606 }
11607
11608 #[inline(always)]
11609 fn inline_size(_context: fidl::encoding::Context) -> usize {
11610 16
11611 }
11612 }
11613
11614 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnvironmentCapability, D>
11615 for &EnvironmentCapability
11616 {
11617 #[inline]
11618 unsafe fn encode(
11619 self,
11620 encoder: &mut fidl::encoding::Encoder<'_, D>,
11621 offset: usize,
11622 _depth: fidl::encoding::Depth,
11623 ) -> fidl::Result<()> {
11624 encoder.debug_check_bounds::<EnvironmentCapability>(offset);
11625 encoder.write_num::<u64>(self.ordinal(), offset);
11626 match self {
11627 EnvironmentCapability::Runner(ref val) => {
11628 fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
11629 <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
11630 encoder,
11631 offset + 8,
11632 _depth,
11633 )
11634 }
11635 EnvironmentCapability::Resolver(ref val) => {
11636 fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
11637 <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
11638 encoder,
11639 offset + 8,
11640 _depth,
11641 )
11642 }
11643 EnvironmentCapability::Debug(ref val) => {
11644 fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
11645 <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
11646 encoder,
11647 offset + 8,
11648 _depth,
11649 )
11650 }
11651 }
11652 }
11653 }
11654
11655 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentCapability {
11656 #[inline(always)]
11657 fn new_empty() -> Self {
11658 Self::Runner(fidl::new_empty!(EnvironmentSource, D))
11659 }
11660
11661 #[inline]
11662 unsafe fn decode(
11663 &mut self,
11664 decoder: &mut fidl::encoding::Decoder<'_, D>,
11665 offset: usize,
11666 mut depth: fidl::encoding::Depth,
11667 ) -> fidl::Result<()> {
11668 decoder.debug_check_bounds::<Self>(offset);
11669 #[allow(unused_variables)]
11670 let next_out_of_line = decoder.next_out_of_line();
11671 let handles_before = decoder.remaining_handles();
11672 let (ordinal, inlined, num_bytes, num_handles) =
11673 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11674
11675 let member_inline_size = match ordinal {
11676 1 => {
11677 <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11678 }
11679 2 => {
11680 <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11681 }
11682 3 => {
11683 <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11684 }
11685 _ => return Err(fidl::Error::UnknownUnionTag),
11686 };
11687
11688 if inlined != (member_inline_size <= 4) {
11689 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11690 }
11691 let _inner_offset;
11692 if inlined {
11693 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11694 _inner_offset = offset + 8;
11695 } else {
11696 depth.increment()?;
11697 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11698 }
11699 match ordinal {
11700 1 => {
11701 #[allow(irrefutable_let_patterns)]
11702 if let EnvironmentCapability::Runner(_) = self {
11703 } else {
11705 *self =
11707 EnvironmentCapability::Runner(fidl::new_empty!(EnvironmentSource, D));
11708 }
11709 #[allow(irrefutable_let_patterns)]
11710 if let EnvironmentCapability::Runner(ref mut val) = self {
11711 fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
11712 } else {
11713 unreachable!()
11714 }
11715 }
11716 2 => {
11717 #[allow(irrefutable_let_patterns)]
11718 if let EnvironmentCapability::Resolver(_) = self {
11719 } else {
11721 *self =
11723 EnvironmentCapability::Resolver(fidl::new_empty!(EnvironmentSource, D));
11724 }
11725 #[allow(irrefutable_let_patterns)]
11726 if let EnvironmentCapability::Resolver(ref mut val) = self {
11727 fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
11728 } else {
11729 unreachable!()
11730 }
11731 }
11732 3 => {
11733 #[allow(irrefutable_let_patterns)]
11734 if let EnvironmentCapability::Debug(_) = self {
11735 } else {
11737 *self =
11739 EnvironmentCapability::Debug(fidl::new_empty!(EnvironmentSource, D));
11740 }
11741 #[allow(irrefutable_let_patterns)]
11742 if let EnvironmentCapability::Debug(ref mut val) = self {
11743 fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
11744 } else {
11745 unreachable!()
11746 }
11747 }
11748 ordinal => panic!("unexpected ordinal {:?}", ordinal),
11749 }
11750 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11751 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11752 }
11753 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11754 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11755 }
11756 Ok(())
11757 }
11758 }
11759
11760 impl fidl::encoding::ValueTypeMarker for InternalCapability {
11761 type Borrowed<'a> = &'a Self;
11762 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11763 value
11764 }
11765 }
11766
11767 unsafe impl fidl::encoding::TypeMarker for InternalCapability {
11768 type Owned = Self;
11769
11770 #[inline(always)]
11771 fn inline_align(_context: fidl::encoding::Context) -> usize {
11772 8
11773 }
11774
11775 #[inline(always)]
11776 fn inline_size(_context: fidl::encoding::Context) -> usize {
11777 16
11778 }
11779 }
11780
11781 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InternalCapability, D>
11782 for &InternalCapability
11783 {
11784 #[inline]
11785 unsafe fn encode(
11786 self,
11787 encoder: &mut fidl::encoding::Encoder<'_, D>,
11788 offset: usize,
11789 _depth: fidl::encoding::Depth,
11790 ) -> fidl::Result<()> {
11791 encoder.debug_check_bounds::<InternalCapability>(offset);
11792 encoder.write_num::<u64>(self.ordinal(), offset);
11793 match self {
11794 InternalCapability::Config(ref val) => fidl::encoding::encode_in_envelope::<
11795 fidl::encoding::BoundedString<100>,
11796 D,
11797 >(
11798 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11799 val,
11800 ),
11801 encoder,
11802 offset + 8,
11803 _depth,
11804 ),
11805 InternalCapability::Dictionary(ref val) => fidl::encoding::encode_in_envelope::<
11806 fidl::encoding::BoundedString<100>,
11807 D,
11808 >(
11809 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11810 val,
11811 ),
11812 encoder,
11813 offset + 8,
11814 _depth,
11815 ),
11816 InternalCapability::Directory(ref val) => fidl::encoding::encode_in_envelope::<
11817 fidl::encoding::BoundedString<100>,
11818 D,
11819 >(
11820 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11821 val,
11822 ),
11823 encoder,
11824 offset + 8,
11825 _depth,
11826 ),
11827 InternalCapability::EventStream(ref val) => fidl::encoding::encode_in_envelope::<
11828 fidl::encoding::BoundedString<100>,
11829 D,
11830 >(
11831 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11832 val,
11833 ),
11834 encoder,
11835 offset + 8,
11836 _depth,
11837 ),
11838 InternalCapability::Protocol(ref val) => fidl::encoding::encode_in_envelope::<
11839 fidl::encoding::BoundedString<100>,
11840 D,
11841 >(
11842 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11843 val,
11844 ),
11845 encoder,
11846 offset + 8,
11847 _depth,
11848 ),
11849 InternalCapability::Resolver(ref val) => fidl::encoding::encode_in_envelope::<
11850 fidl::encoding::BoundedString<100>,
11851 D,
11852 >(
11853 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11854 val,
11855 ),
11856 encoder,
11857 offset + 8,
11858 _depth,
11859 ),
11860 InternalCapability::Runner(ref val) => fidl::encoding::encode_in_envelope::<
11861 fidl::encoding::BoundedString<100>,
11862 D,
11863 >(
11864 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11865 val,
11866 ),
11867 encoder,
11868 offset + 8,
11869 _depth,
11870 ),
11871 InternalCapability::Service(ref val) => fidl::encoding::encode_in_envelope::<
11872 fidl::encoding::BoundedString<100>,
11873 D,
11874 >(
11875 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11876 val,
11877 ),
11878 encoder,
11879 offset + 8,
11880 _depth,
11881 ),
11882 InternalCapability::Storage(ref val) => fidl::encoding::encode_in_envelope::<
11883 fidl::encoding::BoundedString<100>,
11884 D,
11885 >(
11886 <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11887 val,
11888 ),
11889 encoder,
11890 offset + 8,
11891 _depth,
11892 ),
11893 }
11894 }
11895 }
11896
11897 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InternalCapability {
11898 #[inline(always)]
11899 fn new_empty() -> Self {
11900 Self::Config(fidl::new_empty!(fidl::encoding::BoundedString<100>, D))
11901 }
11902
11903 #[inline]
11904 unsafe fn decode(
11905 &mut self,
11906 decoder: &mut fidl::encoding::Decoder<'_, D>,
11907 offset: usize,
11908 mut depth: fidl::encoding::Depth,
11909 ) -> fidl::Result<()> {
11910 decoder.debug_check_bounds::<Self>(offset);
11911 #[allow(unused_variables)]
11912 let next_out_of_line = decoder.next_out_of_line();
11913 let handles_before = decoder.remaining_handles();
11914 let (ordinal, inlined, num_bytes, num_handles) =
11915 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11916
11917 let member_inline_size = match ordinal {
11918 1 => {
11919 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11920 decoder.context,
11921 )
11922 }
11923 2 => {
11924 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11925 decoder.context,
11926 )
11927 }
11928 3 => {
11929 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11930 decoder.context,
11931 )
11932 }
11933 4 => {
11934 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11935 decoder.context,
11936 )
11937 }
11938 5 => {
11939 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11940 decoder.context,
11941 )
11942 }
11943 6 => {
11944 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11945 decoder.context,
11946 )
11947 }
11948 7 => {
11949 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11950 decoder.context,
11951 )
11952 }
11953 8 => {
11954 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11955 decoder.context,
11956 )
11957 }
11958 9 => {
11959 <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11960 decoder.context,
11961 )
11962 }
11963 _ => return Err(fidl::Error::UnknownUnionTag),
11964 };
11965
11966 if inlined != (member_inline_size <= 4) {
11967 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11968 }
11969 let _inner_offset;
11970 if inlined {
11971 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11972 _inner_offset = offset + 8;
11973 } else {
11974 depth.increment()?;
11975 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11976 }
11977 match ordinal {
11978 1 => {
11979 #[allow(irrefutable_let_patterns)]
11980 if let InternalCapability::Config(_) = self {
11981 } else {
11983 *self = InternalCapability::Config(fidl::new_empty!(
11985 fidl::encoding::BoundedString<100>,
11986 D
11987 ));
11988 }
11989 #[allow(irrefutable_let_patterns)]
11990 if let InternalCapability::Config(ref mut val) = self {
11991 fidl::decode!(
11992 fidl::encoding::BoundedString<100>,
11993 D,
11994 val,
11995 decoder,
11996 _inner_offset,
11997 depth
11998 )?;
11999 } else {
12000 unreachable!()
12001 }
12002 }
12003 2 => {
12004 #[allow(irrefutable_let_patterns)]
12005 if let InternalCapability::Dictionary(_) = self {
12006 } else {
12008 *self = InternalCapability::Dictionary(fidl::new_empty!(
12010 fidl::encoding::BoundedString<100>,
12011 D
12012 ));
12013 }
12014 #[allow(irrefutable_let_patterns)]
12015 if let InternalCapability::Dictionary(ref mut val) = self {
12016 fidl::decode!(
12017 fidl::encoding::BoundedString<100>,
12018 D,
12019 val,
12020 decoder,
12021 _inner_offset,
12022 depth
12023 )?;
12024 } else {
12025 unreachable!()
12026 }
12027 }
12028 3 => {
12029 #[allow(irrefutable_let_patterns)]
12030 if let InternalCapability::Directory(_) = self {
12031 } else {
12033 *self = InternalCapability::Directory(fidl::new_empty!(
12035 fidl::encoding::BoundedString<100>,
12036 D
12037 ));
12038 }
12039 #[allow(irrefutable_let_patterns)]
12040 if let InternalCapability::Directory(ref mut val) = self {
12041 fidl::decode!(
12042 fidl::encoding::BoundedString<100>,
12043 D,
12044 val,
12045 decoder,
12046 _inner_offset,
12047 depth
12048 )?;
12049 } else {
12050 unreachable!()
12051 }
12052 }
12053 4 => {
12054 #[allow(irrefutable_let_patterns)]
12055 if let InternalCapability::EventStream(_) = self {
12056 } else {
12058 *self = InternalCapability::EventStream(fidl::new_empty!(
12060 fidl::encoding::BoundedString<100>,
12061 D
12062 ));
12063 }
12064 #[allow(irrefutable_let_patterns)]
12065 if let InternalCapability::EventStream(ref mut val) = self {
12066 fidl::decode!(
12067 fidl::encoding::BoundedString<100>,
12068 D,
12069 val,
12070 decoder,
12071 _inner_offset,
12072 depth
12073 )?;
12074 } else {
12075 unreachable!()
12076 }
12077 }
12078 5 => {
12079 #[allow(irrefutable_let_patterns)]
12080 if let InternalCapability::Protocol(_) = self {
12081 } else {
12083 *self = InternalCapability::Protocol(fidl::new_empty!(
12085 fidl::encoding::BoundedString<100>,
12086 D
12087 ));
12088 }
12089 #[allow(irrefutable_let_patterns)]
12090 if let InternalCapability::Protocol(ref mut val) = self {
12091 fidl::decode!(
12092 fidl::encoding::BoundedString<100>,
12093 D,
12094 val,
12095 decoder,
12096 _inner_offset,
12097 depth
12098 )?;
12099 } else {
12100 unreachable!()
12101 }
12102 }
12103 6 => {
12104 #[allow(irrefutable_let_patterns)]
12105 if let InternalCapability::Resolver(_) = self {
12106 } else {
12108 *self = InternalCapability::Resolver(fidl::new_empty!(
12110 fidl::encoding::BoundedString<100>,
12111 D
12112 ));
12113 }
12114 #[allow(irrefutable_let_patterns)]
12115 if let InternalCapability::Resolver(ref mut val) = self {
12116 fidl::decode!(
12117 fidl::encoding::BoundedString<100>,
12118 D,
12119 val,
12120 decoder,
12121 _inner_offset,
12122 depth
12123 )?;
12124 } else {
12125 unreachable!()
12126 }
12127 }
12128 7 => {
12129 #[allow(irrefutable_let_patterns)]
12130 if let InternalCapability::Runner(_) = self {
12131 } else {
12133 *self = InternalCapability::Runner(fidl::new_empty!(
12135 fidl::encoding::BoundedString<100>,
12136 D
12137 ));
12138 }
12139 #[allow(irrefutable_let_patterns)]
12140 if let InternalCapability::Runner(ref mut val) = self {
12141 fidl::decode!(
12142 fidl::encoding::BoundedString<100>,
12143 D,
12144 val,
12145 decoder,
12146 _inner_offset,
12147 depth
12148 )?;
12149 } else {
12150 unreachable!()
12151 }
12152 }
12153 8 => {
12154 #[allow(irrefutable_let_patterns)]
12155 if let InternalCapability::Service(_) = self {
12156 } else {
12158 *self = InternalCapability::Service(fidl::new_empty!(
12160 fidl::encoding::BoundedString<100>,
12161 D
12162 ));
12163 }
12164 #[allow(irrefutable_let_patterns)]
12165 if let InternalCapability::Service(ref mut val) = self {
12166 fidl::decode!(
12167 fidl::encoding::BoundedString<100>,
12168 D,
12169 val,
12170 decoder,
12171 _inner_offset,
12172 depth
12173 )?;
12174 } else {
12175 unreachable!()
12176 }
12177 }
12178 9 => {
12179 #[allow(irrefutable_let_patterns)]
12180 if let InternalCapability::Storage(_) = self {
12181 } else {
12183 *self = InternalCapability::Storage(fidl::new_empty!(
12185 fidl::encoding::BoundedString<100>,
12186 D
12187 ));
12188 }
12189 #[allow(irrefutable_let_patterns)]
12190 if let InternalCapability::Storage(ref mut val) = self {
12191 fidl::decode!(
12192 fidl::encoding::BoundedString<100>,
12193 D,
12194 val,
12195 decoder,
12196 _inner_offset,
12197 depth
12198 )?;
12199 } else {
12200 unreachable!()
12201 }
12202 }
12203 ordinal => panic!("unexpected ordinal {:?}", ordinal),
12204 }
12205 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12206 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12207 }
12208 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12209 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12210 }
12211 Ok(())
12212 }
12213 }
12214}