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