1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const LOCAL_COMPONENT_NAME_KEY: &str = "LOCAL_COMPONENT_NAME";
12
13pub const MAX_DIRECTORY_ENTRIES: u32 = 1024;
15
16#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
18pub enum RealmBuilderError {
19 ChildAlreadyExists,
22 InvalidManifestExtension,
25 InvalidComponentDecl,
27 NoSuchChild,
29 ChildDeclNotVisible,
33 NoSuchSource,
35 NoSuchTarget,
37 CapabilitiesEmpty,
39 TargetsEmpty,
41 SourceAndTargetMatch,
43 DeclNotFound,
46 DeclReadError,
49 BuildAlreadyCalled,
51 CapabilityInvalid,
54 InvalidChildRealmHandle,
56 ImmutableProgram,
61 UrlIsNotRelative,
64 InvalidPkgDirHandle,
67 NoConfigSchema,
70 NoSuchConfigField,
72 ConfigValueInvalid,
75 ConfigOverrideUnsupported,
78 #[doc(hidden)]
79 __SourceBreaking { unknown_ordinal: u32 },
80}
81
82#[macro_export]
84macro_rules! RealmBuilderErrorUnknown {
85 () => {
86 _
87 };
88}
89
90impl RealmBuilderError {
91 #[inline]
92 pub fn from_primitive(prim: u32) -> Option<Self> {
93 match prim {
94 0 => Some(Self::ChildAlreadyExists),
95 1 => Some(Self::InvalidManifestExtension),
96 2 => Some(Self::InvalidComponentDecl),
97 3 => Some(Self::NoSuchChild),
98 4 => Some(Self::ChildDeclNotVisible),
99 5 => Some(Self::NoSuchSource),
100 6 => Some(Self::NoSuchTarget),
101 7 => Some(Self::CapabilitiesEmpty),
102 8 => Some(Self::TargetsEmpty),
103 9 => Some(Self::SourceAndTargetMatch),
104 10 => Some(Self::DeclNotFound),
105 11 => Some(Self::DeclReadError),
106 12 => Some(Self::BuildAlreadyCalled),
107 13 => Some(Self::CapabilityInvalid),
108 14 => Some(Self::InvalidChildRealmHandle),
109 15 => Some(Self::ImmutableProgram),
110 16 => Some(Self::UrlIsNotRelative),
111 17 => Some(Self::InvalidPkgDirHandle),
112 18 => Some(Self::NoConfigSchema),
113 19 => Some(Self::NoSuchConfigField),
114 20 => Some(Self::ConfigValueInvalid),
115 21 => Some(Self::ConfigOverrideUnsupported),
116 _ => None,
117 }
118 }
119
120 #[inline]
121 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
122 match prim {
123 0 => Self::ChildAlreadyExists,
124 1 => Self::InvalidManifestExtension,
125 2 => Self::InvalidComponentDecl,
126 3 => Self::NoSuchChild,
127 4 => Self::ChildDeclNotVisible,
128 5 => Self::NoSuchSource,
129 6 => Self::NoSuchTarget,
130 7 => Self::CapabilitiesEmpty,
131 8 => Self::TargetsEmpty,
132 9 => Self::SourceAndTargetMatch,
133 10 => Self::DeclNotFound,
134 11 => Self::DeclReadError,
135 12 => Self::BuildAlreadyCalled,
136 13 => Self::CapabilityInvalid,
137 14 => Self::InvalidChildRealmHandle,
138 15 => Self::ImmutableProgram,
139 16 => Self::UrlIsNotRelative,
140 17 => Self::InvalidPkgDirHandle,
141 18 => Self::NoConfigSchema,
142 19 => Self::NoSuchConfigField,
143 20 => Self::ConfigValueInvalid,
144 21 => Self::ConfigOverrideUnsupported,
145 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
146 }
147 }
148
149 #[inline]
150 pub fn unknown() -> Self {
151 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
152 }
153
154 #[inline]
155 pub const fn into_primitive(self) -> u32 {
156 match self {
157 Self::ChildAlreadyExists => 0,
158 Self::InvalidManifestExtension => 1,
159 Self::InvalidComponentDecl => 2,
160 Self::NoSuchChild => 3,
161 Self::ChildDeclNotVisible => 4,
162 Self::NoSuchSource => 5,
163 Self::NoSuchTarget => 6,
164 Self::CapabilitiesEmpty => 7,
165 Self::TargetsEmpty => 8,
166 Self::SourceAndTargetMatch => 9,
167 Self::DeclNotFound => 10,
168 Self::DeclReadError => 11,
169 Self::BuildAlreadyCalled => 12,
170 Self::CapabilityInvalid => 13,
171 Self::InvalidChildRealmHandle => 14,
172 Self::ImmutableProgram => 15,
173 Self::UrlIsNotRelative => 16,
174 Self::InvalidPkgDirHandle => 17,
175 Self::NoConfigSchema => 18,
176 Self::NoSuchConfigField => 19,
177 Self::ConfigValueInvalid => 20,
178 Self::ConfigOverrideUnsupported => 21,
179 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
180 }
181 }
182
183 #[inline]
184 pub fn is_unknown(&self) -> bool {
185 match self {
186 Self::__SourceBreaking { unknown_ordinal: _ } => true,
187 _ => false,
188 }
189 }
190}
191
192#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
193pub struct BuilderBuildResponse {
194 pub root_component_url: String,
195}
196
197impl fidl::Persistable for BuilderBuildResponse {}
198
199#[derive(Clone, Debug, PartialEq)]
200pub struct RealmAddCapabilityRequest {
201 pub capability: fidl_fuchsia_component_decl__common::Capability,
202}
203
204impl fidl::Persistable for RealmAddCapabilityRequest {}
205
206#[derive(Clone, Debug, PartialEq)]
207pub struct RealmAddChildFromDeclRequest {
208 pub name: String,
210 pub decl: fidl_fuchsia_component_decl__common::Component,
212 pub options: ChildOptions,
214}
215
216impl fidl::Persistable for RealmAddChildFromDeclRequest {}
217
218#[derive(Clone, Debug, PartialEq)]
219pub struct RealmAddChildRequest {
220 pub name: String,
222 pub url: String,
224 pub options: ChildOptions,
226}
227
228impl fidl::Persistable for RealmAddChildRequest {}
229
230#[derive(Clone, Debug, PartialEq)]
231pub struct RealmAddCollectionRequest {
232 pub collection: fidl_fuchsia_component_decl__common::Collection,
233}
234
235impl fidl::Persistable for RealmAddCollectionRequest {}
236
237#[derive(Clone, Debug, PartialEq)]
238pub struct RealmAddEnvironmentRequest {
239 pub environment: fidl_fuchsia_component_decl__common::Environment,
240}
241
242impl fidl::Persistable for RealmAddEnvironmentRequest {}
243
244#[derive(Clone, Debug, PartialEq)]
245pub struct RealmAddLocalChildRequest {
246 pub name: String,
248 pub options: ChildOptions,
250}
251
252impl fidl::Persistable for RealmAddLocalChildRequest {}
253
254#[derive(Clone, Debug, PartialEq)]
255pub struct RealmAddRouteRequest {
256 pub capabilities: Vec<Capability>,
258 pub from: fidl_fuchsia_component_decl__common::Ref,
260 pub to: Vec<fidl_fuchsia_component_decl__common::Ref>,
262}
263
264impl fidl::Persistable for RealmAddRouteRequest {}
265
266#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
267pub struct RealmGetComponentDeclRequest {
268 pub name: String,
270}
271
272impl fidl::Persistable for RealmGetComponentDeclRequest {}
273
274#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
275pub struct RealmInitMutableConfigFromPackageRequest {
276 pub name: String,
277}
278
279impl fidl::Persistable for RealmInitMutableConfigFromPackageRequest {}
280
281#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
282pub struct RealmInitMutableConfigToEmptyRequest {
283 pub name: String,
284}
285
286impl fidl::Persistable for RealmInitMutableConfigToEmptyRequest {}
287
288#[derive(Clone, Debug, PartialEq)]
289pub struct RealmReplaceComponentDeclRequest {
290 pub name: String,
292 pub component_decl: fidl_fuchsia_component_decl__common::Component,
294}
295
296impl fidl::Persistable for RealmReplaceComponentDeclRequest {}
297
298#[derive(Clone, Debug, PartialEq)]
299pub struct RealmReplaceRealmDeclRequest {
300 pub component_decl: fidl_fuchsia_component_decl__common::Component,
302}
303
304impl fidl::Persistable for RealmReplaceRealmDeclRequest {}
305
306#[derive(Clone, Debug, PartialEq)]
307pub struct RealmSetConfigValueRequest {
308 pub name: String,
310 pub key: String,
312 pub value: fidl_fuchsia_component_decl__common::ConfigValueSpec,
314}
315
316impl fidl::Persistable for RealmSetConfigValueRequest {}
317
318#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
319pub struct RealmUseNestedComponentManagerRequest {
320 pub component_manager_relative_url: String,
321}
322
323impl fidl::Persistable for RealmUseNestedComponentManagerRequest {}
324
325#[derive(Clone, Debug, PartialEq)]
326pub struct RealmGetComponentDeclResponse {
327 pub component_decl: fidl_fuchsia_component_decl__common::Component,
328}
329
330impl fidl::Persistable for RealmGetComponentDeclResponse {}
331
332#[derive(Clone, Debug, PartialEq)]
333pub struct RealmGetRealmDeclResponse {
334 pub component_decl: fidl_fuchsia_component_decl__common::Component,
335}
336
337impl fidl::Persistable for RealmGetRealmDeclResponse {}
338
339#[derive(Clone, Debug, Default, PartialEq)]
341pub struct ChildOptions {
342 pub startup: Option<fidl_fuchsia_component_decl__common::StartupMode>,
346 pub environment: Option<String>,
348 pub on_terminate: Option<fidl_fuchsia_component_decl__common::OnTerminate>,
352 pub config_overrides: Option<Vec<fidl_fuchsia_component_decl__common::ConfigOverride>>,
357 #[doc(hidden)]
358 pub __source_breaking: fidl::marker::SourceBreaking,
359}
360
361impl fidl::Persistable for ChildOptions {}
362
363#[derive(Clone, Debug, Default, PartialEq)]
365pub struct Config {
366 pub name: Option<String>,
368 pub as_: Option<String>,
371 pub availability: Option<fidl_fuchsia_component_decl__common::Availability>,
374 #[doc(hidden)]
375 pub __source_breaking: fidl::marker::SourceBreaking,
376}
377
378impl fidl::Persistable for Config {}
379
380#[derive(Clone, Debug, Default, PartialEq)]
382pub struct Dictionary {
383 pub name: Option<String>,
385 pub as_: Option<String>,
388 pub type_: Option<fidl_fuchsia_component_decl__common::DependencyType>,
392 pub availability: Option<fidl_fuchsia_component_decl__common::Availability>,
395 pub from_dictionary: Option<String>,
398 #[doc(hidden)]
399 pub __source_breaking: fidl::marker::SourceBreaking,
400}
401
402impl fidl::Persistable for Dictionary {}
403
404#[derive(Clone, Debug, Default, PartialEq)]
406pub struct Directory {
407 pub name: Option<String>,
410 pub as_: Option<String>,
413 pub type_: Option<fidl_fuchsia_component_decl__common::DependencyType>,
417 pub subdir: Option<String>,
421 pub rights: Option<fidl_fuchsia_io__common::Operations>,
425 pub path: Option<String>,
429 pub availability: Option<fidl_fuchsia_component_decl__common::Availability>,
432 pub from_dictionary: Option<String>,
435 #[doc(hidden)]
436 pub __source_breaking: fidl::marker::SourceBreaking,
437}
438
439impl fidl::Persistable for Directory {}
440
441#[derive(Clone, Debug, Default, PartialEq)]
443pub struct Event {
444 pub name: Option<String>,
446 pub as_: Option<String>,
449 pub filter: Option<fidl_fuchsia_data__common::Dictionary>,
451 pub availability: Option<fidl_fuchsia_component_decl__common::Availability>,
454 #[doc(hidden)]
455 pub __source_breaking: fidl::marker::SourceBreaking,
456}
457
458impl fidl::Persistable for Event {}
459
460#[derive(Clone, Debug, Default, PartialEq)]
462pub struct EventStream {
463 pub name: Option<String>,
465 pub as_: Option<String>,
467 pub path: Option<String>,
469 pub filter: Option<fidl_fuchsia_data__common::Dictionary>,
471 pub scope: Option<Vec<fidl_fuchsia_component_decl__common::Ref>>,
474 #[doc(hidden)]
475 pub __source_breaking: fidl::marker::SourceBreaking,
476}
477
478impl fidl::Persistable for EventStream {}
479
480#[derive(Clone, Debug, Default, PartialEq)]
482pub struct Protocol {
483 pub name: Option<String>,
488 pub as_: Option<String>,
491 pub type_: Option<fidl_fuchsia_component_decl__common::DependencyType>,
495 pub path: Option<String>,
500 pub availability: Option<fidl_fuchsia_component_decl__common::Availability>,
503 pub from_dictionary: Option<String>,
506 #[doc(hidden)]
507 pub __source_breaking: fidl::marker::SourceBreaking,
508}
509
510impl fidl::Persistable for Protocol {}
511
512#[derive(Clone, Debug, Default, PartialEq)]
514pub struct Resolver {
515 pub name: Option<String>,
517 pub as_: Option<String>,
520 pub path: Option<String>,
525 pub from_dictionary: Option<String>,
528 #[doc(hidden)]
529 pub __source_breaking: fidl::marker::SourceBreaking,
530}
531
532impl fidl::Persistable for Resolver {}
533
534#[derive(Clone, Debug, Default, PartialEq)]
536pub struct Runner {
537 pub name: Option<String>,
539 pub as_: Option<String>,
542 pub path: Option<String>,
547 pub from_dictionary: Option<String>,
550 #[doc(hidden)]
551 pub __source_breaking: fidl::marker::SourceBreaking,
552}
553
554impl fidl::Persistable for Runner {}
555
556#[derive(Clone, Debug, Default, PartialEq)]
558pub struct Service {
559 pub name: Option<String>,
564 pub as_: Option<String>,
567 pub path: Option<String>,
572 pub availability: Option<fidl_fuchsia_component_decl__common::Availability>,
575 pub from_dictionary: Option<String>,
578 #[doc(hidden)]
579 pub __source_breaking: fidl::marker::SourceBreaking,
580}
581
582impl fidl::Persistable for Service {}
583
584#[derive(Clone, Debug, Default, PartialEq)]
586pub struct Storage {
587 pub name: Option<String>,
590 pub as_: Option<String>,
593 pub path: Option<String>,
597 pub availability: Option<fidl_fuchsia_component_decl__common::Availability>,
600 #[doc(hidden)]
601 pub __source_breaking: fidl::marker::SourceBreaking,
602}
603
604impl fidl::Persistable for Storage {}
605
606#[derive(Clone, Debug)]
611pub enum Capability {
612 Protocol(Protocol),
613 Directory(Directory),
614 Storage(Storage),
615 Service(Service),
616 EventStream(EventStream),
617 Config(Config),
618 Dictionary(Dictionary),
619 Resolver(Resolver),
620 Runner(Runner),
621 #[doc(hidden)]
622 __SourceBreaking {
623 unknown_ordinal: u64,
624 },
625}
626
627#[macro_export]
629macro_rules! CapabilityUnknown {
630 () => {
631 _
632 };
633}
634
635impl PartialEq for Capability {
637 fn eq(&self, other: &Self) -> bool {
638 match (self, other) {
639 (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
640 (Self::Directory(x), Self::Directory(y)) => *x == *y,
641 (Self::Storage(x), Self::Storage(y)) => *x == *y,
642 (Self::Service(x), Self::Service(y)) => *x == *y,
643 (Self::EventStream(x), Self::EventStream(y)) => *x == *y,
644 (Self::Config(x), Self::Config(y)) => *x == *y,
645 (Self::Dictionary(x), Self::Dictionary(y)) => *x == *y,
646 (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
647 (Self::Runner(x), Self::Runner(y)) => *x == *y,
648 _ => false,
649 }
650 }
651}
652
653impl Capability {
654 #[inline]
655 pub fn ordinal(&self) -> u64 {
656 match *self {
657 Self::Protocol(_) => 1,
658 Self::Directory(_) => 2,
659 Self::Storage(_) => 3,
660 Self::Service(_) => 4,
661 Self::EventStream(_) => 6,
662 Self::Config(_) => 7,
663 Self::Dictionary(_) => 8,
664 Self::Resolver(_) => 9,
665 Self::Runner(_) => 10,
666 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
667 }
668 }
669
670 #[inline]
671 pub fn unknown_variant_for_testing() -> Self {
672 Self::__SourceBreaking { unknown_ordinal: 0 }
673 }
674
675 #[inline]
676 pub fn is_unknown(&self) -> bool {
677 match self {
678 Self::__SourceBreaking { .. } => true,
679 _ => false,
680 }
681 }
682}
683
684impl fidl::Persistable for Capability {}
685
686pub mod builder_ordinals {
687 pub const BUILD: u64 = 0x172ba0923ec91575;
688}
689
690pub mod realm_ordinals {
691 pub const ADD_CHILD: u64 = 0x3f6c07627303d801;
692 pub const ADD_CHILD_FROM_DECL: u64 = 0x3950ad500258156d;
693 pub const ADD_LOCAL_CHILD: u64 = 0x3249817bae10abbb;
694 pub const ADD_CHILD_REALM: u64 = 0x3fdf98db373b9458;
695 pub const ADD_CHILD_REALM_FROM_RELATIVE_URL: u64 = 0x44c34c8dcbe06abb;
696 pub const ADD_CHILD_REALM_FROM_DECL: u64 = 0x142e5c326732862e;
697 pub const GET_COMPONENT_DECL: u64 = 0x320832af6a4cbac6;
698 pub const REPLACE_COMPONENT_DECL: u64 = 0x59cecf31b314cd5f;
699 pub const GET_REALM_DECL: u64 = 0x46fa05b17bd64269;
700 pub const REPLACE_REALM_DECL: u64 = 0x48fcba4ac1338da9;
701 pub const USE_NESTED_COMPONENT_MANAGER: u64 = 0x64bd27482f3dcc;
702 pub const ADD_ROUTE: u64 = 0x9d523295be53a0a;
703 pub const READ_ONLY_DIRECTORY: u64 = 0x78a6d150a66e00dc;
704 pub const INIT_MUTABLE_CONFIG_FROM_PACKAGE: u64 = 0x36a30c9837c64216;
705 pub const INIT_MUTABLE_CONFIG_TO_EMPTY: u64 = 0x772cb99e2e0dccc5;
706 pub const ADD_CAPABILITY: u64 = 0x23a6499eb6080249;
707 pub const ADD_COLLECTION: u64 = 0x56b75210a03a99b5;
708 pub const ADD_ENVIRONMENT: u64 = 0x1cd7caefa2cce0e9;
709 pub const SET_CONFIG_VALUE: u64 = 0x886450d291217f2;
710}
711
712pub mod realm_builder_factory_ordinals {
713 pub const CREATE: u64 = 0x73528b1135cb01be;
714 pub const CREATE_FROM_RELATIVE_URL: u64 = 0x1cafd9042c54a86b;
715}
716
717mod internal {
718 use super::*;
719 unsafe impl fidl::encoding::TypeMarker for RealmBuilderError {
720 type Owned = Self;
721
722 #[inline(always)]
723 fn inline_align(_context: fidl::encoding::Context) -> usize {
724 std::mem::align_of::<u32>()
725 }
726
727 #[inline(always)]
728 fn inline_size(_context: fidl::encoding::Context) -> usize {
729 std::mem::size_of::<u32>()
730 }
731
732 #[inline(always)]
733 fn encode_is_copy() -> bool {
734 false
735 }
736
737 #[inline(always)]
738 fn decode_is_copy() -> bool {
739 false
740 }
741 }
742
743 impl fidl::encoding::ValueTypeMarker for RealmBuilderError {
744 type Borrowed<'a> = Self;
745 #[inline(always)]
746 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
747 *value
748 }
749 }
750
751 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
752 for RealmBuilderError
753 {
754 #[inline]
755 unsafe fn encode(
756 self,
757 encoder: &mut fidl::encoding::Encoder<'_, D>,
758 offset: usize,
759 _depth: fidl::encoding::Depth,
760 ) -> fidl::Result<()> {
761 encoder.debug_check_bounds::<Self>(offset);
762 encoder.write_num(self.into_primitive(), offset);
763 Ok(())
764 }
765 }
766
767 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RealmBuilderError {
768 #[inline(always)]
769 fn new_empty() -> Self {
770 Self::unknown()
771 }
772
773 #[inline]
774 unsafe fn decode(
775 &mut self,
776 decoder: &mut fidl::encoding::Decoder<'_, D>,
777 offset: usize,
778 _depth: fidl::encoding::Depth,
779 ) -> fidl::Result<()> {
780 decoder.debug_check_bounds::<Self>(offset);
781 let prim = decoder.read_num::<u32>(offset);
782
783 *self = Self::from_primitive_allow_unknown(prim);
784 Ok(())
785 }
786 }
787
788 impl fidl::encoding::ValueTypeMarker for BuilderBuildResponse {
789 type Borrowed<'a> = &'a Self;
790 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
791 value
792 }
793 }
794
795 unsafe impl fidl::encoding::TypeMarker for BuilderBuildResponse {
796 type Owned = Self;
797
798 #[inline(always)]
799 fn inline_align(_context: fidl::encoding::Context) -> usize {
800 8
801 }
802
803 #[inline(always)]
804 fn inline_size(_context: fidl::encoding::Context) -> usize {
805 16
806 }
807 }
808
809 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BuilderBuildResponse, D>
810 for &BuilderBuildResponse
811 {
812 #[inline]
813 unsafe fn encode(
814 self,
815 encoder: &mut fidl::encoding::Encoder<'_, D>,
816 offset: usize,
817 _depth: fidl::encoding::Depth,
818 ) -> fidl::Result<()> {
819 encoder.debug_check_bounds::<BuilderBuildResponse>(offset);
820 fidl::encoding::Encode::<BuilderBuildResponse, D>::encode(
822 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
823 &self.root_component_url,
824 ),),
825 encoder,
826 offset,
827 _depth,
828 )
829 }
830 }
831 unsafe impl<
832 D: fidl::encoding::ResourceDialect,
833 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
834 > fidl::encoding::Encode<BuilderBuildResponse, D> for (T0,)
835 {
836 #[inline]
837 unsafe fn encode(
838 self,
839 encoder: &mut fidl::encoding::Encoder<'_, D>,
840 offset: usize,
841 depth: fidl::encoding::Depth,
842 ) -> fidl::Result<()> {
843 encoder.debug_check_bounds::<BuilderBuildResponse>(offset);
844 self.0.encode(encoder, offset + 0, depth)?;
848 Ok(())
849 }
850 }
851
852 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BuilderBuildResponse {
853 #[inline(always)]
854 fn new_empty() -> Self {
855 Self { root_component_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
856 }
857
858 #[inline]
859 unsafe fn decode(
860 &mut self,
861 decoder: &mut fidl::encoding::Decoder<'_, D>,
862 offset: usize,
863 _depth: fidl::encoding::Depth,
864 ) -> fidl::Result<()> {
865 decoder.debug_check_bounds::<Self>(offset);
866 fidl::decode!(
868 fidl::encoding::BoundedString<4096>,
869 D,
870 &mut self.root_component_url,
871 decoder,
872 offset + 0,
873 _depth
874 )?;
875 Ok(())
876 }
877 }
878
879 impl fidl::encoding::ValueTypeMarker for RealmAddCapabilityRequest {
880 type Borrowed<'a> = &'a Self;
881 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
882 value
883 }
884 }
885
886 unsafe impl fidl::encoding::TypeMarker for RealmAddCapabilityRequest {
887 type Owned = Self;
888
889 #[inline(always)]
890 fn inline_align(_context: fidl::encoding::Context) -> usize {
891 8
892 }
893
894 #[inline(always)]
895 fn inline_size(_context: fidl::encoding::Context) -> usize {
896 16
897 }
898 }
899
900 unsafe impl<D: fidl::encoding::ResourceDialect>
901 fidl::encoding::Encode<RealmAddCapabilityRequest, D> for &RealmAddCapabilityRequest
902 {
903 #[inline]
904 unsafe fn encode(
905 self,
906 encoder: &mut fidl::encoding::Encoder<'_, D>,
907 offset: usize,
908 _depth: fidl::encoding::Depth,
909 ) -> fidl::Result<()> {
910 encoder.debug_check_bounds::<RealmAddCapabilityRequest>(offset);
911 fidl::encoding::Encode::<RealmAddCapabilityRequest, D>::encode(
913 (
914 <fidl_fuchsia_component_decl__common::Capability as fidl::encoding::ValueTypeMarker>::borrow(&self.capability),
915 ),
916 encoder, offset, _depth
917 )
918 }
919 }
920 unsafe impl<
921 D: fidl::encoding::ResourceDialect,
922 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Capability, D>,
923 > fidl::encoding::Encode<RealmAddCapabilityRequest, D> for (T0,)
924 {
925 #[inline]
926 unsafe fn encode(
927 self,
928 encoder: &mut fidl::encoding::Encoder<'_, D>,
929 offset: usize,
930 depth: fidl::encoding::Depth,
931 ) -> fidl::Result<()> {
932 encoder.debug_check_bounds::<RealmAddCapabilityRequest>(offset);
933 self.0.encode(encoder, offset + 0, depth)?;
937 Ok(())
938 }
939 }
940
941 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
942 for RealmAddCapabilityRequest
943 {
944 #[inline(always)]
945 fn new_empty() -> Self {
946 Self {
947 capability: fidl::new_empty!(fidl_fuchsia_component_decl__common::Capability, D),
948 }
949 }
950
951 #[inline]
952 unsafe fn decode(
953 &mut self,
954 decoder: &mut fidl::encoding::Decoder<'_, D>,
955 offset: usize,
956 _depth: fidl::encoding::Depth,
957 ) -> fidl::Result<()> {
958 decoder.debug_check_bounds::<Self>(offset);
959 fidl::decode!(
961 fidl_fuchsia_component_decl__common::Capability,
962 D,
963 &mut self.capability,
964 decoder,
965 offset + 0,
966 _depth
967 )?;
968 Ok(())
969 }
970 }
971
972 impl fidl::encoding::ValueTypeMarker for RealmAddChildFromDeclRequest {
973 type Borrowed<'a> = &'a Self;
974 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
975 value
976 }
977 }
978
979 unsafe impl fidl::encoding::TypeMarker for RealmAddChildFromDeclRequest {
980 type Owned = Self;
981
982 #[inline(always)]
983 fn inline_align(_context: fidl::encoding::Context) -> usize {
984 8
985 }
986
987 #[inline(always)]
988 fn inline_size(_context: fidl::encoding::Context) -> usize {
989 48
990 }
991 }
992
993 unsafe impl<D: fidl::encoding::ResourceDialect>
994 fidl::encoding::Encode<RealmAddChildFromDeclRequest, D> for &RealmAddChildFromDeclRequest
995 {
996 #[inline]
997 unsafe fn encode(
998 self,
999 encoder: &mut fidl::encoding::Encoder<'_, D>,
1000 offset: usize,
1001 _depth: fidl::encoding::Depth,
1002 ) -> fidl::Result<()> {
1003 encoder.debug_check_bounds::<RealmAddChildFromDeclRequest>(offset);
1004 fidl::encoding::Encode::<RealmAddChildFromDeclRequest, D>::encode(
1006 (
1007 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1008 <fidl_fuchsia_component_decl__common::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.decl),
1009 <ChildOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
1010 ),
1011 encoder, offset, _depth
1012 )
1013 }
1014 }
1015 unsafe impl<
1016 D: fidl::encoding::ResourceDialect,
1017 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
1018 T1: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Component, D>,
1019 T2: fidl::encoding::Encode<ChildOptions, D>,
1020 > fidl::encoding::Encode<RealmAddChildFromDeclRequest, D> for (T0, T1, T2)
1021 {
1022 #[inline]
1023 unsafe fn encode(
1024 self,
1025 encoder: &mut fidl::encoding::Encoder<'_, D>,
1026 offset: usize,
1027 depth: fidl::encoding::Depth,
1028 ) -> fidl::Result<()> {
1029 encoder.debug_check_bounds::<RealmAddChildFromDeclRequest>(offset);
1030 self.0.encode(encoder, offset + 0, depth)?;
1034 self.1.encode(encoder, offset + 16, depth)?;
1035 self.2.encode(encoder, offset + 32, depth)?;
1036 Ok(())
1037 }
1038 }
1039
1040 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1041 for RealmAddChildFromDeclRequest
1042 {
1043 #[inline(always)]
1044 fn new_empty() -> Self {
1045 Self {
1046 name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D),
1047 decl: fidl::new_empty!(fidl_fuchsia_component_decl__common::Component, D),
1048 options: fidl::new_empty!(ChildOptions, D),
1049 }
1050 }
1051
1052 #[inline]
1053 unsafe fn decode(
1054 &mut self,
1055 decoder: &mut fidl::encoding::Decoder<'_, D>,
1056 offset: usize,
1057 _depth: fidl::encoding::Depth,
1058 ) -> fidl::Result<()> {
1059 decoder.debug_check_bounds::<Self>(offset);
1060 fidl::decode!(
1062 fidl::encoding::BoundedString<1024>,
1063 D,
1064 &mut self.name,
1065 decoder,
1066 offset + 0,
1067 _depth
1068 )?;
1069 fidl::decode!(
1070 fidl_fuchsia_component_decl__common::Component,
1071 D,
1072 &mut self.decl,
1073 decoder,
1074 offset + 16,
1075 _depth
1076 )?;
1077 fidl::decode!(ChildOptions, D, &mut self.options, decoder, offset + 32, _depth)?;
1078 Ok(())
1079 }
1080 }
1081
1082 impl fidl::encoding::ValueTypeMarker for RealmAddChildRequest {
1083 type Borrowed<'a> = &'a Self;
1084 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1085 value
1086 }
1087 }
1088
1089 unsafe impl fidl::encoding::TypeMarker for RealmAddChildRequest {
1090 type Owned = Self;
1091
1092 #[inline(always)]
1093 fn inline_align(_context: fidl::encoding::Context) -> usize {
1094 8
1095 }
1096
1097 #[inline(always)]
1098 fn inline_size(_context: fidl::encoding::Context) -> usize {
1099 48
1100 }
1101 }
1102
1103 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RealmAddChildRequest, D>
1104 for &RealmAddChildRequest
1105 {
1106 #[inline]
1107 unsafe fn encode(
1108 self,
1109 encoder: &mut fidl::encoding::Encoder<'_, D>,
1110 offset: usize,
1111 _depth: fidl::encoding::Depth,
1112 ) -> fidl::Result<()> {
1113 encoder.debug_check_bounds::<RealmAddChildRequest>(offset);
1114 fidl::encoding::Encode::<RealmAddChildRequest, D>::encode(
1116 (
1117 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1118 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.url),
1119 <ChildOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
1120 ),
1121 encoder, offset, _depth
1122 )
1123 }
1124 }
1125 unsafe impl<
1126 D: fidl::encoding::ResourceDialect,
1127 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
1128 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
1129 T2: fidl::encoding::Encode<ChildOptions, D>,
1130 > fidl::encoding::Encode<RealmAddChildRequest, D> for (T0, T1, T2)
1131 {
1132 #[inline]
1133 unsafe fn encode(
1134 self,
1135 encoder: &mut fidl::encoding::Encoder<'_, D>,
1136 offset: usize,
1137 depth: fidl::encoding::Depth,
1138 ) -> fidl::Result<()> {
1139 encoder.debug_check_bounds::<RealmAddChildRequest>(offset);
1140 self.0.encode(encoder, offset + 0, depth)?;
1144 self.1.encode(encoder, offset + 16, depth)?;
1145 self.2.encode(encoder, offset + 32, depth)?;
1146 Ok(())
1147 }
1148 }
1149
1150 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RealmAddChildRequest {
1151 #[inline(always)]
1152 fn new_empty() -> Self {
1153 Self {
1154 name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D),
1155 url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
1156 options: fidl::new_empty!(ChildOptions, D),
1157 }
1158 }
1159
1160 #[inline]
1161 unsafe fn decode(
1162 &mut self,
1163 decoder: &mut fidl::encoding::Decoder<'_, D>,
1164 offset: usize,
1165 _depth: fidl::encoding::Depth,
1166 ) -> fidl::Result<()> {
1167 decoder.debug_check_bounds::<Self>(offset);
1168 fidl::decode!(
1170 fidl::encoding::BoundedString<1024>,
1171 D,
1172 &mut self.name,
1173 decoder,
1174 offset + 0,
1175 _depth
1176 )?;
1177 fidl::decode!(
1178 fidl::encoding::BoundedString<4096>,
1179 D,
1180 &mut self.url,
1181 decoder,
1182 offset + 16,
1183 _depth
1184 )?;
1185 fidl::decode!(ChildOptions, D, &mut self.options, decoder, offset + 32, _depth)?;
1186 Ok(())
1187 }
1188 }
1189
1190 impl fidl::encoding::ValueTypeMarker for RealmAddCollectionRequest {
1191 type Borrowed<'a> = &'a Self;
1192 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1193 value
1194 }
1195 }
1196
1197 unsafe impl fidl::encoding::TypeMarker for RealmAddCollectionRequest {
1198 type Owned = Self;
1199
1200 #[inline(always)]
1201 fn inline_align(_context: fidl::encoding::Context) -> usize {
1202 8
1203 }
1204
1205 #[inline(always)]
1206 fn inline_size(_context: fidl::encoding::Context) -> usize {
1207 16
1208 }
1209 }
1210
1211 unsafe impl<D: fidl::encoding::ResourceDialect>
1212 fidl::encoding::Encode<RealmAddCollectionRequest, D> for &RealmAddCollectionRequest
1213 {
1214 #[inline]
1215 unsafe fn encode(
1216 self,
1217 encoder: &mut fidl::encoding::Encoder<'_, D>,
1218 offset: usize,
1219 _depth: fidl::encoding::Depth,
1220 ) -> fidl::Result<()> {
1221 encoder.debug_check_bounds::<RealmAddCollectionRequest>(offset);
1222 fidl::encoding::Encode::<RealmAddCollectionRequest, D>::encode(
1224 (
1225 <fidl_fuchsia_component_decl__common::Collection as fidl::encoding::ValueTypeMarker>::borrow(&self.collection),
1226 ),
1227 encoder, offset, _depth
1228 )
1229 }
1230 }
1231 unsafe impl<
1232 D: fidl::encoding::ResourceDialect,
1233 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Collection, D>,
1234 > fidl::encoding::Encode<RealmAddCollectionRequest, D> for (T0,)
1235 {
1236 #[inline]
1237 unsafe fn encode(
1238 self,
1239 encoder: &mut fidl::encoding::Encoder<'_, D>,
1240 offset: usize,
1241 depth: fidl::encoding::Depth,
1242 ) -> fidl::Result<()> {
1243 encoder.debug_check_bounds::<RealmAddCollectionRequest>(offset);
1244 self.0.encode(encoder, offset + 0, depth)?;
1248 Ok(())
1249 }
1250 }
1251
1252 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1253 for RealmAddCollectionRequest
1254 {
1255 #[inline(always)]
1256 fn new_empty() -> Self {
1257 Self {
1258 collection: fidl::new_empty!(fidl_fuchsia_component_decl__common::Collection, D),
1259 }
1260 }
1261
1262 #[inline]
1263 unsafe fn decode(
1264 &mut self,
1265 decoder: &mut fidl::encoding::Decoder<'_, D>,
1266 offset: usize,
1267 _depth: fidl::encoding::Depth,
1268 ) -> fidl::Result<()> {
1269 decoder.debug_check_bounds::<Self>(offset);
1270 fidl::decode!(
1272 fidl_fuchsia_component_decl__common::Collection,
1273 D,
1274 &mut self.collection,
1275 decoder,
1276 offset + 0,
1277 _depth
1278 )?;
1279 Ok(())
1280 }
1281 }
1282
1283 impl fidl::encoding::ValueTypeMarker for RealmAddEnvironmentRequest {
1284 type Borrowed<'a> = &'a Self;
1285 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1286 value
1287 }
1288 }
1289
1290 unsafe impl fidl::encoding::TypeMarker for RealmAddEnvironmentRequest {
1291 type Owned = Self;
1292
1293 #[inline(always)]
1294 fn inline_align(_context: fidl::encoding::Context) -> usize {
1295 8
1296 }
1297
1298 #[inline(always)]
1299 fn inline_size(_context: fidl::encoding::Context) -> usize {
1300 16
1301 }
1302 }
1303
1304 unsafe impl<D: fidl::encoding::ResourceDialect>
1305 fidl::encoding::Encode<RealmAddEnvironmentRequest, D> for &RealmAddEnvironmentRequest
1306 {
1307 #[inline]
1308 unsafe fn encode(
1309 self,
1310 encoder: &mut fidl::encoding::Encoder<'_, D>,
1311 offset: usize,
1312 _depth: fidl::encoding::Depth,
1313 ) -> fidl::Result<()> {
1314 encoder.debug_check_bounds::<RealmAddEnvironmentRequest>(offset);
1315 fidl::encoding::Encode::<RealmAddEnvironmentRequest, D>::encode(
1317 (
1318 <fidl_fuchsia_component_decl__common::Environment as fidl::encoding::ValueTypeMarker>::borrow(&self.environment),
1319 ),
1320 encoder, offset, _depth
1321 )
1322 }
1323 }
1324 unsafe impl<
1325 D: fidl::encoding::ResourceDialect,
1326 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Environment, D>,
1327 > fidl::encoding::Encode<RealmAddEnvironmentRequest, D> for (T0,)
1328 {
1329 #[inline]
1330 unsafe fn encode(
1331 self,
1332 encoder: &mut fidl::encoding::Encoder<'_, D>,
1333 offset: usize,
1334 depth: fidl::encoding::Depth,
1335 ) -> fidl::Result<()> {
1336 encoder.debug_check_bounds::<RealmAddEnvironmentRequest>(offset);
1337 self.0.encode(encoder, offset + 0, depth)?;
1341 Ok(())
1342 }
1343 }
1344
1345 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1346 for RealmAddEnvironmentRequest
1347 {
1348 #[inline(always)]
1349 fn new_empty() -> Self {
1350 Self {
1351 environment: fidl::new_empty!(fidl_fuchsia_component_decl__common::Environment, D),
1352 }
1353 }
1354
1355 #[inline]
1356 unsafe fn decode(
1357 &mut self,
1358 decoder: &mut fidl::encoding::Decoder<'_, D>,
1359 offset: usize,
1360 _depth: fidl::encoding::Depth,
1361 ) -> fidl::Result<()> {
1362 decoder.debug_check_bounds::<Self>(offset);
1363 fidl::decode!(
1365 fidl_fuchsia_component_decl__common::Environment,
1366 D,
1367 &mut self.environment,
1368 decoder,
1369 offset + 0,
1370 _depth
1371 )?;
1372 Ok(())
1373 }
1374 }
1375
1376 impl fidl::encoding::ValueTypeMarker for RealmAddLocalChildRequest {
1377 type Borrowed<'a> = &'a Self;
1378 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1379 value
1380 }
1381 }
1382
1383 unsafe impl fidl::encoding::TypeMarker for RealmAddLocalChildRequest {
1384 type Owned = Self;
1385
1386 #[inline(always)]
1387 fn inline_align(_context: fidl::encoding::Context) -> usize {
1388 8
1389 }
1390
1391 #[inline(always)]
1392 fn inline_size(_context: fidl::encoding::Context) -> usize {
1393 32
1394 }
1395 }
1396
1397 unsafe impl<D: fidl::encoding::ResourceDialect>
1398 fidl::encoding::Encode<RealmAddLocalChildRequest, D> for &RealmAddLocalChildRequest
1399 {
1400 #[inline]
1401 unsafe fn encode(
1402 self,
1403 encoder: &mut fidl::encoding::Encoder<'_, D>,
1404 offset: usize,
1405 _depth: fidl::encoding::Depth,
1406 ) -> fidl::Result<()> {
1407 encoder.debug_check_bounds::<RealmAddLocalChildRequest>(offset);
1408 fidl::encoding::Encode::<RealmAddLocalChildRequest, D>::encode(
1410 (
1411 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1412 <ChildOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
1413 ),
1414 encoder, offset, _depth
1415 )
1416 }
1417 }
1418 unsafe impl<
1419 D: fidl::encoding::ResourceDialect,
1420 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
1421 T1: fidl::encoding::Encode<ChildOptions, D>,
1422 > fidl::encoding::Encode<RealmAddLocalChildRequest, D> for (T0, T1)
1423 {
1424 #[inline]
1425 unsafe fn encode(
1426 self,
1427 encoder: &mut fidl::encoding::Encoder<'_, D>,
1428 offset: usize,
1429 depth: fidl::encoding::Depth,
1430 ) -> fidl::Result<()> {
1431 encoder.debug_check_bounds::<RealmAddLocalChildRequest>(offset);
1432 self.0.encode(encoder, offset + 0, depth)?;
1436 self.1.encode(encoder, offset + 16, depth)?;
1437 Ok(())
1438 }
1439 }
1440
1441 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1442 for RealmAddLocalChildRequest
1443 {
1444 #[inline(always)]
1445 fn new_empty() -> Self {
1446 Self {
1447 name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D),
1448 options: fidl::new_empty!(ChildOptions, D),
1449 }
1450 }
1451
1452 #[inline]
1453 unsafe fn decode(
1454 &mut self,
1455 decoder: &mut fidl::encoding::Decoder<'_, D>,
1456 offset: usize,
1457 _depth: fidl::encoding::Depth,
1458 ) -> fidl::Result<()> {
1459 decoder.debug_check_bounds::<Self>(offset);
1460 fidl::decode!(
1462 fidl::encoding::BoundedString<1024>,
1463 D,
1464 &mut self.name,
1465 decoder,
1466 offset + 0,
1467 _depth
1468 )?;
1469 fidl::decode!(ChildOptions, D, &mut self.options, decoder, offset + 16, _depth)?;
1470 Ok(())
1471 }
1472 }
1473
1474 impl fidl::encoding::ValueTypeMarker for RealmAddRouteRequest {
1475 type Borrowed<'a> = &'a Self;
1476 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1477 value
1478 }
1479 }
1480
1481 unsafe impl fidl::encoding::TypeMarker for RealmAddRouteRequest {
1482 type Owned = Self;
1483
1484 #[inline(always)]
1485 fn inline_align(_context: fidl::encoding::Context) -> usize {
1486 8
1487 }
1488
1489 #[inline(always)]
1490 fn inline_size(_context: fidl::encoding::Context) -> usize {
1491 48
1492 }
1493 }
1494
1495 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RealmAddRouteRequest, D>
1496 for &RealmAddRouteRequest
1497 {
1498 #[inline]
1499 unsafe fn encode(
1500 self,
1501 encoder: &mut fidl::encoding::Encoder<'_, D>,
1502 offset: usize,
1503 _depth: fidl::encoding::Depth,
1504 ) -> fidl::Result<()> {
1505 encoder.debug_check_bounds::<RealmAddRouteRequest>(offset);
1506 fidl::encoding::Encode::<RealmAddRouteRequest, D>::encode(
1508 (
1509 <fidl::encoding::UnboundedVector<Capability> as fidl::encoding::ValueTypeMarker>::borrow(&self.capabilities),
1510 <fidl_fuchsia_component_decl__common::Ref as fidl::encoding::ValueTypeMarker>::borrow(&self.from),
1511 <fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref> as fidl::encoding::ValueTypeMarker>::borrow(&self.to),
1512 ),
1513 encoder, offset, _depth
1514 )
1515 }
1516 }
1517 unsafe impl<
1518 D: fidl::encoding::ResourceDialect,
1519 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Capability>, D>,
1520 T1: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Ref, D>,
1521 T2: fidl::encoding::Encode<
1522 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
1523 D,
1524 >,
1525 > fidl::encoding::Encode<RealmAddRouteRequest, D> for (T0, T1, T2)
1526 {
1527 #[inline]
1528 unsafe fn encode(
1529 self,
1530 encoder: &mut fidl::encoding::Encoder<'_, D>,
1531 offset: usize,
1532 depth: fidl::encoding::Depth,
1533 ) -> fidl::Result<()> {
1534 encoder.debug_check_bounds::<RealmAddRouteRequest>(offset);
1535 self.0.encode(encoder, offset + 0, depth)?;
1539 self.1.encode(encoder, offset + 16, depth)?;
1540 self.2.encode(encoder, offset + 32, depth)?;
1541 Ok(())
1542 }
1543 }
1544
1545 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RealmAddRouteRequest {
1546 #[inline(always)]
1547 fn new_empty() -> Self {
1548 Self {
1549 capabilities: fidl::new_empty!(fidl::encoding::UnboundedVector<Capability>, D),
1550 from: fidl::new_empty!(fidl_fuchsia_component_decl__common::Ref, D),
1551 to: fidl::new_empty!(
1552 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
1553 D
1554 ),
1555 }
1556 }
1557
1558 #[inline]
1559 unsafe fn decode(
1560 &mut self,
1561 decoder: &mut fidl::encoding::Decoder<'_, D>,
1562 offset: usize,
1563 _depth: fidl::encoding::Depth,
1564 ) -> fidl::Result<()> {
1565 decoder.debug_check_bounds::<Self>(offset);
1566 fidl::decode!(
1568 fidl::encoding::UnboundedVector<Capability>,
1569 D,
1570 &mut self.capabilities,
1571 decoder,
1572 offset + 0,
1573 _depth
1574 )?;
1575 fidl::decode!(
1576 fidl_fuchsia_component_decl__common::Ref,
1577 D,
1578 &mut self.from,
1579 decoder,
1580 offset + 16,
1581 _depth
1582 )?;
1583 fidl::decode!(
1584 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
1585 D,
1586 &mut self.to,
1587 decoder,
1588 offset + 32,
1589 _depth
1590 )?;
1591 Ok(())
1592 }
1593 }
1594
1595 impl fidl::encoding::ValueTypeMarker for RealmGetComponentDeclRequest {
1596 type Borrowed<'a> = &'a Self;
1597 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1598 value
1599 }
1600 }
1601
1602 unsafe impl fidl::encoding::TypeMarker for RealmGetComponentDeclRequest {
1603 type Owned = Self;
1604
1605 #[inline(always)]
1606 fn inline_align(_context: fidl::encoding::Context) -> usize {
1607 8
1608 }
1609
1610 #[inline(always)]
1611 fn inline_size(_context: fidl::encoding::Context) -> usize {
1612 16
1613 }
1614 }
1615
1616 unsafe impl<D: fidl::encoding::ResourceDialect>
1617 fidl::encoding::Encode<RealmGetComponentDeclRequest, D> for &RealmGetComponentDeclRequest
1618 {
1619 #[inline]
1620 unsafe fn encode(
1621 self,
1622 encoder: &mut fidl::encoding::Encoder<'_, D>,
1623 offset: usize,
1624 _depth: fidl::encoding::Depth,
1625 ) -> fidl::Result<()> {
1626 encoder.debug_check_bounds::<RealmGetComponentDeclRequest>(offset);
1627 fidl::encoding::Encode::<RealmGetComponentDeclRequest, D>::encode(
1629 (<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(
1630 &self.name,
1631 ),),
1632 encoder,
1633 offset,
1634 _depth,
1635 )
1636 }
1637 }
1638 unsafe impl<
1639 D: fidl::encoding::ResourceDialect,
1640 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
1641 > fidl::encoding::Encode<RealmGetComponentDeclRequest, D> for (T0,)
1642 {
1643 #[inline]
1644 unsafe fn encode(
1645 self,
1646 encoder: &mut fidl::encoding::Encoder<'_, D>,
1647 offset: usize,
1648 depth: fidl::encoding::Depth,
1649 ) -> fidl::Result<()> {
1650 encoder.debug_check_bounds::<RealmGetComponentDeclRequest>(offset);
1651 self.0.encode(encoder, offset + 0, depth)?;
1655 Ok(())
1656 }
1657 }
1658
1659 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1660 for RealmGetComponentDeclRequest
1661 {
1662 #[inline(always)]
1663 fn new_empty() -> Self {
1664 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D) }
1665 }
1666
1667 #[inline]
1668 unsafe fn decode(
1669 &mut self,
1670 decoder: &mut fidl::encoding::Decoder<'_, D>,
1671 offset: usize,
1672 _depth: fidl::encoding::Depth,
1673 ) -> fidl::Result<()> {
1674 decoder.debug_check_bounds::<Self>(offset);
1675 fidl::decode!(
1677 fidl::encoding::BoundedString<1024>,
1678 D,
1679 &mut self.name,
1680 decoder,
1681 offset + 0,
1682 _depth
1683 )?;
1684 Ok(())
1685 }
1686 }
1687
1688 impl fidl::encoding::ValueTypeMarker for RealmInitMutableConfigFromPackageRequest {
1689 type Borrowed<'a> = &'a Self;
1690 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1691 value
1692 }
1693 }
1694
1695 unsafe impl fidl::encoding::TypeMarker for RealmInitMutableConfigFromPackageRequest {
1696 type Owned = Self;
1697
1698 #[inline(always)]
1699 fn inline_align(_context: fidl::encoding::Context) -> usize {
1700 8
1701 }
1702
1703 #[inline(always)]
1704 fn inline_size(_context: fidl::encoding::Context) -> usize {
1705 16
1706 }
1707 }
1708
1709 unsafe impl<D: fidl::encoding::ResourceDialect>
1710 fidl::encoding::Encode<RealmInitMutableConfigFromPackageRequest, D>
1711 for &RealmInitMutableConfigFromPackageRequest
1712 {
1713 #[inline]
1714 unsafe fn encode(
1715 self,
1716 encoder: &mut fidl::encoding::Encoder<'_, D>,
1717 offset: usize,
1718 _depth: fidl::encoding::Depth,
1719 ) -> fidl::Result<()> {
1720 encoder.debug_check_bounds::<RealmInitMutableConfigFromPackageRequest>(offset);
1721 fidl::encoding::Encode::<RealmInitMutableConfigFromPackageRequest, D>::encode(
1723 (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
1724 &self.name,
1725 ),),
1726 encoder,
1727 offset,
1728 _depth,
1729 )
1730 }
1731 }
1732 unsafe impl<
1733 D: fidl::encoding::ResourceDialect,
1734 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
1735 > fidl::encoding::Encode<RealmInitMutableConfigFromPackageRequest, D> for (T0,)
1736 {
1737 #[inline]
1738 unsafe fn encode(
1739 self,
1740 encoder: &mut fidl::encoding::Encoder<'_, D>,
1741 offset: usize,
1742 depth: fidl::encoding::Depth,
1743 ) -> fidl::Result<()> {
1744 encoder.debug_check_bounds::<RealmInitMutableConfigFromPackageRequest>(offset);
1745 self.0.encode(encoder, offset + 0, depth)?;
1749 Ok(())
1750 }
1751 }
1752
1753 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1754 for RealmInitMutableConfigFromPackageRequest
1755 {
1756 #[inline(always)]
1757 fn new_empty() -> Self {
1758 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
1759 }
1760
1761 #[inline]
1762 unsafe fn decode(
1763 &mut self,
1764 decoder: &mut fidl::encoding::Decoder<'_, D>,
1765 offset: usize,
1766 _depth: fidl::encoding::Depth,
1767 ) -> fidl::Result<()> {
1768 decoder.debug_check_bounds::<Self>(offset);
1769 fidl::decode!(
1771 fidl::encoding::BoundedString<255>,
1772 D,
1773 &mut self.name,
1774 decoder,
1775 offset + 0,
1776 _depth
1777 )?;
1778 Ok(())
1779 }
1780 }
1781
1782 impl fidl::encoding::ValueTypeMarker for RealmInitMutableConfigToEmptyRequest {
1783 type Borrowed<'a> = &'a Self;
1784 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1785 value
1786 }
1787 }
1788
1789 unsafe impl fidl::encoding::TypeMarker for RealmInitMutableConfigToEmptyRequest {
1790 type Owned = Self;
1791
1792 #[inline(always)]
1793 fn inline_align(_context: fidl::encoding::Context) -> usize {
1794 8
1795 }
1796
1797 #[inline(always)]
1798 fn inline_size(_context: fidl::encoding::Context) -> usize {
1799 16
1800 }
1801 }
1802
1803 unsafe impl<D: fidl::encoding::ResourceDialect>
1804 fidl::encoding::Encode<RealmInitMutableConfigToEmptyRequest, D>
1805 for &RealmInitMutableConfigToEmptyRequest
1806 {
1807 #[inline]
1808 unsafe fn encode(
1809 self,
1810 encoder: &mut fidl::encoding::Encoder<'_, D>,
1811 offset: usize,
1812 _depth: fidl::encoding::Depth,
1813 ) -> fidl::Result<()> {
1814 encoder.debug_check_bounds::<RealmInitMutableConfigToEmptyRequest>(offset);
1815 fidl::encoding::Encode::<RealmInitMutableConfigToEmptyRequest, D>::encode(
1817 (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
1818 &self.name,
1819 ),),
1820 encoder,
1821 offset,
1822 _depth,
1823 )
1824 }
1825 }
1826 unsafe impl<
1827 D: fidl::encoding::ResourceDialect,
1828 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
1829 > fidl::encoding::Encode<RealmInitMutableConfigToEmptyRequest, D> for (T0,)
1830 {
1831 #[inline]
1832 unsafe fn encode(
1833 self,
1834 encoder: &mut fidl::encoding::Encoder<'_, D>,
1835 offset: usize,
1836 depth: fidl::encoding::Depth,
1837 ) -> fidl::Result<()> {
1838 encoder.debug_check_bounds::<RealmInitMutableConfigToEmptyRequest>(offset);
1839 self.0.encode(encoder, offset + 0, depth)?;
1843 Ok(())
1844 }
1845 }
1846
1847 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1848 for RealmInitMutableConfigToEmptyRequest
1849 {
1850 #[inline(always)]
1851 fn new_empty() -> Self {
1852 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
1853 }
1854
1855 #[inline]
1856 unsafe fn decode(
1857 &mut self,
1858 decoder: &mut fidl::encoding::Decoder<'_, D>,
1859 offset: usize,
1860 _depth: fidl::encoding::Depth,
1861 ) -> fidl::Result<()> {
1862 decoder.debug_check_bounds::<Self>(offset);
1863 fidl::decode!(
1865 fidl::encoding::BoundedString<255>,
1866 D,
1867 &mut self.name,
1868 decoder,
1869 offset + 0,
1870 _depth
1871 )?;
1872 Ok(())
1873 }
1874 }
1875
1876 impl fidl::encoding::ValueTypeMarker for RealmReplaceComponentDeclRequest {
1877 type Borrowed<'a> = &'a Self;
1878 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1879 value
1880 }
1881 }
1882
1883 unsafe impl fidl::encoding::TypeMarker for RealmReplaceComponentDeclRequest {
1884 type Owned = Self;
1885
1886 #[inline(always)]
1887 fn inline_align(_context: fidl::encoding::Context) -> usize {
1888 8
1889 }
1890
1891 #[inline(always)]
1892 fn inline_size(_context: fidl::encoding::Context) -> usize {
1893 32
1894 }
1895 }
1896
1897 unsafe impl<D: fidl::encoding::ResourceDialect>
1898 fidl::encoding::Encode<RealmReplaceComponentDeclRequest, D>
1899 for &RealmReplaceComponentDeclRequest
1900 {
1901 #[inline]
1902 unsafe fn encode(
1903 self,
1904 encoder: &mut fidl::encoding::Encoder<'_, D>,
1905 offset: usize,
1906 _depth: fidl::encoding::Depth,
1907 ) -> fidl::Result<()> {
1908 encoder.debug_check_bounds::<RealmReplaceComponentDeclRequest>(offset);
1909 fidl::encoding::Encode::<RealmReplaceComponentDeclRequest, D>::encode(
1911 (
1912 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1913 <fidl_fuchsia_component_decl__common::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.component_decl),
1914 ),
1915 encoder, offset, _depth
1916 )
1917 }
1918 }
1919 unsafe impl<
1920 D: fidl::encoding::ResourceDialect,
1921 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
1922 T1: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Component, D>,
1923 > fidl::encoding::Encode<RealmReplaceComponentDeclRequest, D> for (T0, T1)
1924 {
1925 #[inline]
1926 unsafe fn encode(
1927 self,
1928 encoder: &mut fidl::encoding::Encoder<'_, D>,
1929 offset: usize,
1930 depth: fidl::encoding::Depth,
1931 ) -> fidl::Result<()> {
1932 encoder.debug_check_bounds::<RealmReplaceComponentDeclRequest>(offset);
1933 self.0.encode(encoder, offset + 0, depth)?;
1937 self.1.encode(encoder, offset + 16, depth)?;
1938 Ok(())
1939 }
1940 }
1941
1942 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1943 for RealmReplaceComponentDeclRequest
1944 {
1945 #[inline(always)]
1946 fn new_empty() -> Self {
1947 Self {
1948 name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D),
1949 component_decl: fidl::new_empty!(fidl_fuchsia_component_decl__common::Component, D),
1950 }
1951 }
1952
1953 #[inline]
1954 unsafe fn decode(
1955 &mut self,
1956 decoder: &mut fidl::encoding::Decoder<'_, D>,
1957 offset: usize,
1958 _depth: fidl::encoding::Depth,
1959 ) -> fidl::Result<()> {
1960 decoder.debug_check_bounds::<Self>(offset);
1961 fidl::decode!(
1963 fidl::encoding::BoundedString<1024>,
1964 D,
1965 &mut self.name,
1966 decoder,
1967 offset + 0,
1968 _depth
1969 )?;
1970 fidl::decode!(
1971 fidl_fuchsia_component_decl__common::Component,
1972 D,
1973 &mut self.component_decl,
1974 decoder,
1975 offset + 16,
1976 _depth
1977 )?;
1978 Ok(())
1979 }
1980 }
1981
1982 impl fidl::encoding::ValueTypeMarker for RealmReplaceRealmDeclRequest {
1983 type Borrowed<'a> = &'a Self;
1984 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1985 value
1986 }
1987 }
1988
1989 unsafe impl fidl::encoding::TypeMarker for RealmReplaceRealmDeclRequest {
1990 type Owned = Self;
1991
1992 #[inline(always)]
1993 fn inline_align(_context: fidl::encoding::Context) -> usize {
1994 8
1995 }
1996
1997 #[inline(always)]
1998 fn inline_size(_context: fidl::encoding::Context) -> usize {
1999 16
2000 }
2001 }
2002
2003 unsafe impl<D: fidl::encoding::ResourceDialect>
2004 fidl::encoding::Encode<RealmReplaceRealmDeclRequest, D> for &RealmReplaceRealmDeclRequest
2005 {
2006 #[inline]
2007 unsafe fn encode(
2008 self,
2009 encoder: &mut fidl::encoding::Encoder<'_, D>,
2010 offset: usize,
2011 _depth: fidl::encoding::Depth,
2012 ) -> fidl::Result<()> {
2013 encoder.debug_check_bounds::<RealmReplaceRealmDeclRequest>(offset);
2014 fidl::encoding::Encode::<RealmReplaceRealmDeclRequest, D>::encode(
2016 (
2017 <fidl_fuchsia_component_decl__common::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.component_decl),
2018 ),
2019 encoder, offset, _depth
2020 )
2021 }
2022 }
2023 unsafe impl<
2024 D: fidl::encoding::ResourceDialect,
2025 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Component, D>,
2026 > fidl::encoding::Encode<RealmReplaceRealmDeclRequest, D> for (T0,)
2027 {
2028 #[inline]
2029 unsafe fn encode(
2030 self,
2031 encoder: &mut fidl::encoding::Encoder<'_, D>,
2032 offset: usize,
2033 depth: fidl::encoding::Depth,
2034 ) -> fidl::Result<()> {
2035 encoder.debug_check_bounds::<RealmReplaceRealmDeclRequest>(offset);
2036 self.0.encode(encoder, offset + 0, depth)?;
2040 Ok(())
2041 }
2042 }
2043
2044 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2045 for RealmReplaceRealmDeclRequest
2046 {
2047 #[inline(always)]
2048 fn new_empty() -> Self {
2049 Self {
2050 component_decl: fidl::new_empty!(fidl_fuchsia_component_decl__common::Component, D),
2051 }
2052 }
2053
2054 #[inline]
2055 unsafe fn decode(
2056 &mut self,
2057 decoder: &mut fidl::encoding::Decoder<'_, D>,
2058 offset: usize,
2059 _depth: fidl::encoding::Depth,
2060 ) -> fidl::Result<()> {
2061 decoder.debug_check_bounds::<Self>(offset);
2062 fidl::decode!(
2064 fidl_fuchsia_component_decl__common::Component,
2065 D,
2066 &mut self.component_decl,
2067 decoder,
2068 offset + 0,
2069 _depth
2070 )?;
2071 Ok(())
2072 }
2073 }
2074
2075 impl fidl::encoding::ValueTypeMarker for RealmSetConfigValueRequest {
2076 type Borrowed<'a> = &'a Self;
2077 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2078 value
2079 }
2080 }
2081
2082 unsafe impl fidl::encoding::TypeMarker for RealmSetConfigValueRequest {
2083 type Owned = Self;
2084
2085 #[inline(always)]
2086 fn inline_align(_context: fidl::encoding::Context) -> usize {
2087 8
2088 }
2089
2090 #[inline(always)]
2091 fn inline_size(_context: fidl::encoding::Context) -> usize {
2092 48
2093 }
2094 }
2095
2096 unsafe impl<D: fidl::encoding::ResourceDialect>
2097 fidl::encoding::Encode<RealmSetConfigValueRequest, D> for &RealmSetConfigValueRequest
2098 {
2099 #[inline]
2100 unsafe fn encode(
2101 self,
2102 encoder: &mut fidl::encoding::Encoder<'_, D>,
2103 offset: usize,
2104 _depth: fidl::encoding::Depth,
2105 ) -> fidl::Result<()> {
2106 encoder.debug_check_bounds::<RealmSetConfigValueRequest>(offset);
2107 fidl::encoding::Encode::<RealmSetConfigValueRequest, D>::encode(
2109 (
2110 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
2111 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
2112 <fidl_fuchsia_component_decl__common::ConfigValueSpec as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
2113 ),
2114 encoder, offset, _depth
2115 )
2116 }
2117 }
2118 unsafe impl<
2119 D: fidl::encoding::ResourceDialect,
2120 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
2121 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
2122 T2: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::ConfigValueSpec, D>,
2123 > fidl::encoding::Encode<RealmSetConfigValueRequest, D> for (T0, T1, T2)
2124 {
2125 #[inline]
2126 unsafe fn encode(
2127 self,
2128 encoder: &mut fidl::encoding::Encoder<'_, D>,
2129 offset: usize,
2130 depth: fidl::encoding::Depth,
2131 ) -> fidl::Result<()> {
2132 encoder.debug_check_bounds::<RealmSetConfigValueRequest>(offset);
2133 self.0.encode(encoder, offset + 0, depth)?;
2137 self.1.encode(encoder, offset + 16, depth)?;
2138 self.2.encode(encoder, offset + 32, depth)?;
2139 Ok(())
2140 }
2141 }
2142
2143 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2144 for RealmSetConfigValueRequest
2145 {
2146 #[inline(always)]
2147 fn new_empty() -> Self {
2148 Self {
2149 name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
2150 key: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
2151 value: fidl::new_empty!(fidl_fuchsia_component_decl__common::ConfigValueSpec, D),
2152 }
2153 }
2154
2155 #[inline]
2156 unsafe fn decode(
2157 &mut self,
2158 decoder: &mut fidl::encoding::Decoder<'_, D>,
2159 offset: usize,
2160 _depth: fidl::encoding::Depth,
2161 ) -> fidl::Result<()> {
2162 decoder.debug_check_bounds::<Self>(offset);
2163 fidl::decode!(
2165 fidl::encoding::BoundedString<255>,
2166 D,
2167 &mut self.name,
2168 decoder,
2169 offset + 0,
2170 _depth
2171 )?;
2172 fidl::decode!(
2173 fidl::encoding::BoundedString<64>,
2174 D,
2175 &mut self.key,
2176 decoder,
2177 offset + 16,
2178 _depth
2179 )?;
2180 fidl::decode!(
2181 fidl_fuchsia_component_decl__common::ConfigValueSpec,
2182 D,
2183 &mut self.value,
2184 decoder,
2185 offset + 32,
2186 _depth
2187 )?;
2188 Ok(())
2189 }
2190 }
2191
2192 impl fidl::encoding::ValueTypeMarker for RealmUseNestedComponentManagerRequest {
2193 type Borrowed<'a> = &'a Self;
2194 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2195 value
2196 }
2197 }
2198
2199 unsafe impl fidl::encoding::TypeMarker for RealmUseNestedComponentManagerRequest {
2200 type Owned = Self;
2201
2202 #[inline(always)]
2203 fn inline_align(_context: fidl::encoding::Context) -> usize {
2204 8
2205 }
2206
2207 #[inline(always)]
2208 fn inline_size(_context: fidl::encoding::Context) -> usize {
2209 16
2210 }
2211 }
2212
2213 unsafe impl<D: fidl::encoding::ResourceDialect>
2214 fidl::encoding::Encode<RealmUseNestedComponentManagerRequest, D>
2215 for &RealmUseNestedComponentManagerRequest
2216 {
2217 #[inline]
2218 unsafe fn encode(
2219 self,
2220 encoder: &mut fidl::encoding::Encoder<'_, D>,
2221 offset: usize,
2222 _depth: fidl::encoding::Depth,
2223 ) -> fidl::Result<()> {
2224 encoder.debug_check_bounds::<RealmUseNestedComponentManagerRequest>(offset);
2225 fidl::encoding::Encode::<RealmUseNestedComponentManagerRequest, D>::encode(
2227 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
2228 &self.component_manager_relative_url,
2229 ),),
2230 encoder,
2231 offset,
2232 _depth,
2233 )
2234 }
2235 }
2236 unsafe impl<
2237 D: fidl::encoding::ResourceDialect,
2238 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
2239 > fidl::encoding::Encode<RealmUseNestedComponentManagerRequest, D> for (T0,)
2240 {
2241 #[inline]
2242 unsafe fn encode(
2243 self,
2244 encoder: &mut fidl::encoding::Encoder<'_, D>,
2245 offset: usize,
2246 depth: fidl::encoding::Depth,
2247 ) -> fidl::Result<()> {
2248 encoder.debug_check_bounds::<RealmUseNestedComponentManagerRequest>(offset);
2249 self.0.encode(encoder, offset + 0, depth)?;
2253 Ok(())
2254 }
2255 }
2256
2257 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2258 for RealmUseNestedComponentManagerRequest
2259 {
2260 #[inline(always)]
2261 fn new_empty() -> Self {
2262 Self {
2263 component_manager_relative_url: fidl::new_empty!(
2264 fidl::encoding::BoundedString<4096>,
2265 D
2266 ),
2267 }
2268 }
2269
2270 #[inline]
2271 unsafe fn decode(
2272 &mut self,
2273 decoder: &mut fidl::encoding::Decoder<'_, D>,
2274 offset: usize,
2275 _depth: fidl::encoding::Depth,
2276 ) -> fidl::Result<()> {
2277 decoder.debug_check_bounds::<Self>(offset);
2278 fidl::decode!(
2280 fidl::encoding::BoundedString<4096>,
2281 D,
2282 &mut self.component_manager_relative_url,
2283 decoder,
2284 offset + 0,
2285 _depth
2286 )?;
2287 Ok(())
2288 }
2289 }
2290
2291 impl fidl::encoding::ValueTypeMarker for RealmGetComponentDeclResponse {
2292 type Borrowed<'a> = &'a Self;
2293 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2294 value
2295 }
2296 }
2297
2298 unsafe impl fidl::encoding::TypeMarker for RealmGetComponentDeclResponse {
2299 type Owned = Self;
2300
2301 #[inline(always)]
2302 fn inline_align(_context: fidl::encoding::Context) -> usize {
2303 8
2304 }
2305
2306 #[inline(always)]
2307 fn inline_size(_context: fidl::encoding::Context) -> usize {
2308 16
2309 }
2310 }
2311
2312 unsafe impl<D: fidl::encoding::ResourceDialect>
2313 fidl::encoding::Encode<RealmGetComponentDeclResponse, D>
2314 for &RealmGetComponentDeclResponse
2315 {
2316 #[inline]
2317 unsafe fn encode(
2318 self,
2319 encoder: &mut fidl::encoding::Encoder<'_, D>,
2320 offset: usize,
2321 _depth: fidl::encoding::Depth,
2322 ) -> fidl::Result<()> {
2323 encoder.debug_check_bounds::<RealmGetComponentDeclResponse>(offset);
2324 fidl::encoding::Encode::<RealmGetComponentDeclResponse, D>::encode(
2326 (
2327 <fidl_fuchsia_component_decl__common::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.component_decl),
2328 ),
2329 encoder, offset, _depth
2330 )
2331 }
2332 }
2333 unsafe impl<
2334 D: fidl::encoding::ResourceDialect,
2335 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Component, D>,
2336 > fidl::encoding::Encode<RealmGetComponentDeclResponse, D> for (T0,)
2337 {
2338 #[inline]
2339 unsafe fn encode(
2340 self,
2341 encoder: &mut fidl::encoding::Encoder<'_, D>,
2342 offset: usize,
2343 depth: fidl::encoding::Depth,
2344 ) -> fidl::Result<()> {
2345 encoder.debug_check_bounds::<RealmGetComponentDeclResponse>(offset);
2346 self.0.encode(encoder, offset + 0, depth)?;
2350 Ok(())
2351 }
2352 }
2353
2354 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2355 for RealmGetComponentDeclResponse
2356 {
2357 #[inline(always)]
2358 fn new_empty() -> Self {
2359 Self {
2360 component_decl: fidl::new_empty!(fidl_fuchsia_component_decl__common::Component, D),
2361 }
2362 }
2363
2364 #[inline]
2365 unsafe fn decode(
2366 &mut self,
2367 decoder: &mut fidl::encoding::Decoder<'_, D>,
2368 offset: usize,
2369 _depth: fidl::encoding::Depth,
2370 ) -> fidl::Result<()> {
2371 decoder.debug_check_bounds::<Self>(offset);
2372 fidl::decode!(
2374 fidl_fuchsia_component_decl__common::Component,
2375 D,
2376 &mut self.component_decl,
2377 decoder,
2378 offset + 0,
2379 _depth
2380 )?;
2381 Ok(())
2382 }
2383 }
2384
2385 impl fidl::encoding::ValueTypeMarker for RealmGetRealmDeclResponse {
2386 type Borrowed<'a> = &'a Self;
2387 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2388 value
2389 }
2390 }
2391
2392 unsafe impl fidl::encoding::TypeMarker for RealmGetRealmDeclResponse {
2393 type Owned = Self;
2394
2395 #[inline(always)]
2396 fn inline_align(_context: fidl::encoding::Context) -> usize {
2397 8
2398 }
2399
2400 #[inline(always)]
2401 fn inline_size(_context: fidl::encoding::Context) -> usize {
2402 16
2403 }
2404 }
2405
2406 unsafe impl<D: fidl::encoding::ResourceDialect>
2407 fidl::encoding::Encode<RealmGetRealmDeclResponse, D> for &RealmGetRealmDeclResponse
2408 {
2409 #[inline]
2410 unsafe fn encode(
2411 self,
2412 encoder: &mut fidl::encoding::Encoder<'_, D>,
2413 offset: usize,
2414 _depth: fidl::encoding::Depth,
2415 ) -> fidl::Result<()> {
2416 encoder.debug_check_bounds::<RealmGetRealmDeclResponse>(offset);
2417 fidl::encoding::Encode::<RealmGetRealmDeclResponse, D>::encode(
2419 (
2420 <fidl_fuchsia_component_decl__common::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.component_decl),
2421 ),
2422 encoder, offset, _depth
2423 )
2424 }
2425 }
2426 unsafe impl<
2427 D: fidl::encoding::ResourceDialect,
2428 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Component, D>,
2429 > fidl::encoding::Encode<RealmGetRealmDeclResponse, D> for (T0,)
2430 {
2431 #[inline]
2432 unsafe fn encode(
2433 self,
2434 encoder: &mut fidl::encoding::Encoder<'_, D>,
2435 offset: usize,
2436 depth: fidl::encoding::Depth,
2437 ) -> fidl::Result<()> {
2438 encoder.debug_check_bounds::<RealmGetRealmDeclResponse>(offset);
2439 self.0.encode(encoder, offset + 0, depth)?;
2443 Ok(())
2444 }
2445 }
2446
2447 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2448 for RealmGetRealmDeclResponse
2449 {
2450 #[inline(always)]
2451 fn new_empty() -> Self {
2452 Self {
2453 component_decl: fidl::new_empty!(fidl_fuchsia_component_decl__common::Component, D),
2454 }
2455 }
2456
2457 #[inline]
2458 unsafe fn decode(
2459 &mut self,
2460 decoder: &mut fidl::encoding::Decoder<'_, D>,
2461 offset: usize,
2462 _depth: fidl::encoding::Depth,
2463 ) -> fidl::Result<()> {
2464 decoder.debug_check_bounds::<Self>(offset);
2465 fidl::decode!(
2467 fidl_fuchsia_component_decl__common::Component,
2468 D,
2469 &mut self.component_decl,
2470 decoder,
2471 offset + 0,
2472 _depth
2473 )?;
2474 Ok(())
2475 }
2476 }
2477
2478 impl ChildOptions {
2479 #[inline(always)]
2480 fn max_ordinal_present(&self) -> u64 {
2481 if let Some(_) = self.config_overrides {
2482 return 4;
2483 }
2484 if let Some(_) = self.on_terminate {
2485 return 3;
2486 }
2487 if let Some(_) = self.environment {
2488 return 2;
2489 }
2490 if let Some(_) = self.startup {
2491 return 1;
2492 }
2493 0
2494 }
2495 }
2496
2497 impl fidl::encoding::ValueTypeMarker for ChildOptions {
2498 type Borrowed<'a> = &'a Self;
2499 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2500 value
2501 }
2502 }
2503
2504 unsafe impl fidl::encoding::TypeMarker for ChildOptions {
2505 type Owned = Self;
2506
2507 #[inline(always)]
2508 fn inline_align(_context: fidl::encoding::Context) -> usize {
2509 8
2510 }
2511
2512 #[inline(always)]
2513 fn inline_size(_context: fidl::encoding::Context) -> usize {
2514 16
2515 }
2516 }
2517
2518 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChildOptions, D>
2519 for &ChildOptions
2520 {
2521 unsafe fn encode(
2522 self,
2523 encoder: &mut fidl::encoding::Encoder<'_, D>,
2524 offset: usize,
2525 mut depth: fidl::encoding::Depth,
2526 ) -> fidl::Result<()> {
2527 encoder.debug_check_bounds::<ChildOptions>(offset);
2528 let max_ordinal: u64 = self.max_ordinal_present();
2530 encoder.write_num(max_ordinal, offset);
2531 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2532 if max_ordinal == 0 {
2534 return Ok(());
2535 }
2536 depth.increment()?;
2537 let envelope_size = 8;
2538 let bytes_len = max_ordinal as usize * envelope_size;
2539 #[allow(unused_variables)]
2540 let offset = encoder.out_of_line_offset(bytes_len);
2541 let mut _prev_end_offset: usize = 0;
2542 if 1 > max_ordinal {
2543 return Ok(());
2544 }
2545
2546 let cur_offset: usize = (1 - 1) * envelope_size;
2549
2550 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2552
2553 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::StartupMode, D>(
2558 self.startup.as_ref().map(<fidl_fuchsia_component_decl__common::StartupMode as fidl::encoding::ValueTypeMarker>::borrow),
2559 encoder, offset + cur_offset, depth
2560 )?;
2561
2562 _prev_end_offset = cur_offset + envelope_size;
2563 if 2 > max_ordinal {
2564 return Ok(());
2565 }
2566
2567 let cur_offset: usize = (2 - 1) * envelope_size;
2570
2571 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2573
2574 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
2579 self.environment.as_ref().map(
2580 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
2581 ),
2582 encoder,
2583 offset + cur_offset,
2584 depth,
2585 )?;
2586
2587 _prev_end_offset = cur_offset + envelope_size;
2588 if 3 > max_ordinal {
2589 return Ok(());
2590 }
2591
2592 let cur_offset: usize = (3 - 1) * envelope_size;
2595
2596 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2598
2599 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::OnTerminate, D>(
2604 self.on_terminate.as_ref().map(<fidl_fuchsia_component_decl__common::OnTerminate as fidl::encoding::ValueTypeMarker>::borrow),
2605 encoder, offset + cur_offset, depth
2606 )?;
2607
2608 _prev_end_offset = cur_offset + envelope_size;
2609 if 4 > max_ordinal {
2610 return Ok(());
2611 }
2612
2613 let cur_offset: usize = (4 - 1) * envelope_size;
2616
2617 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2619
2620 fidl::encoding::encode_in_envelope_optional::<
2625 fidl::encoding::UnboundedVector<
2626 fidl_fuchsia_component_decl__common::ConfigOverride,
2627 >,
2628 D,
2629 >(
2630 self.config_overrides.as_ref().map(
2631 <fidl::encoding::UnboundedVector<
2632 fidl_fuchsia_component_decl__common::ConfigOverride,
2633 > as fidl::encoding::ValueTypeMarker>::borrow,
2634 ),
2635 encoder,
2636 offset + cur_offset,
2637 depth,
2638 )?;
2639
2640 _prev_end_offset = cur_offset + envelope_size;
2641
2642 Ok(())
2643 }
2644 }
2645
2646 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildOptions {
2647 #[inline(always)]
2648 fn new_empty() -> Self {
2649 Self::default()
2650 }
2651
2652 unsafe fn decode(
2653 &mut self,
2654 decoder: &mut fidl::encoding::Decoder<'_, D>,
2655 offset: usize,
2656 mut depth: fidl::encoding::Depth,
2657 ) -> fidl::Result<()> {
2658 decoder.debug_check_bounds::<Self>(offset);
2659 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2660 None => return Err(fidl::Error::NotNullable),
2661 Some(len) => len,
2662 };
2663 if len == 0 {
2665 return Ok(());
2666 };
2667 depth.increment()?;
2668 let envelope_size = 8;
2669 let bytes_len = len * envelope_size;
2670 let offset = decoder.out_of_line_offset(bytes_len)?;
2671 let mut _next_ordinal_to_read = 0;
2673 let mut next_offset = offset;
2674 let end_offset = offset + bytes_len;
2675 _next_ordinal_to_read += 1;
2676 if next_offset >= end_offset {
2677 return Ok(());
2678 }
2679
2680 while _next_ordinal_to_read < 1 {
2682 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2683 _next_ordinal_to_read += 1;
2684 next_offset += envelope_size;
2685 }
2686
2687 let next_out_of_line = decoder.next_out_of_line();
2688 let handles_before = decoder.remaining_handles();
2689 if let Some((inlined, num_bytes, num_handles)) =
2690 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2691 {
2692 let member_inline_size = <fidl_fuchsia_component_decl__common::StartupMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2693 if inlined != (member_inline_size <= 4) {
2694 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2695 }
2696 let inner_offset;
2697 let mut inner_depth = depth.clone();
2698 if inlined {
2699 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2700 inner_offset = next_offset;
2701 } else {
2702 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2703 inner_depth.increment()?;
2704 }
2705 let val_ref = self.startup.get_or_insert_with(|| {
2706 fidl::new_empty!(fidl_fuchsia_component_decl__common::StartupMode, D)
2707 });
2708 fidl::decode!(
2709 fidl_fuchsia_component_decl__common::StartupMode,
2710 D,
2711 val_ref,
2712 decoder,
2713 inner_offset,
2714 inner_depth
2715 )?;
2716 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2717 {
2718 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2719 }
2720 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2721 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2722 }
2723 }
2724
2725 next_offset += envelope_size;
2726 _next_ordinal_to_read += 1;
2727 if next_offset >= end_offset {
2728 return Ok(());
2729 }
2730
2731 while _next_ordinal_to_read < 2 {
2733 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2734 _next_ordinal_to_read += 1;
2735 next_offset += envelope_size;
2736 }
2737
2738 let next_out_of_line = decoder.next_out_of_line();
2739 let handles_before = decoder.remaining_handles();
2740 if let Some((inlined, num_bytes, num_handles)) =
2741 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2742 {
2743 let member_inline_size =
2744 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2745 decoder.context,
2746 );
2747 if inlined != (member_inline_size <= 4) {
2748 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2749 }
2750 let inner_offset;
2751 let mut inner_depth = depth.clone();
2752 if inlined {
2753 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2754 inner_offset = next_offset;
2755 } else {
2756 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2757 inner_depth.increment()?;
2758 }
2759 let val_ref = self
2760 .environment
2761 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2762 fidl::decode!(
2763 fidl::encoding::BoundedString<255>,
2764 D,
2765 val_ref,
2766 decoder,
2767 inner_offset,
2768 inner_depth
2769 )?;
2770 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2771 {
2772 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2773 }
2774 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2775 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2776 }
2777 }
2778
2779 next_offset += envelope_size;
2780 _next_ordinal_to_read += 1;
2781 if next_offset >= end_offset {
2782 return Ok(());
2783 }
2784
2785 while _next_ordinal_to_read < 3 {
2787 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2788 _next_ordinal_to_read += 1;
2789 next_offset += envelope_size;
2790 }
2791
2792 let next_out_of_line = decoder.next_out_of_line();
2793 let handles_before = decoder.remaining_handles();
2794 if let Some((inlined, num_bytes, num_handles)) =
2795 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2796 {
2797 let member_inline_size = <fidl_fuchsia_component_decl__common::OnTerminate as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2798 if inlined != (member_inline_size <= 4) {
2799 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2800 }
2801 let inner_offset;
2802 let mut inner_depth = depth.clone();
2803 if inlined {
2804 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2805 inner_offset = next_offset;
2806 } else {
2807 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2808 inner_depth.increment()?;
2809 }
2810 let val_ref = self.on_terminate.get_or_insert_with(|| {
2811 fidl::new_empty!(fidl_fuchsia_component_decl__common::OnTerminate, D)
2812 });
2813 fidl::decode!(
2814 fidl_fuchsia_component_decl__common::OnTerminate,
2815 D,
2816 val_ref,
2817 decoder,
2818 inner_offset,
2819 inner_depth
2820 )?;
2821 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2822 {
2823 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2824 }
2825 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2826 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2827 }
2828 }
2829
2830 next_offset += envelope_size;
2831 _next_ordinal_to_read += 1;
2832 if next_offset >= end_offset {
2833 return Ok(());
2834 }
2835
2836 while _next_ordinal_to_read < 4 {
2838 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2839 _next_ordinal_to_read += 1;
2840 next_offset += envelope_size;
2841 }
2842
2843 let next_out_of_line = decoder.next_out_of_line();
2844 let handles_before = decoder.remaining_handles();
2845 if let Some((inlined, num_bytes, num_handles)) =
2846 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2847 {
2848 let member_inline_size = <fidl::encoding::UnboundedVector<
2849 fidl_fuchsia_component_decl__common::ConfigOverride,
2850 > as fidl::encoding::TypeMarker>::inline_size(
2851 decoder.context
2852 );
2853 if inlined != (member_inline_size <= 4) {
2854 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2855 }
2856 let inner_offset;
2857 let mut inner_depth = depth.clone();
2858 if inlined {
2859 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2860 inner_offset = next_offset;
2861 } else {
2862 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2863 inner_depth.increment()?;
2864 }
2865 let val_ref = self.config_overrides.get_or_insert_with(|| {
2866 fidl::new_empty!(
2867 fidl::encoding::UnboundedVector<
2868 fidl_fuchsia_component_decl__common::ConfigOverride,
2869 >,
2870 D
2871 )
2872 });
2873 fidl::decode!(
2874 fidl::encoding::UnboundedVector<
2875 fidl_fuchsia_component_decl__common::ConfigOverride,
2876 >,
2877 D,
2878 val_ref,
2879 decoder,
2880 inner_offset,
2881 inner_depth
2882 )?;
2883 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2884 {
2885 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2886 }
2887 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2888 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2889 }
2890 }
2891
2892 next_offset += envelope_size;
2893
2894 while next_offset < end_offset {
2896 _next_ordinal_to_read += 1;
2897 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2898 next_offset += envelope_size;
2899 }
2900
2901 Ok(())
2902 }
2903 }
2904
2905 impl Config {
2906 #[inline(always)]
2907 fn max_ordinal_present(&self) -> u64 {
2908 if let Some(_) = self.availability {
2909 return 3;
2910 }
2911 if let Some(_) = self.as_ {
2912 return 2;
2913 }
2914 if let Some(_) = self.name {
2915 return 1;
2916 }
2917 0
2918 }
2919 }
2920
2921 impl fidl::encoding::ValueTypeMarker for Config {
2922 type Borrowed<'a> = &'a Self;
2923 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2924 value
2925 }
2926 }
2927
2928 unsafe impl fidl::encoding::TypeMarker for Config {
2929 type Owned = Self;
2930
2931 #[inline(always)]
2932 fn inline_align(_context: fidl::encoding::Context) -> usize {
2933 8
2934 }
2935
2936 #[inline(always)]
2937 fn inline_size(_context: fidl::encoding::Context) -> usize {
2938 16
2939 }
2940 }
2941
2942 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Config, D> for &Config {
2943 unsafe fn encode(
2944 self,
2945 encoder: &mut fidl::encoding::Encoder<'_, D>,
2946 offset: usize,
2947 mut depth: fidl::encoding::Depth,
2948 ) -> fidl::Result<()> {
2949 encoder.debug_check_bounds::<Config>(offset);
2950 let max_ordinal: u64 = self.max_ordinal_present();
2952 encoder.write_num(max_ordinal, offset);
2953 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2954 if max_ordinal == 0 {
2956 return Ok(());
2957 }
2958 depth.increment()?;
2959 let envelope_size = 8;
2960 let bytes_len = max_ordinal as usize * envelope_size;
2961 #[allow(unused_variables)]
2962 let offset = encoder.out_of_line_offset(bytes_len);
2963 let mut _prev_end_offset: usize = 0;
2964 if 1 > max_ordinal {
2965 return Ok(());
2966 }
2967
2968 let cur_offset: usize = (1 - 1) * envelope_size;
2971
2972 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2974
2975 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
2980 self.name.as_ref().map(
2981 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
2982 ),
2983 encoder,
2984 offset + cur_offset,
2985 depth,
2986 )?;
2987
2988 _prev_end_offset = cur_offset + envelope_size;
2989 if 2 > max_ordinal {
2990 return Ok(());
2991 }
2992
2993 let cur_offset: usize = (2 - 1) * envelope_size;
2996
2997 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2999
3000 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3005 self.as_.as_ref().map(
3006 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3007 ),
3008 encoder,
3009 offset + cur_offset,
3010 depth,
3011 )?;
3012
3013 _prev_end_offset = cur_offset + envelope_size;
3014 if 3 > max_ordinal {
3015 return Ok(());
3016 }
3017
3018 let cur_offset: usize = (3 - 1) * envelope_size;
3021
3022 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3024
3025 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
3030 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
3031 encoder, offset + cur_offset, depth
3032 )?;
3033
3034 _prev_end_offset = cur_offset + envelope_size;
3035
3036 Ok(())
3037 }
3038 }
3039
3040 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Config {
3041 #[inline(always)]
3042 fn new_empty() -> Self {
3043 Self::default()
3044 }
3045
3046 unsafe fn decode(
3047 &mut self,
3048 decoder: &mut fidl::encoding::Decoder<'_, D>,
3049 offset: usize,
3050 mut depth: fidl::encoding::Depth,
3051 ) -> fidl::Result<()> {
3052 decoder.debug_check_bounds::<Self>(offset);
3053 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3054 None => return Err(fidl::Error::NotNullable),
3055 Some(len) => len,
3056 };
3057 if len == 0 {
3059 return Ok(());
3060 };
3061 depth.increment()?;
3062 let envelope_size = 8;
3063 let bytes_len = len * envelope_size;
3064 let offset = decoder.out_of_line_offset(bytes_len)?;
3065 let mut _next_ordinal_to_read = 0;
3067 let mut next_offset = offset;
3068 let end_offset = offset + bytes_len;
3069 _next_ordinal_to_read += 1;
3070 if next_offset >= end_offset {
3071 return Ok(());
3072 }
3073
3074 while _next_ordinal_to_read < 1 {
3076 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3077 _next_ordinal_to_read += 1;
3078 next_offset += envelope_size;
3079 }
3080
3081 let next_out_of_line = decoder.next_out_of_line();
3082 let handles_before = decoder.remaining_handles();
3083 if let Some((inlined, num_bytes, num_handles)) =
3084 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3085 {
3086 let member_inline_size =
3087 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3088 decoder.context,
3089 );
3090 if inlined != (member_inline_size <= 4) {
3091 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3092 }
3093 let inner_offset;
3094 let mut inner_depth = depth.clone();
3095 if inlined {
3096 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3097 inner_offset = next_offset;
3098 } else {
3099 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3100 inner_depth.increment()?;
3101 }
3102 let val_ref = self
3103 .name
3104 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3105 fidl::decode!(
3106 fidl::encoding::BoundedString<255>,
3107 D,
3108 val_ref,
3109 decoder,
3110 inner_offset,
3111 inner_depth
3112 )?;
3113 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3114 {
3115 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3116 }
3117 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3118 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3119 }
3120 }
3121
3122 next_offset += envelope_size;
3123 _next_ordinal_to_read += 1;
3124 if next_offset >= end_offset {
3125 return Ok(());
3126 }
3127
3128 while _next_ordinal_to_read < 2 {
3130 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3131 _next_ordinal_to_read += 1;
3132 next_offset += envelope_size;
3133 }
3134
3135 let next_out_of_line = decoder.next_out_of_line();
3136 let handles_before = decoder.remaining_handles();
3137 if let Some((inlined, num_bytes, num_handles)) =
3138 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3139 {
3140 let member_inline_size =
3141 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3142 decoder.context,
3143 );
3144 if inlined != (member_inline_size <= 4) {
3145 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3146 }
3147 let inner_offset;
3148 let mut inner_depth = depth.clone();
3149 if inlined {
3150 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3151 inner_offset = next_offset;
3152 } else {
3153 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3154 inner_depth.increment()?;
3155 }
3156 let val_ref = self
3157 .as_
3158 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3159 fidl::decode!(
3160 fidl::encoding::BoundedString<255>,
3161 D,
3162 val_ref,
3163 decoder,
3164 inner_offset,
3165 inner_depth
3166 )?;
3167 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3168 {
3169 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3170 }
3171 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3172 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3173 }
3174 }
3175
3176 next_offset += envelope_size;
3177 _next_ordinal_to_read += 1;
3178 if next_offset >= end_offset {
3179 return Ok(());
3180 }
3181
3182 while _next_ordinal_to_read < 3 {
3184 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3185 _next_ordinal_to_read += 1;
3186 next_offset += envelope_size;
3187 }
3188
3189 let next_out_of_line = decoder.next_out_of_line();
3190 let handles_before = decoder.remaining_handles();
3191 if let Some((inlined, num_bytes, num_handles)) =
3192 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3193 {
3194 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3195 if inlined != (member_inline_size <= 4) {
3196 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3197 }
3198 let inner_offset;
3199 let mut inner_depth = depth.clone();
3200 if inlined {
3201 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3202 inner_offset = next_offset;
3203 } else {
3204 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3205 inner_depth.increment()?;
3206 }
3207 let val_ref = self.availability.get_or_insert_with(|| {
3208 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
3209 });
3210 fidl::decode!(
3211 fidl_fuchsia_component_decl__common::Availability,
3212 D,
3213 val_ref,
3214 decoder,
3215 inner_offset,
3216 inner_depth
3217 )?;
3218 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3219 {
3220 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3221 }
3222 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3223 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3224 }
3225 }
3226
3227 next_offset += envelope_size;
3228
3229 while next_offset < end_offset {
3231 _next_ordinal_to_read += 1;
3232 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3233 next_offset += envelope_size;
3234 }
3235
3236 Ok(())
3237 }
3238 }
3239
3240 impl Dictionary {
3241 #[inline(always)]
3242 fn max_ordinal_present(&self) -> u64 {
3243 if let Some(_) = self.from_dictionary {
3244 return 5;
3245 }
3246 if let Some(_) = self.availability {
3247 return 4;
3248 }
3249 if let Some(_) = self.type_ {
3250 return 3;
3251 }
3252 if let Some(_) = self.as_ {
3253 return 2;
3254 }
3255 if let Some(_) = self.name {
3256 return 1;
3257 }
3258 0
3259 }
3260 }
3261
3262 impl fidl::encoding::ValueTypeMarker for Dictionary {
3263 type Borrowed<'a> = &'a Self;
3264 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3265 value
3266 }
3267 }
3268
3269 unsafe impl fidl::encoding::TypeMarker for Dictionary {
3270 type Owned = Self;
3271
3272 #[inline(always)]
3273 fn inline_align(_context: fidl::encoding::Context) -> usize {
3274 8
3275 }
3276
3277 #[inline(always)]
3278 fn inline_size(_context: fidl::encoding::Context) -> usize {
3279 16
3280 }
3281 }
3282
3283 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dictionary, D>
3284 for &Dictionary
3285 {
3286 unsafe fn encode(
3287 self,
3288 encoder: &mut fidl::encoding::Encoder<'_, D>,
3289 offset: usize,
3290 mut depth: fidl::encoding::Depth,
3291 ) -> fidl::Result<()> {
3292 encoder.debug_check_bounds::<Dictionary>(offset);
3293 let max_ordinal: u64 = self.max_ordinal_present();
3295 encoder.write_num(max_ordinal, offset);
3296 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3297 if max_ordinal == 0 {
3299 return Ok(());
3300 }
3301 depth.increment()?;
3302 let envelope_size = 8;
3303 let bytes_len = max_ordinal as usize * envelope_size;
3304 #[allow(unused_variables)]
3305 let offset = encoder.out_of_line_offset(bytes_len);
3306 let mut _prev_end_offset: usize = 0;
3307 if 1 > max_ordinal {
3308 return Ok(());
3309 }
3310
3311 let cur_offset: usize = (1 - 1) * envelope_size;
3314
3315 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3317
3318 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3323 self.name.as_ref().map(
3324 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3325 ),
3326 encoder,
3327 offset + cur_offset,
3328 depth,
3329 )?;
3330
3331 _prev_end_offset = cur_offset + envelope_size;
3332 if 2 > max_ordinal {
3333 return Ok(());
3334 }
3335
3336 let cur_offset: usize = (2 - 1) * envelope_size;
3339
3340 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3342
3343 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3348 self.as_.as_ref().map(
3349 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3350 ),
3351 encoder,
3352 offset + cur_offset,
3353 depth,
3354 )?;
3355
3356 _prev_end_offset = cur_offset + envelope_size;
3357 if 3 > max_ordinal {
3358 return Ok(());
3359 }
3360
3361 let cur_offset: usize = (3 - 1) * envelope_size;
3364
3365 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3367
3368 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::DependencyType, D>(
3373 self.type_.as_ref().map(<fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
3374 encoder, offset + cur_offset, depth
3375 )?;
3376
3377 _prev_end_offset = cur_offset + envelope_size;
3378 if 4 > max_ordinal {
3379 return Ok(());
3380 }
3381
3382 let cur_offset: usize = (4 - 1) * envelope_size;
3385
3386 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3388
3389 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
3394 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
3395 encoder, offset + cur_offset, depth
3396 )?;
3397
3398 _prev_end_offset = cur_offset + envelope_size;
3399 if 5 > max_ordinal {
3400 return Ok(());
3401 }
3402
3403 let cur_offset: usize = (5 - 1) * envelope_size;
3406
3407 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3409
3410 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3415 self.from_dictionary.as_ref().map(
3416 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3417 ),
3418 encoder,
3419 offset + cur_offset,
3420 depth,
3421 )?;
3422
3423 _prev_end_offset = cur_offset + envelope_size;
3424
3425 Ok(())
3426 }
3427 }
3428
3429 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dictionary {
3430 #[inline(always)]
3431 fn new_empty() -> Self {
3432 Self::default()
3433 }
3434
3435 unsafe fn decode(
3436 &mut self,
3437 decoder: &mut fidl::encoding::Decoder<'_, D>,
3438 offset: usize,
3439 mut depth: fidl::encoding::Depth,
3440 ) -> fidl::Result<()> {
3441 decoder.debug_check_bounds::<Self>(offset);
3442 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3443 None => return Err(fidl::Error::NotNullable),
3444 Some(len) => len,
3445 };
3446 if len == 0 {
3448 return Ok(());
3449 };
3450 depth.increment()?;
3451 let envelope_size = 8;
3452 let bytes_len = len * envelope_size;
3453 let offset = decoder.out_of_line_offset(bytes_len)?;
3454 let mut _next_ordinal_to_read = 0;
3456 let mut next_offset = offset;
3457 let end_offset = offset + bytes_len;
3458 _next_ordinal_to_read += 1;
3459 if next_offset >= end_offset {
3460 return Ok(());
3461 }
3462
3463 while _next_ordinal_to_read < 1 {
3465 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3466 _next_ordinal_to_read += 1;
3467 next_offset += envelope_size;
3468 }
3469
3470 let next_out_of_line = decoder.next_out_of_line();
3471 let handles_before = decoder.remaining_handles();
3472 if let Some((inlined, num_bytes, num_handles)) =
3473 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3474 {
3475 let member_inline_size =
3476 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3477 decoder.context,
3478 );
3479 if inlined != (member_inline_size <= 4) {
3480 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3481 }
3482 let inner_offset;
3483 let mut inner_depth = depth.clone();
3484 if inlined {
3485 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3486 inner_offset = next_offset;
3487 } else {
3488 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3489 inner_depth.increment()?;
3490 }
3491 let val_ref = self
3492 .name
3493 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3494 fidl::decode!(
3495 fidl::encoding::BoundedString<255>,
3496 D,
3497 val_ref,
3498 decoder,
3499 inner_offset,
3500 inner_depth
3501 )?;
3502 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3503 {
3504 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3505 }
3506 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3507 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3508 }
3509 }
3510
3511 next_offset += envelope_size;
3512 _next_ordinal_to_read += 1;
3513 if next_offset >= end_offset {
3514 return Ok(());
3515 }
3516
3517 while _next_ordinal_to_read < 2 {
3519 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3520 _next_ordinal_to_read += 1;
3521 next_offset += envelope_size;
3522 }
3523
3524 let next_out_of_line = decoder.next_out_of_line();
3525 let handles_before = decoder.remaining_handles();
3526 if let Some((inlined, num_bytes, num_handles)) =
3527 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3528 {
3529 let member_inline_size =
3530 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3531 decoder.context,
3532 );
3533 if inlined != (member_inline_size <= 4) {
3534 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3535 }
3536 let inner_offset;
3537 let mut inner_depth = depth.clone();
3538 if inlined {
3539 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3540 inner_offset = next_offset;
3541 } else {
3542 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3543 inner_depth.increment()?;
3544 }
3545 let val_ref = self
3546 .as_
3547 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3548 fidl::decode!(
3549 fidl::encoding::BoundedString<255>,
3550 D,
3551 val_ref,
3552 decoder,
3553 inner_offset,
3554 inner_depth
3555 )?;
3556 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3557 {
3558 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3559 }
3560 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3561 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3562 }
3563 }
3564
3565 next_offset += envelope_size;
3566 _next_ordinal_to_read += 1;
3567 if next_offset >= end_offset {
3568 return Ok(());
3569 }
3570
3571 while _next_ordinal_to_read < 3 {
3573 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3574 _next_ordinal_to_read += 1;
3575 next_offset += envelope_size;
3576 }
3577
3578 let next_out_of_line = decoder.next_out_of_line();
3579 let handles_before = decoder.remaining_handles();
3580 if let Some((inlined, num_bytes, num_handles)) =
3581 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3582 {
3583 let member_inline_size = <fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3584 if inlined != (member_inline_size <= 4) {
3585 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3586 }
3587 let inner_offset;
3588 let mut inner_depth = depth.clone();
3589 if inlined {
3590 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3591 inner_offset = next_offset;
3592 } else {
3593 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3594 inner_depth.increment()?;
3595 }
3596 let val_ref = self.type_.get_or_insert_with(|| {
3597 fidl::new_empty!(fidl_fuchsia_component_decl__common::DependencyType, D)
3598 });
3599 fidl::decode!(
3600 fidl_fuchsia_component_decl__common::DependencyType,
3601 D,
3602 val_ref,
3603 decoder,
3604 inner_offset,
3605 inner_depth
3606 )?;
3607 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3608 {
3609 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3610 }
3611 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3612 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3613 }
3614 }
3615
3616 next_offset += envelope_size;
3617 _next_ordinal_to_read += 1;
3618 if next_offset >= end_offset {
3619 return Ok(());
3620 }
3621
3622 while _next_ordinal_to_read < 4 {
3624 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3625 _next_ordinal_to_read += 1;
3626 next_offset += envelope_size;
3627 }
3628
3629 let next_out_of_line = decoder.next_out_of_line();
3630 let handles_before = decoder.remaining_handles();
3631 if let Some((inlined, num_bytes, num_handles)) =
3632 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3633 {
3634 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3635 if inlined != (member_inline_size <= 4) {
3636 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3637 }
3638 let inner_offset;
3639 let mut inner_depth = depth.clone();
3640 if inlined {
3641 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3642 inner_offset = next_offset;
3643 } else {
3644 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3645 inner_depth.increment()?;
3646 }
3647 let val_ref = self.availability.get_or_insert_with(|| {
3648 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
3649 });
3650 fidl::decode!(
3651 fidl_fuchsia_component_decl__common::Availability,
3652 D,
3653 val_ref,
3654 decoder,
3655 inner_offset,
3656 inner_depth
3657 )?;
3658 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3659 {
3660 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3661 }
3662 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3663 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3664 }
3665 }
3666
3667 next_offset += envelope_size;
3668 _next_ordinal_to_read += 1;
3669 if next_offset >= end_offset {
3670 return Ok(());
3671 }
3672
3673 while _next_ordinal_to_read < 5 {
3675 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3676 _next_ordinal_to_read += 1;
3677 next_offset += envelope_size;
3678 }
3679
3680 let next_out_of_line = decoder.next_out_of_line();
3681 let handles_before = decoder.remaining_handles();
3682 if let Some((inlined, num_bytes, num_handles)) =
3683 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3684 {
3685 let member_inline_size =
3686 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
3687 decoder.context,
3688 );
3689 if inlined != (member_inline_size <= 4) {
3690 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3691 }
3692 let inner_offset;
3693 let mut inner_depth = depth.clone();
3694 if inlined {
3695 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3696 inner_offset = next_offset;
3697 } else {
3698 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3699 inner_depth.increment()?;
3700 }
3701 let val_ref = self
3702 .from_dictionary
3703 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
3704 fidl::decode!(
3705 fidl::encoding::UnboundedString,
3706 D,
3707 val_ref,
3708 decoder,
3709 inner_offset,
3710 inner_depth
3711 )?;
3712 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3713 {
3714 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3715 }
3716 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3717 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3718 }
3719 }
3720
3721 next_offset += envelope_size;
3722
3723 while next_offset < end_offset {
3725 _next_ordinal_to_read += 1;
3726 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3727 next_offset += envelope_size;
3728 }
3729
3730 Ok(())
3731 }
3732 }
3733
3734 impl Directory {
3735 #[inline(always)]
3736 fn max_ordinal_present(&self) -> u64 {
3737 if let Some(_) = self.from_dictionary {
3738 return 8;
3739 }
3740 if let Some(_) = self.availability {
3741 return 7;
3742 }
3743 if let Some(_) = self.path {
3744 return 6;
3745 }
3746 if let Some(_) = self.rights {
3747 return 5;
3748 }
3749 if let Some(_) = self.subdir {
3750 return 4;
3751 }
3752 if let Some(_) = self.type_ {
3753 return 3;
3754 }
3755 if let Some(_) = self.as_ {
3756 return 2;
3757 }
3758 if let Some(_) = self.name {
3759 return 1;
3760 }
3761 0
3762 }
3763 }
3764
3765 impl fidl::encoding::ValueTypeMarker for Directory {
3766 type Borrowed<'a> = &'a Self;
3767 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3768 value
3769 }
3770 }
3771
3772 unsafe impl fidl::encoding::TypeMarker for Directory {
3773 type Owned = Self;
3774
3775 #[inline(always)]
3776 fn inline_align(_context: fidl::encoding::Context) -> usize {
3777 8
3778 }
3779
3780 #[inline(always)]
3781 fn inline_size(_context: fidl::encoding::Context) -> usize {
3782 16
3783 }
3784 }
3785
3786 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Directory, D>
3787 for &Directory
3788 {
3789 unsafe fn encode(
3790 self,
3791 encoder: &mut fidl::encoding::Encoder<'_, D>,
3792 offset: usize,
3793 mut depth: fidl::encoding::Depth,
3794 ) -> fidl::Result<()> {
3795 encoder.debug_check_bounds::<Directory>(offset);
3796 let max_ordinal: u64 = self.max_ordinal_present();
3798 encoder.write_num(max_ordinal, offset);
3799 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3800 if max_ordinal == 0 {
3802 return Ok(());
3803 }
3804 depth.increment()?;
3805 let envelope_size = 8;
3806 let bytes_len = max_ordinal as usize * envelope_size;
3807 #[allow(unused_variables)]
3808 let offset = encoder.out_of_line_offset(bytes_len);
3809 let mut _prev_end_offset: usize = 0;
3810 if 1 > max_ordinal {
3811 return Ok(());
3812 }
3813
3814 let cur_offset: usize = (1 - 1) * envelope_size;
3817
3818 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3820
3821 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3826 self.name.as_ref().map(
3827 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3828 ),
3829 encoder,
3830 offset + cur_offset,
3831 depth,
3832 )?;
3833
3834 _prev_end_offset = cur_offset + envelope_size;
3835 if 2 > max_ordinal {
3836 return Ok(());
3837 }
3838
3839 let cur_offset: usize = (2 - 1) * envelope_size;
3842
3843 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3845
3846 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3851 self.as_.as_ref().map(
3852 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3853 ),
3854 encoder,
3855 offset + cur_offset,
3856 depth,
3857 )?;
3858
3859 _prev_end_offset = cur_offset + envelope_size;
3860 if 3 > max_ordinal {
3861 return Ok(());
3862 }
3863
3864 let cur_offset: usize = (3 - 1) * envelope_size;
3867
3868 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3870
3871 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::DependencyType, D>(
3876 self.type_.as_ref().map(<fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
3877 encoder, offset + cur_offset, depth
3878 )?;
3879
3880 _prev_end_offset = cur_offset + envelope_size;
3881 if 4 > max_ordinal {
3882 return Ok(());
3883 }
3884
3885 let cur_offset: usize = (4 - 1) * envelope_size;
3888
3889 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3891
3892 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
3897 self.subdir.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
3898 encoder, offset + cur_offset, depth
3899 )?;
3900
3901 _prev_end_offset = cur_offset + envelope_size;
3902 if 5 > max_ordinal {
3903 return Ok(());
3904 }
3905
3906 let cur_offset: usize = (5 - 1) * envelope_size;
3909
3910 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3912
3913 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_io__common::Operations, D>(
3918 self.rights.as_ref().map(<fidl_fuchsia_io__common::Operations as fidl::encoding::ValueTypeMarker>::borrow),
3919 encoder, offset + cur_offset, depth
3920 )?;
3921
3922 _prev_end_offset = cur_offset + envelope_size;
3923 if 6 > max_ordinal {
3924 return Ok(());
3925 }
3926
3927 let cur_offset: usize = (6 - 1) * envelope_size;
3930
3931 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3933
3934 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
3939 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
3940 encoder, offset + cur_offset, depth
3941 )?;
3942
3943 _prev_end_offset = cur_offset + envelope_size;
3944 if 7 > max_ordinal {
3945 return Ok(());
3946 }
3947
3948 let cur_offset: usize = (7 - 1) * envelope_size;
3951
3952 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3954
3955 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
3960 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
3961 encoder, offset + cur_offset, depth
3962 )?;
3963
3964 _prev_end_offset = cur_offset + envelope_size;
3965 if 8 > max_ordinal {
3966 return Ok(());
3967 }
3968
3969 let cur_offset: usize = (8 - 1) * envelope_size;
3972
3973 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3975
3976 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3981 self.from_dictionary.as_ref().map(
3982 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3983 ),
3984 encoder,
3985 offset + cur_offset,
3986 depth,
3987 )?;
3988
3989 _prev_end_offset = cur_offset + envelope_size;
3990
3991 Ok(())
3992 }
3993 }
3994
3995 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Directory {
3996 #[inline(always)]
3997 fn new_empty() -> Self {
3998 Self::default()
3999 }
4000
4001 unsafe fn decode(
4002 &mut self,
4003 decoder: &mut fidl::encoding::Decoder<'_, D>,
4004 offset: usize,
4005 mut depth: fidl::encoding::Depth,
4006 ) -> fidl::Result<()> {
4007 decoder.debug_check_bounds::<Self>(offset);
4008 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4009 None => return Err(fidl::Error::NotNullable),
4010 Some(len) => len,
4011 };
4012 if len == 0 {
4014 return Ok(());
4015 };
4016 depth.increment()?;
4017 let envelope_size = 8;
4018 let bytes_len = len * envelope_size;
4019 let offset = decoder.out_of_line_offset(bytes_len)?;
4020 let mut _next_ordinal_to_read = 0;
4022 let mut next_offset = offset;
4023 let end_offset = offset + bytes_len;
4024 _next_ordinal_to_read += 1;
4025 if next_offset >= end_offset {
4026 return Ok(());
4027 }
4028
4029 while _next_ordinal_to_read < 1 {
4031 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4032 _next_ordinal_to_read += 1;
4033 next_offset += envelope_size;
4034 }
4035
4036 let next_out_of_line = decoder.next_out_of_line();
4037 let handles_before = decoder.remaining_handles();
4038 if let Some((inlined, num_bytes, num_handles)) =
4039 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4040 {
4041 let member_inline_size =
4042 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
4043 decoder.context,
4044 );
4045 if inlined != (member_inline_size <= 4) {
4046 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4047 }
4048 let inner_offset;
4049 let mut inner_depth = depth.clone();
4050 if inlined {
4051 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4052 inner_offset = next_offset;
4053 } else {
4054 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4055 inner_depth.increment()?;
4056 }
4057 let val_ref = self
4058 .name
4059 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
4060 fidl::decode!(
4061 fidl::encoding::BoundedString<255>,
4062 D,
4063 val_ref,
4064 decoder,
4065 inner_offset,
4066 inner_depth
4067 )?;
4068 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4069 {
4070 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4071 }
4072 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4073 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4074 }
4075 }
4076
4077 next_offset += envelope_size;
4078 _next_ordinal_to_read += 1;
4079 if next_offset >= end_offset {
4080 return Ok(());
4081 }
4082
4083 while _next_ordinal_to_read < 2 {
4085 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4086 _next_ordinal_to_read += 1;
4087 next_offset += envelope_size;
4088 }
4089
4090 let next_out_of_line = decoder.next_out_of_line();
4091 let handles_before = decoder.remaining_handles();
4092 if let Some((inlined, num_bytes, num_handles)) =
4093 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4094 {
4095 let member_inline_size =
4096 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
4097 decoder.context,
4098 );
4099 if inlined != (member_inline_size <= 4) {
4100 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4101 }
4102 let inner_offset;
4103 let mut inner_depth = depth.clone();
4104 if inlined {
4105 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4106 inner_offset = next_offset;
4107 } else {
4108 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4109 inner_depth.increment()?;
4110 }
4111 let val_ref = self
4112 .as_
4113 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
4114 fidl::decode!(
4115 fidl::encoding::BoundedString<255>,
4116 D,
4117 val_ref,
4118 decoder,
4119 inner_offset,
4120 inner_depth
4121 )?;
4122 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4123 {
4124 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4125 }
4126 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4127 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4128 }
4129 }
4130
4131 next_offset += envelope_size;
4132 _next_ordinal_to_read += 1;
4133 if next_offset >= end_offset {
4134 return Ok(());
4135 }
4136
4137 while _next_ordinal_to_read < 3 {
4139 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4140 _next_ordinal_to_read += 1;
4141 next_offset += envelope_size;
4142 }
4143
4144 let next_out_of_line = decoder.next_out_of_line();
4145 let handles_before = decoder.remaining_handles();
4146 if let Some((inlined, num_bytes, num_handles)) =
4147 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4148 {
4149 let member_inline_size = <fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4150 if inlined != (member_inline_size <= 4) {
4151 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4152 }
4153 let inner_offset;
4154 let mut inner_depth = depth.clone();
4155 if inlined {
4156 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4157 inner_offset = next_offset;
4158 } else {
4159 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4160 inner_depth.increment()?;
4161 }
4162 let val_ref = self.type_.get_or_insert_with(|| {
4163 fidl::new_empty!(fidl_fuchsia_component_decl__common::DependencyType, D)
4164 });
4165 fidl::decode!(
4166 fidl_fuchsia_component_decl__common::DependencyType,
4167 D,
4168 val_ref,
4169 decoder,
4170 inner_offset,
4171 inner_depth
4172 )?;
4173 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4174 {
4175 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4176 }
4177 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4178 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4179 }
4180 }
4181
4182 next_offset += envelope_size;
4183 _next_ordinal_to_read += 1;
4184 if next_offset >= end_offset {
4185 return Ok(());
4186 }
4187
4188 while _next_ordinal_to_read < 4 {
4190 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4191 _next_ordinal_to_read += 1;
4192 next_offset += envelope_size;
4193 }
4194
4195 let next_out_of_line = decoder.next_out_of_line();
4196 let handles_before = decoder.remaining_handles();
4197 if let Some((inlined, num_bytes, num_handles)) =
4198 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4199 {
4200 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4201 if inlined != (member_inline_size <= 4) {
4202 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4203 }
4204 let inner_offset;
4205 let mut inner_depth = depth.clone();
4206 if inlined {
4207 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4208 inner_offset = next_offset;
4209 } else {
4210 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4211 inner_depth.increment()?;
4212 }
4213 let val_ref = self.subdir.get_or_insert_with(|| {
4214 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
4215 });
4216 fidl::decode!(
4217 fidl::encoding::BoundedString<4095>,
4218 D,
4219 val_ref,
4220 decoder,
4221 inner_offset,
4222 inner_depth
4223 )?;
4224 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4225 {
4226 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4227 }
4228 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4229 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4230 }
4231 }
4232
4233 next_offset += envelope_size;
4234 _next_ordinal_to_read += 1;
4235 if next_offset >= end_offset {
4236 return Ok(());
4237 }
4238
4239 while _next_ordinal_to_read < 5 {
4241 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4242 _next_ordinal_to_read += 1;
4243 next_offset += envelope_size;
4244 }
4245
4246 let next_out_of_line = decoder.next_out_of_line();
4247 let handles_before = decoder.remaining_handles();
4248 if let Some((inlined, num_bytes, num_handles)) =
4249 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4250 {
4251 let member_inline_size = <fidl_fuchsia_io__common::Operations as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4252 if inlined != (member_inline_size <= 4) {
4253 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4254 }
4255 let inner_offset;
4256 let mut inner_depth = depth.clone();
4257 if inlined {
4258 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4259 inner_offset = next_offset;
4260 } else {
4261 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4262 inner_depth.increment()?;
4263 }
4264 let val_ref = self.rights.get_or_insert_with(|| {
4265 fidl::new_empty!(fidl_fuchsia_io__common::Operations, D)
4266 });
4267 fidl::decode!(
4268 fidl_fuchsia_io__common::Operations,
4269 D,
4270 val_ref,
4271 decoder,
4272 inner_offset,
4273 inner_depth
4274 )?;
4275 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4276 {
4277 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4278 }
4279 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4280 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4281 }
4282 }
4283
4284 next_offset += envelope_size;
4285 _next_ordinal_to_read += 1;
4286 if next_offset >= end_offset {
4287 return Ok(());
4288 }
4289
4290 while _next_ordinal_to_read < 6 {
4292 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4293 _next_ordinal_to_read += 1;
4294 next_offset += envelope_size;
4295 }
4296
4297 let next_out_of_line = decoder.next_out_of_line();
4298 let handles_before = decoder.remaining_handles();
4299 if let Some((inlined, num_bytes, num_handles)) =
4300 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4301 {
4302 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4303 if inlined != (member_inline_size <= 4) {
4304 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4305 }
4306 let inner_offset;
4307 let mut inner_depth = depth.clone();
4308 if inlined {
4309 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4310 inner_offset = next_offset;
4311 } else {
4312 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4313 inner_depth.increment()?;
4314 }
4315 let val_ref = self.path.get_or_insert_with(|| {
4316 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
4317 });
4318 fidl::decode!(
4319 fidl::encoding::BoundedString<4095>,
4320 D,
4321 val_ref,
4322 decoder,
4323 inner_offset,
4324 inner_depth
4325 )?;
4326 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4327 {
4328 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4329 }
4330 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4331 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4332 }
4333 }
4334
4335 next_offset += envelope_size;
4336 _next_ordinal_to_read += 1;
4337 if next_offset >= end_offset {
4338 return Ok(());
4339 }
4340
4341 while _next_ordinal_to_read < 7 {
4343 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4344 _next_ordinal_to_read += 1;
4345 next_offset += envelope_size;
4346 }
4347
4348 let next_out_of_line = decoder.next_out_of_line();
4349 let handles_before = decoder.remaining_handles();
4350 if let Some((inlined, num_bytes, num_handles)) =
4351 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4352 {
4353 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4354 if inlined != (member_inline_size <= 4) {
4355 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4356 }
4357 let inner_offset;
4358 let mut inner_depth = depth.clone();
4359 if inlined {
4360 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4361 inner_offset = next_offset;
4362 } else {
4363 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4364 inner_depth.increment()?;
4365 }
4366 let val_ref = self.availability.get_or_insert_with(|| {
4367 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
4368 });
4369 fidl::decode!(
4370 fidl_fuchsia_component_decl__common::Availability,
4371 D,
4372 val_ref,
4373 decoder,
4374 inner_offset,
4375 inner_depth
4376 )?;
4377 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4378 {
4379 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4380 }
4381 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4382 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4383 }
4384 }
4385
4386 next_offset += envelope_size;
4387 _next_ordinal_to_read += 1;
4388 if next_offset >= end_offset {
4389 return Ok(());
4390 }
4391
4392 while _next_ordinal_to_read < 8 {
4394 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4395 _next_ordinal_to_read += 1;
4396 next_offset += envelope_size;
4397 }
4398
4399 let next_out_of_line = decoder.next_out_of_line();
4400 let handles_before = decoder.remaining_handles();
4401 if let Some((inlined, num_bytes, num_handles)) =
4402 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4403 {
4404 let member_inline_size =
4405 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4406 decoder.context,
4407 );
4408 if inlined != (member_inline_size <= 4) {
4409 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4410 }
4411 let inner_offset;
4412 let mut inner_depth = depth.clone();
4413 if inlined {
4414 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4415 inner_offset = next_offset;
4416 } else {
4417 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4418 inner_depth.increment()?;
4419 }
4420 let val_ref = self
4421 .from_dictionary
4422 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4423 fidl::decode!(
4424 fidl::encoding::UnboundedString,
4425 D,
4426 val_ref,
4427 decoder,
4428 inner_offset,
4429 inner_depth
4430 )?;
4431 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4432 {
4433 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4434 }
4435 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4436 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4437 }
4438 }
4439
4440 next_offset += envelope_size;
4441
4442 while next_offset < end_offset {
4444 _next_ordinal_to_read += 1;
4445 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4446 next_offset += envelope_size;
4447 }
4448
4449 Ok(())
4450 }
4451 }
4452
4453 impl Event {
4454 #[inline(always)]
4455 fn max_ordinal_present(&self) -> u64 {
4456 if let Some(_) = self.availability {
4457 return 4;
4458 }
4459 if let Some(_) = self.filter {
4460 return 3;
4461 }
4462 if let Some(_) = self.as_ {
4463 return 2;
4464 }
4465 if let Some(_) = self.name {
4466 return 1;
4467 }
4468 0
4469 }
4470 }
4471
4472 impl fidl::encoding::ValueTypeMarker for Event {
4473 type Borrowed<'a> = &'a Self;
4474 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4475 value
4476 }
4477 }
4478
4479 unsafe impl fidl::encoding::TypeMarker for Event {
4480 type Owned = Self;
4481
4482 #[inline(always)]
4483 fn inline_align(_context: fidl::encoding::Context) -> usize {
4484 8
4485 }
4486
4487 #[inline(always)]
4488 fn inline_size(_context: fidl::encoding::Context) -> usize {
4489 16
4490 }
4491 }
4492
4493 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Event, D> for &Event {
4494 unsafe fn encode(
4495 self,
4496 encoder: &mut fidl::encoding::Encoder<'_, D>,
4497 offset: usize,
4498 mut depth: fidl::encoding::Depth,
4499 ) -> fidl::Result<()> {
4500 encoder.debug_check_bounds::<Event>(offset);
4501 let max_ordinal: u64 = self.max_ordinal_present();
4503 encoder.write_num(max_ordinal, offset);
4504 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4505 if max_ordinal == 0 {
4507 return Ok(());
4508 }
4509 depth.increment()?;
4510 let envelope_size = 8;
4511 let bytes_len = max_ordinal as usize * envelope_size;
4512 #[allow(unused_variables)]
4513 let offset = encoder.out_of_line_offset(bytes_len);
4514 let mut _prev_end_offset: usize = 0;
4515 if 1 > max_ordinal {
4516 return Ok(());
4517 }
4518
4519 let cur_offset: usize = (1 - 1) * envelope_size;
4522
4523 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4525
4526 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
4531 self.name.as_ref().map(
4532 <fidl::encoding::BoundedString<255> 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 2 > max_ordinal {
4541 return Ok(());
4542 }
4543
4544 let cur_offset: usize = (2 - 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::BoundedString<255>, D>(
4556 self.as_.as_ref().map(
4557 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
4558 ),
4559 encoder,
4560 offset + cur_offset,
4561 depth,
4562 )?;
4563
4564 _prev_end_offset = cur_offset + envelope_size;
4565 if 3 > max_ordinal {
4566 return Ok(());
4567 }
4568
4569 let cur_offset: usize = (3 - 1) * envelope_size;
4572
4573 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4575
4576 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_data__common::Dictionary, D>(
4581 self.filter.as_ref().map(<fidl_fuchsia_data__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow),
4582 encoder, offset + cur_offset, depth
4583 )?;
4584
4585 _prev_end_offset = cur_offset + envelope_size;
4586 if 4 > max_ordinal {
4587 return Ok(());
4588 }
4589
4590 let cur_offset: usize = (4 - 1) * envelope_size;
4593
4594 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4596
4597 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
4602 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
4603 encoder, offset + cur_offset, depth
4604 )?;
4605
4606 _prev_end_offset = cur_offset + envelope_size;
4607
4608 Ok(())
4609 }
4610 }
4611
4612 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Event {
4613 #[inline(always)]
4614 fn new_empty() -> Self {
4615 Self::default()
4616 }
4617
4618 unsafe fn decode(
4619 &mut self,
4620 decoder: &mut fidl::encoding::Decoder<'_, D>,
4621 offset: usize,
4622 mut depth: fidl::encoding::Depth,
4623 ) -> fidl::Result<()> {
4624 decoder.debug_check_bounds::<Self>(offset);
4625 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4626 None => return Err(fidl::Error::NotNullable),
4627 Some(len) => len,
4628 };
4629 if len == 0 {
4631 return Ok(());
4632 };
4633 depth.increment()?;
4634 let envelope_size = 8;
4635 let bytes_len = len * envelope_size;
4636 let offset = decoder.out_of_line_offset(bytes_len)?;
4637 let mut _next_ordinal_to_read = 0;
4639 let mut next_offset = offset;
4640 let end_offset = offset + bytes_len;
4641 _next_ordinal_to_read += 1;
4642 if next_offset >= end_offset {
4643 return Ok(());
4644 }
4645
4646 while _next_ordinal_to_read < 1 {
4648 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4649 _next_ordinal_to_read += 1;
4650 next_offset += envelope_size;
4651 }
4652
4653 let next_out_of_line = decoder.next_out_of_line();
4654 let handles_before = decoder.remaining_handles();
4655 if let Some((inlined, num_bytes, num_handles)) =
4656 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4657 {
4658 let member_inline_size =
4659 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
4660 decoder.context,
4661 );
4662 if inlined != (member_inline_size <= 4) {
4663 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4664 }
4665 let inner_offset;
4666 let mut inner_depth = depth.clone();
4667 if inlined {
4668 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4669 inner_offset = next_offset;
4670 } else {
4671 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4672 inner_depth.increment()?;
4673 }
4674 let val_ref = self
4675 .name
4676 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
4677 fidl::decode!(
4678 fidl::encoding::BoundedString<255>,
4679 D,
4680 val_ref,
4681 decoder,
4682 inner_offset,
4683 inner_depth
4684 )?;
4685 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4686 {
4687 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4688 }
4689 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4690 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4691 }
4692 }
4693
4694 next_offset += envelope_size;
4695 _next_ordinal_to_read += 1;
4696 if next_offset >= end_offset {
4697 return Ok(());
4698 }
4699
4700 while _next_ordinal_to_read < 2 {
4702 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4703 _next_ordinal_to_read += 1;
4704 next_offset += envelope_size;
4705 }
4706
4707 let next_out_of_line = decoder.next_out_of_line();
4708 let handles_before = decoder.remaining_handles();
4709 if let Some((inlined, num_bytes, num_handles)) =
4710 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4711 {
4712 let member_inline_size =
4713 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
4714 decoder.context,
4715 );
4716 if inlined != (member_inline_size <= 4) {
4717 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4718 }
4719 let inner_offset;
4720 let mut inner_depth = depth.clone();
4721 if inlined {
4722 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4723 inner_offset = next_offset;
4724 } else {
4725 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4726 inner_depth.increment()?;
4727 }
4728 let val_ref = self
4729 .as_
4730 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
4731 fidl::decode!(
4732 fidl::encoding::BoundedString<255>,
4733 D,
4734 val_ref,
4735 decoder,
4736 inner_offset,
4737 inner_depth
4738 )?;
4739 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4740 {
4741 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4742 }
4743 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4744 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4745 }
4746 }
4747
4748 next_offset += envelope_size;
4749 _next_ordinal_to_read += 1;
4750 if next_offset >= end_offset {
4751 return Ok(());
4752 }
4753
4754 while _next_ordinal_to_read < 3 {
4756 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4757 _next_ordinal_to_read += 1;
4758 next_offset += envelope_size;
4759 }
4760
4761 let next_out_of_line = decoder.next_out_of_line();
4762 let handles_before = decoder.remaining_handles();
4763 if let Some((inlined, num_bytes, num_handles)) =
4764 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4765 {
4766 let member_inline_size = <fidl_fuchsia_data__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4767 if inlined != (member_inline_size <= 4) {
4768 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4769 }
4770 let inner_offset;
4771 let mut inner_depth = depth.clone();
4772 if inlined {
4773 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4774 inner_offset = next_offset;
4775 } else {
4776 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4777 inner_depth.increment()?;
4778 }
4779 let val_ref = self.filter.get_or_insert_with(|| {
4780 fidl::new_empty!(fidl_fuchsia_data__common::Dictionary, D)
4781 });
4782 fidl::decode!(
4783 fidl_fuchsia_data__common::Dictionary,
4784 D,
4785 val_ref,
4786 decoder,
4787 inner_offset,
4788 inner_depth
4789 )?;
4790 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4791 {
4792 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4793 }
4794 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4795 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4796 }
4797 }
4798
4799 next_offset += envelope_size;
4800 _next_ordinal_to_read += 1;
4801 if next_offset >= end_offset {
4802 return Ok(());
4803 }
4804
4805 while _next_ordinal_to_read < 4 {
4807 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4808 _next_ordinal_to_read += 1;
4809 next_offset += envelope_size;
4810 }
4811
4812 let next_out_of_line = decoder.next_out_of_line();
4813 let handles_before = decoder.remaining_handles();
4814 if let Some((inlined, num_bytes, num_handles)) =
4815 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4816 {
4817 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4818 if inlined != (member_inline_size <= 4) {
4819 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4820 }
4821 let inner_offset;
4822 let mut inner_depth = depth.clone();
4823 if inlined {
4824 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4825 inner_offset = next_offset;
4826 } else {
4827 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4828 inner_depth.increment()?;
4829 }
4830 let val_ref = self.availability.get_or_insert_with(|| {
4831 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
4832 });
4833 fidl::decode!(
4834 fidl_fuchsia_component_decl__common::Availability,
4835 D,
4836 val_ref,
4837 decoder,
4838 inner_offset,
4839 inner_depth
4840 )?;
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
4852 while next_offset < end_offset {
4854 _next_ordinal_to_read += 1;
4855 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4856 next_offset += envelope_size;
4857 }
4858
4859 Ok(())
4860 }
4861 }
4862
4863 impl EventStream {
4864 #[inline(always)]
4865 fn max_ordinal_present(&self) -> u64 {
4866 if let Some(_) = self.scope {
4867 return 5;
4868 }
4869 if let Some(_) = self.filter {
4870 return 4;
4871 }
4872 if let Some(_) = self.path {
4873 return 3;
4874 }
4875 if let Some(_) = self.as_ {
4876 return 2;
4877 }
4878 if let Some(_) = self.name {
4879 return 1;
4880 }
4881 0
4882 }
4883 }
4884
4885 impl fidl::encoding::ValueTypeMarker for EventStream {
4886 type Borrowed<'a> = &'a Self;
4887 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4888 value
4889 }
4890 }
4891
4892 unsafe impl fidl::encoding::TypeMarker for EventStream {
4893 type Owned = Self;
4894
4895 #[inline(always)]
4896 fn inline_align(_context: fidl::encoding::Context) -> usize {
4897 8
4898 }
4899
4900 #[inline(always)]
4901 fn inline_size(_context: fidl::encoding::Context) -> usize {
4902 16
4903 }
4904 }
4905
4906 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EventStream, D>
4907 for &EventStream
4908 {
4909 unsafe fn encode(
4910 self,
4911 encoder: &mut fidl::encoding::Encoder<'_, D>,
4912 offset: usize,
4913 mut depth: fidl::encoding::Depth,
4914 ) -> fidl::Result<()> {
4915 encoder.debug_check_bounds::<EventStream>(offset);
4916 let max_ordinal: u64 = self.max_ordinal_present();
4918 encoder.write_num(max_ordinal, offset);
4919 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4920 if max_ordinal == 0 {
4922 return Ok(());
4923 }
4924 depth.increment()?;
4925 let envelope_size = 8;
4926 let bytes_len = max_ordinal as usize * envelope_size;
4927 #[allow(unused_variables)]
4928 let offset = encoder.out_of_line_offset(bytes_len);
4929 let mut _prev_end_offset: usize = 0;
4930 if 1 > max_ordinal {
4931 return Ok(());
4932 }
4933
4934 let cur_offset: usize = (1 - 1) * envelope_size;
4937
4938 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4940
4941 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
4946 self.name.as_ref().map(
4947 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
4948 ),
4949 encoder,
4950 offset + cur_offset,
4951 depth,
4952 )?;
4953
4954 _prev_end_offset = cur_offset + envelope_size;
4955 if 2 > max_ordinal {
4956 return Ok(());
4957 }
4958
4959 let cur_offset: usize = (2 - 1) * envelope_size;
4962
4963 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4965
4966 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
4971 self.as_.as_ref().map(
4972 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
4973 ),
4974 encoder,
4975 offset + cur_offset,
4976 depth,
4977 )?;
4978
4979 _prev_end_offset = cur_offset + envelope_size;
4980 if 3 > max_ordinal {
4981 return Ok(());
4982 }
4983
4984 let cur_offset: usize = (3 - 1) * envelope_size;
4987
4988 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4990
4991 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
4996 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
4997 encoder, offset + cur_offset, depth
4998 )?;
4999
5000 _prev_end_offset = cur_offset + envelope_size;
5001 if 4 > max_ordinal {
5002 return Ok(());
5003 }
5004
5005 let cur_offset: usize = (4 - 1) * envelope_size;
5008
5009 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5011
5012 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_data__common::Dictionary, D>(
5017 self.filter.as_ref().map(<fidl_fuchsia_data__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow),
5018 encoder, offset + cur_offset, depth
5019 )?;
5020
5021 _prev_end_offset = cur_offset + envelope_size;
5022 if 5 > max_ordinal {
5023 return Ok(());
5024 }
5025
5026 let cur_offset: usize = (5 - 1) * envelope_size;
5029
5030 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5032
5033 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>, D>(
5038 self.scope.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref> as fidl::encoding::ValueTypeMarker>::borrow),
5039 encoder, offset + cur_offset, depth
5040 )?;
5041
5042 _prev_end_offset = cur_offset + envelope_size;
5043
5044 Ok(())
5045 }
5046 }
5047
5048 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventStream {
5049 #[inline(always)]
5050 fn new_empty() -> Self {
5051 Self::default()
5052 }
5053
5054 unsafe fn decode(
5055 &mut self,
5056 decoder: &mut fidl::encoding::Decoder<'_, D>,
5057 offset: usize,
5058 mut depth: fidl::encoding::Depth,
5059 ) -> fidl::Result<()> {
5060 decoder.debug_check_bounds::<Self>(offset);
5061 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5062 None => return Err(fidl::Error::NotNullable),
5063 Some(len) => len,
5064 };
5065 if len == 0 {
5067 return Ok(());
5068 };
5069 depth.increment()?;
5070 let envelope_size = 8;
5071 let bytes_len = len * envelope_size;
5072 let offset = decoder.out_of_line_offset(bytes_len)?;
5073 let mut _next_ordinal_to_read = 0;
5075 let mut next_offset = offset;
5076 let end_offset = offset + bytes_len;
5077 _next_ordinal_to_read += 1;
5078 if next_offset >= end_offset {
5079 return Ok(());
5080 }
5081
5082 while _next_ordinal_to_read < 1 {
5084 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5085 _next_ordinal_to_read += 1;
5086 next_offset += envelope_size;
5087 }
5088
5089 let next_out_of_line = decoder.next_out_of_line();
5090 let handles_before = decoder.remaining_handles();
5091 if let Some((inlined, num_bytes, num_handles)) =
5092 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5093 {
5094 let member_inline_size =
5095 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5096 decoder.context,
5097 );
5098 if inlined != (member_inline_size <= 4) {
5099 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5100 }
5101 let inner_offset;
5102 let mut inner_depth = depth.clone();
5103 if inlined {
5104 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5105 inner_offset = next_offset;
5106 } else {
5107 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5108 inner_depth.increment()?;
5109 }
5110 let val_ref = self
5111 .name
5112 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5113 fidl::decode!(
5114 fidl::encoding::BoundedString<255>,
5115 D,
5116 val_ref,
5117 decoder,
5118 inner_offset,
5119 inner_depth
5120 )?;
5121 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5122 {
5123 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5124 }
5125 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5126 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5127 }
5128 }
5129
5130 next_offset += envelope_size;
5131 _next_ordinal_to_read += 1;
5132 if next_offset >= end_offset {
5133 return Ok(());
5134 }
5135
5136 while _next_ordinal_to_read < 2 {
5138 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5139 _next_ordinal_to_read += 1;
5140 next_offset += envelope_size;
5141 }
5142
5143 let next_out_of_line = decoder.next_out_of_line();
5144 let handles_before = decoder.remaining_handles();
5145 if let Some((inlined, num_bytes, num_handles)) =
5146 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5147 {
5148 let member_inline_size =
5149 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5150 decoder.context,
5151 );
5152 if inlined != (member_inline_size <= 4) {
5153 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5154 }
5155 let inner_offset;
5156 let mut inner_depth = depth.clone();
5157 if inlined {
5158 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5159 inner_offset = next_offset;
5160 } else {
5161 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5162 inner_depth.increment()?;
5163 }
5164 let val_ref = self
5165 .as_
5166 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5167 fidl::decode!(
5168 fidl::encoding::BoundedString<255>,
5169 D,
5170 val_ref,
5171 decoder,
5172 inner_offset,
5173 inner_depth
5174 )?;
5175 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5176 {
5177 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5178 }
5179 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5180 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5181 }
5182 }
5183
5184 next_offset += envelope_size;
5185 _next_ordinal_to_read += 1;
5186 if next_offset >= end_offset {
5187 return Ok(());
5188 }
5189
5190 while _next_ordinal_to_read < 3 {
5192 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5193 _next_ordinal_to_read += 1;
5194 next_offset += envelope_size;
5195 }
5196
5197 let next_out_of_line = decoder.next_out_of_line();
5198 let handles_before = decoder.remaining_handles();
5199 if let Some((inlined, num_bytes, num_handles)) =
5200 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5201 {
5202 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5203 if inlined != (member_inline_size <= 4) {
5204 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5205 }
5206 let inner_offset;
5207 let mut inner_depth = depth.clone();
5208 if inlined {
5209 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5210 inner_offset = next_offset;
5211 } else {
5212 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5213 inner_depth.increment()?;
5214 }
5215 let val_ref = self.path.get_or_insert_with(|| {
5216 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
5217 });
5218 fidl::decode!(
5219 fidl::encoding::BoundedString<4095>,
5220 D,
5221 val_ref,
5222 decoder,
5223 inner_offset,
5224 inner_depth
5225 )?;
5226 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5227 {
5228 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5229 }
5230 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5231 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5232 }
5233 }
5234
5235 next_offset += envelope_size;
5236 _next_ordinal_to_read += 1;
5237 if next_offset >= end_offset {
5238 return Ok(());
5239 }
5240
5241 while _next_ordinal_to_read < 4 {
5243 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5244 _next_ordinal_to_read += 1;
5245 next_offset += envelope_size;
5246 }
5247
5248 let next_out_of_line = decoder.next_out_of_line();
5249 let handles_before = decoder.remaining_handles();
5250 if let Some((inlined, num_bytes, num_handles)) =
5251 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5252 {
5253 let member_inline_size = <fidl_fuchsia_data__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5254 if inlined != (member_inline_size <= 4) {
5255 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5256 }
5257 let inner_offset;
5258 let mut inner_depth = depth.clone();
5259 if inlined {
5260 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5261 inner_offset = next_offset;
5262 } else {
5263 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5264 inner_depth.increment()?;
5265 }
5266 let val_ref = self.filter.get_or_insert_with(|| {
5267 fidl::new_empty!(fidl_fuchsia_data__common::Dictionary, D)
5268 });
5269 fidl::decode!(
5270 fidl_fuchsia_data__common::Dictionary,
5271 D,
5272 val_ref,
5273 decoder,
5274 inner_offset,
5275 inner_depth
5276 )?;
5277 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5278 {
5279 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5280 }
5281 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5282 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5283 }
5284 }
5285
5286 next_offset += envelope_size;
5287 _next_ordinal_to_read += 1;
5288 if next_offset >= end_offset {
5289 return Ok(());
5290 }
5291
5292 while _next_ordinal_to_read < 5 {
5294 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5295 _next_ordinal_to_read += 1;
5296 next_offset += envelope_size;
5297 }
5298
5299 let next_out_of_line = decoder.next_out_of_line();
5300 let handles_before = decoder.remaining_handles();
5301 if let Some((inlined, num_bytes, num_handles)) =
5302 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5303 {
5304 let member_inline_size = <fidl::encoding::UnboundedVector<
5305 fidl_fuchsia_component_decl__common::Ref,
5306 > as fidl::encoding::TypeMarker>::inline_size(
5307 decoder.context
5308 );
5309 if inlined != (member_inline_size <= 4) {
5310 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5311 }
5312 let inner_offset;
5313 let mut inner_depth = depth.clone();
5314 if inlined {
5315 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5316 inner_offset = next_offset;
5317 } else {
5318 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5319 inner_depth.increment()?;
5320 }
5321 let val_ref = self.scope.get_or_insert_with(|| {
5322 fidl::new_empty!(
5323 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
5324 D
5325 )
5326 });
5327 fidl::decode!(
5328 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
5329 D,
5330 val_ref,
5331 decoder,
5332 inner_offset,
5333 inner_depth
5334 )?;
5335 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5336 {
5337 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5338 }
5339 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5340 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5341 }
5342 }
5343
5344 next_offset += envelope_size;
5345
5346 while next_offset < end_offset {
5348 _next_ordinal_to_read += 1;
5349 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5350 next_offset += envelope_size;
5351 }
5352
5353 Ok(())
5354 }
5355 }
5356
5357 impl Protocol {
5358 #[inline(always)]
5359 fn max_ordinal_present(&self) -> u64 {
5360 if let Some(_) = self.from_dictionary {
5361 return 6;
5362 }
5363 if let Some(_) = self.availability {
5364 return 5;
5365 }
5366 if let Some(_) = self.path {
5367 return 4;
5368 }
5369 if let Some(_) = self.type_ {
5370 return 3;
5371 }
5372 if let Some(_) = self.as_ {
5373 return 2;
5374 }
5375 if let Some(_) = self.name {
5376 return 1;
5377 }
5378 0
5379 }
5380 }
5381
5382 impl fidl::encoding::ValueTypeMarker for Protocol {
5383 type Borrowed<'a> = &'a Self;
5384 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5385 value
5386 }
5387 }
5388
5389 unsafe impl fidl::encoding::TypeMarker for Protocol {
5390 type Owned = Self;
5391
5392 #[inline(always)]
5393 fn inline_align(_context: fidl::encoding::Context) -> usize {
5394 8
5395 }
5396
5397 #[inline(always)]
5398 fn inline_size(_context: fidl::encoding::Context) -> usize {
5399 16
5400 }
5401 }
5402
5403 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Protocol, D> for &Protocol {
5404 unsafe fn encode(
5405 self,
5406 encoder: &mut fidl::encoding::Encoder<'_, D>,
5407 offset: usize,
5408 mut depth: fidl::encoding::Depth,
5409 ) -> fidl::Result<()> {
5410 encoder.debug_check_bounds::<Protocol>(offset);
5411 let max_ordinal: u64 = self.max_ordinal_present();
5413 encoder.write_num(max_ordinal, offset);
5414 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5415 if max_ordinal == 0 {
5417 return Ok(());
5418 }
5419 depth.increment()?;
5420 let envelope_size = 8;
5421 let bytes_len = max_ordinal as usize * envelope_size;
5422 #[allow(unused_variables)]
5423 let offset = encoder.out_of_line_offset(bytes_len);
5424 let mut _prev_end_offset: usize = 0;
5425 if 1 > max_ordinal {
5426 return Ok(());
5427 }
5428
5429 let cur_offset: usize = (1 - 1) * envelope_size;
5432
5433 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5435
5436 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5441 self.name.as_ref().map(
5442 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5443 ),
5444 encoder,
5445 offset + cur_offset,
5446 depth,
5447 )?;
5448
5449 _prev_end_offset = cur_offset + envelope_size;
5450 if 2 > max_ordinal {
5451 return Ok(());
5452 }
5453
5454 let cur_offset: usize = (2 - 1) * envelope_size;
5457
5458 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5460
5461 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5466 self.as_.as_ref().map(
5467 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5468 ),
5469 encoder,
5470 offset + cur_offset,
5471 depth,
5472 )?;
5473
5474 _prev_end_offset = cur_offset + envelope_size;
5475 if 3 > max_ordinal {
5476 return Ok(());
5477 }
5478
5479 let cur_offset: usize = (3 - 1) * envelope_size;
5482
5483 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5485
5486 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::DependencyType, D>(
5491 self.type_.as_ref().map(<fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
5492 encoder, offset + cur_offset, depth
5493 )?;
5494
5495 _prev_end_offset = cur_offset + envelope_size;
5496 if 4 > max_ordinal {
5497 return Ok(());
5498 }
5499
5500 let cur_offset: usize = (4 - 1) * envelope_size;
5503
5504 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5506
5507 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
5512 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
5513 encoder, offset + cur_offset, depth
5514 )?;
5515
5516 _prev_end_offset = cur_offset + envelope_size;
5517 if 5 > max_ordinal {
5518 return Ok(());
5519 }
5520
5521 let cur_offset: usize = (5 - 1) * envelope_size;
5524
5525 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5527
5528 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
5533 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
5534 encoder, offset + cur_offset, depth
5535 )?;
5536
5537 _prev_end_offset = cur_offset + envelope_size;
5538 if 6 > max_ordinal {
5539 return Ok(());
5540 }
5541
5542 let cur_offset: usize = (6 - 1) * envelope_size;
5545
5546 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5548
5549 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
5554 self.from_dictionary.as_ref().map(
5555 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
5556 ),
5557 encoder,
5558 offset + cur_offset,
5559 depth,
5560 )?;
5561
5562 _prev_end_offset = cur_offset + envelope_size;
5563
5564 Ok(())
5565 }
5566 }
5567
5568 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Protocol {
5569 #[inline(always)]
5570 fn new_empty() -> Self {
5571 Self::default()
5572 }
5573
5574 unsafe fn decode(
5575 &mut self,
5576 decoder: &mut fidl::encoding::Decoder<'_, D>,
5577 offset: usize,
5578 mut depth: fidl::encoding::Depth,
5579 ) -> fidl::Result<()> {
5580 decoder.debug_check_bounds::<Self>(offset);
5581 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5582 None => return Err(fidl::Error::NotNullable),
5583 Some(len) => len,
5584 };
5585 if len == 0 {
5587 return Ok(());
5588 };
5589 depth.increment()?;
5590 let envelope_size = 8;
5591 let bytes_len = len * envelope_size;
5592 let offset = decoder.out_of_line_offset(bytes_len)?;
5593 let mut _next_ordinal_to_read = 0;
5595 let mut next_offset = offset;
5596 let end_offset = offset + bytes_len;
5597 _next_ordinal_to_read += 1;
5598 if next_offset >= end_offset {
5599 return Ok(());
5600 }
5601
5602 while _next_ordinal_to_read < 1 {
5604 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5605 _next_ordinal_to_read += 1;
5606 next_offset += envelope_size;
5607 }
5608
5609 let next_out_of_line = decoder.next_out_of_line();
5610 let handles_before = decoder.remaining_handles();
5611 if let Some((inlined, num_bytes, num_handles)) =
5612 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5613 {
5614 let member_inline_size =
5615 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5616 decoder.context,
5617 );
5618 if inlined != (member_inline_size <= 4) {
5619 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5620 }
5621 let inner_offset;
5622 let mut inner_depth = depth.clone();
5623 if inlined {
5624 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5625 inner_offset = next_offset;
5626 } else {
5627 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5628 inner_depth.increment()?;
5629 }
5630 let val_ref = self
5631 .name
5632 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5633 fidl::decode!(
5634 fidl::encoding::BoundedString<255>,
5635 D,
5636 val_ref,
5637 decoder,
5638 inner_offset,
5639 inner_depth
5640 )?;
5641 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5642 {
5643 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5644 }
5645 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5646 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5647 }
5648 }
5649
5650 next_offset += envelope_size;
5651 _next_ordinal_to_read += 1;
5652 if next_offset >= end_offset {
5653 return Ok(());
5654 }
5655
5656 while _next_ordinal_to_read < 2 {
5658 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5659 _next_ordinal_to_read += 1;
5660 next_offset += envelope_size;
5661 }
5662
5663 let next_out_of_line = decoder.next_out_of_line();
5664 let handles_before = decoder.remaining_handles();
5665 if let Some((inlined, num_bytes, num_handles)) =
5666 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5667 {
5668 let member_inline_size =
5669 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5670 decoder.context,
5671 );
5672 if inlined != (member_inline_size <= 4) {
5673 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5674 }
5675 let inner_offset;
5676 let mut inner_depth = depth.clone();
5677 if inlined {
5678 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5679 inner_offset = next_offset;
5680 } else {
5681 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5682 inner_depth.increment()?;
5683 }
5684 let val_ref = self
5685 .as_
5686 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5687 fidl::decode!(
5688 fidl::encoding::BoundedString<255>,
5689 D,
5690 val_ref,
5691 decoder,
5692 inner_offset,
5693 inner_depth
5694 )?;
5695 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5696 {
5697 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5698 }
5699 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5700 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5701 }
5702 }
5703
5704 next_offset += envelope_size;
5705 _next_ordinal_to_read += 1;
5706 if next_offset >= end_offset {
5707 return Ok(());
5708 }
5709
5710 while _next_ordinal_to_read < 3 {
5712 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5713 _next_ordinal_to_read += 1;
5714 next_offset += envelope_size;
5715 }
5716
5717 let next_out_of_line = decoder.next_out_of_line();
5718 let handles_before = decoder.remaining_handles();
5719 if let Some((inlined, num_bytes, num_handles)) =
5720 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5721 {
5722 let member_inline_size = <fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5723 if inlined != (member_inline_size <= 4) {
5724 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5725 }
5726 let inner_offset;
5727 let mut inner_depth = depth.clone();
5728 if inlined {
5729 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5730 inner_offset = next_offset;
5731 } else {
5732 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5733 inner_depth.increment()?;
5734 }
5735 let val_ref = self.type_.get_or_insert_with(|| {
5736 fidl::new_empty!(fidl_fuchsia_component_decl__common::DependencyType, D)
5737 });
5738 fidl::decode!(
5739 fidl_fuchsia_component_decl__common::DependencyType,
5740 D,
5741 val_ref,
5742 decoder,
5743 inner_offset,
5744 inner_depth
5745 )?;
5746 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5747 {
5748 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5749 }
5750 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5751 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5752 }
5753 }
5754
5755 next_offset += envelope_size;
5756 _next_ordinal_to_read += 1;
5757 if next_offset >= end_offset {
5758 return Ok(());
5759 }
5760
5761 while _next_ordinal_to_read < 4 {
5763 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5764 _next_ordinal_to_read += 1;
5765 next_offset += envelope_size;
5766 }
5767
5768 let next_out_of_line = decoder.next_out_of_line();
5769 let handles_before = decoder.remaining_handles();
5770 if let Some((inlined, num_bytes, num_handles)) =
5771 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5772 {
5773 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5774 if inlined != (member_inline_size <= 4) {
5775 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5776 }
5777 let inner_offset;
5778 let mut inner_depth = depth.clone();
5779 if inlined {
5780 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5781 inner_offset = next_offset;
5782 } else {
5783 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5784 inner_depth.increment()?;
5785 }
5786 let val_ref = self.path.get_or_insert_with(|| {
5787 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
5788 });
5789 fidl::decode!(
5790 fidl::encoding::BoundedString<4095>,
5791 D,
5792 val_ref,
5793 decoder,
5794 inner_offset,
5795 inner_depth
5796 )?;
5797 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5798 {
5799 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5800 }
5801 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5802 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5803 }
5804 }
5805
5806 next_offset += envelope_size;
5807 _next_ordinal_to_read += 1;
5808 if next_offset >= end_offset {
5809 return Ok(());
5810 }
5811
5812 while _next_ordinal_to_read < 5 {
5814 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5815 _next_ordinal_to_read += 1;
5816 next_offset += envelope_size;
5817 }
5818
5819 let next_out_of_line = decoder.next_out_of_line();
5820 let handles_before = decoder.remaining_handles();
5821 if let Some((inlined, num_bytes, num_handles)) =
5822 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5823 {
5824 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5825 if inlined != (member_inline_size <= 4) {
5826 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5827 }
5828 let inner_offset;
5829 let mut inner_depth = depth.clone();
5830 if inlined {
5831 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5832 inner_offset = next_offset;
5833 } else {
5834 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5835 inner_depth.increment()?;
5836 }
5837 let val_ref = self.availability.get_or_insert_with(|| {
5838 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
5839 });
5840 fidl::decode!(
5841 fidl_fuchsia_component_decl__common::Availability,
5842 D,
5843 val_ref,
5844 decoder,
5845 inner_offset,
5846 inner_depth
5847 )?;
5848 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5849 {
5850 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5851 }
5852 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5853 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5854 }
5855 }
5856
5857 next_offset += envelope_size;
5858 _next_ordinal_to_read += 1;
5859 if next_offset >= end_offset {
5860 return Ok(());
5861 }
5862
5863 while _next_ordinal_to_read < 6 {
5865 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5866 _next_ordinal_to_read += 1;
5867 next_offset += envelope_size;
5868 }
5869
5870 let next_out_of_line = decoder.next_out_of_line();
5871 let handles_before = decoder.remaining_handles();
5872 if let Some((inlined, num_bytes, num_handles)) =
5873 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5874 {
5875 let member_inline_size =
5876 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
5877 decoder.context,
5878 );
5879 if inlined != (member_inline_size <= 4) {
5880 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5881 }
5882 let inner_offset;
5883 let mut inner_depth = depth.clone();
5884 if inlined {
5885 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5886 inner_offset = next_offset;
5887 } else {
5888 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5889 inner_depth.increment()?;
5890 }
5891 let val_ref = self
5892 .from_dictionary
5893 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
5894 fidl::decode!(
5895 fidl::encoding::UnboundedString,
5896 D,
5897 val_ref,
5898 decoder,
5899 inner_offset,
5900 inner_depth
5901 )?;
5902 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5903 {
5904 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5905 }
5906 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5907 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5908 }
5909 }
5910
5911 next_offset += envelope_size;
5912
5913 while next_offset < end_offset {
5915 _next_ordinal_to_read += 1;
5916 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5917 next_offset += envelope_size;
5918 }
5919
5920 Ok(())
5921 }
5922 }
5923
5924 impl Resolver {
5925 #[inline(always)]
5926 fn max_ordinal_present(&self) -> u64 {
5927 if let Some(_) = self.from_dictionary {
5928 return 4;
5929 }
5930 if let Some(_) = self.path {
5931 return 3;
5932 }
5933 if let Some(_) = self.as_ {
5934 return 2;
5935 }
5936 if let Some(_) = self.name {
5937 return 1;
5938 }
5939 0
5940 }
5941 }
5942
5943 impl fidl::encoding::ValueTypeMarker for Resolver {
5944 type Borrowed<'a> = &'a Self;
5945 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5946 value
5947 }
5948 }
5949
5950 unsafe impl fidl::encoding::TypeMarker for Resolver {
5951 type Owned = Self;
5952
5953 #[inline(always)]
5954 fn inline_align(_context: fidl::encoding::Context) -> usize {
5955 8
5956 }
5957
5958 #[inline(always)]
5959 fn inline_size(_context: fidl::encoding::Context) -> usize {
5960 16
5961 }
5962 }
5963
5964 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Resolver, D> for &Resolver {
5965 unsafe fn encode(
5966 self,
5967 encoder: &mut fidl::encoding::Encoder<'_, D>,
5968 offset: usize,
5969 mut depth: fidl::encoding::Depth,
5970 ) -> fidl::Result<()> {
5971 encoder.debug_check_bounds::<Resolver>(offset);
5972 let max_ordinal: u64 = self.max_ordinal_present();
5974 encoder.write_num(max_ordinal, offset);
5975 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5976 if max_ordinal == 0 {
5978 return Ok(());
5979 }
5980 depth.increment()?;
5981 let envelope_size = 8;
5982 let bytes_len = max_ordinal as usize * envelope_size;
5983 #[allow(unused_variables)]
5984 let offset = encoder.out_of_line_offset(bytes_len);
5985 let mut _prev_end_offset: usize = 0;
5986 if 1 > max_ordinal {
5987 return Ok(());
5988 }
5989
5990 let cur_offset: usize = (1 - 1) * envelope_size;
5993
5994 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5996
5997 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6002 self.name.as_ref().map(
6003 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6004 ),
6005 encoder,
6006 offset + cur_offset,
6007 depth,
6008 )?;
6009
6010 _prev_end_offset = cur_offset + envelope_size;
6011 if 2 > max_ordinal {
6012 return Ok(());
6013 }
6014
6015 let cur_offset: usize = (2 - 1) * envelope_size;
6018
6019 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6021
6022 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6027 self.as_.as_ref().map(
6028 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6029 ),
6030 encoder,
6031 offset + cur_offset,
6032 depth,
6033 )?;
6034
6035 _prev_end_offset = cur_offset + envelope_size;
6036 if 3 > max_ordinal {
6037 return Ok(());
6038 }
6039
6040 let cur_offset: usize = (3 - 1) * envelope_size;
6043
6044 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6046
6047 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
6052 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
6053 encoder, offset + cur_offset, depth
6054 )?;
6055
6056 _prev_end_offset = cur_offset + envelope_size;
6057 if 4 > max_ordinal {
6058 return Ok(());
6059 }
6060
6061 let cur_offset: usize = (4 - 1) * envelope_size;
6064
6065 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6067
6068 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
6073 self.from_dictionary.as_ref().map(
6074 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
6075 ),
6076 encoder,
6077 offset + cur_offset,
6078 depth,
6079 )?;
6080
6081 _prev_end_offset = cur_offset + envelope_size;
6082
6083 Ok(())
6084 }
6085 }
6086
6087 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Resolver {
6088 #[inline(always)]
6089 fn new_empty() -> Self {
6090 Self::default()
6091 }
6092
6093 unsafe fn decode(
6094 &mut self,
6095 decoder: &mut fidl::encoding::Decoder<'_, D>,
6096 offset: usize,
6097 mut depth: fidl::encoding::Depth,
6098 ) -> fidl::Result<()> {
6099 decoder.debug_check_bounds::<Self>(offset);
6100 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6101 None => return Err(fidl::Error::NotNullable),
6102 Some(len) => len,
6103 };
6104 if len == 0 {
6106 return Ok(());
6107 };
6108 depth.increment()?;
6109 let envelope_size = 8;
6110 let bytes_len = len * envelope_size;
6111 let offset = decoder.out_of_line_offset(bytes_len)?;
6112 let mut _next_ordinal_to_read = 0;
6114 let mut next_offset = offset;
6115 let end_offset = offset + bytes_len;
6116 _next_ordinal_to_read += 1;
6117 if next_offset >= end_offset {
6118 return Ok(());
6119 }
6120
6121 while _next_ordinal_to_read < 1 {
6123 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6124 _next_ordinal_to_read += 1;
6125 next_offset += envelope_size;
6126 }
6127
6128 let next_out_of_line = decoder.next_out_of_line();
6129 let handles_before = decoder.remaining_handles();
6130 if let Some((inlined, num_bytes, num_handles)) =
6131 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6132 {
6133 let member_inline_size =
6134 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6135 decoder.context,
6136 );
6137 if inlined != (member_inline_size <= 4) {
6138 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6139 }
6140 let inner_offset;
6141 let mut inner_depth = depth.clone();
6142 if inlined {
6143 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6144 inner_offset = next_offset;
6145 } else {
6146 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6147 inner_depth.increment()?;
6148 }
6149 let val_ref = self
6150 .name
6151 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6152 fidl::decode!(
6153 fidl::encoding::BoundedString<255>,
6154 D,
6155 val_ref,
6156 decoder,
6157 inner_offset,
6158 inner_depth
6159 )?;
6160 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6161 {
6162 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6163 }
6164 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6165 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6166 }
6167 }
6168
6169 next_offset += envelope_size;
6170 _next_ordinal_to_read += 1;
6171 if next_offset >= end_offset {
6172 return Ok(());
6173 }
6174
6175 while _next_ordinal_to_read < 2 {
6177 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6178 _next_ordinal_to_read += 1;
6179 next_offset += envelope_size;
6180 }
6181
6182 let next_out_of_line = decoder.next_out_of_line();
6183 let handles_before = decoder.remaining_handles();
6184 if let Some((inlined, num_bytes, num_handles)) =
6185 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6186 {
6187 let member_inline_size =
6188 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6189 decoder.context,
6190 );
6191 if inlined != (member_inline_size <= 4) {
6192 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6193 }
6194 let inner_offset;
6195 let mut inner_depth = depth.clone();
6196 if inlined {
6197 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6198 inner_offset = next_offset;
6199 } else {
6200 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6201 inner_depth.increment()?;
6202 }
6203 let val_ref = self
6204 .as_
6205 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6206 fidl::decode!(
6207 fidl::encoding::BoundedString<255>,
6208 D,
6209 val_ref,
6210 decoder,
6211 inner_offset,
6212 inner_depth
6213 )?;
6214 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6215 {
6216 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6217 }
6218 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6219 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6220 }
6221 }
6222
6223 next_offset += envelope_size;
6224 _next_ordinal_to_read += 1;
6225 if next_offset >= end_offset {
6226 return Ok(());
6227 }
6228
6229 while _next_ordinal_to_read < 3 {
6231 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6232 _next_ordinal_to_read += 1;
6233 next_offset += envelope_size;
6234 }
6235
6236 let next_out_of_line = decoder.next_out_of_line();
6237 let handles_before = decoder.remaining_handles();
6238 if let Some((inlined, num_bytes, num_handles)) =
6239 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6240 {
6241 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6242 if inlined != (member_inline_size <= 4) {
6243 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6244 }
6245 let inner_offset;
6246 let mut inner_depth = depth.clone();
6247 if inlined {
6248 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6249 inner_offset = next_offset;
6250 } else {
6251 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6252 inner_depth.increment()?;
6253 }
6254 let val_ref = self.path.get_or_insert_with(|| {
6255 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
6256 });
6257 fidl::decode!(
6258 fidl::encoding::BoundedString<4095>,
6259 D,
6260 val_ref,
6261 decoder,
6262 inner_offset,
6263 inner_depth
6264 )?;
6265 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6266 {
6267 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6268 }
6269 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6270 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6271 }
6272 }
6273
6274 next_offset += envelope_size;
6275 _next_ordinal_to_read += 1;
6276 if next_offset >= end_offset {
6277 return Ok(());
6278 }
6279
6280 while _next_ordinal_to_read < 4 {
6282 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6283 _next_ordinal_to_read += 1;
6284 next_offset += envelope_size;
6285 }
6286
6287 let next_out_of_line = decoder.next_out_of_line();
6288 let handles_before = decoder.remaining_handles();
6289 if let Some((inlined, num_bytes, num_handles)) =
6290 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6291 {
6292 let member_inline_size =
6293 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
6294 decoder.context,
6295 );
6296 if inlined != (member_inline_size <= 4) {
6297 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6298 }
6299 let inner_offset;
6300 let mut inner_depth = depth.clone();
6301 if inlined {
6302 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6303 inner_offset = next_offset;
6304 } else {
6305 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6306 inner_depth.increment()?;
6307 }
6308 let val_ref = self
6309 .from_dictionary
6310 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
6311 fidl::decode!(
6312 fidl::encoding::UnboundedString,
6313 D,
6314 val_ref,
6315 decoder,
6316 inner_offset,
6317 inner_depth
6318 )?;
6319 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6320 {
6321 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6322 }
6323 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6324 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6325 }
6326 }
6327
6328 next_offset += envelope_size;
6329
6330 while next_offset < end_offset {
6332 _next_ordinal_to_read += 1;
6333 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6334 next_offset += envelope_size;
6335 }
6336
6337 Ok(())
6338 }
6339 }
6340
6341 impl Runner {
6342 #[inline(always)]
6343 fn max_ordinal_present(&self) -> u64 {
6344 if let Some(_) = self.from_dictionary {
6345 return 4;
6346 }
6347 if let Some(_) = self.path {
6348 return 3;
6349 }
6350 if let Some(_) = self.as_ {
6351 return 2;
6352 }
6353 if let Some(_) = self.name {
6354 return 1;
6355 }
6356 0
6357 }
6358 }
6359
6360 impl fidl::encoding::ValueTypeMarker for Runner {
6361 type Borrowed<'a> = &'a Self;
6362 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6363 value
6364 }
6365 }
6366
6367 unsafe impl fidl::encoding::TypeMarker for Runner {
6368 type Owned = Self;
6369
6370 #[inline(always)]
6371 fn inline_align(_context: fidl::encoding::Context) -> usize {
6372 8
6373 }
6374
6375 #[inline(always)]
6376 fn inline_size(_context: fidl::encoding::Context) -> usize {
6377 16
6378 }
6379 }
6380
6381 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Runner, D> for &Runner {
6382 unsafe fn encode(
6383 self,
6384 encoder: &mut fidl::encoding::Encoder<'_, D>,
6385 offset: usize,
6386 mut depth: fidl::encoding::Depth,
6387 ) -> fidl::Result<()> {
6388 encoder.debug_check_bounds::<Runner>(offset);
6389 let max_ordinal: u64 = self.max_ordinal_present();
6391 encoder.write_num(max_ordinal, offset);
6392 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6393 if max_ordinal == 0 {
6395 return Ok(());
6396 }
6397 depth.increment()?;
6398 let envelope_size = 8;
6399 let bytes_len = max_ordinal as usize * envelope_size;
6400 #[allow(unused_variables)]
6401 let offset = encoder.out_of_line_offset(bytes_len);
6402 let mut _prev_end_offset: usize = 0;
6403 if 1 > max_ordinal {
6404 return Ok(());
6405 }
6406
6407 let cur_offset: usize = (1 - 1) * envelope_size;
6410
6411 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6413
6414 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6419 self.name.as_ref().map(
6420 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6421 ),
6422 encoder,
6423 offset + cur_offset,
6424 depth,
6425 )?;
6426
6427 _prev_end_offset = cur_offset + envelope_size;
6428 if 2 > max_ordinal {
6429 return Ok(());
6430 }
6431
6432 let cur_offset: usize = (2 - 1) * envelope_size;
6435
6436 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6438
6439 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6444 self.as_.as_ref().map(
6445 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6446 ),
6447 encoder,
6448 offset + cur_offset,
6449 depth,
6450 )?;
6451
6452 _prev_end_offset = cur_offset + envelope_size;
6453 if 3 > max_ordinal {
6454 return Ok(());
6455 }
6456
6457 let cur_offset: usize = (3 - 1) * envelope_size;
6460
6461 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6463
6464 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
6469 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
6470 encoder, offset + cur_offset, depth
6471 )?;
6472
6473 _prev_end_offset = cur_offset + envelope_size;
6474 if 4 > max_ordinal {
6475 return Ok(());
6476 }
6477
6478 let cur_offset: usize = (4 - 1) * envelope_size;
6481
6482 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6484
6485 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
6490 self.from_dictionary.as_ref().map(
6491 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
6492 ),
6493 encoder,
6494 offset + cur_offset,
6495 depth,
6496 )?;
6497
6498 _prev_end_offset = cur_offset + envelope_size;
6499
6500 Ok(())
6501 }
6502 }
6503
6504 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Runner {
6505 #[inline(always)]
6506 fn new_empty() -> Self {
6507 Self::default()
6508 }
6509
6510 unsafe fn decode(
6511 &mut self,
6512 decoder: &mut fidl::encoding::Decoder<'_, D>,
6513 offset: usize,
6514 mut depth: fidl::encoding::Depth,
6515 ) -> fidl::Result<()> {
6516 decoder.debug_check_bounds::<Self>(offset);
6517 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6518 None => return Err(fidl::Error::NotNullable),
6519 Some(len) => len,
6520 };
6521 if len == 0 {
6523 return Ok(());
6524 };
6525 depth.increment()?;
6526 let envelope_size = 8;
6527 let bytes_len = len * envelope_size;
6528 let offset = decoder.out_of_line_offset(bytes_len)?;
6529 let mut _next_ordinal_to_read = 0;
6531 let mut next_offset = offset;
6532 let end_offset = offset + bytes_len;
6533 _next_ordinal_to_read += 1;
6534 if next_offset >= end_offset {
6535 return Ok(());
6536 }
6537
6538 while _next_ordinal_to_read < 1 {
6540 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6541 _next_ordinal_to_read += 1;
6542 next_offset += envelope_size;
6543 }
6544
6545 let next_out_of_line = decoder.next_out_of_line();
6546 let handles_before = decoder.remaining_handles();
6547 if let Some((inlined, num_bytes, num_handles)) =
6548 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6549 {
6550 let member_inline_size =
6551 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6552 decoder.context,
6553 );
6554 if inlined != (member_inline_size <= 4) {
6555 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6556 }
6557 let inner_offset;
6558 let mut inner_depth = depth.clone();
6559 if inlined {
6560 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6561 inner_offset = next_offset;
6562 } else {
6563 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6564 inner_depth.increment()?;
6565 }
6566 let val_ref = self
6567 .name
6568 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6569 fidl::decode!(
6570 fidl::encoding::BoundedString<255>,
6571 D,
6572 val_ref,
6573 decoder,
6574 inner_offset,
6575 inner_depth
6576 )?;
6577 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6578 {
6579 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6580 }
6581 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6582 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6583 }
6584 }
6585
6586 next_offset += envelope_size;
6587 _next_ordinal_to_read += 1;
6588 if next_offset >= end_offset {
6589 return Ok(());
6590 }
6591
6592 while _next_ordinal_to_read < 2 {
6594 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6595 _next_ordinal_to_read += 1;
6596 next_offset += envelope_size;
6597 }
6598
6599 let next_out_of_line = decoder.next_out_of_line();
6600 let handles_before = decoder.remaining_handles();
6601 if let Some((inlined, num_bytes, num_handles)) =
6602 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6603 {
6604 let member_inline_size =
6605 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6606 decoder.context,
6607 );
6608 if inlined != (member_inline_size <= 4) {
6609 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6610 }
6611 let inner_offset;
6612 let mut inner_depth = depth.clone();
6613 if inlined {
6614 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6615 inner_offset = next_offset;
6616 } else {
6617 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6618 inner_depth.increment()?;
6619 }
6620 let val_ref = self
6621 .as_
6622 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6623 fidl::decode!(
6624 fidl::encoding::BoundedString<255>,
6625 D,
6626 val_ref,
6627 decoder,
6628 inner_offset,
6629 inner_depth
6630 )?;
6631 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6632 {
6633 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6634 }
6635 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6636 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6637 }
6638 }
6639
6640 next_offset += envelope_size;
6641 _next_ordinal_to_read += 1;
6642 if next_offset >= end_offset {
6643 return Ok(());
6644 }
6645
6646 while _next_ordinal_to_read < 3 {
6648 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6649 _next_ordinal_to_read += 1;
6650 next_offset += envelope_size;
6651 }
6652
6653 let next_out_of_line = decoder.next_out_of_line();
6654 let handles_before = decoder.remaining_handles();
6655 if let Some((inlined, num_bytes, num_handles)) =
6656 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6657 {
6658 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6659 if inlined != (member_inline_size <= 4) {
6660 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6661 }
6662 let inner_offset;
6663 let mut inner_depth = depth.clone();
6664 if inlined {
6665 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6666 inner_offset = next_offset;
6667 } else {
6668 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6669 inner_depth.increment()?;
6670 }
6671 let val_ref = self.path.get_or_insert_with(|| {
6672 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
6673 });
6674 fidl::decode!(
6675 fidl::encoding::BoundedString<4095>,
6676 D,
6677 val_ref,
6678 decoder,
6679 inner_offset,
6680 inner_depth
6681 )?;
6682 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6683 {
6684 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6685 }
6686 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6687 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6688 }
6689 }
6690
6691 next_offset += envelope_size;
6692 _next_ordinal_to_read += 1;
6693 if next_offset >= end_offset {
6694 return Ok(());
6695 }
6696
6697 while _next_ordinal_to_read < 4 {
6699 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6700 _next_ordinal_to_read += 1;
6701 next_offset += envelope_size;
6702 }
6703
6704 let next_out_of_line = decoder.next_out_of_line();
6705 let handles_before = decoder.remaining_handles();
6706 if let Some((inlined, num_bytes, num_handles)) =
6707 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6708 {
6709 let member_inline_size =
6710 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
6711 decoder.context,
6712 );
6713 if inlined != (member_inline_size <= 4) {
6714 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6715 }
6716 let inner_offset;
6717 let mut inner_depth = depth.clone();
6718 if inlined {
6719 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6720 inner_offset = next_offset;
6721 } else {
6722 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6723 inner_depth.increment()?;
6724 }
6725 let val_ref = self
6726 .from_dictionary
6727 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
6728 fidl::decode!(
6729 fidl::encoding::UnboundedString,
6730 D,
6731 val_ref,
6732 decoder,
6733 inner_offset,
6734 inner_depth
6735 )?;
6736 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6737 {
6738 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6739 }
6740 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6741 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6742 }
6743 }
6744
6745 next_offset += envelope_size;
6746
6747 while next_offset < end_offset {
6749 _next_ordinal_to_read += 1;
6750 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6751 next_offset += envelope_size;
6752 }
6753
6754 Ok(())
6755 }
6756 }
6757
6758 impl Service {
6759 #[inline(always)]
6760 fn max_ordinal_present(&self) -> u64 {
6761 if let Some(_) = self.from_dictionary {
6762 return 5;
6763 }
6764 if let Some(_) = self.availability {
6765 return 4;
6766 }
6767 if let Some(_) = self.path {
6768 return 3;
6769 }
6770 if let Some(_) = self.as_ {
6771 return 2;
6772 }
6773 if let Some(_) = self.name {
6774 return 1;
6775 }
6776 0
6777 }
6778 }
6779
6780 impl fidl::encoding::ValueTypeMarker for Service {
6781 type Borrowed<'a> = &'a Self;
6782 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6783 value
6784 }
6785 }
6786
6787 unsafe impl fidl::encoding::TypeMarker for Service {
6788 type Owned = Self;
6789
6790 #[inline(always)]
6791 fn inline_align(_context: fidl::encoding::Context) -> usize {
6792 8
6793 }
6794
6795 #[inline(always)]
6796 fn inline_size(_context: fidl::encoding::Context) -> usize {
6797 16
6798 }
6799 }
6800
6801 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Service, D> for &Service {
6802 unsafe fn encode(
6803 self,
6804 encoder: &mut fidl::encoding::Encoder<'_, D>,
6805 offset: usize,
6806 mut depth: fidl::encoding::Depth,
6807 ) -> fidl::Result<()> {
6808 encoder.debug_check_bounds::<Service>(offset);
6809 let max_ordinal: u64 = self.max_ordinal_present();
6811 encoder.write_num(max_ordinal, offset);
6812 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6813 if max_ordinal == 0 {
6815 return Ok(());
6816 }
6817 depth.increment()?;
6818 let envelope_size = 8;
6819 let bytes_len = max_ordinal as usize * envelope_size;
6820 #[allow(unused_variables)]
6821 let offset = encoder.out_of_line_offset(bytes_len);
6822 let mut _prev_end_offset: usize = 0;
6823 if 1 > max_ordinal {
6824 return Ok(());
6825 }
6826
6827 let cur_offset: usize = (1 - 1) * envelope_size;
6830
6831 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6833
6834 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6839 self.name.as_ref().map(
6840 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6841 ),
6842 encoder,
6843 offset + cur_offset,
6844 depth,
6845 )?;
6846
6847 _prev_end_offset = cur_offset + envelope_size;
6848 if 2 > max_ordinal {
6849 return Ok(());
6850 }
6851
6852 let cur_offset: usize = (2 - 1) * envelope_size;
6855
6856 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6858
6859 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6864 self.as_.as_ref().map(
6865 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6866 ),
6867 encoder,
6868 offset + cur_offset,
6869 depth,
6870 )?;
6871
6872 _prev_end_offset = cur_offset + envelope_size;
6873 if 3 > max_ordinal {
6874 return Ok(());
6875 }
6876
6877 let cur_offset: usize = (3 - 1) * envelope_size;
6880
6881 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6883
6884 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
6889 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
6890 encoder, offset + cur_offset, depth
6891 )?;
6892
6893 _prev_end_offset = cur_offset + envelope_size;
6894 if 4 > max_ordinal {
6895 return Ok(());
6896 }
6897
6898 let cur_offset: usize = (4 - 1) * envelope_size;
6901
6902 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6904
6905 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
6910 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
6911 encoder, offset + cur_offset, depth
6912 )?;
6913
6914 _prev_end_offset = cur_offset + envelope_size;
6915 if 5 > max_ordinal {
6916 return Ok(());
6917 }
6918
6919 let cur_offset: usize = (5 - 1) * envelope_size;
6922
6923 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6925
6926 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
6931 self.from_dictionary.as_ref().map(
6932 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
6933 ),
6934 encoder,
6935 offset + cur_offset,
6936 depth,
6937 )?;
6938
6939 _prev_end_offset = cur_offset + envelope_size;
6940
6941 Ok(())
6942 }
6943 }
6944
6945 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Service {
6946 #[inline(always)]
6947 fn new_empty() -> Self {
6948 Self::default()
6949 }
6950
6951 unsafe fn decode(
6952 &mut self,
6953 decoder: &mut fidl::encoding::Decoder<'_, D>,
6954 offset: usize,
6955 mut depth: fidl::encoding::Depth,
6956 ) -> fidl::Result<()> {
6957 decoder.debug_check_bounds::<Self>(offset);
6958 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6959 None => return Err(fidl::Error::NotNullable),
6960 Some(len) => len,
6961 };
6962 if len == 0 {
6964 return Ok(());
6965 };
6966 depth.increment()?;
6967 let envelope_size = 8;
6968 let bytes_len = len * envelope_size;
6969 let offset = decoder.out_of_line_offset(bytes_len)?;
6970 let mut _next_ordinal_to_read = 0;
6972 let mut next_offset = offset;
6973 let end_offset = offset + bytes_len;
6974 _next_ordinal_to_read += 1;
6975 if next_offset >= end_offset {
6976 return Ok(());
6977 }
6978
6979 while _next_ordinal_to_read < 1 {
6981 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6982 _next_ordinal_to_read += 1;
6983 next_offset += envelope_size;
6984 }
6985
6986 let next_out_of_line = decoder.next_out_of_line();
6987 let handles_before = decoder.remaining_handles();
6988 if let Some((inlined, num_bytes, num_handles)) =
6989 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6990 {
6991 let member_inline_size =
6992 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6993 decoder.context,
6994 );
6995 if inlined != (member_inline_size <= 4) {
6996 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6997 }
6998 let inner_offset;
6999 let mut inner_depth = depth.clone();
7000 if inlined {
7001 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7002 inner_offset = next_offset;
7003 } else {
7004 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7005 inner_depth.increment()?;
7006 }
7007 let val_ref = self
7008 .name
7009 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7010 fidl::decode!(
7011 fidl::encoding::BoundedString<255>,
7012 D,
7013 val_ref,
7014 decoder,
7015 inner_offset,
7016 inner_depth
7017 )?;
7018 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7019 {
7020 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7021 }
7022 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7023 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7024 }
7025 }
7026
7027 next_offset += envelope_size;
7028 _next_ordinal_to_read += 1;
7029 if next_offset >= end_offset {
7030 return Ok(());
7031 }
7032
7033 while _next_ordinal_to_read < 2 {
7035 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7036 _next_ordinal_to_read += 1;
7037 next_offset += envelope_size;
7038 }
7039
7040 let next_out_of_line = decoder.next_out_of_line();
7041 let handles_before = decoder.remaining_handles();
7042 if let Some((inlined, num_bytes, num_handles)) =
7043 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7044 {
7045 let member_inline_size =
7046 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7047 decoder.context,
7048 );
7049 if inlined != (member_inline_size <= 4) {
7050 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7051 }
7052 let inner_offset;
7053 let mut inner_depth = depth.clone();
7054 if inlined {
7055 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7056 inner_offset = next_offset;
7057 } else {
7058 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7059 inner_depth.increment()?;
7060 }
7061 let val_ref = self
7062 .as_
7063 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7064 fidl::decode!(
7065 fidl::encoding::BoundedString<255>,
7066 D,
7067 val_ref,
7068 decoder,
7069 inner_offset,
7070 inner_depth
7071 )?;
7072 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7073 {
7074 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7075 }
7076 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7077 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7078 }
7079 }
7080
7081 next_offset += envelope_size;
7082 _next_ordinal_to_read += 1;
7083 if next_offset >= end_offset {
7084 return Ok(());
7085 }
7086
7087 while _next_ordinal_to_read < 3 {
7089 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7090 _next_ordinal_to_read += 1;
7091 next_offset += envelope_size;
7092 }
7093
7094 let next_out_of_line = decoder.next_out_of_line();
7095 let handles_before = decoder.remaining_handles();
7096 if let Some((inlined, num_bytes, num_handles)) =
7097 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7098 {
7099 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7100 if inlined != (member_inline_size <= 4) {
7101 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7102 }
7103 let inner_offset;
7104 let mut inner_depth = depth.clone();
7105 if inlined {
7106 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7107 inner_offset = next_offset;
7108 } else {
7109 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7110 inner_depth.increment()?;
7111 }
7112 let val_ref = self.path.get_or_insert_with(|| {
7113 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
7114 });
7115 fidl::decode!(
7116 fidl::encoding::BoundedString<4095>,
7117 D,
7118 val_ref,
7119 decoder,
7120 inner_offset,
7121 inner_depth
7122 )?;
7123 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7124 {
7125 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7126 }
7127 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7128 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7129 }
7130 }
7131
7132 next_offset += envelope_size;
7133 _next_ordinal_to_read += 1;
7134 if next_offset >= end_offset {
7135 return Ok(());
7136 }
7137
7138 while _next_ordinal_to_read < 4 {
7140 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7141 _next_ordinal_to_read += 1;
7142 next_offset += envelope_size;
7143 }
7144
7145 let next_out_of_line = decoder.next_out_of_line();
7146 let handles_before = decoder.remaining_handles();
7147 if let Some((inlined, num_bytes, num_handles)) =
7148 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7149 {
7150 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7151 if inlined != (member_inline_size <= 4) {
7152 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7153 }
7154 let inner_offset;
7155 let mut inner_depth = depth.clone();
7156 if inlined {
7157 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7158 inner_offset = next_offset;
7159 } else {
7160 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7161 inner_depth.increment()?;
7162 }
7163 let val_ref = self.availability.get_or_insert_with(|| {
7164 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
7165 });
7166 fidl::decode!(
7167 fidl_fuchsia_component_decl__common::Availability,
7168 D,
7169 val_ref,
7170 decoder,
7171 inner_offset,
7172 inner_depth
7173 )?;
7174 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7175 {
7176 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7177 }
7178 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7179 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7180 }
7181 }
7182
7183 next_offset += envelope_size;
7184 _next_ordinal_to_read += 1;
7185 if next_offset >= end_offset {
7186 return Ok(());
7187 }
7188
7189 while _next_ordinal_to_read < 5 {
7191 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7192 _next_ordinal_to_read += 1;
7193 next_offset += envelope_size;
7194 }
7195
7196 let next_out_of_line = decoder.next_out_of_line();
7197 let handles_before = decoder.remaining_handles();
7198 if let Some((inlined, num_bytes, num_handles)) =
7199 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7200 {
7201 let member_inline_size =
7202 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7203 decoder.context,
7204 );
7205 if inlined != (member_inline_size <= 4) {
7206 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7207 }
7208 let inner_offset;
7209 let mut inner_depth = depth.clone();
7210 if inlined {
7211 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7212 inner_offset = next_offset;
7213 } else {
7214 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7215 inner_depth.increment()?;
7216 }
7217 let val_ref = self
7218 .from_dictionary
7219 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7220 fidl::decode!(
7221 fidl::encoding::UnboundedString,
7222 D,
7223 val_ref,
7224 decoder,
7225 inner_offset,
7226 inner_depth
7227 )?;
7228 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7229 {
7230 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7231 }
7232 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7233 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7234 }
7235 }
7236
7237 next_offset += envelope_size;
7238
7239 while next_offset < end_offset {
7241 _next_ordinal_to_read += 1;
7242 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7243 next_offset += envelope_size;
7244 }
7245
7246 Ok(())
7247 }
7248 }
7249
7250 impl Storage {
7251 #[inline(always)]
7252 fn max_ordinal_present(&self) -> u64 {
7253 if let Some(_) = self.availability {
7254 return 4;
7255 }
7256 if let Some(_) = self.path {
7257 return 3;
7258 }
7259 if let Some(_) = self.as_ {
7260 return 2;
7261 }
7262 if let Some(_) = self.name {
7263 return 1;
7264 }
7265 0
7266 }
7267 }
7268
7269 impl fidl::encoding::ValueTypeMarker for Storage {
7270 type Borrowed<'a> = &'a Self;
7271 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7272 value
7273 }
7274 }
7275
7276 unsafe impl fidl::encoding::TypeMarker for Storage {
7277 type Owned = Self;
7278
7279 #[inline(always)]
7280 fn inline_align(_context: fidl::encoding::Context) -> usize {
7281 8
7282 }
7283
7284 #[inline(always)]
7285 fn inline_size(_context: fidl::encoding::Context) -> usize {
7286 16
7287 }
7288 }
7289
7290 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Storage, D> for &Storage {
7291 unsafe fn encode(
7292 self,
7293 encoder: &mut fidl::encoding::Encoder<'_, D>,
7294 offset: usize,
7295 mut depth: fidl::encoding::Depth,
7296 ) -> fidl::Result<()> {
7297 encoder.debug_check_bounds::<Storage>(offset);
7298 let max_ordinal: u64 = self.max_ordinal_present();
7300 encoder.write_num(max_ordinal, offset);
7301 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7302 if max_ordinal == 0 {
7304 return Ok(());
7305 }
7306 depth.increment()?;
7307 let envelope_size = 8;
7308 let bytes_len = max_ordinal as usize * envelope_size;
7309 #[allow(unused_variables)]
7310 let offset = encoder.out_of_line_offset(bytes_len);
7311 let mut _prev_end_offset: usize = 0;
7312 if 1 > max_ordinal {
7313 return Ok(());
7314 }
7315
7316 let cur_offset: usize = (1 - 1) * envelope_size;
7319
7320 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7322
7323 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
7328 self.name.as_ref().map(
7329 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
7330 ),
7331 encoder,
7332 offset + cur_offset,
7333 depth,
7334 )?;
7335
7336 _prev_end_offset = cur_offset + envelope_size;
7337 if 2 > max_ordinal {
7338 return Ok(());
7339 }
7340
7341 let cur_offset: usize = (2 - 1) * envelope_size;
7344
7345 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7347
7348 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
7353 self.as_.as_ref().map(
7354 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
7355 ),
7356 encoder,
7357 offset + cur_offset,
7358 depth,
7359 )?;
7360
7361 _prev_end_offset = cur_offset + envelope_size;
7362 if 3 > max_ordinal {
7363 return Ok(());
7364 }
7365
7366 let cur_offset: usize = (3 - 1) * envelope_size;
7369
7370 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7372
7373 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
7378 self.path.as_ref().map(
7379 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
7380 ),
7381 encoder,
7382 offset + cur_offset,
7383 depth,
7384 )?;
7385
7386 _prev_end_offset = cur_offset + envelope_size;
7387 if 4 > max_ordinal {
7388 return Ok(());
7389 }
7390
7391 let cur_offset: usize = (4 - 1) * envelope_size;
7394
7395 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7397
7398 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
7403 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
7404 encoder, offset + cur_offset, depth
7405 )?;
7406
7407 _prev_end_offset = cur_offset + envelope_size;
7408
7409 Ok(())
7410 }
7411 }
7412
7413 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Storage {
7414 #[inline(always)]
7415 fn new_empty() -> Self {
7416 Self::default()
7417 }
7418
7419 unsafe fn decode(
7420 &mut self,
7421 decoder: &mut fidl::encoding::Decoder<'_, D>,
7422 offset: usize,
7423 mut depth: fidl::encoding::Depth,
7424 ) -> fidl::Result<()> {
7425 decoder.debug_check_bounds::<Self>(offset);
7426 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7427 None => return Err(fidl::Error::NotNullable),
7428 Some(len) => len,
7429 };
7430 if len == 0 {
7432 return Ok(());
7433 };
7434 depth.increment()?;
7435 let envelope_size = 8;
7436 let bytes_len = len * envelope_size;
7437 let offset = decoder.out_of_line_offset(bytes_len)?;
7438 let mut _next_ordinal_to_read = 0;
7440 let mut next_offset = offset;
7441 let end_offset = offset + bytes_len;
7442 _next_ordinal_to_read += 1;
7443 if next_offset >= end_offset {
7444 return Ok(());
7445 }
7446
7447 while _next_ordinal_to_read < 1 {
7449 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7450 _next_ordinal_to_read += 1;
7451 next_offset += envelope_size;
7452 }
7453
7454 let next_out_of_line = decoder.next_out_of_line();
7455 let handles_before = decoder.remaining_handles();
7456 if let Some((inlined, num_bytes, num_handles)) =
7457 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7458 {
7459 let member_inline_size =
7460 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7461 decoder.context,
7462 );
7463 if inlined != (member_inline_size <= 4) {
7464 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7465 }
7466 let inner_offset;
7467 let mut inner_depth = depth.clone();
7468 if inlined {
7469 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7470 inner_offset = next_offset;
7471 } else {
7472 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7473 inner_depth.increment()?;
7474 }
7475 let val_ref = self
7476 .name
7477 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7478 fidl::decode!(
7479 fidl::encoding::BoundedString<255>,
7480 D,
7481 val_ref,
7482 decoder,
7483 inner_offset,
7484 inner_depth
7485 )?;
7486 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7487 {
7488 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7489 }
7490 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7491 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7492 }
7493 }
7494
7495 next_offset += envelope_size;
7496 _next_ordinal_to_read += 1;
7497 if next_offset >= end_offset {
7498 return Ok(());
7499 }
7500
7501 while _next_ordinal_to_read < 2 {
7503 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7504 _next_ordinal_to_read += 1;
7505 next_offset += envelope_size;
7506 }
7507
7508 let next_out_of_line = decoder.next_out_of_line();
7509 let handles_before = decoder.remaining_handles();
7510 if let Some((inlined, num_bytes, num_handles)) =
7511 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7512 {
7513 let member_inline_size =
7514 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7515 decoder.context,
7516 );
7517 if inlined != (member_inline_size <= 4) {
7518 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7519 }
7520 let inner_offset;
7521 let mut inner_depth = depth.clone();
7522 if inlined {
7523 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7524 inner_offset = next_offset;
7525 } else {
7526 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7527 inner_depth.increment()?;
7528 }
7529 let val_ref = self
7530 .as_
7531 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7532 fidl::decode!(
7533 fidl::encoding::BoundedString<255>,
7534 D,
7535 val_ref,
7536 decoder,
7537 inner_offset,
7538 inner_depth
7539 )?;
7540 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7541 {
7542 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7543 }
7544 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7545 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7546 }
7547 }
7548
7549 next_offset += envelope_size;
7550 _next_ordinal_to_read += 1;
7551 if next_offset >= end_offset {
7552 return Ok(());
7553 }
7554
7555 while _next_ordinal_to_read < 3 {
7557 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7558 _next_ordinal_to_read += 1;
7559 next_offset += envelope_size;
7560 }
7561
7562 let next_out_of_line = decoder.next_out_of_line();
7563 let handles_before = decoder.remaining_handles();
7564 if let Some((inlined, num_bytes, num_handles)) =
7565 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7566 {
7567 let member_inline_size =
7568 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7569 decoder.context,
7570 );
7571 if inlined != (member_inline_size <= 4) {
7572 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7573 }
7574 let inner_offset;
7575 let mut inner_depth = depth.clone();
7576 if inlined {
7577 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7578 inner_offset = next_offset;
7579 } else {
7580 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7581 inner_depth.increment()?;
7582 }
7583 let val_ref = self
7584 .path
7585 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7586 fidl::decode!(
7587 fidl::encoding::BoundedString<255>,
7588 D,
7589 val_ref,
7590 decoder,
7591 inner_offset,
7592 inner_depth
7593 )?;
7594 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7595 {
7596 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7597 }
7598 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7599 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7600 }
7601 }
7602
7603 next_offset += envelope_size;
7604 _next_ordinal_to_read += 1;
7605 if next_offset >= end_offset {
7606 return Ok(());
7607 }
7608
7609 while _next_ordinal_to_read < 4 {
7611 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7612 _next_ordinal_to_read += 1;
7613 next_offset += envelope_size;
7614 }
7615
7616 let next_out_of_line = decoder.next_out_of_line();
7617 let handles_before = decoder.remaining_handles();
7618 if let Some((inlined, num_bytes, num_handles)) =
7619 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7620 {
7621 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7622 if inlined != (member_inline_size <= 4) {
7623 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7624 }
7625 let inner_offset;
7626 let mut inner_depth = depth.clone();
7627 if inlined {
7628 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7629 inner_offset = next_offset;
7630 } else {
7631 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7632 inner_depth.increment()?;
7633 }
7634 let val_ref = self.availability.get_or_insert_with(|| {
7635 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
7636 });
7637 fidl::decode!(
7638 fidl_fuchsia_component_decl__common::Availability,
7639 D,
7640 val_ref,
7641 decoder,
7642 inner_offset,
7643 inner_depth
7644 )?;
7645 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7646 {
7647 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7648 }
7649 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7650 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7651 }
7652 }
7653
7654 next_offset += envelope_size;
7655
7656 while next_offset < end_offset {
7658 _next_ordinal_to_read += 1;
7659 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7660 next_offset += envelope_size;
7661 }
7662
7663 Ok(())
7664 }
7665 }
7666
7667 impl fidl::encoding::ValueTypeMarker for Capability {
7668 type Borrowed<'a> = &'a Self;
7669 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7670 value
7671 }
7672 }
7673
7674 unsafe impl fidl::encoding::TypeMarker for Capability {
7675 type Owned = Self;
7676
7677 #[inline(always)]
7678 fn inline_align(_context: fidl::encoding::Context) -> usize {
7679 8
7680 }
7681
7682 #[inline(always)]
7683 fn inline_size(_context: fidl::encoding::Context) -> usize {
7684 16
7685 }
7686 }
7687
7688 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Capability, D>
7689 for &Capability
7690 {
7691 #[inline]
7692 unsafe fn encode(
7693 self,
7694 encoder: &mut fidl::encoding::Encoder<'_, D>,
7695 offset: usize,
7696 _depth: fidl::encoding::Depth,
7697 ) -> fidl::Result<()> {
7698 encoder.debug_check_bounds::<Capability>(offset);
7699 encoder.write_num::<u64>(self.ordinal(), offset);
7700 match self {
7701 Capability::Protocol(ref val) => fidl::encoding::encode_in_envelope::<Protocol, D>(
7702 <Protocol as fidl::encoding::ValueTypeMarker>::borrow(val),
7703 encoder,
7704 offset + 8,
7705 _depth,
7706 ),
7707 Capability::Directory(ref val) => {
7708 fidl::encoding::encode_in_envelope::<Directory, D>(
7709 <Directory as fidl::encoding::ValueTypeMarker>::borrow(val),
7710 encoder,
7711 offset + 8,
7712 _depth,
7713 )
7714 }
7715 Capability::Storage(ref val) => fidl::encoding::encode_in_envelope::<Storage, D>(
7716 <Storage as fidl::encoding::ValueTypeMarker>::borrow(val),
7717 encoder,
7718 offset + 8,
7719 _depth,
7720 ),
7721 Capability::Service(ref val) => fidl::encoding::encode_in_envelope::<Service, D>(
7722 <Service as fidl::encoding::ValueTypeMarker>::borrow(val),
7723 encoder,
7724 offset + 8,
7725 _depth,
7726 ),
7727 Capability::EventStream(ref val) => {
7728 fidl::encoding::encode_in_envelope::<EventStream, D>(
7729 <EventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
7730 encoder,
7731 offset + 8,
7732 _depth,
7733 )
7734 }
7735 Capability::Config(ref val) => fidl::encoding::encode_in_envelope::<Config, D>(
7736 <Config as fidl::encoding::ValueTypeMarker>::borrow(val),
7737 encoder,
7738 offset + 8,
7739 _depth,
7740 ),
7741 Capability::Dictionary(ref val) => {
7742 fidl::encoding::encode_in_envelope::<Dictionary, D>(
7743 <Dictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
7744 encoder,
7745 offset + 8,
7746 _depth,
7747 )
7748 }
7749 Capability::Resolver(ref val) => fidl::encoding::encode_in_envelope::<Resolver, D>(
7750 <Resolver as fidl::encoding::ValueTypeMarker>::borrow(val),
7751 encoder,
7752 offset + 8,
7753 _depth,
7754 ),
7755 Capability::Runner(ref val) => fidl::encoding::encode_in_envelope::<Runner, D>(
7756 <Runner as fidl::encoding::ValueTypeMarker>::borrow(val),
7757 encoder,
7758 offset + 8,
7759 _depth,
7760 ),
7761 Capability::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
7762 }
7763 }
7764 }
7765
7766 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Capability {
7767 #[inline(always)]
7768 fn new_empty() -> Self {
7769 Self::__SourceBreaking { unknown_ordinal: 0 }
7770 }
7771
7772 #[inline]
7773 unsafe fn decode(
7774 &mut self,
7775 decoder: &mut fidl::encoding::Decoder<'_, D>,
7776 offset: usize,
7777 mut depth: fidl::encoding::Depth,
7778 ) -> fidl::Result<()> {
7779 decoder.debug_check_bounds::<Self>(offset);
7780 #[allow(unused_variables)]
7781 let next_out_of_line = decoder.next_out_of_line();
7782 let handles_before = decoder.remaining_handles();
7783 let (ordinal, inlined, num_bytes, num_handles) =
7784 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7785
7786 let member_inline_size = match ordinal {
7787 1 => <Protocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7788 2 => <Directory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7789 3 => <Storage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7790 4 => <Service as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7791 6 => <EventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7792 7 => <Config as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7793 8 => <Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7794 9 => <Resolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7795 10 => <Runner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7796 0 => return Err(fidl::Error::UnknownUnionTag),
7797 _ => num_bytes as usize,
7798 };
7799
7800 if inlined != (member_inline_size <= 4) {
7801 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7802 }
7803 let _inner_offset;
7804 if inlined {
7805 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7806 _inner_offset = offset + 8;
7807 } else {
7808 depth.increment()?;
7809 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7810 }
7811 match ordinal {
7812 1 => {
7813 #[allow(irrefutable_let_patterns)]
7814 if let Capability::Protocol(_) = self {
7815 } else {
7817 *self = Capability::Protocol(fidl::new_empty!(Protocol, D));
7819 }
7820 #[allow(irrefutable_let_patterns)]
7821 if let Capability::Protocol(ref mut val) = self {
7822 fidl::decode!(Protocol, D, val, decoder, _inner_offset, depth)?;
7823 } else {
7824 unreachable!()
7825 }
7826 }
7827 2 => {
7828 #[allow(irrefutable_let_patterns)]
7829 if let Capability::Directory(_) = self {
7830 } else {
7832 *self = Capability::Directory(fidl::new_empty!(Directory, D));
7834 }
7835 #[allow(irrefutable_let_patterns)]
7836 if let Capability::Directory(ref mut val) = self {
7837 fidl::decode!(Directory, D, val, decoder, _inner_offset, depth)?;
7838 } else {
7839 unreachable!()
7840 }
7841 }
7842 3 => {
7843 #[allow(irrefutable_let_patterns)]
7844 if let Capability::Storage(_) = self {
7845 } else {
7847 *self = Capability::Storage(fidl::new_empty!(Storage, D));
7849 }
7850 #[allow(irrefutable_let_patterns)]
7851 if let Capability::Storage(ref mut val) = self {
7852 fidl::decode!(Storage, D, val, decoder, _inner_offset, depth)?;
7853 } else {
7854 unreachable!()
7855 }
7856 }
7857 4 => {
7858 #[allow(irrefutable_let_patterns)]
7859 if let Capability::Service(_) = self {
7860 } else {
7862 *self = Capability::Service(fidl::new_empty!(Service, D));
7864 }
7865 #[allow(irrefutable_let_patterns)]
7866 if let Capability::Service(ref mut val) = self {
7867 fidl::decode!(Service, D, val, decoder, _inner_offset, depth)?;
7868 } else {
7869 unreachable!()
7870 }
7871 }
7872 6 => {
7873 #[allow(irrefutable_let_patterns)]
7874 if let Capability::EventStream(_) = self {
7875 } else {
7877 *self = Capability::EventStream(fidl::new_empty!(EventStream, D));
7879 }
7880 #[allow(irrefutable_let_patterns)]
7881 if let Capability::EventStream(ref mut val) = self {
7882 fidl::decode!(EventStream, D, val, decoder, _inner_offset, depth)?;
7883 } else {
7884 unreachable!()
7885 }
7886 }
7887 7 => {
7888 #[allow(irrefutable_let_patterns)]
7889 if let Capability::Config(_) = self {
7890 } else {
7892 *self = Capability::Config(fidl::new_empty!(Config, D));
7894 }
7895 #[allow(irrefutable_let_patterns)]
7896 if let Capability::Config(ref mut val) = self {
7897 fidl::decode!(Config, D, val, decoder, _inner_offset, depth)?;
7898 } else {
7899 unreachable!()
7900 }
7901 }
7902 8 => {
7903 #[allow(irrefutable_let_patterns)]
7904 if let Capability::Dictionary(_) = self {
7905 } else {
7907 *self = Capability::Dictionary(fidl::new_empty!(Dictionary, D));
7909 }
7910 #[allow(irrefutable_let_patterns)]
7911 if let Capability::Dictionary(ref mut val) = self {
7912 fidl::decode!(Dictionary, D, val, decoder, _inner_offset, depth)?;
7913 } else {
7914 unreachable!()
7915 }
7916 }
7917 9 => {
7918 #[allow(irrefutable_let_patterns)]
7919 if let Capability::Resolver(_) = self {
7920 } else {
7922 *self = Capability::Resolver(fidl::new_empty!(Resolver, D));
7924 }
7925 #[allow(irrefutable_let_patterns)]
7926 if let Capability::Resolver(ref mut val) = self {
7927 fidl::decode!(Resolver, D, val, decoder, _inner_offset, depth)?;
7928 } else {
7929 unreachable!()
7930 }
7931 }
7932 10 => {
7933 #[allow(irrefutable_let_patterns)]
7934 if let Capability::Runner(_) = self {
7935 } else {
7937 *self = Capability::Runner(fidl::new_empty!(Runner, D));
7939 }
7940 #[allow(irrefutable_let_patterns)]
7941 if let Capability::Runner(ref mut val) = self {
7942 fidl::decode!(Runner, D, val, decoder, _inner_offset, depth)?;
7943 } else {
7944 unreachable!()
7945 }
7946 }
7947 #[allow(deprecated)]
7948 ordinal => {
7949 for _ in 0..num_handles {
7950 decoder.drop_next_handle()?;
7951 }
7952 *self = Capability::__SourceBreaking { unknown_ordinal: ordinal };
7953 }
7954 }
7955 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
7956 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7957 }
7958 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7959 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7960 }
7961 Ok(())
7962 }
7963 }
7964}