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
686mod internal {
687 use super::*;
688 unsafe impl fidl::encoding::TypeMarker for RealmBuilderError {
689 type Owned = Self;
690
691 #[inline(always)]
692 fn inline_align(_context: fidl::encoding::Context) -> usize {
693 std::mem::align_of::<u32>()
694 }
695
696 #[inline(always)]
697 fn inline_size(_context: fidl::encoding::Context) -> usize {
698 std::mem::size_of::<u32>()
699 }
700
701 #[inline(always)]
702 fn encode_is_copy() -> bool {
703 false
704 }
705
706 #[inline(always)]
707 fn decode_is_copy() -> bool {
708 false
709 }
710 }
711
712 impl fidl::encoding::ValueTypeMarker for RealmBuilderError {
713 type Borrowed<'a> = Self;
714 #[inline(always)]
715 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
716 *value
717 }
718 }
719
720 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
721 for RealmBuilderError
722 {
723 #[inline]
724 unsafe fn encode(
725 self,
726 encoder: &mut fidl::encoding::Encoder<'_, D>,
727 offset: usize,
728 _depth: fidl::encoding::Depth,
729 ) -> fidl::Result<()> {
730 encoder.debug_check_bounds::<Self>(offset);
731 encoder.write_num(self.into_primitive(), offset);
732 Ok(())
733 }
734 }
735
736 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RealmBuilderError {
737 #[inline(always)]
738 fn new_empty() -> Self {
739 Self::unknown()
740 }
741
742 #[inline]
743 unsafe fn decode(
744 &mut self,
745 decoder: &mut fidl::encoding::Decoder<'_, D>,
746 offset: usize,
747 _depth: fidl::encoding::Depth,
748 ) -> fidl::Result<()> {
749 decoder.debug_check_bounds::<Self>(offset);
750 let prim = decoder.read_num::<u32>(offset);
751
752 *self = Self::from_primitive_allow_unknown(prim);
753 Ok(())
754 }
755 }
756
757 impl fidl::encoding::ValueTypeMarker for BuilderBuildResponse {
758 type Borrowed<'a> = &'a Self;
759 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
760 value
761 }
762 }
763
764 unsafe impl fidl::encoding::TypeMarker for BuilderBuildResponse {
765 type Owned = Self;
766
767 #[inline(always)]
768 fn inline_align(_context: fidl::encoding::Context) -> usize {
769 8
770 }
771
772 #[inline(always)]
773 fn inline_size(_context: fidl::encoding::Context) -> usize {
774 16
775 }
776 }
777
778 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BuilderBuildResponse, D>
779 for &BuilderBuildResponse
780 {
781 #[inline]
782 unsafe fn encode(
783 self,
784 encoder: &mut fidl::encoding::Encoder<'_, D>,
785 offset: usize,
786 _depth: fidl::encoding::Depth,
787 ) -> fidl::Result<()> {
788 encoder.debug_check_bounds::<BuilderBuildResponse>(offset);
789 fidl::encoding::Encode::<BuilderBuildResponse, D>::encode(
791 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
792 &self.root_component_url,
793 ),),
794 encoder,
795 offset,
796 _depth,
797 )
798 }
799 }
800 unsafe impl<
801 D: fidl::encoding::ResourceDialect,
802 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
803 > fidl::encoding::Encode<BuilderBuildResponse, D> for (T0,)
804 {
805 #[inline]
806 unsafe fn encode(
807 self,
808 encoder: &mut fidl::encoding::Encoder<'_, D>,
809 offset: usize,
810 depth: fidl::encoding::Depth,
811 ) -> fidl::Result<()> {
812 encoder.debug_check_bounds::<BuilderBuildResponse>(offset);
813 self.0.encode(encoder, offset + 0, depth)?;
817 Ok(())
818 }
819 }
820
821 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BuilderBuildResponse {
822 #[inline(always)]
823 fn new_empty() -> Self {
824 Self { root_component_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
825 }
826
827 #[inline]
828 unsafe fn decode(
829 &mut self,
830 decoder: &mut fidl::encoding::Decoder<'_, D>,
831 offset: usize,
832 _depth: fidl::encoding::Depth,
833 ) -> fidl::Result<()> {
834 decoder.debug_check_bounds::<Self>(offset);
835 fidl::decode!(
837 fidl::encoding::BoundedString<4096>,
838 D,
839 &mut self.root_component_url,
840 decoder,
841 offset + 0,
842 _depth
843 )?;
844 Ok(())
845 }
846 }
847
848 impl fidl::encoding::ValueTypeMarker for RealmAddCapabilityRequest {
849 type Borrowed<'a> = &'a Self;
850 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
851 value
852 }
853 }
854
855 unsafe impl fidl::encoding::TypeMarker for RealmAddCapabilityRequest {
856 type Owned = Self;
857
858 #[inline(always)]
859 fn inline_align(_context: fidl::encoding::Context) -> usize {
860 8
861 }
862
863 #[inline(always)]
864 fn inline_size(_context: fidl::encoding::Context) -> usize {
865 16
866 }
867 }
868
869 unsafe impl<D: fidl::encoding::ResourceDialect>
870 fidl::encoding::Encode<RealmAddCapabilityRequest, D> for &RealmAddCapabilityRequest
871 {
872 #[inline]
873 unsafe fn encode(
874 self,
875 encoder: &mut fidl::encoding::Encoder<'_, D>,
876 offset: usize,
877 _depth: fidl::encoding::Depth,
878 ) -> fidl::Result<()> {
879 encoder.debug_check_bounds::<RealmAddCapabilityRequest>(offset);
880 fidl::encoding::Encode::<RealmAddCapabilityRequest, D>::encode(
882 (
883 <fidl_fuchsia_component_decl__common::Capability as fidl::encoding::ValueTypeMarker>::borrow(&self.capability),
884 ),
885 encoder, offset, _depth
886 )
887 }
888 }
889 unsafe impl<
890 D: fidl::encoding::ResourceDialect,
891 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Capability, D>,
892 > fidl::encoding::Encode<RealmAddCapabilityRequest, D> for (T0,)
893 {
894 #[inline]
895 unsafe fn encode(
896 self,
897 encoder: &mut fidl::encoding::Encoder<'_, D>,
898 offset: usize,
899 depth: fidl::encoding::Depth,
900 ) -> fidl::Result<()> {
901 encoder.debug_check_bounds::<RealmAddCapabilityRequest>(offset);
902 self.0.encode(encoder, offset + 0, depth)?;
906 Ok(())
907 }
908 }
909
910 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
911 for RealmAddCapabilityRequest
912 {
913 #[inline(always)]
914 fn new_empty() -> Self {
915 Self {
916 capability: fidl::new_empty!(fidl_fuchsia_component_decl__common::Capability, D),
917 }
918 }
919
920 #[inline]
921 unsafe fn decode(
922 &mut self,
923 decoder: &mut fidl::encoding::Decoder<'_, D>,
924 offset: usize,
925 _depth: fidl::encoding::Depth,
926 ) -> fidl::Result<()> {
927 decoder.debug_check_bounds::<Self>(offset);
928 fidl::decode!(
930 fidl_fuchsia_component_decl__common::Capability,
931 D,
932 &mut self.capability,
933 decoder,
934 offset + 0,
935 _depth
936 )?;
937 Ok(())
938 }
939 }
940
941 impl fidl::encoding::ValueTypeMarker for RealmAddChildFromDeclRequest {
942 type Borrowed<'a> = &'a Self;
943 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
944 value
945 }
946 }
947
948 unsafe impl fidl::encoding::TypeMarker for RealmAddChildFromDeclRequest {
949 type Owned = Self;
950
951 #[inline(always)]
952 fn inline_align(_context: fidl::encoding::Context) -> usize {
953 8
954 }
955
956 #[inline(always)]
957 fn inline_size(_context: fidl::encoding::Context) -> usize {
958 48
959 }
960 }
961
962 unsafe impl<D: fidl::encoding::ResourceDialect>
963 fidl::encoding::Encode<RealmAddChildFromDeclRequest, D> for &RealmAddChildFromDeclRequest
964 {
965 #[inline]
966 unsafe fn encode(
967 self,
968 encoder: &mut fidl::encoding::Encoder<'_, D>,
969 offset: usize,
970 _depth: fidl::encoding::Depth,
971 ) -> fidl::Result<()> {
972 encoder.debug_check_bounds::<RealmAddChildFromDeclRequest>(offset);
973 fidl::encoding::Encode::<RealmAddChildFromDeclRequest, D>::encode(
975 (
976 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
977 <fidl_fuchsia_component_decl__common::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.decl),
978 <ChildOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
979 ),
980 encoder, offset, _depth
981 )
982 }
983 }
984 unsafe impl<
985 D: fidl::encoding::ResourceDialect,
986 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
987 T1: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Component, D>,
988 T2: fidl::encoding::Encode<ChildOptions, D>,
989 > fidl::encoding::Encode<RealmAddChildFromDeclRequest, D> for (T0, T1, T2)
990 {
991 #[inline]
992 unsafe fn encode(
993 self,
994 encoder: &mut fidl::encoding::Encoder<'_, D>,
995 offset: usize,
996 depth: fidl::encoding::Depth,
997 ) -> fidl::Result<()> {
998 encoder.debug_check_bounds::<RealmAddChildFromDeclRequest>(offset);
999 self.0.encode(encoder, offset + 0, depth)?;
1003 self.1.encode(encoder, offset + 16, depth)?;
1004 self.2.encode(encoder, offset + 32, depth)?;
1005 Ok(())
1006 }
1007 }
1008
1009 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1010 for RealmAddChildFromDeclRequest
1011 {
1012 #[inline(always)]
1013 fn new_empty() -> Self {
1014 Self {
1015 name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D),
1016 decl: fidl::new_empty!(fidl_fuchsia_component_decl__common::Component, D),
1017 options: fidl::new_empty!(ChildOptions, D),
1018 }
1019 }
1020
1021 #[inline]
1022 unsafe fn decode(
1023 &mut self,
1024 decoder: &mut fidl::encoding::Decoder<'_, D>,
1025 offset: usize,
1026 _depth: fidl::encoding::Depth,
1027 ) -> fidl::Result<()> {
1028 decoder.debug_check_bounds::<Self>(offset);
1029 fidl::decode!(
1031 fidl::encoding::BoundedString<1024>,
1032 D,
1033 &mut self.name,
1034 decoder,
1035 offset + 0,
1036 _depth
1037 )?;
1038 fidl::decode!(
1039 fidl_fuchsia_component_decl__common::Component,
1040 D,
1041 &mut self.decl,
1042 decoder,
1043 offset + 16,
1044 _depth
1045 )?;
1046 fidl::decode!(ChildOptions, D, &mut self.options, decoder, offset + 32, _depth)?;
1047 Ok(())
1048 }
1049 }
1050
1051 impl fidl::encoding::ValueTypeMarker for RealmAddChildRequest {
1052 type Borrowed<'a> = &'a Self;
1053 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1054 value
1055 }
1056 }
1057
1058 unsafe impl fidl::encoding::TypeMarker for RealmAddChildRequest {
1059 type Owned = Self;
1060
1061 #[inline(always)]
1062 fn inline_align(_context: fidl::encoding::Context) -> usize {
1063 8
1064 }
1065
1066 #[inline(always)]
1067 fn inline_size(_context: fidl::encoding::Context) -> usize {
1068 48
1069 }
1070 }
1071
1072 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RealmAddChildRequest, D>
1073 for &RealmAddChildRequest
1074 {
1075 #[inline]
1076 unsafe fn encode(
1077 self,
1078 encoder: &mut fidl::encoding::Encoder<'_, D>,
1079 offset: usize,
1080 _depth: fidl::encoding::Depth,
1081 ) -> fidl::Result<()> {
1082 encoder.debug_check_bounds::<RealmAddChildRequest>(offset);
1083 fidl::encoding::Encode::<RealmAddChildRequest, D>::encode(
1085 (
1086 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1087 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.url),
1088 <ChildOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
1089 ),
1090 encoder, offset, _depth
1091 )
1092 }
1093 }
1094 unsafe impl<
1095 D: fidl::encoding::ResourceDialect,
1096 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
1097 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
1098 T2: fidl::encoding::Encode<ChildOptions, D>,
1099 > fidl::encoding::Encode<RealmAddChildRequest, D> for (T0, T1, T2)
1100 {
1101 #[inline]
1102 unsafe fn encode(
1103 self,
1104 encoder: &mut fidl::encoding::Encoder<'_, D>,
1105 offset: usize,
1106 depth: fidl::encoding::Depth,
1107 ) -> fidl::Result<()> {
1108 encoder.debug_check_bounds::<RealmAddChildRequest>(offset);
1109 self.0.encode(encoder, offset + 0, depth)?;
1113 self.1.encode(encoder, offset + 16, depth)?;
1114 self.2.encode(encoder, offset + 32, depth)?;
1115 Ok(())
1116 }
1117 }
1118
1119 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RealmAddChildRequest {
1120 #[inline(always)]
1121 fn new_empty() -> Self {
1122 Self {
1123 name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D),
1124 url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
1125 options: fidl::new_empty!(ChildOptions, D),
1126 }
1127 }
1128
1129 #[inline]
1130 unsafe fn decode(
1131 &mut self,
1132 decoder: &mut fidl::encoding::Decoder<'_, D>,
1133 offset: usize,
1134 _depth: fidl::encoding::Depth,
1135 ) -> fidl::Result<()> {
1136 decoder.debug_check_bounds::<Self>(offset);
1137 fidl::decode!(
1139 fidl::encoding::BoundedString<1024>,
1140 D,
1141 &mut self.name,
1142 decoder,
1143 offset + 0,
1144 _depth
1145 )?;
1146 fidl::decode!(
1147 fidl::encoding::BoundedString<4096>,
1148 D,
1149 &mut self.url,
1150 decoder,
1151 offset + 16,
1152 _depth
1153 )?;
1154 fidl::decode!(ChildOptions, D, &mut self.options, decoder, offset + 32, _depth)?;
1155 Ok(())
1156 }
1157 }
1158
1159 impl fidl::encoding::ValueTypeMarker for RealmAddCollectionRequest {
1160 type Borrowed<'a> = &'a Self;
1161 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1162 value
1163 }
1164 }
1165
1166 unsafe impl fidl::encoding::TypeMarker for RealmAddCollectionRequest {
1167 type Owned = Self;
1168
1169 #[inline(always)]
1170 fn inline_align(_context: fidl::encoding::Context) -> usize {
1171 8
1172 }
1173
1174 #[inline(always)]
1175 fn inline_size(_context: fidl::encoding::Context) -> usize {
1176 16
1177 }
1178 }
1179
1180 unsafe impl<D: fidl::encoding::ResourceDialect>
1181 fidl::encoding::Encode<RealmAddCollectionRequest, D> for &RealmAddCollectionRequest
1182 {
1183 #[inline]
1184 unsafe fn encode(
1185 self,
1186 encoder: &mut fidl::encoding::Encoder<'_, D>,
1187 offset: usize,
1188 _depth: fidl::encoding::Depth,
1189 ) -> fidl::Result<()> {
1190 encoder.debug_check_bounds::<RealmAddCollectionRequest>(offset);
1191 fidl::encoding::Encode::<RealmAddCollectionRequest, D>::encode(
1193 (
1194 <fidl_fuchsia_component_decl__common::Collection as fidl::encoding::ValueTypeMarker>::borrow(&self.collection),
1195 ),
1196 encoder, offset, _depth
1197 )
1198 }
1199 }
1200 unsafe impl<
1201 D: fidl::encoding::ResourceDialect,
1202 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Collection, D>,
1203 > fidl::encoding::Encode<RealmAddCollectionRequest, D> for (T0,)
1204 {
1205 #[inline]
1206 unsafe fn encode(
1207 self,
1208 encoder: &mut fidl::encoding::Encoder<'_, D>,
1209 offset: usize,
1210 depth: fidl::encoding::Depth,
1211 ) -> fidl::Result<()> {
1212 encoder.debug_check_bounds::<RealmAddCollectionRequest>(offset);
1213 self.0.encode(encoder, offset + 0, depth)?;
1217 Ok(())
1218 }
1219 }
1220
1221 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1222 for RealmAddCollectionRequest
1223 {
1224 #[inline(always)]
1225 fn new_empty() -> Self {
1226 Self {
1227 collection: fidl::new_empty!(fidl_fuchsia_component_decl__common::Collection, D),
1228 }
1229 }
1230
1231 #[inline]
1232 unsafe fn decode(
1233 &mut self,
1234 decoder: &mut fidl::encoding::Decoder<'_, D>,
1235 offset: usize,
1236 _depth: fidl::encoding::Depth,
1237 ) -> fidl::Result<()> {
1238 decoder.debug_check_bounds::<Self>(offset);
1239 fidl::decode!(
1241 fidl_fuchsia_component_decl__common::Collection,
1242 D,
1243 &mut self.collection,
1244 decoder,
1245 offset + 0,
1246 _depth
1247 )?;
1248 Ok(())
1249 }
1250 }
1251
1252 impl fidl::encoding::ValueTypeMarker for RealmAddEnvironmentRequest {
1253 type Borrowed<'a> = &'a Self;
1254 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1255 value
1256 }
1257 }
1258
1259 unsafe impl fidl::encoding::TypeMarker for RealmAddEnvironmentRequest {
1260 type Owned = Self;
1261
1262 #[inline(always)]
1263 fn inline_align(_context: fidl::encoding::Context) -> usize {
1264 8
1265 }
1266
1267 #[inline(always)]
1268 fn inline_size(_context: fidl::encoding::Context) -> usize {
1269 16
1270 }
1271 }
1272
1273 unsafe impl<D: fidl::encoding::ResourceDialect>
1274 fidl::encoding::Encode<RealmAddEnvironmentRequest, D> for &RealmAddEnvironmentRequest
1275 {
1276 #[inline]
1277 unsafe fn encode(
1278 self,
1279 encoder: &mut fidl::encoding::Encoder<'_, D>,
1280 offset: usize,
1281 _depth: fidl::encoding::Depth,
1282 ) -> fidl::Result<()> {
1283 encoder.debug_check_bounds::<RealmAddEnvironmentRequest>(offset);
1284 fidl::encoding::Encode::<RealmAddEnvironmentRequest, D>::encode(
1286 (
1287 <fidl_fuchsia_component_decl__common::Environment as fidl::encoding::ValueTypeMarker>::borrow(&self.environment),
1288 ),
1289 encoder, offset, _depth
1290 )
1291 }
1292 }
1293 unsafe impl<
1294 D: fidl::encoding::ResourceDialect,
1295 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Environment, D>,
1296 > fidl::encoding::Encode<RealmAddEnvironmentRequest, D> for (T0,)
1297 {
1298 #[inline]
1299 unsafe fn encode(
1300 self,
1301 encoder: &mut fidl::encoding::Encoder<'_, D>,
1302 offset: usize,
1303 depth: fidl::encoding::Depth,
1304 ) -> fidl::Result<()> {
1305 encoder.debug_check_bounds::<RealmAddEnvironmentRequest>(offset);
1306 self.0.encode(encoder, offset + 0, depth)?;
1310 Ok(())
1311 }
1312 }
1313
1314 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1315 for RealmAddEnvironmentRequest
1316 {
1317 #[inline(always)]
1318 fn new_empty() -> Self {
1319 Self {
1320 environment: fidl::new_empty!(fidl_fuchsia_component_decl__common::Environment, D),
1321 }
1322 }
1323
1324 #[inline]
1325 unsafe fn decode(
1326 &mut self,
1327 decoder: &mut fidl::encoding::Decoder<'_, D>,
1328 offset: usize,
1329 _depth: fidl::encoding::Depth,
1330 ) -> fidl::Result<()> {
1331 decoder.debug_check_bounds::<Self>(offset);
1332 fidl::decode!(
1334 fidl_fuchsia_component_decl__common::Environment,
1335 D,
1336 &mut self.environment,
1337 decoder,
1338 offset + 0,
1339 _depth
1340 )?;
1341 Ok(())
1342 }
1343 }
1344
1345 impl fidl::encoding::ValueTypeMarker for RealmAddLocalChildRequest {
1346 type Borrowed<'a> = &'a Self;
1347 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1348 value
1349 }
1350 }
1351
1352 unsafe impl fidl::encoding::TypeMarker for RealmAddLocalChildRequest {
1353 type Owned = Self;
1354
1355 #[inline(always)]
1356 fn inline_align(_context: fidl::encoding::Context) -> usize {
1357 8
1358 }
1359
1360 #[inline(always)]
1361 fn inline_size(_context: fidl::encoding::Context) -> usize {
1362 32
1363 }
1364 }
1365
1366 unsafe impl<D: fidl::encoding::ResourceDialect>
1367 fidl::encoding::Encode<RealmAddLocalChildRequest, D> for &RealmAddLocalChildRequest
1368 {
1369 #[inline]
1370 unsafe fn encode(
1371 self,
1372 encoder: &mut fidl::encoding::Encoder<'_, D>,
1373 offset: usize,
1374 _depth: fidl::encoding::Depth,
1375 ) -> fidl::Result<()> {
1376 encoder.debug_check_bounds::<RealmAddLocalChildRequest>(offset);
1377 fidl::encoding::Encode::<RealmAddLocalChildRequest, D>::encode(
1379 (
1380 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1381 <ChildOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
1382 ),
1383 encoder, offset, _depth
1384 )
1385 }
1386 }
1387 unsafe impl<
1388 D: fidl::encoding::ResourceDialect,
1389 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
1390 T1: fidl::encoding::Encode<ChildOptions, D>,
1391 > fidl::encoding::Encode<RealmAddLocalChildRequest, D> for (T0, T1)
1392 {
1393 #[inline]
1394 unsafe fn encode(
1395 self,
1396 encoder: &mut fidl::encoding::Encoder<'_, D>,
1397 offset: usize,
1398 depth: fidl::encoding::Depth,
1399 ) -> fidl::Result<()> {
1400 encoder.debug_check_bounds::<RealmAddLocalChildRequest>(offset);
1401 self.0.encode(encoder, offset + 0, depth)?;
1405 self.1.encode(encoder, offset + 16, depth)?;
1406 Ok(())
1407 }
1408 }
1409
1410 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1411 for RealmAddLocalChildRequest
1412 {
1413 #[inline(always)]
1414 fn new_empty() -> Self {
1415 Self {
1416 name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D),
1417 options: fidl::new_empty!(ChildOptions, D),
1418 }
1419 }
1420
1421 #[inline]
1422 unsafe fn decode(
1423 &mut self,
1424 decoder: &mut fidl::encoding::Decoder<'_, D>,
1425 offset: usize,
1426 _depth: fidl::encoding::Depth,
1427 ) -> fidl::Result<()> {
1428 decoder.debug_check_bounds::<Self>(offset);
1429 fidl::decode!(
1431 fidl::encoding::BoundedString<1024>,
1432 D,
1433 &mut self.name,
1434 decoder,
1435 offset + 0,
1436 _depth
1437 )?;
1438 fidl::decode!(ChildOptions, D, &mut self.options, decoder, offset + 16, _depth)?;
1439 Ok(())
1440 }
1441 }
1442
1443 impl fidl::encoding::ValueTypeMarker for RealmAddRouteRequest {
1444 type Borrowed<'a> = &'a Self;
1445 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1446 value
1447 }
1448 }
1449
1450 unsafe impl fidl::encoding::TypeMarker for RealmAddRouteRequest {
1451 type Owned = Self;
1452
1453 #[inline(always)]
1454 fn inline_align(_context: fidl::encoding::Context) -> usize {
1455 8
1456 }
1457
1458 #[inline(always)]
1459 fn inline_size(_context: fidl::encoding::Context) -> usize {
1460 48
1461 }
1462 }
1463
1464 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RealmAddRouteRequest, D>
1465 for &RealmAddRouteRequest
1466 {
1467 #[inline]
1468 unsafe fn encode(
1469 self,
1470 encoder: &mut fidl::encoding::Encoder<'_, D>,
1471 offset: usize,
1472 _depth: fidl::encoding::Depth,
1473 ) -> fidl::Result<()> {
1474 encoder.debug_check_bounds::<RealmAddRouteRequest>(offset);
1475 fidl::encoding::Encode::<RealmAddRouteRequest, D>::encode(
1477 (
1478 <fidl::encoding::UnboundedVector<Capability> as fidl::encoding::ValueTypeMarker>::borrow(&self.capabilities),
1479 <fidl_fuchsia_component_decl__common::Ref as fidl::encoding::ValueTypeMarker>::borrow(&self.from),
1480 <fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref> as fidl::encoding::ValueTypeMarker>::borrow(&self.to),
1481 ),
1482 encoder, offset, _depth
1483 )
1484 }
1485 }
1486 unsafe impl<
1487 D: fidl::encoding::ResourceDialect,
1488 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Capability>, D>,
1489 T1: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Ref, D>,
1490 T2: fidl::encoding::Encode<
1491 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
1492 D,
1493 >,
1494 > fidl::encoding::Encode<RealmAddRouteRequest, D> for (T0, T1, T2)
1495 {
1496 #[inline]
1497 unsafe fn encode(
1498 self,
1499 encoder: &mut fidl::encoding::Encoder<'_, D>,
1500 offset: usize,
1501 depth: fidl::encoding::Depth,
1502 ) -> fidl::Result<()> {
1503 encoder.debug_check_bounds::<RealmAddRouteRequest>(offset);
1504 self.0.encode(encoder, offset + 0, depth)?;
1508 self.1.encode(encoder, offset + 16, depth)?;
1509 self.2.encode(encoder, offset + 32, depth)?;
1510 Ok(())
1511 }
1512 }
1513
1514 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RealmAddRouteRequest {
1515 #[inline(always)]
1516 fn new_empty() -> Self {
1517 Self {
1518 capabilities: fidl::new_empty!(fidl::encoding::UnboundedVector<Capability>, D),
1519 from: fidl::new_empty!(fidl_fuchsia_component_decl__common::Ref, D),
1520 to: fidl::new_empty!(
1521 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
1522 D
1523 ),
1524 }
1525 }
1526
1527 #[inline]
1528 unsafe fn decode(
1529 &mut self,
1530 decoder: &mut fidl::encoding::Decoder<'_, D>,
1531 offset: usize,
1532 _depth: fidl::encoding::Depth,
1533 ) -> fidl::Result<()> {
1534 decoder.debug_check_bounds::<Self>(offset);
1535 fidl::decode!(
1537 fidl::encoding::UnboundedVector<Capability>,
1538 D,
1539 &mut self.capabilities,
1540 decoder,
1541 offset + 0,
1542 _depth
1543 )?;
1544 fidl::decode!(
1545 fidl_fuchsia_component_decl__common::Ref,
1546 D,
1547 &mut self.from,
1548 decoder,
1549 offset + 16,
1550 _depth
1551 )?;
1552 fidl::decode!(
1553 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
1554 D,
1555 &mut self.to,
1556 decoder,
1557 offset + 32,
1558 _depth
1559 )?;
1560 Ok(())
1561 }
1562 }
1563
1564 impl fidl::encoding::ValueTypeMarker for RealmGetComponentDeclRequest {
1565 type Borrowed<'a> = &'a Self;
1566 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1567 value
1568 }
1569 }
1570
1571 unsafe impl fidl::encoding::TypeMarker for RealmGetComponentDeclRequest {
1572 type Owned = Self;
1573
1574 #[inline(always)]
1575 fn inline_align(_context: fidl::encoding::Context) -> usize {
1576 8
1577 }
1578
1579 #[inline(always)]
1580 fn inline_size(_context: fidl::encoding::Context) -> usize {
1581 16
1582 }
1583 }
1584
1585 unsafe impl<D: fidl::encoding::ResourceDialect>
1586 fidl::encoding::Encode<RealmGetComponentDeclRequest, D> for &RealmGetComponentDeclRequest
1587 {
1588 #[inline]
1589 unsafe fn encode(
1590 self,
1591 encoder: &mut fidl::encoding::Encoder<'_, D>,
1592 offset: usize,
1593 _depth: fidl::encoding::Depth,
1594 ) -> fidl::Result<()> {
1595 encoder.debug_check_bounds::<RealmGetComponentDeclRequest>(offset);
1596 fidl::encoding::Encode::<RealmGetComponentDeclRequest, D>::encode(
1598 (<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(
1599 &self.name,
1600 ),),
1601 encoder,
1602 offset,
1603 _depth,
1604 )
1605 }
1606 }
1607 unsafe impl<
1608 D: fidl::encoding::ResourceDialect,
1609 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
1610 > fidl::encoding::Encode<RealmGetComponentDeclRequest, D> for (T0,)
1611 {
1612 #[inline]
1613 unsafe fn encode(
1614 self,
1615 encoder: &mut fidl::encoding::Encoder<'_, D>,
1616 offset: usize,
1617 depth: fidl::encoding::Depth,
1618 ) -> fidl::Result<()> {
1619 encoder.debug_check_bounds::<RealmGetComponentDeclRequest>(offset);
1620 self.0.encode(encoder, offset + 0, depth)?;
1624 Ok(())
1625 }
1626 }
1627
1628 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1629 for RealmGetComponentDeclRequest
1630 {
1631 #[inline(always)]
1632 fn new_empty() -> Self {
1633 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D) }
1634 }
1635
1636 #[inline]
1637 unsafe fn decode(
1638 &mut self,
1639 decoder: &mut fidl::encoding::Decoder<'_, D>,
1640 offset: usize,
1641 _depth: fidl::encoding::Depth,
1642 ) -> fidl::Result<()> {
1643 decoder.debug_check_bounds::<Self>(offset);
1644 fidl::decode!(
1646 fidl::encoding::BoundedString<1024>,
1647 D,
1648 &mut self.name,
1649 decoder,
1650 offset + 0,
1651 _depth
1652 )?;
1653 Ok(())
1654 }
1655 }
1656
1657 impl fidl::encoding::ValueTypeMarker for RealmInitMutableConfigFromPackageRequest {
1658 type Borrowed<'a> = &'a Self;
1659 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1660 value
1661 }
1662 }
1663
1664 unsafe impl fidl::encoding::TypeMarker for RealmInitMutableConfigFromPackageRequest {
1665 type Owned = Self;
1666
1667 #[inline(always)]
1668 fn inline_align(_context: fidl::encoding::Context) -> usize {
1669 8
1670 }
1671
1672 #[inline(always)]
1673 fn inline_size(_context: fidl::encoding::Context) -> usize {
1674 16
1675 }
1676 }
1677
1678 unsafe impl<D: fidl::encoding::ResourceDialect>
1679 fidl::encoding::Encode<RealmInitMutableConfigFromPackageRequest, D>
1680 for &RealmInitMutableConfigFromPackageRequest
1681 {
1682 #[inline]
1683 unsafe fn encode(
1684 self,
1685 encoder: &mut fidl::encoding::Encoder<'_, D>,
1686 offset: usize,
1687 _depth: fidl::encoding::Depth,
1688 ) -> fidl::Result<()> {
1689 encoder.debug_check_bounds::<RealmInitMutableConfigFromPackageRequest>(offset);
1690 fidl::encoding::Encode::<RealmInitMutableConfigFromPackageRequest, D>::encode(
1692 (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
1693 &self.name,
1694 ),),
1695 encoder,
1696 offset,
1697 _depth,
1698 )
1699 }
1700 }
1701 unsafe impl<
1702 D: fidl::encoding::ResourceDialect,
1703 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
1704 > fidl::encoding::Encode<RealmInitMutableConfigFromPackageRequest, D> for (T0,)
1705 {
1706 #[inline]
1707 unsafe fn encode(
1708 self,
1709 encoder: &mut fidl::encoding::Encoder<'_, D>,
1710 offset: usize,
1711 depth: fidl::encoding::Depth,
1712 ) -> fidl::Result<()> {
1713 encoder.debug_check_bounds::<RealmInitMutableConfigFromPackageRequest>(offset);
1714 self.0.encode(encoder, offset + 0, depth)?;
1718 Ok(())
1719 }
1720 }
1721
1722 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1723 for RealmInitMutableConfigFromPackageRequest
1724 {
1725 #[inline(always)]
1726 fn new_empty() -> Self {
1727 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
1728 }
1729
1730 #[inline]
1731 unsafe fn decode(
1732 &mut self,
1733 decoder: &mut fidl::encoding::Decoder<'_, D>,
1734 offset: usize,
1735 _depth: fidl::encoding::Depth,
1736 ) -> fidl::Result<()> {
1737 decoder.debug_check_bounds::<Self>(offset);
1738 fidl::decode!(
1740 fidl::encoding::BoundedString<255>,
1741 D,
1742 &mut self.name,
1743 decoder,
1744 offset + 0,
1745 _depth
1746 )?;
1747 Ok(())
1748 }
1749 }
1750
1751 impl fidl::encoding::ValueTypeMarker for RealmInitMutableConfigToEmptyRequest {
1752 type Borrowed<'a> = &'a Self;
1753 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1754 value
1755 }
1756 }
1757
1758 unsafe impl fidl::encoding::TypeMarker for RealmInitMutableConfigToEmptyRequest {
1759 type Owned = Self;
1760
1761 #[inline(always)]
1762 fn inline_align(_context: fidl::encoding::Context) -> usize {
1763 8
1764 }
1765
1766 #[inline(always)]
1767 fn inline_size(_context: fidl::encoding::Context) -> usize {
1768 16
1769 }
1770 }
1771
1772 unsafe impl<D: fidl::encoding::ResourceDialect>
1773 fidl::encoding::Encode<RealmInitMutableConfigToEmptyRequest, D>
1774 for &RealmInitMutableConfigToEmptyRequest
1775 {
1776 #[inline]
1777 unsafe fn encode(
1778 self,
1779 encoder: &mut fidl::encoding::Encoder<'_, D>,
1780 offset: usize,
1781 _depth: fidl::encoding::Depth,
1782 ) -> fidl::Result<()> {
1783 encoder.debug_check_bounds::<RealmInitMutableConfigToEmptyRequest>(offset);
1784 fidl::encoding::Encode::<RealmInitMutableConfigToEmptyRequest, D>::encode(
1786 (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
1787 &self.name,
1788 ),),
1789 encoder,
1790 offset,
1791 _depth,
1792 )
1793 }
1794 }
1795 unsafe impl<
1796 D: fidl::encoding::ResourceDialect,
1797 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
1798 > fidl::encoding::Encode<RealmInitMutableConfigToEmptyRequest, D> for (T0,)
1799 {
1800 #[inline]
1801 unsafe fn encode(
1802 self,
1803 encoder: &mut fidl::encoding::Encoder<'_, D>,
1804 offset: usize,
1805 depth: fidl::encoding::Depth,
1806 ) -> fidl::Result<()> {
1807 encoder.debug_check_bounds::<RealmInitMutableConfigToEmptyRequest>(offset);
1808 self.0.encode(encoder, offset + 0, depth)?;
1812 Ok(())
1813 }
1814 }
1815
1816 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1817 for RealmInitMutableConfigToEmptyRequest
1818 {
1819 #[inline(always)]
1820 fn new_empty() -> Self {
1821 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
1822 }
1823
1824 #[inline]
1825 unsafe fn decode(
1826 &mut self,
1827 decoder: &mut fidl::encoding::Decoder<'_, D>,
1828 offset: usize,
1829 _depth: fidl::encoding::Depth,
1830 ) -> fidl::Result<()> {
1831 decoder.debug_check_bounds::<Self>(offset);
1832 fidl::decode!(
1834 fidl::encoding::BoundedString<255>,
1835 D,
1836 &mut self.name,
1837 decoder,
1838 offset + 0,
1839 _depth
1840 )?;
1841 Ok(())
1842 }
1843 }
1844
1845 impl fidl::encoding::ValueTypeMarker for RealmReplaceComponentDeclRequest {
1846 type Borrowed<'a> = &'a Self;
1847 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1848 value
1849 }
1850 }
1851
1852 unsafe impl fidl::encoding::TypeMarker for RealmReplaceComponentDeclRequest {
1853 type Owned = Self;
1854
1855 #[inline(always)]
1856 fn inline_align(_context: fidl::encoding::Context) -> usize {
1857 8
1858 }
1859
1860 #[inline(always)]
1861 fn inline_size(_context: fidl::encoding::Context) -> usize {
1862 32
1863 }
1864 }
1865
1866 unsafe impl<D: fidl::encoding::ResourceDialect>
1867 fidl::encoding::Encode<RealmReplaceComponentDeclRequest, D>
1868 for &RealmReplaceComponentDeclRequest
1869 {
1870 #[inline]
1871 unsafe fn encode(
1872 self,
1873 encoder: &mut fidl::encoding::Encoder<'_, D>,
1874 offset: usize,
1875 _depth: fidl::encoding::Depth,
1876 ) -> fidl::Result<()> {
1877 encoder.debug_check_bounds::<RealmReplaceComponentDeclRequest>(offset);
1878 fidl::encoding::Encode::<RealmReplaceComponentDeclRequest, D>::encode(
1880 (
1881 <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1882 <fidl_fuchsia_component_decl__common::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.component_decl),
1883 ),
1884 encoder, offset, _depth
1885 )
1886 }
1887 }
1888 unsafe impl<
1889 D: fidl::encoding::ResourceDialect,
1890 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
1891 T1: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Component, D>,
1892 > fidl::encoding::Encode<RealmReplaceComponentDeclRequest, D> for (T0, T1)
1893 {
1894 #[inline]
1895 unsafe fn encode(
1896 self,
1897 encoder: &mut fidl::encoding::Encoder<'_, D>,
1898 offset: usize,
1899 depth: fidl::encoding::Depth,
1900 ) -> fidl::Result<()> {
1901 encoder.debug_check_bounds::<RealmReplaceComponentDeclRequest>(offset);
1902 self.0.encode(encoder, offset + 0, depth)?;
1906 self.1.encode(encoder, offset + 16, depth)?;
1907 Ok(())
1908 }
1909 }
1910
1911 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1912 for RealmReplaceComponentDeclRequest
1913 {
1914 #[inline(always)]
1915 fn new_empty() -> Self {
1916 Self {
1917 name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D),
1918 component_decl: fidl::new_empty!(fidl_fuchsia_component_decl__common::Component, D),
1919 }
1920 }
1921
1922 #[inline]
1923 unsafe fn decode(
1924 &mut self,
1925 decoder: &mut fidl::encoding::Decoder<'_, D>,
1926 offset: usize,
1927 _depth: fidl::encoding::Depth,
1928 ) -> fidl::Result<()> {
1929 decoder.debug_check_bounds::<Self>(offset);
1930 fidl::decode!(
1932 fidl::encoding::BoundedString<1024>,
1933 D,
1934 &mut self.name,
1935 decoder,
1936 offset + 0,
1937 _depth
1938 )?;
1939 fidl::decode!(
1940 fidl_fuchsia_component_decl__common::Component,
1941 D,
1942 &mut self.component_decl,
1943 decoder,
1944 offset + 16,
1945 _depth
1946 )?;
1947 Ok(())
1948 }
1949 }
1950
1951 impl fidl::encoding::ValueTypeMarker for RealmReplaceRealmDeclRequest {
1952 type Borrowed<'a> = &'a Self;
1953 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1954 value
1955 }
1956 }
1957
1958 unsafe impl fidl::encoding::TypeMarker for RealmReplaceRealmDeclRequest {
1959 type Owned = Self;
1960
1961 #[inline(always)]
1962 fn inline_align(_context: fidl::encoding::Context) -> usize {
1963 8
1964 }
1965
1966 #[inline(always)]
1967 fn inline_size(_context: fidl::encoding::Context) -> usize {
1968 16
1969 }
1970 }
1971
1972 unsafe impl<D: fidl::encoding::ResourceDialect>
1973 fidl::encoding::Encode<RealmReplaceRealmDeclRequest, D> for &RealmReplaceRealmDeclRequest
1974 {
1975 #[inline]
1976 unsafe fn encode(
1977 self,
1978 encoder: &mut fidl::encoding::Encoder<'_, D>,
1979 offset: usize,
1980 _depth: fidl::encoding::Depth,
1981 ) -> fidl::Result<()> {
1982 encoder.debug_check_bounds::<RealmReplaceRealmDeclRequest>(offset);
1983 fidl::encoding::Encode::<RealmReplaceRealmDeclRequest, D>::encode(
1985 (
1986 <fidl_fuchsia_component_decl__common::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.component_decl),
1987 ),
1988 encoder, offset, _depth
1989 )
1990 }
1991 }
1992 unsafe impl<
1993 D: fidl::encoding::ResourceDialect,
1994 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Component, D>,
1995 > fidl::encoding::Encode<RealmReplaceRealmDeclRequest, D> for (T0,)
1996 {
1997 #[inline]
1998 unsafe fn encode(
1999 self,
2000 encoder: &mut fidl::encoding::Encoder<'_, D>,
2001 offset: usize,
2002 depth: fidl::encoding::Depth,
2003 ) -> fidl::Result<()> {
2004 encoder.debug_check_bounds::<RealmReplaceRealmDeclRequest>(offset);
2005 self.0.encode(encoder, offset + 0, depth)?;
2009 Ok(())
2010 }
2011 }
2012
2013 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2014 for RealmReplaceRealmDeclRequest
2015 {
2016 #[inline(always)]
2017 fn new_empty() -> Self {
2018 Self {
2019 component_decl: fidl::new_empty!(fidl_fuchsia_component_decl__common::Component, D),
2020 }
2021 }
2022
2023 #[inline]
2024 unsafe fn decode(
2025 &mut self,
2026 decoder: &mut fidl::encoding::Decoder<'_, D>,
2027 offset: usize,
2028 _depth: fidl::encoding::Depth,
2029 ) -> fidl::Result<()> {
2030 decoder.debug_check_bounds::<Self>(offset);
2031 fidl::decode!(
2033 fidl_fuchsia_component_decl__common::Component,
2034 D,
2035 &mut self.component_decl,
2036 decoder,
2037 offset + 0,
2038 _depth
2039 )?;
2040 Ok(())
2041 }
2042 }
2043
2044 impl fidl::encoding::ValueTypeMarker for RealmSetConfigValueRequest {
2045 type Borrowed<'a> = &'a Self;
2046 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2047 value
2048 }
2049 }
2050
2051 unsafe impl fidl::encoding::TypeMarker for RealmSetConfigValueRequest {
2052 type Owned = Self;
2053
2054 #[inline(always)]
2055 fn inline_align(_context: fidl::encoding::Context) -> usize {
2056 8
2057 }
2058
2059 #[inline(always)]
2060 fn inline_size(_context: fidl::encoding::Context) -> usize {
2061 48
2062 }
2063 }
2064
2065 unsafe impl<D: fidl::encoding::ResourceDialect>
2066 fidl::encoding::Encode<RealmSetConfigValueRequest, D> for &RealmSetConfigValueRequest
2067 {
2068 #[inline]
2069 unsafe fn encode(
2070 self,
2071 encoder: &mut fidl::encoding::Encoder<'_, D>,
2072 offset: usize,
2073 _depth: fidl::encoding::Depth,
2074 ) -> fidl::Result<()> {
2075 encoder.debug_check_bounds::<RealmSetConfigValueRequest>(offset);
2076 fidl::encoding::Encode::<RealmSetConfigValueRequest, D>::encode(
2078 (
2079 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
2080 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
2081 <fidl_fuchsia_component_decl__common::ConfigValueSpec as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
2082 ),
2083 encoder, offset, _depth
2084 )
2085 }
2086 }
2087 unsafe impl<
2088 D: fidl::encoding::ResourceDialect,
2089 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
2090 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
2091 T2: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::ConfigValueSpec, D>,
2092 > fidl::encoding::Encode<RealmSetConfigValueRequest, D> for (T0, T1, T2)
2093 {
2094 #[inline]
2095 unsafe fn encode(
2096 self,
2097 encoder: &mut fidl::encoding::Encoder<'_, D>,
2098 offset: usize,
2099 depth: fidl::encoding::Depth,
2100 ) -> fidl::Result<()> {
2101 encoder.debug_check_bounds::<RealmSetConfigValueRequest>(offset);
2102 self.0.encode(encoder, offset + 0, depth)?;
2106 self.1.encode(encoder, offset + 16, depth)?;
2107 self.2.encode(encoder, offset + 32, depth)?;
2108 Ok(())
2109 }
2110 }
2111
2112 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2113 for RealmSetConfigValueRequest
2114 {
2115 #[inline(always)]
2116 fn new_empty() -> Self {
2117 Self {
2118 name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
2119 key: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
2120 value: fidl::new_empty!(fidl_fuchsia_component_decl__common::ConfigValueSpec, D),
2121 }
2122 }
2123
2124 #[inline]
2125 unsafe fn decode(
2126 &mut self,
2127 decoder: &mut fidl::encoding::Decoder<'_, D>,
2128 offset: usize,
2129 _depth: fidl::encoding::Depth,
2130 ) -> fidl::Result<()> {
2131 decoder.debug_check_bounds::<Self>(offset);
2132 fidl::decode!(
2134 fidl::encoding::BoundedString<255>,
2135 D,
2136 &mut self.name,
2137 decoder,
2138 offset + 0,
2139 _depth
2140 )?;
2141 fidl::decode!(
2142 fidl::encoding::BoundedString<64>,
2143 D,
2144 &mut self.key,
2145 decoder,
2146 offset + 16,
2147 _depth
2148 )?;
2149 fidl::decode!(
2150 fidl_fuchsia_component_decl__common::ConfigValueSpec,
2151 D,
2152 &mut self.value,
2153 decoder,
2154 offset + 32,
2155 _depth
2156 )?;
2157 Ok(())
2158 }
2159 }
2160
2161 impl fidl::encoding::ValueTypeMarker for RealmUseNestedComponentManagerRequest {
2162 type Borrowed<'a> = &'a Self;
2163 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2164 value
2165 }
2166 }
2167
2168 unsafe impl fidl::encoding::TypeMarker for RealmUseNestedComponentManagerRequest {
2169 type Owned = Self;
2170
2171 #[inline(always)]
2172 fn inline_align(_context: fidl::encoding::Context) -> usize {
2173 8
2174 }
2175
2176 #[inline(always)]
2177 fn inline_size(_context: fidl::encoding::Context) -> usize {
2178 16
2179 }
2180 }
2181
2182 unsafe impl<D: fidl::encoding::ResourceDialect>
2183 fidl::encoding::Encode<RealmUseNestedComponentManagerRequest, D>
2184 for &RealmUseNestedComponentManagerRequest
2185 {
2186 #[inline]
2187 unsafe fn encode(
2188 self,
2189 encoder: &mut fidl::encoding::Encoder<'_, D>,
2190 offset: usize,
2191 _depth: fidl::encoding::Depth,
2192 ) -> fidl::Result<()> {
2193 encoder.debug_check_bounds::<RealmUseNestedComponentManagerRequest>(offset);
2194 fidl::encoding::Encode::<RealmUseNestedComponentManagerRequest, D>::encode(
2196 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
2197 &self.component_manager_relative_url,
2198 ),),
2199 encoder,
2200 offset,
2201 _depth,
2202 )
2203 }
2204 }
2205 unsafe impl<
2206 D: fidl::encoding::ResourceDialect,
2207 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
2208 > fidl::encoding::Encode<RealmUseNestedComponentManagerRequest, D> for (T0,)
2209 {
2210 #[inline]
2211 unsafe fn encode(
2212 self,
2213 encoder: &mut fidl::encoding::Encoder<'_, D>,
2214 offset: usize,
2215 depth: fidl::encoding::Depth,
2216 ) -> fidl::Result<()> {
2217 encoder.debug_check_bounds::<RealmUseNestedComponentManagerRequest>(offset);
2218 self.0.encode(encoder, offset + 0, depth)?;
2222 Ok(())
2223 }
2224 }
2225
2226 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2227 for RealmUseNestedComponentManagerRequest
2228 {
2229 #[inline(always)]
2230 fn new_empty() -> Self {
2231 Self {
2232 component_manager_relative_url: fidl::new_empty!(
2233 fidl::encoding::BoundedString<4096>,
2234 D
2235 ),
2236 }
2237 }
2238
2239 #[inline]
2240 unsafe fn decode(
2241 &mut self,
2242 decoder: &mut fidl::encoding::Decoder<'_, D>,
2243 offset: usize,
2244 _depth: fidl::encoding::Depth,
2245 ) -> fidl::Result<()> {
2246 decoder.debug_check_bounds::<Self>(offset);
2247 fidl::decode!(
2249 fidl::encoding::BoundedString<4096>,
2250 D,
2251 &mut self.component_manager_relative_url,
2252 decoder,
2253 offset + 0,
2254 _depth
2255 )?;
2256 Ok(())
2257 }
2258 }
2259
2260 impl fidl::encoding::ValueTypeMarker for RealmGetComponentDeclResponse {
2261 type Borrowed<'a> = &'a Self;
2262 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2263 value
2264 }
2265 }
2266
2267 unsafe impl fidl::encoding::TypeMarker for RealmGetComponentDeclResponse {
2268 type Owned = Self;
2269
2270 #[inline(always)]
2271 fn inline_align(_context: fidl::encoding::Context) -> usize {
2272 8
2273 }
2274
2275 #[inline(always)]
2276 fn inline_size(_context: fidl::encoding::Context) -> usize {
2277 16
2278 }
2279 }
2280
2281 unsafe impl<D: fidl::encoding::ResourceDialect>
2282 fidl::encoding::Encode<RealmGetComponentDeclResponse, D>
2283 for &RealmGetComponentDeclResponse
2284 {
2285 #[inline]
2286 unsafe fn encode(
2287 self,
2288 encoder: &mut fidl::encoding::Encoder<'_, D>,
2289 offset: usize,
2290 _depth: fidl::encoding::Depth,
2291 ) -> fidl::Result<()> {
2292 encoder.debug_check_bounds::<RealmGetComponentDeclResponse>(offset);
2293 fidl::encoding::Encode::<RealmGetComponentDeclResponse, D>::encode(
2295 (
2296 <fidl_fuchsia_component_decl__common::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.component_decl),
2297 ),
2298 encoder, offset, _depth
2299 )
2300 }
2301 }
2302 unsafe impl<
2303 D: fidl::encoding::ResourceDialect,
2304 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Component, D>,
2305 > fidl::encoding::Encode<RealmGetComponentDeclResponse, D> for (T0,)
2306 {
2307 #[inline]
2308 unsafe fn encode(
2309 self,
2310 encoder: &mut fidl::encoding::Encoder<'_, D>,
2311 offset: usize,
2312 depth: fidl::encoding::Depth,
2313 ) -> fidl::Result<()> {
2314 encoder.debug_check_bounds::<RealmGetComponentDeclResponse>(offset);
2315 self.0.encode(encoder, offset + 0, depth)?;
2319 Ok(())
2320 }
2321 }
2322
2323 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2324 for RealmGetComponentDeclResponse
2325 {
2326 #[inline(always)]
2327 fn new_empty() -> Self {
2328 Self {
2329 component_decl: fidl::new_empty!(fidl_fuchsia_component_decl__common::Component, D),
2330 }
2331 }
2332
2333 #[inline]
2334 unsafe fn decode(
2335 &mut self,
2336 decoder: &mut fidl::encoding::Decoder<'_, D>,
2337 offset: usize,
2338 _depth: fidl::encoding::Depth,
2339 ) -> fidl::Result<()> {
2340 decoder.debug_check_bounds::<Self>(offset);
2341 fidl::decode!(
2343 fidl_fuchsia_component_decl__common::Component,
2344 D,
2345 &mut self.component_decl,
2346 decoder,
2347 offset + 0,
2348 _depth
2349 )?;
2350 Ok(())
2351 }
2352 }
2353
2354 impl fidl::encoding::ValueTypeMarker for RealmGetRealmDeclResponse {
2355 type Borrowed<'a> = &'a Self;
2356 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2357 value
2358 }
2359 }
2360
2361 unsafe impl fidl::encoding::TypeMarker for RealmGetRealmDeclResponse {
2362 type Owned = Self;
2363
2364 #[inline(always)]
2365 fn inline_align(_context: fidl::encoding::Context) -> usize {
2366 8
2367 }
2368
2369 #[inline(always)]
2370 fn inline_size(_context: fidl::encoding::Context) -> usize {
2371 16
2372 }
2373 }
2374
2375 unsafe impl<D: fidl::encoding::ResourceDialect>
2376 fidl::encoding::Encode<RealmGetRealmDeclResponse, D> for &RealmGetRealmDeclResponse
2377 {
2378 #[inline]
2379 unsafe fn encode(
2380 self,
2381 encoder: &mut fidl::encoding::Encoder<'_, D>,
2382 offset: usize,
2383 _depth: fidl::encoding::Depth,
2384 ) -> fidl::Result<()> {
2385 encoder.debug_check_bounds::<RealmGetRealmDeclResponse>(offset);
2386 fidl::encoding::Encode::<RealmGetRealmDeclResponse, D>::encode(
2388 (
2389 <fidl_fuchsia_component_decl__common::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.component_decl),
2390 ),
2391 encoder, offset, _depth
2392 )
2393 }
2394 }
2395 unsafe impl<
2396 D: fidl::encoding::ResourceDialect,
2397 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::Component, D>,
2398 > fidl::encoding::Encode<RealmGetRealmDeclResponse, D> for (T0,)
2399 {
2400 #[inline]
2401 unsafe fn encode(
2402 self,
2403 encoder: &mut fidl::encoding::Encoder<'_, D>,
2404 offset: usize,
2405 depth: fidl::encoding::Depth,
2406 ) -> fidl::Result<()> {
2407 encoder.debug_check_bounds::<RealmGetRealmDeclResponse>(offset);
2408 self.0.encode(encoder, offset + 0, depth)?;
2412 Ok(())
2413 }
2414 }
2415
2416 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2417 for RealmGetRealmDeclResponse
2418 {
2419 #[inline(always)]
2420 fn new_empty() -> Self {
2421 Self {
2422 component_decl: fidl::new_empty!(fidl_fuchsia_component_decl__common::Component, D),
2423 }
2424 }
2425
2426 #[inline]
2427 unsafe fn decode(
2428 &mut self,
2429 decoder: &mut fidl::encoding::Decoder<'_, D>,
2430 offset: usize,
2431 _depth: fidl::encoding::Depth,
2432 ) -> fidl::Result<()> {
2433 decoder.debug_check_bounds::<Self>(offset);
2434 fidl::decode!(
2436 fidl_fuchsia_component_decl__common::Component,
2437 D,
2438 &mut self.component_decl,
2439 decoder,
2440 offset + 0,
2441 _depth
2442 )?;
2443 Ok(())
2444 }
2445 }
2446
2447 impl ChildOptions {
2448 #[inline(always)]
2449 fn max_ordinal_present(&self) -> u64 {
2450 if let Some(_) = self.config_overrides {
2451 return 4;
2452 }
2453 if let Some(_) = self.on_terminate {
2454 return 3;
2455 }
2456 if let Some(_) = self.environment {
2457 return 2;
2458 }
2459 if let Some(_) = self.startup {
2460 return 1;
2461 }
2462 0
2463 }
2464 }
2465
2466 impl fidl::encoding::ValueTypeMarker for ChildOptions {
2467 type Borrowed<'a> = &'a Self;
2468 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2469 value
2470 }
2471 }
2472
2473 unsafe impl fidl::encoding::TypeMarker for ChildOptions {
2474 type Owned = Self;
2475
2476 #[inline(always)]
2477 fn inline_align(_context: fidl::encoding::Context) -> usize {
2478 8
2479 }
2480
2481 #[inline(always)]
2482 fn inline_size(_context: fidl::encoding::Context) -> usize {
2483 16
2484 }
2485 }
2486
2487 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChildOptions, D>
2488 for &ChildOptions
2489 {
2490 unsafe fn encode(
2491 self,
2492 encoder: &mut fidl::encoding::Encoder<'_, D>,
2493 offset: usize,
2494 mut depth: fidl::encoding::Depth,
2495 ) -> fidl::Result<()> {
2496 encoder.debug_check_bounds::<ChildOptions>(offset);
2497 let max_ordinal: u64 = self.max_ordinal_present();
2499 encoder.write_num(max_ordinal, offset);
2500 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2501 if max_ordinal == 0 {
2503 return Ok(());
2504 }
2505 depth.increment()?;
2506 let envelope_size = 8;
2507 let bytes_len = max_ordinal as usize * envelope_size;
2508 #[allow(unused_variables)]
2509 let offset = encoder.out_of_line_offset(bytes_len);
2510 let mut _prev_end_offset: usize = 0;
2511 if 1 > max_ordinal {
2512 return Ok(());
2513 }
2514
2515 let cur_offset: usize = (1 - 1) * envelope_size;
2518
2519 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2521
2522 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::StartupMode, D>(
2527 self.startup.as_ref().map(<fidl_fuchsia_component_decl__common::StartupMode as fidl::encoding::ValueTypeMarker>::borrow),
2528 encoder, offset + cur_offset, depth
2529 )?;
2530
2531 _prev_end_offset = cur_offset + envelope_size;
2532 if 2 > max_ordinal {
2533 return Ok(());
2534 }
2535
2536 let cur_offset: usize = (2 - 1) * envelope_size;
2539
2540 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2542
2543 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
2548 self.environment.as_ref().map(
2549 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
2550 ),
2551 encoder,
2552 offset + cur_offset,
2553 depth,
2554 )?;
2555
2556 _prev_end_offset = cur_offset + envelope_size;
2557 if 3 > max_ordinal {
2558 return Ok(());
2559 }
2560
2561 let cur_offset: usize = (3 - 1) * envelope_size;
2564
2565 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2567
2568 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::OnTerminate, D>(
2573 self.on_terminate.as_ref().map(<fidl_fuchsia_component_decl__common::OnTerminate as fidl::encoding::ValueTypeMarker>::borrow),
2574 encoder, offset + cur_offset, depth
2575 )?;
2576
2577 _prev_end_offset = cur_offset + envelope_size;
2578 if 4 > max_ordinal {
2579 return Ok(());
2580 }
2581
2582 let cur_offset: usize = (4 - 1) * envelope_size;
2585
2586 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2588
2589 fidl::encoding::encode_in_envelope_optional::<
2594 fidl::encoding::UnboundedVector<
2595 fidl_fuchsia_component_decl__common::ConfigOverride,
2596 >,
2597 D,
2598 >(
2599 self.config_overrides.as_ref().map(
2600 <fidl::encoding::UnboundedVector<
2601 fidl_fuchsia_component_decl__common::ConfigOverride,
2602 > as fidl::encoding::ValueTypeMarker>::borrow,
2603 ),
2604 encoder,
2605 offset + cur_offset,
2606 depth,
2607 )?;
2608
2609 _prev_end_offset = cur_offset + envelope_size;
2610
2611 Ok(())
2612 }
2613 }
2614
2615 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildOptions {
2616 #[inline(always)]
2617 fn new_empty() -> Self {
2618 Self::default()
2619 }
2620
2621 unsafe fn decode(
2622 &mut self,
2623 decoder: &mut fidl::encoding::Decoder<'_, D>,
2624 offset: usize,
2625 mut depth: fidl::encoding::Depth,
2626 ) -> fidl::Result<()> {
2627 decoder.debug_check_bounds::<Self>(offset);
2628 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2629 None => return Err(fidl::Error::NotNullable),
2630 Some(len) => len,
2631 };
2632 if len == 0 {
2634 return Ok(());
2635 };
2636 depth.increment()?;
2637 let envelope_size = 8;
2638 let bytes_len = len * envelope_size;
2639 let offset = decoder.out_of_line_offset(bytes_len)?;
2640 let mut _next_ordinal_to_read = 0;
2642 let mut next_offset = offset;
2643 let end_offset = offset + bytes_len;
2644 _next_ordinal_to_read += 1;
2645 if next_offset >= end_offset {
2646 return Ok(());
2647 }
2648
2649 while _next_ordinal_to_read < 1 {
2651 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2652 _next_ordinal_to_read += 1;
2653 next_offset += envelope_size;
2654 }
2655
2656 let next_out_of_line = decoder.next_out_of_line();
2657 let handles_before = decoder.remaining_handles();
2658 if let Some((inlined, num_bytes, num_handles)) =
2659 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2660 {
2661 let member_inline_size = <fidl_fuchsia_component_decl__common::StartupMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2662 if inlined != (member_inline_size <= 4) {
2663 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2664 }
2665 let inner_offset;
2666 let mut inner_depth = depth.clone();
2667 if inlined {
2668 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2669 inner_offset = next_offset;
2670 } else {
2671 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2672 inner_depth.increment()?;
2673 }
2674 let val_ref = self.startup.get_or_insert_with(|| {
2675 fidl::new_empty!(fidl_fuchsia_component_decl__common::StartupMode, D)
2676 });
2677 fidl::decode!(
2678 fidl_fuchsia_component_decl__common::StartupMode,
2679 D,
2680 val_ref,
2681 decoder,
2682 inner_offset,
2683 inner_depth
2684 )?;
2685 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2686 {
2687 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2688 }
2689 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2690 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2691 }
2692 }
2693
2694 next_offset += envelope_size;
2695 _next_ordinal_to_read += 1;
2696 if next_offset >= end_offset {
2697 return Ok(());
2698 }
2699
2700 while _next_ordinal_to_read < 2 {
2702 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2703 _next_ordinal_to_read += 1;
2704 next_offset += envelope_size;
2705 }
2706
2707 let next_out_of_line = decoder.next_out_of_line();
2708 let handles_before = decoder.remaining_handles();
2709 if let Some((inlined, num_bytes, num_handles)) =
2710 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2711 {
2712 let member_inline_size =
2713 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2714 decoder.context,
2715 );
2716 if inlined != (member_inline_size <= 4) {
2717 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2718 }
2719 let inner_offset;
2720 let mut inner_depth = depth.clone();
2721 if inlined {
2722 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2723 inner_offset = next_offset;
2724 } else {
2725 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2726 inner_depth.increment()?;
2727 }
2728 let val_ref = self
2729 .environment
2730 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2731 fidl::decode!(
2732 fidl::encoding::BoundedString<255>,
2733 D,
2734 val_ref,
2735 decoder,
2736 inner_offset,
2737 inner_depth
2738 )?;
2739 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2740 {
2741 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2742 }
2743 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2744 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2745 }
2746 }
2747
2748 next_offset += envelope_size;
2749 _next_ordinal_to_read += 1;
2750 if next_offset >= end_offset {
2751 return Ok(());
2752 }
2753
2754 while _next_ordinal_to_read < 3 {
2756 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2757 _next_ordinal_to_read += 1;
2758 next_offset += envelope_size;
2759 }
2760
2761 let next_out_of_line = decoder.next_out_of_line();
2762 let handles_before = decoder.remaining_handles();
2763 if let Some((inlined, num_bytes, num_handles)) =
2764 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2765 {
2766 let member_inline_size = <fidl_fuchsia_component_decl__common::OnTerminate as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2767 if inlined != (member_inline_size <= 4) {
2768 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2769 }
2770 let inner_offset;
2771 let mut inner_depth = depth.clone();
2772 if inlined {
2773 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2774 inner_offset = next_offset;
2775 } else {
2776 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2777 inner_depth.increment()?;
2778 }
2779 let val_ref = self.on_terminate.get_or_insert_with(|| {
2780 fidl::new_empty!(fidl_fuchsia_component_decl__common::OnTerminate, D)
2781 });
2782 fidl::decode!(
2783 fidl_fuchsia_component_decl__common::OnTerminate,
2784 D,
2785 val_ref,
2786 decoder,
2787 inner_offset,
2788 inner_depth
2789 )?;
2790 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2791 {
2792 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2793 }
2794 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2795 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2796 }
2797 }
2798
2799 next_offset += envelope_size;
2800 _next_ordinal_to_read += 1;
2801 if next_offset >= end_offset {
2802 return Ok(());
2803 }
2804
2805 while _next_ordinal_to_read < 4 {
2807 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2808 _next_ordinal_to_read += 1;
2809 next_offset += envelope_size;
2810 }
2811
2812 let next_out_of_line = decoder.next_out_of_line();
2813 let handles_before = decoder.remaining_handles();
2814 if let Some((inlined, num_bytes, num_handles)) =
2815 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2816 {
2817 let member_inline_size = <fidl::encoding::UnboundedVector<
2818 fidl_fuchsia_component_decl__common::ConfigOverride,
2819 > as fidl::encoding::TypeMarker>::inline_size(
2820 decoder.context
2821 );
2822 if inlined != (member_inline_size <= 4) {
2823 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2824 }
2825 let inner_offset;
2826 let mut inner_depth = depth.clone();
2827 if inlined {
2828 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2829 inner_offset = next_offset;
2830 } else {
2831 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2832 inner_depth.increment()?;
2833 }
2834 let val_ref = self.config_overrides.get_or_insert_with(|| {
2835 fidl::new_empty!(
2836 fidl::encoding::UnboundedVector<
2837 fidl_fuchsia_component_decl__common::ConfigOverride,
2838 >,
2839 D
2840 )
2841 });
2842 fidl::decode!(
2843 fidl::encoding::UnboundedVector<
2844 fidl_fuchsia_component_decl__common::ConfigOverride,
2845 >,
2846 D,
2847 val_ref,
2848 decoder,
2849 inner_offset,
2850 inner_depth
2851 )?;
2852 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2853 {
2854 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2855 }
2856 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2857 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2858 }
2859 }
2860
2861 next_offset += envelope_size;
2862
2863 while next_offset < end_offset {
2865 _next_ordinal_to_read += 1;
2866 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2867 next_offset += envelope_size;
2868 }
2869
2870 Ok(())
2871 }
2872 }
2873
2874 impl Config {
2875 #[inline(always)]
2876 fn max_ordinal_present(&self) -> u64 {
2877 if let Some(_) = self.availability {
2878 return 3;
2879 }
2880 if let Some(_) = self.as_ {
2881 return 2;
2882 }
2883 if let Some(_) = self.name {
2884 return 1;
2885 }
2886 0
2887 }
2888 }
2889
2890 impl fidl::encoding::ValueTypeMarker for Config {
2891 type Borrowed<'a> = &'a Self;
2892 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2893 value
2894 }
2895 }
2896
2897 unsafe impl fidl::encoding::TypeMarker for Config {
2898 type Owned = Self;
2899
2900 #[inline(always)]
2901 fn inline_align(_context: fidl::encoding::Context) -> usize {
2902 8
2903 }
2904
2905 #[inline(always)]
2906 fn inline_size(_context: fidl::encoding::Context) -> usize {
2907 16
2908 }
2909 }
2910
2911 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Config, D> for &Config {
2912 unsafe fn encode(
2913 self,
2914 encoder: &mut fidl::encoding::Encoder<'_, D>,
2915 offset: usize,
2916 mut depth: fidl::encoding::Depth,
2917 ) -> fidl::Result<()> {
2918 encoder.debug_check_bounds::<Config>(offset);
2919 let max_ordinal: u64 = self.max_ordinal_present();
2921 encoder.write_num(max_ordinal, offset);
2922 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2923 if max_ordinal == 0 {
2925 return Ok(());
2926 }
2927 depth.increment()?;
2928 let envelope_size = 8;
2929 let bytes_len = max_ordinal as usize * envelope_size;
2930 #[allow(unused_variables)]
2931 let offset = encoder.out_of_line_offset(bytes_len);
2932 let mut _prev_end_offset: usize = 0;
2933 if 1 > max_ordinal {
2934 return Ok(());
2935 }
2936
2937 let cur_offset: usize = (1 - 1) * envelope_size;
2940
2941 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2943
2944 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
2949 self.name.as_ref().map(
2950 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
2951 ),
2952 encoder,
2953 offset + cur_offset,
2954 depth,
2955 )?;
2956
2957 _prev_end_offset = cur_offset + envelope_size;
2958 if 2 > max_ordinal {
2959 return Ok(());
2960 }
2961
2962 let cur_offset: usize = (2 - 1) * envelope_size;
2965
2966 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2968
2969 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
2974 self.as_.as_ref().map(
2975 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
2976 ),
2977 encoder,
2978 offset + cur_offset,
2979 depth,
2980 )?;
2981
2982 _prev_end_offset = cur_offset + envelope_size;
2983 if 3 > max_ordinal {
2984 return Ok(());
2985 }
2986
2987 let cur_offset: usize = (3 - 1) * envelope_size;
2990
2991 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2993
2994 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
2999 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
3000 encoder, offset + cur_offset, depth
3001 )?;
3002
3003 _prev_end_offset = cur_offset + envelope_size;
3004
3005 Ok(())
3006 }
3007 }
3008
3009 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Config {
3010 #[inline(always)]
3011 fn new_empty() -> Self {
3012 Self::default()
3013 }
3014
3015 unsafe fn decode(
3016 &mut self,
3017 decoder: &mut fidl::encoding::Decoder<'_, D>,
3018 offset: usize,
3019 mut depth: fidl::encoding::Depth,
3020 ) -> fidl::Result<()> {
3021 decoder.debug_check_bounds::<Self>(offset);
3022 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3023 None => return Err(fidl::Error::NotNullable),
3024 Some(len) => len,
3025 };
3026 if len == 0 {
3028 return Ok(());
3029 };
3030 depth.increment()?;
3031 let envelope_size = 8;
3032 let bytes_len = len * envelope_size;
3033 let offset = decoder.out_of_line_offset(bytes_len)?;
3034 let mut _next_ordinal_to_read = 0;
3036 let mut next_offset = offset;
3037 let end_offset = offset + bytes_len;
3038 _next_ordinal_to_read += 1;
3039 if next_offset >= end_offset {
3040 return Ok(());
3041 }
3042
3043 while _next_ordinal_to_read < 1 {
3045 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3046 _next_ordinal_to_read += 1;
3047 next_offset += envelope_size;
3048 }
3049
3050 let next_out_of_line = decoder.next_out_of_line();
3051 let handles_before = decoder.remaining_handles();
3052 if let Some((inlined, num_bytes, num_handles)) =
3053 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3054 {
3055 let member_inline_size =
3056 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3057 decoder.context,
3058 );
3059 if inlined != (member_inline_size <= 4) {
3060 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3061 }
3062 let inner_offset;
3063 let mut inner_depth = depth.clone();
3064 if inlined {
3065 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3066 inner_offset = next_offset;
3067 } else {
3068 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3069 inner_depth.increment()?;
3070 }
3071 let val_ref = self
3072 .name
3073 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3074 fidl::decode!(
3075 fidl::encoding::BoundedString<255>,
3076 D,
3077 val_ref,
3078 decoder,
3079 inner_offset,
3080 inner_depth
3081 )?;
3082 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3083 {
3084 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3085 }
3086 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3087 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3088 }
3089 }
3090
3091 next_offset += envelope_size;
3092 _next_ordinal_to_read += 1;
3093 if next_offset >= end_offset {
3094 return Ok(());
3095 }
3096
3097 while _next_ordinal_to_read < 2 {
3099 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3100 _next_ordinal_to_read += 1;
3101 next_offset += envelope_size;
3102 }
3103
3104 let next_out_of_line = decoder.next_out_of_line();
3105 let handles_before = decoder.remaining_handles();
3106 if let Some((inlined, num_bytes, num_handles)) =
3107 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3108 {
3109 let member_inline_size =
3110 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3111 decoder.context,
3112 );
3113 if inlined != (member_inline_size <= 4) {
3114 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3115 }
3116 let inner_offset;
3117 let mut inner_depth = depth.clone();
3118 if inlined {
3119 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3120 inner_offset = next_offset;
3121 } else {
3122 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3123 inner_depth.increment()?;
3124 }
3125 let val_ref = self
3126 .as_
3127 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3128 fidl::decode!(
3129 fidl::encoding::BoundedString<255>,
3130 D,
3131 val_ref,
3132 decoder,
3133 inner_offset,
3134 inner_depth
3135 )?;
3136 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3137 {
3138 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3139 }
3140 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3141 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3142 }
3143 }
3144
3145 next_offset += envelope_size;
3146 _next_ordinal_to_read += 1;
3147 if next_offset >= end_offset {
3148 return Ok(());
3149 }
3150
3151 while _next_ordinal_to_read < 3 {
3153 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3154 _next_ordinal_to_read += 1;
3155 next_offset += envelope_size;
3156 }
3157
3158 let next_out_of_line = decoder.next_out_of_line();
3159 let handles_before = decoder.remaining_handles();
3160 if let Some((inlined, num_bytes, num_handles)) =
3161 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3162 {
3163 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3164 if inlined != (member_inline_size <= 4) {
3165 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3166 }
3167 let inner_offset;
3168 let mut inner_depth = depth.clone();
3169 if inlined {
3170 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3171 inner_offset = next_offset;
3172 } else {
3173 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3174 inner_depth.increment()?;
3175 }
3176 let val_ref = self.availability.get_or_insert_with(|| {
3177 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
3178 });
3179 fidl::decode!(
3180 fidl_fuchsia_component_decl__common::Availability,
3181 D,
3182 val_ref,
3183 decoder,
3184 inner_offset,
3185 inner_depth
3186 )?;
3187 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3188 {
3189 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3190 }
3191 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3192 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3193 }
3194 }
3195
3196 next_offset += envelope_size;
3197
3198 while next_offset < end_offset {
3200 _next_ordinal_to_read += 1;
3201 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3202 next_offset += envelope_size;
3203 }
3204
3205 Ok(())
3206 }
3207 }
3208
3209 impl Dictionary {
3210 #[inline(always)]
3211 fn max_ordinal_present(&self) -> u64 {
3212 if let Some(_) = self.from_dictionary {
3213 return 5;
3214 }
3215 if let Some(_) = self.availability {
3216 return 4;
3217 }
3218 if let Some(_) = self.type_ {
3219 return 3;
3220 }
3221 if let Some(_) = self.as_ {
3222 return 2;
3223 }
3224 if let Some(_) = self.name {
3225 return 1;
3226 }
3227 0
3228 }
3229 }
3230
3231 impl fidl::encoding::ValueTypeMarker for Dictionary {
3232 type Borrowed<'a> = &'a Self;
3233 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3234 value
3235 }
3236 }
3237
3238 unsafe impl fidl::encoding::TypeMarker for Dictionary {
3239 type Owned = Self;
3240
3241 #[inline(always)]
3242 fn inline_align(_context: fidl::encoding::Context) -> usize {
3243 8
3244 }
3245
3246 #[inline(always)]
3247 fn inline_size(_context: fidl::encoding::Context) -> usize {
3248 16
3249 }
3250 }
3251
3252 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dictionary, D>
3253 for &Dictionary
3254 {
3255 unsafe fn encode(
3256 self,
3257 encoder: &mut fidl::encoding::Encoder<'_, D>,
3258 offset: usize,
3259 mut depth: fidl::encoding::Depth,
3260 ) -> fidl::Result<()> {
3261 encoder.debug_check_bounds::<Dictionary>(offset);
3262 let max_ordinal: u64 = self.max_ordinal_present();
3264 encoder.write_num(max_ordinal, offset);
3265 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3266 if max_ordinal == 0 {
3268 return Ok(());
3269 }
3270 depth.increment()?;
3271 let envelope_size = 8;
3272 let bytes_len = max_ordinal as usize * envelope_size;
3273 #[allow(unused_variables)]
3274 let offset = encoder.out_of_line_offset(bytes_len);
3275 let mut _prev_end_offset: usize = 0;
3276 if 1 > max_ordinal {
3277 return Ok(());
3278 }
3279
3280 let cur_offset: usize = (1 - 1) * envelope_size;
3283
3284 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3286
3287 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3292 self.name.as_ref().map(
3293 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3294 ),
3295 encoder,
3296 offset + cur_offset,
3297 depth,
3298 )?;
3299
3300 _prev_end_offset = cur_offset + envelope_size;
3301 if 2 > max_ordinal {
3302 return Ok(());
3303 }
3304
3305 let cur_offset: usize = (2 - 1) * envelope_size;
3308
3309 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3311
3312 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3317 self.as_.as_ref().map(
3318 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3319 ),
3320 encoder,
3321 offset + cur_offset,
3322 depth,
3323 )?;
3324
3325 _prev_end_offset = cur_offset + envelope_size;
3326 if 3 > max_ordinal {
3327 return Ok(());
3328 }
3329
3330 let cur_offset: usize = (3 - 1) * envelope_size;
3333
3334 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3336
3337 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::DependencyType, D>(
3342 self.type_.as_ref().map(<fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
3343 encoder, offset + cur_offset, depth
3344 )?;
3345
3346 _prev_end_offset = cur_offset + envelope_size;
3347 if 4 > max_ordinal {
3348 return Ok(());
3349 }
3350
3351 let cur_offset: usize = (4 - 1) * envelope_size;
3354
3355 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3357
3358 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
3363 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
3364 encoder, offset + cur_offset, depth
3365 )?;
3366
3367 _prev_end_offset = cur_offset + envelope_size;
3368 if 5 > max_ordinal {
3369 return Ok(());
3370 }
3371
3372 let cur_offset: usize = (5 - 1) * envelope_size;
3375
3376 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3378
3379 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3384 self.from_dictionary.as_ref().map(
3385 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3386 ),
3387 encoder,
3388 offset + cur_offset,
3389 depth,
3390 )?;
3391
3392 _prev_end_offset = cur_offset + envelope_size;
3393
3394 Ok(())
3395 }
3396 }
3397
3398 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dictionary {
3399 #[inline(always)]
3400 fn new_empty() -> Self {
3401 Self::default()
3402 }
3403
3404 unsafe fn decode(
3405 &mut self,
3406 decoder: &mut fidl::encoding::Decoder<'_, D>,
3407 offset: usize,
3408 mut depth: fidl::encoding::Depth,
3409 ) -> fidl::Result<()> {
3410 decoder.debug_check_bounds::<Self>(offset);
3411 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3412 None => return Err(fidl::Error::NotNullable),
3413 Some(len) => len,
3414 };
3415 if len == 0 {
3417 return Ok(());
3418 };
3419 depth.increment()?;
3420 let envelope_size = 8;
3421 let bytes_len = len * envelope_size;
3422 let offset = decoder.out_of_line_offset(bytes_len)?;
3423 let mut _next_ordinal_to_read = 0;
3425 let mut next_offset = offset;
3426 let end_offset = offset + bytes_len;
3427 _next_ordinal_to_read += 1;
3428 if next_offset >= end_offset {
3429 return Ok(());
3430 }
3431
3432 while _next_ordinal_to_read < 1 {
3434 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3435 _next_ordinal_to_read += 1;
3436 next_offset += envelope_size;
3437 }
3438
3439 let next_out_of_line = decoder.next_out_of_line();
3440 let handles_before = decoder.remaining_handles();
3441 if let Some((inlined, num_bytes, num_handles)) =
3442 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3443 {
3444 let member_inline_size =
3445 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3446 decoder.context,
3447 );
3448 if inlined != (member_inline_size <= 4) {
3449 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3450 }
3451 let inner_offset;
3452 let mut inner_depth = depth.clone();
3453 if inlined {
3454 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3455 inner_offset = next_offset;
3456 } else {
3457 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3458 inner_depth.increment()?;
3459 }
3460 let val_ref = self
3461 .name
3462 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3463 fidl::decode!(
3464 fidl::encoding::BoundedString<255>,
3465 D,
3466 val_ref,
3467 decoder,
3468 inner_offset,
3469 inner_depth
3470 )?;
3471 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3472 {
3473 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3474 }
3475 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3476 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3477 }
3478 }
3479
3480 next_offset += envelope_size;
3481 _next_ordinal_to_read += 1;
3482 if next_offset >= end_offset {
3483 return Ok(());
3484 }
3485
3486 while _next_ordinal_to_read < 2 {
3488 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3489 _next_ordinal_to_read += 1;
3490 next_offset += envelope_size;
3491 }
3492
3493 let next_out_of_line = decoder.next_out_of_line();
3494 let handles_before = decoder.remaining_handles();
3495 if let Some((inlined, num_bytes, num_handles)) =
3496 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3497 {
3498 let member_inline_size =
3499 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3500 decoder.context,
3501 );
3502 if inlined != (member_inline_size <= 4) {
3503 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3504 }
3505 let inner_offset;
3506 let mut inner_depth = depth.clone();
3507 if inlined {
3508 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3509 inner_offset = next_offset;
3510 } else {
3511 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3512 inner_depth.increment()?;
3513 }
3514 let val_ref = self
3515 .as_
3516 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3517 fidl::decode!(
3518 fidl::encoding::BoundedString<255>,
3519 D,
3520 val_ref,
3521 decoder,
3522 inner_offset,
3523 inner_depth
3524 )?;
3525 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3526 {
3527 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3528 }
3529 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3530 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3531 }
3532 }
3533
3534 next_offset += envelope_size;
3535 _next_ordinal_to_read += 1;
3536 if next_offset >= end_offset {
3537 return Ok(());
3538 }
3539
3540 while _next_ordinal_to_read < 3 {
3542 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3543 _next_ordinal_to_read += 1;
3544 next_offset += envelope_size;
3545 }
3546
3547 let next_out_of_line = decoder.next_out_of_line();
3548 let handles_before = decoder.remaining_handles();
3549 if let Some((inlined, num_bytes, num_handles)) =
3550 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3551 {
3552 let member_inline_size = <fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3553 if inlined != (member_inline_size <= 4) {
3554 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3555 }
3556 let inner_offset;
3557 let mut inner_depth = depth.clone();
3558 if inlined {
3559 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3560 inner_offset = next_offset;
3561 } else {
3562 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3563 inner_depth.increment()?;
3564 }
3565 let val_ref = self.type_.get_or_insert_with(|| {
3566 fidl::new_empty!(fidl_fuchsia_component_decl__common::DependencyType, D)
3567 });
3568 fidl::decode!(
3569 fidl_fuchsia_component_decl__common::DependencyType,
3570 D,
3571 val_ref,
3572 decoder,
3573 inner_offset,
3574 inner_depth
3575 )?;
3576 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3577 {
3578 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3579 }
3580 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3581 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3582 }
3583 }
3584
3585 next_offset += envelope_size;
3586 _next_ordinal_to_read += 1;
3587 if next_offset >= end_offset {
3588 return Ok(());
3589 }
3590
3591 while _next_ordinal_to_read < 4 {
3593 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3594 _next_ordinal_to_read += 1;
3595 next_offset += envelope_size;
3596 }
3597
3598 let next_out_of_line = decoder.next_out_of_line();
3599 let handles_before = decoder.remaining_handles();
3600 if let Some((inlined, num_bytes, num_handles)) =
3601 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3602 {
3603 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3604 if inlined != (member_inline_size <= 4) {
3605 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3606 }
3607 let inner_offset;
3608 let mut inner_depth = depth.clone();
3609 if inlined {
3610 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3611 inner_offset = next_offset;
3612 } else {
3613 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3614 inner_depth.increment()?;
3615 }
3616 let val_ref = self.availability.get_or_insert_with(|| {
3617 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
3618 });
3619 fidl::decode!(
3620 fidl_fuchsia_component_decl__common::Availability,
3621 D,
3622 val_ref,
3623 decoder,
3624 inner_offset,
3625 inner_depth
3626 )?;
3627 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3628 {
3629 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3630 }
3631 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3632 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3633 }
3634 }
3635
3636 next_offset += envelope_size;
3637 _next_ordinal_to_read += 1;
3638 if next_offset >= end_offset {
3639 return Ok(());
3640 }
3641
3642 while _next_ordinal_to_read < 5 {
3644 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3645 _next_ordinal_to_read += 1;
3646 next_offset += envelope_size;
3647 }
3648
3649 let next_out_of_line = decoder.next_out_of_line();
3650 let handles_before = decoder.remaining_handles();
3651 if let Some((inlined, num_bytes, num_handles)) =
3652 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3653 {
3654 let member_inline_size =
3655 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
3656 decoder.context,
3657 );
3658 if inlined != (member_inline_size <= 4) {
3659 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3660 }
3661 let inner_offset;
3662 let mut inner_depth = depth.clone();
3663 if inlined {
3664 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3665 inner_offset = next_offset;
3666 } else {
3667 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3668 inner_depth.increment()?;
3669 }
3670 let val_ref = self
3671 .from_dictionary
3672 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
3673 fidl::decode!(
3674 fidl::encoding::UnboundedString,
3675 D,
3676 val_ref,
3677 decoder,
3678 inner_offset,
3679 inner_depth
3680 )?;
3681 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3682 {
3683 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3684 }
3685 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3686 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3687 }
3688 }
3689
3690 next_offset += envelope_size;
3691
3692 while next_offset < end_offset {
3694 _next_ordinal_to_read += 1;
3695 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3696 next_offset += envelope_size;
3697 }
3698
3699 Ok(())
3700 }
3701 }
3702
3703 impl Directory {
3704 #[inline(always)]
3705 fn max_ordinal_present(&self) -> u64 {
3706 if let Some(_) = self.from_dictionary {
3707 return 8;
3708 }
3709 if let Some(_) = self.availability {
3710 return 7;
3711 }
3712 if let Some(_) = self.path {
3713 return 6;
3714 }
3715 if let Some(_) = self.rights {
3716 return 5;
3717 }
3718 if let Some(_) = self.subdir {
3719 return 4;
3720 }
3721 if let Some(_) = self.type_ {
3722 return 3;
3723 }
3724 if let Some(_) = self.as_ {
3725 return 2;
3726 }
3727 if let Some(_) = self.name {
3728 return 1;
3729 }
3730 0
3731 }
3732 }
3733
3734 impl fidl::encoding::ValueTypeMarker for Directory {
3735 type Borrowed<'a> = &'a Self;
3736 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3737 value
3738 }
3739 }
3740
3741 unsafe impl fidl::encoding::TypeMarker for Directory {
3742 type Owned = Self;
3743
3744 #[inline(always)]
3745 fn inline_align(_context: fidl::encoding::Context) -> usize {
3746 8
3747 }
3748
3749 #[inline(always)]
3750 fn inline_size(_context: fidl::encoding::Context) -> usize {
3751 16
3752 }
3753 }
3754
3755 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Directory, D>
3756 for &Directory
3757 {
3758 unsafe fn encode(
3759 self,
3760 encoder: &mut fidl::encoding::Encoder<'_, D>,
3761 offset: usize,
3762 mut depth: fidl::encoding::Depth,
3763 ) -> fidl::Result<()> {
3764 encoder.debug_check_bounds::<Directory>(offset);
3765 let max_ordinal: u64 = self.max_ordinal_present();
3767 encoder.write_num(max_ordinal, offset);
3768 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3769 if max_ordinal == 0 {
3771 return Ok(());
3772 }
3773 depth.increment()?;
3774 let envelope_size = 8;
3775 let bytes_len = max_ordinal as usize * envelope_size;
3776 #[allow(unused_variables)]
3777 let offset = encoder.out_of_line_offset(bytes_len);
3778 let mut _prev_end_offset: usize = 0;
3779 if 1 > max_ordinal {
3780 return Ok(());
3781 }
3782
3783 let cur_offset: usize = (1 - 1) * envelope_size;
3786
3787 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3789
3790 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3795 self.name.as_ref().map(
3796 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3797 ),
3798 encoder,
3799 offset + cur_offset,
3800 depth,
3801 )?;
3802
3803 _prev_end_offset = cur_offset + envelope_size;
3804 if 2 > max_ordinal {
3805 return Ok(());
3806 }
3807
3808 let cur_offset: usize = (2 - 1) * envelope_size;
3811
3812 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3814
3815 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3820 self.as_.as_ref().map(
3821 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3822 ),
3823 encoder,
3824 offset + cur_offset,
3825 depth,
3826 )?;
3827
3828 _prev_end_offset = cur_offset + envelope_size;
3829 if 3 > max_ordinal {
3830 return Ok(());
3831 }
3832
3833 let cur_offset: usize = (3 - 1) * envelope_size;
3836
3837 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3839
3840 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::DependencyType, D>(
3845 self.type_.as_ref().map(<fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
3846 encoder, offset + cur_offset, depth
3847 )?;
3848
3849 _prev_end_offset = cur_offset + envelope_size;
3850 if 4 > max_ordinal {
3851 return Ok(());
3852 }
3853
3854 let cur_offset: usize = (4 - 1) * envelope_size;
3857
3858 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3860
3861 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
3866 self.subdir.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
3867 encoder, offset + cur_offset, depth
3868 )?;
3869
3870 _prev_end_offset = cur_offset + envelope_size;
3871 if 5 > max_ordinal {
3872 return Ok(());
3873 }
3874
3875 let cur_offset: usize = (5 - 1) * envelope_size;
3878
3879 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3881
3882 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_io__common::Operations, D>(
3887 self.rights.as_ref().map(<fidl_fuchsia_io__common::Operations as fidl::encoding::ValueTypeMarker>::borrow),
3888 encoder, offset + cur_offset, depth
3889 )?;
3890
3891 _prev_end_offset = cur_offset + envelope_size;
3892 if 6 > max_ordinal {
3893 return Ok(());
3894 }
3895
3896 let cur_offset: usize = (6 - 1) * envelope_size;
3899
3900 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3902
3903 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
3908 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
3909 encoder, offset + cur_offset, depth
3910 )?;
3911
3912 _prev_end_offset = cur_offset + envelope_size;
3913 if 7 > max_ordinal {
3914 return Ok(());
3915 }
3916
3917 let cur_offset: usize = (7 - 1) * envelope_size;
3920
3921 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3923
3924 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
3929 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
3930 encoder, offset + cur_offset, depth
3931 )?;
3932
3933 _prev_end_offset = cur_offset + envelope_size;
3934 if 8 > max_ordinal {
3935 return Ok(());
3936 }
3937
3938 let cur_offset: usize = (8 - 1) * envelope_size;
3941
3942 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3944
3945 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3950 self.from_dictionary.as_ref().map(
3951 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3952 ),
3953 encoder,
3954 offset + cur_offset,
3955 depth,
3956 )?;
3957
3958 _prev_end_offset = cur_offset + envelope_size;
3959
3960 Ok(())
3961 }
3962 }
3963
3964 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Directory {
3965 #[inline(always)]
3966 fn new_empty() -> Self {
3967 Self::default()
3968 }
3969
3970 unsafe fn decode(
3971 &mut self,
3972 decoder: &mut fidl::encoding::Decoder<'_, D>,
3973 offset: usize,
3974 mut depth: fidl::encoding::Depth,
3975 ) -> fidl::Result<()> {
3976 decoder.debug_check_bounds::<Self>(offset);
3977 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3978 None => return Err(fidl::Error::NotNullable),
3979 Some(len) => len,
3980 };
3981 if len == 0 {
3983 return Ok(());
3984 };
3985 depth.increment()?;
3986 let envelope_size = 8;
3987 let bytes_len = len * envelope_size;
3988 let offset = decoder.out_of_line_offset(bytes_len)?;
3989 let mut _next_ordinal_to_read = 0;
3991 let mut next_offset = offset;
3992 let end_offset = offset + bytes_len;
3993 _next_ordinal_to_read += 1;
3994 if next_offset >= end_offset {
3995 return Ok(());
3996 }
3997
3998 while _next_ordinal_to_read < 1 {
4000 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4001 _next_ordinal_to_read += 1;
4002 next_offset += envelope_size;
4003 }
4004
4005 let next_out_of_line = decoder.next_out_of_line();
4006 let handles_before = decoder.remaining_handles();
4007 if let Some((inlined, num_bytes, num_handles)) =
4008 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4009 {
4010 let member_inline_size =
4011 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
4012 decoder.context,
4013 );
4014 if inlined != (member_inline_size <= 4) {
4015 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4016 }
4017 let inner_offset;
4018 let mut inner_depth = depth.clone();
4019 if inlined {
4020 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4021 inner_offset = next_offset;
4022 } else {
4023 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4024 inner_depth.increment()?;
4025 }
4026 let val_ref = self
4027 .name
4028 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
4029 fidl::decode!(
4030 fidl::encoding::BoundedString<255>,
4031 D,
4032 val_ref,
4033 decoder,
4034 inner_offset,
4035 inner_depth
4036 )?;
4037 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4038 {
4039 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4040 }
4041 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4042 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4043 }
4044 }
4045
4046 next_offset += envelope_size;
4047 _next_ordinal_to_read += 1;
4048 if next_offset >= end_offset {
4049 return Ok(());
4050 }
4051
4052 while _next_ordinal_to_read < 2 {
4054 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4055 _next_ordinal_to_read += 1;
4056 next_offset += envelope_size;
4057 }
4058
4059 let next_out_of_line = decoder.next_out_of_line();
4060 let handles_before = decoder.remaining_handles();
4061 if let Some((inlined, num_bytes, num_handles)) =
4062 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4063 {
4064 let member_inline_size =
4065 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
4066 decoder.context,
4067 );
4068 if inlined != (member_inline_size <= 4) {
4069 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4070 }
4071 let inner_offset;
4072 let mut inner_depth = depth.clone();
4073 if inlined {
4074 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4075 inner_offset = next_offset;
4076 } else {
4077 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4078 inner_depth.increment()?;
4079 }
4080 let val_ref = self
4081 .as_
4082 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
4083 fidl::decode!(
4084 fidl::encoding::BoundedString<255>,
4085 D,
4086 val_ref,
4087 decoder,
4088 inner_offset,
4089 inner_depth
4090 )?;
4091 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4092 {
4093 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4094 }
4095 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4096 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4097 }
4098 }
4099
4100 next_offset += envelope_size;
4101 _next_ordinal_to_read += 1;
4102 if next_offset >= end_offset {
4103 return Ok(());
4104 }
4105
4106 while _next_ordinal_to_read < 3 {
4108 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4109 _next_ordinal_to_read += 1;
4110 next_offset += envelope_size;
4111 }
4112
4113 let next_out_of_line = decoder.next_out_of_line();
4114 let handles_before = decoder.remaining_handles();
4115 if let Some((inlined, num_bytes, num_handles)) =
4116 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4117 {
4118 let member_inline_size = <fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4119 if inlined != (member_inline_size <= 4) {
4120 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4121 }
4122 let inner_offset;
4123 let mut inner_depth = depth.clone();
4124 if inlined {
4125 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4126 inner_offset = next_offset;
4127 } else {
4128 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4129 inner_depth.increment()?;
4130 }
4131 let val_ref = self.type_.get_or_insert_with(|| {
4132 fidl::new_empty!(fidl_fuchsia_component_decl__common::DependencyType, D)
4133 });
4134 fidl::decode!(
4135 fidl_fuchsia_component_decl__common::DependencyType,
4136 D,
4137 val_ref,
4138 decoder,
4139 inner_offset,
4140 inner_depth
4141 )?;
4142 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4143 {
4144 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4145 }
4146 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4147 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4148 }
4149 }
4150
4151 next_offset += envelope_size;
4152 _next_ordinal_to_read += 1;
4153 if next_offset >= end_offset {
4154 return Ok(());
4155 }
4156
4157 while _next_ordinal_to_read < 4 {
4159 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4160 _next_ordinal_to_read += 1;
4161 next_offset += envelope_size;
4162 }
4163
4164 let next_out_of_line = decoder.next_out_of_line();
4165 let handles_before = decoder.remaining_handles();
4166 if let Some((inlined, num_bytes, num_handles)) =
4167 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4168 {
4169 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4170 if inlined != (member_inline_size <= 4) {
4171 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4172 }
4173 let inner_offset;
4174 let mut inner_depth = depth.clone();
4175 if inlined {
4176 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4177 inner_offset = next_offset;
4178 } else {
4179 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4180 inner_depth.increment()?;
4181 }
4182 let val_ref = self.subdir.get_or_insert_with(|| {
4183 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
4184 });
4185 fidl::decode!(
4186 fidl::encoding::BoundedString<4095>,
4187 D,
4188 val_ref,
4189 decoder,
4190 inner_offset,
4191 inner_depth
4192 )?;
4193 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4194 {
4195 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4196 }
4197 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4198 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4199 }
4200 }
4201
4202 next_offset += envelope_size;
4203 _next_ordinal_to_read += 1;
4204 if next_offset >= end_offset {
4205 return Ok(());
4206 }
4207
4208 while _next_ordinal_to_read < 5 {
4210 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4211 _next_ordinal_to_read += 1;
4212 next_offset += envelope_size;
4213 }
4214
4215 let next_out_of_line = decoder.next_out_of_line();
4216 let handles_before = decoder.remaining_handles();
4217 if let Some((inlined, num_bytes, num_handles)) =
4218 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4219 {
4220 let member_inline_size = <fidl_fuchsia_io__common::Operations as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4221 if inlined != (member_inline_size <= 4) {
4222 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4223 }
4224 let inner_offset;
4225 let mut inner_depth = depth.clone();
4226 if inlined {
4227 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4228 inner_offset = next_offset;
4229 } else {
4230 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4231 inner_depth.increment()?;
4232 }
4233 let val_ref = self.rights.get_or_insert_with(|| {
4234 fidl::new_empty!(fidl_fuchsia_io__common::Operations, D)
4235 });
4236 fidl::decode!(
4237 fidl_fuchsia_io__common::Operations,
4238 D,
4239 val_ref,
4240 decoder,
4241 inner_offset,
4242 inner_depth
4243 )?;
4244 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4245 {
4246 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4247 }
4248 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4249 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4250 }
4251 }
4252
4253 next_offset += envelope_size;
4254 _next_ordinal_to_read += 1;
4255 if next_offset >= end_offset {
4256 return Ok(());
4257 }
4258
4259 while _next_ordinal_to_read < 6 {
4261 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4262 _next_ordinal_to_read += 1;
4263 next_offset += envelope_size;
4264 }
4265
4266 let next_out_of_line = decoder.next_out_of_line();
4267 let handles_before = decoder.remaining_handles();
4268 if let Some((inlined, num_bytes, num_handles)) =
4269 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4270 {
4271 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4272 if inlined != (member_inline_size <= 4) {
4273 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4274 }
4275 let inner_offset;
4276 let mut inner_depth = depth.clone();
4277 if inlined {
4278 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4279 inner_offset = next_offset;
4280 } else {
4281 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4282 inner_depth.increment()?;
4283 }
4284 let val_ref = self.path.get_or_insert_with(|| {
4285 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
4286 });
4287 fidl::decode!(
4288 fidl::encoding::BoundedString<4095>,
4289 D,
4290 val_ref,
4291 decoder,
4292 inner_offset,
4293 inner_depth
4294 )?;
4295 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4296 {
4297 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4298 }
4299 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4300 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4301 }
4302 }
4303
4304 next_offset += envelope_size;
4305 _next_ordinal_to_read += 1;
4306 if next_offset >= end_offset {
4307 return Ok(());
4308 }
4309
4310 while _next_ordinal_to_read < 7 {
4312 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4313 _next_ordinal_to_read += 1;
4314 next_offset += envelope_size;
4315 }
4316
4317 let next_out_of_line = decoder.next_out_of_line();
4318 let handles_before = decoder.remaining_handles();
4319 if let Some((inlined, num_bytes, num_handles)) =
4320 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4321 {
4322 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4323 if inlined != (member_inline_size <= 4) {
4324 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4325 }
4326 let inner_offset;
4327 let mut inner_depth = depth.clone();
4328 if inlined {
4329 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4330 inner_offset = next_offset;
4331 } else {
4332 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4333 inner_depth.increment()?;
4334 }
4335 let val_ref = self.availability.get_or_insert_with(|| {
4336 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
4337 });
4338 fidl::decode!(
4339 fidl_fuchsia_component_decl__common::Availability,
4340 D,
4341 val_ref,
4342 decoder,
4343 inner_offset,
4344 inner_depth
4345 )?;
4346 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4347 {
4348 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4349 }
4350 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4351 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4352 }
4353 }
4354
4355 next_offset += envelope_size;
4356 _next_ordinal_to_read += 1;
4357 if next_offset >= end_offset {
4358 return Ok(());
4359 }
4360
4361 while _next_ordinal_to_read < 8 {
4363 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4364 _next_ordinal_to_read += 1;
4365 next_offset += envelope_size;
4366 }
4367
4368 let next_out_of_line = decoder.next_out_of_line();
4369 let handles_before = decoder.remaining_handles();
4370 if let Some((inlined, num_bytes, num_handles)) =
4371 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4372 {
4373 let member_inline_size =
4374 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4375 decoder.context,
4376 );
4377 if inlined != (member_inline_size <= 4) {
4378 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4379 }
4380 let inner_offset;
4381 let mut inner_depth = depth.clone();
4382 if inlined {
4383 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4384 inner_offset = next_offset;
4385 } else {
4386 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4387 inner_depth.increment()?;
4388 }
4389 let val_ref = self
4390 .from_dictionary
4391 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4392 fidl::decode!(
4393 fidl::encoding::UnboundedString,
4394 D,
4395 val_ref,
4396 decoder,
4397 inner_offset,
4398 inner_depth
4399 )?;
4400 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4401 {
4402 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4403 }
4404 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4405 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4406 }
4407 }
4408
4409 next_offset += envelope_size;
4410
4411 while next_offset < end_offset {
4413 _next_ordinal_to_read += 1;
4414 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4415 next_offset += envelope_size;
4416 }
4417
4418 Ok(())
4419 }
4420 }
4421
4422 impl Event {
4423 #[inline(always)]
4424 fn max_ordinal_present(&self) -> u64 {
4425 if let Some(_) = self.availability {
4426 return 4;
4427 }
4428 if let Some(_) = self.filter {
4429 return 3;
4430 }
4431 if let Some(_) = self.as_ {
4432 return 2;
4433 }
4434 if let Some(_) = self.name {
4435 return 1;
4436 }
4437 0
4438 }
4439 }
4440
4441 impl fidl::encoding::ValueTypeMarker for Event {
4442 type Borrowed<'a> = &'a Self;
4443 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4444 value
4445 }
4446 }
4447
4448 unsafe impl fidl::encoding::TypeMarker for Event {
4449 type Owned = Self;
4450
4451 #[inline(always)]
4452 fn inline_align(_context: fidl::encoding::Context) -> usize {
4453 8
4454 }
4455
4456 #[inline(always)]
4457 fn inline_size(_context: fidl::encoding::Context) -> usize {
4458 16
4459 }
4460 }
4461
4462 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Event, D> for &Event {
4463 unsafe fn encode(
4464 self,
4465 encoder: &mut fidl::encoding::Encoder<'_, D>,
4466 offset: usize,
4467 mut depth: fidl::encoding::Depth,
4468 ) -> fidl::Result<()> {
4469 encoder.debug_check_bounds::<Event>(offset);
4470 let max_ordinal: u64 = self.max_ordinal_present();
4472 encoder.write_num(max_ordinal, offset);
4473 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4474 if max_ordinal == 0 {
4476 return Ok(());
4477 }
4478 depth.increment()?;
4479 let envelope_size = 8;
4480 let bytes_len = max_ordinal as usize * envelope_size;
4481 #[allow(unused_variables)]
4482 let offset = encoder.out_of_line_offset(bytes_len);
4483 let mut _prev_end_offset: usize = 0;
4484 if 1 > max_ordinal {
4485 return Ok(());
4486 }
4487
4488 let cur_offset: usize = (1 - 1) * envelope_size;
4491
4492 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4494
4495 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
4500 self.name.as_ref().map(
4501 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
4502 ),
4503 encoder,
4504 offset + cur_offset,
4505 depth,
4506 )?;
4507
4508 _prev_end_offset = cur_offset + envelope_size;
4509 if 2 > max_ordinal {
4510 return Ok(());
4511 }
4512
4513 let cur_offset: usize = (2 - 1) * envelope_size;
4516
4517 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4519
4520 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
4525 self.as_.as_ref().map(
4526 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
4527 ),
4528 encoder,
4529 offset + cur_offset,
4530 depth,
4531 )?;
4532
4533 _prev_end_offset = cur_offset + envelope_size;
4534 if 3 > max_ordinal {
4535 return Ok(());
4536 }
4537
4538 let cur_offset: usize = (3 - 1) * envelope_size;
4541
4542 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4544
4545 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_data__common::Dictionary, D>(
4550 self.filter.as_ref().map(<fidl_fuchsia_data__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow),
4551 encoder, offset + cur_offset, depth
4552 )?;
4553
4554 _prev_end_offset = cur_offset + envelope_size;
4555 if 4 > max_ordinal {
4556 return Ok(());
4557 }
4558
4559 let cur_offset: usize = (4 - 1) * envelope_size;
4562
4563 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4565
4566 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
4571 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
4572 encoder, offset + cur_offset, depth
4573 )?;
4574
4575 _prev_end_offset = cur_offset + envelope_size;
4576
4577 Ok(())
4578 }
4579 }
4580
4581 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Event {
4582 #[inline(always)]
4583 fn new_empty() -> Self {
4584 Self::default()
4585 }
4586
4587 unsafe fn decode(
4588 &mut self,
4589 decoder: &mut fidl::encoding::Decoder<'_, D>,
4590 offset: usize,
4591 mut depth: fidl::encoding::Depth,
4592 ) -> fidl::Result<()> {
4593 decoder.debug_check_bounds::<Self>(offset);
4594 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4595 None => return Err(fidl::Error::NotNullable),
4596 Some(len) => len,
4597 };
4598 if len == 0 {
4600 return Ok(());
4601 };
4602 depth.increment()?;
4603 let envelope_size = 8;
4604 let bytes_len = len * envelope_size;
4605 let offset = decoder.out_of_line_offset(bytes_len)?;
4606 let mut _next_ordinal_to_read = 0;
4608 let mut next_offset = offset;
4609 let end_offset = offset + bytes_len;
4610 _next_ordinal_to_read += 1;
4611 if next_offset >= end_offset {
4612 return Ok(());
4613 }
4614
4615 while _next_ordinal_to_read < 1 {
4617 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4618 _next_ordinal_to_read += 1;
4619 next_offset += envelope_size;
4620 }
4621
4622 let next_out_of_line = decoder.next_out_of_line();
4623 let handles_before = decoder.remaining_handles();
4624 if let Some((inlined, num_bytes, num_handles)) =
4625 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4626 {
4627 let member_inline_size =
4628 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
4629 decoder.context,
4630 );
4631 if inlined != (member_inline_size <= 4) {
4632 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4633 }
4634 let inner_offset;
4635 let mut inner_depth = depth.clone();
4636 if inlined {
4637 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4638 inner_offset = next_offset;
4639 } else {
4640 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4641 inner_depth.increment()?;
4642 }
4643 let val_ref = self
4644 .name
4645 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
4646 fidl::decode!(
4647 fidl::encoding::BoundedString<255>,
4648 D,
4649 val_ref,
4650 decoder,
4651 inner_offset,
4652 inner_depth
4653 )?;
4654 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4655 {
4656 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4657 }
4658 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4659 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4660 }
4661 }
4662
4663 next_offset += envelope_size;
4664 _next_ordinal_to_read += 1;
4665 if next_offset >= end_offset {
4666 return Ok(());
4667 }
4668
4669 while _next_ordinal_to_read < 2 {
4671 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4672 _next_ordinal_to_read += 1;
4673 next_offset += envelope_size;
4674 }
4675
4676 let next_out_of_line = decoder.next_out_of_line();
4677 let handles_before = decoder.remaining_handles();
4678 if let Some((inlined, num_bytes, num_handles)) =
4679 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4680 {
4681 let member_inline_size =
4682 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
4683 decoder.context,
4684 );
4685 if inlined != (member_inline_size <= 4) {
4686 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4687 }
4688 let inner_offset;
4689 let mut inner_depth = depth.clone();
4690 if inlined {
4691 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4692 inner_offset = next_offset;
4693 } else {
4694 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4695 inner_depth.increment()?;
4696 }
4697 let val_ref = self
4698 .as_
4699 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
4700 fidl::decode!(
4701 fidl::encoding::BoundedString<255>,
4702 D,
4703 val_ref,
4704 decoder,
4705 inner_offset,
4706 inner_depth
4707 )?;
4708 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4709 {
4710 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4711 }
4712 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4713 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4714 }
4715 }
4716
4717 next_offset += envelope_size;
4718 _next_ordinal_to_read += 1;
4719 if next_offset >= end_offset {
4720 return Ok(());
4721 }
4722
4723 while _next_ordinal_to_read < 3 {
4725 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4726 _next_ordinal_to_read += 1;
4727 next_offset += envelope_size;
4728 }
4729
4730 let next_out_of_line = decoder.next_out_of_line();
4731 let handles_before = decoder.remaining_handles();
4732 if let Some((inlined, num_bytes, num_handles)) =
4733 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4734 {
4735 let member_inline_size = <fidl_fuchsia_data__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4736 if inlined != (member_inline_size <= 4) {
4737 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4738 }
4739 let inner_offset;
4740 let mut inner_depth = depth.clone();
4741 if inlined {
4742 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4743 inner_offset = next_offset;
4744 } else {
4745 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4746 inner_depth.increment()?;
4747 }
4748 let val_ref = self.filter.get_or_insert_with(|| {
4749 fidl::new_empty!(fidl_fuchsia_data__common::Dictionary, D)
4750 });
4751 fidl::decode!(
4752 fidl_fuchsia_data__common::Dictionary,
4753 D,
4754 val_ref,
4755 decoder,
4756 inner_offset,
4757 inner_depth
4758 )?;
4759 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4760 {
4761 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4762 }
4763 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4764 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4765 }
4766 }
4767
4768 next_offset += envelope_size;
4769 _next_ordinal_to_read += 1;
4770 if next_offset >= end_offset {
4771 return Ok(());
4772 }
4773
4774 while _next_ordinal_to_read < 4 {
4776 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4777 _next_ordinal_to_read += 1;
4778 next_offset += envelope_size;
4779 }
4780
4781 let next_out_of_line = decoder.next_out_of_line();
4782 let handles_before = decoder.remaining_handles();
4783 if let Some((inlined, num_bytes, num_handles)) =
4784 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4785 {
4786 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4787 if inlined != (member_inline_size <= 4) {
4788 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4789 }
4790 let inner_offset;
4791 let mut inner_depth = depth.clone();
4792 if inlined {
4793 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4794 inner_offset = next_offset;
4795 } else {
4796 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4797 inner_depth.increment()?;
4798 }
4799 let val_ref = self.availability.get_or_insert_with(|| {
4800 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
4801 });
4802 fidl::decode!(
4803 fidl_fuchsia_component_decl__common::Availability,
4804 D,
4805 val_ref,
4806 decoder,
4807 inner_offset,
4808 inner_depth
4809 )?;
4810 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4811 {
4812 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4813 }
4814 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4815 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4816 }
4817 }
4818
4819 next_offset += envelope_size;
4820
4821 while next_offset < end_offset {
4823 _next_ordinal_to_read += 1;
4824 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4825 next_offset += envelope_size;
4826 }
4827
4828 Ok(())
4829 }
4830 }
4831
4832 impl EventStream {
4833 #[inline(always)]
4834 fn max_ordinal_present(&self) -> u64 {
4835 if let Some(_) = self.scope {
4836 return 5;
4837 }
4838 if let Some(_) = self.filter {
4839 return 4;
4840 }
4841 if let Some(_) = self.path {
4842 return 3;
4843 }
4844 if let Some(_) = self.as_ {
4845 return 2;
4846 }
4847 if let Some(_) = self.name {
4848 return 1;
4849 }
4850 0
4851 }
4852 }
4853
4854 impl fidl::encoding::ValueTypeMarker for EventStream {
4855 type Borrowed<'a> = &'a Self;
4856 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4857 value
4858 }
4859 }
4860
4861 unsafe impl fidl::encoding::TypeMarker for EventStream {
4862 type Owned = Self;
4863
4864 #[inline(always)]
4865 fn inline_align(_context: fidl::encoding::Context) -> usize {
4866 8
4867 }
4868
4869 #[inline(always)]
4870 fn inline_size(_context: fidl::encoding::Context) -> usize {
4871 16
4872 }
4873 }
4874
4875 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EventStream, D>
4876 for &EventStream
4877 {
4878 unsafe fn encode(
4879 self,
4880 encoder: &mut fidl::encoding::Encoder<'_, D>,
4881 offset: usize,
4882 mut depth: fidl::encoding::Depth,
4883 ) -> fidl::Result<()> {
4884 encoder.debug_check_bounds::<EventStream>(offset);
4885 let max_ordinal: u64 = self.max_ordinal_present();
4887 encoder.write_num(max_ordinal, offset);
4888 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4889 if max_ordinal == 0 {
4891 return Ok(());
4892 }
4893 depth.increment()?;
4894 let envelope_size = 8;
4895 let bytes_len = max_ordinal as usize * envelope_size;
4896 #[allow(unused_variables)]
4897 let offset = encoder.out_of_line_offset(bytes_len);
4898 let mut _prev_end_offset: usize = 0;
4899 if 1 > max_ordinal {
4900 return Ok(());
4901 }
4902
4903 let cur_offset: usize = (1 - 1) * envelope_size;
4906
4907 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4909
4910 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
4915 self.name.as_ref().map(
4916 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
4917 ),
4918 encoder,
4919 offset + cur_offset,
4920 depth,
4921 )?;
4922
4923 _prev_end_offset = cur_offset + envelope_size;
4924 if 2 > max_ordinal {
4925 return Ok(());
4926 }
4927
4928 let cur_offset: usize = (2 - 1) * envelope_size;
4931
4932 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4934
4935 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
4940 self.as_.as_ref().map(
4941 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
4942 ),
4943 encoder,
4944 offset + cur_offset,
4945 depth,
4946 )?;
4947
4948 _prev_end_offset = cur_offset + envelope_size;
4949 if 3 > max_ordinal {
4950 return Ok(());
4951 }
4952
4953 let cur_offset: usize = (3 - 1) * envelope_size;
4956
4957 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4959
4960 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
4965 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
4966 encoder, offset + cur_offset, depth
4967 )?;
4968
4969 _prev_end_offset = cur_offset + envelope_size;
4970 if 4 > max_ordinal {
4971 return Ok(());
4972 }
4973
4974 let cur_offset: usize = (4 - 1) * envelope_size;
4977
4978 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4980
4981 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_data__common::Dictionary, D>(
4986 self.filter.as_ref().map(<fidl_fuchsia_data__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow),
4987 encoder, offset + cur_offset, depth
4988 )?;
4989
4990 _prev_end_offset = cur_offset + envelope_size;
4991 if 5 > max_ordinal {
4992 return Ok(());
4993 }
4994
4995 let cur_offset: usize = (5 - 1) * envelope_size;
4998
4999 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5001
5002 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>, D>(
5007 self.scope.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref> as fidl::encoding::ValueTypeMarker>::borrow),
5008 encoder, offset + cur_offset, depth
5009 )?;
5010
5011 _prev_end_offset = cur_offset + envelope_size;
5012
5013 Ok(())
5014 }
5015 }
5016
5017 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventStream {
5018 #[inline(always)]
5019 fn new_empty() -> Self {
5020 Self::default()
5021 }
5022
5023 unsafe fn decode(
5024 &mut self,
5025 decoder: &mut fidl::encoding::Decoder<'_, D>,
5026 offset: usize,
5027 mut depth: fidl::encoding::Depth,
5028 ) -> fidl::Result<()> {
5029 decoder.debug_check_bounds::<Self>(offset);
5030 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5031 None => return Err(fidl::Error::NotNullable),
5032 Some(len) => len,
5033 };
5034 if len == 0 {
5036 return Ok(());
5037 };
5038 depth.increment()?;
5039 let envelope_size = 8;
5040 let bytes_len = len * envelope_size;
5041 let offset = decoder.out_of_line_offset(bytes_len)?;
5042 let mut _next_ordinal_to_read = 0;
5044 let mut next_offset = offset;
5045 let end_offset = offset + bytes_len;
5046 _next_ordinal_to_read += 1;
5047 if next_offset >= end_offset {
5048 return Ok(());
5049 }
5050
5051 while _next_ordinal_to_read < 1 {
5053 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5054 _next_ordinal_to_read += 1;
5055 next_offset += envelope_size;
5056 }
5057
5058 let next_out_of_line = decoder.next_out_of_line();
5059 let handles_before = decoder.remaining_handles();
5060 if let Some((inlined, num_bytes, num_handles)) =
5061 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5062 {
5063 let member_inline_size =
5064 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5065 decoder.context,
5066 );
5067 if inlined != (member_inline_size <= 4) {
5068 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5069 }
5070 let inner_offset;
5071 let mut inner_depth = depth.clone();
5072 if inlined {
5073 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5074 inner_offset = next_offset;
5075 } else {
5076 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5077 inner_depth.increment()?;
5078 }
5079 let val_ref = self
5080 .name
5081 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5082 fidl::decode!(
5083 fidl::encoding::BoundedString<255>,
5084 D,
5085 val_ref,
5086 decoder,
5087 inner_offset,
5088 inner_depth
5089 )?;
5090 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5091 {
5092 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5093 }
5094 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5095 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5096 }
5097 }
5098
5099 next_offset += envelope_size;
5100 _next_ordinal_to_read += 1;
5101 if next_offset >= end_offset {
5102 return Ok(());
5103 }
5104
5105 while _next_ordinal_to_read < 2 {
5107 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5108 _next_ordinal_to_read += 1;
5109 next_offset += envelope_size;
5110 }
5111
5112 let next_out_of_line = decoder.next_out_of_line();
5113 let handles_before = decoder.remaining_handles();
5114 if let Some((inlined, num_bytes, num_handles)) =
5115 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5116 {
5117 let member_inline_size =
5118 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5119 decoder.context,
5120 );
5121 if inlined != (member_inline_size <= 4) {
5122 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5123 }
5124 let inner_offset;
5125 let mut inner_depth = depth.clone();
5126 if inlined {
5127 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5128 inner_offset = next_offset;
5129 } else {
5130 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5131 inner_depth.increment()?;
5132 }
5133 let val_ref = self
5134 .as_
5135 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5136 fidl::decode!(
5137 fidl::encoding::BoundedString<255>,
5138 D,
5139 val_ref,
5140 decoder,
5141 inner_offset,
5142 inner_depth
5143 )?;
5144 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5145 {
5146 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5147 }
5148 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5149 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5150 }
5151 }
5152
5153 next_offset += envelope_size;
5154 _next_ordinal_to_read += 1;
5155 if next_offset >= end_offset {
5156 return Ok(());
5157 }
5158
5159 while _next_ordinal_to_read < 3 {
5161 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5162 _next_ordinal_to_read += 1;
5163 next_offset += envelope_size;
5164 }
5165
5166 let next_out_of_line = decoder.next_out_of_line();
5167 let handles_before = decoder.remaining_handles();
5168 if let Some((inlined, num_bytes, num_handles)) =
5169 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5170 {
5171 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5172 if inlined != (member_inline_size <= 4) {
5173 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5174 }
5175 let inner_offset;
5176 let mut inner_depth = depth.clone();
5177 if inlined {
5178 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5179 inner_offset = next_offset;
5180 } else {
5181 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5182 inner_depth.increment()?;
5183 }
5184 let val_ref = self.path.get_or_insert_with(|| {
5185 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
5186 });
5187 fidl::decode!(
5188 fidl::encoding::BoundedString<4095>,
5189 D,
5190 val_ref,
5191 decoder,
5192 inner_offset,
5193 inner_depth
5194 )?;
5195 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5196 {
5197 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5198 }
5199 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5200 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5201 }
5202 }
5203
5204 next_offset += envelope_size;
5205 _next_ordinal_to_read += 1;
5206 if next_offset >= end_offset {
5207 return Ok(());
5208 }
5209
5210 while _next_ordinal_to_read < 4 {
5212 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5213 _next_ordinal_to_read += 1;
5214 next_offset += envelope_size;
5215 }
5216
5217 let next_out_of_line = decoder.next_out_of_line();
5218 let handles_before = decoder.remaining_handles();
5219 if let Some((inlined, num_bytes, num_handles)) =
5220 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5221 {
5222 let member_inline_size = <fidl_fuchsia_data__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5223 if inlined != (member_inline_size <= 4) {
5224 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5225 }
5226 let inner_offset;
5227 let mut inner_depth = depth.clone();
5228 if inlined {
5229 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5230 inner_offset = next_offset;
5231 } else {
5232 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5233 inner_depth.increment()?;
5234 }
5235 let val_ref = self.filter.get_or_insert_with(|| {
5236 fidl::new_empty!(fidl_fuchsia_data__common::Dictionary, D)
5237 });
5238 fidl::decode!(
5239 fidl_fuchsia_data__common::Dictionary,
5240 D,
5241 val_ref,
5242 decoder,
5243 inner_offset,
5244 inner_depth
5245 )?;
5246 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5247 {
5248 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5249 }
5250 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5251 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5252 }
5253 }
5254
5255 next_offset += envelope_size;
5256 _next_ordinal_to_read += 1;
5257 if next_offset >= end_offset {
5258 return Ok(());
5259 }
5260
5261 while _next_ordinal_to_read < 5 {
5263 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5264 _next_ordinal_to_read += 1;
5265 next_offset += envelope_size;
5266 }
5267
5268 let next_out_of_line = decoder.next_out_of_line();
5269 let handles_before = decoder.remaining_handles();
5270 if let Some((inlined, num_bytes, num_handles)) =
5271 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5272 {
5273 let member_inline_size = <fidl::encoding::UnboundedVector<
5274 fidl_fuchsia_component_decl__common::Ref,
5275 > as fidl::encoding::TypeMarker>::inline_size(
5276 decoder.context
5277 );
5278 if inlined != (member_inline_size <= 4) {
5279 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5280 }
5281 let inner_offset;
5282 let mut inner_depth = depth.clone();
5283 if inlined {
5284 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5285 inner_offset = next_offset;
5286 } else {
5287 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5288 inner_depth.increment()?;
5289 }
5290 let val_ref = self.scope.get_or_insert_with(|| {
5291 fidl::new_empty!(
5292 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
5293 D
5294 )
5295 });
5296 fidl::decode!(
5297 fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
5298 D,
5299 val_ref,
5300 decoder,
5301 inner_offset,
5302 inner_depth
5303 )?;
5304 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5305 {
5306 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5307 }
5308 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5309 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5310 }
5311 }
5312
5313 next_offset += envelope_size;
5314
5315 while next_offset < end_offset {
5317 _next_ordinal_to_read += 1;
5318 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5319 next_offset += envelope_size;
5320 }
5321
5322 Ok(())
5323 }
5324 }
5325
5326 impl Protocol {
5327 #[inline(always)]
5328 fn max_ordinal_present(&self) -> u64 {
5329 if let Some(_) = self.from_dictionary {
5330 return 6;
5331 }
5332 if let Some(_) = self.availability {
5333 return 5;
5334 }
5335 if let Some(_) = self.path {
5336 return 4;
5337 }
5338 if let Some(_) = self.type_ {
5339 return 3;
5340 }
5341 if let Some(_) = self.as_ {
5342 return 2;
5343 }
5344 if let Some(_) = self.name {
5345 return 1;
5346 }
5347 0
5348 }
5349 }
5350
5351 impl fidl::encoding::ValueTypeMarker for Protocol {
5352 type Borrowed<'a> = &'a Self;
5353 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5354 value
5355 }
5356 }
5357
5358 unsafe impl fidl::encoding::TypeMarker for Protocol {
5359 type Owned = Self;
5360
5361 #[inline(always)]
5362 fn inline_align(_context: fidl::encoding::Context) -> usize {
5363 8
5364 }
5365
5366 #[inline(always)]
5367 fn inline_size(_context: fidl::encoding::Context) -> usize {
5368 16
5369 }
5370 }
5371
5372 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Protocol, D> for &Protocol {
5373 unsafe fn encode(
5374 self,
5375 encoder: &mut fidl::encoding::Encoder<'_, D>,
5376 offset: usize,
5377 mut depth: fidl::encoding::Depth,
5378 ) -> fidl::Result<()> {
5379 encoder.debug_check_bounds::<Protocol>(offset);
5380 let max_ordinal: u64 = self.max_ordinal_present();
5382 encoder.write_num(max_ordinal, offset);
5383 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5384 if max_ordinal == 0 {
5386 return Ok(());
5387 }
5388 depth.increment()?;
5389 let envelope_size = 8;
5390 let bytes_len = max_ordinal as usize * envelope_size;
5391 #[allow(unused_variables)]
5392 let offset = encoder.out_of_line_offset(bytes_len);
5393 let mut _prev_end_offset: usize = 0;
5394 if 1 > max_ordinal {
5395 return Ok(());
5396 }
5397
5398 let cur_offset: usize = (1 - 1) * envelope_size;
5401
5402 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5404
5405 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5410 self.name.as_ref().map(
5411 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5412 ),
5413 encoder,
5414 offset + cur_offset,
5415 depth,
5416 )?;
5417
5418 _prev_end_offset = cur_offset + envelope_size;
5419 if 2 > max_ordinal {
5420 return Ok(());
5421 }
5422
5423 let cur_offset: usize = (2 - 1) * envelope_size;
5426
5427 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5429
5430 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5435 self.as_.as_ref().map(
5436 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5437 ),
5438 encoder,
5439 offset + cur_offset,
5440 depth,
5441 )?;
5442
5443 _prev_end_offset = cur_offset + envelope_size;
5444 if 3 > max_ordinal {
5445 return Ok(());
5446 }
5447
5448 let cur_offset: usize = (3 - 1) * envelope_size;
5451
5452 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5454
5455 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::DependencyType, D>(
5460 self.type_.as_ref().map(<fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
5461 encoder, offset + cur_offset, depth
5462 )?;
5463
5464 _prev_end_offset = cur_offset + envelope_size;
5465 if 4 > max_ordinal {
5466 return Ok(());
5467 }
5468
5469 let cur_offset: usize = (4 - 1) * envelope_size;
5472
5473 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5475
5476 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
5481 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
5482 encoder, offset + cur_offset, depth
5483 )?;
5484
5485 _prev_end_offset = cur_offset + envelope_size;
5486 if 5 > max_ordinal {
5487 return Ok(());
5488 }
5489
5490 let cur_offset: usize = (5 - 1) * envelope_size;
5493
5494 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5496
5497 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
5502 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
5503 encoder, offset + cur_offset, depth
5504 )?;
5505
5506 _prev_end_offset = cur_offset + envelope_size;
5507 if 6 > max_ordinal {
5508 return Ok(());
5509 }
5510
5511 let cur_offset: usize = (6 - 1) * envelope_size;
5514
5515 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5517
5518 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
5523 self.from_dictionary.as_ref().map(
5524 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
5525 ),
5526 encoder,
5527 offset + cur_offset,
5528 depth,
5529 )?;
5530
5531 _prev_end_offset = cur_offset + envelope_size;
5532
5533 Ok(())
5534 }
5535 }
5536
5537 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Protocol {
5538 #[inline(always)]
5539 fn new_empty() -> Self {
5540 Self::default()
5541 }
5542
5543 unsafe fn decode(
5544 &mut self,
5545 decoder: &mut fidl::encoding::Decoder<'_, D>,
5546 offset: usize,
5547 mut depth: fidl::encoding::Depth,
5548 ) -> fidl::Result<()> {
5549 decoder.debug_check_bounds::<Self>(offset);
5550 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5551 None => return Err(fidl::Error::NotNullable),
5552 Some(len) => len,
5553 };
5554 if len == 0 {
5556 return Ok(());
5557 };
5558 depth.increment()?;
5559 let envelope_size = 8;
5560 let bytes_len = len * envelope_size;
5561 let offset = decoder.out_of_line_offset(bytes_len)?;
5562 let mut _next_ordinal_to_read = 0;
5564 let mut next_offset = offset;
5565 let end_offset = offset + bytes_len;
5566 _next_ordinal_to_read += 1;
5567 if next_offset >= end_offset {
5568 return Ok(());
5569 }
5570
5571 while _next_ordinal_to_read < 1 {
5573 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5574 _next_ordinal_to_read += 1;
5575 next_offset += envelope_size;
5576 }
5577
5578 let next_out_of_line = decoder.next_out_of_line();
5579 let handles_before = decoder.remaining_handles();
5580 if let Some((inlined, num_bytes, num_handles)) =
5581 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5582 {
5583 let member_inline_size =
5584 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5585 decoder.context,
5586 );
5587 if inlined != (member_inline_size <= 4) {
5588 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5589 }
5590 let inner_offset;
5591 let mut inner_depth = depth.clone();
5592 if inlined {
5593 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5594 inner_offset = next_offset;
5595 } else {
5596 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5597 inner_depth.increment()?;
5598 }
5599 let val_ref = self
5600 .name
5601 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5602 fidl::decode!(
5603 fidl::encoding::BoundedString<255>,
5604 D,
5605 val_ref,
5606 decoder,
5607 inner_offset,
5608 inner_depth
5609 )?;
5610 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5611 {
5612 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5613 }
5614 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5615 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5616 }
5617 }
5618
5619 next_offset += envelope_size;
5620 _next_ordinal_to_read += 1;
5621 if next_offset >= end_offset {
5622 return Ok(());
5623 }
5624
5625 while _next_ordinal_to_read < 2 {
5627 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5628 _next_ordinal_to_read += 1;
5629 next_offset += envelope_size;
5630 }
5631
5632 let next_out_of_line = decoder.next_out_of_line();
5633 let handles_before = decoder.remaining_handles();
5634 if let Some((inlined, num_bytes, num_handles)) =
5635 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5636 {
5637 let member_inline_size =
5638 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5639 decoder.context,
5640 );
5641 if inlined != (member_inline_size <= 4) {
5642 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5643 }
5644 let inner_offset;
5645 let mut inner_depth = depth.clone();
5646 if inlined {
5647 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5648 inner_offset = next_offset;
5649 } else {
5650 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5651 inner_depth.increment()?;
5652 }
5653 let val_ref = self
5654 .as_
5655 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5656 fidl::decode!(
5657 fidl::encoding::BoundedString<255>,
5658 D,
5659 val_ref,
5660 decoder,
5661 inner_offset,
5662 inner_depth
5663 )?;
5664 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5665 {
5666 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5667 }
5668 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5669 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5670 }
5671 }
5672
5673 next_offset += envelope_size;
5674 _next_ordinal_to_read += 1;
5675 if next_offset >= end_offset {
5676 return Ok(());
5677 }
5678
5679 while _next_ordinal_to_read < 3 {
5681 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5682 _next_ordinal_to_read += 1;
5683 next_offset += envelope_size;
5684 }
5685
5686 let next_out_of_line = decoder.next_out_of_line();
5687 let handles_before = decoder.remaining_handles();
5688 if let Some((inlined, num_bytes, num_handles)) =
5689 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5690 {
5691 let member_inline_size = <fidl_fuchsia_component_decl__common::DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5692 if inlined != (member_inline_size <= 4) {
5693 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5694 }
5695 let inner_offset;
5696 let mut inner_depth = depth.clone();
5697 if inlined {
5698 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5699 inner_offset = next_offset;
5700 } else {
5701 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5702 inner_depth.increment()?;
5703 }
5704 let val_ref = self.type_.get_or_insert_with(|| {
5705 fidl::new_empty!(fidl_fuchsia_component_decl__common::DependencyType, D)
5706 });
5707 fidl::decode!(
5708 fidl_fuchsia_component_decl__common::DependencyType,
5709 D,
5710 val_ref,
5711 decoder,
5712 inner_offset,
5713 inner_depth
5714 )?;
5715 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5716 {
5717 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5718 }
5719 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5720 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5721 }
5722 }
5723
5724 next_offset += envelope_size;
5725 _next_ordinal_to_read += 1;
5726 if next_offset >= end_offset {
5727 return Ok(());
5728 }
5729
5730 while _next_ordinal_to_read < 4 {
5732 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5733 _next_ordinal_to_read += 1;
5734 next_offset += envelope_size;
5735 }
5736
5737 let next_out_of_line = decoder.next_out_of_line();
5738 let handles_before = decoder.remaining_handles();
5739 if let Some((inlined, num_bytes, num_handles)) =
5740 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5741 {
5742 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5743 if inlined != (member_inline_size <= 4) {
5744 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5745 }
5746 let inner_offset;
5747 let mut inner_depth = depth.clone();
5748 if inlined {
5749 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5750 inner_offset = next_offset;
5751 } else {
5752 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5753 inner_depth.increment()?;
5754 }
5755 let val_ref = self.path.get_or_insert_with(|| {
5756 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
5757 });
5758 fidl::decode!(
5759 fidl::encoding::BoundedString<4095>,
5760 D,
5761 val_ref,
5762 decoder,
5763 inner_offset,
5764 inner_depth
5765 )?;
5766 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5767 {
5768 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5769 }
5770 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5771 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5772 }
5773 }
5774
5775 next_offset += envelope_size;
5776 _next_ordinal_to_read += 1;
5777 if next_offset >= end_offset {
5778 return Ok(());
5779 }
5780
5781 while _next_ordinal_to_read < 5 {
5783 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5784 _next_ordinal_to_read += 1;
5785 next_offset += envelope_size;
5786 }
5787
5788 let next_out_of_line = decoder.next_out_of_line();
5789 let handles_before = decoder.remaining_handles();
5790 if let Some((inlined, num_bytes, num_handles)) =
5791 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5792 {
5793 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5794 if inlined != (member_inline_size <= 4) {
5795 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5796 }
5797 let inner_offset;
5798 let mut inner_depth = depth.clone();
5799 if inlined {
5800 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5801 inner_offset = next_offset;
5802 } else {
5803 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5804 inner_depth.increment()?;
5805 }
5806 let val_ref = self.availability.get_or_insert_with(|| {
5807 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
5808 });
5809 fidl::decode!(
5810 fidl_fuchsia_component_decl__common::Availability,
5811 D,
5812 val_ref,
5813 decoder,
5814 inner_offset,
5815 inner_depth
5816 )?;
5817 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5818 {
5819 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5820 }
5821 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5822 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5823 }
5824 }
5825
5826 next_offset += envelope_size;
5827 _next_ordinal_to_read += 1;
5828 if next_offset >= end_offset {
5829 return Ok(());
5830 }
5831
5832 while _next_ordinal_to_read < 6 {
5834 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5835 _next_ordinal_to_read += 1;
5836 next_offset += envelope_size;
5837 }
5838
5839 let next_out_of_line = decoder.next_out_of_line();
5840 let handles_before = decoder.remaining_handles();
5841 if let Some((inlined, num_bytes, num_handles)) =
5842 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5843 {
5844 let member_inline_size =
5845 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
5846 decoder.context,
5847 );
5848 if inlined != (member_inline_size <= 4) {
5849 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5850 }
5851 let inner_offset;
5852 let mut inner_depth = depth.clone();
5853 if inlined {
5854 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5855 inner_offset = next_offset;
5856 } else {
5857 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5858 inner_depth.increment()?;
5859 }
5860 let val_ref = self
5861 .from_dictionary
5862 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
5863 fidl::decode!(
5864 fidl::encoding::UnboundedString,
5865 D,
5866 val_ref,
5867 decoder,
5868 inner_offset,
5869 inner_depth
5870 )?;
5871 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5872 {
5873 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5874 }
5875 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5876 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5877 }
5878 }
5879
5880 next_offset += envelope_size;
5881
5882 while next_offset < end_offset {
5884 _next_ordinal_to_read += 1;
5885 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5886 next_offset += envelope_size;
5887 }
5888
5889 Ok(())
5890 }
5891 }
5892
5893 impl Resolver {
5894 #[inline(always)]
5895 fn max_ordinal_present(&self) -> u64 {
5896 if let Some(_) = self.from_dictionary {
5897 return 4;
5898 }
5899 if let Some(_) = self.path {
5900 return 3;
5901 }
5902 if let Some(_) = self.as_ {
5903 return 2;
5904 }
5905 if let Some(_) = self.name {
5906 return 1;
5907 }
5908 0
5909 }
5910 }
5911
5912 impl fidl::encoding::ValueTypeMarker for Resolver {
5913 type Borrowed<'a> = &'a Self;
5914 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5915 value
5916 }
5917 }
5918
5919 unsafe impl fidl::encoding::TypeMarker for Resolver {
5920 type Owned = Self;
5921
5922 #[inline(always)]
5923 fn inline_align(_context: fidl::encoding::Context) -> usize {
5924 8
5925 }
5926
5927 #[inline(always)]
5928 fn inline_size(_context: fidl::encoding::Context) -> usize {
5929 16
5930 }
5931 }
5932
5933 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Resolver, D> for &Resolver {
5934 unsafe fn encode(
5935 self,
5936 encoder: &mut fidl::encoding::Encoder<'_, D>,
5937 offset: usize,
5938 mut depth: fidl::encoding::Depth,
5939 ) -> fidl::Result<()> {
5940 encoder.debug_check_bounds::<Resolver>(offset);
5941 let max_ordinal: u64 = self.max_ordinal_present();
5943 encoder.write_num(max_ordinal, offset);
5944 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5945 if max_ordinal == 0 {
5947 return Ok(());
5948 }
5949 depth.increment()?;
5950 let envelope_size = 8;
5951 let bytes_len = max_ordinal as usize * envelope_size;
5952 #[allow(unused_variables)]
5953 let offset = encoder.out_of_line_offset(bytes_len);
5954 let mut _prev_end_offset: usize = 0;
5955 if 1 > max_ordinal {
5956 return Ok(());
5957 }
5958
5959 let cur_offset: usize = (1 - 1) * envelope_size;
5962
5963 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5965
5966 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5971 self.name.as_ref().map(
5972 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5973 ),
5974 encoder,
5975 offset + cur_offset,
5976 depth,
5977 )?;
5978
5979 _prev_end_offset = cur_offset + envelope_size;
5980 if 2 > max_ordinal {
5981 return Ok(());
5982 }
5983
5984 let cur_offset: usize = (2 - 1) * envelope_size;
5987
5988 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5990
5991 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5996 self.as_.as_ref().map(
5997 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5998 ),
5999 encoder,
6000 offset + cur_offset,
6001 depth,
6002 )?;
6003
6004 _prev_end_offset = cur_offset + envelope_size;
6005 if 3 > max_ordinal {
6006 return Ok(());
6007 }
6008
6009 let cur_offset: usize = (3 - 1) * envelope_size;
6012
6013 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6015
6016 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
6021 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
6022 encoder, offset + cur_offset, depth
6023 )?;
6024
6025 _prev_end_offset = cur_offset + envelope_size;
6026 if 4 > max_ordinal {
6027 return Ok(());
6028 }
6029
6030 let cur_offset: usize = (4 - 1) * envelope_size;
6033
6034 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6036
6037 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
6042 self.from_dictionary.as_ref().map(
6043 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
6044 ),
6045 encoder,
6046 offset + cur_offset,
6047 depth,
6048 )?;
6049
6050 _prev_end_offset = cur_offset + envelope_size;
6051
6052 Ok(())
6053 }
6054 }
6055
6056 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Resolver {
6057 #[inline(always)]
6058 fn new_empty() -> Self {
6059 Self::default()
6060 }
6061
6062 unsafe fn decode(
6063 &mut self,
6064 decoder: &mut fidl::encoding::Decoder<'_, D>,
6065 offset: usize,
6066 mut depth: fidl::encoding::Depth,
6067 ) -> fidl::Result<()> {
6068 decoder.debug_check_bounds::<Self>(offset);
6069 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6070 None => return Err(fidl::Error::NotNullable),
6071 Some(len) => len,
6072 };
6073 if len == 0 {
6075 return Ok(());
6076 };
6077 depth.increment()?;
6078 let envelope_size = 8;
6079 let bytes_len = len * envelope_size;
6080 let offset = decoder.out_of_line_offset(bytes_len)?;
6081 let mut _next_ordinal_to_read = 0;
6083 let mut next_offset = offset;
6084 let end_offset = offset + bytes_len;
6085 _next_ordinal_to_read += 1;
6086 if next_offset >= end_offset {
6087 return Ok(());
6088 }
6089
6090 while _next_ordinal_to_read < 1 {
6092 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6093 _next_ordinal_to_read += 1;
6094 next_offset += envelope_size;
6095 }
6096
6097 let next_out_of_line = decoder.next_out_of_line();
6098 let handles_before = decoder.remaining_handles();
6099 if let Some((inlined, num_bytes, num_handles)) =
6100 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6101 {
6102 let member_inline_size =
6103 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6104 decoder.context,
6105 );
6106 if inlined != (member_inline_size <= 4) {
6107 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6108 }
6109 let inner_offset;
6110 let mut inner_depth = depth.clone();
6111 if inlined {
6112 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6113 inner_offset = next_offset;
6114 } else {
6115 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6116 inner_depth.increment()?;
6117 }
6118 let val_ref = self
6119 .name
6120 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6121 fidl::decode!(
6122 fidl::encoding::BoundedString<255>,
6123 D,
6124 val_ref,
6125 decoder,
6126 inner_offset,
6127 inner_depth
6128 )?;
6129 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6130 {
6131 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6132 }
6133 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6134 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6135 }
6136 }
6137
6138 next_offset += envelope_size;
6139 _next_ordinal_to_read += 1;
6140 if next_offset >= end_offset {
6141 return Ok(());
6142 }
6143
6144 while _next_ordinal_to_read < 2 {
6146 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6147 _next_ordinal_to_read += 1;
6148 next_offset += envelope_size;
6149 }
6150
6151 let next_out_of_line = decoder.next_out_of_line();
6152 let handles_before = decoder.remaining_handles();
6153 if let Some((inlined, num_bytes, num_handles)) =
6154 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6155 {
6156 let member_inline_size =
6157 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6158 decoder.context,
6159 );
6160 if inlined != (member_inline_size <= 4) {
6161 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6162 }
6163 let inner_offset;
6164 let mut inner_depth = depth.clone();
6165 if inlined {
6166 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6167 inner_offset = next_offset;
6168 } else {
6169 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6170 inner_depth.increment()?;
6171 }
6172 let val_ref = self
6173 .as_
6174 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6175 fidl::decode!(
6176 fidl::encoding::BoundedString<255>,
6177 D,
6178 val_ref,
6179 decoder,
6180 inner_offset,
6181 inner_depth
6182 )?;
6183 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6184 {
6185 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6186 }
6187 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6188 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6189 }
6190 }
6191
6192 next_offset += envelope_size;
6193 _next_ordinal_to_read += 1;
6194 if next_offset >= end_offset {
6195 return Ok(());
6196 }
6197
6198 while _next_ordinal_to_read < 3 {
6200 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6201 _next_ordinal_to_read += 1;
6202 next_offset += envelope_size;
6203 }
6204
6205 let next_out_of_line = decoder.next_out_of_line();
6206 let handles_before = decoder.remaining_handles();
6207 if let Some((inlined, num_bytes, num_handles)) =
6208 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6209 {
6210 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6211 if inlined != (member_inline_size <= 4) {
6212 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6213 }
6214 let inner_offset;
6215 let mut inner_depth = depth.clone();
6216 if inlined {
6217 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6218 inner_offset = next_offset;
6219 } else {
6220 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6221 inner_depth.increment()?;
6222 }
6223 let val_ref = self.path.get_or_insert_with(|| {
6224 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
6225 });
6226 fidl::decode!(
6227 fidl::encoding::BoundedString<4095>,
6228 D,
6229 val_ref,
6230 decoder,
6231 inner_offset,
6232 inner_depth
6233 )?;
6234 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6235 {
6236 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6237 }
6238 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6239 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6240 }
6241 }
6242
6243 next_offset += envelope_size;
6244 _next_ordinal_to_read += 1;
6245 if next_offset >= end_offset {
6246 return Ok(());
6247 }
6248
6249 while _next_ordinal_to_read < 4 {
6251 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6252 _next_ordinal_to_read += 1;
6253 next_offset += envelope_size;
6254 }
6255
6256 let next_out_of_line = decoder.next_out_of_line();
6257 let handles_before = decoder.remaining_handles();
6258 if let Some((inlined, num_bytes, num_handles)) =
6259 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6260 {
6261 let member_inline_size =
6262 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
6263 decoder.context,
6264 );
6265 if inlined != (member_inline_size <= 4) {
6266 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6267 }
6268 let inner_offset;
6269 let mut inner_depth = depth.clone();
6270 if inlined {
6271 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6272 inner_offset = next_offset;
6273 } else {
6274 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6275 inner_depth.increment()?;
6276 }
6277 let val_ref = self
6278 .from_dictionary
6279 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
6280 fidl::decode!(
6281 fidl::encoding::UnboundedString,
6282 D,
6283 val_ref,
6284 decoder,
6285 inner_offset,
6286 inner_depth
6287 )?;
6288 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6289 {
6290 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6291 }
6292 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6293 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6294 }
6295 }
6296
6297 next_offset += envelope_size;
6298
6299 while next_offset < end_offset {
6301 _next_ordinal_to_read += 1;
6302 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6303 next_offset += envelope_size;
6304 }
6305
6306 Ok(())
6307 }
6308 }
6309
6310 impl Runner {
6311 #[inline(always)]
6312 fn max_ordinal_present(&self) -> u64 {
6313 if let Some(_) = self.from_dictionary {
6314 return 4;
6315 }
6316 if let Some(_) = self.path {
6317 return 3;
6318 }
6319 if let Some(_) = self.as_ {
6320 return 2;
6321 }
6322 if let Some(_) = self.name {
6323 return 1;
6324 }
6325 0
6326 }
6327 }
6328
6329 impl fidl::encoding::ValueTypeMarker for Runner {
6330 type Borrowed<'a> = &'a Self;
6331 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6332 value
6333 }
6334 }
6335
6336 unsafe impl fidl::encoding::TypeMarker for Runner {
6337 type Owned = Self;
6338
6339 #[inline(always)]
6340 fn inline_align(_context: fidl::encoding::Context) -> usize {
6341 8
6342 }
6343
6344 #[inline(always)]
6345 fn inline_size(_context: fidl::encoding::Context) -> usize {
6346 16
6347 }
6348 }
6349
6350 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Runner, D> for &Runner {
6351 unsafe fn encode(
6352 self,
6353 encoder: &mut fidl::encoding::Encoder<'_, D>,
6354 offset: usize,
6355 mut depth: fidl::encoding::Depth,
6356 ) -> fidl::Result<()> {
6357 encoder.debug_check_bounds::<Runner>(offset);
6358 let max_ordinal: u64 = self.max_ordinal_present();
6360 encoder.write_num(max_ordinal, offset);
6361 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6362 if max_ordinal == 0 {
6364 return Ok(());
6365 }
6366 depth.increment()?;
6367 let envelope_size = 8;
6368 let bytes_len = max_ordinal as usize * envelope_size;
6369 #[allow(unused_variables)]
6370 let offset = encoder.out_of_line_offset(bytes_len);
6371 let mut _prev_end_offset: usize = 0;
6372 if 1 > max_ordinal {
6373 return Ok(());
6374 }
6375
6376 let cur_offset: usize = (1 - 1) * envelope_size;
6379
6380 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6382
6383 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6388 self.name.as_ref().map(
6389 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6390 ),
6391 encoder,
6392 offset + cur_offset,
6393 depth,
6394 )?;
6395
6396 _prev_end_offset = cur_offset + envelope_size;
6397 if 2 > max_ordinal {
6398 return Ok(());
6399 }
6400
6401 let cur_offset: usize = (2 - 1) * envelope_size;
6404
6405 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6407
6408 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6413 self.as_.as_ref().map(
6414 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6415 ),
6416 encoder,
6417 offset + cur_offset,
6418 depth,
6419 )?;
6420
6421 _prev_end_offset = cur_offset + envelope_size;
6422 if 3 > max_ordinal {
6423 return Ok(());
6424 }
6425
6426 let cur_offset: usize = (3 - 1) * envelope_size;
6429
6430 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6432
6433 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
6438 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
6439 encoder, offset + cur_offset, depth
6440 )?;
6441
6442 _prev_end_offset = cur_offset + envelope_size;
6443 if 4 > max_ordinal {
6444 return Ok(());
6445 }
6446
6447 let cur_offset: usize = (4 - 1) * envelope_size;
6450
6451 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6453
6454 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
6459 self.from_dictionary.as_ref().map(
6460 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
6461 ),
6462 encoder,
6463 offset + cur_offset,
6464 depth,
6465 )?;
6466
6467 _prev_end_offset = cur_offset + envelope_size;
6468
6469 Ok(())
6470 }
6471 }
6472
6473 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Runner {
6474 #[inline(always)]
6475 fn new_empty() -> Self {
6476 Self::default()
6477 }
6478
6479 unsafe fn decode(
6480 &mut self,
6481 decoder: &mut fidl::encoding::Decoder<'_, D>,
6482 offset: usize,
6483 mut depth: fidl::encoding::Depth,
6484 ) -> fidl::Result<()> {
6485 decoder.debug_check_bounds::<Self>(offset);
6486 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6487 None => return Err(fidl::Error::NotNullable),
6488 Some(len) => len,
6489 };
6490 if len == 0 {
6492 return Ok(());
6493 };
6494 depth.increment()?;
6495 let envelope_size = 8;
6496 let bytes_len = len * envelope_size;
6497 let offset = decoder.out_of_line_offset(bytes_len)?;
6498 let mut _next_ordinal_to_read = 0;
6500 let mut next_offset = offset;
6501 let end_offset = offset + bytes_len;
6502 _next_ordinal_to_read += 1;
6503 if next_offset >= end_offset {
6504 return Ok(());
6505 }
6506
6507 while _next_ordinal_to_read < 1 {
6509 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6510 _next_ordinal_to_read += 1;
6511 next_offset += envelope_size;
6512 }
6513
6514 let next_out_of_line = decoder.next_out_of_line();
6515 let handles_before = decoder.remaining_handles();
6516 if let Some((inlined, num_bytes, num_handles)) =
6517 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6518 {
6519 let member_inline_size =
6520 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6521 decoder.context,
6522 );
6523 if inlined != (member_inline_size <= 4) {
6524 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6525 }
6526 let inner_offset;
6527 let mut inner_depth = depth.clone();
6528 if inlined {
6529 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6530 inner_offset = next_offset;
6531 } else {
6532 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6533 inner_depth.increment()?;
6534 }
6535 let val_ref = self
6536 .name
6537 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6538 fidl::decode!(
6539 fidl::encoding::BoundedString<255>,
6540 D,
6541 val_ref,
6542 decoder,
6543 inner_offset,
6544 inner_depth
6545 )?;
6546 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6547 {
6548 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6549 }
6550 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6551 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6552 }
6553 }
6554
6555 next_offset += envelope_size;
6556 _next_ordinal_to_read += 1;
6557 if next_offset >= end_offset {
6558 return Ok(());
6559 }
6560
6561 while _next_ordinal_to_read < 2 {
6563 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6564 _next_ordinal_to_read += 1;
6565 next_offset += envelope_size;
6566 }
6567
6568 let next_out_of_line = decoder.next_out_of_line();
6569 let handles_before = decoder.remaining_handles();
6570 if let Some((inlined, num_bytes, num_handles)) =
6571 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6572 {
6573 let member_inline_size =
6574 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6575 decoder.context,
6576 );
6577 if inlined != (member_inline_size <= 4) {
6578 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6579 }
6580 let inner_offset;
6581 let mut inner_depth = depth.clone();
6582 if inlined {
6583 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6584 inner_offset = next_offset;
6585 } else {
6586 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6587 inner_depth.increment()?;
6588 }
6589 let val_ref = self
6590 .as_
6591 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6592 fidl::decode!(
6593 fidl::encoding::BoundedString<255>,
6594 D,
6595 val_ref,
6596 decoder,
6597 inner_offset,
6598 inner_depth
6599 )?;
6600 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6601 {
6602 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6603 }
6604 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6605 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6606 }
6607 }
6608
6609 next_offset += envelope_size;
6610 _next_ordinal_to_read += 1;
6611 if next_offset >= end_offset {
6612 return Ok(());
6613 }
6614
6615 while _next_ordinal_to_read < 3 {
6617 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6618 _next_ordinal_to_read += 1;
6619 next_offset += envelope_size;
6620 }
6621
6622 let next_out_of_line = decoder.next_out_of_line();
6623 let handles_before = decoder.remaining_handles();
6624 if let Some((inlined, num_bytes, num_handles)) =
6625 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6626 {
6627 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6628 if inlined != (member_inline_size <= 4) {
6629 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6630 }
6631 let inner_offset;
6632 let mut inner_depth = depth.clone();
6633 if inlined {
6634 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6635 inner_offset = next_offset;
6636 } else {
6637 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6638 inner_depth.increment()?;
6639 }
6640 let val_ref = self.path.get_or_insert_with(|| {
6641 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
6642 });
6643 fidl::decode!(
6644 fidl::encoding::BoundedString<4095>,
6645 D,
6646 val_ref,
6647 decoder,
6648 inner_offset,
6649 inner_depth
6650 )?;
6651 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6652 {
6653 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6654 }
6655 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6656 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6657 }
6658 }
6659
6660 next_offset += envelope_size;
6661 _next_ordinal_to_read += 1;
6662 if next_offset >= end_offset {
6663 return Ok(());
6664 }
6665
6666 while _next_ordinal_to_read < 4 {
6668 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6669 _next_ordinal_to_read += 1;
6670 next_offset += envelope_size;
6671 }
6672
6673 let next_out_of_line = decoder.next_out_of_line();
6674 let handles_before = decoder.remaining_handles();
6675 if let Some((inlined, num_bytes, num_handles)) =
6676 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6677 {
6678 let member_inline_size =
6679 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
6680 decoder.context,
6681 );
6682 if inlined != (member_inline_size <= 4) {
6683 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6684 }
6685 let inner_offset;
6686 let mut inner_depth = depth.clone();
6687 if inlined {
6688 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6689 inner_offset = next_offset;
6690 } else {
6691 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6692 inner_depth.increment()?;
6693 }
6694 let val_ref = self
6695 .from_dictionary
6696 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
6697 fidl::decode!(
6698 fidl::encoding::UnboundedString,
6699 D,
6700 val_ref,
6701 decoder,
6702 inner_offset,
6703 inner_depth
6704 )?;
6705 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6706 {
6707 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6708 }
6709 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6710 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6711 }
6712 }
6713
6714 next_offset += envelope_size;
6715
6716 while next_offset < end_offset {
6718 _next_ordinal_to_read += 1;
6719 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6720 next_offset += envelope_size;
6721 }
6722
6723 Ok(())
6724 }
6725 }
6726
6727 impl Service {
6728 #[inline(always)]
6729 fn max_ordinal_present(&self) -> u64 {
6730 if let Some(_) = self.from_dictionary {
6731 return 5;
6732 }
6733 if let Some(_) = self.availability {
6734 return 4;
6735 }
6736 if let Some(_) = self.path {
6737 return 3;
6738 }
6739 if let Some(_) = self.as_ {
6740 return 2;
6741 }
6742 if let Some(_) = self.name {
6743 return 1;
6744 }
6745 0
6746 }
6747 }
6748
6749 impl fidl::encoding::ValueTypeMarker for Service {
6750 type Borrowed<'a> = &'a Self;
6751 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6752 value
6753 }
6754 }
6755
6756 unsafe impl fidl::encoding::TypeMarker for Service {
6757 type Owned = Self;
6758
6759 #[inline(always)]
6760 fn inline_align(_context: fidl::encoding::Context) -> usize {
6761 8
6762 }
6763
6764 #[inline(always)]
6765 fn inline_size(_context: fidl::encoding::Context) -> usize {
6766 16
6767 }
6768 }
6769
6770 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Service, D> for &Service {
6771 unsafe fn encode(
6772 self,
6773 encoder: &mut fidl::encoding::Encoder<'_, D>,
6774 offset: usize,
6775 mut depth: fidl::encoding::Depth,
6776 ) -> fidl::Result<()> {
6777 encoder.debug_check_bounds::<Service>(offset);
6778 let max_ordinal: u64 = self.max_ordinal_present();
6780 encoder.write_num(max_ordinal, offset);
6781 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6782 if max_ordinal == 0 {
6784 return Ok(());
6785 }
6786 depth.increment()?;
6787 let envelope_size = 8;
6788 let bytes_len = max_ordinal as usize * envelope_size;
6789 #[allow(unused_variables)]
6790 let offset = encoder.out_of_line_offset(bytes_len);
6791 let mut _prev_end_offset: usize = 0;
6792 if 1 > max_ordinal {
6793 return Ok(());
6794 }
6795
6796 let cur_offset: usize = (1 - 1) * envelope_size;
6799
6800 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6802
6803 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6808 self.name.as_ref().map(
6809 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6810 ),
6811 encoder,
6812 offset + cur_offset,
6813 depth,
6814 )?;
6815
6816 _prev_end_offset = cur_offset + envelope_size;
6817 if 2 > max_ordinal {
6818 return Ok(());
6819 }
6820
6821 let cur_offset: usize = (2 - 1) * envelope_size;
6824
6825 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6827
6828 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6833 self.as_.as_ref().map(
6834 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6835 ),
6836 encoder,
6837 offset + cur_offset,
6838 depth,
6839 )?;
6840
6841 _prev_end_offset = cur_offset + envelope_size;
6842 if 3 > max_ordinal {
6843 return Ok(());
6844 }
6845
6846 let cur_offset: usize = (3 - 1) * envelope_size;
6849
6850 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6852
6853 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
6858 self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
6859 encoder, offset + cur_offset, depth
6860 )?;
6861
6862 _prev_end_offset = cur_offset + envelope_size;
6863 if 4 > max_ordinal {
6864 return Ok(());
6865 }
6866
6867 let cur_offset: usize = (4 - 1) * envelope_size;
6870
6871 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6873
6874 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
6879 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
6880 encoder, offset + cur_offset, depth
6881 )?;
6882
6883 _prev_end_offset = cur_offset + envelope_size;
6884 if 5 > max_ordinal {
6885 return Ok(());
6886 }
6887
6888 let cur_offset: usize = (5 - 1) * envelope_size;
6891
6892 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6894
6895 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
6900 self.from_dictionary.as_ref().map(
6901 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
6902 ),
6903 encoder,
6904 offset + cur_offset,
6905 depth,
6906 )?;
6907
6908 _prev_end_offset = cur_offset + envelope_size;
6909
6910 Ok(())
6911 }
6912 }
6913
6914 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Service {
6915 #[inline(always)]
6916 fn new_empty() -> Self {
6917 Self::default()
6918 }
6919
6920 unsafe fn decode(
6921 &mut self,
6922 decoder: &mut fidl::encoding::Decoder<'_, D>,
6923 offset: usize,
6924 mut depth: fidl::encoding::Depth,
6925 ) -> fidl::Result<()> {
6926 decoder.debug_check_bounds::<Self>(offset);
6927 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6928 None => return Err(fidl::Error::NotNullable),
6929 Some(len) => len,
6930 };
6931 if len == 0 {
6933 return Ok(());
6934 };
6935 depth.increment()?;
6936 let envelope_size = 8;
6937 let bytes_len = len * envelope_size;
6938 let offset = decoder.out_of_line_offset(bytes_len)?;
6939 let mut _next_ordinal_to_read = 0;
6941 let mut next_offset = offset;
6942 let end_offset = offset + bytes_len;
6943 _next_ordinal_to_read += 1;
6944 if next_offset >= end_offset {
6945 return Ok(());
6946 }
6947
6948 while _next_ordinal_to_read < 1 {
6950 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6951 _next_ordinal_to_read += 1;
6952 next_offset += envelope_size;
6953 }
6954
6955 let next_out_of_line = decoder.next_out_of_line();
6956 let handles_before = decoder.remaining_handles();
6957 if let Some((inlined, num_bytes, num_handles)) =
6958 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6959 {
6960 let member_inline_size =
6961 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6962 decoder.context,
6963 );
6964 if inlined != (member_inline_size <= 4) {
6965 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6966 }
6967 let inner_offset;
6968 let mut inner_depth = depth.clone();
6969 if inlined {
6970 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6971 inner_offset = next_offset;
6972 } else {
6973 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6974 inner_depth.increment()?;
6975 }
6976 let val_ref = self
6977 .name
6978 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6979 fidl::decode!(
6980 fidl::encoding::BoundedString<255>,
6981 D,
6982 val_ref,
6983 decoder,
6984 inner_offset,
6985 inner_depth
6986 )?;
6987 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6988 {
6989 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6990 }
6991 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6992 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6993 }
6994 }
6995
6996 next_offset += envelope_size;
6997 _next_ordinal_to_read += 1;
6998 if next_offset >= end_offset {
6999 return Ok(());
7000 }
7001
7002 while _next_ordinal_to_read < 2 {
7004 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7005 _next_ordinal_to_read += 1;
7006 next_offset += envelope_size;
7007 }
7008
7009 let next_out_of_line = decoder.next_out_of_line();
7010 let handles_before = decoder.remaining_handles();
7011 if let Some((inlined, num_bytes, num_handles)) =
7012 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7013 {
7014 let member_inline_size =
7015 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7016 decoder.context,
7017 );
7018 if inlined != (member_inline_size <= 4) {
7019 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7020 }
7021 let inner_offset;
7022 let mut inner_depth = depth.clone();
7023 if inlined {
7024 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7025 inner_offset = next_offset;
7026 } else {
7027 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7028 inner_depth.increment()?;
7029 }
7030 let val_ref = self
7031 .as_
7032 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7033 fidl::decode!(
7034 fidl::encoding::BoundedString<255>,
7035 D,
7036 val_ref,
7037 decoder,
7038 inner_offset,
7039 inner_depth
7040 )?;
7041 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7042 {
7043 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7044 }
7045 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7046 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7047 }
7048 }
7049
7050 next_offset += envelope_size;
7051 _next_ordinal_to_read += 1;
7052 if next_offset >= end_offset {
7053 return Ok(());
7054 }
7055
7056 while _next_ordinal_to_read < 3 {
7058 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7059 _next_ordinal_to_read += 1;
7060 next_offset += envelope_size;
7061 }
7062
7063 let next_out_of_line = decoder.next_out_of_line();
7064 let handles_before = decoder.remaining_handles();
7065 if let Some((inlined, num_bytes, num_handles)) =
7066 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7067 {
7068 let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7069 if inlined != (member_inline_size <= 4) {
7070 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7071 }
7072 let inner_offset;
7073 let mut inner_depth = depth.clone();
7074 if inlined {
7075 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7076 inner_offset = next_offset;
7077 } else {
7078 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7079 inner_depth.increment()?;
7080 }
7081 let val_ref = self.path.get_or_insert_with(|| {
7082 fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
7083 });
7084 fidl::decode!(
7085 fidl::encoding::BoundedString<4095>,
7086 D,
7087 val_ref,
7088 decoder,
7089 inner_offset,
7090 inner_depth
7091 )?;
7092 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7093 {
7094 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7095 }
7096 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7097 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7098 }
7099 }
7100
7101 next_offset += envelope_size;
7102 _next_ordinal_to_read += 1;
7103 if next_offset >= end_offset {
7104 return Ok(());
7105 }
7106
7107 while _next_ordinal_to_read < 4 {
7109 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7110 _next_ordinal_to_read += 1;
7111 next_offset += envelope_size;
7112 }
7113
7114 let next_out_of_line = decoder.next_out_of_line();
7115 let handles_before = decoder.remaining_handles();
7116 if let Some((inlined, num_bytes, num_handles)) =
7117 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7118 {
7119 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7120 if inlined != (member_inline_size <= 4) {
7121 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7122 }
7123 let inner_offset;
7124 let mut inner_depth = depth.clone();
7125 if inlined {
7126 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7127 inner_offset = next_offset;
7128 } else {
7129 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7130 inner_depth.increment()?;
7131 }
7132 let val_ref = self.availability.get_or_insert_with(|| {
7133 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
7134 });
7135 fidl::decode!(
7136 fidl_fuchsia_component_decl__common::Availability,
7137 D,
7138 val_ref,
7139 decoder,
7140 inner_offset,
7141 inner_depth
7142 )?;
7143 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7144 {
7145 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7146 }
7147 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7148 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7149 }
7150 }
7151
7152 next_offset += envelope_size;
7153 _next_ordinal_to_read += 1;
7154 if next_offset >= end_offset {
7155 return Ok(());
7156 }
7157
7158 while _next_ordinal_to_read < 5 {
7160 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7161 _next_ordinal_to_read += 1;
7162 next_offset += envelope_size;
7163 }
7164
7165 let next_out_of_line = decoder.next_out_of_line();
7166 let handles_before = decoder.remaining_handles();
7167 if let Some((inlined, num_bytes, num_handles)) =
7168 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7169 {
7170 let member_inline_size =
7171 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7172 decoder.context,
7173 );
7174 if inlined != (member_inline_size <= 4) {
7175 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7176 }
7177 let inner_offset;
7178 let mut inner_depth = depth.clone();
7179 if inlined {
7180 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7181 inner_offset = next_offset;
7182 } else {
7183 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7184 inner_depth.increment()?;
7185 }
7186 let val_ref = self
7187 .from_dictionary
7188 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7189 fidl::decode!(
7190 fidl::encoding::UnboundedString,
7191 D,
7192 val_ref,
7193 decoder,
7194 inner_offset,
7195 inner_depth
7196 )?;
7197 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7198 {
7199 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7200 }
7201 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7202 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7203 }
7204 }
7205
7206 next_offset += envelope_size;
7207
7208 while next_offset < end_offset {
7210 _next_ordinal_to_read += 1;
7211 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7212 next_offset += envelope_size;
7213 }
7214
7215 Ok(())
7216 }
7217 }
7218
7219 impl Storage {
7220 #[inline(always)]
7221 fn max_ordinal_present(&self) -> u64 {
7222 if let Some(_) = self.availability {
7223 return 4;
7224 }
7225 if let Some(_) = self.path {
7226 return 3;
7227 }
7228 if let Some(_) = self.as_ {
7229 return 2;
7230 }
7231 if let Some(_) = self.name {
7232 return 1;
7233 }
7234 0
7235 }
7236 }
7237
7238 impl fidl::encoding::ValueTypeMarker for Storage {
7239 type Borrowed<'a> = &'a Self;
7240 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7241 value
7242 }
7243 }
7244
7245 unsafe impl fidl::encoding::TypeMarker for Storage {
7246 type Owned = Self;
7247
7248 #[inline(always)]
7249 fn inline_align(_context: fidl::encoding::Context) -> usize {
7250 8
7251 }
7252
7253 #[inline(always)]
7254 fn inline_size(_context: fidl::encoding::Context) -> usize {
7255 16
7256 }
7257 }
7258
7259 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Storage, D> for &Storage {
7260 unsafe fn encode(
7261 self,
7262 encoder: &mut fidl::encoding::Encoder<'_, D>,
7263 offset: usize,
7264 mut depth: fidl::encoding::Depth,
7265 ) -> fidl::Result<()> {
7266 encoder.debug_check_bounds::<Storage>(offset);
7267 let max_ordinal: u64 = self.max_ordinal_present();
7269 encoder.write_num(max_ordinal, offset);
7270 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7271 if max_ordinal == 0 {
7273 return Ok(());
7274 }
7275 depth.increment()?;
7276 let envelope_size = 8;
7277 let bytes_len = max_ordinal as usize * envelope_size;
7278 #[allow(unused_variables)]
7279 let offset = encoder.out_of_line_offset(bytes_len);
7280 let mut _prev_end_offset: usize = 0;
7281 if 1 > max_ordinal {
7282 return Ok(());
7283 }
7284
7285 let cur_offset: usize = (1 - 1) * envelope_size;
7288
7289 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7291
7292 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
7297 self.name.as_ref().map(
7298 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
7299 ),
7300 encoder,
7301 offset + cur_offset,
7302 depth,
7303 )?;
7304
7305 _prev_end_offset = cur_offset + envelope_size;
7306 if 2 > max_ordinal {
7307 return Ok(());
7308 }
7309
7310 let cur_offset: usize = (2 - 1) * envelope_size;
7313
7314 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7316
7317 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
7322 self.as_.as_ref().map(
7323 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
7324 ),
7325 encoder,
7326 offset + cur_offset,
7327 depth,
7328 )?;
7329
7330 _prev_end_offset = cur_offset + envelope_size;
7331 if 3 > max_ordinal {
7332 return Ok(());
7333 }
7334
7335 let cur_offset: usize = (3 - 1) * envelope_size;
7338
7339 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7341
7342 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
7347 self.path.as_ref().map(
7348 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
7349 ),
7350 encoder,
7351 offset + cur_offset,
7352 depth,
7353 )?;
7354
7355 _prev_end_offset = cur_offset + envelope_size;
7356 if 4 > max_ordinal {
7357 return Ok(());
7358 }
7359
7360 let cur_offset: usize = (4 - 1) * envelope_size;
7363
7364 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7366
7367 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
7372 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
7373 encoder, offset + cur_offset, depth
7374 )?;
7375
7376 _prev_end_offset = cur_offset + envelope_size;
7377
7378 Ok(())
7379 }
7380 }
7381
7382 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Storage {
7383 #[inline(always)]
7384 fn new_empty() -> Self {
7385 Self::default()
7386 }
7387
7388 unsafe fn decode(
7389 &mut self,
7390 decoder: &mut fidl::encoding::Decoder<'_, D>,
7391 offset: usize,
7392 mut depth: fidl::encoding::Depth,
7393 ) -> fidl::Result<()> {
7394 decoder.debug_check_bounds::<Self>(offset);
7395 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7396 None => return Err(fidl::Error::NotNullable),
7397 Some(len) => len,
7398 };
7399 if len == 0 {
7401 return Ok(());
7402 };
7403 depth.increment()?;
7404 let envelope_size = 8;
7405 let bytes_len = len * envelope_size;
7406 let offset = decoder.out_of_line_offset(bytes_len)?;
7407 let mut _next_ordinal_to_read = 0;
7409 let mut next_offset = offset;
7410 let end_offset = offset + bytes_len;
7411 _next_ordinal_to_read += 1;
7412 if next_offset >= end_offset {
7413 return Ok(());
7414 }
7415
7416 while _next_ordinal_to_read < 1 {
7418 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7419 _next_ordinal_to_read += 1;
7420 next_offset += envelope_size;
7421 }
7422
7423 let next_out_of_line = decoder.next_out_of_line();
7424 let handles_before = decoder.remaining_handles();
7425 if let Some((inlined, num_bytes, num_handles)) =
7426 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7427 {
7428 let member_inline_size =
7429 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7430 decoder.context,
7431 );
7432 if inlined != (member_inline_size <= 4) {
7433 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7434 }
7435 let inner_offset;
7436 let mut inner_depth = depth.clone();
7437 if inlined {
7438 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7439 inner_offset = next_offset;
7440 } else {
7441 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7442 inner_depth.increment()?;
7443 }
7444 let val_ref = self
7445 .name
7446 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7447 fidl::decode!(
7448 fidl::encoding::BoundedString<255>,
7449 D,
7450 val_ref,
7451 decoder,
7452 inner_offset,
7453 inner_depth
7454 )?;
7455 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7456 {
7457 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7458 }
7459 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7460 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7461 }
7462 }
7463
7464 next_offset += envelope_size;
7465 _next_ordinal_to_read += 1;
7466 if next_offset >= end_offset {
7467 return Ok(());
7468 }
7469
7470 while _next_ordinal_to_read < 2 {
7472 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7473 _next_ordinal_to_read += 1;
7474 next_offset += envelope_size;
7475 }
7476
7477 let next_out_of_line = decoder.next_out_of_line();
7478 let handles_before = decoder.remaining_handles();
7479 if let Some((inlined, num_bytes, num_handles)) =
7480 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7481 {
7482 let member_inline_size =
7483 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7484 decoder.context,
7485 );
7486 if inlined != (member_inline_size <= 4) {
7487 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7488 }
7489 let inner_offset;
7490 let mut inner_depth = depth.clone();
7491 if inlined {
7492 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7493 inner_offset = next_offset;
7494 } else {
7495 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7496 inner_depth.increment()?;
7497 }
7498 let val_ref = self
7499 .as_
7500 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7501 fidl::decode!(
7502 fidl::encoding::BoundedString<255>,
7503 D,
7504 val_ref,
7505 decoder,
7506 inner_offset,
7507 inner_depth
7508 )?;
7509 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7510 {
7511 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7512 }
7513 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7514 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7515 }
7516 }
7517
7518 next_offset += envelope_size;
7519 _next_ordinal_to_read += 1;
7520 if next_offset >= end_offset {
7521 return Ok(());
7522 }
7523
7524 while _next_ordinal_to_read < 3 {
7526 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7527 _next_ordinal_to_read += 1;
7528 next_offset += envelope_size;
7529 }
7530
7531 let next_out_of_line = decoder.next_out_of_line();
7532 let handles_before = decoder.remaining_handles();
7533 if let Some((inlined, num_bytes, num_handles)) =
7534 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7535 {
7536 let member_inline_size =
7537 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7538 decoder.context,
7539 );
7540 if inlined != (member_inline_size <= 4) {
7541 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7542 }
7543 let inner_offset;
7544 let mut inner_depth = depth.clone();
7545 if inlined {
7546 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7547 inner_offset = next_offset;
7548 } else {
7549 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7550 inner_depth.increment()?;
7551 }
7552 let val_ref = self
7553 .path
7554 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7555 fidl::decode!(
7556 fidl::encoding::BoundedString<255>,
7557 D,
7558 val_ref,
7559 decoder,
7560 inner_offset,
7561 inner_depth
7562 )?;
7563 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7564 {
7565 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7566 }
7567 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7568 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7569 }
7570 }
7571
7572 next_offset += envelope_size;
7573 _next_ordinal_to_read += 1;
7574 if next_offset >= end_offset {
7575 return Ok(());
7576 }
7577
7578 while _next_ordinal_to_read < 4 {
7580 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7581 _next_ordinal_to_read += 1;
7582 next_offset += envelope_size;
7583 }
7584
7585 let next_out_of_line = decoder.next_out_of_line();
7586 let handles_before = decoder.remaining_handles();
7587 if let Some((inlined, num_bytes, num_handles)) =
7588 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7589 {
7590 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7591 if inlined != (member_inline_size <= 4) {
7592 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7593 }
7594 let inner_offset;
7595 let mut inner_depth = depth.clone();
7596 if inlined {
7597 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7598 inner_offset = next_offset;
7599 } else {
7600 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7601 inner_depth.increment()?;
7602 }
7603 let val_ref = self.availability.get_or_insert_with(|| {
7604 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
7605 });
7606 fidl::decode!(
7607 fidl_fuchsia_component_decl__common::Availability,
7608 D,
7609 val_ref,
7610 decoder,
7611 inner_offset,
7612 inner_depth
7613 )?;
7614 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7615 {
7616 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7617 }
7618 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7619 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7620 }
7621 }
7622
7623 next_offset += envelope_size;
7624
7625 while next_offset < end_offset {
7627 _next_ordinal_to_read += 1;
7628 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7629 next_offset += envelope_size;
7630 }
7631
7632 Ok(())
7633 }
7634 }
7635
7636 impl fidl::encoding::ValueTypeMarker for Capability {
7637 type Borrowed<'a> = &'a Self;
7638 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7639 value
7640 }
7641 }
7642
7643 unsafe impl fidl::encoding::TypeMarker for Capability {
7644 type Owned = Self;
7645
7646 #[inline(always)]
7647 fn inline_align(_context: fidl::encoding::Context) -> usize {
7648 8
7649 }
7650
7651 #[inline(always)]
7652 fn inline_size(_context: fidl::encoding::Context) -> usize {
7653 16
7654 }
7655 }
7656
7657 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Capability, D>
7658 for &Capability
7659 {
7660 #[inline]
7661 unsafe fn encode(
7662 self,
7663 encoder: &mut fidl::encoding::Encoder<'_, D>,
7664 offset: usize,
7665 _depth: fidl::encoding::Depth,
7666 ) -> fidl::Result<()> {
7667 encoder.debug_check_bounds::<Capability>(offset);
7668 encoder.write_num::<u64>(self.ordinal(), offset);
7669 match self {
7670 Capability::Protocol(ref val) => fidl::encoding::encode_in_envelope::<Protocol, D>(
7671 <Protocol as fidl::encoding::ValueTypeMarker>::borrow(val),
7672 encoder,
7673 offset + 8,
7674 _depth,
7675 ),
7676 Capability::Directory(ref val) => {
7677 fidl::encoding::encode_in_envelope::<Directory, D>(
7678 <Directory as fidl::encoding::ValueTypeMarker>::borrow(val),
7679 encoder,
7680 offset + 8,
7681 _depth,
7682 )
7683 }
7684 Capability::Storage(ref val) => fidl::encoding::encode_in_envelope::<Storage, D>(
7685 <Storage as fidl::encoding::ValueTypeMarker>::borrow(val),
7686 encoder,
7687 offset + 8,
7688 _depth,
7689 ),
7690 Capability::Service(ref val) => fidl::encoding::encode_in_envelope::<Service, D>(
7691 <Service as fidl::encoding::ValueTypeMarker>::borrow(val),
7692 encoder,
7693 offset + 8,
7694 _depth,
7695 ),
7696 Capability::EventStream(ref val) => {
7697 fidl::encoding::encode_in_envelope::<EventStream, D>(
7698 <EventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
7699 encoder,
7700 offset + 8,
7701 _depth,
7702 )
7703 }
7704 Capability::Config(ref val) => fidl::encoding::encode_in_envelope::<Config, D>(
7705 <Config as fidl::encoding::ValueTypeMarker>::borrow(val),
7706 encoder,
7707 offset + 8,
7708 _depth,
7709 ),
7710 Capability::Dictionary(ref val) => {
7711 fidl::encoding::encode_in_envelope::<Dictionary, D>(
7712 <Dictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
7713 encoder,
7714 offset + 8,
7715 _depth,
7716 )
7717 }
7718 Capability::Resolver(ref val) => fidl::encoding::encode_in_envelope::<Resolver, D>(
7719 <Resolver as fidl::encoding::ValueTypeMarker>::borrow(val),
7720 encoder,
7721 offset + 8,
7722 _depth,
7723 ),
7724 Capability::Runner(ref val) => fidl::encoding::encode_in_envelope::<Runner, D>(
7725 <Runner as fidl::encoding::ValueTypeMarker>::borrow(val),
7726 encoder,
7727 offset + 8,
7728 _depth,
7729 ),
7730 Capability::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
7731 }
7732 }
7733 }
7734
7735 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Capability {
7736 #[inline(always)]
7737 fn new_empty() -> Self {
7738 Self::__SourceBreaking { unknown_ordinal: 0 }
7739 }
7740
7741 #[inline]
7742 unsafe fn decode(
7743 &mut self,
7744 decoder: &mut fidl::encoding::Decoder<'_, D>,
7745 offset: usize,
7746 mut depth: fidl::encoding::Depth,
7747 ) -> fidl::Result<()> {
7748 decoder.debug_check_bounds::<Self>(offset);
7749 #[allow(unused_variables)]
7750 let next_out_of_line = decoder.next_out_of_line();
7751 let handles_before = decoder.remaining_handles();
7752 let (ordinal, inlined, num_bytes, num_handles) =
7753 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7754
7755 let member_inline_size = match ordinal {
7756 1 => <Protocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7757 2 => <Directory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7758 3 => <Storage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7759 4 => <Service as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7760 6 => <EventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7761 7 => <Config as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7762 8 => <Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7763 9 => <Resolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7764 10 => <Runner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7765 0 => return Err(fidl::Error::UnknownUnionTag),
7766 _ => num_bytes as usize,
7767 };
7768
7769 if inlined != (member_inline_size <= 4) {
7770 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7771 }
7772 let _inner_offset;
7773 if inlined {
7774 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7775 _inner_offset = offset + 8;
7776 } else {
7777 depth.increment()?;
7778 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7779 }
7780 match ordinal {
7781 1 => {
7782 #[allow(irrefutable_let_patterns)]
7783 if let Capability::Protocol(_) = self {
7784 } else {
7786 *self = Capability::Protocol(fidl::new_empty!(Protocol, D));
7788 }
7789 #[allow(irrefutable_let_patterns)]
7790 if let Capability::Protocol(ref mut val) = self {
7791 fidl::decode!(Protocol, D, val, decoder, _inner_offset, depth)?;
7792 } else {
7793 unreachable!()
7794 }
7795 }
7796 2 => {
7797 #[allow(irrefutable_let_patterns)]
7798 if let Capability::Directory(_) = self {
7799 } else {
7801 *self = Capability::Directory(fidl::new_empty!(Directory, D));
7803 }
7804 #[allow(irrefutable_let_patterns)]
7805 if let Capability::Directory(ref mut val) = self {
7806 fidl::decode!(Directory, D, val, decoder, _inner_offset, depth)?;
7807 } else {
7808 unreachable!()
7809 }
7810 }
7811 3 => {
7812 #[allow(irrefutable_let_patterns)]
7813 if let Capability::Storage(_) = self {
7814 } else {
7816 *self = Capability::Storage(fidl::new_empty!(Storage, D));
7818 }
7819 #[allow(irrefutable_let_patterns)]
7820 if let Capability::Storage(ref mut val) = self {
7821 fidl::decode!(Storage, D, val, decoder, _inner_offset, depth)?;
7822 } else {
7823 unreachable!()
7824 }
7825 }
7826 4 => {
7827 #[allow(irrefutable_let_patterns)]
7828 if let Capability::Service(_) = self {
7829 } else {
7831 *self = Capability::Service(fidl::new_empty!(Service, D));
7833 }
7834 #[allow(irrefutable_let_patterns)]
7835 if let Capability::Service(ref mut val) = self {
7836 fidl::decode!(Service, D, val, decoder, _inner_offset, depth)?;
7837 } else {
7838 unreachable!()
7839 }
7840 }
7841 6 => {
7842 #[allow(irrefutable_let_patterns)]
7843 if let Capability::EventStream(_) = self {
7844 } else {
7846 *self = Capability::EventStream(fidl::new_empty!(EventStream, D));
7848 }
7849 #[allow(irrefutable_let_patterns)]
7850 if let Capability::EventStream(ref mut val) = self {
7851 fidl::decode!(EventStream, D, val, decoder, _inner_offset, depth)?;
7852 } else {
7853 unreachable!()
7854 }
7855 }
7856 7 => {
7857 #[allow(irrefutable_let_patterns)]
7858 if let Capability::Config(_) = self {
7859 } else {
7861 *self = Capability::Config(fidl::new_empty!(Config, D));
7863 }
7864 #[allow(irrefutable_let_patterns)]
7865 if let Capability::Config(ref mut val) = self {
7866 fidl::decode!(Config, D, val, decoder, _inner_offset, depth)?;
7867 } else {
7868 unreachable!()
7869 }
7870 }
7871 8 => {
7872 #[allow(irrefutable_let_patterns)]
7873 if let Capability::Dictionary(_) = self {
7874 } else {
7876 *self = Capability::Dictionary(fidl::new_empty!(Dictionary, D));
7878 }
7879 #[allow(irrefutable_let_patterns)]
7880 if let Capability::Dictionary(ref mut val) = self {
7881 fidl::decode!(Dictionary, D, val, decoder, _inner_offset, depth)?;
7882 } else {
7883 unreachable!()
7884 }
7885 }
7886 9 => {
7887 #[allow(irrefutable_let_patterns)]
7888 if let Capability::Resolver(_) = self {
7889 } else {
7891 *self = Capability::Resolver(fidl::new_empty!(Resolver, D));
7893 }
7894 #[allow(irrefutable_let_patterns)]
7895 if let Capability::Resolver(ref mut val) = self {
7896 fidl::decode!(Resolver, D, val, decoder, _inner_offset, depth)?;
7897 } else {
7898 unreachable!()
7899 }
7900 }
7901 10 => {
7902 #[allow(irrefutable_let_patterns)]
7903 if let Capability::Runner(_) = self {
7904 } else {
7906 *self = Capability::Runner(fidl::new_empty!(Runner, D));
7908 }
7909 #[allow(irrefutable_let_patterns)]
7910 if let Capability::Runner(ref mut val) = self {
7911 fidl::decode!(Runner, D, val, decoder, _inner_offset, depth)?;
7912 } else {
7913 unreachable!()
7914 }
7915 }
7916 #[allow(deprecated)]
7917 ordinal => {
7918 for _ in 0..num_handles {
7919 decoder.drop_next_handle()?;
7920 }
7921 *self = Capability::__SourceBreaking { unknown_ordinal: ordinal };
7922 }
7923 }
7924 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
7925 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7926 }
7927 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7928 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7929 }
7930 Ok(())
7931 }
7932 }
7933}