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 MAX_INSTANCE_ID_LENGTH: u32 = 64;
15
16pub const MAX_START_REASON: u32 = 5000;
20
21pub const MAX_STORAGE_ID_LENGTH: u32 = 64;
25
26#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
28pub enum ConfigOverrideError {
29 InstanceNotFound,
31 BadMoniker,
33 InstanceNotResolved,
35 NoConfig,
37 KeyNotFound,
39 #[doc(hidden)]
40 __SourceBreaking { unknown_ordinal: u32 },
41}
42
43#[macro_export]
45macro_rules! ConfigOverrideErrorUnknown {
46 () => {
47 _
48 };
49}
50
51impl ConfigOverrideError {
52 #[inline]
53 pub fn from_primitive(prim: u32) -> Option<Self> {
54 match prim {
55 1 => Some(Self::InstanceNotFound),
56 2 => Some(Self::BadMoniker),
57 3 => Some(Self::InstanceNotResolved),
58 4 => Some(Self::NoConfig),
59 5 => Some(Self::KeyNotFound),
60 _ => None,
61 }
62 }
63
64 #[inline]
65 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
66 match prim {
67 1 => Self::InstanceNotFound,
68 2 => Self::BadMoniker,
69 3 => Self::InstanceNotResolved,
70 4 => Self::NoConfig,
71 5 => Self::KeyNotFound,
72 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
73 }
74 }
75
76 #[inline]
77 pub fn unknown() -> Self {
78 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
79 }
80
81 #[inline]
82 pub const fn into_primitive(self) -> u32 {
83 match self {
84 Self::InstanceNotFound => 1,
85 Self::BadMoniker => 2,
86 Self::InstanceNotResolved => 3,
87 Self::NoConfig => 4,
88 Self::KeyNotFound => 5,
89 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
90 }
91 }
92
93 #[inline]
94 pub fn is_unknown(&self) -> bool {
95 match self {
96 Self::__SourceBreaking { unknown_ordinal: _ } => true,
97 _ => false,
98 }
99 }
100}
101
102#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
104pub enum ConnectToStorageAdminError {
105 InstanceNotFound,
107 BadMoniker,
109 StorageNotFound,
111 InstanceNotResolved,
113 BadCapability,
115 #[doc(hidden)]
116 __SourceBreaking { unknown_ordinal: u32 },
117}
118
119#[macro_export]
121macro_rules! ConnectToStorageAdminErrorUnknown {
122 () => {
123 _
124 };
125}
126
127impl ConnectToStorageAdminError {
128 #[inline]
129 pub fn from_primitive(prim: u32) -> Option<Self> {
130 match prim {
131 1 => Some(Self::InstanceNotFound),
132 2 => Some(Self::BadMoniker),
133 3 => Some(Self::StorageNotFound),
134 4 => Some(Self::InstanceNotResolved),
135 5 => Some(Self::BadCapability),
136 _ => None,
137 }
138 }
139
140 #[inline]
141 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
142 match prim {
143 1 => Self::InstanceNotFound,
144 2 => Self::BadMoniker,
145 3 => Self::StorageNotFound,
146 4 => Self::InstanceNotResolved,
147 5 => Self::BadCapability,
148 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
149 }
150 }
151
152 #[inline]
153 pub fn unknown() -> Self {
154 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
155 }
156
157 #[inline]
158 pub const fn into_primitive(self) -> u32 {
159 match self {
160 Self::InstanceNotFound => 1,
161 Self::BadMoniker => 2,
162 Self::StorageNotFound => 3,
163 Self::InstanceNotResolved => 4,
164 Self::BadCapability => 5,
165 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
166 }
167 }
168
169 #[inline]
170 pub fn is_unknown(&self) -> bool {
171 match self {
172 Self::__SourceBreaking { unknown_ordinal: _ } => true,
173 _ => false,
174 }
175 }
176}
177
178#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
180pub enum ConstructNamespaceError {
181 InstanceNotFound,
183 BadMoniker,
185 InstanceNotResolved,
187 #[doc(hidden)]
188 __SourceBreaking { unknown_ordinal: u32 },
189}
190
191#[macro_export]
193macro_rules! ConstructNamespaceErrorUnknown {
194 () => {
195 _
196 };
197}
198
199impl ConstructNamespaceError {
200 #[inline]
201 pub fn from_primitive(prim: u32) -> Option<Self> {
202 match prim {
203 1 => Some(Self::InstanceNotFound),
204 2 => Some(Self::BadMoniker),
205 3 => Some(Self::InstanceNotResolved),
206 _ => None,
207 }
208 }
209
210 #[inline]
211 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
212 match prim {
213 1 => Self::InstanceNotFound,
214 2 => Self::BadMoniker,
215 3 => Self::InstanceNotResolved,
216 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
217 }
218 }
219
220 #[inline]
221 pub fn unknown() -> Self {
222 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
223 }
224
225 #[inline]
226 pub const fn into_primitive(self) -> u32 {
227 match self {
228 Self::InstanceNotFound => 1,
229 Self::BadMoniker => 2,
230 Self::InstanceNotResolved => 3,
231 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
232 }
233 }
234
235 #[inline]
236 pub fn is_unknown(&self) -> bool {
237 match self {
238 Self::__SourceBreaking { unknown_ordinal: _ } => true,
239 _ => false,
240 }
241 }
242}
243
244#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
245pub enum CreateError {
246 Internal,
247 InstanceNotFound,
248 InstanceAlreadyExists,
249 BadMoniker,
250 BadChildDecl,
251 CollectionNotFound,
252 BadDynamicOffer,
253 DynamicOffersForbidden,
254 EagerStartupForbidden,
255 NumberedHandlesForbidden,
256 #[doc(hidden)]
257 __SourceBreaking {
258 unknown_ordinal: u32,
259 },
260}
261
262#[macro_export]
264macro_rules! CreateErrorUnknown {
265 () => {
266 _
267 };
268}
269
270impl CreateError {
271 #[inline]
272 pub fn from_primitive(prim: u32) -> Option<Self> {
273 match prim {
274 1 => Some(Self::Internal),
275 2 => Some(Self::InstanceNotFound),
276 3 => Some(Self::InstanceAlreadyExists),
277 4 => Some(Self::BadMoniker),
278 5 => Some(Self::BadChildDecl),
279 6 => Some(Self::CollectionNotFound),
280 7 => Some(Self::BadDynamicOffer),
281 8 => Some(Self::DynamicOffersForbidden),
282 9 => Some(Self::EagerStartupForbidden),
283 10 => Some(Self::NumberedHandlesForbidden),
284 _ => None,
285 }
286 }
287
288 #[inline]
289 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
290 match prim {
291 1 => Self::Internal,
292 2 => Self::InstanceNotFound,
293 3 => Self::InstanceAlreadyExists,
294 4 => Self::BadMoniker,
295 5 => Self::BadChildDecl,
296 6 => Self::CollectionNotFound,
297 7 => Self::BadDynamicOffer,
298 8 => Self::DynamicOffersForbidden,
299 9 => Self::EagerStartupForbidden,
300 10 => Self::NumberedHandlesForbidden,
301 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
302 }
303 }
304
305 #[inline]
306 pub fn unknown() -> Self {
307 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
308 }
309
310 #[inline]
311 pub const fn into_primitive(self) -> u32 {
312 match self {
313 Self::Internal => 1,
314 Self::InstanceNotFound => 2,
315 Self::InstanceAlreadyExists => 3,
316 Self::BadMoniker => 4,
317 Self::BadChildDecl => 5,
318 Self::CollectionNotFound => 6,
319 Self::BadDynamicOffer => 7,
320 Self::DynamicOffersForbidden => 8,
321 Self::EagerStartupForbidden => 9,
322 Self::NumberedHandlesForbidden => 10,
323 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
324 }
325 }
326
327 #[inline]
328 pub fn is_unknown(&self) -> bool {
329 match self {
330 Self::__SourceBreaking { unknown_ordinal: _ } => true,
331 _ => false,
332 }
333 }
334}
335
336#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
337pub enum DeclType {
338 Use,
341 Expose,
343 Any,
346 #[doc(hidden)]
347 __SourceBreaking { unknown_ordinal: u32 },
348}
349
350#[macro_export]
352macro_rules! DeclTypeUnknown {
353 () => {
354 _
355 };
356}
357
358impl DeclType {
359 #[inline]
360 pub fn from_primitive(prim: u32) -> Option<Self> {
361 match prim {
362 1 => Some(Self::Use),
363 2 => Some(Self::Expose),
364 3 => Some(Self::Any),
365 _ => None,
366 }
367 }
368
369 #[inline]
370 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
371 match prim {
372 1 => Self::Use,
373 2 => Self::Expose,
374 3 => Self::Any,
375 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
376 }
377 }
378
379 #[inline]
380 pub fn unknown() -> Self {
381 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
382 }
383
384 #[inline]
385 pub const fn into_primitive(self) -> u32 {
386 match self {
387 Self::Use => 1,
388 Self::Expose => 2,
389 Self::Any => 3,
390 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
391 }
392 }
393
394 #[inline]
395 pub fn is_unknown(&self) -> bool {
396 match self {
397 Self::__SourceBreaking { unknown_ordinal: _ } => true,
398 _ => false,
399 }
400 }
401}
402
403#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
404#[repr(u32)]
405pub enum DeletionError {
406 Connection = 1,
408 Protocol = 2,
411 NoneAvailable = 3,
413 Unsupported = 4,
415}
416
417impl DeletionError {
418 #[inline]
419 pub fn from_primitive(prim: u32) -> Option<Self> {
420 match prim {
421 1 => Some(Self::Connection),
422 2 => Some(Self::Protocol),
423 3 => Some(Self::NoneAvailable),
424 4 => Some(Self::Unsupported),
425 _ => None,
426 }
427 }
428
429 #[inline]
430 pub const fn into_primitive(self) -> u32 {
431 self as u32
432 }
433}
434
435#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
436pub enum DestroyError {
437 Internal,
438 InstanceNotFound,
439 BadMoniker,
440 BadChildRef,
441 InstanceNotResolved,
442 #[doc(hidden)]
443 __SourceBreaking {
444 unknown_ordinal: u32,
445 },
446}
447
448#[macro_export]
450macro_rules! DestroyErrorUnknown {
451 () => {
452 _
453 };
454}
455
456impl DestroyError {
457 #[inline]
458 pub fn from_primitive(prim: u32) -> Option<Self> {
459 match prim {
460 1 => Some(Self::Internal),
461 2 => Some(Self::InstanceNotFound),
462 3 => Some(Self::BadMoniker),
463 4 => Some(Self::BadChildRef),
464 5 => Some(Self::InstanceNotResolved),
465 _ => None,
466 }
467 }
468
469 #[inline]
470 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
471 match prim {
472 1 => Self::Internal,
473 2 => Self::InstanceNotFound,
474 3 => Self::BadMoniker,
475 4 => Self::BadChildRef,
476 5 => Self::InstanceNotResolved,
477 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
478 }
479 }
480
481 #[inline]
482 pub fn unknown() -> Self {
483 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
484 }
485
486 #[inline]
487 pub const fn into_primitive(self) -> u32 {
488 match self {
489 Self::Internal => 1,
490 Self::InstanceNotFound => 2,
491 Self::BadMoniker => 3,
492 Self::BadChildRef => 4,
493 Self::InstanceNotResolved => 5,
494 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
495 }
496 }
497
498 #[inline]
499 pub fn is_unknown(&self) -> bool {
500 match self {
501 Self::__SourceBreaking { unknown_ordinal: _ } => true,
502 _ => false,
503 }
504 }
505}
506
507#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
509pub enum GetAllInstancesError {
510 InstanceNotFound,
512 #[doc(hidden)]
513 __SourceBreaking { unknown_ordinal: u32 },
514}
515
516#[macro_export]
518macro_rules! GetAllInstancesErrorUnknown {
519 () => {
520 _
521 };
522}
523
524impl GetAllInstancesError {
525 #[inline]
526 pub fn from_primitive(prim: u32) -> Option<Self> {
527 match prim {
528 1 => Some(Self::InstanceNotFound),
529 _ => None,
530 }
531 }
532
533 #[inline]
534 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
535 match prim {
536 1 => Self::InstanceNotFound,
537 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
538 }
539 }
540
541 #[inline]
542 pub fn unknown() -> Self {
543 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
544 }
545
546 #[inline]
547 pub const fn into_primitive(self) -> u32 {
548 match self {
549 Self::InstanceNotFound => 1,
550 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
551 }
552 }
553
554 #[inline]
555 pub fn is_unknown(&self) -> bool {
556 match self {
557 Self::__SourceBreaking { unknown_ordinal: _ } => true,
558 _ => false,
559 }
560 }
561}
562
563#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
565pub enum GetDeclarationError {
566 InstanceNotFound,
568 BadMoniker,
570 InstanceNotResolved,
572 EncodeFailed,
574 BadChildLocation,
576 BadUrl,
578 #[doc(hidden)]
579 __SourceBreaking { unknown_ordinal: u32 },
580}
581
582#[macro_export]
584macro_rules! GetDeclarationErrorUnknown {
585 () => {
586 _
587 };
588}
589
590impl GetDeclarationError {
591 #[inline]
592 pub fn from_primitive(prim: u32) -> Option<Self> {
593 match prim {
594 1 => Some(Self::InstanceNotFound),
595 2 => Some(Self::BadMoniker),
596 3 => Some(Self::InstanceNotResolved),
597 4 => Some(Self::EncodeFailed),
598 5 => Some(Self::BadChildLocation),
599 6 => Some(Self::BadUrl),
600 _ => None,
601 }
602 }
603
604 #[inline]
605 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
606 match prim {
607 1 => Self::InstanceNotFound,
608 2 => Self::BadMoniker,
609 3 => Self::InstanceNotResolved,
610 4 => Self::EncodeFailed,
611 5 => Self::BadChildLocation,
612 6 => Self::BadUrl,
613 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
614 }
615 }
616
617 #[inline]
618 pub fn unknown() -> Self {
619 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
620 }
621
622 #[inline]
623 pub const fn into_primitive(self) -> u32 {
624 match self {
625 Self::InstanceNotFound => 1,
626 Self::BadMoniker => 2,
627 Self::InstanceNotResolved => 3,
628 Self::EncodeFailed => 4,
629 Self::BadChildLocation => 5,
630 Self::BadUrl => 6,
631 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
632 }
633 }
634
635 #[inline]
636 pub fn is_unknown(&self) -> bool {
637 match self {
638 Self::__SourceBreaking { unknown_ordinal: _ } => true,
639 _ => false,
640 }
641 }
642}
643
644#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
646pub enum GetInstanceError {
647 InstanceNotFound,
649 BadMoniker,
651 #[doc(hidden)]
652 __SourceBreaking { unknown_ordinal: u32 },
653}
654
655#[macro_export]
657macro_rules! GetInstanceErrorUnknown {
658 () => {
659 _
660 };
661}
662
663impl GetInstanceError {
664 #[inline]
665 pub fn from_primitive(prim: u32) -> Option<Self> {
666 match prim {
667 1 => Some(Self::InstanceNotFound),
668 2 => Some(Self::BadMoniker),
669 _ => None,
670 }
671 }
672
673 #[inline]
674 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
675 match prim {
676 1 => Self::InstanceNotFound,
677 2 => Self::BadMoniker,
678 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
679 }
680 }
681
682 #[inline]
683 pub fn unknown() -> Self {
684 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
685 }
686
687 #[inline]
688 pub const fn into_primitive(self) -> u32 {
689 match self {
690 Self::InstanceNotFound => 1,
691 Self::BadMoniker => 2,
692 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
693 }
694 }
695
696 #[inline]
697 pub fn is_unknown(&self) -> bool {
698 match self {
699 Self::__SourceBreaking { unknown_ordinal: _ } => true,
700 _ => false,
701 }
702 }
703}
704
705#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
707pub enum GetStructuredConfigError {
708 InstanceNotFound,
710 BadMoniker,
712 InstanceNotResolved,
714 NoConfig,
716 #[doc(hidden)]
717 __SourceBreaking { unknown_ordinal: u32 },
718}
719
720#[macro_export]
722macro_rules! GetStructuredConfigErrorUnknown {
723 () => {
724 _
725 };
726}
727
728impl GetStructuredConfigError {
729 #[inline]
730 pub fn from_primitive(prim: u32) -> Option<Self> {
731 match prim {
732 1 => Some(Self::InstanceNotFound),
733 2 => Some(Self::BadMoniker),
734 3 => Some(Self::InstanceNotResolved),
735 4 => Some(Self::NoConfig),
736 _ => None,
737 }
738 }
739
740 #[inline]
741 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
742 match prim {
743 1 => Self::InstanceNotFound,
744 2 => Self::BadMoniker,
745 3 => Self::InstanceNotResolved,
746 4 => Self::NoConfig,
747 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
748 }
749 }
750
751 #[inline]
752 pub fn unknown() -> Self {
753 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
754 }
755
756 #[inline]
757 pub const fn into_primitive(self) -> u32 {
758 match self {
759 Self::InstanceNotFound => 1,
760 Self::BadMoniker => 2,
761 Self::InstanceNotResolved => 3,
762 Self::NoConfig => 4,
763 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
764 }
765 }
766
767 #[inline]
768 pub fn is_unknown(&self) -> bool {
769 match self {
770 Self::__SourceBreaking { unknown_ordinal: _ } => true,
771 _ => false,
772 }
773 }
774}
775
776#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
778pub enum OpenDirType {
779 OutgoingDir,
781 RuntimeDir,
783 PackageDir,
785 ExposedDir,
787 NamespaceDir,
789 #[doc(hidden)]
790 __SourceBreaking { unknown_ordinal: u32 },
791}
792
793#[macro_export]
795macro_rules! OpenDirTypeUnknown {
796 () => {
797 _
798 };
799}
800
801impl OpenDirType {
802 #[inline]
803 pub fn from_primitive(prim: u32) -> Option<Self> {
804 match prim {
805 1 => Some(Self::OutgoingDir),
806 2 => Some(Self::RuntimeDir),
807 3 => Some(Self::PackageDir),
808 4 => Some(Self::ExposedDir),
809 5 => Some(Self::NamespaceDir),
810 _ => None,
811 }
812 }
813
814 #[inline]
815 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
816 match prim {
817 1 => Self::OutgoingDir,
818 2 => Self::RuntimeDir,
819 3 => Self::PackageDir,
820 4 => Self::ExposedDir,
821 5 => Self::NamespaceDir,
822 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
823 }
824 }
825
826 #[inline]
827 pub fn unknown() -> Self {
828 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
829 }
830
831 #[inline]
832 pub const fn into_primitive(self) -> u32 {
833 match self {
834 Self::OutgoingDir => 1,
835 Self::RuntimeDir => 2,
836 Self::PackageDir => 3,
837 Self::ExposedDir => 4,
838 Self::NamespaceDir => 5,
839 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
840 }
841 }
842
843 #[inline]
844 pub fn is_unknown(&self) -> bool {
845 match self {
846 Self::__SourceBreaking { unknown_ordinal: _ } => true,
847 _ => false,
848 }
849 }
850}
851
852#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
854pub enum OpenError {
855 InstanceNotFound,
857 BadMoniker,
859 InstanceNotResolved,
861 InstanceNotRunning,
866 FidlError,
868 NoSuchDir,
870 BadDirType,
872 BadPath,
874 InstanceFailedToStart,
877 InstanceDestroyed,
879 #[doc(hidden)]
880 __SourceBreaking { unknown_ordinal: u32 },
881}
882
883#[macro_export]
885macro_rules! OpenErrorUnknown {
886 () => {
887 _
888 };
889}
890
891impl OpenError {
892 #[inline]
893 pub fn from_primitive(prim: u32) -> Option<Self> {
894 match prim {
895 1 => Some(Self::InstanceNotFound),
896 2 => Some(Self::BadMoniker),
897 3 => Some(Self::InstanceNotResolved),
898 4 => Some(Self::InstanceNotRunning),
899 5 => Some(Self::FidlError),
900 6 => Some(Self::NoSuchDir),
901 7 => Some(Self::BadDirType),
902 8 => Some(Self::BadPath),
903 9 => Some(Self::InstanceFailedToStart),
904 10 => Some(Self::InstanceDestroyed),
905 _ => None,
906 }
907 }
908
909 #[inline]
910 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
911 match prim {
912 1 => Self::InstanceNotFound,
913 2 => Self::BadMoniker,
914 3 => Self::InstanceNotResolved,
915 4 => Self::InstanceNotRunning,
916 5 => Self::FidlError,
917 6 => Self::NoSuchDir,
918 7 => Self::BadDirType,
919 8 => Self::BadPath,
920 9 => Self::InstanceFailedToStart,
921 10 => Self::InstanceDestroyed,
922 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
923 }
924 }
925
926 #[inline]
927 pub fn unknown() -> Self {
928 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
929 }
930
931 #[inline]
932 pub const fn into_primitive(self) -> u32 {
933 match self {
934 Self::InstanceNotFound => 1,
935 Self::BadMoniker => 2,
936 Self::InstanceNotResolved => 3,
937 Self::InstanceNotRunning => 4,
938 Self::FidlError => 5,
939 Self::NoSuchDir => 6,
940 Self::BadDirType => 7,
941 Self::BadPath => 8,
942 Self::InstanceFailedToStart => 9,
943 Self::InstanceDestroyed => 10,
944 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
945 }
946 }
947
948 #[inline]
949 pub fn is_unknown(&self) -> bool {
950 match self {
951 Self::__SourceBreaking { unknown_ordinal: _ } => true,
952 _ => false,
953 }
954 }
955}
956
957#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
959pub enum RealmQueryError {
960 InstanceNotFound,
962 BadMoniker,
964 #[doc(hidden)]
965 __SourceBreaking { unknown_ordinal: u32 },
966}
967
968#[macro_export]
970macro_rules! RealmQueryErrorUnknown {
971 () => {
972 _
973 };
974}
975
976impl RealmQueryError {
977 #[inline]
978 pub fn from_primitive(prim: u32) -> Option<Self> {
979 match prim {
980 1 => Some(Self::InstanceNotFound),
981 2 => Some(Self::BadMoniker),
982 _ => None,
983 }
984 }
985
986 #[inline]
987 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
988 match prim {
989 1 => Self::InstanceNotFound,
990 2 => Self::BadMoniker,
991 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
992 }
993 }
994
995 #[inline]
996 pub fn unknown() -> Self {
997 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
998 }
999
1000 #[inline]
1001 pub const fn into_primitive(self) -> u32 {
1002 match self {
1003 Self::InstanceNotFound => 1,
1004 Self::BadMoniker => 2,
1005 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1006 }
1007 }
1008
1009 #[inline]
1010 pub fn is_unknown(&self) -> bool {
1011 match self {
1012 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1013 _ => false,
1014 }
1015 }
1016}
1017
1018#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1019pub enum ResolveError {
1020 Internal,
1021 InstanceNotFound,
1022 BadMoniker,
1023 PackageNotFound,
1024 ManifestNotFound,
1025 PolicyError,
1026 #[doc(hidden)]
1027 __SourceBreaking {
1028 unknown_ordinal: u32,
1029 },
1030}
1031
1032#[macro_export]
1034macro_rules! ResolveErrorUnknown {
1035 () => {
1036 _
1037 };
1038}
1039
1040impl ResolveError {
1041 #[inline]
1042 pub fn from_primitive(prim: u32) -> Option<Self> {
1043 match prim {
1044 1 => Some(Self::Internal),
1045 2 => Some(Self::InstanceNotFound),
1046 3 => Some(Self::BadMoniker),
1047 4 => Some(Self::PackageNotFound),
1048 5 => Some(Self::ManifestNotFound),
1049 6 => Some(Self::PolicyError),
1050 _ => None,
1051 }
1052 }
1053
1054 #[inline]
1055 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1056 match prim {
1057 1 => Self::Internal,
1058 2 => Self::InstanceNotFound,
1059 3 => Self::BadMoniker,
1060 4 => Self::PackageNotFound,
1061 5 => Self::ManifestNotFound,
1062 6 => Self::PolicyError,
1063 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1064 }
1065 }
1066
1067 #[inline]
1068 pub fn unknown() -> Self {
1069 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1070 }
1071
1072 #[inline]
1073 pub const fn into_primitive(self) -> u32 {
1074 match self {
1075 Self::Internal => 1,
1076 Self::InstanceNotFound => 2,
1077 Self::BadMoniker => 3,
1078 Self::PackageNotFound => 4,
1079 Self::ManifestNotFound => 5,
1080 Self::PolicyError => 6,
1081 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1082 }
1083 }
1084
1085 #[inline]
1086 pub fn is_unknown(&self) -> bool {
1087 match self {
1088 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1089 _ => false,
1090 }
1091 }
1092}
1093
1094#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1095pub enum RouteOutcome {
1096 Success,
1098 Void,
1101 Failed,
1103 #[doc(hidden)]
1104 __SourceBreaking { unknown_ordinal: u32 },
1105}
1106
1107#[macro_export]
1109macro_rules! RouteOutcomeUnknown {
1110 () => {
1111 _
1112 };
1113}
1114
1115impl RouteOutcome {
1116 #[inline]
1117 pub fn from_primitive(prim: u32) -> Option<Self> {
1118 match prim {
1119 1 => Some(Self::Success),
1120 2 => Some(Self::Void),
1121 3 => Some(Self::Failed),
1122 _ => None,
1123 }
1124 }
1125
1126 #[inline]
1127 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1128 match prim {
1129 1 => Self::Success,
1130 2 => Self::Void,
1131 3 => Self::Failed,
1132 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1133 }
1134 }
1135
1136 #[inline]
1137 pub fn unknown() -> Self {
1138 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1139 }
1140
1141 #[inline]
1142 pub const fn into_primitive(self) -> u32 {
1143 match self {
1144 Self::Success => 1,
1145 Self::Void => 2,
1146 Self::Failed => 3,
1147 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1148 }
1149 }
1150
1151 #[inline]
1152 pub fn is_unknown(&self) -> bool {
1153 match self {
1154 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1155 _ => false,
1156 }
1157 }
1158}
1159
1160#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1162pub enum RouteValidatorError {
1163 Internal,
1165 InvalidArguments,
1167 InstanceNotFound,
1169 InstanceNotResolved,
1171 #[doc(hidden)]
1172 __SourceBreaking { unknown_ordinal: u32 },
1173}
1174
1175#[macro_export]
1177macro_rules! RouteValidatorErrorUnknown {
1178 () => {
1179 _
1180 };
1181}
1182
1183impl RouteValidatorError {
1184 #[inline]
1185 pub fn from_primitive(prim: u32) -> Option<Self> {
1186 match prim {
1187 1 => Some(Self::Internal),
1188 2 => Some(Self::InvalidArguments),
1189 3 => Some(Self::InstanceNotFound),
1190 4 => Some(Self::InstanceNotResolved),
1191 _ => None,
1192 }
1193 }
1194
1195 #[inline]
1196 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1197 match prim {
1198 1 => Self::Internal,
1199 2 => Self::InvalidArguments,
1200 3 => Self::InstanceNotFound,
1201 4 => Self::InstanceNotResolved,
1202 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1203 }
1204 }
1205
1206 #[inline]
1207 pub fn unknown() -> Self {
1208 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1209 }
1210
1211 #[inline]
1212 pub const fn into_primitive(self) -> u32 {
1213 match self {
1214 Self::Internal => 1,
1215 Self::InvalidArguments => 2,
1216 Self::InstanceNotFound => 3,
1217 Self::InstanceNotResolved => 4,
1218 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1219 }
1220 }
1221
1222 #[inline]
1223 pub fn is_unknown(&self) -> bool {
1224 match self {
1225 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1226 _ => false,
1227 }
1228 }
1229}
1230
1231#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1232pub enum StartError {
1233 Internal,
1234 InstanceNotFound,
1235 BadMoniker,
1236 PackageNotFound,
1237 ManifestNotFound,
1238 PolicyError,
1239 InvalidArguments,
1240 #[doc(hidden)]
1241 __SourceBreaking {
1242 unknown_ordinal: u32,
1243 },
1244}
1245
1246#[macro_export]
1248macro_rules! StartErrorUnknown {
1249 () => {
1250 _
1251 };
1252}
1253
1254impl StartError {
1255 #[inline]
1256 pub fn from_primitive(prim: u32) -> Option<Self> {
1257 match prim {
1258 1 => Some(Self::Internal),
1259 2 => Some(Self::InstanceNotFound),
1260 3 => Some(Self::BadMoniker),
1261 4 => Some(Self::PackageNotFound),
1262 5 => Some(Self::ManifestNotFound),
1263 6 => Some(Self::PolicyError),
1264 7 => Some(Self::InvalidArguments),
1265 _ => None,
1266 }
1267 }
1268
1269 #[inline]
1270 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1271 match prim {
1272 1 => Self::Internal,
1273 2 => Self::InstanceNotFound,
1274 3 => Self::BadMoniker,
1275 4 => Self::PackageNotFound,
1276 5 => Self::ManifestNotFound,
1277 6 => Self::PolicyError,
1278 7 => Self::InvalidArguments,
1279 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1280 }
1281 }
1282
1283 #[inline]
1284 pub fn unknown() -> Self {
1285 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1286 }
1287
1288 #[inline]
1289 pub const fn into_primitive(self) -> u32 {
1290 match self {
1291 Self::Internal => 1,
1292 Self::InstanceNotFound => 2,
1293 Self::BadMoniker => 3,
1294 Self::PackageNotFound => 4,
1295 Self::ManifestNotFound => 5,
1296 Self::PolicyError => 6,
1297 Self::InvalidArguments => 7,
1298 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1299 }
1300 }
1301
1302 #[inline]
1303 pub fn is_unknown(&self) -> bool {
1304 match self {
1305 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1306 _ => false,
1307 }
1308 }
1309}
1310
1311#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1312#[repr(u32)]
1313pub enum StatusError {
1314 Provider = 1,
1317 ResponseInvalid = 2,
1319 StatusUnknown = 3,
1322 Unsupported = 4,
1324}
1325
1326impl StatusError {
1327 #[inline]
1328 pub fn from_primitive(prim: u32) -> Option<Self> {
1329 match prim {
1330 1 => Some(Self::Provider),
1331 2 => Some(Self::ResponseInvalid),
1332 3 => Some(Self::StatusUnknown),
1333 4 => Some(Self::Unsupported),
1334 _ => None,
1335 }
1336 }
1337
1338 #[inline]
1339 pub const fn into_primitive(self) -> u32 {
1340 self as u32
1341 }
1342}
1343
1344#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1345pub enum StopError {
1346 Internal,
1347 InstanceNotFound,
1348 BadMoniker,
1349 #[doc(hidden)]
1350 __SourceBreaking {
1351 unknown_ordinal: u32,
1352 },
1353}
1354
1355#[macro_export]
1357macro_rules! StopErrorUnknown {
1358 () => {
1359 _
1360 };
1361}
1362
1363impl StopError {
1364 #[inline]
1365 pub fn from_primitive(prim: u32) -> Option<Self> {
1366 match prim {
1367 1 => Some(Self::Internal),
1368 2 => Some(Self::InstanceNotFound),
1369 3 => Some(Self::BadMoniker),
1370 _ => None,
1371 }
1372 }
1373
1374 #[inline]
1375 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1376 match prim {
1377 1 => Self::Internal,
1378 2 => Self::InstanceNotFound,
1379 3 => Self::BadMoniker,
1380 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1381 }
1382 }
1383
1384 #[inline]
1385 pub fn unknown() -> Self {
1386 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1387 }
1388
1389 #[inline]
1390 pub const fn into_primitive(self) -> u32 {
1391 match self {
1392 Self::Internal => 1,
1393 Self::InstanceNotFound => 2,
1394 Self::BadMoniker => 3,
1395 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1396 }
1397 }
1398
1399 #[inline]
1400 pub fn is_unknown(&self) -> bool {
1401 match self {
1402 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1403 _ => false,
1404 }
1405 }
1406}
1407
1408#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1409pub enum UnresolveError {
1410 Internal,
1411 InstanceNotFound,
1412 BadMoniker,
1413 #[doc(hidden)]
1414 __SourceBreaking {
1415 unknown_ordinal: u32,
1416 },
1417}
1418
1419#[macro_export]
1421macro_rules! UnresolveErrorUnknown {
1422 () => {
1423 _
1424 };
1425}
1426
1427impl UnresolveError {
1428 #[inline]
1429 pub fn from_primitive(prim: u32) -> Option<Self> {
1430 match prim {
1431 1 => Some(Self::Internal),
1432 2 => Some(Self::InstanceNotFound),
1433 3 => Some(Self::BadMoniker),
1434 _ => None,
1435 }
1436 }
1437
1438 #[inline]
1439 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1440 match prim {
1441 1 => Self::Internal,
1442 2 => Self::InstanceNotFound,
1443 3 => Self::BadMoniker,
1444 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1445 }
1446 }
1447
1448 #[inline]
1449 pub fn unknown() -> Self {
1450 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1451 }
1452
1453 #[inline]
1454 pub const fn into_primitive(self) -> u32 {
1455 match self {
1456 Self::Internal => 1,
1457 Self::InstanceNotFound => 2,
1458 Self::BadMoniker => 3,
1459 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1460 }
1461 }
1462
1463 #[inline]
1464 pub fn is_unknown(&self) -> bool {
1465 match self {
1466 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1467 _ => false,
1468 }
1469 }
1470}
1471
1472#[derive(Clone, Debug, PartialEq)]
1473pub struct ConfigOverrideSetStructuredConfigRequest {
1474 pub moniker: String,
1478 pub fields: Vec<fidl_fuchsia_component_decl__common::ConfigOverride>,
1479}
1480
1481impl fidl::Persistable for ConfigOverrideSetStructuredConfigRequest {}
1482
1483#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1484pub struct ConfigOverrideUnsetStructuredConfigRequest {
1485 pub moniker: String,
1489}
1490
1491impl fidl::Persistable for ConfigOverrideUnsetStructuredConfigRequest {}
1492
1493#[derive(Clone, Debug, PartialEq)]
1494pub struct CrashIntrospectFindComponentByThreadKoidResponse {
1495 pub info: ComponentCrashInfo,
1496}
1497
1498impl fidl::Persistable for CrashIntrospectFindComponentByThreadKoidResponse {}
1499
1500#[derive(Clone, Debug, PartialEq)]
1501pub struct InstanceIteratorNextResponse {
1502 pub infos: Vec<Instance>,
1503}
1504
1505impl fidl::Persistable for InstanceIteratorNextResponse {}
1506
1507#[derive(Clone, Debug, PartialEq)]
1508pub struct LifecycleControllerDestroyInstanceRequest {
1509 pub parent_moniker: String,
1510 pub child: fidl_fuchsia_component_decl__common::ChildRef,
1511}
1512
1513impl fidl::Persistable for LifecycleControllerDestroyInstanceRequest {}
1514
1515#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1516pub struct LifecycleControllerResolveInstanceRequest {
1517 pub moniker: String,
1518}
1519
1520impl fidl::Persistable for LifecycleControllerResolveInstanceRequest {}
1521
1522#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1523pub struct LifecycleControllerStopInstanceRequest {
1524 pub moniker: String,
1525}
1526
1527impl fidl::Persistable for LifecycleControllerStopInstanceRequest {}
1528
1529#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1530pub struct LifecycleControllerUnresolveInstanceRequest {
1531 pub moniker: String,
1532}
1533
1534impl fidl::Persistable for LifecycleControllerUnresolveInstanceRequest {}
1535
1536#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1537pub struct ManifestBytesIteratorNextResponse {
1538 pub infos: Vec<u8>,
1539}
1540
1541impl fidl::Persistable for ManifestBytesIteratorNextResponse {}
1542
1543#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1544pub struct RealmQueryConstructNamespaceRequest {
1545 pub moniker: String,
1546}
1547
1548impl fidl::Persistable for RealmQueryConstructNamespaceRequest {}
1549
1550#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1551pub struct RealmQueryGetInstanceRequest {
1552 pub moniker: String,
1553}
1554
1555impl fidl::Persistable for RealmQueryGetInstanceRequest {}
1556
1557#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1558pub struct RealmQueryGetManifestRequest {
1559 pub moniker: String,
1560}
1561
1562impl fidl::Persistable for RealmQueryGetManifestRequest {}
1563
1564#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1565pub struct RealmQueryGetResolvedDeclarationRequest {
1566 pub moniker: String,
1567}
1568
1569impl fidl::Persistable for RealmQueryGetResolvedDeclarationRequest {}
1570
1571#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1572pub struct RealmQueryGetStructuredConfigRequest {
1573 pub moniker: String,
1574}
1575
1576impl fidl::Persistable for RealmQueryGetStructuredConfigRequest {}
1577
1578#[derive(Clone, Debug, PartialEq)]
1579pub struct RealmQueryResolveDeclarationRequest {
1580 pub parent: String,
1581 pub child_location: ChildLocation,
1582 pub url: String,
1583}
1584
1585impl fidl::Persistable for RealmQueryResolveDeclarationRequest {}
1586
1587#[derive(Clone, Debug, PartialEq)]
1588pub struct RealmQueryGetInstanceResponse {
1589 pub instance: Instance,
1590}
1591
1592impl fidl::Persistable for RealmQueryGetInstanceResponse {}
1593
1594#[derive(Clone, Debug, PartialEq)]
1595pub struct RealmQueryGetStructuredConfigResponse {
1596 pub config: fidl_fuchsia_component_decl__common::ResolvedConfig,
1597}
1598
1599impl fidl::Persistable for RealmQueryGetStructuredConfigResponse {}
1600
1601#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1603pub struct RouteTarget {
1604 pub name: String,
1607 pub decl_type: DeclType,
1610}
1611
1612impl fidl::Persistable for RouteTarget {}
1613
1614#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1615pub struct RouteValidatorRouteRequest {
1616 pub moniker: String,
1618 pub targets: Vec<RouteTarget>,
1620}
1621
1622impl fidl::Persistable for RouteValidatorRouteRequest {}
1623
1624#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1625pub struct RouteValidatorValidateRequest {
1626 pub moniker: String,
1627}
1628
1629impl fidl::Persistable for RouteValidatorValidateRequest {}
1630
1631#[derive(Clone, Debug, PartialEq)]
1632pub struct RouteValidatorRouteResponse {
1633 pub reports: Vec<RouteReport>,
1634}
1635
1636impl fidl::Persistable for RouteValidatorRouteResponse {}
1637
1638#[derive(Clone, Debug, PartialEq)]
1639pub struct RouteValidatorValidateResponse {
1640 pub reports: Vec<RouteReport>,
1641}
1642
1643impl fidl::Persistable for RouteValidatorValidateResponse {}
1644
1645#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1646pub struct StorageAdminDeleteComponentStorageRequest {
1647 pub relative_moniker: String,
1648}
1649
1650impl fidl::Persistable for StorageAdminDeleteComponentStorageRequest {}
1651
1652#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1653pub struct StorageIteratorNextResponse {
1654 pub relative_monikers: Vec<String>,
1655}
1656
1657impl fidl::Persistable for StorageIteratorNextResponse {}
1658
1659#[derive(Clone, Debug, Default, PartialEq)]
1661pub struct ComponentCrashInfo {
1662 pub url: Option<String>,
1663 pub moniker: Option<String>,
1664 #[doc(hidden)]
1665 pub __source_breaking: fidl::marker::SourceBreaking,
1666}
1667
1668impl fidl::Persistable for ComponentCrashInfo {}
1669
1670#[derive(Clone, Debug, Default, PartialEq)]
1672pub struct ExecutionInfo {
1673 pub start_reason: Option<String>,
1675 #[doc(hidden)]
1676 pub __source_breaking: fidl::marker::SourceBreaking,
1677}
1678
1679impl fidl::Persistable for ExecutionInfo {}
1680
1681#[derive(Clone, Debug, Default, PartialEq)]
1687pub struct Instance {
1688 pub moniker: Option<String>,
1690 pub url: Option<String>,
1692 pub instance_id: Option<String>,
1694 pub resolved_info: Option<ResolvedInfo>,
1697 pub environment: Option<String>,
1699 #[doc(hidden)]
1700 pub __source_breaking: fidl::marker::SourceBreaking,
1701}
1702
1703impl fidl::Persistable for Instance {}
1704
1705#[derive(Clone, Debug, Default, PartialEq)]
1707pub struct ResolvedInfo {
1708 pub resolved_url: Option<String>,
1710 pub execution_info: Option<ExecutionInfo>,
1713 #[doc(hidden)]
1714 pub __source_breaking: fidl::marker::SourceBreaking,
1715}
1716
1717impl fidl::Persistable for ResolvedInfo {}
1718
1719#[derive(Clone, Debug, Default, PartialEq)]
1721pub struct RouteError {
1722 pub summary: Option<String>,
1724 #[doc(hidden)]
1725 pub __source_breaking: fidl::marker::SourceBreaking,
1726}
1727
1728impl fidl::Persistable for RouteError {}
1729
1730#[derive(Clone, Debug, Default, PartialEq)]
1732pub struct RouteReport {
1733 pub capability: Option<String>,
1735 pub decl_type: Option<DeclType>,
1737 pub error: Option<RouteError>,
1740 pub source_moniker: Option<String>,
1742 pub service_instances: Option<Vec<ServiceInstance>>,
1744 pub availability: Option<fidl_fuchsia_component_decl__common::Availability>,
1746 pub outcome: Option<RouteOutcome>,
1748 #[doc(hidden)]
1749 pub __source_breaking: fidl::marker::SourceBreaking,
1750}
1751
1752impl fidl::Persistable for RouteReport {}
1753
1754#[derive(Clone, Debug, Default, PartialEq)]
1756pub struct ServiceInstance {
1757 pub instance_name: Option<String>,
1759 pub child_name: Option<String>,
1762 pub child_instance_name: Option<String>,
1764 #[doc(hidden)]
1765 pub __source_breaking: fidl::marker::SourceBreaking,
1766}
1767
1768impl fidl::Persistable for ServiceInstance {}
1769
1770#[derive(Clone, Debug, Default, PartialEq)]
1772pub struct StorageStatus {
1773 pub total_size: Option<u64>,
1774 pub used_size: Option<u64>,
1775 #[doc(hidden)]
1776 pub __source_breaking: fidl::marker::SourceBreaking,
1777}
1778
1779impl fidl::Persistable for StorageStatus {}
1780
1781#[derive(Clone, Debug)]
1783pub enum ChildLocation {
1784 Collection(String),
1785 #[doc(hidden)]
1786 __SourceBreaking {
1787 unknown_ordinal: u64,
1788 },
1789}
1790
1791#[macro_export]
1793macro_rules! ChildLocationUnknown {
1794 () => {
1795 _
1796 };
1797}
1798
1799impl PartialEq for ChildLocation {
1801 fn eq(&self, other: &Self) -> bool {
1802 match (self, other) {
1803 (Self::Collection(x), Self::Collection(y)) => *x == *y,
1804 _ => false,
1805 }
1806 }
1807}
1808
1809impl ChildLocation {
1810 #[inline]
1811 pub fn ordinal(&self) -> u64 {
1812 match *self {
1813 Self::Collection(_) => 1,
1814 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1815 }
1816 }
1817
1818 #[inline]
1819 pub fn unknown_variant_for_testing() -> Self {
1820 Self::__SourceBreaking { unknown_ordinal: 0 }
1821 }
1822
1823 #[inline]
1824 pub fn is_unknown(&self) -> bool {
1825 match self {
1826 Self::__SourceBreaking { .. } => true,
1827 _ => false,
1828 }
1829 }
1830}
1831
1832impl fidl::Persistable for ChildLocation {}
1833
1834mod internal {
1835 use super::*;
1836 unsafe impl fidl::encoding::TypeMarker for ConfigOverrideError {
1837 type Owned = Self;
1838
1839 #[inline(always)]
1840 fn inline_align(_context: fidl::encoding::Context) -> usize {
1841 std::mem::align_of::<u32>()
1842 }
1843
1844 #[inline(always)]
1845 fn inline_size(_context: fidl::encoding::Context) -> usize {
1846 std::mem::size_of::<u32>()
1847 }
1848
1849 #[inline(always)]
1850 fn encode_is_copy() -> bool {
1851 false
1852 }
1853
1854 #[inline(always)]
1855 fn decode_is_copy() -> bool {
1856 false
1857 }
1858 }
1859
1860 impl fidl::encoding::ValueTypeMarker for ConfigOverrideError {
1861 type Borrowed<'a> = Self;
1862 #[inline(always)]
1863 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1864 *value
1865 }
1866 }
1867
1868 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1869 for ConfigOverrideError
1870 {
1871 #[inline]
1872 unsafe fn encode(
1873 self,
1874 encoder: &mut fidl::encoding::Encoder<'_, D>,
1875 offset: usize,
1876 _depth: fidl::encoding::Depth,
1877 ) -> fidl::Result<()> {
1878 encoder.debug_check_bounds::<Self>(offset);
1879 encoder.write_num(self.into_primitive(), offset);
1880 Ok(())
1881 }
1882 }
1883
1884 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigOverrideError {
1885 #[inline(always)]
1886 fn new_empty() -> Self {
1887 Self::unknown()
1888 }
1889
1890 #[inline]
1891 unsafe fn decode(
1892 &mut self,
1893 decoder: &mut fidl::encoding::Decoder<'_, D>,
1894 offset: usize,
1895 _depth: fidl::encoding::Depth,
1896 ) -> fidl::Result<()> {
1897 decoder.debug_check_bounds::<Self>(offset);
1898 let prim = decoder.read_num::<u32>(offset);
1899
1900 *self = Self::from_primitive_allow_unknown(prim);
1901 Ok(())
1902 }
1903 }
1904 unsafe impl fidl::encoding::TypeMarker for ConnectToStorageAdminError {
1905 type Owned = Self;
1906
1907 #[inline(always)]
1908 fn inline_align(_context: fidl::encoding::Context) -> usize {
1909 std::mem::align_of::<u32>()
1910 }
1911
1912 #[inline(always)]
1913 fn inline_size(_context: fidl::encoding::Context) -> usize {
1914 std::mem::size_of::<u32>()
1915 }
1916
1917 #[inline(always)]
1918 fn encode_is_copy() -> bool {
1919 false
1920 }
1921
1922 #[inline(always)]
1923 fn decode_is_copy() -> bool {
1924 false
1925 }
1926 }
1927
1928 impl fidl::encoding::ValueTypeMarker for ConnectToStorageAdminError {
1929 type Borrowed<'a> = Self;
1930 #[inline(always)]
1931 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1932 *value
1933 }
1934 }
1935
1936 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1937 for ConnectToStorageAdminError
1938 {
1939 #[inline]
1940 unsafe fn encode(
1941 self,
1942 encoder: &mut fidl::encoding::Encoder<'_, D>,
1943 offset: usize,
1944 _depth: fidl::encoding::Depth,
1945 ) -> fidl::Result<()> {
1946 encoder.debug_check_bounds::<Self>(offset);
1947 encoder.write_num(self.into_primitive(), offset);
1948 Ok(())
1949 }
1950 }
1951
1952 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1953 for ConnectToStorageAdminError
1954 {
1955 #[inline(always)]
1956 fn new_empty() -> Self {
1957 Self::unknown()
1958 }
1959
1960 #[inline]
1961 unsafe fn decode(
1962 &mut self,
1963 decoder: &mut fidl::encoding::Decoder<'_, D>,
1964 offset: usize,
1965 _depth: fidl::encoding::Depth,
1966 ) -> fidl::Result<()> {
1967 decoder.debug_check_bounds::<Self>(offset);
1968 let prim = decoder.read_num::<u32>(offset);
1969
1970 *self = Self::from_primitive_allow_unknown(prim);
1971 Ok(())
1972 }
1973 }
1974 unsafe impl fidl::encoding::TypeMarker for ConstructNamespaceError {
1975 type Owned = Self;
1976
1977 #[inline(always)]
1978 fn inline_align(_context: fidl::encoding::Context) -> usize {
1979 std::mem::align_of::<u32>()
1980 }
1981
1982 #[inline(always)]
1983 fn inline_size(_context: fidl::encoding::Context) -> usize {
1984 std::mem::size_of::<u32>()
1985 }
1986
1987 #[inline(always)]
1988 fn encode_is_copy() -> bool {
1989 false
1990 }
1991
1992 #[inline(always)]
1993 fn decode_is_copy() -> bool {
1994 false
1995 }
1996 }
1997
1998 impl fidl::encoding::ValueTypeMarker for ConstructNamespaceError {
1999 type Borrowed<'a> = Self;
2000 #[inline(always)]
2001 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2002 *value
2003 }
2004 }
2005
2006 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2007 for ConstructNamespaceError
2008 {
2009 #[inline]
2010 unsafe fn encode(
2011 self,
2012 encoder: &mut fidl::encoding::Encoder<'_, D>,
2013 offset: usize,
2014 _depth: fidl::encoding::Depth,
2015 ) -> fidl::Result<()> {
2016 encoder.debug_check_bounds::<Self>(offset);
2017 encoder.write_num(self.into_primitive(), offset);
2018 Ok(())
2019 }
2020 }
2021
2022 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2023 for ConstructNamespaceError
2024 {
2025 #[inline(always)]
2026 fn new_empty() -> Self {
2027 Self::unknown()
2028 }
2029
2030 #[inline]
2031 unsafe fn decode(
2032 &mut self,
2033 decoder: &mut fidl::encoding::Decoder<'_, D>,
2034 offset: usize,
2035 _depth: fidl::encoding::Depth,
2036 ) -> fidl::Result<()> {
2037 decoder.debug_check_bounds::<Self>(offset);
2038 let prim = decoder.read_num::<u32>(offset);
2039
2040 *self = Self::from_primitive_allow_unknown(prim);
2041 Ok(())
2042 }
2043 }
2044 unsafe impl fidl::encoding::TypeMarker for CreateError {
2045 type Owned = Self;
2046
2047 #[inline(always)]
2048 fn inline_align(_context: fidl::encoding::Context) -> usize {
2049 std::mem::align_of::<u32>()
2050 }
2051
2052 #[inline(always)]
2053 fn inline_size(_context: fidl::encoding::Context) -> usize {
2054 std::mem::size_of::<u32>()
2055 }
2056
2057 #[inline(always)]
2058 fn encode_is_copy() -> bool {
2059 false
2060 }
2061
2062 #[inline(always)]
2063 fn decode_is_copy() -> bool {
2064 false
2065 }
2066 }
2067
2068 impl fidl::encoding::ValueTypeMarker for CreateError {
2069 type Borrowed<'a> = Self;
2070 #[inline(always)]
2071 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2072 *value
2073 }
2074 }
2075
2076 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CreateError {
2077 #[inline]
2078 unsafe fn encode(
2079 self,
2080 encoder: &mut fidl::encoding::Encoder<'_, D>,
2081 offset: usize,
2082 _depth: fidl::encoding::Depth,
2083 ) -> fidl::Result<()> {
2084 encoder.debug_check_bounds::<Self>(offset);
2085 encoder.write_num(self.into_primitive(), offset);
2086 Ok(())
2087 }
2088 }
2089
2090 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CreateError {
2091 #[inline(always)]
2092 fn new_empty() -> Self {
2093 Self::unknown()
2094 }
2095
2096 #[inline]
2097 unsafe fn decode(
2098 &mut self,
2099 decoder: &mut fidl::encoding::Decoder<'_, D>,
2100 offset: usize,
2101 _depth: fidl::encoding::Depth,
2102 ) -> fidl::Result<()> {
2103 decoder.debug_check_bounds::<Self>(offset);
2104 let prim = decoder.read_num::<u32>(offset);
2105
2106 *self = Self::from_primitive_allow_unknown(prim);
2107 Ok(())
2108 }
2109 }
2110 unsafe impl fidl::encoding::TypeMarker for DeclType {
2111 type Owned = Self;
2112
2113 #[inline(always)]
2114 fn inline_align(_context: fidl::encoding::Context) -> usize {
2115 std::mem::align_of::<u32>()
2116 }
2117
2118 #[inline(always)]
2119 fn inline_size(_context: fidl::encoding::Context) -> usize {
2120 std::mem::size_of::<u32>()
2121 }
2122
2123 #[inline(always)]
2124 fn encode_is_copy() -> bool {
2125 false
2126 }
2127
2128 #[inline(always)]
2129 fn decode_is_copy() -> bool {
2130 false
2131 }
2132 }
2133
2134 impl fidl::encoding::ValueTypeMarker for DeclType {
2135 type Borrowed<'a> = Self;
2136 #[inline(always)]
2137 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2138 *value
2139 }
2140 }
2141
2142 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeclType {
2143 #[inline]
2144 unsafe fn encode(
2145 self,
2146 encoder: &mut fidl::encoding::Encoder<'_, D>,
2147 offset: usize,
2148 _depth: fidl::encoding::Depth,
2149 ) -> fidl::Result<()> {
2150 encoder.debug_check_bounds::<Self>(offset);
2151 encoder.write_num(self.into_primitive(), offset);
2152 Ok(())
2153 }
2154 }
2155
2156 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeclType {
2157 #[inline(always)]
2158 fn new_empty() -> Self {
2159 Self::unknown()
2160 }
2161
2162 #[inline]
2163 unsafe fn decode(
2164 &mut self,
2165 decoder: &mut fidl::encoding::Decoder<'_, D>,
2166 offset: usize,
2167 _depth: fidl::encoding::Depth,
2168 ) -> fidl::Result<()> {
2169 decoder.debug_check_bounds::<Self>(offset);
2170 let prim = decoder.read_num::<u32>(offset);
2171
2172 *self = Self::from_primitive_allow_unknown(prim);
2173 Ok(())
2174 }
2175 }
2176 unsafe impl fidl::encoding::TypeMarker for DeletionError {
2177 type Owned = Self;
2178
2179 #[inline(always)]
2180 fn inline_align(_context: fidl::encoding::Context) -> usize {
2181 std::mem::align_of::<u32>()
2182 }
2183
2184 #[inline(always)]
2185 fn inline_size(_context: fidl::encoding::Context) -> usize {
2186 std::mem::size_of::<u32>()
2187 }
2188
2189 #[inline(always)]
2190 fn encode_is_copy() -> bool {
2191 true
2192 }
2193
2194 #[inline(always)]
2195 fn decode_is_copy() -> bool {
2196 false
2197 }
2198 }
2199
2200 impl fidl::encoding::ValueTypeMarker for DeletionError {
2201 type Borrowed<'a> = Self;
2202 #[inline(always)]
2203 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2204 *value
2205 }
2206 }
2207
2208 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeletionError {
2209 #[inline]
2210 unsafe fn encode(
2211 self,
2212 encoder: &mut fidl::encoding::Encoder<'_, D>,
2213 offset: usize,
2214 _depth: fidl::encoding::Depth,
2215 ) -> fidl::Result<()> {
2216 encoder.debug_check_bounds::<Self>(offset);
2217 encoder.write_num(self.into_primitive(), offset);
2218 Ok(())
2219 }
2220 }
2221
2222 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeletionError {
2223 #[inline(always)]
2224 fn new_empty() -> Self {
2225 Self::Connection
2226 }
2227
2228 #[inline]
2229 unsafe fn decode(
2230 &mut self,
2231 decoder: &mut fidl::encoding::Decoder<'_, D>,
2232 offset: usize,
2233 _depth: fidl::encoding::Depth,
2234 ) -> fidl::Result<()> {
2235 decoder.debug_check_bounds::<Self>(offset);
2236 let prim = decoder.read_num::<u32>(offset);
2237
2238 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2239 Ok(())
2240 }
2241 }
2242 unsafe impl fidl::encoding::TypeMarker for DestroyError {
2243 type Owned = Self;
2244
2245 #[inline(always)]
2246 fn inline_align(_context: fidl::encoding::Context) -> usize {
2247 std::mem::align_of::<u32>()
2248 }
2249
2250 #[inline(always)]
2251 fn inline_size(_context: fidl::encoding::Context) -> usize {
2252 std::mem::size_of::<u32>()
2253 }
2254
2255 #[inline(always)]
2256 fn encode_is_copy() -> bool {
2257 false
2258 }
2259
2260 #[inline(always)]
2261 fn decode_is_copy() -> bool {
2262 false
2263 }
2264 }
2265
2266 impl fidl::encoding::ValueTypeMarker for DestroyError {
2267 type Borrowed<'a> = Self;
2268 #[inline(always)]
2269 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2270 *value
2271 }
2272 }
2273
2274 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DestroyError {
2275 #[inline]
2276 unsafe fn encode(
2277 self,
2278 encoder: &mut fidl::encoding::Encoder<'_, D>,
2279 offset: usize,
2280 _depth: fidl::encoding::Depth,
2281 ) -> fidl::Result<()> {
2282 encoder.debug_check_bounds::<Self>(offset);
2283 encoder.write_num(self.into_primitive(), offset);
2284 Ok(())
2285 }
2286 }
2287
2288 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DestroyError {
2289 #[inline(always)]
2290 fn new_empty() -> Self {
2291 Self::unknown()
2292 }
2293
2294 #[inline]
2295 unsafe fn decode(
2296 &mut self,
2297 decoder: &mut fidl::encoding::Decoder<'_, D>,
2298 offset: usize,
2299 _depth: fidl::encoding::Depth,
2300 ) -> fidl::Result<()> {
2301 decoder.debug_check_bounds::<Self>(offset);
2302 let prim = decoder.read_num::<u32>(offset);
2303
2304 *self = Self::from_primitive_allow_unknown(prim);
2305 Ok(())
2306 }
2307 }
2308 unsafe impl fidl::encoding::TypeMarker for GetAllInstancesError {
2309 type Owned = Self;
2310
2311 #[inline(always)]
2312 fn inline_align(_context: fidl::encoding::Context) -> usize {
2313 std::mem::align_of::<u32>()
2314 }
2315
2316 #[inline(always)]
2317 fn inline_size(_context: fidl::encoding::Context) -> usize {
2318 std::mem::size_of::<u32>()
2319 }
2320
2321 #[inline(always)]
2322 fn encode_is_copy() -> bool {
2323 false
2324 }
2325
2326 #[inline(always)]
2327 fn decode_is_copy() -> bool {
2328 false
2329 }
2330 }
2331
2332 impl fidl::encoding::ValueTypeMarker for GetAllInstancesError {
2333 type Borrowed<'a> = Self;
2334 #[inline(always)]
2335 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2336 *value
2337 }
2338 }
2339
2340 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2341 for GetAllInstancesError
2342 {
2343 #[inline]
2344 unsafe fn encode(
2345 self,
2346 encoder: &mut fidl::encoding::Encoder<'_, D>,
2347 offset: usize,
2348 _depth: fidl::encoding::Depth,
2349 ) -> fidl::Result<()> {
2350 encoder.debug_check_bounds::<Self>(offset);
2351 encoder.write_num(self.into_primitive(), offset);
2352 Ok(())
2353 }
2354 }
2355
2356 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetAllInstancesError {
2357 #[inline(always)]
2358 fn new_empty() -> Self {
2359 Self::unknown()
2360 }
2361
2362 #[inline]
2363 unsafe fn decode(
2364 &mut self,
2365 decoder: &mut fidl::encoding::Decoder<'_, D>,
2366 offset: usize,
2367 _depth: fidl::encoding::Depth,
2368 ) -> fidl::Result<()> {
2369 decoder.debug_check_bounds::<Self>(offset);
2370 let prim = decoder.read_num::<u32>(offset);
2371
2372 *self = Self::from_primitive_allow_unknown(prim);
2373 Ok(())
2374 }
2375 }
2376 unsafe impl fidl::encoding::TypeMarker for GetDeclarationError {
2377 type Owned = Self;
2378
2379 #[inline(always)]
2380 fn inline_align(_context: fidl::encoding::Context) -> usize {
2381 std::mem::align_of::<u32>()
2382 }
2383
2384 #[inline(always)]
2385 fn inline_size(_context: fidl::encoding::Context) -> usize {
2386 std::mem::size_of::<u32>()
2387 }
2388
2389 #[inline(always)]
2390 fn encode_is_copy() -> bool {
2391 false
2392 }
2393
2394 #[inline(always)]
2395 fn decode_is_copy() -> bool {
2396 false
2397 }
2398 }
2399
2400 impl fidl::encoding::ValueTypeMarker for GetDeclarationError {
2401 type Borrowed<'a> = Self;
2402 #[inline(always)]
2403 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2404 *value
2405 }
2406 }
2407
2408 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2409 for GetDeclarationError
2410 {
2411 #[inline]
2412 unsafe fn encode(
2413 self,
2414 encoder: &mut fidl::encoding::Encoder<'_, D>,
2415 offset: usize,
2416 _depth: fidl::encoding::Depth,
2417 ) -> fidl::Result<()> {
2418 encoder.debug_check_bounds::<Self>(offset);
2419 encoder.write_num(self.into_primitive(), offset);
2420 Ok(())
2421 }
2422 }
2423
2424 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetDeclarationError {
2425 #[inline(always)]
2426 fn new_empty() -> Self {
2427 Self::unknown()
2428 }
2429
2430 #[inline]
2431 unsafe fn decode(
2432 &mut self,
2433 decoder: &mut fidl::encoding::Decoder<'_, D>,
2434 offset: usize,
2435 _depth: fidl::encoding::Depth,
2436 ) -> fidl::Result<()> {
2437 decoder.debug_check_bounds::<Self>(offset);
2438 let prim = decoder.read_num::<u32>(offset);
2439
2440 *self = Self::from_primitive_allow_unknown(prim);
2441 Ok(())
2442 }
2443 }
2444 unsafe impl fidl::encoding::TypeMarker for GetInstanceError {
2445 type Owned = Self;
2446
2447 #[inline(always)]
2448 fn inline_align(_context: fidl::encoding::Context) -> usize {
2449 std::mem::align_of::<u32>()
2450 }
2451
2452 #[inline(always)]
2453 fn inline_size(_context: fidl::encoding::Context) -> usize {
2454 std::mem::size_of::<u32>()
2455 }
2456
2457 #[inline(always)]
2458 fn encode_is_copy() -> bool {
2459 false
2460 }
2461
2462 #[inline(always)]
2463 fn decode_is_copy() -> bool {
2464 false
2465 }
2466 }
2467
2468 impl fidl::encoding::ValueTypeMarker for GetInstanceError {
2469 type Borrowed<'a> = Self;
2470 #[inline(always)]
2471 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2472 *value
2473 }
2474 }
2475
2476 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2477 for GetInstanceError
2478 {
2479 #[inline]
2480 unsafe fn encode(
2481 self,
2482 encoder: &mut fidl::encoding::Encoder<'_, D>,
2483 offset: usize,
2484 _depth: fidl::encoding::Depth,
2485 ) -> fidl::Result<()> {
2486 encoder.debug_check_bounds::<Self>(offset);
2487 encoder.write_num(self.into_primitive(), offset);
2488 Ok(())
2489 }
2490 }
2491
2492 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetInstanceError {
2493 #[inline(always)]
2494 fn new_empty() -> Self {
2495 Self::unknown()
2496 }
2497
2498 #[inline]
2499 unsafe fn decode(
2500 &mut self,
2501 decoder: &mut fidl::encoding::Decoder<'_, D>,
2502 offset: usize,
2503 _depth: fidl::encoding::Depth,
2504 ) -> fidl::Result<()> {
2505 decoder.debug_check_bounds::<Self>(offset);
2506 let prim = decoder.read_num::<u32>(offset);
2507
2508 *self = Self::from_primitive_allow_unknown(prim);
2509 Ok(())
2510 }
2511 }
2512 unsafe impl fidl::encoding::TypeMarker for GetStructuredConfigError {
2513 type Owned = Self;
2514
2515 #[inline(always)]
2516 fn inline_align(_context: fidl::encoding::Context) -> usize {
2517 std::mem::align_of::<u32>()
2518 }
2519
2520 #[inline(always)]
2521 fn inline_size(_context: fidl::encoding::Context) -> usize {
2522 std::mem::size_of::<u32>()
2523 }
2524
2525 #[inline(always)]
2526 fn encode_is_copy() -> bool {
2527 false
2528 }
2529
2530 #[inline(always)]
2531 fn decode_is_copy() -> bool {
2532 false
2533 }
2534 }
2535
2536 impl fidl::encoding::ValueTypeMarker for GetStructuredConfigError {
2537 type Borrowed<'a> = Self;
2538 #[inline(always)]
2539 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2540 *value
2541 }
2542 }
2543
2544 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2545 for GetStructuredConfigError
2546 {
2547 #[inline]
2548 unsafe fn encode(
2549 self,
2550 encoder: &mut fidl::encoding::Encoder<'_, D>,
2551 offset: usize,
2552 _depth: fidl::encoding::Depth,
2553 ) -> fidl::Result<()> {
2554 encoder.debug_check_bounds::<Self>(offset);
2555 encoder.write_num(self.into_primitive(), offset);
2556 Ok(())
2557 }
2558 }
2559
2560 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2561 for GetStructuredConfigError
2562 {
2563 #[inline(always)]
2564 fn new_empty() -> Self {
2565 Self::unknown()
2566 }
2567
2568 #[inline]
2569 unsafe fn decode(
2570 &mut self,
2571 decoder: &mut fidl::encoding::Decoder<'_, D>,
2572 offset: usize,
2573 _depth: fidl::encoding::Depth,
2574 ) -> fidl::Result<()> {
2575 decoder.debug_check_bounds::<Self>(offset);
2576 let prim = decoder.read_num::<u32>(offset);
2577
2578 *self = Self::from_primitive_allow_unknown(prim);
2579 Ok(())
2580 }
2581 }
2582 unsafe impl fidl::encoding::TypeMarker for OpenDirType {
2583 type Owned = Self;
2584
2585 #[inline(always)]
2586 fn inline_align(_context: fidl::encoding::Context) -> usize {
2587 std::mem::align_of::<u32>()
2588 }
2589
2590 #[inline(always)]
2591 fn inline_size(_context: fidl::encoding::Context) -> usize {
2592 std::mem::size_of::<u32>()
2593 }
2594
2595 #[inline(always)]
2596 fn encode_is_copy() -> bool {
2597 false
2598 }
2599
2600 #[inline(always)]
2601 fn decode_is_copy() -> bool {
2602 false
2603 }
2604 }
2605
2606 impl fidl::encoding::ValueTypeMarker for OpenDirType {
2607 type Borrowed<'a> = Self;
2608 #[inline(always)]
2609 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2610 *value
2611 }
2612 }
2613
2614 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OpenDirType {
2615 #[inline]
2616 unsafe fn encode(
2617 self,
2618 encoder: &mut fidl::encoding::Encoder<'_, D>,
2619 offset: usize,
2620 _depth: fidl::encoding::Depth,
2621 ) -> fidl::Result<()> {
2622 encoder.debug_check_bounds::<Self>(offset);
2623 encoder.write_num(self.into_primitive(), offset);
2624 Ok(())
2625 }
2626 }
2627
2628 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OpenDirType {
2629 #[inline(always)]
2630 fn new_empty() -> Self {
2631 Self::unknown()
2632 }
2633
2634 #[inline]
2635 unsafe fn decode(
2636 &mut self,
2637 decoder: &mut fidl::encoding::Decoder<'_, D>,
2638 offset: usize,
2639 _depth: fidl::encoding::Depth,
2640 ) -> fidl::Result<()> {
2641 decoder.debug_check_bounds::<Self>(offset);
2642 let prim = decoder.read_num::<u32>(offset);
2643
2644 *self = Self::from_primitive_allow_unknown(prim);
2645 Ok(())
2646 }
2647 }
2648 unsafe impl fidl::encoding::TypeMarker for OpenError {
2649 type Owned = Self;
2650
2651 #[inline(always)]
2652 fn inline_align(_context: fidl::encoding::Context) -> usize {
2653 std::mem::align_of::<u32>()
2654 }
2655
2656 #[inline(always)]
2657 fn inline_size(_context: fidl::encoding::Context) -> usize {
2658 std::mem::size_of::<u32>()
2659 }
2660
2661 #[inline(always)]
2662 fn encode_is_copy() -> bool {
2663 false
2664 }
2665
2666 #[inline(always)]
2667 fn decode_is_copy() -> bool {
2668 false
2669 }
2670 }
2671
2672 impl fidl::encoding::ValueTypeMarker for OpenError {
2673 type Borrowed<'a> = Self;
2674 #[inline(always)]
2675 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2676 *value
2677 }
2678 }
2679
2680 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OpenError {
2681 #[inline]
2682 unsafe fn encode(
2683 self,
2684 encoder: &mut fidl::encoding::Encoder<'_, D>,
2685 offset: usize,
2686 _depth: fidl::encoding::Depth,
2687 ) -> fidl::Result<()> {
2688 encoder.debug_check_bounds::<Self>(offset);
2689 encoder.write_num(self.into_primitive(), offset);
2690 Ok(())
2691 }
2692 }
2693
2694 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OpenError {
2695 #[inline(always)]
2696 fn new_empty() -> Self {
2697 Self::unknown()
2698 }
2699
2700 #[inline]
2701 unsafe fn decode(
2702 &mut self,
2703 decoder: &mut fidl::encoding::Decoder<'_, D>,
2704 offset: usize,
2705 _depth: fidl::encoding::Depth,
2706 ) -> fidl::Result<()> {
2707 decoder.debug_check_bounds::<Self>(offset);
2708 let prim = decoder.read_num::<u32>(offset);
2709
2710 *self = Self::from_primitive_allow_unknown(prim);
2711 Ok(())
2712 }
2713 }
2714 unsafe impl fidl::encoding::TypeMarker for RealmQueryError {
2715 type Owned = Self;
2716
2717 #[inline(always)]
2718 fn inline_align(_context: fidl::encoding::Context) -> usize {
2719 std::mem::align_of::<u32>()
2720 }
2721
2722 #[inline(always)]
2723 fn inline_size(_context: fidl::encoding::Context) -> usize {
2724 std::mem::size_of::<u32>()
2725 }
2726
2727 #[inline(always)]
2728 fn encode_is_copy() -> bool {
2729 false
2730 }
2731
2732 #[inline(always)]
2733 fn decode_is_copy() -> bool {
2734 false
2735 }
2736 }
2737
2738 impl fidl::encoding::ValueTypeMarker for RealmQueryError {
2739 type Borrowed<'a> = Self;
2740 #[inline(always)]
2741 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2742 *value
2743 }
2744 }
2745
2746 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2747 for RealmQueryError
2748 {
2749 #[inline]
2750 unsafe fn encode(
2751 self,
2752 encoder: &mut fidl::encoding::Encoder<'_, D>,
2753 offset: usize,
2754 _depth: fidl::encoding::Depth,
2755 ) -> fidl::Result<()> {
2756 encoder.debug_check_bounds::<Self>(offset);
2757 encoder.write_num(self.into_primitive(), offset);
2758 Ok(())
2759 }
2760 }
2761
2762 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RealmQueryError {
2763 #[inline(always)]
2764 fn new_empty() -> Self {
2765 Self::unknown()
2766 }
2767
2768 #[inline]
2769 unsafe fn decode(
2770 &mut self,
2771 decoder: &mut fidl::encoding::Decoder<'_, D>,
2772 offset: usize,
2773 _depth: fidl::encoding::Depth,
2774 ) -> fidl::Result<()> {
2775 decoder.debug_check_bounds::<Self>(offset);
2776 let prim = decoder.read_num::<u32>(offset);
2777
2778 *self = Self::from_primitive_allow_unknown(prim);
2779 Ok(())
2780 }
2781 }
2782 unsafe impl fidl::encoding::TypeMarker for ResolveError {
2783 type Owned = Self;
2784
2785 #[inline(always)]
2786 fn inline_align(_context: fidl::encoding::Context) -> usize {
2787 std::mem::align_of::<u32>()
2788 }
2789
2790 #[inline(always)]
2791 fn inline_size(_context: fidl::encoding::Context) -> usize {
2792 std::mem::size_of::<u32>()
2793 }
2794
2795 #[inline(always)]
2796 fn encode_is_copy() -> bool {
2797 false
2798 }
2799
2800 #[inline(always)]
2801 fn decode_is_copy() -> bool {
2802 false
2803 }
2804 }
2805
2806 impl fidl::encoding::ValueTypeMarker for ResolveError {
2807 type Borrowed<'a> = Self;
2808 #[inline(always)]
2809 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2810 *value
2811 }
2812 }
2813
2814 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ResolveError {
2815 #[inline]
2816 unsafe fn encode(
2817 self,
2818 encoder: &mut fidl::encoding::Encoder<'_, D>,
2819 offset: usize,
2820 _depth: fidl::encoding::Depth,
2821 ) -> fidl::Result<()> {
2822 encoder.debug_check_bounds::<Self>(offset);
2823 encoder.write_num(self.into_primitive(), offset);
2824 Ok(())
2825 }
2826 }
2827
2828 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolveError {
2829 #[inline(always)]
2830 fn new_empty() -> Self {
2831 Self::unknown()
2832 }
2833
2834 #[inline]
2835 unsafe fn decode(
2836 &mut self,
2837 decoder: &mut fidl::encoding::Decoder<'_, D>,
2838 offset: usize,
2839 _depth: fidl::encoding::Depth,
2840 ) -> fidl::Result<()> {
2841 decoder.debug_check_bounds::<Self>(offset);
2842 let prim = decoder.read_num::<u32>(offset);
2843
2844 *self = Self::from_primitive_allow_unknown(prim);
2845 Ok(())
2846 }
2847 }
2848 unsafe impl fidl::encoding::TypeMarker for RouteOutcome {
2849 type Owned = Self;
2850
2851 #[inline(always)]
2852 fn inline_align(_context: fidl::encoding::Context) -> usize {
2853 std::mem::align_of::<u32>()
2854 }
2855
2856 #[inline(always)]
2857 fn inline_size(_context: fidl::encoding::Context) -> usize {
2858 std::mem::size_of::<u32>()
2859 }
2860
2861 #[inline(always)]
2862 fn encode_is_copy() -> bool {
2863 false
2864 }
2865
2866 #[inline(always)]
2867 fn decode_is_copy() -> bool {
2868 false
2869 }
2870 }
2871
2872 impl fidl::encoding::ValueTypeMarker for RouteOutcome {
2873 type Borrowed<'a> = Self;
2874 #[inline(always)]
2875 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2876 *value
2877 }
2878 }
2879
2880 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for RouteOutcome {
2881 #[inline]
2882 unsafe fn encode(
2883 self,
2884 encoder: &mut fidl::encoding::Encoder<'_, D>,
2885 offset: usize,
2886 _depth: fidl::encoding::Depth,
2887 ) -> fidl::Result<()> {
2888 encoder.debug_check_bounds::<Self>(offset);
2889 encoder.write_num(self.into_primitive(), offset);
2890 Ok(())
2891 }
2892 }
2893
2894 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RouteOutcome {
2895 #[inline(always)]
2896 fn new_empty() -> Self {
2897 Self::unknown()
2898 }
2899
2900 #[inline]
2901 unsafe fn decode(
2902 &mut self,
2903 decoder: &mut fidl::encoding::Decoder<'_, D>,
2904 offset: usize,
2905 _depth: fidl::encoding::Depth,
2906 ) -> fidl::Result<()> {
2907 decoder.debug_check_bounds::<Self>(offset);
2908 let prim = decoder.read_num::<u32>(offset);
2909
2910 *self = Self::from_primitive_allow_unknown(prim);
2911 Ok(())
2912 }
2913 }
2914 unsafe impl fidl::encoding::TypeMarker for RouteValidatorError {
2915 type Owned = Self;
2916
2917 #[inline(always)]
2918 fn inline_align(_context: fidl::encoding::Context) -> usize {
2919 std::mem::align_of::<u32>()
2920 }
2921
2922 #[inline(always)]
2923 fn inline_size(_context: fidl::encoding::Context) -> usize {
2924 std::mem::size_of::<u32>()
2925 }
2926
2927 #[inline(always)]
2928 fn encode_is_copy() -> bool {
2929 false
2930 }
2931
2932 #[inline(always)]
2933 fn decode_is_copy() -> bool {
2934 false
2935 }
2936 }
2937
2938 impl fidl::encoding::ValueTypeMarker for RouteValidatorError {
2939 type Borrowed<'a> = Self;
2940 #[inline(always)]
2941 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2942 *value
2943 }
2944 }
2945
2946 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2947 for RouteValidatorError
2948 {
2949 #[inline]
2950 unsafe fn encode(
2951 self,
2952 encoder: &mut fidl::encoding::Encoder<'_, D>,
2953 offset: usize,
2954 _depth: fidl::encoding::Depth,
2955 ) -> fidl::Result<()> {
2956 encoder.debug_check_bounds::<Self>(offset);
2957 encoder.write_num(self.into_primitive(), offset);
2958 Ok(())
2959 }
2960 }
2961
2962 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RouteValidatorError {
2963 #[inline(always)]
2964 fn new_empty() -> Self {
2965 Self::unknown()
2966 }
2967
2968 #[inline]
2969 unsafe fn decode(
2970 &mut self,
2971 decoder: &mut fidl::encoding::Decoder<'_, D>,
2972 offset: usize,
2973 _depth: fidl::encoding::Depth,
2974 ) -> fidl::Result<()> {
2975 decoder.debug_check_bounds::<Self>(offset);
2976 let prim = decoder.read_num::<u32>(offset);
2977
2978 *self = Self::from_primitive_allow_unknown(prim);
2979 Ok(())
2980 }
2981 }
2982 unsafe impl fidl::encoding::TypeMarker for StartError {
2983 type Owned = Self;
2984
2985 #[inline(always)]
2986 fn inline_align(_context: fidl::encoding::Context) -> usize {
2987 std::mem::align_of::<u32>()
2988 }
2989
2990 #[inline(always)]
2991 fn inline_size(_context: fidl::encoding::Context) -> usize {
2992 std::mem::size_of::<u32>()
2993 }
2994
2995 #[inline(always)]
2996 fn encode_is_copy() -> bool {
2997 false
2998 }
2999
3000 #[inline(always)]
3001 fn decode_is_copy() -> bool {
3002 false
3003 }
3004 }
3005
3006 impl fidl::encoding::ValueTypeMarker for StartError {
3007 type Borrowed<'a> = Self;
3008 #[inline(always)]
3009 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3010 *value
3011 }
3012 }
3013
3014 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StartError {
3015 #[inline]
3016 unsafe fn encode(
3017 self,
3018 encoder: &mut fidl::encoding::Encoder<'_, D>,
3019 offset: usize,
3020 _depth: fidl::encoding::Depth,
3021 ) -> fidl::Result<()> {
3022 encoder.debug_check_bounds::<Self>(offset);
3023 encoder.write_num(self.into_primitive(), offset);
3024 Ok(())
3025 }
3026 }
3027
3028 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartError {
3029 #[inline(always)]
3030 fn new_empty() -> Self {
3031 Self::unknown()
3032 }
3033
3034 #[inline]
3035 unsafe fn decode(
3036 &mut self,
3037 decoder: &mut fidl::encoding::Decoder<'_, D>,
3038 offset: usize,
3039 _depth: fidl::encoding::Depth,
3040 ) -> fidl::Result<()> {
3041 decoder.debug_check_bounds::<Self>(offset);
3042 let prim = decoder.read_num::<u32>(offset);
3043
3044 *self = Self::from_primitive_allow_unknown(prim);
3045 Ok(())
3046 }
3047 }
3048 unsafe impl fidl::encoding::TypeMarker for StatusError {
3049 type Owned = Self;
3050
3051 #[inline(always)]
3052 fn inline_align(_context: fidl::encoding::Context) -> usize {
3053 std::mem::align_of::<u32>()
3054 }
3055
3056 #[inline(always)]
3057 fn inline_size(_context: fidl::encoding::Context) -> usize {
3058 std::mem::size_of::<u32>()
3059 }
3060
3061 #[inline(always)]
3062 fn encode_is_copy() -> bool {
3063 true
3064 }
3065
3066 #[inline(always)]
3067 fn decode_is_copy() -> bool {
3068 false
3069 }
3070 }
3071
3072 impl fidl::encoding::ValueTypeMarker for StatusError {
3073 type Borrowed<'a> = Self;
3074 #[inline(always)]
3075 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3076 *value
3077 }
3078 }
3079
3080 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StatusError {
3081 #[inline]
3082 unsafe fn encode(
3083 self,
3084 encoder: &mut fidl::encoding::Encoder<'_, D>,
3085 offset: usize,
3086 _depth: fidl::encoding::Depth,
3087 ) -> fidl::Result<()> {
3088 encoder.debug_check_bounds::<Self>(offset);
3089 encoder.write_num(self.into_primitive(), offset);
3090 Ok(())
3091 }
3092 }
3093
3094 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StatusError {
3095 #[inline(always)]
3096 fn new_empty() -> Self {
3097 Self::Provider
3098 }
3099
3100 #[inline]
3101 unsafe fn decode(
3102 &mut self,
3103 decoder: &mut fidl::encoding::Decoder<'_, D>,
3104 offset: usize,
3105 _depth: fidl::encoding::Depth,
3106 ) -> fidl::Result<()> {
3107 decoder.debug_check_bounds::<Self>(offset);
3108 let prim = decoder.read_num::<u32>(offset);
3109
3110 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3111 Ok(())
3112 }
3113 }
3114 unsafe impl fidl::encoding::TypeMarker for StopError {
3115 type Owned = Self;
3116
3117 #[inline(always)]
3118 fn inline_align(_context: fidl::encoding::Context) -> usize {
3119 std::mem::align_of::<u32>()
3120 }
3121
3122 #[inline(always)]
3123 fn inline_size(_context: fidl::encoding::Context) -> usize {
3124 std::mem::size_of::<u32>()
3125 }
3126
3127 #[inline(always)]
3128 fn encode_is_copy() -> bool {
3129 false
3130 }
3131
3132 #[inline(always)]
3133 fn decode_is_copy() -> bool {
3134 false
3135 }
3136 }
3137
3138 impl fidl::encoding::ValueTypeMarker for StopError {
3139 type Borrowed<'a> = Self;
3140 #[inline(always)]
3141 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3142 *value
3143 }
3144 }
3145
3146 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StopError {
3147 #[inline]
3148 unsafe fn encode(
3149 self,
3150 encoder: &mut fidl::encoding::Encoder<'_, D>,
3151 offset: usize,
3152 _depth: fidl::encoding::Depth,
3153 ) -> fidl::Result<()> {
3154 encoder.debug_check_bounds::<Self>(offset);
3155 encoder.write_num(self.into_primitive(), offset);
3156 Ok(())
3157 }
3158 }
3159
3160 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopError {
3161 #[inline(always)]
3162 fn new_empty() -> Self {
3163 Self::unknown()
3164 }
3165
3166 #[inline]
3167 unsafe fn decode(
3168 &mut self,
3169 decoder: &mut fidl::encoding::Decoder<'_, D>,
3170 offset: usize,
3171 _depth: fidl::encoding::Depth,
3172 ) -> fidl::Result<()> {
3173 decoder.debug_check_bounds::<Self>(offset);
3174 let prim = decoder.read_num::<u32>(offset);
3175
3176 *self = Self::from_primitive_allow_unknown(prim);
3177 Ok(())
3178 }
3179 }
3180 unsafe impl fidl::encoding::TypeMarker for UnresolveError {
3181 type Owned = Self;
3182
3183 #[inline(always)]
3184 fn inline_align(_context: fidl::encoding::Context) -> usize {
3185 std::mem::align_of::<u32>()
3186 }
3187
3188 #[inline(always)]
3189 fn inline_size(_context: fidl::encoding::Context) -> usize {
3190 std::mem::size_of::<u32>()
3191 }
3192
3193 #[inline(always)]
3194 fn encode_is_copy() -> bool {
3195 false
3196 }
3197
3198 #[inline(always)]
3199 fn decode_is_copy() -> bool {
3200 false
3201 }
3202 }
3203
3204 impl fidl::encoding::ValueTypeMarker for UnresolveError {
3205 type Borrowed<'a> = Self;
3206 #[inline(always)]
3207 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3208 *value
3209 }
3210 }
3211
3212 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for UnresolveError {
3213 #[inline]
3214 unsafe fn encode(
3215 self,
3216 encoder: &mut fidl::encoding::Encoder<'_, D>,
3217 offset: usize,
3218 _depth: fidl::encoding::Depth,
3219 ) -> fidl::Result<()> {
3220 encoder.debug_check_bounds::<Self>(offset);
3221 encoder.write_num(self.into_primitive(), offset);
3222 Ok(())
3223 }
3224 }
3225
3226 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UnresolveError {
3227 #[inline(always)]
3228 fn new_empty() -> Self {
3229 Self::unknown()
3230 }
3231
3232 #[inline]
3233 unsafe fn decode(
3234 &mut self,
3235 decoder: &mut fidl::encoding::Decoder<'_, D>,
3236 offset: usize,
3237 _depth: fidl::encoding::Depth,
3238 ) -> fidl::Result<()> {
3239 decoder.debug_check_bounds::<Self>(offset);
3240 let prim = decoder.read_num::<u32>(offset);
3241
3242 *self = Self::from_primitive_allow_unknown(prim);
3243 Ok(())
3244 }
3245 }
3246
3247 impl fidl::encoding::ValueTypeMarker for ConfigOverrideSetStructuredConfigRequest {
3248 type Borrowed<'a> = &'a Self;
3249 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3250 value
3251 }
3252 }
3253
3254 unsafe impl fidl::encoding::TypeMarker for ConfigOverrideSetStructuredConfigRequest {
3255 type Owned = Self;
3256
3257 #[inline(always)]
3258 fn inline_align(_context: fidl::encoding::Context) -> usize {
3259 8
3260 }
3261
3262 #[inline(always)]
3263 fn inline_size(_context: fidl::encoding::Context) -> usize {
3264 32
3265 }
3266 }
3267
3268 unsafe impl<D: fidl::encoding::ResourceDialect>
3269 fidl::encoding::Encode<ConfigOverrideSetStructuredConfigRequest, D>
3270 for &ConfigOverrideSetStructuredConfigRequest
3271 {
3272 #[inline]
3273 unsafe fn encode(
3274 self,
3275 encoder: &mut fidl::encoding::Encoder<'_, D>,
3276 offset: usize,
3277 _depth: fidl::encoding::Depth,
3278 ) -> fidl::Result<()> {
3279 encoder.debug_check_bounds::<ConfigOverrideSetStructuredConfigRequest>(offset);
3280 fidl::encoding::Encode::<ConfigOverrideSetStructuredConfigRequest, D>::encode(
3282 (
3283 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.moniker),
3284 <fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::ConfigOverride> as fidl::encoding::ValueTypeMarker>::borrow(&self.fields),
3285 ),
3286 encoder, offset, _depth
3287 )
3288 }
3289 }
3290 unsafe impl<
3291 D: fidl::encoding::ResourceDialect,
3292 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3293 T1: fidl::encoding::Encode<
3294 fidl::encoding::UnboundedVector<
3295 fidl_fuchsia_component_decl__common::ConfigOverride,
3296 >,
3297 D,
3298 >,
3299 > fidl::encoding::Encode<ConfigOverrideSetStructuredConfigRequest, D> for (T0, T1)
3300 {
3301 #[inline]
3302 unsafe fn encode(
3303 self,
3304 encoder: &mut fidl::encoding::Encoder<'_, D>,
3305 offset: usize,
3306 depth: fidl::encoding::Depth,
3307 ) -> fidl::Result<()> {
3308 encoder.debug_check_bounds::<ConfigOverrideSetStructuredConfigRequest>(offset);
3309 self.0.encode(encoder, offset + 0, depth)?;
3313 self.1.encode(encoder, offset + 16, depth)?;
3314 Ok(())
3315 }
3316 }
3317
3318 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3319 for ConfigOverrideSetStructuredConfigRequest
3320 {
3321 #[inline(always)]
3322 fn new_empty() -> Self {
3323 Self {
3324 moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
3325 fields: fidl::new_empty!(
3326 fidl::encoding::UnboundedVector<
3327 fidl_fuchsia_component_decl__common::ConfigOverride,
3328 >,
3329 D
3330 ),
3331 }
3332 }
3333
3334 #[inline]
3335 unsafe fn decode(
3336 &mut self,
3337 decoder: &mut fidl::encoding::Decoder<'_, D>,
3338 offset: usize,
3339 _depth: fidl::encoding::Depth,
3340 ) -> fidl::Result<()> {
3341 decoder.debug_check_bounds::<Self>(offset);
3342 fidl::decode!(
3344 fidl::encoding::BoundedString<4096>,
3345 D,
3346 &mut self.moniker,
3347 decoder,
3348 offset + 0,
3349 _depth
3350 )?;
3351 fidl::decode!(
3352 fidl::encoding::UnboundedVector<
3353 fidl_fuchsia_component_decl__common::ConfigOverride,
3354 >,
3355 D,
3356 &mut self.fields,
3357 decoder,
3358 offset + 16,
3359 _depth
3360 )?;
3361 Ok(())
3362 }
3363 }
3364
3365 impl fidl::encoding::ValueTypeMarker for ConfigOverrideUnsetStructuredConfigRequest {
3366 type Borrowed<'a> = &'a Self;
3367 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3368 value
3369 }
3370 }
3371
3372 unsafe impl fidl::encoding::TypeMarker for ConfigOverrideUnsetStructuredConfigRequest {
3373 type Owned = Self;
3374
3375 #[inline(always)]
3376 fn inline_align(_context: fidl::encoding::Context) -> usize {
3377 8
3378 }
3379
3380 #[inline(always)]
3381 fn inline_size(_context: fidl::encoding::Context) -> usize {
3382 16
3383 }
3384 }
3385
3386 unsafe impl<D: fidl::encoding::ResourceDialect>
3387 fidl::encoding::Encode<ConfigOverrideUnsetStructuredConfigRequest, D>
3388 for &ConfigOverrideUnsetStructuredConfigRequest
3389 {
3390 #[inline]
3391 unsafe fn encode(
3392 self,
3393 encoder: &mut fidl::encoding::Encoder<'_, D>,
3394 offset: usize,
3395 _depth: fidl::encoding::Depth,
3396 ) -> fidl::Result<()> {
3397 encoder.debug_check_bounds::<ConfigOverrideUnsetStructuredConfigRequest>(offset);
3398 fidl::encoding::Encode::<ConfigOverrideUnsetStructuredConfigRequest, D>::encode(
3400 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
3401 &self.moniker,
3402 ),),
3403 encoder,
3404 offset,
3405 _depth,
3406 )
3407 }
3408 }
3409 unsafe impl<
3410 D: fidl::encoding::ResourceDialect,
3411 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3412 > fidl::encoding::Encode<ConfigOverrideUnsetStructuredConfigRequest, D> for (T0,)
3413 {
3414 #[inline]
3415 unsafe fn encode(
3416 self,
3417 encoder: &mut fidl::encoding::Encoder<'_, D>,
3418 offset: usize,
3419 depth: fidl::encoding::Depth,
3420 ) -> fidl::Result<()> {
3421 encoder.debug_check_bounds::<ConfigOverrideUnsetStructuredConfigRequest>(offset);
3422 self.0.encode(encoder, offset + 0, depth)?;
3426 Ok(())
3427 }
3428 }
3429
3430 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3431 for ConfigOverrideUnsetStructuredConfigRequest
3432 {
3433 #[inline(always)]
3434 fn new_empty() -> Self {
3435 Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
3436 }
3437
3438 #[inline]
3439 unsafe fn decode(
3440 &mut self,
3441 decoder: &mut fidl::encoding::Decoder<'_, D>,
3442 offset: usize,
3443 _depth: fidl::encoding::Depth,
3444 ) -> fidl::Result<()> {
3445 decoder.debug_check_bounds::<Self>(offset);
3446 fidl::decode!(
3448 fidl::encoding::BoundedString<4096>,
3449 D,
3450 &mut self.moniker,
3451 decoder,
3452 offset + 0,
3453 _depth
3454 )?;
3455 Ok(())
3456 }
3457 }
3458
3459 impl fidl::encoding::ValueTypeMarker for CrashIntrospectFindComponentByThreadKoidResponse {
3460 type Borrowed<'a> = &'a Self;
3461 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3462 value
3463 }
3464 }
3465
3466 unsafe impl fidl::encoding::TypeMarker for CrashIntrospectFindComponentByThreadKoidResponse {
3467 type Owned = Self;
3468
3469 #[inline(always)]
3470 fn inline_align(_context: fidl::encoding::Context) -> usize {
3471 8
3472 }
3473
3474 #[inline(always)]
3475 fn inline_size(_context: fidl::encoding::Context) -> usize {
3476 16
3477 }
3478 }
3479
3480 unsafe impl<D: fidl::encoding::ResourceDialect>
3481 fidl::encoding::Encode<CrashIntrospectFindComponentByThreadKoidResponse, D>
3482 for &CrashIntrospectFindComponentByThreadKoidResponse
3483 {
3484 #[inline]
3485 unsafe fn encode(
3486 self,
3487 encoder: &mut fidl::encoding::Encoder<'_, D>,
3488 offset: usize,
3489 _depth: fidl::encoding::Depth,
3490 ) -> fidl::Result<()> {
3491 encoder.debug_check_bounds::<CrashIntrospectFindComponentByThreadKoidResponse>(offset);
3492 fidl::encoding::Encode::<CrashIntrospectFindComponentByThreadKoidResponse, D>::encode(
3494 (<ComponentCrashInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
3495 encoder,
3496 offset,
3497 _depth,
3498 )
3499 }
3500 }
3501 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ComponentCrashInfo, D>>
3502 fidl::encoding::Encode<CrashIntrospectFindComponentByThreadKoidResponse, D> for (T0,)
3503 {
3504 #[inline]
3505 unsafe fn encode(
3506 self,
3507 encoder: &mut fidl::encoding::Encoder<'_, D>,
3508 offset: usize,
3509 depth: fidl::encoding::Depth,
3510 ) -> fidl::Result<()> {
3511 encoder.debug_check_bounds::<CrashIntrospectFindComponentByThreadKoidResponse>(offset);
3512 self.0.encode(encoder, offset + 0, depth)?;
3516 Ok(())
3517 }
3518 }
3519
3520 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3521 for CrashIntrospectFindComponentByThreadKoidResponse
3522 {
3523 #[inline(always)]
3524 fn new_empty() -> Self {
3525 Self { info: fidl::new_empty!(ComponentCrashInfo, D) }
3526 }
3527
3528 #[inline]
3529 unsafe fn decode(
3530 &mut self,
3531 decoder: &mut fidl::encoding::Decoder<'_, D>,
3532 offset: usize,
3533 _depth: fidl::encoding::Depth,
3534 ) -> fidl::Result<()> {
3535 decoder.debug_check_bounds::<Self>(offset);
3536 fidl::decode!(ComponentCrashInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
3538 Ok(())
3539 }
3540 }
3541
3542 impl fidl::encoding::ValueTypeMarker for InstanceIteratorNextResponse {
3543 type Borrowed<'a> = &'a Self;
3544 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3545 value
3546 }
3547 }
3548
3549 unsafe impl fidl::encoding::TypeMarker for InstanceIteratorNextResponse {
3550 type Owned = Self;
3551
3552 #[inline(always)]
3553 fn inline_align(_context: fidl::encoding::Context) -> usize {
3554 8
3555 }
3556
3557 #[inline(always)]
3558 fn inline_size(_context: fidl::encoding::Context) -> usize {
3559 16
3560 }
3561 }
3562
3563 unsafe impl<D: fidl::encoding::ResourceDialect>
3564 fidl::encoding::Encode<InstanceIteratorNextResponse, D> for &InstanceIteratorNextResponse
3565 {
3566 #[inline]
3567 unsafe fn encode(
3568 self,
3569 encoder: &mut fidl::encoding::Encoder<'_, D>,
3570 offset: usize,
3571 _depth: fidl::encoding::Depth,
3572 ) -> fidl::Result<()> {
3573 encoder.debug_check_bounds::<InstanceIteratorNextResponse>(offset);
3574 fidl::encoding::Encode::<InstanceIteratorNextResponse, D>::encode(
3576 (
3577 <fidl::encoding::UnboundedVector<Instance> as fidl::encoding::ValueTypeMarker>::borrow(&self.infos),
3578 ),
3579 encoder, offset, _depth
3580 )
3581 }
3582 }
3583 unsafe impl<
3584 D: fidl::encoding::ResourceDialect,
3585 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Instance>, D>,
3586 > fidl::encoding::Encode<InstanceIteratorNextResponse, D> for (T0,)
3587 {
3588 #[inline]
3589 unsafe fn encode(
3590 self,
3591 encoder: &mut fidl::encoding::Encoder<'_, D>,
3592 offset: usize,
3593 depth: fidl::encoding::Depth,
3594 ) -> fidl::Result<()> {
3595 encoder.debug_check_bounds::<InstanceIteratorNextResponse>(offset);
3596 self.0.encode(encoder, offset + 0, depth)?;
3600 Ok(())
3601 }
3602 }
3603
3604 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3605 for InstanceIteratorNextResponse
3606 {
3607 #[inline(always)]
3608 fn new_empty() -> Self {
3609 Self { infos: fidl::new_empty!(fidl::encoding::UnboundedVector<Instance>, D) }
3610 }
3611
3612 #[inline]
3613 unsafe fn decode(
3614 &mut self,
3615 decoder: &mut fidl::encoding::Decoder<'_, D>,
3616 offset: usize,
3617 _depth: fidl::encoding::Depth,
3618 ) -> fidl::Result<()> {
3619 decoder.debug_check_bounds::<Self>(offset);
3620 fidl::decode!(
3622 fidl::encoding::UnboundedVector<Instance>,
3623 D,
3624 &mut self.infos,
3625 decoder,
3626 offset + 0,
3627 _depth
3628 )?;
3629 Ok(())
3630 }
3631 }
3632
3633 impl fidl::encoding::ValueTypeMarker for LifecycleControllerDestroyInstanceRequest {
3634 type Borrowed<'a> = &'a Self;
3635 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3636 value
3637 }
3638 }
3639
3640 unsafe impl fidl::encoding::TypeMarker for LifecycleControllerDestroyInstanceRequest {
3641 type Owned = Self;
3642
3643 #[inline(always)]
3644 fn inline_align(_context: fidl::encoding::Context) -> usize {
3645 8
3646 }
3647
3648 #[inline(always)]
3649 fn inline_size(_context: fidl::encoding::Context) -> usize {
3650 48
3651 }
3652 }
3653
3654 unsafe impl<D: fidl::encoding::ResourceDialect>
3655 fidl::encoding::Encode<LifecycleControllerDestroyInstanceRequest, D>
3656 for &LifecycleControllerDestroyInstanceRequest
3657 {
3658 #[inline]
3659 unsafe fn encode(
3660 self,
3661 encoder: &mut fidl::encoding::Encoder<'_, D>,
3662 offset: usize,
3663 _depth: fidl::encoding::Depth,
3664 ) -> fidl::Result<()> {
3665 encoder.debug_check_bounds::<LifecycleControllerDestroyInstanceRequest>(offset);
3666 fidl::encoding::Encode::<LifecycleControllerDestroyInstanceRequest, D>::encode(
3668 (
3669 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.parent_moniker),
3670 <fidl_fuchsia_component_decl__common::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(&self.child),
3671 ),
3672 encoder, offset, _depth
3673 )
3674 }
3675 }
3676 unsafe impl<
3677 D: fidl::encoding::ResourceDialect,
3678 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3679 T1: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::ChildRef, D>,
3680 > fidl::encoding::Encode<LifecycleControllerDestroyInstanceRequest, D> for (T0, T1)
3681 {
3682 #[inline]
3683 unsafe fn encode(
3684 self,
3685 encoder: &mut fidl::encoding::Encoder<'_, D>,
3686 offset: usize,
3687 depth: fidl::encoding::Depth,
3688 ) -> fidl::Result<()> {
3689 encoder.debug_check_bounds::<LifecycleControllerDestroyInstanceRequest>(offset);
3690 self.0.encode(encoder, offset + 0, depth)?;
3694 self.1.encode(encoder, offset + 16, depth)?;
3695 Ok(())
3696 }
3697 }
3698
3699 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3700 for LifecycleControllerDestroyInstanceRequest
3701 {
3702 #[inline(always)]
3703 fn new_empty() -> Self {
3704 Self {
3705 parent_moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
3706 child: fidl::new_empty!(fidl_fuchsia_component_decl__common::ChildRef, D),
3707 }
3708 }
3709
3710 #[inline]
3711 unsafe fn decode(
3712 &mut self,
3713 decoder: &mut fidl::encoding::Decoder<'_, D>,
3714 offset: usize,
3715 _depth: fidl::encoding::Depth,
3716 ) -> fidl::Result<()> {
3717 decoder.debug_check_bounds::<Self>(offset);
3718 fidl::decode!(
3720 fidl::encoding::BoundedString<4096>,
3721 D,
3722 &mut self.parent_moniker,
3723 decoder,
3724 offset + 0,
3725 _depth
3726 )?;
3727 fidl::decode!(
3728 fidl_fuchsia_component_decl__common::ChildRef,
3729 D,
3730 &mut self.child,
3731 decoder,
3732 offset + 16,
3733 _depth
3734 )?;
3735 Ok(())
3736 }
3737 }
3738
3739 impl fidl::encoding::ValueTypeMarker for LifecycleControllerResolveInstanceRequest {
3740 type Borrowed<'a> = &'a Self;
3741 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3742 value
3743 }
3744 }
3745
3746 unsafe impl fidl::encoding::TypeMarker for LifecycleControllerResolveInstanceRequest {
3747 type Owned = Self;
3748
3749 #[inline(always)]
3750 fn inline_align(_context: fidl::encoding::Context) -> usize {
3751 8
3752 }
3753
3754 #[inline(always)]
3755 fn inline_size(_context: fidl::encoding::Context) -> usize {
3756 16
3757 }
3758 }
3759
3760 unsafe impl<D: fidl::encoding::ResourceDialect>
3761 fidl::encoding::Encode<LifecycleControllerResolveInstanceRequest, D>
3762 for &LifecycleControllerResolveInstanceRequest
3763 {
3764 #[inline]
3765 unsafe fn encode(
3766 self,
3767 encoder: &mut fidl::encoding::Encoder<'_, D>,
3768 offset: usize,
3769 _depth: fidl::encoding::Depth,
3770 ) -> fidl::Result<()> {
3771 encoder.debug_check_bounds::<LifecycleControllerResolveInstanceRequest>(offset);
3772 fidl::encoding::Encode::<LifecycleControllerResolveInstanceRequest, D>::encode(
3774 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
3775 &self.moniker,
3776 ),),
3777 encoder,
3778 offset,
3779 _depth,
3780 )
3781 }
3782 }
3783 unsafe impl<
3784 D: fidl::encoding::ResourceDialect,
3785 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3786 > fidl::encoding::Encode<LifecycleControllerResolveInstanceRequest, D> for (T0,)
3787 {
3788 #[inline]
3789 unsafe fn encode(
3790 self,
3791 encoder: &mut fidl::encoding::Encoder<'_, D>,
3792 offset: usize,
3793 depth: fidl::encoding::Depth,
3794 ) -> fidl::Result<()> {
3795 encoder.debug_check_bounds::<LifecycleControllerResolveInstanceRequest>(offset);
3796 self.0.encode(encoder, offset + 0, depth)?;
3800 Ok(())
3801 }
3802 }
3803
3804 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3805 for LifecycleControllerResolveInstanceRequest
3806 {
3807 #[inline(always)]
3808 fn new_empty() -> Self {
3809 Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
3810 }
3811
3812 #[inline]
3813 unsafe fn decode(
3814 &mut self,
3815 decoder: &mut fidl::encoding::Decoder<'_, D>,
3816 offset: usize,
3817 _depth: fidl::encoding::Depth,
3818 ) -> fidl::Result<()> {
3819 decoder.debug_check_bounds::<Self>(offset);
3820 fidl::decode!(
3822 fidl::encoding::BoundedString<4096>,
3823 D,
3824 &mut self.moniker,
3825 decoder,
3826 offset + 0,
3827 _depth
3828 )?;
3829 Ok(())
3830 }
3831 }
3832
3833 impl fidl::encoding::ValueTypeMarker for LifecycleControllerStopInstanceRequest {
3834 type Borrowed<'a> = &'a Self;
3835 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3836 value
3837 }
3838 }
3839
3840 unsafe impl fidl::encoding::TypeMarker for LifecycleControllerStopInstanceRequest {
3841 type Owned = Self;
3842
3843 #[inline(always)]
3844 fn inline_align(_context: fidl::encoding::Context) -> usize {
3845 8
3846 }
3847
3848 #[inline(always)]
3849 fn inline_size(_context: fidl::encoding::Context) -> usize {
3850 16
3851 }
3852 }
3853
3854 unsafe impl<D: fidl::encoding::ResourceDialect>
3855 fidl::encoding::Encode<LifecycleControllerStopInstanceRequest, D>
3856 for &LifecycleControllerStopInstanceRequest
3857 {
3858 #[inline]
3859 unsafe fn encode(
3860 self,
3861 encoder: &mut fidl::encoding::Encoder<'_, D>,
3862 offset: usize,
3863 _depth: fidl::encoding::Depth,
3864 ) -> fidl::Result<()> {
3865 encoder.debug_check_bounds::<LifecycleControllerStopInstanceRequest>(offset);
3866 fidl::encoding::Encode::<LifecycleControllerStopInstanceRequest, D>::encode(
3868 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
3869 &self.moniker,
3870 ),),
3871 encoder,
3872 offset,
3873 _depth,
3874 )
3875 }
3876 }
3877 unsafe impl<
3878 D: fidl::encoding::ResourceDialect,
3879 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3880 > fidl::encoding::Encode<LifecycleControllerStopInstanceRequest, D> for (T0,)
3881 {
3882 #[inline]
3883 unsafe fn encode(
3884 self,
3885 encoder: &mut fidl::encoding::Encoder<'_, D>,
3886 offset: usize,
3887 depth: fidl::encoding::Depth,
3888 ) -> fidl::Result<()> {
3889 encoder.debug_check_bounds::<LifecycleControllerStopInstanceRequest>(offset);
3890 self.0.encode(encoder, offset + 0, depth)?;
3894 Ok(())
3895 }
3896 }
3897
3898 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3899 for LifecycleControllerStopInstanceRequest
3900 {
3901 #[inline(always)]
3902 fn new_empty() -> Self {
3903 Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
3904 }
3905
3906 #[inline]
3907 unsafe fn decode(
3908 &mut self,
3909 decoder: &mut fidl::encoding::Decoder<'_, D>,
3910 offset: usize,
3911 _depth: fidl::encoding::Depth,
3912 ) -> fidl::Result<()> {
3913 decoder.debug_check_bounds::<Self>(offset);
3914 fidl::decode!(
3916 fidl::encoding::BoundedString<4096>,
3917 D,
3918 &mut self.moniker,
3919 decoder,
3920 offset + 0,
3921 _depth
3922 )?;
3923 Ok(())
3924 }
3925 }
3926
3927 impl fidl::encoding::ValueTypeMarker for LifecycleControllerUnresolveInstanceRequest {
3928 type Borrowed<'a> = &'a Self;
3929 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3930 value
3931 }
3932 }
3933
3934 unsafe impl fidl::encoding::TypeMarker for LifecycleControllerUnresolveInstanceRequest {
3935 type Owned = Self;
3936
3937 #[inline(always)]
3938 fn inline_align(_context: fidl::encoding::Context) -> usize {
3939 8
3940 }
3941
3942 #[inline(always)]
3943 fn inline_size(_context: fidl::encoding::Context) -> usize {
3944 16
3945 }
3946 }
3947
3948 unsafe impl<D: fidl::encoding::ResourceDialect>
3949 fidl::encoding::Encode<LifecycleControllerUnresolveInstanceRequest, D>
3950 for &LifecycleControllerUnresolveInstanceRequest
3951 {
3952 #[inline]
3953 unsafe fn encode(
3954 self,
3955 encoder: &mut fidl::encoding::Encoder<'_, D>,
3956 offset: usize,
3957 _depth: fidl::encoding::Depth,
3958 ) -> fidl::Result<()> {
3959 encoder.debug_check_bounds::<LifecycleControllerUnresolveInstanceRequest>(offset);
3960 fidl::encoding::Encode::<LifecycleControllerUnresolveInstanceRequest, D>::encode(
3962 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
3963 &self.moniker,
3964 ),),
3965 encoder,
3966 offset,
3967 _depth,
3968 )
3969 }
3970 }
3971 unsafe impl<
3972 D: fidl::encoding::ResourceDialect,
3973 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3974 > fidl::encoding::Encode<LifecycleControllerUnresolveInstanceRequest, D> for (T0,)
3975 {
3976 #[inline]
3977 unsafe fn encode(
3978 self,
3979 encoder: &mut fidl::encoding::Encoder<'_, D>,
3980 offset: usize,
3981 depth: fidl::encoding::Depth,
3982 ) -> fidl::Result<()> {
3983 encoder.debug_check_bounds::<LifecycleControllerUnresolveInstanceRequest>(offset);
3984 self.0.encode(encoder, offset + 0, depth)?;
3988 Ok(())
3989 }
3990 }
3991
3992 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3993 for LifecycleControllerUnresolveInstanceRequest
3994 {
3995 #[inline(always)]
3996 fn new_empty() -> Self {
3997 Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
3998 }
3999
4000 #[inline]
4001 unsafe fn decode(
4002 &mut self,
4003 decoder: &mut fidl::encoding::Decoder<'_, D>,
4004 offset: usize,
4005 _depth: fidl::encoding::Depth,
4006 ) -> fidl::Result<()> {
4007 decoder.debug_check_bounds::<Self>(offset);
4008 fidl::decode!(
4010 fidl::encoding::BoundedString<4096>,
4011 D,
4012 &mut self.moniker,
4013 decoder,
4014 offset + 0,
4015 _depth
4016 )?;
4017 Ok(())
4018 }
4019 }
4020
4021 impl fidl::encoding::ValueTypeMarker for ManifestBytesIteratorNextResponse {
4022 type Borrowed<'a> = &'a Self;
4023 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4024 value
4025 }
4026 }
4027
4028 unsafe impl fidl::encoding::TypeMarker for ManifestBytesIteratorNextResponse {
4029 type Owned = Self;
4030
4031 #[inline(always)]
4032 fn inline_align(_context: fidl::encoding::Context) -> usize {
4033 8
4034 }
4035
4036 #[inline(always)]
4037 fn inline_size(_context: fidl::encoding::Context) -> usize {
4038 16
4039 }
4040 }
4041
4042 unsafe impl<D: fidl::encoding::ResourceDialect>
4043 fidl::encoding::Encode<ManifestBytesIteratorNextResponse, D>
4044 for &ManifestBytesIteratorNextResponse
4045 {
4046 #[inline]
4047 unsafe fn encode(
4048 self,
4049 encoder: &mut fidl::encoding::Encoder<'_, D>,
4050 offset: usize,
4051 _depth: fidl::encoding::Depth,
4052 ) -> fidl::Result<()> {
4053 encoder.debug_check_bounds::<ManifestBytesIteratorNextResponse>(offset);
4054 fidl::encoding::Encode::<ManifestBytesIteratorNextResponse, D>::encode(
4056 (<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(
4057 &self.infos,
4058 ),),
4059 encoder,
4060 offset,
4061 _depth,
4062 )
4063 }
4064 }
4065 unsafe impl<
4066 D: fidl::encoding::ResourceDialect,
4067 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
4068 > fidl::encoding::Encode<ManifestBytesIteratorNextResponse, D> for (T0,)
4069 {
4070 #[inline]
4071 unsafe fn encode(
4072 self,
4073 encoder: &mut fidl::encoding::Encoder<'_, D>,
4074 offset: usize,
4075 depth: fidl::encoding::Depth,
4076 ) -> fidl::Result<()> {
4077 encoder.debug_check_bounds::<ManifestBytesIteratorNextResponse>(offset);
4078 self.0.encode(encoder, offset + 0, depth)?;
4082 Ok(())
4083 }
4084 }
4085
4086 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4087 for ManifestBytesIteratorNextResponse
4088 {
4089 #[inline(always)]
4090 fn new_empty() -> Self {
4091 Self { infos: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D) }
4092 }
4093
4094 #[inline]
4095 unsafe fn decode(
4096 &mut self,
4097 decoder: &mut fidl::encoding::Decoder<'_, D>,
4098 offset: usize,
4099 _depth: fidl::encoding::Depth,
4100 ) -> fidl::Result<()> {
4101 decoder.debug_check_bounds::<Self>(offset);
4102 fidl::decode!(
4104 fidl::encoding::UnboundedVector<u8>,
4105 D,
4106 &mut self.infos,
4107 decoder,
4108 offset + 0,
4109 _depth
4110 )?;
4111 Ok(())
4112 }
4113 }
4114
4115 impl fidl::encoding::ValueTypeMarker for RealmQueryConstructNamespaceRequest {
4116 type Borrowed<'a> = &'a Self;
4117 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4118 value
4119 }
4120 }
4121
4122 unsafe impl fidl::encoding::TypeMarker for RealmQueryConstructNamespaceRequest {
4123 type Owned = Self;
4124
4125 #[inline(always)]
4126 fn inline_align(_context: fidl::encoding::Context) -> usize {
4127 8
4128 }
4129
4130 #[inline(always)]
4131 fn inline_size(_context: fidl::encoding::Context) -> usize {
4132 16
4133 }
4134 }
4135
4136 unsafe impl<D: fidl::encoding::ResourceDialect>
4137 fidl::encoding::Encode<RealmQueryConstructNamespaceRequest, D>
4138 for &RealmQueryConstructNamespaceRequest
4139 {
4140 #[inline]
4141 unsafe fn encode(
4142 self,
4143 encoder: &mut fidl::encoding::Encoder<'_, D>,
4144 offset: usize,
4145 _depth: fidl::encoding::Depth,
4146 ) -> fidl::Result<()> {
4147 encoder.debug_check_bounds::<RealmQueryConstructNamespaceRequest>(offset);
4148 fidl::encoding::Encode::<RealmQueryConstructNamespaceRequest, D>::encode(
4150 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
4151 &self.moniker,
4152 ),),
4153 encoder,
4154 offset,
4155 _depth,
4156 )
4157 }
4158 }
4159 unsafe impl<
4160 D: fidl::encoding::ResourceDialect,
4161 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4162 > fidl::encoding::Encode<RealmQueryConstructNamespaceRequest, D> for (T0,)
4163 {
4164 #[inline]
4165 unsafe fn encode(
4166 self,
4167 encoder: &mut fidl::encoding::Encoder<'_, D>,
4168 offset: usize,
4169 depth: fidl::encoding::Depth,
4170 ) -> fidl::Result<()> {
4171 encoder.debug_check_bounds::<RealmQueryConstructNamespaceRequest>(offset);
4172 self.0.encode(encoder, offset + 0, depth)?;
4176 Ok(())
4177 }
4178 }
4179
4180 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4181 for RealmQueryConstructNamespaceRequest
4182 {
4183 #[inline(always)]
4184 fn new_empty() -> Self {
4185 Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
4186 }
4187
4188 #[inline]
4189 unsafe fn decode(
4190 &mut self,
4191 decoder: &mut fidl::encoding::Decoder<'_, D>,
4192 offset: usize,
4193 _depth: fidl::encoding::Depth,
4194 ) -> fidl::Result<()> {
4195 decoder.debug_check_bounds::<Self>(offset);
4196 fidl::decode!(
4198 fidl::encoding::BoundedString<4096>,
4199 D,
4200 &mut self.moniker,
4201 decoder,
4202 offset + 0,
4203 _depth
4204 )?;
4205 Ok(())
4206 }
4207 }
4208
4209 impl fidl::encoding::ValueTypeMarker for RealmQueryGetInstanceRequest {
4210 type Borrowed<'a> = &'a Self;
4211 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4212 value
4213 }
4214 }
4215
4216 unsafe impl fidl::encoding::TypeMarker for RealmQueryGetInstanceRequest {
4217 type Owned = Self;
4218
4219 #[inline(always)]
4220 fn inline_align(_context: fidl::encoding::Context) -> usize {
4221 8
4222 }
4223
4224 #[inline(always)]
4225 fn inline_size(_context: fidl::encoding::Context) -> usize {
4226 16
4227 }
4228 }
4229
4230 unsafe impl<D: fidl::encoding::ResourceDialect>
4231 fidl::encoding::Encode<RealmQueryGetInstanceRequest, D> for &RealmQueryGetInstanceRequest
4232 {
4233 #[inline]
4234 unsafe fn encode(
4235 self,
4236 encoder: &mut fidl::encoding::Encoder<'_, D>,
4237 offset: usize,
4238 _depth: fidl::encoding::Depth,
4239 ) -> fidl::Result<()> {
4240 encoder.debug_check_bounds::<RealmQueryGetInstanceRequest>(offset);
4241 fidl::encoding::Encode::<RealmQueryGetInstanceRequest, D>::encode(
4243 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
4244 &self.moniker,
4245 ),),
4246 encoder,
4247 offset,
4248 _depth,
4249 )
4250 }
4251 }
4252 unsafe impl<
4253 D: fidl::encoding::ResourceDialect,
4254 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4255 > fidl::encoding::Encode<RealmQueryGetInstanceRequest, D> for (T0,)
4256 {
4257 #[inline]
4258 unsafe fn encode(
4259 self,
4260 encoder: &mut fidl::encoding::Encoder<'_, D>,
4261 offset: usize,
4262 depth: fidl::encoding::Depth,
4263 ) -> fidl::Result<()> {
4264 encoder.debug_check_bounds::<RealmQueryGetInstanceRequest>(offset);
4265 self.0.encode(encoder, offset + 0, depth)?;
4269 Ok(())
4270 }
4271 }
4272
4273 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4274 for RealmQueryGetInstanceRequest
4275 {
4276 #[inline(always)]
4277 fn new_empty() -> Self {
4278 Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
4279 }
4280
4281 #[inline]
4282 unsafe fn decode(
4283 &mut self,
4284 decoder: &mut fidl::encoding::Decoder<'_, D>,
4285 offset: usize,
4286 _depth: fidl::encoding::Depth,
4287 ) -> fidl::Result<()> {
4288 decoder.debug_check_bounds::<Self>(offset);
4289 fidl::decode!(
4291 fidl::encoding::BoundedString<4096>,
4292 D,
4293 &mut self.moniker,
4294 decoder,
4295 offset + 0,
4296 _depth
4297 )?;
4298 Ok(())
4299 }
4300 }
4301
4302 impl fidl::encoding::ValueTypeMarker for RealmQueryGetManifestRequest {
4303 type Borrowed<'a> = &'a Self;
4304 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4305 value
4306 }
4307 }
4308
4309 unsafe impl fidl::encoding::TypeMarker for RealmQueryGetManifestRequest {
4310 type Owned = Self;
4311
4312 #[inline(always)]
4313 fn inline_align(_context: fidl::encoding::Context) -> usize {
4314 8
4315 }
4316
4317 #[inline(always)]
4318 fn inline_size(_context: fidl::encoding::Context) -> usize {
4319 16
4320 }
4321 }
4322
4323 unsafe impl<D: fidl::encoding::ResourceDialect>
4324 fidl::encoding::Encode<RealmQueryGetManifestRequest, D> for &RealmQueryGetManifestRequest
4325 {
4326 #[inline]
4327 unsafe fn encode(
4328 self,
4329 encoder: &mut fidl::encoding::Encoder<'_, D>,
4330 offset: usize,
4331 _depth: fidl::encoding::Depth,
4332 ) -> fidl::Result<()> {
4333 encoder.debug_check_bounds::<RealmQueryGetManifestRequest>(offset);
4334 fidl::encoding::Encode::<RealmQueryGetManifestRequest, D>::encode(
4336 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
4337 &self.moniker,
4338 ),),
4339 encoder,
4340 offset,
4341 _depth,
4342 )
4343 }
4344 }
4345 unsafe impl<
4346 D: fidl::encoding::ResourceDialect,
4347 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4348 > fidl::encoding::Encode<RealmQueryGetManifestRequest, D> for (T0,)
4349 {
4350 #[inline]
4351 unsafe fn encode(
4352 self,
4353 encoder: &mut fidl::encoding::Encoder<'_, D>,
4354 offset: usize,
4355 depth: fidl::encoding::Depth,
4356 ) -> fidl::Result<()> {
4357 encoder.debug_check_bounds::<RealmQueryGetManifestRequest>(offset);
4358 self.0.encode(encoder, offset + 0, depth)?;
4362 Ok(())
4363 }
4364 }
4365
4366 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4367 for RealmQueryGetManifestRequest
4368 {
4369 #[inline(always)]
4370 fn new_empty() -> Self {
4371 Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
4372 }
4373
4374 #[inline]
4375 unsafe fn decode(
4376 &mut self,
4377 decoder: &mut fidl::encoding::Decoder<'_, D>,
4378 offset: usize,
4379 _depth: fidl::encoding::Depth,
4380 ) -> fidl::Result<()> {
4381 decoder.debug_check_bounds::<Self>(offset);
4382 fidl::decode!(
4384 fidl::encoding::BoundedString<4096>,
4385 D,
4386 &mut self.moniker,
4387 decoder,
4388 offset + 0,
4389 _depth
4390 )?;
4391 Ok(())
4392 }
4393 }
4394
4395 impl fidl::encoding::ValueTypeMarker for RealmQueryGetResolvedDeclarationRequest {
4396 type Borrowed<'a> = &'a Self;
4397 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4398 value
4399 }
4400 }
4401
4402 unsafe impl fidl::encoding::TypeMarker for RealmQueryGetResolvedDeclarationRequest {
4403 type Owned = Self;
4404
4405 #[inline(always)]
4406 fn inline_align(_context: fidl::encoding::Context) -> usize {
4407 8
4408 }
4409
4410 #[inline(always)]
4411 fn inline_size(_context: fidl::encoding::Context) -> usize {
4412 16
4413 }
4414 }
4415
4416 unsafe impl<D: fidl::encoding::ResourceDialect>
4417 fidl::encoding::Encode<RealmQueryGetResolvedDeclarationRequest, D>
4418 for &RealmQueryGetResolvedDeclarationRequest
4419 {
4420 #[inline]
4421 unsafe fn encode(
4422 self,
4423 encoder: &mut fidl::encoding::Encoder<'_, D>,
4424 offset: usize,
4425 _depth: fidl::encoding::Depth,
4426 ) -> fidl::Result<()> {
4427 encoder.debug_check_bounds::<RealmQueryGetResolvedDeclarationRequest>(offset);
4428 fidl::encoding::Encode::<RealmQueryGetResolvedDeclarationRequest, D>::encode(
4430 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
4431 &self.moniker,
4432 ),),
4433 encoder,
4434 offset,
4435 _depth,
4436 )
4437 }
4438 }
4439 unsafe impl<
4440 D: fidl::encoding::ResourceDialect,
4441 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4442 > fidl::encoding::Encode<RealmQueryGetResolvedDeclarationRequest, D> for (T0,)
4443 {
4444 #[inline]
4445 unsafe fn encode(
4446 self,
4447 encoder: &mut fidl::encoding::Encoder<'_, D>,
4448 offset: usize,
4449 depth: fidl::encoding::Depth,
4450 ) -> fidl::Result<()> {
4451 encoder.debug_check_bounds::<RealmQueryGetResolvedDeclarationRequest>(offset);
4452 self.0.encode(encoder, offset + 0, depth)?;
4456 Ok(())
4457 }
4458 }
4459
4460 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4461 for RealmQueryGetResolvedDeclarationRequest
4462 {
4463 #[inline(always)]
4464 fn new_empty() -> Self {
4465 Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
4466 }
4467
4468 #[inline]
4469 unsafe fn decode(
4470 &mut self,
4471 decoder: &mut fidl::encoding::Decoder<'_, D>,
4472 offset: usize,
4473 _depth: fidl::encoding::Depth,
4474 ) -> fidl::Result<()> {
4475 decoder.debug_check_bounds::<Self>(offset);
4476 fidl::decode!(
4478 fidl::encoding::BoundedString<4096>,
4479 D,
4480 &mut self.moniker,
4481 decoder,
4482 offset + 0,
4483 _depth
4484 )?;
4485 Ok(())
4486 }
4487 }
4488
4489 impl fidl::encoding::ValueTypeMarker for RealmQueryGetStructuredConfigRequest {
4490 type Borrowed<'a> = &'a Self;
4491 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4492 value
4493 }
4494 }
4495
4496 unsafe impl fidl::encoding::TypeMarker for RealmQueryGetStructuredConfigRequest {
4497 type Owned = Self;
4498
4499 #[inline(always)]
4500 fn inline_align(_context: fidl::encoding::Context) -> usize {
4501 8
4502 }
4503
4504 #[inline(always)]
4505 fn inline_size(_context: fidl::encoding::Context) -> usize {
4506 16
4507 }
4508 }
4509
4510 unsafe impl<D: fidl::encoding::ResourceDialect>
4511 fidl::encoding::Encode<RealmQueryGetStructuredConfigRequest, D>
4512 for &RealmQueryGetStructuredConfigRequest
4513 {
4514 #[inline]
4515 unsafe fn encode(
4516 self,
4517 encoder: &mut fidl::encoding::Encoder<'_, D>,
4518 offset: usize,
4519 _depth: fidl::encoding::Depth,
4520 ) -> fidl::Result<()> {
4521 encoder.debug_check_bounds::<RealmQueryGetStructuredConfigRequest>(offset);
4522 fidl::encoding::Encode::<RealmQueryGetStructuredConfigRequest, D>::encode(
4524 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
4525 &self.moniker,
4526 ),),
4527 encoder,
4528 offset,
4529 _depth,
4530 )
4531 }
4532 }
4533 unsafe impl<
4534 D: fidl::encoding::ResourceDialect,
4535 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4536 > fidl::encoding::Encode<RealmQueryGetStructuredConfigRequest, D> for (T0,)
4537 {
4538 #[inline]
4539 unsafe fn encode(
4540 self,
4541 encoder: &mut fidl::encoding::Encoder<'_, D>,
4542 offset: usize,
4543 depth: fidl::encoding::Depth,
4544 ) -> fidl::Result<()> {
4545 encoder.debug_check_bounds::<RealmQueryGetStructuredConfigRequest>(offset);
4546 self.0.encode(encoder, offset + 0, depth)?;
4550 Ok(())
4551 }
4552 }
4553
4554 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4555 for RealmQueryGetStructuredConfigRequest
4556 {
4557 #[inline(always)]
4558 fn new_empty() -> Self {
4559 Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
4560 }
4561
4562 #[inline]
4563 unsafe fn decode(
4564 &mut self,
4565 decoder: &mut fidl::encoding::Decoder<'_, D>,
4566 offset: usize,
4567 _depth: fidl::encoding::Depth,
4568 ) -> fidl::Result<()> {
4569 decoder.debug_check_bounds::<Self>(offset);
4570 fidl::decode!(
4572 fidl::encoding::BoundedString<4096>,
4573 D,
4574 &mut self.moniker,
4575 decoder,
4576 offset + 0,
4577 _depth
4578 )?;
4579 Ok(())
4580 }
4581 }
4582
4583 impl fidl::encoding::ValueTypeMarker for RealmQueryResolveDeclarationRequest {
4584 type Borrowed<'a> = &'a Self;
4585 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4586 value
4587 }
4588 }
4589
4590 unsafe impl fidl::encoding::TypeMarker for RealmQueryResolveDeclarationRequest {
4591 type Owned = Self;
4592
4593 #[inline(always)]
4594 fn inline_align(_context: fidl::encoding::Context) -> usize {
4595 8
4596 }
4597
4598 #[inline(always)]
4599 fn inline_size(_context: fidl::encoding::Context) -> usize {
4600 48
4601 }
4602 }
4603
4604 unsafe impl<D: fidl::encoding::ResourceDialect>
4605 fidl::encoding::Encode<RealmQueryResolveDeclarationRequest, D>
4606 for &RealmQueryResolveDeclarationRequest
4607 {
4608 #[inline]
4609 unsafe fn encode(
4610 self,
4611 encoder: &mut fidl::encoding::Encoder<'_, D>,
4612 offset: usize,
4613 _depth: fidl::encoding::Depth,
4614 ) -> fidl::Result<()> {
4615 encoder.debug_check_bounds::<RealmQueryResolveDeclarationRequest>(offset);
4616 fidl::encoding::Encode::<RealmQueryResolveDeclarationRequest, D>::encode(
4618 (
4619 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.parent),
4620 <ChildLocation as fidl::encoding::ValueTypeMarker>::borrow(&self.child_location),
4621 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.url),
4622 ),
4623 encoder, offset, _depth
4624 )
4625 }
4626 }
4627 unsafe impl<
4628 D: fidl::encoding::ResourceDialect,
4629 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4630 T1: fidl::encoding::Encode<ChildLocation, D>,
4631 T2: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4632 > fidl::encoding::Encode<RealmQueryResolveDeclarationRequest, D> for (T0, T1, T2)
4633 {
4634 #[inline]
4635 unsafe fn encode(
4636 self,
4637 encoder: &mut fidl::encoding::Encoder<'_, D>,
4638 offset: usize,
4639 depth: fidl::encoding::Depth,
4640 ) -> fidl::Result<()> {
4641 encoder.debug_check_bounds::<RealmQueryResolveDeclarationRequest>(offset);
4642 self.0.encode(encoder, offset + 0, depth)?;
4646 self.1.encode(encoder, offset + 16, depth)?;
4647 self.2.encode(encoder, offset + 32, depth)?;
4648 Ok(())
4649 }
4650 }
4651
4652 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4653 for RealmQueryResolveDeclarationRequest
4654 {
4655 #[inline(always)]
4656 fn new_empty() -> Self {
4657 Self {
4658 parent: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
4659 child_location: fidl::new_empty!(ChildLocation, D),
4660 url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
4661 }
4662 }
4663
4664 #[inline]
4665 unsafe fn decode(
4666 &mut self,
4667 decoder: &mut fidl::encoding::Decoder<'_, D>,
4668 offset: usize,
4669 _depth: fidl::encoding::Depth,
4670 ) -> fidl::Result<()> {
4671 decoder.debug_check_bounds::<Self>(offset);
4672 fidl::decode!(
4674 fidl::encoding::BoundedString<4096>,
4675 D,
4676 &mut self.parent,
4677 decoder,
4678 offset + 0,
4679 _depth
4680 )?;
4681 fidl::decode!(
4682 ChildLocation,
4683 D,
4684 &mut self.child_location,
4685 decoder,
4686 offset + 16,
4687 _depth
4688 )?;
4689 fidl::decode!(
4690 fidl::encoding::BoundedString<4096>,
4691 D,
4692 &mut self.url,
4693 decoder,
4694 offset + 32,
4695 _depth
4696 )?;
4697 Ok(())
4698 }
4699 }
4700
4701 impl fidl::encoding::ValueTypeMarker for RealmQueryGetInstanceResponse {
4702 type Borrowed<'a> = &'a Self;
4703 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4704 value
4705 }
4706 }
4707
4708 unsafe impl fidl::encoding::TypeMarker for RealmQueryGetInstanceResponse {
4709 type Owned = Self;
4710
4711 #[inline(always)]
4712 fn inline_align(_context: fidl::encoding::Context) -> usize {
4713 8
4714 }
4715
4716 #[inline(always)]
4717 fn inline_size(_context: fidl::encoding::Context) -> usize {
4718 16
4719 }
4720 }
4721
4722 unsafe impl<D: fidl::encoding::ResourceDialect>
4723 fidl::encoding::Encode<RealmQueryGetInstanceResponse, D>
4724 for &RealmQueryGetInstanceResponse
4725 {
4726 #[inline]
4727 unsafe fn encode(
4728 self,
4729 encoder: &mut fidl::encoding::Encoder<'_, D>,
4730 offset: usize,
4731 _depth: fidl::encoding::Depth,
4732 ) -> fidl::Result<()> {
4733 encoder.debug_check_bounds::<RealmQueryGetInstanceResponse>(offset);
4734 fidl::encoding::Encode::<RealmQueryGetInstanceResponse, D>::encode(
4736 (<Instance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
4737 encoder,
4738 offset,
4739 _depth,
4740 )
4741 }
4742 }
4743 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Instance, D>>
4744 fidl::encoding::Encode<RealmQueryGetInstanceResponse, D> for (T0,)
4745 {
4746 #[inline]
4747 unsafe fn encode(
4748 self,
4749 encoder: &mut fidl::encoding::Encoder<'_, D>,
4750 offset: usize,
4751 depth: fidl::encoding::Depth,
4752 ) -> fidl::Result<()> {
4753 encoder.debug_check_bounds::<RealmQueryGetInstanceResponse>(offset);
4754 self.0.encode(encoder, offset + 0, depth)?;
4758 Ok(())
4759 }
4760 }
4761
4762 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4763 for RealmQueryGetInstanceResponse
4764 {
4765 #[inline(always)]
4766 fn new_empty() -> Self {
4767 Self { instance: fidl::new_empty!(Instance, D) }
4768 }
4769
4770 #[inline]
4771 unsafe fn decode(
4772 &mut self,
4773 decoder: &mut fidl::encoding::Decoder<'_, D>,
4774 offset: usize,
4775 _depth: fidl::encoding::Depth,
4776 ) -> fidl::Result<()> {
4777 decoder.debug_check_bounds::<Self>(offset);
4778 fidl::decode!(Instance, D, &mut self.instance, decoder, offset + 0, _depth)?;
4780 Ok(())
4781 }
4782 }
4783
4784 impl fidl::encoding::ValueTypeMarker for RealmQueryGetStructuredConfigResponse {
4785 type Borrowed<'a> = &'a Self;
4786 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4787 value
4788 }
4789 }
4790
4791 unsafe impl fidl::encoding::TypeMarker for RealmQueryGetStructuredConfigResponse {
4792 type Owned = Self;
4793
4794 #[inline(always)]
4795 fn inline_align(_context: fidl::encoding::Context) -> usize {
4796 8
4797 }
4798
4799 #[inline(always)]
4800 fn inline_size(_context: fidl::encoding::Context) -> usize {
4801 32
4802 }
4803 }
4804
4805 unsafe impl<D: fidl::encoding::ResourceDialect>
4806 fidl::encoding::Encode<RealmQueryGetStructuredConfigResponse, D>
4807 for &RealmQueryGetStructuredConfigResponse
4808 {
4809 #[inline]
4810 unsafe fn encode(
4811 self,
4812 encoder: &mut fidl::encoding::Encoder<'_, D>,
4813 offset: usize,
4814 _depth: fidl::encoding::Depth,
4815 ) -> fidl::Result<()> {
4816 encoder.debug_check_bounds::<RealmQueryGetStructuredConfigResponse>(offset);
4817 fidl::encoding::Encode::<RealmQueryGetStructuredConfigResponse, D>::encode(
4819 (
4820 <fidl_fuchsia_component_decl__common::ResolvedConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.config),
4821 ),
4822 encoder, offset, _depth
4823 )
4824 }
4825 }
4826 unsafe impl<
4827 D: fidl::encoding::ResourceDialect,
4828 T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::ResolvedConfig, D>,
4829 > fidl::encoding::Encode<RealmQueryGetStructuredConfigResponse, D> for (T0,)
4830 {
4831 #[inline]
4832 unsafe fn encode(
4833 self,
4834 encoder: &mut fidl::encoding::Encoder<'_, D>,
4835 offset: usize,
4836 depth: fidl::encoding::Depth,
4837 ) -> fidl::Result<()> {
4838 encoder.debug_check_bounds::<RealmQueryGetStructuredConfigResponse>(offset);
4839 self.0.encode(encoder, offset + 0, depth)?;
4843 Ok(())
4844 }
4845 }
4846
4847 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4848 for RealmQueryGetStructuredConfigResponse
4849 {
4850 #[inline(always)]
4851 fn new_empty() -> Self {
4852 Self {
4853 config: fidl::new_empty!(fidl_fuchsia_component_decl__common::ResolvedConfig, D),
4854 }
4855 }
4856
4857 #[inline]
4858 unsafe fn decode(
4859 &mut self,
4860 decoder: &mut fidl::encoding::Decoder<'_, D>,
4861 offset: usize,
4862 _depth: fidl::encoding::Depth,
4863 ) -> fidl::Result<()> {
4864 decoder.debug_check_bounds::<Self>(offset);
4865 fidl::decode!(
4867 fidl_fuchsia_component_decl__common::ResolvedConfig,
4868 D,
4869 &mut self.config,
4870 decoder,
4871 offset + 0,
4872 _depth
4873 )?;
4874 Ok(())
4875 }
4876 }
4877
4878 impl fidl::encoding::ValueTypeMarker for RouteTarget {
4879 type Borrowed<'a> = &'a Self;
4880 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4881 value
4882 }
4883 }
4884
4885 unsafe impl fidl::encoding::TypeMarker for RouteTarget {
4886 type Owned = Self;
4887
4888 #[inline(always)]
4889 fn inline_align(_context: fidl::encoding::Context) -> usize {
4890 8
4891 }
4892
4893 #[inline(always)]
4894 fn inline_size(_context: fidl::encoding::Context) -> usize {
4895 24
4896 }
4897 }
4898
4899 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RouteTarget, D>
4900 for &RouteTarget
4901 {
4902 #[inline]
4903 unsafe fn encode(
4904 self,
4905 encoder: &mut fidl::encoding::Encoder<'_, D>,
4906 offset: usize,
4907 _depth: fidl::encoding::Depth,
4908 ) -> fidl::Result<()> {
4909 encoder.debug_check_bounds::<RouteTarget>(offset);
4910 fidl::encoding::Encode::<RouteTarget, D>::encode(
4912 (
4913 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
4914 &self.name,
4915 ),
4916 <DeclType as fidl::encoding::ValueTypeMarker>::borrow(&self.decl_type),
4917 ),
4918 encoder,
4919 offset,
4920 _depth,
4921 )
4922 }
4923 }
4924 unsafe impl<
4925 D: fidl::encoding::ResourceDialect,
4926 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
4927 T1: fidl::encoding::Encode<DeclType, D>,
4928 > fidl::encoding::Encode<RouteTarget, D> for (T0, T1)
4929 {
4930 #[inline]
4931 unsafe fn encode(
4932 self,
4933 encoder: &mut fidl::encoding::Encoder<'_, D>,
4934 offset: usize,
4935 depth: fidl::encoding::Depth,
4936 ) -> fidl::Result<()> {
4937 encoder.debug_check_bounds::<RouteTarget>(offset);
4938 unsafe {
4941 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
4942 (ptr as *mut u64).write_unaligned(0);
4943 }
4944 self.0.encode(encoder, offset + 0, depth)?;
4946 self.1.encode(encoder, offset + 16, depth)?;
4947 Ok(())
4948 }
4949 }
4950
4951 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RouteTarget {
4952 #[inline(always)]
4953 fn new_empty() -> Self {
4954 Self {
4955 name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
4956 decl_type: fidl::new_empty!(DeclType, D),
4957 }
4958 }
4959
4960 #[inline]
4961 unsafe fn decode(
4962 &mut self,
4963 decoder: &mut fidl::encoding::Decoder<'_, D>,
4964 offset: usize,
4965 _depth: fidl::encoding::Depth,
4966 ) -> fidl::Result<()> {
4967 decoder.debug_check_bounds::<Self>(offset);
4968 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
4970 let padval = unsafe { (ptr as *const u64).read_unaligned() };
4971 let mask = 0xffffffff00000000u64;
4972 let maskedval = padval & mask;
4973 if maskedval != 0 {
4974 return Err(fidl::Error::NonZeroPadding {
4975 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
4976 });
4977 }
4978 fidl::decode!(
4979 fidl::encoding::BoundedString<255>,
4980 D,
4981 &mut self.name,
4982 decoder,
4983 offset + 0,
4984 _depth
4985 )?;
4986 fidl::decode!(DeclType, D, &mut self.decl_type, decoder, offset + 16, _depth)?;
4987 Ok(())
4988 }
4989 }
4990
4991 impl fidl::encoding::ValueTypeMarker for RouteValidatorRouteRequest {
4992 type Borrowed<'a> = &'a Self;
4993 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4994 value
4995 }
4996 }
4997
4998 unsafe impl fidl::encoding::TypeMarker for RouteValidatorRouteRequest {
4999 type Owned = Self;
5000
5001 #[inline(always)]
5002 fn inline_align(_context: fidl::encoding::Context) -> usize {
5003 8
5004 }
5005
5006 #[inline(always)]
5007 fn inline_size(_context: fidl::encoding::Context) -> usize {
5008 32
5009 }
5010 }
5011
5012 unsafe impl<D: fidl::encoding::ResourceDialect>
5013 fidl::encoding::Encode<RouteValidatorRouteRequest, D> for &RouteValidatorRouteRequest
5014 {
5015 #[inline]
5016 unsafe fn encode(
5017 self,
5018 encoder: &mut fidl::encoding::Encoder<'_, D>,
5019 offset: usize,
5020 _depth: fidl::encoding::Depth,
5021 ) -> fidl::Result<()> {
5022 encoder.debug_check_bounds::<RouteValidatorRouteRequest>(offset);
5023 fidl::encoding::Encode::<RouteValidatorRouteRequest, D>::encode(
5025 (
5026 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.moniker),
5027 <fidl::encoding::UnboundedVector<RouteTarget> as fidl::encoding::ValueTypeMarker>::borrow(&self.targets),
5028 ),
5029 encoder, offset, _depth
5030 )
5031 }
5032 }
5033 unsafe impl<
5034 D: fidl::encoding::ResourceDialect,
5035 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
5036 T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RouteTarget>, D>,
5037 > fidl::encoding::Encode<RouteValidatorRouteRequest, D> for (T0, T1)
5038 {
5039 #[inline]
5040 unsafe fn encode(
5041 self,
5042 encoder: &mut fidl::encoding::Encoder<'_, D>,
5043 offset: usize,
5044 depth: fidl::encoding::Depth,
5045 ) -> fidl::Result<()> {
5046 encoder.debug_check_bounds::<RouteValidatorRouteRequest>(offset);
5047 self.0.encode(encoder, offset + 0, depth)?;
5051 self.1.encode(encoder, offset + 16, depth)?;
5052 Ok(())
5053 }
5054 }
5055
5056 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5057 for RouteValidatorRouteRequest
5058 {
5059 #[inline(always)]
5060 fn new_empty() -> Self {
5061 Self {
5062 moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
5063 targets: fidl::new_empty!(fidl::encoding::UnboundedVector<RouteTarget>, D),
5064 }
5065 }
5066
5067 #[inline]
5068 unsafe fn decode(
5069 &mut self,
5070 decoder: &mut fidl::encoding::Decoder<'_, D>,
5071 offset: usize,
5072 _depth: fidl::encoding::Depth,
5073 ) -> fidl::Result<()> {
5074 decoder.debug_check_bounds::<Self>(offset);
5075 fidl::decode!(
5077 fidl::encoding::BoundedString<4096>,
5078 D,
5079 &mut self.moniker,
5080 decoder,
5081 offset + 0,
5082 _depth
5083 )?;
5084 fidl::decode!(
5085 fidl::encoding::UnboundedVector<RouteTarget>,
5086 D,
5087 &mut self.targets,
5088 decoder,
5089 offset + 16,
5090 _depth
5091 )?;
5092 Ok(())
5093 }
5094 }
5095
5096 impl fidl::encoding::ValueTypeMarker for RouteValidatorValidateRequest {
5097 type Borrowed<'a> = &'a Self;
5098 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5099 value
5100 }
5101 }
5102
5103 unsafe impl fidl::encoding::TypeMarker for RouteValidatorValidateRequest {
5104 type Owned = Self;
5105
5106 #[inline(always)]
5107 fn inline_align(_context: fidl::encoding::Context) -> usize {
5108 8
5109 }
5110
5111 #[inline(always)]
5112 fn inline_size(_context: fidl::encoding::Context) -> usize {
5113 16
5114 }
5115 }
5116
5117 unsafe impl<D: fidl::encoding::ResourceDialect>
5118 fidl::encoding::Encode<RouteValidatorValidateRequest, D>
5119 for &RouteValidatorValidateRequest
5120 {
5121 #[inline]
5122 unsafe fn encode(
5123 self,
5124 encoder: &mut fidl::encoding::Encoder<'_, D>,
5125 offset: usize,
5126 _depth: fidl::encoding::Depth,
5127 ) -> fidl::Result<()> {
5128 encoder.debug_check_bounds::<RouteValidatorValidateRequest>(offset);
5129 fidl::encoding::Encode::<RouteValidatorValidateRequest, D>::encode(
5131 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
5132 &self.moniker,
5133 ),),
5134 encoder,
5135 offset,
5136 _depth,
5137 )
5138 }
5139 }
5140 unsafe impl<
5141 D: fidl::encoding::ResourceDialect,
5142 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
5143 > fidl::encoding::Encode<RouteValidatorValidateRequest, D> for (T0,)
5144 {
5145 #[inline]
5146 unsafe fn encode(
5147 self,
5148 encoder: &mut fidl::encoding::Encoder<'_, D>,
5149 offset: usize,
5150 depth: fidl::encoding::Depth,
5151 ) -> fidl::Result<()> {
5152 encoder.debug_check_bounds::<RouteValidatorValidateRequest>(offset);
5153 self.0.encode(encoder, offset + 0, depth)?;
5157 Ok(())
5158 }
5159 }
5160
5161 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5162 for RouteValidatorValidateRequest
5163 {
5164 #[inline(always)]
5165 fn new_empty() -> Self {
5166 Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
5167 }
5168
5169 #[inline]
5170 unsafe fn decode(
5171 &mut self,
5172 decoder: &mut fidl::encoding::Decoder<'_, D>,
5173 offset: usize,
5174 _depth: fidl::encoding::Depth,
5175 ) -> fidl::Result<()> {
5176 decoder.debug_check_bounds::<Self>(offset);
5177 fidl::decode!(
5179 fidl::encoding::BoundedString<4096>,
5180 D,
5181 &mut self.moniker,
5182 decoder,
5183 offset + 0,
5184 _depth
5185 )?;
5186 Ok(())
5187 }
5188 }
5189
5190 impl fidl::encoding::ValueTypeMarker for RouteValidatorRouteResponse {
5191 type Borrowed<'a> = &'a Self;
5192 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5193 value
5194 }
5195 }
5196
5197 unsafe impl fidl::encoding::TypeMarker for RouteValidatorRouteResponse {
5198 type Owned = Self;
5199
5200 #[inline(always)]
5201 fn inline_align(_context: fidl::encoding::Context) -> usize {
5202 8
5203 }
5204
5205 #[inline(always)]
5206 fn inline_size(_context: fidl::encoding::Context) -> usize {
5207 16
5208 }
5209 }
5210
5211 unsafe impl<D: fidl::encoding::ResourceDialect>
5212 fidl::encoding::Encode<RouteValidatorRouteResponse, D> for &RouteValidatorRouteResponse
5213 {
5214 #[inline]
5215 unsafe fn encode(
5216 self,
5217 encoder: &mut fidl::encoding::Encoder<'_, D>,
5218 offset: usize,
5219 _depth: fidl::encoding::Depth,
5220 ) -> fidl::Result<()> {
5221 encoder.debug_check_bounds::<RouteValidatorRouteResponse>(offset);
5222 fidl::encoding::Encode::<RouteValidatorRouteResponse, D>::encode(
5224 (
5225 <fidl::encoding::UnboundedVector<RouteReport> as fidl::encoding::ValueTypeMarker>::borrow(&self.reports),
5226 ),
5227 encoder, offset, _depth
5228 )
5229 }
5230 }
5231 unsafe impl<
5232 D: fidl::encoding::ResourceDialect,
5233 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RouteReport>, D>,
5234 > fidl::encoding::Encode<RouteValidatorRouteResponse, D> for (T0,)
5235 {
5236 #[inline]
5237 unsafe fn encode(
5238 self,
5239 encoder: &mut fidl::encoding::Encoder<'_, D>,
5240 offset: usize,
5241 depth: fidl::encoding::Depth,
5242 ) -> fidl::Result<()> {
5243 encoder.debug_check_bounds::<RouteValidatorRouteResponse>(offset);
5244 self.0.encode(encoder, offset + 0, depth)?;
5248 Ok(())
5249 }
5250 }
5251
5252 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5253 for RouteValidatorRouteResponse
5254 {
5255 #[inline(always)]
5256 fn new_empty() -> Self {
5257 Self { reports: fidl::new_empty!(fidl::encoding::UnboundedVector<RouteReport>, D) }
5258 }
5259
5260 #[inline]
5261 unsafe fn decode(
5262 &mut self,
5263 decoder: &mut fidl::encoding::Decoder<'_, D>,
5264 offset: usize,
5265 _depth: fidl::encoding::Depth,
5266 ) -> fidl::Result<()> {
5267 decoder.debug_check_bounds::<Self>(offset);
5268 fidl::decode!(
5270 fidl::encoding::UnboundedVector<RouteReport>,
5271 D,
5272 &mut self.reports,
5273 decoder,
5274 offset + 0,
5275 _depth
5276 )?;
5277 Ok(())
5278 }
5279 }
5280
5281 impl fidl::encoding::ValueTypeMarker for RouteValidatorValidateResponse {
5282 type Borrowed<'a> = &'a Self;
5283 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5284 value
5285 }
5286 }
5287
5288 unsafe impl fidl::encoding::TypeMarker for RouteValidatorValidateResponse {
5289 type Owned = Self;
5290
5291 #[inline(always)]
5292 fn inline_align(_context: fidl::encoding::Context) -> usize {
5293 8
5294 }
5295
5296 #[inline(always)]
5297 fn inline_size(_context: fidl::encoding::Context) -> usize {
5298 16
5299 }
5300 }
5301
5302 unsafe impl<D: fidl::encoding::ResourceDialect>
5303 fidl::encoding::Encode<RouteValidatorValidateResponse, D>
5304 for &RouteValidatorValidateResponse
5305 {
5306 #[inline]
5307 unsafe fn encode(
5308 self,
5309 encoder: &mut fidl::encoding::Encoder<'_, D>,
5310 offset: usize,
5311 _depth: fidl::encoding::Depth,
5312 ) -> fidl::Result<()> {
5313 encoder.debug_check_bounds::<RouteValidatorValidateResponse>(offset);
5314 fidl::encoding::Encode::<RouteValidatorValidateResponse, D>::encode(
5316 (
5317 <fidl::encoding::UnboundedVector<RouteReport> as fidl::encoding::ValueTypeMarker>::borrow(&self.reports),
5318 ),
5319 encoder, offset, _depth
5320 )
5321 }
5322 }
5323 unsafe impl<
5324 D: fidl::encoding::ResourceDialect,
5325 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RouteReport>, D>,
5326 > fidl::encoding::Encode<RouteValidatorValidateResponse, D> for (T0,)
5327 {
5328 #[inline]
5329 unsafe fn encode(
5330 self,
5331 encoder: &mut fidl::encoding::Encoder<'_, D>,
5332 offset: usize,
5333 depth: fidl::encoding::Depth,
5334 ) -> fidl::Result<()> {
5335 encoder.debug_check_bounds::<RouteValidatorValidateResponse>(offset);
5336 self.0.encode(encoder, offset + 0, depth)?;
5340 Ok(())
5341 }
5342 }
5343
5344 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5345 for RouteValidatorValidateResponse
5346 {
5347 #[inline(always)]
5348 fn new_empty() -> Self {
5349 Self { reports: fidl::new_empty!(fidl::encoding::UnboundedVector<RouteReport>, D) }
5350 }
5351
5352 #[inline]
5353 unsafe fn decode(
5354 &mut self,
5355 decoder: &mut fidl::encoding::Decoder<'_, D>,
5356 offset: usize,
5357 _depth: fidl::encoding::Depth,
5358 ) -> fidl::Result<()> {
5359 decoder.debug_check_bounds::<Self>(offset);
5360 fidl::decode!(
5362 fidl::encoding::UnboundedVector<RouteReport>,
5363 D,
5364 &mut self.reports,
5365 decoder,
5366 offset + 0,
5367 _depth
5368 )?;
5369 Ok(())
5370 }
5371 }
5372
5373 impl fidl::encoding::ValueTypeMarker for StorageAdminDeleteComponentStorageRequest {
5374 type Borrowed<'a> = &'a Self;
5375 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5376 value
5377 }
5378 }
5379
5380 unsafe impl fidl::encoding::TypeMarker for StorageAdminDeleteComponentStorageRequest {
5381 type Owned = Self;
5382
5383 #[inline(always)]
5384 fn inline_align(_context: fidl::encoding::Context) -> usize {
5385 8
5386 }
5387
5388 #[inline(always)]
5389 fn inline_size(_context: fidl::encoding::Context) -> usize {
5390 16
5391 }
5392 }
5393
5394 unsafe impl<D: fidl::encoding::ResourceDialect>
5395 fidl::encoding::Encode<StorageAdminDeleteComponentStorageRequest, D>
5396 for &StorageAdminDeleteComponentStorageRequest
5397 {
5398 #[inline]
5399 unsafe fn encode(
5400 self,
5401 encoder: &mut fidl::encoding::Encoder<'_, D>,
5402 offset: usize,
5403 _depth: fidl::encoding::Depth,
5404 ) -> fidl::Result<()> {
5405 encoder.debug_check_bounds::<StorageAdminDeleteComponentStorageRequest>(offset);
5406 fidl::encoding::Encode::<StorageAdminDeleteComponentStorageRequest, D>::encode(
5408 (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
5409 &self.relative_moniker,
5410 ),),
5411 encoder,
5412 offset,
5413 _depth,
5414 )
5415 }
5416 }
5417 unsafe impl<
5418 D: fidl::encoding::ResourceDialect,
5419 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
5420 > fidl::encoding::Encode<StorageAdminDeleteComponentStorageRequest, D> for (T0,)
5421 {
5422 #[inline]
5423 unsafe fn encode(
5424 self,
5425 encoder: &mut fidl::encoding::Encoder<'_, D>,
5426 offset: usize,
5427 depth: fidl::encoding::Depth,
5428 ) -> fidl::Result<()> {
5429 encoder.debug_check_bounds::<StorageAdminDeleteComponentStorageRequest>(offset);
5430 self.0.encode(encoder, offset + 0, depth)?;
5434 Ok(())
5435 }
5436 }
5437
5438 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5439 for StorageAdminDeleteComponentStorageRequest
5440 {
5441 #[inline(always)]
5442 fn new_empty() -> Self {
5443 Self { relative_moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
5444 }
5445
5446 #[inline]
5447 unsafe fn decode(
5448 &mut self,
5449 decoder: &mut fidl::encoding::Decoder<'_, D>,
5450 offset: usize,
5451 _depth: fidl::encoding::Depth,
5452 ) -> fidl::Result<()> {
5453 decoder.debug_check_bounds::<Self>(offset);
5454 fidl::decode!(
5456 fidl::encoding::BoundedString<4096>,
5457 D,
5458 &mut self.relative_moniker,
5459 decoder,
5460 offset + 0,
5461 _depth
5462 )?;
5463 Ok(())
5464 }
5465 }
5466
5467 impl fidl::encoding::ValueTypeMarker for StorageIteratorNextResponse {
5468 type Borrowed<'a> = &'a Self;
5469 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5470 value
5471 }
5472 }
5473
5474 unsafe impl fidl::encoding::TypeMarker for StorageIteratorNextResponse {
5475 type Owned = Self;
5476
5477 #[inline(always)]
5478 fn inline_align(_context: fidl::encoding::Context) -> usize {
5479 8
5480 }
5481
5482 #[inline(always)]
5483 fn inline_size(_context: fidl::encoding::Context) -> usize {
5484 16
5485 }
5486 }
5487
5488 unsafe impl<D: fidl::encoding::ResourceDialect>
5489 fidl::encoding::Encode<StorageIteratorNextResponse, D> for &StorageIteratorNextResponse
5490 {
5491 #[inline]
5492 unsafe fn encode(
5493 self,
5494 encoder: &mut fidl::encoding::Encoder<'_, D>,
5495 offset: usize,
5496 _depth: fidl::encoding::Depth,
5497 ) -> fidl::Result<()> {
5498 encoder.debug_check_bounds::<StorageIteratorNextResponse>(offset);
5499 fidl::encoding::Encode::<StorageIteratorNextResponse, D>::encode(
5501 (
5502 <fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>> as fidl::encoding::ValueTypeMarker>::borrow(&self.relative_monikers),
5503 ),
5504 encoder, offset, _depth
5505 )
5506 }
5507 }
5508 unsafe impl<
5509 D: fidl::encoding::ResourceDialect,
5510 T0: fidl::encoding::Encode<
5511 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>>,
5512 D,
5513 >,
5514 > fidl::encoding::Encode<StorageIteratorNextResponse, D> for (T0,)
5515 {
5516 #[inline]
5517 unsafe fn encode(
5518 self,
5519 encoder: &mut fidl::encoding::Encoder<'_, D>,
5520 offset: usize,
5521 depth: fidl::encoding::Depth,
5522 ) -> fidl::Result<()> {
5523 encoder.debug_check_bounds::<StorageIteratorNextResponse>(offset);
5524 self.0.encode(encoder, offset + 0, depth)?;
5528 Ok(())
5529 }
5530 }
5531
5532 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5533 for StorageIteratorNextResponse
5534 {
5535 #[inline(always)]
5536 fn new_empty() -> Self {
5537 Self {
5538 relative_monikers: fidl::new_empty!(
5539 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>>,
5540 D
5541 ),
5542 }
5543 }
5544
5545 #[inline]
5546 unsafe fn decode(
5547 &mut self,
5548 decoder: &mut fidl::encoding::Decoder<'_, D>,
5549 offset: usize,
5550 _depth: fidl::encoding::Depth,
5551 ) -> fidl::Result<()> {
5552 decoder.debug_check_bounds::<Self>(offset);
5553 fidl::decode!(
5555 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>>,
5556 D,
5557 &mut self.relative_monikers,
5558 decoder,
5559 offset + 0,
5560 _depth
5561 )?;
5562 Ok(())
5563 }
5564 }
5565
5566 impl ComponentCrashInfo {
5567 #[inline(always)]
5568 fn max_ordinal_present(&self) -> u64 {
5569 if let Some(_) = self.moniker {
5570 return 2;
5571 }
5572 if let Some(_) = self.url {
5573 return 1;
5574 }
5575 0
5576 }
5577 }
5578
5579 impl fidl::encoding::ValueTypeMarker for ComponentCrashInfo {
5580 type Borrowed<'a> = &'a Self;
5581 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5582 value
5583 }
5584 }
5585
5586 unsafe impl fidl::encoding::TypeMarker for ComponentCrashInfo {
5587 type Owned = Self;
5588
5589 #[inline(always)]
5590 fn inline_align(_context: fidl::encoding::Context) -> usize {
5591 8
5592 }
5593
5594 #[inline(always)]
5595 fn inline_size(_context: fidl::encoding::Context) -> usize {
5596 16
5597 }
5598 }
5599
5600 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentCrashInfo, D>
5601 for &ComponentCrashInfo
5602 {
5603 unsafe fn encode(
5604 self,
5605 encoder: &mut fidl::encoding::Encoder<'_, D>,
5606 offset: usize,
5607 mut depth: fidl::encoding::Depth,
5608 ) -> fidl::Result<()> {
5609 encoder.debug_check_bounds::<ComponentCrashInfo>(offset);
5610 let max_ordinal: u64 = self.max_ordinal_present();
5612 encoder.write_num(max_ordinal, offset);
5613 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5614 if max_ordinal == 0 {
5616 return Ok(());
5617 }
5618 depth.increment()?;
5619 let envelope_size = 8;
5620 let bytes_len = max_ordinal as usize * envelope_size;
5621 #[allow(unused_variables)]
5622 let offset = encoder.out_of_line_offset(bytes_len);
5623 let mut _prev_end_offset: usize = 0;
5624 if 1 > max_ordinal {
5625 return Ok(());
5626 }
5627
5628 let cur_offset: usize = (1 - 1) * envelope_size;
5631
5632 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5634
5635 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
5640 self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
5641 encoder, offset + cur_offset, depth
5642 )?;
5643
5644 _prev_end_offset = cur_offset + envelope_size;
5645 if 2 > max_ordinal {
5646 return Ok(());
5647 }
5648
5649 let cur_offset: usize = (2 - 1) * envelope_size;
5652
5653 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5655
5656 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
5661 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
5662 encoder, offset + cur_offset, depth
5663 )?;
5664
5665 _prev_end_offset = cur_offset + envelope_size;
5666
5667 Ok(())
5668 }
5669 }
5670
5671 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentCrashInfo {
5672 #[inline(always)]
5673 fn new_empty() -> Self {
5674 Self::default()
5675 }
5676
5677 unsafe fn decode(
5678 &mut self,
5679 decoder: &mut fidl::encoding::Decoder<'_, D>,
5680 offset: usize,
5681 mut depth: fidl::encoding::Depth,
5682 ) -> fidl::Result<()> {
5683 decoder.debug_check_bounds::<Self>(offset);
5684 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5685 None => return Err(fidl::Error::NotNullable),
5686 Some(len) => len,
5687 };
5688 if len == 0 {
5690 return Ok(());
5691 };
5692 depth.increment()?;
5693 let envelope_size = 8;
5694 let bytes_len = len * envelope_size;
5695 let offset = decoder.out_of_line_offset(bytes_len)?;
5696 let mut _next_ordinal_to_read = 0;
5698 let mut next_offset = offset;
5699 let end_offset = offset + bytes_len;
5700 _next_ordinal_to_read += 1;
5701 if next_offset >= end_offset {
5702 return Ok(());
5703 }
5704
5705 while _next_ordinal_to_read < 1 {
5707 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5708 _next_ordinal_to_read += 1;
5709 next_offset += envelope_size;
5710 }
5711
5712 let next_out_of_line = decoder.next_out_of_line();
5713 let handles_before = decoder.remaining_handles();
5714 if let Some((inlined, num_bytes, num_handles)) =
5715 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5716 {
5717 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5718 if inlined != (member_inline_size <= 4) {
5719 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5720 }
5721 let inner_offset;
5722 let mut inner_depth = depth.clone();
5723 if inlined {
5724 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5725 inner_offset = next_offset;
5726 } else {
5727 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5728 inner_depth.increment()?;
5729 }
5730 let val_ref = self.url.get_or_insert_with(|| {
5731 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
5732 });
5733 fidl::decode!(
5734 fidl::encoding::BoundedString<4096>,
5735 D,
5736 val_ref,
5737 decoder,
5738 inner_offset,
5739 inner_depth
5740 )?;
5741 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5742 {
5743 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5744 }
5745 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5746 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5747 }
5748 }
5749
5750 next_offset += envelope_size;
5751 _next_ordinal_to_read += 1;
5752 if next_offset >= end_offset {
5753 return Ok(());
5754 }
5755
5756 while _next_ordinal_to_read < 2 {
5758 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5759 _next_ordinal_to_read += 1;
5760 next_offset += envelope_size;
5761 }
5762
5763 let next_out_of_line = decoder.next_out_of_line();
5764 let handles_before = decoder.remaining_handles();
5765 if let Some((inlined, num_bytes, num_handles)) =
5766 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5767 {
5768 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5769 if inlined != (member_inline_size <= 4) {
5770 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5771 }
5772 let inner_offset;
5773 let mut inner_depth = depth.clone();
5774 if inlined {
5775 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5776 inner_offset = next_offset;
5777 } else {
5778 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5779 inner_depth.increment()?;
5780 }
5781 let val_ref = self.moniker.get_or_insert_with(|| {
5782 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
5783 });
5784 fidl::decode!(
5785 fidl::encoding::BoundedString<4096>,
5786 D,
5787 val_ref,
5788 decoder,
5789 inner_offset,
5790 inner_depth
5791 )?;
5792 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5793 {
5794 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5795 }
5796 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5797 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5798 }
5799 }
5800
5801 next_offset += envelope_size;
5802
5803 while next_offset < end_offset {
5805 _next_ordinal_to_read += 1;
5806 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5807 next_offset += envelope_size;
5808 }
5809
5810 Ok(())
5811 }
5812 }
5813
5814 impl ExecutionInfo {
5815 #[inline(always)]
5816 fn max_ordinal_present(&self) -> u64 {
5817 if let Some(_) = self.start_reason {
5818 return 1;
5819 }
5820 0
5821 }
5822 }
5823
5824 impl fidl::encoding::ValueTypeMarker for ExecutionInfo {
5825 type Borrowed<'a> = &'a Self;
5826 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5827 value
5828 }
5829 }
5830
5831 unsafe impl fidl::encoding::TypeMarker for ExecutionInfo {
5832 type Owned = Self;
5833
5834 #[inline(always)]
5835 fn inline_align(_context: fidl::encoding::Context) -> usize {
5836 8
5837 }
5838
5839 #[inline(always)]
5840 fn inline_size(_context: fidl::encoding::Context) -> usize {
5841 16
5842 }
5843 }
5844
5845 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExecutionInfo, D>
5846 for &ExecutionInfo
5847 {
5848 unsafe fn encode(
5849 self,
5850 encoder: &mut fidl::encoding::Encoder<'_, D>,
5851 offset: usize,
5852 mut depth: fidl::encoding::Depth,
5853 ) -> fidl::Result<()> {
5854 encoder.debug_check_bounds::<ExecutionInfo>(offset);
5855 let max_ordinal: u64 = self.max_ordinal_present();
5857 encoder.write_num(max_ordinal, offset);
5858 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5859 if max_ordinal == 0 {
5861 return Ok(());
5862 }
5863 depth.increment()?;
5864 let envelope_size = 8;
5865 let bytes_len = max_ordinal as usize * envelope_size;
5866 #[allow(unused_variables)]
5867 let offset = encoder.out_of_line_offset(bytes_len);
5868 let mut _prev_end_offset: usize = 0;
5869 if 1 > max_ordinal {
5870 return Ok(());
5871 }
5872
5873 let cur_offset: usize = (1 - 1) * envelope_size;
5876
5877 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5879
5880 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<5000>, D>(
5885 self.start_reason.as_ref().map(<fidl::encoding::BoundedString<5000> as fidl::encoding::ValueTypeMarker>::borrow),
5886 encoder, offset + cur_offset, depth
5887 )?;
5888
5889 _prev_end_offset = cur_offset + envelope_size;
5890
5891 Ok(())
5892 }
5893 }
5894
5895 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExecutionInfo {
5896 #[inline(always)]
5897 fn new_empty() -> Self {
5898 Self::default()
5899 }
5900
5901 unsafe fn decode(
5902 &mut self,
5903 decoder: &mut fidl::encoding::Decoder<'_, D>,
5904 offset: usize,
5905 mut depth: fidl::encoding::Depth,
5906 ) -> fidl::Result<()> {
5907 decoder.debug_check_bounds::<Self>(offset);
5908 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5909 None => return Err(fidl::Error::NotNullable),
5910 Some(len) => len,
5911 };
5912 if len == 0 {
5914 return Ok(());
5915 };
5916 depth.increment()?;
5917 let envelope_size = 8;
5918 let bytes_len = len * envelope_size;
5919 let offset = decoder.out_of_line_offset(bytes_len)?;
5920 let mut _next_ordinal_to_read = 0;
5922 let mut next_offset = offset;
5923 let end_offset = offset + bytes_len;
5924 _next_ordinal_to_read += 1;
5925 if next_offset >= end_offset {
5926 return Ok(());
5927 }
5928
5929 while _next_ordinal_to_read < 1 {
5931 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5932 _next_ordinal_to_read += 1;
5933 next_offset += envelope_size;
5934 }
5935
5936 let next_out_of_line = decoder.next_out_of_line();
5937 let handles_before = decoder.remaining_handles();
5938 if let Some((inlined, num_bytes, num_handles)) =
5939 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5940 {
5941 let member_inline_size = <fidl::encoding::BoundedString<5000> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5942 if inlined != (member_inline_size <= 4) {
5943 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5944 }
5945 let inner_offset;
5946 let mut inner_depth = depth.clone();
5947 if inlined {
5948 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5949 inner_offset = next_offset;
5950 } else {
5951 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5952 inner_depth.increment()?;
5953 }
5954 let val_ref = self.start_reason.get_or_insert_with(|| {
5955 fidl::new_empty!(fidl::encoding::BoundedString<5000>, D)
5956 });
5957 fidl::decode!(
5958 fidl::encoding::BoundedString<5000>,
5959 D,
5960 val_ref,
5961 decoder,
5962 inner_offset,
5963 inner_depth
5964 )?;
5965 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5966 {
5967 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5968 }
5969 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5970 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5971 }
5972 }
5973
5974 next_offset += envelope_size;
5975
5976 while next_offset < end_offset {
5978 _next_ordinal_to_read += 1;
5979 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5980 next_offset += envelope_size;
5981 }
5982
5983 Ok(())
5984 }
5985 }
5986
5987 impl Instance {
5988 #[inline(always)]
5989 fn max_ordinal_present(&self) -> u64 {
5990 if let Some(_) = self.environment {
5991 return 5;
5992 }
5993 if let Some(_) = self.resolved_info {
5994 return 4;
5995 }
5996 if let Some(_) = self.instance_id {
5997 return 3;
5998 }
5999 if let Some(_) = self.url {
6000 return 2;
6001 }
6002 if let Some(_) = self.moniker {
6003 return 1;
6004 }
6005 0
6006 }
6007 }
6008
6009 impl fidl::encoding::ValueTypeMarker for Instance {
6010 type Borrowed<'a> = &'a Self;
6011 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6012 value
6013 }
6014 }
6015
6016 unsafe impl fidl::encoding::TypeMarker for Instance {
6017 type Owned = Self;
6018
6019 #[inline(always)]
6020 fn inline_align(_context: fidl::encoding::Context) -> usize {
6021 8
6022 }
6023
6024 #[inline(always)]
6025 fn inline_size(_context: fidl::encoding::Context) -> usize {
6026 16
6027 }
6028 }
6029
6030 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Instance, D> for &Instance {
6031 unsafe fn encode(
6032 self,
6033 encoder: &mut fidl::encoding::Encoder<'_, D>,
6034 offset: usize,
6035 mut depth: fidl::encoding::Depth,
6036 ) -> fidl::Result<()> {
6037 encoder.debug_check_bounds::<Instance>(offset);
6038 let max_ordinal: u64 = self.max_ordinal_present();
6040 encoder.write_num(max_ordinal, offset);
6041 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6042 if max_ordinal == 0 {
6044 return Ok(());
6045 }
6046 depth.increment()?;
6047 let envelope_size = 8;
6048 let bytes_len = max_ordinal as usize * envelope_size;
6049 #[allow(unused_variables)]
6050 let offset = encoder.out_of_line_offset(bytes_len);
6051 let mut _prev_end_offset: usize = 0;
6052 if 1 > max_ordinal {
6053 return Ok(());
6054 }
6055
6056 let cur_offset: usize = (1 - 1) * envelope_size;
6059
6060 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6062
6063 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6068 self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6069 encoder, offset + cur_offset, depth
6070 )?;
6071
6072 _prev_end_offset = cur_offset + envelope_size;
6073 if 2 > max_ordinal {
6074 return Ok(());
6075 }
6076
6077 let cur_offset: usize = (2 - 1) * envelope_size;
6080
6081 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6083
6084 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6089 self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6090 encoder, offset + cur_offset, depth
6091 )?;
6092
6093 _prev_end_offset = cur_offset + envelope_size;
6094 if 3 > max_ordinal {
6095 return Ok(());
6096 }
6097
6098 let cur_offset: usize = (3 - 1) * envelope_size;
6101
6102 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6104
6105 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6110 self.instance_id.as_ref().map(
6111 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6112 ),
6113 encoder,
6114 offset + cur_offset,
6115 depth,
6116 )?;
6117
6118 _prev_end_offset = cur_offset + envelope_size;
6119 if 4 > max_ordinal {
6120 return Ok(());
6121 }
6122
6123 let cur_offset: usize = (4 - 1) * envelope_size;
6126
6127 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6129
6130 fidl::encoding::encode_in_envelope_optional::<ResolvedInfo, D>(
6135 self.resolved_info
6136 .as_ref()
6137 .map(<ResolvedInfo as fidl::encoding::ValueTypeMarker>::borrow),
6138 encoder,
6139 offset + cur_offset,
6140 depth,
6141 )?;
6142
6143 _prev_end_offset = cur_offset + envelope_size;
6144 if 5 > max_ordinal {
6145 return Ok(());
6146 }
6147
6148 let cur_offset: usize = (5 - 1) * envelope_size;
6151
6152 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6154
6155 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6160 self.environment.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6161 encoder, offset + cur_offset, depth
6162 )?;
6163
6164 _prev_end_offset = cur_offset + envelope_size;
6165
6166 Ok(())
6167 }
6168 }
6169
6170 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Instance {
6171 #[inline(always)]
6172 fn new_empty() -> Self {
6173 Self::default()
6174 }
6175
6176 unsafe fn decode(
6177 &mut self,
6178 decoder: &mut fidl::encoding::Decoder<'_, D>,
6179 offset: usize,
6180 mut depth: fidl::encoding::Depth,
6181 ) -> fidl::Result<()> {
6182 decoder.debug_check_bounds::<Self>(offset);
6183 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6184 None => return Err(fidl::Error::NotNullable),
6185 Some(len) => len,
6186 };
6187 if len == 0 {
6189 return Ok(());
6190 };
6191 depth.increment()?;
6192 let envelope_size = 8;
6193 let bytes_len = len * envelope_size;
6194 let offset = decoder.out_of_line_offset(bytes_len)?;
6195 let mut _next_ordinal_to_read = 0;
6197 let mut next_offset = offset;
6198 let end_offset = offset + bytes_len;
6199 _next_ordinal_to_read += 1;
6200 if next_offset >= end_offset {
6201 return Ok(());
6202 }
6203
6204 while _next_ordinal_to_read < 1 {
6206 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6207 _next_ordinal_to_read += 1;
6208 next_offset += envelope_size;
6209 }
6210
6211 let next_out_of_line = decoder.next_out_of_line();
6212 let handles_before = decoder.remaining_handles();
6213 if let Some((inlined, num_bytes, num_handles)) =
6214 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6215 {
6216 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6217 if inlined != (member_inline_size <= 4) {
6218 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6219 }
6220 let inner_offset;
6221 let mut inner_depth = depth.clone();
6222 if inlined {
6223 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6224 inner_offset = next_offset;
6225 } else {
6226 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6227 inner_depth.increment()?;
6228 }
6229 let val_ref = self.moniker.get_or_insert_with(|| {
6230 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6231 });
6232 fidl::decode!(
6233 fidl::encoding::BoundedString<4096>,
6234 D,
6235 val_ref,
6236 decoder,
6237 inner_offset,
6238 inner_depth
6239 )?;
6240 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6241 {
6242 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6243 }
6244 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6245 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6246 }
6247 }
6248
6249 next_offset += envelope_size;
6250 _next_ordinal_to_read += 1;
6251 if next_offset >= end_offset {
6252 return Ok(());
6253 }
6254
6255 while _next_ordinal_to_read < 2 {
6257 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6258 _next_ordinal_to_read += 1;
6259 next_offset += envelope_size;
6260 }
6261
6262 let next_out_of_line = decoder.next_out_of_line();
6263 let handles_before = decoder.remaining_handles();
6264 if let Some((inlined, num_bytes, num_handles)) =
6265 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6266 {
6267 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6268 if inlined != (member_inline_size <= 4) {
6269 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6270 }
6271 let inner_offset;
6272 let mut inner_depth = depth.clone();
6273 if inlined {
6274 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6275 inner_offset = next_offset;
6276 } else {
6277 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6278 inner_depth.increment()?;
6279 }
6280 let val_ref = self.url.get_or_insert_with(|| {
6281 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6282 });
6283 fidl::decode!(
6284 fidl::encoding::BoundedString<4096>,
6285 D,
6286 val_ref,
6287 decoder,
6288 inner_offset,
6289 inner_depth
6290 )?;
6291 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6292 {
6293 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6294 }
6295 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6296 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6297 }
6298 }
6299
6300 next_offset += envelope_size;
6301 _next_ordinal_to_read += 1;
6302 if next_offset >= end_offset {
6303 return Ok(());
6304 }
6305
6306 while _next_ordinal_to_read < 3 {
6308 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6309 _next_ordinal_to_read += 1;
6310 next_offset += envelope_size;
6311 }
6312
6313 let next_out_of_line = decoder.next_out_of_line();
6314 let handles_before = decoder.remaining_handles();
6315 if let Some((inlined, num_bytes, num_handles)) =
6316 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6317 {
6318 let member_inline_size =
6319 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
6320 decoder.context,
6321 );
6322 if inlined != (member_inline_size <= 4) {
6323 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6324 }
6325 let inner_offset;
6326 let mut inner_depth = depth.clone();
6327 if inlined {
6328 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6329 inner_offset = next_offset;
6330 } else {
6331 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6332 inner_depth.increment()?;
6333 }
6334 let val_ref = self
6335 .instance_id
6336 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
6337 fidl::decode!(
6338 fidl::encoding::BoundedString<64>,
6339 D,
6340 val_ref,
6341 decoder,
6342 inner_offset,
6343 inner_depth
6344 )?;
6345 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6346 {
6347 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6348 }
6349 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6350 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6351 }
6352 }
6353
6354 next_offset += envelope_size;
6355 _next_ordinal_to_read += 1;
6356 if next_offset >= end_offset {
6357 return Ok(());
6358 }
6359
6360 while _next_ordinal_to_read < 4 {
6362 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6363 _next_ordinal_to_read += 1;
6364 next_offset += envelope_size;
6365 }
6366
6367 let next_out_of_line = decoder.next_out_of_line();
6368 let handles_before = decoder.remaining_handles();
6369 if let Some((inlined, num_bytes, num_handles)) =
6370 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6371 {
6372 let member_inline_size =
6373 <ResolvedInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6374 if inlined != (member_inline_size <= 4) {
6375 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6376 }
6377 let inner_offset;
6378 let mut inner_depth = depth.clone();
6379 if inlined {
6380 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6381 inner_offset = next_offset;
6382 } else {
6383 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6384 inner_depth.increment()?;
6385 }
6386 let val_ref =
6387 self.resolved_info.get_or_insert_with(|| fidl::new_empty!(ResolvedInfo, D));
6388 fidl::decode!(ResolvedInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
6389 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6390 {
6391 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6392 }
6393 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6394 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6395 }
6396 }
6397
6398 next_offset += envelope_size;
6399 _next_ordinal_to_read += 1;
6400 if next_offset >= end_offset {
6401 return Ok(());
6402 }
6403
6404 while _next_ordinal_to_read < 5 {
6406 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6407 _next_ordinal_to_read += 1;
6408 next_offset += envelope_size;
6409 }
6410
6411 let next_out_of_line = decoder.next_out_of_line();
6412 let handles_before = decoder.remaining_handles();
6413 if let Some((inlined, num_bytes, num_handles)) =
6414 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6415 {
6416 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6417 if inlined != (member_inline_size <= 4) {
6418 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6419 }
6420 let inner_offset;
6421 let mut inner_depth = depth.clone();
6422 if inlined {
6423 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6424 inner_offset = next_offset;
6425 } else {
6426 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6427 inner_depth.increment()?;
6428 }
6429 let val_ref = self.environment.get_or_insert_with(|| {
6430 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6431 });
6432 fidl::decode!(
6433 fidl::encoding::BoundedString<4096>,
6434 D,
6435 val_ref,
6436 decoder,
6437 inner_offset,
6438 inner_depth
6439 )?;
6440 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6441 {
6442 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6443 }
6444 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6445 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6446 }
6447 }
6448
6449 next_offset += envelope_size;
6450
6451 while next_offset < end_offset {
6453 _next_ordinal_to_read += 1;
6454 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6455 next_offset += envelope_size;
6456 }
6457
6458 Ok(())
6459 }
6460 }
6461
6462 impl ResolvedInfo {
6463 #[inline(always)]
6464 fn max_ordinal_present(&self) -> u64 {
6465 if let Some(_) = self.execution_info {
6466 return 2;
6467 }
6468 if let Some(_) = self.resolved_url {
6469 return 1;
6470 }
6471 0
6472 }
6473 }
6474
6475 impl fidl::encoding::ValueTypeMarker for ResolvedInfo {
6476 type Borrowed<'a> = &'a Self;
6477 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6478 value
6479 }
6480 }
6481
6482 unsafe impl fidl::encoding::TypeMarker for ResolvedInfo {
6483 type Owned = Self;
6484
6485 #[inline(always)]
6486 fn inline_align(_context: fidl::encoding::Context) -> usize {
6487 8
6488 }
6489
6490 #[inline(always)]
6491 fn inline_size(_context: fidl::encoding::Context) -> usize {
6492 16
6493 }
6494 }
6495
6496 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolvedInfo, D>
6497 for &ResolvedInfo
6498 {
6499 unsafe fn encode(
6500 self,
6501 encoder: &mut fidl::encoding::Encoder<'_, D>,
6502 offset: usize,
6503 mut depth: fidl::encoding::Depth,
6504 ) -> fidl::Result<()> {
6505 encoder.debug_check_bounds::<ResolvedInfo>(offset);
6506 let max_ordinal: u64 = self.max_ordinal_present();
6508 encoder.write_num(max_ordinal, offset);
6509 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6510 if max_ordinal == 0 {
6512 return Ok(());
6513 }
6514 depth.increment()?;
6515 let envelope_size = 8;
6516 let bytes_len = max_ordinal as usize * envelope_size;
6517 #[allow(unused_variables)]
6518 let offset = encoder.out_of_line_offset(bytes_len);
6519 let mut _prev_end_offset: usize = 0;
6520 if 1 > max_ordinal {
6521 return Ok(());
6522 }
6523
6524 let cur_offset: usize = (1 - 1) * envelope_size;
6527
6528 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6530
6531 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6536 self.resolved_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6537 encoder, offset + cur_offset, depth
6538 )?;
6539
6540 _prev_end_offset = cur_offset + envelope_size;
6541 if 2 > max_ordinal {
6542 return Ok(());
6543 }
6544
6545 let cur_offset: usize = (2 - 1) * envelope_size;
6548
6549 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6551
6552 fidl::encoding::encode_in_envelope_optional::<ExecutionInfo, D>(
6557 self.execution_info
6558 .as_ref()
6559 .map(<ExecutionInfo as fidl::encoding::ValueTypeMarker>::borrow),
6560 encoder,
6561 offset + cur_offset,
6562 depth,
6563 )?;
6564
6565 _prev_end_offset = cur_offset + envelope_size;
6566
6567 Ok(())
6568 }
6569 }
6570
6571 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolvedInfo {
6572 #[inline(always)]
6573 fn new_empty() -> Self {
6574 Self::default()
6575 }
6576
6577 unsafe fn decode(
6578 &mut self,
6579 decoder: &mut fidl::encoding::Decoder<'_, D>,
6580 offset: usize,
6581 mut depth: fidl::encoding::Depth,
6582 ) -> fidl::Result<()> {
6583 decoder.debug_check_bounds::<Self>(offset);
6584 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6585 None => return Err(fidl::Error::NotNullable),
6586 Some(len) => len,
6587 };
6588 if len == 0 {
6590 return Ok(());
6591 };
6592 depth.increment()?;
6593 let envelope_size = 8;
6594 let bytes_len = len * envelope_size;
6595 let offset = decoder.out_of_line_offset(bytes_len)?;
6596 let mut _next_ordinal_to_read = 0;
6598 let mut next_offset = offset;
6599 let end_offset = offset + bytes_len;
6600 _next_ordinal_to_read += 1;
6601 if next_offset >= end_offset {
6602 return Ok(());
6603 }
6604
6605 while _next_ordinal_to_read < 1 {
6607 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6608 _next_ordinal_to_read += 1;
6609 next_offset += envelope_size;
6610 }
6611
6612 let next_out_of_line = decoder.next_out_of_line();
6613 let handles_before = decoder.remaining_handles();
6614 if let Some((inlined, num_bytes, num_handles)) =
6615 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6616 {
6617 let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6618 if inlined != (member_inline_size <= 4) {
6619 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6620 }
6621 let inner_offset;
6622 let mut inner_depth = depth.clone();
6623 if inlined {
6624 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6625 inner_offset = next_offset;
6626 } else {
6627 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6628 inner_depth.increment()?;
6629 }
6630 let val_ref = self.resolved_url.get_or_insert_with(|| {
6631 fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6632 });
6633 fidl::decode!(
6634 fidl::encoding::BoundedString<4096>,
6635 D,
6636 val_ref,
6637 decoder,
6638 inner_offset,
6639 inner_depth
6640 )?;
6641 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6642 {
6643 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6644 }
6645 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6646 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6647 }
6648 }
6649
6650 next_offset += envelope_size;
6651 _next_ordinal_to_read += 1;
6652 if next_offset >= end_offset {
6653 return Ok(());
6654 }
6655
6656 while _next_ordinal_to_read < 2 {
6658 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6659 _next_ordinal_to_read += 1;
6660 next_offset += envelope_size;
6661 }
6662
6663 let next_out_of_line = decoder.next_out_of_line();
6664 let handles_before = decoder.remaining_handles();
6665 if let Some((inlined, num_bytes, num_handles)) =
6666 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6667 {
6668 let member_inline_size =
6669 <ExecutionInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6670 if inlined != (member_inline_size <= 4) {
6671 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6672 }
6673 let inner_offset;
6674 let mut inner_depth = depth.clone();
6675 if inlined {
6676 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6677 inner_offset = next_offset;
6678 } else {
6679 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6680 inner_depth.increment()?;
6681 }
6682 let val_ref =
6683 self.execution_info.get_or_insert_with(|| fidl::new_empty!(ExecutionInfo, D));
6684 fidl::decode!(ExecutionInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
6685 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6686 {
6687 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6688 }
6689 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6690 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6691 }
6692 }
6693
6694 next_offset += envelope_size;
6695
6696 while next_offset < end_offset {
6698 _next_ordinal_to_read += 1;
6699 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6700 next_offset += envelope_size;
6701 }
6702
6703 Ok(())
6704 }
6705 }
6706
6707 impl RouteError {
6708 #[inline(always)]
6709 fn max_ordinal_present(&self) -> u64 {
6710 if let Some(_) = self.summary {
6711 return 1;
6712 }
6713 0
6714 }
6715 }
6716
6717 impl fidl::encoding::ValueTypeMarker for RouteError {
6718 type Borrowed<'a> = &'a Self;
6719 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6720 value
6721 }
6722 }
6723
6724 unsafe impl fidl::encoding::TypeMarker for RouteError {
6725 type Owned = Self;
6726
6727 #[inline(always)]
6728 fn inline_align(_context: fidl::encoding::Context) -> usize {
6729 8
6730 }
6731
6732 #[inline(always)]
6733 fn inline_size(_context: fidl::encoding::Context) -> usize {
6734 16
6735 }
6736 }
6737
6738 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RouteError, D>
6739 for &RouteError
6740 {
6741 unsafe fn encode(
6742 self,
6743 encoder: &mut fidl::encoding::Encoder<'_, D>,
6744 offset: usize,
6745 mut depth: fidl::encoding::Depth,
6746 ) -> fidl::Result<()> {
6747 encoder.debug_check_bounds::<RouteError>(offset);
6748 let max_ordinal: u64 = self.max_ordinal_present();
6750 encoder.write_num(max_ordinal, offset);
6751 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6752 if max_ordinal == 0 {
6754 return Ok(());
6755 }
6756 depth.increment()?;
6757 let envelope_size = 8;
6758 let bytes_len = max_ordinal as usize * envelope_size;
6759 #[allow(unused_variables)]
6760 let offset = encoder.out_of_line_offset(bytes_len);
6761 let mut _prev_end_offset: usize = 0;
6762 if 1 > max_ordinal {
6763 return Ok(());
6764 }
6765
6766 let cur_offset: usize = (1 - 1) * envelope_size;
6769
6770 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6772
6773 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
6778 self.summary.as_ref().map(
6779 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
6780 ),
6781 encoder,
6782 offset + cur_offset,
6783 depth,
6784 )?;
6785
6786 _prev_end_offset = cur_offset + envelope_size;
6787
6788 Ok(())
6789 }
6790 }
6791
6792 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RouteError {
6793 #[inline(always)]
6794 fn new_empty() -> Self {
6795 Self::default()
6796 }
6797
6798 unsafe fn decode(
6799 &mut self,
6800 decoder: &mut fidl::encoding::Decoder<'_, D>,
6801 offset: usize,
6802 mut depth: fidl::encoding::Depth,
6803 ) -> fidl::Result<()> {
6804 decoder.debug_check_bounds::<Self>(offset);
6805 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6806 None => return Err(fidl::Error::NotNullable),
6807 Some(len) => len,
6808 };
6809 if len == 0 {
6811 return Ok(());
6812 };
6813 depth.increment()?;
6814 let envelope_size = 8;
6815 let bytes_len = len * envelope_size;
6816 let offset = decoder.out_of_line_offset(bytes_len)?;
6817 let mut _next_ordinal_to_read = 0;
6819 let mut next_offset = offset;
6820 let end_offset = offset + bytes_len;
6821 _next_ordinal_to_read += 1;
6822 if next_offset >= end_offset {
6823 return Ok(());
6824 }
6825
6826 while _next_ordinal_to_read < 1 {
6828 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6829 _next_ordinal_to_read += 1;
6830 next_offset += envelope_size;
6831 }
6832
6833 let next_out_of_line = decoder.next_out_of_line();
6834 let handles_before = decoder.remaining_handles();
6835 if let Some((inlined, num_bytes, num_handles)) =
6836 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6837 {
6838 let member_inline_size =
6839 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
6840 decoder.context,
6841 );
6842 if inlined != (member_inline_size <= 4) {
6843 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6844 }
6845 let inner_offset;
6846 let mut inner_depth = depth.clone();
6847 if inlined {
6848 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6849 inner_offset = next_offset;
6850 } else {
6851 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6852 inner_depth.increment()?;
6853 }
6854 let val_ref = self
6855 .summary
6856 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
6857 fidl::decode!(
6858 fidl::encoding::UnboundedString,
6859 D,
6860 val_ref,
6861 decoder,
6862 inner_offset,
6863 inner_depth
6864 )?;
6865 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6866 {
6867 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6868 }
6869 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6870 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6871 }
6872 }
6873
6874 next_offset += envelope_size;
6875
6876 while next_offset < end_offset {
6878 _next_ordinal_to_read += 1;
6879 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6880 next_offset += envelope_size;
6881 }
6882
6883 Ok(())
6884 }
6885 }
6886
6887 impl RouteReport {
6888 #[inline(always)]
6889 fn max_ordinal_present(&self) -> u64 {
6890 if let Some(_) = self.outcome {
6891 return 7;
6892 }
6893 if let Some(_) = self.availability {
6894 return 6;
6895 }
6896 if let Some(_) = self.service_instances {
6897 return 5;
6898 }
6899 if let Some(_) = self.source_moniker {
6900 return 4;
6901 }
6902 if let Some(_) = self.error {
6903 return 3;
6904 }
6905 if let Some(_) = self.decl_type {
6906 return 2;
6907 }
6908 if let Some(_) = self.capability {
6909 return 1;
6910 }
6911 0
6912 }
6913 }
6914
6915 impl fidl::encoding::ValueTypeMarker for RouteReport {
6916 type Borrowed<'a> = &'a Self;
6917 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6918 value
6919 }
6920 }
6921
6922 unsafe impl fidl::encoding::TypeMarker for RouteReport {
6923 type Owned = Self;
6924
6925 #[inline(always)]
6926 fn inline_align(_context: fidl::encoding::Context) -> usize {
6927 8
6928 }
6929
6930 #[inline(always)]
6931 fn inline_size(_context: fidl::encoding::Context) -> usize {
6932 16
6933 }
6934 }
6935
6936 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RouteReport, D>
6937 for &RouteReport
6938 {
6939 unsafe fn encode(
6940 self,
6941 encoder: &mut fidl::encoding::Encoder<'_, D>,
6942 offset: usize,
6943 mut depth: fidl::encoding::Depth,
6944 ) -> fidl::Result<()> {
6945 encoder.debug_check_bounds::<RouteReport>(offset);
6946 let max_ordinal: u64 = self.max_ordinal_present();
6948 encoder.write_num(max_ordinal, offset);
6949 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6950 if max_ordinal == 0 {
6952 return Ok(());
6953 }
6954 depth.increment()?;
6955 let envelope_size = 8;
6956 let bytes_len = max_ordinal as usize * envelope_size;
6957 #[allow(unused_variables)]
6958 let offset = encoder.out_of_line_offset(bytes_len);
6959 let mut _prev_end_offset: usize = 0;
6960 if 1 > max_ordinal {
6961 return Ok(());
6962 }
6963
6964 let cur_offset: usize = (1 - 1) * envelope_size;
6967
6968 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6970
6971 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
6976 self.capability.as_ref().map(
6977 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
6978 ),
6979 encoder,
6980 offset + cur_offset,
6981 depth,
6982 )?;
6983
6984 _prev_end_offset = cur_offset + envelope_size;
6985 if 2 > max_ordinal {
6986 return Ok(());
6987 }
6988
6989 let cur_offset: usize = (2 - 1) * envelope_size;
6992
6993 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6995
6996 fidl::encoding::encode_in_envelope_optional::<DeclType, D>(
7001 self.decl_type.as_ref().map(<DeclType as fidl::encoding::ValueTypeMarker>::borrow),
7002 encoder,
7003 offset + cur_offset,
7004 depth,
7005 )?;
7006
7007 _prev_end_offset = cur_offset + envelope_size;
7008 if 3 > max_ordinal {
7009 return Ok(());
7010 }
7011
7012 let cur_offset: usize = (3 - 1) * envelope_size;
7015
7016 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7018
7019 fidl::encoding::encode_in_envelope_optional::<RouteError, D>(
7024 self.error.as_ref().map(<RouteError as fidl::encoding::ValueTypeMarker>::borrow),
7025 encoder,
7026 offset + cur_offset,
7027 depth,
7028 )?;
7029
7030 _prev_end_offset = cur_offset + envelope_size;
7031 if 4 > max_ordinal {
7032 return Ok(());
7033 }
7034
7035 let cur_offset: usize = (4 - 1) * envelope_size;
7038
7039 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7041
7042 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
7047 self.source_moniker.as_ref().map(
7048 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
7049 ),
7050 encoder,
7051 offset + cur_offset,
7052 depth,
7053 )?;
7054
7055 _prev_end_offset = cur_offset + envelope_size;
7056 if 5 > max_ordinal {
7057 return Ok(());
7058 }
7059
7060 let cur_offset: usize = (5 - 1) * envelope_size;
7063
7064 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7066
7067 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ServiceInstance>, D>(
7072 self.service_instances.as_ref().map(<fidl::encoding::UnboundedVector<ServiceInstance> as fidl::encoding::ValueTypeMarker>::borrow),
7073 encoder, offset + cur_offset, depth
7074 )?;
7075
7076 _prev_end_offset = cur_offset + envelope_size;
7077 if 6 > max_ordinal {
7078 return Ok(());
7079 }
7080
7081 let cur_offset: usize = (6 - 1) * envelope_size;
7084
7085 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7087
7088 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
7093 self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
7094 encoder, offset + cur_offset, depth
7095 )?;
7096
7097 _prev_end_offset = cur_offset + envelope_size;
7098 if 7 > max_ordinal {
7099 return Ok(());
7100 }
7101
7102 let cur_offset: usize = (7 - 1) * envelope_size;
7105
7106 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7108
7109 fidl::encoding::encode_in_envelope_optional::<RouteOutcome, D>(
7114 self.outcome
7115 .as_ref()
7116 .map(<RouteOutcome as fidl::encoding::ValueTypeMarker>::borrow),
7117 encoder,
7118 offset + cur_offset,
7119 depth,
7120 )?;
7121
7122 _prev_end_offset = cur_offset + envelope_size;
7123
7124 Ok(())
7125 }
7126 }
7127
7128 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RouteReport {
7129 #[inline(always)]
7130 fn new_empty() -> Self {
7131 Self::default()
7132 }
7133
7134 unsafe fn decode(
7135 &mut self,
7136 decoder: &mut fidl::encoding::Decoder<'_, D>,
7137 offset: usize,
7138 mut depth: fidl::encoding::Depth,
7139 ) -> fidl::Result<()> {
7140 decoder.debug_check_bounds::<Self>(offset);
7141 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7142 None => return Err(fidl::Error::NotNullable),
7143 Some(len) => len,
7144 };
7145 if len == 0 {
7147 return Ok(());
7148 };
7149 depth.increment()?;
7150 let envelope_size = 8;
7151 let bytes_len = len * envelope_size;
7152 let offset = decoder.out_of_line_offset(bytes_len)?;
7153 let mut _next_ordinal_to_read = 0;
7155 let mut next_offset = offset;
7156 let end_offset = offset + bytes_len;
7157 _next_ordinal_to_read += 1;
7158 if next_offset >= end_offset {
7159 return Ok(());
7160 }
7161
7162 while _next_ordinal_to_read < 1 {
7164 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7165 _next_ordinal_to_read += 1;
7166 next_offset += envelope_size;
7167 }
7168
7169 let next_out_of_line = decoder.next_out_of_line();
7170 let handles_before = decoder.remaining_handles();
7171 if let Some((inlined, num_bytes, num_handles)) =
7172 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7173 {
7174 let member_inline_size =
7175 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7176 decoder.context,
7177 );
7178 if inlined != (member_inline_size <= 4) {
7179 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7180 }
7181 let inner_offset;
7182 let mut inner_depth = depth.clone();
7183 if inlined {
7184 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7185 inner_offset = next_offset;
7186 } else {
7187 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7188 inner_depth.increment()?;
7189 }
7190 let val_ref = self
7191 .capability
7192 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7193 fidl::decode!(
7194 fidl::encoding::UnboundedString,
7195 D,
7196 val_ref,
7197 decoder,
7198 inner_offset,
7199 inner_depth
7200 )?;
7201 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7202 {
7203 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7204 }
7205 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7206 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7207 }
7208 }
7209
7210 next_offset += envelope_size;
7211 _next_ordinal_to_read += 1;
7212 if next_offset >= end_offset {
7213 return Ok(());
7214 }
7215
7216 while _next_ordinal_to_read < 2 {
7218 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7219 _next_ordinal_to_read += 1;
7220 next_offset += envelope_size;
7221 }
7222
7223 let next_out_of_line = decoder.next_out_of_line();
7224 let handles_before = decoder.remaining_handles();
7225 if let Some((inlined, num_bytes, num_handles)) =
7226 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7227 {
7228 let member_inline_size =
7229 <DeclType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7230 if inlined != (member_inline_size <= 4) {
7231 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7232 }
7233 let inner_offset;
7234 let mut inner_depth = depth.clone();
7235 if inlined {
7236 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7237 inner_offset = next_offset;
7238 } else {
7239 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7240 inner_depth.increment()?;
7241 }
7242 let val_ref = self.decl_type.get_or_insert_with(|| fidl::new_empty!(DeclType, D));
7243 fidl::decode!(DeclType, D, val_ref, decoder, inner_offset, inner_depth)?;
7244 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7245 {
7246 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7247 }
7248 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7249 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7250 }
7251 }
7252
7253 next_offset += envelope_size;
7254 _next_ordinal_to_read += 1;
7255 if next_offset >= end_offset {
7256 return Ok(());
7257 }
7258
7259 while _next_ordinal_to_read < 3 {
7261 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7262 _next_ordinal_to_read += 1;
7263 next_offset += envelope_size;
7264 }
7265
7266 let next_out_of_line = decoder.next_out_of_line();
7267 let handles_before = decoder.remaining_handles();
7268 if let Some((inlined, num_bytes, num_handles)) =
7269 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7270 {
7271 let member_inline_size =
7272 <RouteError as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7273 if inlined != (member_inline_size <= 4) {
7274 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7275 }
7276 let inner_offset;
7277 let mut inner_depth = depth.clone();
7278 if inlined {
7279 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7280 inner_offset = next_offset;
7281 } else {
7282 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7283 inner_depth.increment()?;
7284 }
7285 let val_ref = self.error.get_or_insert_with(|| fidl::new_empty!(RouteError, D));
7286 fidl::decode!(RouteError, D, val_ref, decoder, inner_offset, inner_depth)?;
7287 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7288 {
7289 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7290 }
7291 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7292 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7293 }
7294 }
7295
7296 next_offset += envelope_size;
7297 _next_ordinal_to_read += 1;
7298 if next_offset >= end_offset {
7299 return Ok(());
7300 }
7301
7302 while _next_ordinal_to_read < 4 {
7304 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7305 _next_ordinal_to_read += 1;
7306 next_offset += envelope_size;
7307 }
7308
7309 let next_out_of_line = decoder.next_out_of_line();
7310 let handles_before = decoder.remaining_handles();
7311 if let Some((inlined, num_bytes, num_handles)) =
7312 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7313 {
7314 let member_inline_size =
7315 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7316 decoder.context,
7317 );
7318 if inlined != (member_inline_size <= 4) {
7319 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7320 }
7321 let inner_offset;
7322 let mut inner_depth = depth.clone();
7323 if inlined {
7324 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7325 inner_offset = next_offset;
7326 } else {
7327 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7328 inner_depth.increment()?;
7329 }
7330 let val_ref = self
7331 .source_moniker
7332 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7333 fidl::decode!(
7334 fidl::encoding::UnboundedString,
7335 D,
7336 val_ref,
7337 decoder,
7338 inner_offset,
7339 inner_depth
7340 )?;
7341 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7342 {
7343 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7344 }
7345 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7346 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7347 }
7348 }
7349
7350 next_offset += envelope_size;
7351 _next_ordinal_to_read += 1;
7352 if next_offset >= end_offset {
7353 return Ok(());
7354 }
7355
7356 while _next_ordinal_to_read < 5 {
7358 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7359 _next_ordinal_to_read += 1;
7360 next_offset += envelope_size;
7361 }
7362
7363 let next_out_of_line = decoder.next_out_of_line();
7364 let handles_before = decoder.remaining_handles();
7365 if let Some((inlined, num_bytes, num_handles)) =
7366 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7367 {
7368 let member_inline_size = <fidl::encoding::UnboundedVector<ServiceInstance> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7369 if inlined != (member_inline_size <= 4) {
7370 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7371 }
7372 let inner_offset;
7373 let mut inner_depth = depth.clone();
7374 if inlined {
7375 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7376 inner_offset = next_offset;
7377 } else {
7378 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7379 inner_depth.increment()?;
7380 }
7381 let val_ref = self.service_instances.get_or_insert_with(|| {
7382 fidl::new_empty!(fidl::encoding::UnboundedVector<ServiceInstance>, D)
7383 });
7384 fidl::decode!(
7385 fidl::encoding::UnboundedVector<ServiceInstance>,
7386 D,
7387 val_ref,
7388 decoder,
7389 inner_offset,
7390 inner_depth
7391 )?;
7392 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7393 {
7394 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7395 }
7396 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7397 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7398 }
7399 }
7400
7401 next_offset += envelope_size;
7402 _next_ordinal_to_read += 1;
7403 if next_offset >= end_offset {
7404 return Ok(());
7405 }
7406
7407 while _next_ordinal_to_read < 6 {
7409 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7410 _next_ordinal_to_read += 1;
7411 next_offset += envelope_size;
7412 }
7413
7414 let next_out_of_line = decoder.next_out_of_line();
7415 let handles_before = decoder.remaining_handles();
7416 if let Some((inlined, num_bytes, num_handles)) =
7417 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7418 {
7419 let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7420 if inlined != (member_inline_size <= 4) {
7421 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7422 }
7423 let inner_offset;
7424 let mut inner_depth = depth.clone();
7425 if inlined {
7426 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7427 inner_offset = next_offset;
7428 } else {
7429 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7430 inner_depth.increment()?;
7431 }
7432 let val_ref = self.availability.get_or_insert_with(|| {
7433 fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
7434 });
7435 fidl::decode!(
7436 fidl_fuchsia_component_decl__common::Availability,
7437 D,
7438 val_ref,
7439 decoder,
7440 inner_offset,
7441 inner_depth
7442 )?;
7443 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7444 {
7445 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7446 }
7447 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7448 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7449 }
7450 }
7451
7452 next_offset += envelope_size;
7453 _next_ordinal_to_read += 1;
7454 if next_offset >= end_offset {
7455 return Ok(());
7456 }
7457
7458 while _next_ordinal_to_read < 7 {
7460 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7461 _next_ordinal_to_read += 1;
7462 next_offset += envelope_size;
7463 }
7464
7465 let next_out_of_line = decoder.next_out_of_line();
7466 let handles_before = decoder.remaining_handles();
7467 if let Some((inlined, num_bytes, num_handles)) =
7468 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7469 {
7470 let member_inline_size =
7471 <RouteOutcome as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7472 if inlined != (member_inline_size <= 4) {
7473 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7474 }
7475 let inner_offset;
7476 let mut inner_depth = depth.clone();
7477 if inlined {
7478 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7479 inner_offset = next_offset;
7480 } else {
7481 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7482 inner_depth.increment()?;
7483 }
7484 let val_ref = self.outcome.get_or_insert_with(|| fidl::new_empty!(RouteOutcome, D));
7485 fidl::decode!(RouteOutcome, D, val_ref, decoder, inner_offset, inner_depth)?;
7486 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7487 {
7488 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7489 }
7490 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7491 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7492 }
7493 }
7494
7495 next_offset += envelope_size;
7496
7497 while next_offset < end_offset {
7499 _next_ordinal_to_read += 1;
7500 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7501 next_offset += envelope_size;
7502 }
7503
7504 Ok(())
7505 }
7506 }
7507
7508 impl ServiceInstance {
7509 #[inline(always)]
7510 fn max_ordinal_present(&self) -> u64 {
7511 if let Some(_) = self.child_instance_name {
7512 return 3;
7513 }
7514 if let Some(_) = self.child_name {
7515 return 2;
7516 }
7517 if let Some(_) = self.instance_name {
7518 return 1;
7519 }
7520 0
7521 }
7522 }
7523
7524 impl fidl::encoding::ValueTypeMarker for ServiceInstance {
7525 type Borrowed<'a> = &'a Self;
7526 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7527 value
7528 }
7529 }
7530
7531 unsafe impl fidl::encoding::TypeMarker for ServiceInstance {
7532 type Owned = Self;
7533
7534 #[inline(always)]
7535 fn inline_align(_context: fidl::encoding::Context) -> usize {
7536 8
7537 }
7538
7539 #[inline(always)]
7540 fn inline_size(_context: fidl::encoding::Context) -> usize {
7541 16
7542 }
7543 }
7544
7545 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceInstance, D>
7546 for &ServiceInstance
7547 {
7548 unsafe fn encode(
7549 self,
7550 encoder: &mut fidl::encoding::Encoder<'_, D>,
7551 offset: usize,
7552 mut depth: fidl::encoding::Depth,
7553 ) -> fidl::Result<()> {
7554 encoder.debug_check_bounds::<ServiceInstance>(offset);
7555 let max_ordinal: u64 = self.max_ordinal_present();
7557 encoder.write_num(max_ordinal, offset);
7558 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7559 if max_ordinal == 0 {
7561 return Ok(());
7562 }
7563 depth.increment()?;
7564 let envelope_size = 8;
7565 let bytes_len = max_ordinal as usize * envelope_size;
7566 #[allow(unused_variables)]
7567 let offset = encoder.out_of_line_offset(bytes_len);
7568 let mut _prev_end_offset: usize = 0;
7569 if 1 > max_ordinal {
7570 return Ok(());
7571 }
7572
7573 let cur_offset: usize = (1 - 1) * envelope_size;
7576
7577 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7579
7580 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
7585 self.instance_name.as_ref().map(
7586 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
7587 ),
7588 encoder,
7589 offset + cur_offset,
7590 depth,
7591 )?;
7592
7593 _prev_end_offset = cur_offset + envelope_size;
7594 if 2 > max_ordinal {
7595 return Ok(());
7596 }
7597
7598 let cur_offset: usize = (2 - 1) * envelope_size;
7601
7602 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7604
7605 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
7610 self.child_name.as_ref().map(
7611 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
7612 ),
7613 encoder,
7614 offset + cur_offset,
7615 depth,
7616 )?;
7617
7618 _prev_end_offset = cur_offset + envelope_size;
7619 if 3 > max_ordinal {
7620 return Ok(());
7621 }
7622
7623 let cur_offset: usize = (3 - 1) * envelope_size;
7626
7627 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7629
7630 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
7635 self.child_instance_name.as_ref().map(
7636 <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
7637 ),
7638 encoder,
7639 offset + cur_offset,
7640 depth,
7641 )?;
7642
7643 _prev_end_offset = cur_offset + envelope_size;
7644
7645 Ok(())
7646 }
7647 }
7648
7649 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceInstance {
7650 #[inline(always)]
7651 fn new_empty() -> Self {
7652 Self::default()
7653 }
7654
7655 unsafe fn decode(
7656 &mut self,
7657 decoder: &mut fidl::encoding::Decoder<'_, D>,
7658 offset: usize,
7659 mut depth: fidl::encoding::Depth,
7660 ) -> fidl::Result<()> {
7661 decoder.debug_check_bounds::<Self>(offset);
7662 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7663 None => return Err(fidl::Error::NotNullable),
7664 Some(len) => len,
7665 };
7666 if len == 0 {
7668 return Ok(());
7669 };
7670 depth.increment()?;
7671 let envelope_size = 8;
7672 let bytes_len = len * envelope_size;
7673 let offset = decoder.out_of_line_offset(bytes_len)?;
7674 let mut _next_ordinal_to_read = 0;
7676 let mut next_offset = offset;
7677 let end_offset = offset + bytes_len;
7678 _next_ordinal_to_read += 1;
7679 if next_offset >= end_offset {
7680 return Ok(());
7681 }
7682
7683 while _next_ordinal_to_read < 1 {
7685 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7686 _next_ordinal_to_read += 1;
7687 next_offset += envelope_size;
7688 }
7689
7690 let next_out_of_line = decoder.next_out_of_line();
7691 let handles_before = decoder.remaining_handles();
7692 if let Some((inlined, num_bytes, num_handles)) =
7693 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7694 {
7695 let member_inline_size =
7696 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7697 decoder.context,
7698 );
7699 if inlined != (member_inline_size <= 4) {
7700 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7701 }
7702 let inner_offset;
7703 let mut inner_depth = depth.clone();
7704 if inlined {
7705 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7706 inner_offset = next_offset;
7707 } else {
7708 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7709 inner_depth.increment()?;
7710 }
7711 let val_ref = self
7712 .instance_name
7713 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7714 fidl::decode!(
7715 fidl::encoding::UnboundedString,
7716 D,
7717 val_ref,
7718 decoder,
7719 inner_offset,
7720 inner_depth
7721 )?;
7722 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7723 {
7724 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7725 }
7726 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7727 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7728 }
7729 }
7730
7731 next_offset += envelope_size;
7732 _next_ordinal_to_read += 1;
7733 if next_offset >= end_offset {
7734 return Ok(());
7735 }
7736
7737 while _next_ordinal_to_read < 2 {
7739 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7740 _next_ordinal_to_read += 1;
7741 next_offset += envelope_size;
7742 }
7743
7744 let next_out_of_line = decoder.next_out_of_line();
7745 let handles_before = decoder.remaining_handles();
7746 if let Some((inlined, num_bytes, num_handles)) =
7747 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7748 {
7749 let member_inline_size =
7750 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7751 decoder.context,
7752 );
7753 if inlined != (member_inline_size <= 4) {
7754 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7755 }
7756 let inner_offset;
7757 let mut inner_depth = depth.clone();
7758 if inlined {
7759 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7760 inner_offset = next_offset;
7761 } else {
7762 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7763 inner_depth.increment()?;
7764 }
7765 let val_ref = self
7766 .child_name
7767 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7768 fidl::decode!(
7769 fidl::encoding::UnboundedString,
7770 D,
7771 val_ref,
7772 decoder,
7773 inner_offset,
7774 inner_depth
7775 )?;
7776 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7777 {
7778 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7779 }
7780 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7781 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7782 }
7783 }
7784
7785 next_offset += envelope_size;
7786 _next_ordinal_to_read += 1;
7787 if next_offset >= end_offset {
7788 return Ok(());
7789 }
7790
7791 while _next_ordinal_to_read < 3 {
7793 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7794 _next_ordinal_to_read += 1;
7795 next_offset += envelope_size;
7796 }
7797
7798 let next_out_of_line = decoder.next_out_of_line();
7799 let handles_before = decoder.remaining_handles();
7800 if let Some((inlined, num_bytes, num_handles)) =
7801 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7802 {
7803 let member_inline_size =
7804 <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7805 decoder.context,
7806 );
7807 if inlined != (member_inline_size <= 4) {
7808 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7809 }
7810 let inner_offset;
7811 let mut inner_depth = depth.clone();
7812 if inlined {
7813 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7814 inner_offset = next_offset;
7815 } else {
7816 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7817 inner_depth.increment()?;
7818 }
7819 let val_ref = self
7820 .child_instance_name
7821 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7822 fidl::decode!(
7823 fidl::encoding::UnboundedString,
7824 D,
7825 val_ref,
7826 decoder,
7827 inner_offset,
7828 inner_depth
7829 )?;
7830 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7831 {
7832 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7833 }
7834 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7835 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7836 }
7837 }
7838
7839 next_offset += envelope_size;
7840
7841 while next_offset < end_offset {
7843 _next_ordinal_to_read += 1;
7844 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7845 next_offset += envelope_size;
7846 }
7847
7848 Ok(())
7849 }
7850 }
7851
7852 impl StorageStatus {
7853 #[inline(always)]
7854 fn max_ordinal_present(&self) -> u64 {
7855 if let Some(_) = self.used_size {
7856 return 2;
7857 }
7858 if let Some(_) = self.total_size {
7859 return 1;
7860 }
7861 0
7862 }
7863 }
7864
7865 impl fidl::encoding::ValueTypeMarker for StorageStatus {
7866 type Borrowed<'a> = &'a Self;
7867 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7868 value
7869 }
7870 }
7871
7872 unsafe impl fidl::encoding::TypeMarker for StorageStatus {
7873 type Owned = Self;
7874
7875 #[inline(always)]
7876 fn inline_align(_context: fidl::encoding::Context) -> usize {
7877 8
7878 }
7879
7880 #[inline(always)]
7881 fn inline_size(_context: fidl::encoding::Context) -> usize {
7882 16
7883 }
7884 }
7885
7886 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StorageStatus, D>
7887 for &StorageStatus
7888 {
7889 unsafe fn encode(
7890 self,
7891 encoder: &mut fidl::encoding::Encoder<'_, D>,
7892 offset: usize,
7893 mut depth: fidl::encoding::Depth,
7894 ) -> fidl::Result<()> {
7895 encoder.debug_check_bounds::<StorageStatus>(offset);
7896 let max_ordinal: u64 = self.max_ordinal_present();
7898 encoder.write_num(max_ordinal, offset);
7899 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7900 if max_ordinal == 0 {
7902 return Ok(());
7903 }
7904 depth.increment()?;
7905 let envelope_size = 8;
7906 let bytes_len = max_ordinal as usize * envelope_size;
7907 #[allow(unused_variables)]
7908 let offset = encoder.out_of_line_offset(bytes_len);
7909 let mut _prev_end_offset: usize = 0;
7910 if 1 > max_ordinal {
7911 return Ok(());
7912 }
7913
7914 let cur_offset: usize = (1 - 1) * envelope_size;
7917
7918 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7920
7921 fidl::encoding::encode_in_envelope_optional::<u64, D>(
7926 self.total_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7927 encoder,
7928 offset + cur_offset,
7929 depth,
7930 )?;
7931
7932 _prev_end_offset = cur_offset + envelope_size;
7933 if 2 > max_ordinal {
7934 return Ok(());
7935 }
7936
7937 let cur_offset: usize = (2 - 1) * envelope_size;
7940
7941 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7943
7944 fidl::encoding::encode_in_envelope_optional::<u64, D>(
7949 self.used_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7950 encoder,
7951 offset + cur_offset,
7952 depth,
7953 )?;
7954
7955 _prev_end_offset = cur_offset + envelope_size;
7956
7957 Ok(())
7958 }
7959 }
7960
7961 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StorageStatus {
7962 #[inline(always)]
7963 fn new_empty() -> Self {
7964 Self::default()
7965 }
7966
7967 unsafe fn decode(
7968 &mut self,
7969 decoder: &mut fidl::encoding::Decoder<'_, D>,
7970 offset: usize,
7971 mut depth: fidl::encoding::Depth,
7972 ) -> fidl::Result<()> {
7973 decoder.debug_check_bounds::<Self>(offset);
7974 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7975 None => return Err(fidl::Error::NotNullable),
7976 Some(len) => len,
7977 };
7978 if len == 0 {
7980 return Ok(());
7981 };
7982 depth.increment()?;
7983 let envelope_size = 8;
7984 let bytes_len = len * envelope_size;
7985 let offset = decoder.out_of_line_offset(bytes_len)?;
7986 let mut _next_ordinal_to_read = 0;
7988 let mut next_offset = offset;
7989 let end_offset = offset + bytes_len;
7990 _next_ordinal_to_read += 1;
7991 if next_offset >= end_offset {
7992 return Ok(());
7993 }
7994
7995 while _next_ordinal_to_read < 1 {
7997 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7998 _next_ordinal_to_read += 1;
7999 next_offset += envelope_size;
8000 }
8001
8002 let next_out_of_line = decoder.next_out_of_line();
8003 let handles_before = decoder.remaining_handles();
8004 if let Some((inlined, num_bytes, num_handles)) =
8005 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8006 {
8007 let member_inline_size =
8008 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8009 if inlined != (member_inline_size <= 4) {
8010 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8011 }
8012 let inner_offset;
8013 let mut inner_depth = depth.clone();
8014 if inlined {
8015 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8016 inner_offset = next_offset;
8017 } else {
8018 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8019 inner_depth.increment()?;
8020 }
8021 let val_ref = self.total_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
8022 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8023 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8024 {
8025 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8026 }
8027 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8028 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8029 }
8030 }
8031
8032 next_offset += envelope_size;
8033 _next_ordinal_to_read += 1;
8034 if next_offset >= end_offset {
8035 return Ok(());
8036 }
8037
8038 while _next_ordinal_to_read < 2 {
8040 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8041 _next_ordinal_to_read += 1;
8042 next_offset += envelope_size;
8043 }
8044
8045 let next_out_of_line = decoder.next_out_of_line();
8046 let handles_before = decoder.remaining_handles();
8047 if let Some((inlined, num_bytes, num_handles)) =
8048 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8049 {
8050 let member_inline_size =
8051 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8052 if inlined != (member_inline_size <= 4) {
8053 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8054 }
8055 let inner_offset;
8056 let mut inner_depth = depth.clone();
8057 if inlined {
8058 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8059 inner_offset = next_offset;
8060 } else {
8061 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8062 inner_depth.increment()?;
8063 }
8064 let val_ref = self.used_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
8065 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8066 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8067 {
8068 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8069 }
8070 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8071 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8072 }
8073 }
8074
8075 next_offset += envelope_size;
8076
8077 while next_offset < end_offset {
8079 _next_ordinal_to_read += 1;
8080 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8081 next_offset += envelope_size;
8082 }
8083
8084 Ok(())
8085 }
8086 }
8087
8088 impl fidl::encoding::ValueTypeMarker for ChildLocation {
8089 type Borrowed<'a> = &'a Self;
8090 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8091 value
8092 }
8093 }
8094
8095 unsafe impl fidl::encoding::TypeMarker for ChildLocation {
8096 type Owned = Self;
8097
8098 #[inline(always)]
8099 fn inline_align(_context: fidl::encoding::Context) -> usize {
8100 8
8101 }
8102
8103 #[inline(always)]
8104 fn inline_size(_context: fidl::encoding::Context) -> usize {
8105 16
8106 }
8107 }
8108
8109 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChildLocation, D>
8110 for &ChildLocation
8111 {
8112 #[inline]
8113 unsafe fn encode(
8114 self,
8115 encoder: &mut fidl::encoding::Encoder<'_, D>,
8116 offset: usize,
8117 _depth: fidl::encoding::Depth,
8118 ) -> fidl::Result<()> {
8119 encoder.debug_check_bounds::<ChildLocation>(offset);
8120 encoder.write_num::<u64>(self.ordinal(), offset);
8121 match self {
8122 ChildLocation::Collection(ref val) => fidl::encoding::encode_in_envelope::<
8123 fidl::encoding::BoundedString<255>,
8124 D,
8125 >(
8126 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
8127 val,
8128 ),
8129 encoder,
8130 offset + 8,
8131 _depth,
8132 ),
8133 ChildLocation::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
8134 }
8135 }
8136 }
8137
8138 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildLocation {
8139 #[inline(always)]
8140 fn new_empty() -> Self {
8141 Self::__SourceBreaking { unknown_ordinal: 0 }
8142 }
8143
8144 #[inline]
8145 unsafe fn decode(
8146 &mut self,
8147 decoder: &mut fidl::encoding::Decoder<'_, D>,
8148 offset: usize,
8149 mut depth: fidl::encoding::Depth,
8150 ) -> fidl::Result<()> {
8151 decoder.debug_check_bounds::<Self>(offset);
8152 #[allow(unused_variables)]
8153 let next_out_of_line = decoder.next_out_of_line();
8154 let handles_before = decoder.remaining_handles();
8155 let (ordinal, inlined, num_bytes, num_handles) =
8156 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
8157
8158 let member_inline_size = match ordinal {
8159 1 => {
8160 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
8161 decoder.context,
8162 )
8163 }
8164 0 => return Err(fidl::Error::UnknownUnionTag),
8165 _ => num_bytes as usize,
8166 };
8167
8168 if inlined != (member_inline_size <= 4) {
8169 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8170 }
8171 let _inner_offset;
8172 if inlined {
8173 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
8174 _inner_offset = offset + 8;
8175 } else {
8176 depth.increment()?;
8177 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8178 }
8179 match ordinal {
8180 1 => {
8181 #[allow(irrefutable_let_patterns)]
8182 if let ChildLocation::Collection(_) = self {
8183 } else {
8185 *self = ChildLocation::Collection(fidl::new_empty!(
8187 fidl::encoding::BoundedString<255>,
8188 D
8189 ));
8190 }
8191 #[allow(irrefutable_let_patterns)]
8192 if let ChildLocation::Collection(ref mut val) = self {
8193 fidl::decode!(
8194 fidl::encoding::BoundedString<255>,
8195 D,
8196 val,
8197 decoder,
8198 _inner_offset,
8199 depth
8200 )?;
8201 } else {
8202 unreachable!()
8203 }
8204 }
8205 #[allow(deprecated)]
8206 ordinal => {
8207 for _ in 0..num_handles {
8208 decoder.drop_next_handle()?;
8209 }
8210 *self = ChildLocation::__SourceBreaking { unknown_ordinal: ordinal };
8211 }
8212 }
8213 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
8214 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8215 }
8216 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8217 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8218 }
8219 Ok(())
8220 }
8221 }
8222}