1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub type Name = ::std::string::String;
8
9 #[derive(Debug, Clone, PartialEq)]
10 pub struct ChildIteratorNextResponse {
11 pub children: ::std::vec::Vec<::fidl_next_common_fuchsia_component_decl::natural::ChildRef>,
12 }
13
14 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>
15 for ChildIteratorNextResponse
16 where
17 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18 ___E: ::fidl_next::Encoder,
19 {
20 #[inline]
21 fn encode(
22 self,
23 encoder_: &mut ___E,
24 out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildIteratorNextResponse<'static>>,
25 _: (),
26 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
27 ::fidl_next::munge! {
28 let crate::wire::ChildIteratorNextResponse {
29 children,
30
31 } = out_;
32 }
33
34 ::fidl_next::Encode::encode(self.children, encoder_, children, (128, ()))?;
35
36 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(children.as_mut_ptr()) };
37 ::fidl_next::Constrained::validate(_field, (128, ()))?;
38
39 Ok(())
40 }
41 }
42
43 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>
44 for &'a ChildIteratorNextResponse
45 where
46 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
47 ___E: ::fidl_next::Encoder,
48 {
49 #[inline]
50 fn encode(
51 self,
52 encoder_: &mut ___E,
53 out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildIteratorNextResponse<'static>>,
54 _: (),
55 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
56 ::fidl_next::munge! {
57 let crate::wire::ChildIteratorNextResponse {
58 children,
59
60 } = out_;
61 }
62
63 ::fidl_next::Encode::encode(&self.children, encoder_, children, (128, ()))?;
64
65 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(children.as_mut_ptr()) };
66 ::fidl_next::Constrained::validate(_field, (128, ()))?;
67
68 Ok(())
69 }
70 }
71
72 unsafe impl<___E>
73 ::fidl_next::EncodeOption<
74 ::fidl_next::wire::Box<'static, crate::wire::ChildIteratorNextResponse<'static>>,
75 ___E,
76 > for ChildIteratorNextResponse
77 where
78 ___E: ::fidl_next::Encoder + ?Sized,
79 ChildIteratorNextResponse:
80 ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>,
81 {
82 #[inline]
83 fn encode_option(
84 this: ::core::option::Option<Self>,
85 encoder: &mut ___E,
86 out: &mut ::core::mem::MaybeUninit<
87 ::fidl_next::wire::Box<'static, crate::wire::ChildIteratorNextResponse<'static>>,
88 >,
89 _: (),
90 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
91 if let Some(inner) = this {
92 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
93 ::fidl_next::wire::Box::encode_present(out);
94 } else {
95 ::fidl_next::wire::Box::encode_absent(out);
96 }
97
98 Ok(())
99 }
100 }
101
102 unsafe impl<'a, ___E>
103 ::fidl_next::EncodeOption<
104 ::fidl_next::wire::Box<'static, crate::wire::ChildIteratorNextResponse<'static>>,
105 ___E,
106 > for &'a ChildIteratorNextResponse
107 where
108 ___E: ::fidl_next::Encoder + ?Sized,
109 &'a ChildIteratorNextResponse:
110 ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>,
111 {
112 #[inline]
113 fn encode_option(
114 this: ::core::option::Option<Self>,
115 encoder: &mut ___E,
116 out: &mut ::core::mem::MaybeUninit<
117 ::fidl_next::wire::Box<'static, crate::wire::ChildIteratorNextResponse<'static>>,
118 >,
119 _: (),
120 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
121 if let Some(inner) = this {
122 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
123 ::fidl_next::wire::Box::encode_present(out);
124 } else {
125 ::fidl_next::wire::Box::encode_absent(out);
126 }
127
128 Ok(())
129 }
130 }
131
132 impl<'de> ::fidl_next::FromWire<crate::wire::ChildIteratorNextResponse<'de>>
133 for ChildIteratorNextResponse
134 {
135 #[inline]
136 fn from_wire(wire: crate::wire::ChildIteratorNextResponse<'de>) -> Self {
137 Self { children: ::fidl_next::FromWire::from_wire(wire.children) }
138 }
139 }
140
141 impl<'de> ::fidl_next::FromWireRef<crate::wire::ChildIteratorNextResponse<'de>>
142 for ChildIteratorNextResponse
143 {
144 #[inline]
145 fn from_wire_ref(wire: &crate::wire::ChildIteratorNextResponse<'de>) -> Self {
146 Self { children: ::fidl_next::FromWireRef::from_wire_ref(&wire.children) }
147 }
148 }
149
150 pub type ControllerStartResponse = ();
151
152 #[doc = " Standard error codes for component framework protocols.\n"]
153 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
154 #[repr(u32)]
155 pub enum Error {
156 Internal = 1,
157 InvalidArguments = 2,
158 Unsupported = 3,
159 AccessDenied = 4,
160 InstanceNotFound = 5,
161 InstanceAlreadyExists = 6,
162 InstanceCannotStart = 7,
163 InstanceCannotResolve = 8,
164 CollectionNotFound = 9,
165 ResourceUnavailable = 10,
166 InstanceDied = 11,
167 ResourceNotFound = 12,
168 InstanceCannotUnresolve = 13,
169 InstanceAlreadyStarted = 14,
170 DependencyCycle = 15,
171 UnknownOrdinal_(u32) = 16,
172 }
173 impl ::std::convert::From<u32> for Error {
174 fn from(value: u32) -> Self {
175 match value {
176 1 => Self::Internal,
177 2 => Self::InvalidArguments,
178 3 => Self::Unsupported,
179 4 => Self::AccessDenied,
180 5 => Self::InstanceNotFound,
181 6 => Self::InstanceAlreadyExists,
182 7 => Self::InstanceCannotStart,
183 8 => Self::InstanceCannotResolve,
184 9 => Self::CollectionNotFound,
185 10 => Self::ResourceUnavailable,
186 11 => Self::InstanceDied,
187 12 => Self::ResourceNotFound,
188 13 => Self::InstanceCannotUnresolve,
189 14 => Self::InstanceAlreadyStarted,
190 15 => Self::DependencyCycle,
191
192 _ => Self::UnknownOrdinal_(value),
193 }
194 }
195 }
196
197 impl ::std::convert::From<Error> for u32 {
198 fn from(value: Error) -> Self {
199 match value {
200 Error::Internal => 1,
201 Error::InvalidArguments => 2,
202 Error::Unsupported => 3,
203 Error::AccessDenied => 4,
204 Error::InstanceNotFound => 5,
205 Error::InstanceAlreadyExists => 6,
206 Error::InstanceCannotStart => 7,
207 Error::InstanceCannotResolve => 8,
208 Error::CollectionNotFound => 9,
209 Error::ResourceUnavailable => 10,
210 Error::InstanceDied => 11,
211 Error::ResourceNotFound => 12,
212 Error::InstanceCannotUnresolve => 13,
213 Error::InstanceAlreadyStarted => 14,
214 Error::DependencyCycle => 15,
215
216 Error::UnknownOrdinal_(value) => value,
217 }
218 }
219 }
220
221 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Error, ___E> for Error
222 where
223 ___E: ?Sized,
224 {
225 #[inline]
226 fn encode(
227 self,
228 encoder: &mut ___E,
229 out: &mut ::core::mem::MaybeUninit<crate::wire::Error>,
230 _: (),
231 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
232 ::fidl_next::Encode::encode(&self, encoder, out, ())
233 }
234 }
235
236 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Error, ___E> for &'a Error
237 where
238 ___E: ?Sized,
239 {
240 #[inline]
241 fn encode(
242 self,
243 encoder: &mut ___E,
244 out: &mut ::core::mem::MaybeUninit<crate::wire::Error>,
245 _: (),
246 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
247 ::fidl_next::munge!(let crate::wire::Error { value } = out);
248 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
249 Error::Internal => 1,
250
251 Error::InvalidArguments => 2,
252
253 Error::Unsupported => 3,
254
255 Error::AccessDenied => 4,
256
257 Error::InstanceNotFound => 5,
258
259 Error::InstanceAlreadyExists => 6,
260
261 Error::InstanceCannotStart => 7,
262
263 Error::InstanceCannotResolve => 8,
264
265 Error::CollectionNotFound => 9,
266
267 Error::ResourceUnavailable => 10,
268
269 Error::InstanceDied => 11,
270
271 Error::ResourceNotFound => 12,
272
273 Error::InstanceCannotUnresolve => 13,
274
275 Error::InstanceAlreadyStarted => 14,
276
277 Error::DependencyCycle => 15,
278
279 Error::UnknownOrdinal_(value) => value,
280 }));
281
282 Ok(())
283 }
284 }
285
286 impl ::core::convert::From<crate::wire::Error> for Error {
287 fn from(wire: crate::wire::Error) -> Self {
288 match u32::from(wire.value) {
289 1 => Self::Internal,
290
291 2 => Self::InvalidArguments,
292
293 3 => Self::Unsupported,
294
295 4 => Self::AccessDenied,
296
297 5 => Self::InstanceNotFound,
298
299 6 => Self::InstanceAlreadyExists,
300
301 7 => Self::InstanceCannotStart,
302
303 8 => Self::InstanceCannotResolve,
304
305 9 => Self::CollectionNotFound,
306
307 10 => Self::ResourceUnavailable,
308
309 11 => Self::InstanceDied,
310
311 12 => Self::ResourceNotFound,
312
313 13 => Self::InstanceCannotUnresolve,
314
315 14 => Self::InstanceAlreadyStarted,
316
317 15 => Self::DependencyCycle,
318
319 value => Self::UnknownOrdinal_(value),
320 }
321 }
322 }
323
324 impl ::fidl_next::FromWire<crate::wire::Error> for Error {
325 #[inline]
326 fn from_wire(wire: crate::wire::Error) -> Self {
327 Self::from(wire)
328 }
329 }
330
331 impl ::fidl_next::FromWireRef<crate::wire::Error> for Error {
332 #[inline]
333 fn from_wire_ref(wire: &crate::wire::Error) -> Self {
334 Self::from(*wire)
335 }
336 }
337
338 pub type ControllerOpenExposedDirResponse = ();
339
340 pub type ControllerDestroyResponse = ();
341
342 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
343 #[repr(u32)]
344 pub enum DeletionError {
345 Connection = 1,
346 Protocol = 2,
347 NoneAvailable = 3,
348 Unsupported = 4,
349 }
350 impl ::core::convert::TryFrom<u32> for DeletionError {
351 type Error = ::fidl_next::UnknownStrictEnumMemberError;
352 fn try_from(
353 value: u32,
354 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
355 match value {
356 1 => Ok(Self::Connection),
357 2 => Ok(Self::Protocol),
358 3 => Ok(Self::NoneAvailable),
359 4 => Ok(Self::Unsupported),
360
361 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
362 }
363 }
364 }
365
366 impl ::std::convert::From<DeletionError> for u32 {
367 fn from(value: DeletionError) -> Self {
368 match value {
369 DeletionError::Connection => 1,
370 DeletionError::Protocol => 2,
371 DeletionError::NoneAvailable => 3,
372 DeletionError::Unsupported => 4,
373 }
374 }
375 }
376
377 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeletionError, ___E> for DeletionError
378 where
379 ___E: ?Sized,
380 {
381 #[inline]
382 fn encode(
383 self,
384 encoder: &mut ___E,
385 out: &mut ::core::mem::MaybeUninit<crate::wire::DeletionError>,
386 _: (),
387 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
388 ::fidl_next::Encode::encode(&self, encoder, out, ())
389 }
390 }
391
392 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeletionError, ___E> for &'a DeletionError
393 where
394 ___E: ?Sized,
395 {
396 #[inline]
397 fn encode(
398 self,
399 encoder: &mut ___E,
400 out: &mut ::core::mem::MaybeUninit<crate::wire::DeletionError>,
401 _: (),
402 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
403 ::fidl_next::munge!(let crate::wire::DeletionError { value } = out);
404 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
405 DeletionError::Connection => 1,
406
407 DeletionError::Protocol => 2,
408
409 DeletionError::NoneAvailable => 3,
410
411 DeletionError::Unsupported => 4,
412 }));
413
414 Ok(())
415 }
416 }
417
418 impl ::core::convert::From<crate::wire::DeletionError> for DeletionError {
419 fn from(wire: crate::wire::DeletionError) -> Self {
420 match u32::from(wire.value) {
421 1 => Self::Connection,
422
423 2 => Self::Protocol,
424
425 3 => Self::NoneAvailable,
426
427 4 => Self::Unsupported,
428
429 _ => unsafe { ::core::hint::unreachable_unchecked() },
430 }
431 }
432 }
433
434 impl ::fidl_next::FromWire<crate::wire::DeletionError> for DeletionError {
435 #[inline]
436 fn from_wire(wire: crate::wire::DeletionError) -> Self {
437 Self::from(wire)
438 }
439 }
440
441 impl ::fidl_next::FromWireRef<crate::wire::DeletionError> for DeletionError {
442 #[inline]
443 fn from_wire_ref(wire: &crate::wire::DeletionError) -> Self {
444 Self::from(*wire)
445 }
446 }
447
448 #[doc = " Payload for Destroyed events.\n"]
449 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
450 pub struct DestroyedPayload {}
451
452 impl DestroyedPayload {
453 fn __max_ordinal(&self) -> usize {
454 0
455 }
456 }
457
458 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DestroyedPayload<'static>, ___E>
459 for DestroyedPayload
460 where
461 ___E: ::fidl_next::Encoder + ?Sized,
462 {
463 #[inline]
464 fn encode(
465 mut self,
466 encoder: &mut ___E,
467 out: &mut ::core::mem::MaybeUninit<crate::wire::DestroyedPayload<'static>>,
468 _: (),
469 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
470 ::fidl_next::munge!(let crate::wire::DestroyedPayload { table } = out);
471
472 let max_ord = self.__max_ordinal();
473
474 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
475 ::fidl_next::Wire::zero_padding(&mut out);
476
477 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
478 ::fidl_next::wire::Envelope,
479 >(encoder, max_ord);
480
481 for i in 1..=max_ord {
482 match i {
483 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
484 }
485 unsafe {
486 preallocated.write_next(out.assume_init_ref());
487 }
488 }
489
490 ::fidl_next::wire::Table::encode_len(table, max_ord);
491
492 Ok(())
493 }
494 }
495
496 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DestroyedPayload<'static>, ___E>
497 for &'a DestroyedPayload
498 where
499 ___E: ::fidl_next::Encoder + ?Sized,
500 {
501 #[inline]
502 fn encode(
503 self,
504 encoder: &mut ___E,
505 out: &mut ::core::mem::MaybeUninit<crate::wire::DestroyedPayload<'static>>,
506 _: (),
507 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
508 ::fidl_next::munge!(let crate::wire::DestroyedPayload { table } = out);
509
510 let max_ord = self.__max_ordinal();
511
512 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
513 ::fidl_next::Wire::zero_padding(&mut out);
514
515 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
516 ::fidl_next::wire::Envelope,
517 >(encoder, max_ord);
518
519 for i in 1..=max_ord {
520 match i {
521 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
522 }
523 unsafe {
524 preallocated.write_next(out.assume_init_ref());
525 }
526 }
527
528 ::fidl_next::wire::Table::encode_len(table, max_ord);
529
530 Ok(())
531 }
532 }
533
534 impl<'de> ::fidl_next::FromWire<crate::wire::DestroyedPayload<'de>> for DestroyedPayload {
535 #[inline]
536 fn from_wire(wire_: crate::wire::DestroyedPayload<'de>) -> Self {
537 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
538
539 Self {}
540 }
541 }
542
543 impl<'de> ::fidl_next::FromWireRef<crate::wire::DestroyedPayload<'de>> for DestroyedPayload {
544 #[inline]
545 fn from_wire_ref(wire: &crate::wire::DestroyedPayload<'de>) -> Self {
546 Self {}
547 }
548 }
549
550 #[doc = " Payload for Discovered events.\n"]
551 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
552 pub struct DiscoveredPayload {}
553
554 impl DiscoveredPayload {
555 fn __max_ordinal(&self) -> usize {
556 0
557 }
558 }
559
560 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DiscoveredPayload<'static>, ___E>
561 for DiscoveredPayload
562 where
563 ___E: ::fidl_next::Encoder + ?Sized,
564 {
565 #[inline]
566 fn encode(
567 mut self,
568 encoder: &mut ___E,
569 out: &mut ::core::mem::MaybeUninit<crate::wire::DiscoveredPayload<'static>>,
570 _: (),
571 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
572 ::fidl_next::munge!(let crate::wire::DiscoveredPayload { table } = out);
573
574 let max_ord = self.__max_ordinal();
575
576 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
577 ::fidl_next::Wire::zero_padding(&mut out);
578
579 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
580 ::fidl_next::wire::Envelope,
581 >(encoder, max_ord);
582
583 for i in 1..=max_ord {
584 match i {
585 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
586 }
587 unsafe {
588 preallocated.write_next(out.assume_init_ref());
589 }
590 }
591
592 ::fidl_next::wire::Table::encode_len(table, max_ord);
593
594 Ok(())
595 }
596 }
597
598 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DiscoveredPayload<'static>, ___E>
599 for &'a DiscoveredPayload
600 where
601 ___E: ::fidl_next::Encoder + ?Sized,
602 {
603 #[inline]
604 fn encode(
605 self,
606 encoder: &mut ___E,
607 out: &mut ::core::mem::MaybeUninit<crate::wire::DiscoveredPayload<'static>>,
608 _: (),
609 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
610 ::fidl_next::munge!(let crate::wire::DiscoveredPayload { table } = out);
611
612 let max_ord = self.__max_ordinal();
613
614 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
615 ::fidl_next::Wire::zero_padding(&mut out);
616
617 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
618 ::fidl_next::wire::Envelope,
619 >(encoder, max_ord);
620
621 for i in 1..=max_ord {
622 match i {
623 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
624 }
625 unsafe {
626 preallocated.write_next(out.assume_init_ref());
627 }
628 }
629
630 ::fidl_next::wire::Table::encode_len(table, max_ord);
631
632 Ok(())
633 }
634 }
635
636 impl<'de> ::fidl_next::FromWire<crate::wire::DiscoveredPayload<'de>> for DiscoveredPayload {
637 #[inline]
638 fn from_wire(wire_: crate::wire::DiscoveredPayload<'de>) -> Self {
639 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
640
641 Self {}
642 }
643 }
644
645 impl<'de> ::fidl_next::FromWireRef<crate::wire::DiscoveredPayload<'de>> for DiscoveredPayload {
646 #[inline]
647 fn from_wire_ref(wire: &crate::wire::DiscoveredPayload<'de>) -> Self {
648 Self {}
649 }
650 }
651
652 #[doc = " Payload for Purged events.\n"]
653 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
654 pub struct PurgedPayload {}
655
656 impl PurgedPayload {
657 fn __max_ordinal(&self) -> usize {
658 0
659 }
660 }
661
662 unsafe impl<___E> ::fidl_next::Encode<crate::wire::PurgedPayload<'static>, ___E> for PurgedPayload
663 where
664 ___E: ::fidl_next::Encoder + ?Sized,
665 {
666 #[inline]
667 fn encode(
668 mut self,
669 encoder: &mut ___E,
670 out: &mut ::core::mem::MaybeUninit<crate::wire::PurgedPayload<'static>>,
671 _: (),
672 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
673 ::fidl_next::munge!(let crate::wire::PurgedPayload { table } = out);
674
675 let max_ord = self.__max_ordinal();
676
677 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
678 ::fidl_next::Wire::zero_padding(&mut out);
679
680 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
681 ::fidl_next::wire::Envelope,
682 >(encoder, max_ord);
683
684 for i in 1..=max_ord {
685 match i {
686 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
687 }
688 unsafe {
689 preallocated.write_next(out.assume_init_ref());
690 }
691 }
692
693 ::fidl_next::wire::Table::encode_len(table, max_ord);
694
695 Ok(())
696 }
697 }
698
699 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::PurgedPayload<'static>, ___E>
700 for &'a PurgedPayload
701 where
702 ___E: ::fidl_next::Encoder + ?Sized,
703 {
704 #[inline]
705 fn encode(
706 self,
707 encoder: &mut ___E,
708 out: &mut ::core::mem::MaybeUninit<crate::wire::PurgedPayload<'static>>,
709 _: (),
710 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
711 ::fidl_next::munge!(let crate::wire::PurgedPayload { table } = out);
712
713 let max_ord = self.__max_ordinal();
714
715 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
716 ::fidl_next::Wire::zero_padding(&mut out);
717
718 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
719 ::fidl_next::wire::Envelope,
720 >(encoder, max_ord);
721
722 for i in 1..=max_ord {
723 match i {
724 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
725 }
726 unsafe {
727 preallocated.write_next(out.assume_init_ref());
728 }
729 }
730
731 ::fidl_next::wire::Table::encode_len(table, max_ord);
732
733 Ok(())
734 }
735 }
736
737 impl<'de> ::fidl_next::FromWire<crate::wire::PurgedPayload<'de>> for PurgedPayload {
738 #[inline]
739 fn from_wire(wire_: crate::wire::PurgedPayload<'de>) -> Self {
740 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
741
742 Self {}
743 }
744 }
745
746 impl<'de> ::fidl_next::FromWireRef<crate::wire::PurgedPayload<'de>> for PurgedPayload {
747 #[inline]
748 fn from_wire_ref(wire: &crate::wire::PurgedPayload<'de>) -> Self {
749 Self {}
750 }
751 }
752
753 #[doc = " Payload for Resolved events.\n"]
754 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
755 pub struct ResolvedPayload {}
756
757 impl ResolvedPayload {
758 fn __max_ordinal(&self) -> usize {
759 0
760 }
761 }
762
763 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ResolvedPayload<'static>, ___E>
764 for ResolvedPayload
765 where
766 ___E: ::fidl_next::Encoder + ?Sized,
767 {
768 #[inline]
769 fn encode(
770 mut self,
771 encoder: &mut ___E,
772 out: &mut ::core::mem::MaybeUninit<crate::wire::ResolvedPayload<'static>>,
773 _: (),
774 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
775 ::fidl_next::munge!(let crate::wire::ResolvedPayload { table } = out);
776
777 let max_ord = self.__max_ordinal();
778
779 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
780 ::fidl_next::Wire::zero_padding(&mut out);
781
782 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
783 ::fidl_next::wire::Envelope,
784 >(encoder, max_ord);
785
786 for i in 1..=max_ord {
787 match i {
788 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
789 }
790 unsafe {
791 preallocated.write_next(out.assume_init_ref());
792 }
793 }
794
795 ::fidl_next::wire::Table::encode_len(table, max_ord);
796
797 Ok(())
798 }
799 }
800
801 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ResolvedPayload<'static>, ___E>
802 for &'a ResolvedPayload
803 where
804 ___E: ::fidl_next::Encoder + ?Sized,
805 {
806 #[inline]
807 fn encode(
808 self,
809 encoder: &mut ___E,
810 out: &mut ::core::mem::MaybeUninit<crate::wire::ResolvedPayload<'static>>,
811 _: (),
812 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
813 ::fidl_next::munge!(let crate::wire::ResolvedPayload { table } = out);
814
815 let max_ord = self.__max_ordinal();
816
817 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
818 ::fidl_next::Wire::zero_padding(&mut out);
819
820 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
821 ::fidl_next::wire::Envelope,
822 >(encoder, max_ord);
823
824 for i in 1..=max_ord {
825 match i {
826 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
827 }
828 unsafe {
829 preallocated.write_next(out.assume_init_ref());
830 }
831 }
832
833 ::fidl_next::wire::Table::encode_len(table, max_ord);
834
835 Ok(())
836 }
837 }
838
839 impl<'de> ::fidl_next::FromWire<crate::wire::ResolvedPayload<'de>> for ResolvedPayload {
840 #[inline]
841 fn from_wire(wire_: crate::wire::ResolvedPayload<'de>) -> Self {
842 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
843
844 Self {}
845 }
846 }
847
848 impl<'de> ::fidl_next::FromWireRef<crate::wire::ResolvedPayload<'de>> for ResolvedPayload {
849 #[inline]
850 fn from_wire_ref(wire: &crate::wire::ResolvedPayload<'de>) -> Self {
851 Self {}
852 }
853 }
854
855 #[doc = " Payload for Started events.\n"]
856 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
857 pub struct StartedPayload {}
858
859 impl StartedPayload {
860 fn __max_ordinal(&self) -> usize {
861 0
862 }
863 }
864
865 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StartedPayload<'static>, ___E> for StartedPayload
866 where
867 ___E: ::fidl_next::Encoder + ?Sized,
868 {
869 #[inline]
870 fn encode(
871 mut self,
872 encoder: &mut ___E,
873 out: &mut ::core::mem::MaybeUninit<crate::wire::StartedPayload<'static>>,
874 _: (),
875 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
876 ::fidl_next::munge!(let crate::wire::StartedPayload { table } = out);
877
878 let max_ord = self.__max_ordinal();
879
880 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
881 ::fidl_next::Wire::zero_padding(&mut out);
882
883 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
884 ::fidl_next::wire::Envelope,
885 >(encoder, max_ord);
886
887 for i in 1..=max_ord {
888 match i {
889 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
890 }
891 unsafe {
892 preallocated.write_next(out.assume_init_ref());
893 }
894 }
895
896 ::fidl_next::wire::Table::encode_len(table, max_ord);
897
898 Ok(())
899 }
900 }
901
902 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StartedPayload<'static>, ___E>
903 for &'a StartedPayload
904 where
905 ___E: ::fidl_next::Encoder + ?Sized,
906 {
907 #[inline]
908 fn encode(
909 self,
910 encoder: &mut ___E,
911 out: &mut ::core::mem::MaybeUninit<crate::wire::StartedPayload<'static>>,
912 _: (),
913 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
914 ::fidl_next::munge!(let crate::wire::StartedPayload { table } = out);
915
916 let max_ord = self.__max_ordinal();
917
918 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
919 ::fidl_next::Wire::zero_padding(&mut out);
920
921 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
922 ::fidl_next::wire::Envelope,
923 >(encoder, max_ord);
924
925 for i in 1..=max_ord {
926 match i {
927 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
928 }
929 unsafe {
930 preallocated.write_next(out.assume_init_ref());
931 }
932 }
933
934 ::fidl_next::wire::Table::encode_len(table, max_ord);
935
936 Ok(())
937 }
938 }
939
940 impl<'de> ::fidl_next::FromWire<crate::wire::StartedPayload<'de>> for StartedPayload {
941 #[inline]
942 fn from_wire(wire_: crate::wire::StartedPayload<'de>) -> Self {
943 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
944
945 Self {}
946 }
947 }
948
949 impl<'de> ::fidl_next::FromWireRef<crate::wire::StartedPayload<'de>> for StartedPayload {
950 #[inline]
951 fn from_wire_ref(wire: &crate::wire::StartedPayload<'de>) -> Self {
952 Self {}
953 }
954 }
955
956 #[doc = " Payload for Unresolved events.\n"]
957 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
958 pub struct UnresolvedPayload {}
959
960 impl UnresolvedPayload {
961 fn __max_ordinal(&self) -> usize {
962 0
963 }
964 }
965
966 unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnresolvedPayload<'static>, ___E>
967 for UnresolvedPayload
968 where
969 ___E: ::fidl_next::Encoder + ?Sized,
970 {
971 #[inline]
972 fn encode(
973 mut self,
974 encoder: &mut ___E,
975 out: &mut ::core::mem::MaybeUninit<crate::wire::UnresolvedPayload<'static>>,
976 _: (),
977 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
978 ::fidl_next::munge!(let crate::wire::UnresolvedPayload { table } = out);
979
980 let max_ord = self.__max_ordinal();
981
982 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
983 ::fidl_next::Wire::zero_padding(&mut out);
984
985 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
986 ::fidl_next::wire::Envelope,
987 >(encoder, max_ord);
988
989 for i in 1..=max_ord {
990 match i {
991 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
992 }
993 unsafe {
994 preallocated.write_next(out.assume_init_ref());
995 }
996 }
997
998 ::fidl_next::wire::Table::encode_len(table, max_ord);
999
1000 Ok(())
1001 }
1002 }
1003
1004 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UnresolvedPayload<'static>, ___E>
1005 for &'a UnresolvedPayload
1006 where
1007 ___E: ::fidl_next::Encoder + ?Sized,
1008 {
1009 #[inline]
1010 fn encode(
1011 self,
1012 encoder: &mut ___E,
1013 out: &mut ::core::mem::MaybeUninit<crate::wire::UnresolvedPayload<'static>>,
1014 _: (),
1015 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1016 ::fidl_next::munge!(let crate::wire::UnresolvedPayload { table } = out);
1017
1018 let max_ord = self.__max_ordinal();
1019
1020 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1021 ::fidl_next::Wire::zero_padding(&mut out);
1022
1023 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1024 ::fidl_next::wire::Envelope,
1025 >(encoder, max_ord);
1026
1027 for i in 1..=max_ord {
1028 match i {
1029 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1030 }
1031 unsafe {
1032 preallocated.write_next(out.assume_init_ref());
1033 }
1034 }
1035
1036 ::fidl_next::wire::Table::encode_len(table, max_ord);
1037
1038 Ok(())
1039 }
1040 }
1041
1042 impl<'de> ::fidl_next::FromWire<crate::wire::UnresolvedPayload<'de>> for UnresolvedPayload {
1043 #[inline]
1044 fn from_wire(wire_: crate::wire::UnresolvedPayload<'de>) -> Self {
1045 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1046
1047 Self {}
1048 }
1049 }
1050
1051 impl<'de> ::fidl_next::FromWireRef<crate::wire::UnresolvedPayload<'de>> for UnresolvedPayload {
1052 #[inline]
1053 fn from_wire_ref(wire: &crate::wire::UnresolvedPayload<'de>) -> Self {
1054 Self {}
1055 }
1056 }
1057
1058 #[doc = " These EventTypes are used for the EventStream protocol.\n They are FIDL versions of the EventType enum in hooks.rs and have\n the same meaning.\n"]
1059 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1060 #[repr(u32)]
1061 pub enum EventType {
1062 CapabilityRequested = 1,
1063 Discovered = 3,
1064 Destroyed = 4,
1065 Resolved = 5,
1066 Started = 6,
1067 Stopped = 7,
1068 DebugStarted = 8,
1069 Unresolved = 9,
1070 }
1071 impl ::core::convert::TryFrom<u32> for EventType {
1072 type Error = ::fidl_next::UnknownStrictEnumMemberError;
1073 fn try_from(
1074 value: u32,
1075 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
1076 match value {
1077 1 => Ok(Self::CapabilityRequested),
1078 3 => Ok(Self::Discovered),
1079 4 => Ok(Self::Destroyed),
1080 5 => Ok(Self::Resolved),
1081 6 => Ok(Self::Started),
1082 7 => Ok(Self::Stopped),
1083 8 => Ok(Self::DebugStarted),
1084 9 => Ok(Self::Unresolved),
1085
1086 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
1087 }
1088 }
1089 }
1090
1091 impl ::std::convert::From<EventType> for u32 {
1092 fn from(value: EventType) -> Self {
1093 match value {
1094 EventType::CapabilityRequested => 1,
1095 EventType::Discovered => 3,
1096 EventType::Destroyed => 4,
1097 EventType::Resolved => 5,
1098 EventType::Started => 6,
1099 EventType::Stopped => 7,
1100 EventType::DebugStarted => 8,
1101 EventType::Unresolved => 9,
1102 }
1103 }
1104 }
1105
1106 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventType, ___E> for EventType
1107 where
1108 ___E: ?Sized,
1109 {
1110 #[inline]
1111 fn encode(
1112 self,
1113 encoder: &mut ___E,
1114 out: &mut ::core::mem::MaybeUninit<crate::wire::EventType>,
1115 _: (),
1116 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1117 ::fidl_next::Encode::encode(&self, encoder, out, ())
1118 }
1119 }
1120
1121 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::EventType, ___E> for &'a EventType
1122 where
1123 ___E: ?Sized,
1124 {
1125 #[inline]
1126 fn encode(
1127 self,
1128 encoder: &mut ___E,
1129 out: &mut ::core::mem::MaybeUninit<crate::wire::EventType>,
1130 _: (),
1131 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1132 ::fidl_next::munge!(let crate::wire::EventType { value } = out);
1133 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
1134 EventType::CapabilityRequested => 1,
1135
1136 EventType::Discovered => 3,
1137
1138 EventType::Destroyed => 4,
1139
1140 EventType::Resolved => 5,
1141
1142 EventType::Started => 6,
1143
1144 EventType::Stopped => 7,
1145
1146 EventType::DebugStarted => 8,
1147
1148 EventType::Unresolved => 9,
1149 }));
1150
1151 Ok(())
1152 }
1153 }
1154
1155 impl ::core::convert::From<crate::wire::EventType> for EventType {
1156 fn from(wire: crate::wire::EventType) -> Self {
1157 match u32::from(wire.value) {
1158 1 => Self::CapabilityRequested,
1159
1160 3 => Self::Discovered,
1161
1162 4 => Self::Destroyed,
1163
1164 5 => Self::Resolved,
1165
1166 6 => Self::Started,
1167
1168 7 => Self::Stopped,
1169
1170 8 => Self::DebugStarted,
1171
1172 9 => Self::Unresolved,
1173
1174 _ => unsafe { ::core::hint::unreachable_unchecked() },
1175 }
1176 }
1177 }
1178
1179 impl ::fidl_next::FromWire<crate::wire::EventType> for EventType {
1180 #[inline]
1181 fn from_wire(wire: crate::wire::EventType) -> Self {
1182 Self::from(wire)
1183 }
1184 }
1185
1186 impl ::fidl_next::FromWireRef<crate::wire::EventType> for EventType {
1187 #[inline]
1188 fn from_wire_ref(wire: &crate::wire::EventType) -> Self {
1189 Self::from(*wire)
1190 }
1191 }
1192
1193 #[doc = " Payload for Stopped events.\n"]
1194 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1195 pub struct StoppedPayload {
1196 pub status:
1197 ::core::option::Option<::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>>,
1198
1199 pub exit_code: ::core::option::Option<i64>,
1200 }
1201
1202 impl StoppedPayload {
1203 fn __max_ordinal(&self) -> usize {
1204 if self.exit_code.is_some() {
1205 return 2;
1206 }
1207
1208 if self.status.is_some() {
1209 return 1;
1210 }
1211
1212 0
1213 }
1214 }
1215
1216 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E> for StoppedPayload
1217 where
1218 ___E: ::fidl_next::Encoder + ?Sized,
1219 {
1220 #[inline]
1221 fn encode(
1222 mut self,
1223 encoder: &mut ___E,
1224 out: &mut ::core::mem::MaybeUninit<crate::wire::StoppedPayload<'static>>,
1225 _: (),
1226 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1227 ::fidl_next::munge!(let crate::wire::StoppedPayload { table } = out);
1228
1229 let max_ord = self.__max_ordinal();
1230
1231 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1232 ::fidl_next::Wire::zero_padding(&mut out);
1233
1234 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1235 ::fidl_next::wire::Envelope,
1236 >(encoder, max_ord);
1237
1238 for i in 1..=max_ord {
1239 match i {
1240 2 => {
1241 if let Some(value) = self.exit_code.take() {
1242 ::fidl_next::wire::Envelope::encode_value::<
1243 ::fidl_next::wire::Int64,
1244 ___E,
1245 >(
1246 value, preallocated.encoder, &mut out, ()
1247 )?;
1248 } else {
1249 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1250 }
1251 }
1252
1253 1 => {
1254 if let Some(value) = self.status.take() {
1255 ::fidl_next::wire::Envelope::encode_value::<
1256 ::fidl_next::wire::fuchsia::StatusResult,
1257 ___E,
1258 >(
1259 value, preallocated.encoder, &mut out, ()
1260 )?;
1261 } else {
1262 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1263 }
1264 }
1265
1266 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1267 }
1268 unsafe {
1269 preallocated.write_next(out.assume_init_ref());
1270 }
1271 }
1272
1273 ::fidl_next::wire::Table::encode_len(table, max_ord);
1274
1275 Ok(())
1276 }
1277 }
1278
1279 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E>
1280 for &'a StoppedPayload
1281 where
1282 ___E: ::fidl_next::Encoder + ?Sized,
1283 {
1284 #[inline]
1285 fn encode(
1286 self,
1287 encoder: &mut ___E,
1288 out: &mut ::core::mem::MaybeUninit<crate::wire::StoppedPayload<'static>>,
1289 _: (),
1290 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1291 ::fidl_next::munge!(let crate::wire::StoppedPayload { table } = out);
1292
1293 let max_ord = self.__max_ordinal();
1294
1295 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1296 ::fidl_next::Wire::zero_padding(&mut out);
1297
1298 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1299 ::fidl_next::wire::Envelope,
1300 >(encoder, max_ord);
1301
1302 for i in 1..=max_ord {
1303 match i {
1304 2 => {
1305 if let Some(value) = &self.exit_code {
1306 ::fidl_next::wire::Envelope::encode_value::<
1307 ::fidl_next::wire::Int64,
1308 ___E,
1309 >(
1310 value, preallocated.encoder, &mut out, ()
1311 )?;
1312 } else {
1313 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1314 }
1315 }
1316
1317 1 => {
1318 if let Some(value) = &self.status {
1319 ::fidl_next::wire::Envelope::encode_value::<
1320 ::fidl_next::wire::fuchsia::StatusResult,
1321 ___E,
1322 >(
1323 value, preallocated.encoder, &mut out, ()
1324 )?;
1325 } else {
1326 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1327 }
1328 }
1329
1330 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1331 }
1332 unsafe {
1333 preallocated.write_next(out.assume_init_ref());
1334 }
1335 }
1336
1337 ::fidl_next::wire::Table::encode_len(table, max_ord);
1338
1339 Ok(())
1340 }
1341 }
1342
1343 impl<'de> ::fidl_next::FromWire<crate::wire::StoppedPayload<'de>> for StoppedPayload {
1344 #[inline]
1345 fn from_wire(wire_: crate::wire::StoppedPayload<'de>) -> Self {
1346 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1347
1348 let status = wire_.table.get(1);
1349
1350 let exit_code = wire_.table.get(2);
1351
1352 Self {
1353 status: status.map(|envelope| {
1354 ::fidl_next::FromWire::from_wire(unsafe {
1355 envelope.read_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
1356 })
1357 }),
1358
1359 exit_code: exit_code.map(|envelope| {
1360 ::fidl_next::FromWire::from_wire(unsafe {
1361 envelope.read_unchecked::<::fidl_next::wire::Int64>()
1362 })
1363 }),
1364 }
1365 }
1366 }
1367
1368 impl<'de> ::fidl_next::FromWireRef<crate::wire::StoppedPayload<'de>> for StoppedPayload {
1369 #[inline]
1370 fn from_wire_ref(wire: &crate::wire::StoppedPayload<'de>) -> Self {
1371 Self {
1372 status: wire.table.get(1).map(|envelope| {
1373 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1374 envelope.deref_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
1375 })
1376 }),
1377
1378 exit_code: wire.table.get(2).map(|envelope| {
1379 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1380 envelope.deref_unchecked::<::fidl_next::wire::Int64>()
1381 })
1382 }),
1383 }
1384 }
1385 }
1386
1387 #[doc = " A head providing metadata about a target component instance.\n"]
1388 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1389 pub struct EventHeader {
1390 pub event_type: ::core::option::Option<crate::natural::EventType>,
1391
1392 pub moniker: ::core::option::Option<::std::string::String>,
1393
1394 pub component_url: ::core::option::Option<::std::string::String>,
1395
1396 pub timestamp: ::core::option::Option<i64>,
1397 }
1398
1399 impl EventHeader {
1400 fn __max_ordinal(&self) -> usize {
1401 if self.timestamp.is_some() {
1402 return 4;
1403 }
1404
1405 if self.component_url.is_some() {
1406 return 3;
1407 }
1408
1409 if self.moniker.is_some() {
1410 return 2;
1411 }
1412
1413 if self.event_type.is_some() {
1414 return 1;
1415 }
1416
1417 0
1418 }
1419 }
1420
1421 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventHeader<'static>, ___E> for EventHeader
1422 where
1423 ___E: ::fidl_next::Encoder + ?Sized,
1424 {
1425 #[inline]
1426 fn encode(
1427 mut self,
1428 encoder: &mut ___E,
1429 out: &mut ::core::mem::MaybeUninit<crate::wire::EventHeader<'static>>,
1430 _: (),
1431 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1432 ::fidl_next::munge!(let crate::wire::EventHeader { table } = out);
1433
1434 let max_ord = self.__max_ordinal();
1435
1436 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1437 ::fidl_next::Wire::zero_padding(&mut out);
1438
1439 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1440 ::fidl_next::wire::Envelope,
1441 >(encoder, max_ord);
1442
1443 for i in 1..=max_ord {
1444 match i {
1445 4 => {
1446 if let Some(value) = self.timestamp.take() {
1447 ::fidl_next::wire::Envelope::encode_value::<
1448 ::fidl_next::wire::Int64,
1449 ___E,
1450 >(
1451 value, preallocated.encoder, &mut out, ()
1452 )?;
1453 } else {
1454 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1455 }
1456 }
1457
1458 3 => {
1459 if let Some(value) = self.component_url.take() {
1460 ::fidl_next::wire::Envelope::encode_value::<
1461 ::fidl_next::wire::String<'static>,
1462 ___E,
1463 >(
1464 value, preallocated.encoder, &mut out, 4096
1465 )?;
1466 } else {
1467 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1468 }
1469 }
1470
1471 2 => {
1472 if let Some(value) = self.moniker.take() {
1473 ::fidl_next::wire::Envelope::encode_value::<
1474 ::fidl_next::wire::String<'static>,
1475 ___E,
1476 >(
1477 value, preallocated.encoder, &mut out, 4096
1478 )?;
1479 } else {
1480 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1481 }
1482 }
1483
1484 1 => {
1485 if let Some(value) = self.event_type.take() {
1486 ::fidl_next::wire::Envelope::encode_value::<
1487 crate::wire::EventType,
1488 ___E,
1489 >(
1490 value, preallocated.encoder, &mut out, ()
1491 )?;
1492 } else {
1493 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1494 }
1495 }
1496
1497 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1498 }
1499 unsafe {
1500 preallocated.write_next(out.assume_init_ref());
1501 }
1502 }
1503
1504 ::fidl_next::wire::Table::encode_len(table, max_ord);
1505
1506 Ok(())
1507 }
1508 }
1509
1510 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::EventHeader<'static>, ___E>
1511 for &'a EventHeader
1512 where
1513 ___E: ::fidl_next::Encoder + ?Sized,
1514 {
1515 #[inline]
1516 fn encode(
1517 self,
1518 encoder: &mut ___E,
1519 out: &mut ::core::mem::MaybeUninit<crate::wire::EventHeader<'static>>,
1520 _: (),
1521 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1522 ::fidl_next::munge!(let crate::wire::EventHeader { table } = out);
1523
1524 let max_ord = self.__max_ordinal();
1525
1526 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1527 ::fidl_next::Wire::zero_padding(&mut out);
1528
1529 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1530 ::fidl_next::wire::Envelope,
1531 >(encoder, max_ord);
1532
1533 for i in 1..=max_ord {
1534 match i {
1535 4 => {
1536 if let Some(value) = &self.timestamp {
1537 ::fidl_next::wire::Envelope::encode_value::<
1538 ::fidl_next::wire::Int64,
1539 ___E,
1540 >(
1541 value, preallocated.encoder, &mut out, ()
1542 )?;
1543 } else {
1544 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1545 }
1546 }
1547
1548 3 => {
1549 if let Some(value) = &self.component_url {
1550 ::fidl_next::wire::Envelope::encode_value::<
1551 ::fidl_next::wire::String<'static>,
1552 ___E,
1553 >(
1554 value, preallocated.encoder, &mut out, 4096
1555 )?;
1556 } else {
1557 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1558 }
1559 }
1560
1561 2 => {
1562 if let Some(value) = &self.moniker {
1563 ::fidl_next::wire::Envelope::encode_value::<
1564 ::fidl_next::wire::String<'static>,
1565 ___E,
1566 >(
1567 value, preallocated.encoder, &mut out, 4096
1568 )?;
1569 } else {
1570 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1571 }
1572 }
1573
1574 1 => {
1575 if let Some(value) = &self.event_type {
1576 ::fidl_next::wire::Envelope::encode_value::<
1577 crate::wire::EventType,
1578 ___E,
1579 >(
1580 value, preallocated.encoder, &mut out, ()
1581 )?;
1582 } else {
1583 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1584 }
1585 }
1586
1587 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1588 }
1589 unsafe {
1590 preallocated.write_next(out.assume_init_ref());
1591 }
1592 }
1593
1594 ::fidl_next::wire::Table::encode_len(table, max_ord);
1595
1596 Ok(())
1597 }
1598 }
1599
1600 impl<'de> ::fidl_next::FromWire<crate::wire::EventHeader<'de>> for EventHeader {
1601 #[inline]
1602 fn from_wire(wire_: crate::wire::EventHeader<'de>) -> Self {
1603 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1604
1605 let event_type = wire_.table.get(1);
1606
1607 let moniker = wire_.table.get(2);
1608
1609 let component_url = wire_.table.get(3);
1610
1611 let timestamp = wire_.table.get(4);
1612
1613 Self {
1614 event_type: event_type.map(|envelope| {
1615 ::fidl_next::FromWire::from_wire(unsafe {
1616 envelope.read_unchecked::<crate::wire::EventType>()
1617 })
1618 }),
1619
1620 moniker: moniker.map(|envelope| {
1621 ::fidl_next::FromWire::from_wire(unsafe {
1622 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
1623 })
1624 }),
1625
1626 component_url: component_url.map(|envelope| {
1627 ::fidl_next::FromWire::from_wire(unsafe {
1628 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
1629 })
1630 }),
1631
1632 timestamp: timestamp.map(|envelope| {
1633 ::fidl_next::FromWire::from_wire(unsafe {
1634 envelope.read_unchecked::<::fidl_next::wire::Int64>()
1635 })
1636 }),
1637 }
1638 }
1639 }
1640
1641 impl<'de> ::fidl_next::FromWireRef<crate::wire::EventHeader<'de>> for EventHeader {
1642 #[inline]
1643 fn from_wire_ref(wire: &crate::wire::EventHeader<'de>) -> Self {
1644 Self {
1645 event_type: wire.table.get(1).map(|envelope| {
1646 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1647 envelope.deref_unchecked::<crate::wire::EventType>()
1648 })
1649 }),
1650
1651 moniker: wire.table.get(2).map(|envelope| {
1652 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1653 envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
1654 })
1655 }),
1656
1657 component_url: wire.table.get(3).map(|envelope| {
1658 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1659 envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
1660 })
1661 }),
1662
1663 timestamp: wire.table.get(4).map(|envelope| {
1664 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1665 envelope.deref_unchecked::<::fidl_next::wire::Int64>()
1666 })
1667 }),
1668 }
1669 }
1670 }
1671
1672 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1673 pub struct ExecutionControllerOnStopRequest {
1674 pub stopped_payload: crate::natural::StoppedPayload,
1675 }
1676
1677 unsafe impl<___E>
1678 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
1679 for ExecutionControllerOnStopRequest
1680 where
1681 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1682 ___E: ::fidl_next::Encoder,
1683 {
1684 #[inline]
1685 fn encode(
1686 self,
1687 encoder_: &mut ___E,
1688 out_: &mut ::core::mem::MaybeUninit<
1689 crate::wire::ExecutionControllerOnStopRequest<'static>,
1690 >,
1691 _: (),
1692 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1693 ::fidl_next::munge! {
1694 let crate::wire::ExecutionControllerOnStopRequest {
1695 stopped_payload,
1696
1697 } = out_;
1698 }
1699
1700 ::fidl_next::Encode::encode(self.stopped_payload, encoder_, stopped_payload, ())?;
1701
1702 let mut _field =
1703 unsafe { ::fidl_next::Slot::new_unchecked(stopped_payload.as_mut_ptr()) };
1704
1705 Ok(())
1706 }
1707 }
1708
1709 unsafe impl<'a, ___E>
1710 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
1711 for &'a ExecutionControllerOnStopRequest
1712 where
1713 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1714 ___E: ::fidl_next::Encoder,
1715 {
1716 #[inline]
1717 fn encode(
1718 self,
1719 encoder_: &mut ___E,
1720 out_: &mut ::core::mem::MaybeUninit<
1721 crate::wire::ExecutionControllerOnStopRequest<'static>,
1722 >,
1723 _: (),
1724 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1725 ::fidl_next::munge! {
1726 let crate::wire::ExecutionControllerOnStopRequest {
1727 stopped_payload,
1728
1729 } = out_;
1730 }
1731
1732 ::fidl_next::Encode::encode(&self.stopped_payload, encoder_, stopped_payload, ())?;
1733
1734 let mut _field =
1735 unsafe { ::fidl_next::Slot::new_unchecked(stopped_payload.as_mut_ptr()) };
1736
1737 Ok(())
1738 }
1739 }
1740
1741 unsafe impl<___E>
1742 ::fidl_next::EncodeOption<
1743 ::fidl_next::wire::Box<'static, crate::wire::ExecutionControllerOnStopRequest<'static>>,
1744 ___E,
1745 > for ExecutionControllerOnStopRequest
1746 where
1747 ___E: ::fidl_next::Encoder + ?Sized,
1748 ExecutionControllerOnStopRequest:
1749 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>,
1750 {
1751 #[inline]
1752 fn encode_option(
1753 this: ::core::option::Option<Self>,
1754 encoder: &mut ___E,
1755 out: &mut ::core::mem::MaybeUninit<
1756 ::fidl_next::wire::Box<
1757 'static,
1758 crate::wire::ExecutionControllerOnStopRequest<'static>,
1759 >,
1760 >,
1761 _: (),
1762 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1763 if let Some(inner) = this {
1764 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1765 ::fidl_next::wire::Box::encode_present(out);
1766 } else {
1767 ::fidl_next::wire::Box::encode_absent(out);
1768 }
1769
1770 Ok(())
1771 }
1772 }
1773
1774 unsafe impl<'a, ___E>
1775 ::fidl_next::EncodeOption<
1776 ::fidl_next::wire::Box<'static, crate::wire::ExecutionControllerOnStopRequest<'static>>,
1777 ___E,
1778 > for &'a ExecutionControllerOnStopRequest
1779 where
1780 ___E: ::fidl_next::Encoder + ?Sized,
1781 &'a ExecutionControllerOnStopRequest:
1782 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>,
1783 {
1784 #[inline]
1785 fn encode_option(
1786 this: ::core::option::Option<Self>,
1787 encoder: &mut ___E,
1788 out: &mut ::core::mem::MaybeUninit<
1789 ::fidl_next::wire::Box<
1790 'static,
1791 crate::wire::ExecutionControllerOnStopRequest<'static>,
1792 >,
1793 >,
1794 _: (),
1795 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1796 if let Some(inner) = this {
1797 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1798 ::fidl_next::wire::Box::encode_present(out);
1799 } else {
1800 ::fidl_next::wire::Box::encode_absent(out);
1801 }
1802
1803 Ok(())
1804 }
1805 }
1806
1807 impl<'de> ::fidl_next::FromWire<crate::wire::ExecutionControllerOnStopRequest<'de>>
1808 for ExecutionControllerOnStopRequest
1809 {
1810 #[inline]
1811 fn from_wire(wire: crate::wire::ExecutionControllerOnStopRequest<'de>) -> Self {
1812 Self { stopped_payload: ::fidl_next::FromWire::from_wire(wire.stopped_payload) }
1813 }
1814 }
1815
1816 impl<'de> ::fidl_next::FromWireRef<crate::wire::ExecutionControllerOnStopRequest<'de>>
1817 for ExecutionControllerOnStopRequest
1818 {
1819 #[inline]
1820 fn from_wire_ref(wire: &crate::wire::ExecutionControllerOnStopRequest<'de>) -> Self {
1821 Self { stopped_payload: ::fidl_next::FromWireRef::from_wire_ref(&wire.stopped_payload) }
1822 }
1823 }
1824
1825 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1826 pub struct IntrospectorGetMonikerResponse {
1827 pub moniker: ::std::string::String,
1828 }
1829
1830 unsafe impl<___E>
1831 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
1832 for IntrospectorGetMonikerResponse
1833 where
1834 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1835 ___E: ::fidl_next::Encoder,
1836 {
1837 #[inline]
1838 fn encode(
1839 self,
1840 encoder_: &mut ___E,
1841 out_: &mut ::core::mem::MaybeUninit<
1842 crate::wire::IntrospectorGetMonikerResponse<'static>,
1843 >,
1844 _: (),
1845 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1846 ::fidl_next::munge! {
1847 let crate::wire::IntrospectorGetMonikerResponse {
1848 moniker,
1849
1850 } = out_;
1851 }
1852
1853 ::fidl_next::Encode::encode(self.moniker, encoder_, moniker, 4096)?;
1854
1855 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(moniker.as_mut_ptr()) };
1856 ::fidl_next::Constrained::validate(_field, 4096)?;
1857
1858 Ok(())
1859 }
1860 }
1861
1862 unsafe impl<'a, ___E>
1863 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
1864 for &'a IntrospectorGetMonikerResponse
1865 where
1866 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1867 ___E: ::fidl_next::Encoder,
1868 {
1869 #[inline]
1870 fn encode(
1871 self,
1872 encoder_: &mut ___E,
1873 out_: &mut ::core::mem::MaybeUninit<
1874 crate::wire::IntrospectorGetMonikerResponse<'static>,
1875 >,
1876 _: (),
1877 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1878 ::fidl_next::munge! {
1879 let crate::wire::IntrospectorGetMonikerResponse {
1880 moniker,
1881
1882 } = out_;
1883 }
1884
1885 ::fidl_next::Encode::encode(&self.moniker, encoder_, moniker, 4096)?;
1886
1887 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(moniker.as_mut_ptr()) };
1888 ::fidl_next::Constrained::validate(_field, 4096)?;
1889
1890 Ok(())
1891 }
1892 }
1893
1894 unsafe impl<___E>
1895 ::fidl_next::EncodeOption<
1896 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerResponse<'static>>,
1897 ___E,
1898 > for IntrospectorGetMonikerResponse
1899 where
1900 ___E: ::fidl_next::Encoder + ?Sized,
1901 IntrospectorGetMonikerResponse:
1902 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>,
1903 {
1904 #[inline]
1905 fn encode_option(
1906 this: ::core::option::Option<Self>,
1907 encoder: &mut ___E,
1908 out: &mut ::core::mem::MaybeUninit<
1909 ::fidl_next::wire::Box<
1910 'static,
1911 crate::wire::IntrospectorGetMonikerResponse<'static>,
1912 >,
1913 >,
1914 _: (),
1915 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1916 if let Some(inner) = this {
1917 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1918 ::fidl_next::wire::Box::encode_present(out);
1919 } else {
1920 ::fidl_next::wire::Box::encode_absent(out);
1921 }
1922
1923 Ok(())
1924 }
1925 }
1926
1927 unsafe impl<'a, ___E>
1928 ::fidl_next::EncodeOption<
1929 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerResponse<'static>>,
1930 ___E,
1931 > for &'a IntrospectorGetMonikerResponse
1932 where
1933 ___E: ::fidl_next::Encoder + ?Sized,
1934 &'a IntrospectorGetMonikerResponse:
1935 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>,
1936 {
1937 #[inline]
1938 fn encode_option(
1939 this: ::core::option::Option<Self>,
1940 encoder: &mut ___E,
1941 out: &mut ::core::mem::MaybeUninit<
1942 ::fidl_next::wire::Box<
1943 'static,
1944 crate::wire::IntrospectorGetMonikerResponse<'static>,
1945 >,
1946 >,
1947 _: (),
1948 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1949 if let Some(inner) = this {
1950 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1951 ::fidl_next::wire::Box::encode_present(out);
1952 } else {
1953 ::fidl_next::wire::Box::encode_absent(out);
1954 }
1955
1956 Ok(())
1957 }
1958 }
1959
1960 impl<'de> ::fidl_next::FromWire<crate::wire::IntrospectorGetMonikerResponse<'de>>
1961 for IntrospectorGetMonikerResponse
1962 {
1963 #[inline]
1964 fn from_wire(wire: crate::wire::IntrospectorGetMonikerResponse<'de>) -> Self {
1965 Self { moniker: ::fidl_next::FromWire::from_wire(wire.moniker) }
1966 }
1967 }
1968
1969 impl<'de> ::fidl_next::FromWireRef<crate::wire::IntrospectorGetMonikerResponse<'de>>
1970 for IntrospectorGetMonikerResponse
1971 {
1972 #[inline]
1973 fn from_wire_ref(wire: &crate::wire::IntrospectorGetMonikerResponse<'de>) -> Self {
1974 Self { moniker: ::fidl_next::FromWireRef::from_wire_ref(&wire.moniker) }
1975 }
1976 }
1977
1978 #[doc = " Error returned from methods in [`Namespace`].\n"]
1979 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1980 #[repr(u32)]
1981 pub enum NamespaceError {
1982 Shadow = 1,
1983 Duplicate = 2,
1984 Conversion = 3,
1985 BadEntry = 4,
1986 DictionaryRead = 5,
1987 UnknownOrdinal_(u32) = 6,
1988 }
1989 impl ::std::convert::From<u32> for NamespaceError {
1990 fn from(value: u32) -> Self {
1991 match value {
1992 1 => Self::Shadow,
1993 2 => Self::Duplicate,
1994 3 => Self::Conversion,
1995 4 => Self::BadEntry,
1996 5 => Self::DictionaryRead,
1997
1998 _ => Self::UnknownOrdinal_(value),
1999 }
2000 }
2001 }
2002
2003 impl ::std::convert::From<NamespaceError> for u32 {
2004 fn from(value: NamespaceError) -> Self {
2005 match value {
2006 NamespaceError::Shadow => 1,
2007 NamespaceError::Duplicate => 2,
2008 NamespaceError::Conversion => 3,
2009 NamespaceError::BadEntry => 4,
2010 NamespaceError::DictionaryRead => 5,
2011
2012 NamespaceError::UnknownOrdinal_(value) => value,
2013 }
2014 }
2015 }
2016
2017 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceError, ___E> for NamespaceError
2018 where
2019 ___E: ?Sized,
2020 {
2021 #[inline]
2022 fn encode(
2023 self,
2024 encoder: &mut ___E,
2025 out: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceError>,
2026 _: (),
2027 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2028 ::fidl_next::Encode::encode(&self, encoder, out, ())
2029 }
2030 }
2031
2032 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NamespaceError, ___E> for &'a NamespaceError
2033 where
2034 ___E: ?Sized,
2035 {
2036 #[inline]
2037 fn encode(
2038 self,
2039 encoder: &mut ___E,
2040 out: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceError>,
2041 _: (),
2042 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2043 ::fidl_next::munge!(let crate::wire::NamespaceError { value } = out);
2044 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
2045 NamespaceError::Shadow => 1,
2046
2047 NamespaceError::Duplicate => 2,
2048
2049 NamespaceError::Conversion => 3,
2050
2051 NamespaceError::BadEntry => 4,
2052
2053 NamespaceError::DictionaryRead => 5,
2054
2055 NamespaceError::UnknownOrdinal_(value) => value,
2056 }));
2057
2058 Ok(())
2059 }
2060 }
2061
2062 impl ::core::convert::From<crate::wire::NamespaceError> for NamespaceError {
2063 fn from(wire: crate::wire::NamespaceError) -> Self {
2064 match u32::from(wire.value) {
2065 1 => Self::Shadow,
2066
2067 2 => Self::Duplicate,
2068
2069 3 => Self::Conversion,
2070
2071 4 => Self::BadEntry,
2072
2073 5 => Self::DictionaryRead,
2074
2075 value => Self::UnknownOrdinal_(value),
2076 }
2077 }
2078 }
2079
2080 impl ::fidl_next::FromWire<crate::wire::NamespaceError> for NamespaceError {
2081 #[inline]
2082 fn from_wire(wire: crate::wire::NamespaceError) -> Self {
2083 Self::from(wire)
2084 }
2085 }
2086
2087 impl ::fidl_next::FromWireRef<crate::wire::NamespaceError> for NamespaceError {
2088 #[inline]
2089 fn from_wire_ref(wire: &crate::wire::NamespaceError) -> Self {
2090 Self::from(*wire)
2091 }
2092 }
2093
2094 pub type RealmOpenExposedDirResponse = ();
2095
2096 pub type RealmCreateChildResponse = ();
2097
2098 #[derive(Debug, Clone, PartialEq)]
2099 pub struct RealmDestroyChildRequest {
2100 pub child: ::fidl_next_common_fuchsia_component_decl::natural::ChildRef,
2101 }
2102
2103 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
2104 for RealmDestroyChildRequest
2105 where
2106 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2107 ___E: ::fidl_next::Encoder,
2108 {
2109 #[inline]
2110 fn encode(
2111 self,
2112 encoder_: &mut ___E,
2113 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
2114 _: (),
2115 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2116 ::fidl_next::munge! {
2117 let crate::wire::RealmDestroyChildRequest {
2118 child,
2119
2120 } = out_;
2121 }
2122
2123 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2124
2125 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2126
2127 Ok(())
2128 }
2129 }
2130
2131 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
2132 for &'a RealmDestroyChildRequest
2133 where
2134 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2135 ___E: ::fidl_next::Encoder,
2136 {
2137 #[inline]
2138 fn encode(
2139 self,
2140 encoder_: &mut ___E,
2141 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
2142 _: (),
2143 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2144 ::fidl_next::munge! {
2145 let crate::wire::RealmDestroyChildRequest {
2146 child,
2147
2148 } = out_;
2149 }
2150
2151 ::fidl_next::Encode::encode(&self.child, encoder_, child, ())?;
2152
2153 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2154
2155 Ok(())
2156 }
2157 }
2158
2159 unsafe impl<___E>
2160 ::fidl_next::EncodeOption<
2161 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2162 ___E,
2163 > for RealmDestroyChildRequest
2164 where
2165 ___E: ::fidl_next::Encoder + ?Sized,
2166 RealmDestroyChildRequest:
2167 ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>,
2168 {
2169 #[inline]
2170 fn encode_option(
2171 this: ::core::option::Option<Self>,
2172 encoder: &mut ___E,
2173 out: &mut ::core::mem::MaybeUninit<
2174 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2175 >,
2176 _: (),
2177 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2178 if let Some(inner) = this {
2179 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2180 ::fidl_next::wire::Box::encode_present(out);
2181 } else {
2182 ::fidl_next::wire::Box::encode_absent(out);
2183 }
2184
2185 Ok(())
2186 }
2187 }
2188
2189 unsafe impl<'a, ___E>
2190 ::fidl_next::EncodeOption<
2191 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2192 ___E,
2193 > for &'a RealmDestroyChildRequest
2194 where
2195 ___E: ::fidl_next::Encoder + ?Sized,
2196 &'a RealmDestroyChildRequest:
2197 ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>,
2198 {
2199 #[inline]
2200 fn encode_option(
2201 this: ::core::option::Option<Self>,
2202 encoder: &mut ___E,
2203 out: &mut ::core::mem::MaybeUninit<
2204 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2205 >,
2206 _: (),
2207 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2208 if let Some(inner) = this {
2209 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2210 ::fidl_next::wire::Box::encode_present(out);
2211 } else {
2212 ::fidl_next::wire::Box::encode_absent(out);
2213 }
2214
2215 Ok(())
2216 }
2217 }
2218
2219 impl<'de> ::fidl_next::FromWire<crate::wire::RealmDestroyChildRequest<'de>>
2220 for RealmDestroyChildRequest
2221 {
2222 #[inline]
2223 fn from_wire(wire: crate::wire::RealmDestroyChildRequest<'de>) -> Self {
2224 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2225 }
2226 }
2227
2228 impl<'de> ::fidl_next::FromWireRef<crate::wire::RealmDestroyChildRequest<'de>>
2229 for RealmDestroyChildRequest
2230 {
2231 #[inline]
2232 fn from_wire_ref(wire: &crate::wire::RealmDestroyChildRequest<'de>) -> Self {
2233 Self { child: ::fidl_next::FromWireRef::from_wire_ref(&wire.child) }
2234 }
2235 }
2236
2237 pub type RealmDestroyChildResponse = ();
2238
2239 pub type RealmListChildrenResponse = ();
2240
2241 pub type RealmOpenControllerResponse = ();
2242
2243 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2244 #[repr(u32)]
2245 pub enum StatusError {
2246 Provider = 1,
2247 ResponseInvalid = 2,
2248 StatusUnknown = 3,
2249 Unsupported = 4,
2250 }
2251 impl ::core::convert::TryFrom<u32> for StatusError {
2252 type Error = ::fidl_next::UnknownStrictEnumMemberError;
2253 fn try_from(
2254 value: u32,
2255 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
2256 match value {
2257 1 => Ok(Self::Provider),
2258 2 => Ok(Self::ResponseInvalid),
2259 3 => Ok(Self::StatusUnknown),
2260 4 => Ok(Self::Unsupported),
2261
2262 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
2263 }
2264 }
2265 }
2266
2267 impl ::std::convert::From<StatusError> for u32 {
2268 fn from(value: StatusError) -> Self {
2269 match value {
2270 StatusError::Provider => 1,
2271 StatusError::ResponseInvalid => 2,
2272 StatusError::StatusUnknown => 3,
2273 StatusError::Unsupported => 4,
2274 }
2275 }
2276 }
2277
2278 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StatusError, ___E> for StatusError
2279 where
2280 ___E: ?Sized,
2281 {
2282 #[inline]
2283 fn encode(
2284 self,
2285 encoder: &mut ___E,
2286 out: &mut ::core::mem::MaybeUninit<crate::wire::StatusError>,
2287 _: (),
2288 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2289 ::fidl_next::Encode::encode(&self, encoder, out, ())
2290 }
2291 }
2292
2293 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StatusError, ___E> for &'a StatusError
2294 where
2295 ___E: ?Sized,
2296 {
2297 #[inline]
2298 fn encode(
2299 self,
2300 encoder: &mut ___E,
2301 out: &mut ::core::mem::MaybeUninit<crate::wire::StatusError>,
2302 _: (),
2303 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2304 ::fidl_next::munge!(let crate::wire::StatusError { value } = out);
2305 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
2306 StatusError::Provider => 1,
2307
2308 StatusError::ResponseInvalid => 2,
2309
2310 StatusError::StatusUnknown => 3,
2311
2312 StatusError::Unsupported => 4,
2313 }));
2314
2315 Ok(())
2316 }
2317 }
2318
2319 impl ::core::convert::From<crate::wire::StatusError> for StatusError {
2320 fn from(wire: crate::wire::StatusError) -> Self {
2321 match u32::from(wire.value) {
2322 1 => Self::Provider,
2323
2324 2 => Self::ResponseInvalid,
2325
2326 3 => Self::StatusUnknown,
2327
2328 4 => Self::Unsupported,
2329
2330 _ => unsafe { ::core::hint::unreachable_unchecked() },
2331 }
2332 }
2333 }
2334
2335 impl ::fidl_next::FromWire<crate::wire::StatusError> for StatusError {
2336 #[inline]
2337 fn from_wire(wire: crate::wire::StatusError) -> Self {
2338 Self::from(wire)
2339 }
2340 }
2341
2342 impl ::fidl_next::FromWireRef<crate::wire::StatusError> for StatusError {
2343 #[inline]
2344 fn from_wire_ref(wire: &crate::wire::StatusError) -> Self {
2345 Self::from(*wire)
2346 }
2347 }
2348
2349 pub type StorageAdminOpenStorageResponse = ();
2350
2351 pub type StorageAdminListStorageInRealmResponse = ();
2352
2353 pub type StorageAdminOpenComponentStorageByIdResponse = ();
2354
2355 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2356 pub struct StorageAdminDeleteComponentStorageRequest {
2357 pub relative_moniker: ::std::string::String,
2358 }
2359
2360 unsafe impl<___E>
2361 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
2362 for StorageAdminDeleteComponentStorageRequest
2363 where
2364 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2365 ___E: ::fidl_next::Encoder,
2366 {
2367 #[inline]
2368 fn encode(
2369 self,
2370 encoder_: &mut ___E,
2371 out_: &mut ::core::mem::MaybeUninit<
2372 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2373 >,
2374 _: (),
2375 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2376 ::fidl_next::munge! {
2377 let crate::wire::StorageAdminDeleteComponentStorageRequest {
2378 relative_moniker,
2379
2380 } = out_;
2381 }
2382
2383 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
2384
2385 let mut _field =
2386 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
2387 ::fidl_next::Constrained::validate(_field, 4096)?;
2388
2389 Ok(())
2390 }
2391 }
2392
2393 unsafe impl<'a, ___E>
2394 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
2395 for &'a StorageAdminDeleteComponentStorageRequest
2396 where
2397 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2398 ___E: ::fidl_next::Encoder,
2399 {
2400 #[inline]
2401 fn encode(
2402 self,
2403 encoder_: &mut ___E,
2404 out_: &mut ::core::mem::MaybeUninit<
2405 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2406 >,
2407 _: (),
2408 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2409 ::fidl_next::munge! {
2410 let crate::wire::StorageAdminDeleteComponentStorageRequest {
2411 relative_moniker,
2412
2413 } = out_;
2414 }
2415
2416 ::fidl_next::Encode::encode(&self.relative_moniker, encoder_, relative_moniker, 4096)?;
2417
2418 let mut _field =
2419 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
2420 ::fidl_next::Constrained::validate(_field, 4096)?;
2421
2422 Ok(())
2423 }
2424 }
2425
2426 unsafe impl<___E>
2427 ::fidl_next::EncodeOption<
2428 ::fidl_next::wire::Box<
2429 'static,
2430 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2431 >,
2432 ___E,
2433 > for StorageAdminDeleteComponentStorageRequest
2434 where
2435 ___E: ::fidl_next::Encoder + ?Sized,
2436 StorageAdminDeleteComponentStorageRequest: ::fidl_next::Encode<
2437 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2438 ___E,
2439 >,
2440 {
2441 #[inline]
2442 fn encode_option(
2443 this: ::core::option::Option<Self>,
2444 encoder: &mut ___E,
2445 out: &mut ::core::mem::MaybeUninit<
2446 ::fidl_next::wire::Box<
2447 'static,
2448 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2449 >,
2450 >,
2451 _: (),
2452 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2453 if let Some(inner) = this {
2454 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2455 ::fidl_next::wire::Box::encode_present(out);
2456 } else {
2457 ::fidl_next::wire::Box::encode_absent(out);
2458 }
2459
2460 Ok(())
2461 }
2462 }
2463
2464 unsafe impl<'a, ___E>
2465 ::fidl_next::EncodeOption<
2466 ::fidl_next::wire::Box<
2467 'static,
2468 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2469 >,
2470 ___E,
2471 > for &'a StorageAdminDeleteComponentStorageRequest
2472 where
2473 ___E: ::fidl_next::Encoder + ?Sized,
2474 &'a StorageAdminDeleteComponentStorageRequest: ::fidl_next::Encode<
2475 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2476 ___E,
2477 >,
2478 {
2479 #[inline]
2480 fn encode_option(
2481 this: ::core::option::Option<Self>,
2482 encoder: &mut ___E,
2483 out: &mut ::core::mem::MaybeUninit<
2484 ::fidl_next::wire::Box<
2485 'static,
2486 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2487 >,
2488 >,
2489 _: (),
2490 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2491 if let Some(inner) = this {
2492 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2493 ::fidl_next::wire::Box::encode_present(out);
2494 } else {
2495 ::fidl_next::wire::Box::encode_absent(out);
2496 }
2497
2498 Ok(())
2499 }
2500 }
2501
2502 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminDeleteComponentStorageRequest<'de>>
2503 for StorageAdminDeleteComponentStorageRequest
2504 {
2505 #[inline]
2506 fn from_wire(wire: crate::wire::StorageAdminDeleteComponentStorageRequest<'de>) -> Self {
2507 Self { relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker) }
2508 }
2509 }
2510
2511 impl<'de> ::fidl_next::FromWireRef<crate::wire::StorageAdminDeleteComponentStorageRequest<'de>>
2512 for StorageAdminDeleteComponentStorageRequest
2513 {
2514 #[inline]
2515 fn from_wire_ref(
2516 wire: &crate::wire::StorageAdminDeleteComponentStorageRequest<'de>,
2517 ) -> Self {
2518 Self {
2519 relative_moniker: ::fidl_next::FromWireRef::from_wire_ref(&wire.relative_moniker),
2520 }
2521 }
2522 }
2523
2524 pub type StorageAdminDeleteComponentStorageResponse = ();
2525
2526 #[doc = " Metadata about status of the storage\n"]
2527 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2528 pub struct StorageStatus {
2529 pub total_size: ::core::option::Option<u64>,
2530
2531 pub used_size: ::core::option::Option<u64>,
2532 }
2533
2534 impl StorageStatus {
2535 fn __max_ordinal(&self) -> usize {
2536 if self.used_size.is_some() {
2537 return 2;
2538 }
2539
2540 if self.total_size.is_some() {
2541 return 1;
2542 }
2543
2544 0
2545 }
2546 }
2547
2548 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StorageStatus<'static>, ___E> for StorageStatus
2549 where
2550 ___E: ::fidl_next::Encoder + ?Sized,
2551 {
2552 #[inline]
2553 fn encode(
2554 mut self,
2555 encoder: &mut ___E,
2556 out: &mut ::core::mem::MaybeUninit<crate::wire::StorageStatus<'static>>,
2557 _: (),
2558 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2559 ::fidl_next::munge!(let crate::wire::StorageStatus { table } = out);
2560
2561 let max_ord = self.__max_ordinal();
2562
2563 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2564 ::fidl_next::Wire::zero_padding(&mut out);
2565
2566 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2567 ::fidl_next::wire::Envelope,
2568 >(encoder, max_ord);
2569
2570 for i in 1..=max_ord {
2571 match i {
2572 2 => {
2573 if let Some(value) = self.used_size.take() {
2574 ::fidl_next::wire::Envelope::encode_value::<
2575 ::fidl_next::wire::Uint64,
2576 ___E,
2577 >(
2578 value, preallocated.encoder, &mut out, ()
2579 )?;
2580 } else {
2581 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2582 }
2583 }
2584
2585 1 => {
2586 if let Some(value) = self.total_size.take() {
2587 ::fidl_next::wire::Envelope::encode_value::<
2588 ::fidl_next::wire::Uint64,
2589 ___E,
2590 >(
2591 value, preallocated.encoder, &mut out, ()
2592 )?;
2593 } else {
2594 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2595 }
2596 }
2597
2598 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2599 }
2600 unsafe {
2601 preallocated.write_next(out.assume_init_ref());
2602 }
2603 }
2604
2605 ::fidl_next::wire::Table::encode_len(table, max_ord);
2606
2607 Ok(())
2608 }
2609 }
2610
2611 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StorageStatus<'static>, ___E>
2612 for &'a StorageStatus
2613 where
2614 ___E: ::fidl_next::Encoder + ?Sized,
2615 {
2616 #[inline]
2617 fn encode(
2618 self,
2619 encoder: &mut ___E,
2620 out: &mut ::core::mem::MaybeUninit<crate::wire::StorageStatus<'static>>,
2621 _: (),
2622 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2623 ::fidl_next::munge!(let crate::wire::StorageStatus { table } = out);
2624
2625 let max_ord = self.__max_ordinal();
2626
2627 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2628 ::fidl_next::Wire::zero_padding(&mut out);
2629
2630 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2631 ::fidl_next::wire::Envelope,
2632 >(encoder, max_ord);
2633
2634 for i in 1..=max_ord {
2635 match i {
2636 2 => {
2637 if let Some(value) = &self.used_size {
2638 ::fidl_next::wire::Envelope::encode_value::<
2639 ::fidl_next::wire::Uint64,
2640 ___E,
2641 >(
2642 value, preallocated.encoder, &mut out, ()
2643 )?;
2644 } else {
2645 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2646 }
2647 }
2648
2649 1 => {
2650 if let Some(value) = &self.total_size {
2651 ::fidl_next::wire::Envelope::encode_value::<
2652 ::fidl_next::wire::Uint64,
2653 ___E,
2654 >(
2655 value, preallocated.encoder, &mut out, ()
2656 )?;
2657 } else {
2658 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2659 }
2660 }
2661
2662 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2663 }
2664 unsafe {
2665 preallocated.write_next(out.assume_init_ref());
2666 }
2667 }
2668
2669 ::fidl_next::wire::Table::encode_len(table, max_ord);
2670
2671 Ok(())
2672 }
2673 }
2674
2675 impl<'de> ::fidl_next::FromWire<crate::wire::StorageStatus<'de>> for StorageStatus {
2676 #[inline]
2677 fn from_wire(wire_: crate::wire::StorageStatus<'de>) -> Self {
2678 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2679
2680 let total_size = wire_.table.get(1);
2681
2682 let used_size = wire_.table.get(2);
2683
2684 Self {
2685 total_size: total_size.map(|envelope| {
2686 ::fidl_next::FromWire::from_wire(unsafe {
2687 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
2688 })
2689 }),
2690
2691 used_size: used_size.map(|envelope| {
2692 ::fidl_next::FromWire::from_wire(unsafe {
2693 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
2694 })
2695 }),
2696 }
2697 }
2698 }
2699
2700 impl<'de> ::fidl_next::FromWireRef<crate::wire::StorageStatus<'de>> for StorageStatus {
2701 #[inline]
2702 fn from_wire_ref(wire: &crate::wire::StorageStatus<'de>) -> Self {
2703 Self {
2704 total_size: wire.table.get(1).map(|envelope| {
2705 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2706 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
2707 })
2708 }),
2709
2710 used_size: wire.table.get(2).map(|envelope| {
2711 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2712 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
2713 })
2714 }),
2715 }
2716 }
2717 }
2718
2719 pub type StorageAdminDeleteAllStorageContentsResponse = ();
2720
2721 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2722 pub struct StorageIteratorNextResponse {
2723 pub relative_monikers: ::std::vec::Vec<::std::string::String>,
2724 }
2725
2726 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
2727 for StorageIteratorNextResponse
2728 where
2729 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2730 ___E: ::fidl_next::Encoder,
2731 {
2732 #[inline]
2733 fn encode(
2734 self,
2735 encoder_: &mut ___E,
2736 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
2737 _: (),
2738 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2739 ::fidl_next::munge! {
2740 let crate::wire::StorageIteratorNextResponse {
2741 relative_monikers,
2742
2743 } = out_;
2744 }
2745
2746 ::fidl_next::Encode::encode(
2747 self.relative_monikers,
2748 encoder_,
2749 relative_monikers,
2750 (4294967295, 4096),
2751 )?;
2752
2753 let mut _field =
2754 unsafe { ::fidl_next::Slot::new_unchecked(relative_monikers.as_mut_ptr()) };
2755 ::fidl_next::Constrained::validate(_field, (4294967295, 4096))?;
2756
2757 Ok(())
2758 }
2759 }
2760
2761 unsafe impl<'a, ___E>
2762 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
2763 for &'a StorageIteratorNextResponse
2764 where
2765 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2766 ___E: ::fidl_next::Encoder,
2767 {
2768 #[inline]
2769 fn encode(
2770 self,
2771 encoder_: &mut ___E,
2772 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
2773 _: (),
2774 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2775 ::fidl_next::munge! {
2776 let crate::wire::StorageIteratorNextResponse {
2777 relative_monikers,
2778
2779 } = out_;
2780 }
2781
2782 ::fidl_next::Encode::encode(
2783 &self.relative_monikers,
2784 encoder_,
2785 relative_monikers,
2786 (4294967295, 4096),
2787 )?;
2788
2789 let mut _field =
2790 unsafe { ::fidl_next::Slot::new_unchecked(relative_monikers.as_mut_ptr()) };
2791 ::fidl_next::Constrained::validate(_field, (4294967295, 4096))?;
2792
2793 Ok(())
2794 }
2795 }
2796
2797 unsafe impl<___E>
2798 ::fidl_next::EncodeOption<
2799 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2800 ___E,
2801 > for StorageIteratorNextResponse
2802 where
2803 ___E: ::fidl_next::Encoder + ?Sized,
2804 StorageIteratorNextResponse:
2805 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>,
2806 {
2807 #[inline]
2808 fn encode_option(
2809 this: ::core::option::Option<Self>,
2810 encoder: &mut ___E,
2811 out: &mut ::core::mem::MaybeUninit<
2812 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2813 >,
2814 _: (),
2815 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2816 if let Some(inner) = this {
2817 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2818 ::fidl_next::wire::Box::encode_present(out);
2819 } else {
2820 ::fidl_next::wire::Box::encode_absent(out);
2821 }
2822
2823 Ok(())
2824 }
2825 }
2826
2827 unsafe impl<'a, ___E>
2828 ::fidl_next::EncodeOption<
2829 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2830 ___E,
2831 > for &'a StorageIteratorNextResponse
2832 where
2833 ___E: ::fidl_next::Encoder + ?Sized,
2834 &'a StorageIteratorNextResponse:
2835 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>,
2836 {
2837 #[inline]
2838 fn encode_option(
2839 this: ::core::option::Option<Self>,
2840 encoder: &mut ___E,
2841 out: &mut ::core::mem::MaybeUninit<
2842 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2843 >,
2844 _: (),
2845 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2846 if let Some(inner) = this {
2847 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2848 ::fidl_next::wire::Box::encode_present(out);
2849 } else {
2850 ::fidl_next::wire::Box::encode_absent(out);
2851 }
2852
2853 Ok(())
2854 }
2855 }
2856
2857 impl<'de> ::fidl_next::FromWire<crate::wire::StorageIteratorNextResponse<'de>>
2858 for StorageIteratorNextResponse
2859 {
2860 #[inline]
2861 fn from_wire(wire: crate::wire::StorageIteratorNextResponse<'de>) -> Self {
2862 Self { relative_monikers: ::fidl_next::FromWire::from_wire(wire.relative_monikers) }
2863 }
2864 }
2865
2866 impl<'de> ::fidl_next::FromWireRef<crate::wire::StorageIteratorNextResponse<'de>>
2867 for StorageIteratorNextResponse
2868 {
2869 #[inline]
2870 fn from_wire_ref(wire: &crate::wire::StorageIteratorNextResponse<'de>) -> Self {
2871 Self {
2872 relative_monikers: ::fidl_next::FromWireRef::from_wire_ref(&wire.relative_monikers),
2873 }
2874 }
2875 }
2876
2877 pub type ChildName = ::std::string::String;
2878
2879 pub type UrlScheme = ::std::string::String;
2880}
2881
2882pub mod wire {
2883
2884 pub type Name<'de> = ::fidl_next::wire::String<'de>;
2886
2887 #[derive(Debug)]
2889 #[repr(C)]
2890 pub struct ChildIteratorNextResponse<'de> {
2891 pub children: ::fidl_next::wire::Vector<
2892 'de,
2893 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'de>,
2894 >,
2895 }
2896
2897 static_assertions::const_assert_eq!(std::mem::size_of::<ChildIteratorNextResponse<'_>>(), 16);
2898 static_assertions::const_assert_eq!(std::mem::align_of::<ChildIteratorNextResponse<'_>>(), 8);
2899
2900 static_assertions::const_assert_eq!(
2901 std::mem::offset_of!(ChildIteratorNextResponse<'_>, children),
2902 0
2903 );
2904
2905 impl ::fidl_next::Constrained for ChildIteratorNextResponse<'_> {
2906 type Constraint = ();
2907
2908 fn validate(
2909 _: ::fidl_next::Slot<'_, Self>,
2910 _: Self::Constraint,
2911 ) -> Result<(), ::fidl_next::ValidationError> {
2912 Ok(())
2913 }
2914 }
2915
2916 unsafe impl ::fidl_next::Wire for ChildIteratorNextResponse<'static> {
2917 type Narrowed<'de> = ChildIteratorNextResponse<'de>;
2918
2919 #[inline]
2920 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2921 ::fidl_next::munge! {
2922 let Self {
2923 children,
2924
2925 } = &mut *out_;
2926 }
2927
2928 ::fidl_next::Wire::zero_padding(children);
2929 }
2930 }
2931
2932 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ChildIteratorNextResponse<'de>
2933 where
2934 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2935 ___D: ::fidl_next::Decoder<'de>,
2936 {
2937 fn decode(
2938 slot_: ::fidl_next::Slot<'_, Self>,
2939 decoder_: &mut ___D,
2940 _: (),
2941 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2942 ::fidl_next::munge! {
2943 let Self {
2944 mut children,
2945
2946 } = slot_;
2947 }
2948
2949 let _field = children.as_mut();
2950 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2951 ::fidl_next::Decode::decode(children.as_mut(), decoder_, (128, ()))?;
2952
2953 let children = unsafe { children.deref_unchecked() };
2954
2955 if children.len() > 128 {
2956 return Err(::fidl_next::DecodeError::VectorTooLong {
2957 size: children.len() as u64,
2958 limit: 128,
2959 });
2960 }
2961
2962 Ok(())
2963 }
2964 }
2965
2966 impl<'de> ::fidl_next::IntoNatural for ChildIteratorNextResponse<'de> {
2967 type Natural = crate::natural::ChildIteratorNextResponse;
2968 }
2969
2970 pub type ControllerStartResponse = ::fidl_next::wire::Unit;
2972
2973 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
2975 #[repr(transparent)]
2976 pub struct Error {
2977 pub(crate) value: ::fidl_next::wire::Uint32,
2978 }
2979
2980 impl ::fidl_next::Constrained for Error {
2981 type Constraint = ();
2982
2983 fn validate(
2984 _: ::fidl_next::Slot<'_, Self>,
2985 _: Self::Constraint,
2986 ) -> Result<(), ::fidl_next::ValidationError> {
2987 Ok(())
2988 }
2989 }
2990
2991 unsafe impl ::fidl_next::Wire for Error {
2992 type Narrowed<'de> = Self;
2993
2994 #[inline]
2995 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
2996 }
2998 }
2999
3000 impl Error {
3001 pub const INTERNAL: Error = Error { value: ::fidl_next::wire::Uint32(1) };
3002
3003 pub const INVALID_ARGUMENTS: Error = Error { value: ::fidl_next::wire::Uint32(2) };
3004
3005 pub const UNSUPPORTED: Error = Error { value: ::fidl_next::wire::Uint32(3) };
3006
3007 pub const ACCESS_DENIED: Error = Error { value: ::fidl_next::wire::Uint32(4) };
3008
3009 pub const INSTANCE_NOT_FOUND: Error = Error { value: ::fidl_next::wire::Uint32(5) };
3010
3011 pub const INSTANCE_ALREADY_EXISTS: Error = Error { value: ::fidl_next::wire::Uint32(6) };
3012
3013 pub const INSTANCE_CANNOT_START: Error = Error { value: ::fidl_next::wire::Uint32(7) };
3014
3015 pub const INSTANCE_CANNOT_RESOLVE: Error = Error { value: ::fidl_next::wire::Uint32(8) };
3016
3017 pub const COLLECTION_NOT_FOUND: Error = Error { value: ::fidl_next::wire::Uint32(9) };
3018
3019 pub const RESOURCE_UNAVAILABLE: Error = Error { value: ::fidl_next::wire::Uint32(10) };
3020
3021 pub const INSTANCE_DIED: Error = Error { value: ::fidl_next::wire::Uint32(11) };
3022
3023 pub const RESOURCE_NOT_FOUND: Error = Error { value: ::fidl_next::wire::Uint32(12) };
3024
3025 pub const INSTANCE_CANNOT_UNRESOLVE: Error = Error { value: ::fidl_next::wire::Uint32(13) };
3026
3027 pub const INSTANCE_ALREADY_STARTED: Error = Error { value: ::fidl_next::wire::Uint32(14) };
3028
3029 pub const DEPENDENCY_CYCLE: Error = Error { value: ::fidl_next::wire::Uint32(15) };
3030 }
3031
3032 unsafe impl<___D> ::fidl_next::Decode<___D> for Error
3033 where
3034 ___D: ?Sized,
3035 {
3036 fn decode(
3037 slot: ::fidl_next::Slot<'_, Self>,
3038 _: &mut ___D,
3039 _: (),
3040 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3041 Ok(())
3042 }
3043 }
3044
3045 impl ::core::convert::From<crate::natural::Error> for Error {
3046 fn from(natural: crate::natural::Error) -> Self {
3047 match natural {
3048 crate::natural::Error::Internal => Error::INTERNAL,
3049
3050 crate::natural::Error::InvalidArguments => Error::INVALID_ARGUMENTS,
3051
3052 crate::natural::Error::Unsupported => Error::UNSUPPORTED,
3053
3054 crate::natural::Error::AccessDenied => Error::ACCESS_DENIED,
3055
3056 crate::natural::Error::InstanceNotFound => Error::INSTANCE_NOT_FOUND,
3057
3058 crate::natural::Error::InstanceAlreadyExists => Error::INSTANCE_ALREADY_EXISTS,
3059
3060 crate::natural::Error::InstanceCannotStart => Error::INSTANCE_CANNOT_START,
3061
3062 crate::natural::Error::InstanceCannotResolve => Error::INSTANCE_CANNOT_RESOLVE,
3063
3064 crate::natural::Error::CollectionNotFound => Error::COLLECTION_NOT_FOUND,
3065
3066 crate::natural::Error::ResourceUnavailable => Error::RESOURCE_UNAVAILABLE,
3067
3068 crate::natural::Error::InstanceDied => Error::INSTANCE_DIED,
3069
3070 crate::natural::Error::ResourceNotFound => Error::RESOURCE_NOT_FOUND,
3071
3072 crate::natural::Error::InstanceCannotUnresolve => Error::INSTANCE_CANNOT_UNRESOLVE,
3073
3074 crate::natural::Error::InstanceAlreadyStarted => Error::INSTANCE_ALREADY_STARTED,
3075
3076 crate::natural::Error::DependencyCycle => Error::DEPENDENCY_CYCLE,
3077
3078 crate::natural::Error::UnknownOrdinal_(value) => {
3079 Error { value: ::fidl_next::wire::Uint32::from(value) }
3080 }
3081 }
3082 }
3083 }
3084
3085 impl ::fidl_next::IntoNatural for Error {
3086 type Natural = crate::natural::Error;
3087 }
3088
3089 pub type ControllerOpenExposedDirResponse = ::fidl_next::wire::Unit;
3091
3092 pub type ControllerDestroyResponse = ::fidl_next::wire::Unit;
3094
3095 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
3097 #[repr(transparent)]
3098 pub struct DeletionError {
3099 pub(crate) value: ::fidl_next::wire::Uint32,
3100 }
3101
3102 impl ::fidl_next::Constrained for DeletionError {
3103 type Constraint = ();
3104
3105 fn validate(
3106 _: ::fidl_next::Slot<'_, Self>,
3107 _: Self::Constraint,
3108 ) -> Result<(), ::fidl_next::ValidationError> {
3109 Ok(())
3110 }
3111 }
3112
3113 unsafe impl ::fidl_next::Wire for DeletionError {
3114 type Narrowed<'de> = Self;
3115
3116 #[inline]
3117 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
3118 }
3120 }
3121
3122 impl DeletionError {
3123 pub const CONNECTION: DeletionError = DeletionError { value: ::fidl_next::wire::Uint32(1) };
3124
3125 pub const PROTOCOL: DeletionError = DeletionError { value: ::fidl_next::wire::Uint32(2) };
3126
3127 pub const NONE_AVAILABLE: DeletionError =
3128 DeletionError { value: ::fidl_next::wire::Uint32(3) };
3129
3130 pub const UNSUPPORTED: DeletionError =
3131 DeletionError { value: ::fidl_next::wire::Uint32(4) };
3132 }
3133
3134 unsafe impl<___D> ::fidl_next::Decode<___D> for DeletionError
3135 where
3136 ___D: ?Sized,
3137 {
3138 fn decode(
3139 slot: ::fidl_next::Slot<'_, Self>,
3140 _: &mut ___D,
3141 _: (),
3142 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3143 ::fidl_next::munge!(let Self { value } = slot);
3144
3145 match u32::from(*value) {
3146 1 | 2 | 3 | 4 => (),
3147 unknown => {
3148 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
3149 }
3150 }
3151
3152 Ok(())
3153 }
3154 }
3155
3156 impl ::core::convert::From<crate::natural::DeletionError> for DeletionError {
3157 fn from(natural: crate::natural::DeletionError) -> Self {
3158 match natural {
3159 crate::natural::DeletionError::Connection => DeletionError::CONNECTION,
3160
3161 crate::natural::DeletionError::Protocol => DeletionError::PROTOCOL,
3162
3163 crate::natural::DeletionError::NoneAvailable => DeletionError::NONE_AVAILABLE,
3164
3165 crate::natural::DeletionError::Unsupported => DeletionError::UNSUPPORTED,
3166 }
3167 }
3168 }
3169
3170 impl ::fidl_next::IntoNatural for DeletionError {
3171 type Natural = crate::natural::DeletionError;
3172 }
3173
3174 #[repr(C)]
3176 pub struct DestroyedPayload<'de> {
3177 pub(crate) table: ::fidl_next::wire::Table<'de>,
3178 }
3179
3180 impl<'de> Drop for DestroyedPayload<'de> {
3181 fn drop(&mut self) {}
3182 }
3183
3184 impl ::fidl_next::Constrained for DestroyedPayload<'_> {
3185 type Constraint = ();
3186
3187 fn validate(
3188 _: ::fidl_next::Slot<'_, Self>,
3189 _: Self::Constraint,
3190 ) -> Result<(), ::fidl_next::ValidationError> {
3191 Ok(())
3192 }
3193 }
3194
3195 unsafe impl ::fidl_next::Wire for DestroyedPayload<'static> {
3196 type Narrowed<'de> = DestroyedPayload<'de>;
3197
3198 #[inline]
3199 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3200 ::fidl_next::munge!(let Self { table } = out);
3201 ::fidl_next::wire::Table::zero_padding(table);
3202 }
3203 }
3204
3205 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DestroyedPayload<'de>
3206 where
3207 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3208 {
3209 fn decode(
3210 slot: ::fidl_next::Slot<'_, Self>,
3211 decoder: &mut ___D,
3212 _: (),
3213 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3214 ::fidl_next::munge!(let Self { table } = slot);
3215
3216 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3217 match ordinal {
3218 0 => unsafe { ::core::hint::unreachable_unchecked() },
3219
3220 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3221 }
3222 })
3223 }
3224 }
3225
3226 impl<'de> DestroyedPayload<'de> {}
3227
3228 impl<'de> ::core::fmt::Debug for DestroyedPayload<'de> {
3229 fn fmt(
3230 &self,
3231 f: &mut ::core::fmt::Formatter<'_>,
3232 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3233 f.debug_struct("DestroyedPayload").finish()
3234 }
3235 }
3236
3237 impl<'de> ::fidl_next::IntoNatural for DestroyedPayload<'de> {
3238 type Natural = crate::natural::DestroyedPayload;
3239 }
3240
3241 #[repr(C)]
3243 pub struct DiscoveredPayload<'de> {
3244 pub(crate) table: ::fidl_next::wire::Table<'de>,
3245 }
3246
3247 impl<'de> Drop for DiscoveredPayload<'de> {
3248 fn drop(&mut self) {}
3249 }
3250
3251 impl ::fidl_next::Constrained for DiscoveredPayload<'_> {
3252 type Constraint = ();
3253
3254 fn validate(
3255 _: ::fidl_next::Slot<'_, Self>,
3256 _: Self::Constraint,
3257 ) -> Result<(), ::fidl_next::ValidationError> {
3258 Ok(())
3259 }
3260 }
3261
3262 unsafe impl ::fidl_next::Wire for DiscoveredPayload<'static> {
3263 type Narrowed<'de> = DiscoveredPayload<'de>;
3264
3265 #[inline]
3266 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3267 ::fidl_next::munge!(let Self { table } = out);
3268 ::fidl_next::wire::Table::zero_padding(table);
3269 }
3270 }
3271
3272 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DiscoveredPayload<'de>
3273 where
3274 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3275 {
3276 fn decode(
3277 slot: ::fidl_next::Slot<'_, Self>,
3278 decoder: &mut ___D,
3279 _: (),
3280 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3281 ::fidl_next::munge!(let Self { table } = slot);
3282
3283 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3284 match ordinal {
3285 0 => unsafe { ::core::hint::unreachable_unchecked() },
3286
3287 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3288 }
3289 })
3290 }
3291 }
3292
3293 impl<'de> DiscoveredPayload<'de> {}
3294
3295 impl<'de> ::core::fmt::Debug for DiscoveredPayload<'de> {
3296 fn fmt(
3297 &self,
3298 f: &mut ::core::fmt::Formatter<'_>,
3299 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3300 f.debug_struct("DiscoveredPayload").finish()
3301 }
3302 }
3303
3304 impl<'de> ::fidl_next::IntoNatural for DiscoveredPayload<'de> {
3305 type Natural = crate::natural::DiscoveredPayload;
3306 }
3307
3308 #[repr(C)]
3310 pub struct PurgedPayload<'de> {
3311 pub(crate) table: ::fidl_next::wire::Table<'de>,
3312 }
3313
3314 impl<'de> Drop for PurgedPayload<'de> {
3315 fn drop(&mut self) {}
3316 }
3317
3318 impl ::fidl_next::Constrained for PurgedPayload<'_> {
3319 type Constraint = ();
3320
3321 fn validate(
3322 _: ::fidl_next::Slot<'_, Self>,
3323 _: Self::Constraint,
3324 ) -> Result<(), ::fidl_next::ValidationError> {
3325 Ok(())
3326 }
3327 }
3328
3329 unsafe impl ::fidl_next::Wire for PurgedPayload<'static> {
3330 type Narrowed<'de> = PurgedPayload<'de>;
3331
3332 #[inline]
3333 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3334 ::fidl_next::munge!(let Self { table } = out);
3335 ::fidl_next::wire::Table::zero_padding(table);
3336 }
3337 }
3338
3339 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for PurgedPayload<'de>
3340 where
3341 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3342 {
3343 fn decode(
3344 slot: ::fidl_next::Slot<'_, Self>,
3345 decoder: &mut ___D,
3346 _: (),
3347 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3348 ::fidl_next::munge!(let Self { table } = slot);
3349
3350 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3351 match ordinal {
3352 0 => unsafe { ::core::hint::unreachable_unchecked() },
3353
3354 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3355 }
3356 })
3357 }
3358 }
3359
3360 impl<'de> PurgedPayload<'de> {}
3361
3362 impl<'de> ::core::fmt::Debug for PurgedPayload<'de> {
3363 fn fmt(
3364 &self,
3365 f: &mut ::core::fmt::Formatter<'_>,
3366 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3367 f.debug_struct("PurgedPayload").finish()
3368 }
3369 }
3370
3371 impl<'de> ::fidl_next::IntoNatural for PurgedPayload<'de> {
3372 type Natural = crate::natural::PurgedPayload;
3373 }
3374
3375 #[repr(C)]
3377 pub struct ResolvedPayload<'de> {
3378 pub(crate) table: ::fidl_next::wire::Table<'de>,
3379 }
3380
3381 impl<'de> Drop for ResolvedPayload<'de> {
3382 fn drop(&mut self) {}
3383 }
3384
3385 impl ::fidl_next::Constrained for ResolvedPayload<'_> {
3386 type Constraint = ();
3387
3388 fn validate(
3389 _: ::fidl_next::Slot<'_, Self>,
3390 _: Self::Constraint,
3391 ) -> Result<(), ::fidl_next::ValidationError> {
3392 Ok(())
3393 }
3394 }
3395
3396 unsafe impl ::fidl_next::Wire for ResolvedPayload<'static> {
3397 type Narrowed<'de> = ResolvedPayload<'de>;
3398
3399 #[inline]
3400 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3401 ::fidl_next::munge!(let Self { table } = out);
3402 ::fidl_next::wire::Table::zero_padding(table);
3403 }
3404 }
3405
3406 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ResolvedPayload<'de>
3407 where
3408 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3409 {
3410 fn decode(
3411 slot: ::fidl_next::Slot<'_, Self>,
3412 decoder: &mut ___D,
3413 _: (),
3414 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3415 ::fidl_next::munge!(let Self { table } = slot);
3416
3417 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3418 match ordinal {
3419 0 => unsafe { ::core::hint::unreachable_unchecked() },
3420
3421 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3422 }
3423 })
3424 }
3425 }
3426
3427 impl<'de> ResolvedPayload<'de> {}
3428
3429 impl<'de> ::core::fmt::Debug for ResolvedPayload<'de> {
3430 fn fmt(
3431 &self,
3432 f: &mut ::core::fmt::Formatter<'_>,
3433 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3434 f.debug_struct("ResolvedPayload").finish()
3435 }
3436 }
3437
3438 impl<'de> ::fidl_next::IntoNatural for ResolvedPayload<'de> {
3439 type Natural = crate::natural::ResolvedPayload;
3440 }
3441
3442 #[repr(C)]
3444 pub struct StartedPayload<'de> {
3445 pub(crate) table: ::fidl_next::wire::Table<'de>,
3446 }
3447
3448 impl<'de> Drop for StartedPayload<'de> {
3449 fn drop(&mut self) {}
3450 }
3451
3452 impl ::fidl_next::Constrained for StartedPayload<'_> {
3453 type Constraint = ();
3454
3455 fn validate(
3456 _: ::fidl_next::Slot<'_, Self>,
3457 _: Self::Constraint,
3458 ) -> Result<(), ::fidl_next::ValidationError> {
3459 Ok(())
3460 }
3461 }
3462
3463 unsafe impl ::fidl_next::Wire for StartedPayload<'static> {
3464 type Narrowed<'de> = StartedPayload<'de>;
3465
3466 #[inline]
3467 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3468 ::fidl_next::munge!(let Self { table } = out);
3469 ::fidl_next::wire::Table::zero_padding(table);
3470 }
3471 }
3472
3473 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StartedPayload<'de>
3474 where
3475 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3476 {
3477 fn decode(
3478 slot: ::fidl_next::Slot<'_, Self>,
3479 decoder: &mut ___D,
3480 _: (),
3481 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3482 ::fidl_next::munge!(let Self { table } = slot);
3483
3484 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3485 match ordinal {
3486 0 => unsafe { ::core::hint::unreachable_unchecked() },
3487
3488 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3489 }
3490 })
3491 }
3492 }
3493
3494 impl<'de> StartedPayload<'de> {}
3495
3496 impl<'de> ::core::fmt::Debug for StartedPayload<'de> {
3497 fn fmt(
3498 &self,
3499 f: &mut ::core::fmt::Formatter<'_>,
3500 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3501 f.debug_struct("StartedPayload").finish()
3502 }
3503 }
3504
3505 impl<'de> ::fidl_next::IntoNatural for StartedPayload<'de> {
3506 type Natural = crate::natural::StartedPayload;
3507 }
3508
3509 #[repr(C)]
3511 pub struct UnresolvedPayload<'de> {
3512 pub(crate) table: ::fidl_next::wire::Table<'de>,
3513 }
3514
3515 impl<'de> Drop for UnresolvedPayload<'de> {
3516 fn drop(&mut self) {}
3517 }
3518
3519 impl ::fidl_next::Constrained for UnresolvedPayload<'_> {
3520 type Constraint = ();
3521
3522 fn validate(
3523 _: ::fidl_next::Slot<'_, Self>,
3524 _: Self::Constraint,
3525 ) -> Result<(), ::fidl_next::ValidationError> {
3526 Ok(())
3527 }
3528 }
3529
3530 unsafe impl ::fidl_next::Wire for UnresolvedPayload<'static> {
3531 type Narrowed<'de> = UnresolvedPayload<'de>;
3532
3533 #[inline]
3534 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3535 ::fidl_next::munge!(let Self { table } = out);
3536 ::fidl_next::wire::Table::zero_padding(table);
3537 }
3538 }
3539
3540 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnresolvedPayload<'de>
3541 where
3542 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3543 {
3544 fn decode(
3545 slot: ::fidl_next::Slot<'_, Self>,
3546 decoder: &mut ___D,
3547 _: (),
3548 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3549 ::fidl_next::munge!(let Self { table } = slot);
3550
3551 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3552 match ordinal {
3553 0 => unsafe { ::core::hint::unreachable_unchecked() },
3554
3555 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3556 }
3557 })
3558 }
3559 }
3560
3561 impl<'de> UnresolvedPayload<'de> {}
3562
3563 impl<'de> ::core::fmt::Debug for UnresolvedPayload<'de> {
3564 fn fmt(
3565 &self,
3566 f: &mut ::core::fmt::Formatter<'_>,
3567 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3568 f.debug_struct("UnresolvedPayload").finish()
3569 }
3570 }
3571
3572 impl<'de> ::fidl_next::IntoNatural for UnresolvedPayload<'de> {
3573 type Natural = crate::natural::UnresolvedPayload;
3574 }
3575
3576 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
3578 #[repr(transparent)]
3579 pub struct EventType {
3580 pub(crate) value: ::fidl_next::wire::Uint32,
3581 }
3582
3583 impl ::fidl_next::Constrained for EventType {
3584 type Constraint = ();
3585
3586 fn validate(
3587 _: ::fidl_next::Slot<'_, Self>,
3588 _: Self::Constraint,
3589 ) -> Result<(), ::fidl_next::ValidationError> {
3590 Ok(())
3591 }
3592 }
3593
3594 unsafe impl ::fidl_next::Wire for EventType {
3595 type Narrowed<'de> = Self;
3596
3597 #[inline]
3598 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
3599 }
3601 }
3602
3603 impl EventType {
3604 pub const CAPABILITY_REQUESTED: EventType =
3605 EventType { value: ::fidl_next::wire::Uint32(1) };
3606
3607 pub const DISCOVERED: EventType = EventType { value: ::fidl_next::wire::Uint32(3) };
3608
3609 pub const DESTROYED: EventType = EventType { value: ::fidl_next::wire::Uint32(4) };
3610
3611 pub const RESOLVED: EventType = EventType { value: ::fidl_next::wire::Uint32(5) };
3612
3613 pub const STARTED: EventType = EventType { value: ::fidl_next::wire::Uint32(6) };
3614
3615 pub const STOPPED: EventType = EventType { value: ::fidl_next::wire::Uint32(7) };
3616
3617 pub const DEBUG_STARTED: EventType = EventType { value: ::fidl_next::wire::Uint32(8) };
3618
3619 pub const UNRESOLVED: EventType = EventType { value: ::fidl_next::wire::Uint32(9) };
3620 }
3621
3622 unsafe impl<___D> ::fidl_next::Decode<___D> for EventType
3623 where
3624 ___D: ?Sized,
3625 {
3626 fn decode(
3627 slot: ::fidl_next::Slot<'_, Self>,
3628 _: &mut ___D,
3629 _: (),
3630 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3631 ::fidl_next::munge!(let Self { value } = slot);
3632
3633 match u32::from(*value) {
3634 1 | 3 | 4 | 5 | 6 | 7 | 8 | 9 => (),
3635 unknown => {
3636 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
3637 }
3638 }
3639
3640 Ok(())
3641 }
3642 }
3643
3644 impl ::core::convert::From<crate::natural::EventType> for EventType {
3645 fn from(natural: crate::natural::EventType) -> Self {
3646 match natural {
3647 crate::natural::EventType::CapabilityRequested => EventType::CAPABILITY_REQUESTED,
3648
3649 crate::natural::EventType::Discovered => EventType::DISCOVERED,
3650
3651 crate::natural::EventType::Destroyed => EventType::DESTROYED,
3652
3653 crate::natural::EventType::Resolved => EventType::RESOLVED,
3654
3655 crate::natural::EventType::Started => EventType::STARTED,
3656
3657 crate::natural::EventType::Stopped => EventType::STOPPED,
3658
3659 crate::natural::EventType::DebugStarted => EventType::DEBUG_STARTED,
3660
3661 crate::natural::EventType::Unresolved => EventType::UNRESOLVED,
3662 }
3663 }
3664 }
3665
3666 impl ::fidl_next::IntoNatural for EventType {
3667 type Natural = crate::natural::EventType;
3668 }
3669
3670 #[repr(C)]
3672 pub struct StoppedPayload<'de> {
3673 pub(crate) table: ::fidl_next::wire::Table<'de>,
3674 }
3675
3676 impl<'de> Drop for StoppedPayload<'de> {
3677 fn drop(&mut self) {
3678 let _ = self.table.get(1).map(|envelope| unsafe {
3679 envelope.read_unchecked::<::fidl_next::wire::fuchsia::StatusResult>()
3680 });
3681
3682 let _ = self
3683 .table
3684 .get(2)
3685 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Int64>() });
3686 }
3687 }
3688
3689 impl ::fidl_next::Constrained for StoppedPayload<'_> {
3690 type Constraint = ();
3691
3692 fn validate(
3693 _: ::fidl_next::Slot<'_, Self>,
3694 _: Self::Constraint,
3695 ) -> Result<(), ::fidl_next::ValidationError> {
3696 Ok(())
3697 }
3698 }
3699
3700 unsafe impl ::fidl_next::Wire for StoppedPayload<'static> {
3701 type Narrowed<'de> = StoppedPayload<'de>;
3702
3703 #[inline]
3704 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3705 ::fidl_next::munge!(let Self { table } = out);
3706 ::fidl_next::wire::Table::zero_padding(table);
3707 }
3708 }
3709
3710 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StoppedPayload<'de>
3711 where
3712 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3713 {
3714 fn decode(
3715 slot: ::fidl_next::Slot<'_, Self>,
3716 decoder: &mut ___D,
3717 _: (),
3718 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3719 ::fidl_next::munge!(let Self { table } = slot);
3720
3721 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3722 match ordinal {
3723 0 => unsafe { ::core::hint::unreachable_unchecked() },
3724
3725 1 => {
3726 ::fidl_next::wire::Envelope::decode_as::<
3727 ___D,
3728 ::fidl_next::wire::fuchsia::StatusResult,
3729 >(slot.as_mut(), decoder, ())?;
3730
3731 Ok(())
3732 }
3733
3734 2 => {
3735 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Int64>(
3736 slot.as_mut(),
3737 decoder,
3738 (),
3739 )?;
3740
3741 Ok(())
3742 }
3743
3744 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3745 }
3746 })
3747 }
3748 }
3749
3750 impl<'de> StoppedPayload<'de> {
3751 pub fn status(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::StatusResult> {
3752 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3753 }
3754
3755 pub fn take_status(
3756 &mut self,
3757 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::StatusResult> {
3758 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3759 }
3760
3761 pub fn exit_code(&self) -> ::core::option::Option<&::fidl_next::wire::Int64> {
3762 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3763 }
3764
3765 pub fn take_exit_code(&mut self) -> ::core::option::Option<::fidl_next::wire::Int64> {
3766 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3767 }
3768 }
3769
3770 impl<'de> ::core::fmt::Debug for StoppedPayload<'de> {
3771 fn fmt(
3772 &self,
3773 f: &mut ::core::fmt::Formatter<'_>,
3774 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3775 f.debug_struct("StoppedPayload")
3776 .field("status", &self.status())
3777 .field("exit_code", &self.exit_code())
3778 .finish()
3779 }
3780 }
3781
3782 impl<'de> ::fidl_next::IntoNatural for StoppedPayload<'de> {
3783 type Natural = crate::natural::StoppedPayload;
3784 }
3785
3786 #[repr(C)]
3788 pub struct EventHeader<'de> {
3789 pub(crate) table: ::fidl_next::wire::Table<'de>,
3790 }
3791
3792 impl<'de> Drop for EventHeader<'de> {
3793 fn drop(&mut self) {
3794 let _ = self
3795 .table
3796 .get(1)
3797 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::EventType>() });
3798
3799 let _ = self.table.get(2).map(|envelope| unsafe {
3800 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3801 });
3802
3803 let _ = self.table.get(3).map(|envelope| unsafe {
3804 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3805 });
3806
3807 let _ = self
3808 .table
3809 .get(4)
3810 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Int64>() });
3811 }
3812 }
3813
3814 impl ::fidl_next::Constrained for EventHeader<'_> {
3815 type Constraint = ();
3816
3817 fn validate(
3818 _: ::fidl_next::Slot<'_, Self>,
3819 _: Self::Constraint,
3820 ) -> Result<(), ::fidl_next::ValidationError> {
3821 Ok(())
3822 }
3823 }
3824
3825 unsafe impl ::fidl_next::Wire for EventHeader<'static> {
3826 type Narrowed<'de> = EventHeader<'de>;
3827
3828 #[inline]
3829 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3830 ::fidl_next::munge!(let Self { table } = out);
3831 ::fidl_next::wire::Table::zero_padding(table);
3832 }
3833 }
3834
3835 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventHeader<'de>
3836 where
3837 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3838 {
3839 fn decode(
3840 slot: ::fidl_next::Slot<'_, Self>,
3841 decoder: &mut ___D,
3842 _: (),
3843 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3844 ::fidl_next::munge!(let Self { table } = slot);
3845
3846 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3847 match ordinal {
3848 0 => unsafe { ::core::hint::unreachable_unchecked() },
3849
3850 1 => {
3851 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::EventType>(
3852 slot.as_mut(),
3853 decoder,
3854 (),
3855 )?;
3856
3857 Ok(())
3858 }
3859
3860 2 => {
3861 ::fidl_next::wire::Envelope::decode_as::<
3862 ___D,
3863 ::fidl_next::wire::String<'de>,
3864 >(slot.as_mut(), decoder, 4096)?;
3865
3866 let value = unsafe {
3867 slot.deref_unchecked()
3868 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3869 };
3870
3871 if value.len() > 4096 {
3872 return Err(::fidl_next::DecodeError::VectorTooLong {
3873 size: value.len() as u64,
3874 limit: 4096,
3875 });
3876 }
3877
3878 Ok(())
3879 }
3880
3881 3 => {
3882 ::fidl_next::wire::Envelope::decode_as::<
3883 ___D,
3884 ::fidl_next::wire::String<'de>,
3885 >(slot.as_mut(), decoder, 4096)?;
3886
3887 let value = unsafe {
3888 slot.deref_unchecked()
3889 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3890 };
3891
3892 if value.len() > 4096 {
3893 return Err(::fidl_next::DecodeError::VectorTooLong {
3894 size: value.len() as u64,
3895 limit: 4096,
3896 });
3897 }
3898
3899 Ok(())
3900 }
3901
3902 4 => {
3903 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Int64>(
3904 slot.as_mut(),
3905 decoder,
3906 (),
3907 )?;
3908
3909 Ok(())
3910 }
3911
3912 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3913 }
3914 })
3915 }
3916 }
3917
3918 impl<'de> EventHeader<'de> {
3919 pub fn event_type(&self) -> ::core::option::Option<&crate::wire::EventType> {
3920 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3921 }
3922
3923 pub fn take_event_type(&mut self) -> ::core::option::Option<crate::wire::EventType> {
3924 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3925 }
3926
3927 pub fn moniker(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3928 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3929 }
3930
3931 pub fn take_moniker(&mut self) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
3932 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3933 }
3934
3935 pub fn component_url(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3936 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3937 }
3938
3939 pub fn take_component_url(
3940 &mut self,
3941 ) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
3942 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
3943 }
3944
3945 pub fn timestamp(&self) -> ::core::option::Option<&::fidl_next::wire::Int64> {
3946 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3947 }
3948
3949 pub fn take_timestamp(&mut self) -> ::core::option::Option<::fidl_next::wire::Int64> {
3950 unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
3951 }
3952 }
3953
3954 impl<'de> ::core::fmt::Debug for EventHeader<'de> {
3955 fn fmt(
3956 &self,
3957 f: &mut ::core::fmt::Formatter<'_>,
3958 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3959 f.debug_struct("EventHeader")
3960 .field("event_type", &self.event_type())
3961 .field("moniker", &self.moniker())
3962 .field("component_url", &self.component_url())
3963 .field("timestamp", &self.timestamp())
3964 .finish()
3965 }
3966 }
3967
3968 impl<'de> ::fidl_next::IntoNatural for EventHeader<'de> {
3969 type Natural = crate::natural::EventHeader;
3970 }
3971
3972 #[derive(Debug)]
3974 #[repr(C)]
3975 pub struct ExecutionControllerOnStopRequest<'de> {
3976 pub stopped_payload: crate::wire::StoppedPayload<'de>,
3977 }
3978
3979 static_assertions::const_assert_eq!(
3980 std::mem::size_of::<ExecutionControllerOnStopRequest<'_>>(),
3981 16
3982 );
3983 static_assertions::const_assert_eq!(
3984 std::mem::align_of::<ExecutionControllerOnStopRequest<'_>>(),
3985 8
3986 );
3987
3988 static_assertions::const_assert_eq!(
3989 std::mem::offset_of!(ExecutionControllerOnStopRequest<'_>, stopped_payload),
3990 0
3991 );
3992
3993 impl ::fidl_next::Constrained for ExecutionControllerOnStopRequest<'_> {
3994 type Constraint = ();
3995
3996 fn validate(
3997 _: ::fidl_next::Slot<'_, Self>,
3998 _: Self::Constraint,
3999 ) -> Result<(), ::fidl_next::ValidationError> {
4000 Ok(())
4001 }
4002 }
4003
4004 unsafe impl ::fidl_next::Wire for ExecutionControllerOnStopRequest<'static> {
4005 type Narrowed<'de> = ExecutionControllerOnStopRequest<'de>;
4006
4007 #[inline]
4008 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4009 ::fidl_next::munge! {
4010 let Self {
4011 stopped_payload,
4012
4013 } = &mut *out_;
4014 }
4015
4016 ::fidl_next::Wire::zero_padding(stopped_payload);
4017 }
4018 }
4019
4020 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExecutionControllerOnStopRequest<'de>
4021 where
4022 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4023 ___D: ::fidl_next::Decoder<'de>,
4024 {
4025 fn decode(
4026 slot_: ::fidl_next::Slot<'_, Self>,
4027 decoder_: &mut ___D,
4028 _: (),
4029 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4030 ::fidl_next::munge! {
4031 let Self {
4032 mut stopped_payload,
4033
4034 } = slot_;
4035 }
4036
4037 let _field = stopped_payload.as_mut();
4038
4039 ::fidl_next::Decode::decode(stopped_payload.as_mut(), decoder_, ())?;
4040
4041 Ok(())
4042 }
4043 }
4044
4045 impl<'de> ::fidl_next::IntoNatural for ExecutionControllerOnStopRequest<'de> {
4046 type Natural = crate::natural::ExecutionControllerOnStopRequest;
4047 }
4048
4049 #[derive(Debug)]
4051 #[repr(C)]
4052 pub struct IntrospectorGetMonikerResponse<'de> {
4053 pub moniker: ::fidl_next::wire::String<'de>,
4054 }
4055
4056 static_assertions::const_assert_eq!(
4057 std::mem::size_of::<IntrospectorGetMonikerResponse<'_>>(),
4058 16
4059 );
4060 static_assertions::const_assert_eq!(
4061 std::mem::align_of::<IntrospectorGetMonikerResponse<'_>>(),
4062 8
4063 );
4064
4065 static_assertions::const_assert_eq!(
4066 std::mem::offset_of!(IntrospectorGetMonikerResponse<'_>, moniker),
4067 0
4068 );
4069
4070 impl ::fidl_next::Constrained for IntrospectorGetMonikerResponse<'_> {
4071 type Constraint = ();
4072
4073 fn validate(
4074 _: ::fidl_next::Slot<'_, Self>,
4075 _: Self::Constraint,
4076 ) -> Result<(), ::fidl_next::ValidationError> {
4077 Ok(())
4078 }
4079 }
4080
4081 unsafe impl ::fidl_next::Wire for IntrospectorGetMonikerResponse<'static> {
4082 type Narrowed<'de> = IntrospectorGetMonikerResponse<'de>;
4083
4084 #[inline]
4085 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4086 ::fidl_next::munge! {
4087 let Self {
4088 moniker,
4089
4090 } = &mut *out_;
4091 }
4092
4093 ::fidl_next::Wire::zero_padding(moniker);
4094 }
4095 }
4096
4097 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for IntrospectorGetMonikerResponse<'de>
4098 where
4099 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4100 ___D: ::fidl_next::Decoder<'de>,
4101 {
4102 fn decode(
4103 slot_: ::fidl_next::Slot<'_, Self>,
4104 decoder_: &mut ___D,
4105 _: (),
4106 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4107 ::fidl_next::munge! {
4108 let Self {
4109 mut moniker,
4110
4111 } = slot_;
4112 }
4113
4114 let _field = moniker.as_mut();
4115 ::fidl_next::Constrained::validate(_field, 4096)?;
4116 ::fidl_next::Decode::decode(moniker.as_mut(), decoder_, 4096)?;
4117
4118 let moniker = unsafe { moniker.deref_unchecked() };
4119
4120 if moniker.len() > 4096 {
4121 return Err(::fidl_next::DecodeError::VectorTooLong {
4122 size: moniker.len() as u64,
4123 limit: 4096,
4124 });
4125 }
4126
4127 Ok(())
4128 }
4129 }
4130
4131 impl<'de> ::fidl_next::IntoNatural for IntrospectorGetMonikerResponse<'de> {
4132 type Natural = crate::natural::IntrospectorGetMonikerResponse;
4133 }
4134
4135 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4137 #[repr(transparent)]
4138 pub struct NamespaceError {
4139 pub(crate) value: ::fidl_next::wire::Uint32,
4140 }
4141
4142 impl ::fidl_next::Constrained for NamespaceError {
4143 type Constraint = ();
4144
4145 fn validate(
4146 _: ::fidl_next::Slot<'_, Self>,
4147 _: Self::Constraint,
4148 ) -> Result<(), ::fidl_next::ValidationError> {
4149 Ok(())
4150 }
4151 }
4152
4153 unsafe impl ::fidl_next::Wire for NamespaceError {
4154 type Narrowed<'de> = Self;
4155
4156 #[inline]
4157 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4158 }
4160 }
4161
4162 impl NamespaceError {
4163 pub const SHADOW: NamespaceError = NamespaceError { value: ::fidl_next::wire::Uint32(1) };
4164
4165 pub const DUPLICATE: NamespaceError =
4166 NamespaceError { value: ::fidl_next::wire::Uint32(2) };
4167
4168 pub const CONVERSION: NamespaceError =
4169 NamespaceError { value: ::fidl_next::wire::Uint32(3) };
4170
4171 pub const BAD_ENTRY: NamespaceError =
4172 NamespaceError { value: ::fidl_next::wire::Uint32(4) };
4173
4174 pub const DICTIONARY_READ: NamespaceError =
4175 NamespaceError { value: ::fidl_next::wire::Uint32(5) };
4176 }
4177
4178 unsafe impl<___D> ::fidl_next::Decode<___D> for NamespaceError
4179 where
4180 ___D: ?Sized,
4181 {
4182 fn decode(
4183 slot: ::fidl_next::Slot<'_, Self>,
4184 _: &mut ___D,
4185 _: (),
4186 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4187 Ok(())
4188 }
4189 }
4190
4191 impl ::core::convert::From<crate::natural::NamespaceError> for NamespaceError {
4192 fn from(natural: crate::natural::NamespaceError) -> Self {
4193 match natural {
4194 crate::natural::NamespaceError::Shadow => NamespaceError::SHADOW,
4195
4196 crate::natural::NamespaceError::Duplicate => NamespaceError::DUPLICATE,
4197
4198 crate::natural::NamespaceError::Conversion => NamespaceError::CONVERSION,
4199
4200 crate::natural::NamespaceError::BadEntry => NamespaceError::BAD_ENTRY,
4201
4202 crate::natural::NamespaceError::DictionaryRead => NamespaceError::DICTIONARY_READ,
4203
4204 crate::natural::NamespaceError::UnknownOrdinal_(value) => {
4205 NamespaceError { value: ::fidl_next::wire::Uint32::from(value) }
4206 }
4207 }
4208 }
4209 }
4210
4211 impl ::fidl_next::IntoNatural for NamespaceError {
4212 type Natural = crate::natural::NamespaceError;
4213 }
4214
4215 pub type RealmOpenExposedDirResponse = ::fidl_next::wire::Unit;
4217
4218 pub type RealmCreateChildResponse = ::fidl_next::wire::Unit;
4220
4221 #[derive(Debug)]
4223 #[repr(C)]
4224 pub struct RealmDestroyChildRequest<'de> {
4225 pub child: ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'de>,
4226 }
4227
4228 static_assertions::const_assert_eq!(std::mem::size_of::<RealmDestroyChildRequest<'_>>(), 32);
4229 static_assertions::const_assert_eq!(std::mem::align_of::<RealmDestroyChildRequest<'_>>(), 8);
4230
4231 static_assertions::const_assert_eq!(
4232 std::mem::offset_of!(RealmDestroyChildRequest<'_>, child),
4233 0
4234 );
4235
4236 impl ::fidl_next::Constrained for RealmDestroyChildRequest<'_> {
4237 type Constraint = ();
4238
4239 fn validate(
4240 _: ::fidl_next::Slot<'_, Self>,
4241 _: Self::Constraint,
4242 ) -> Result<(), ::fidl_next::ValidationError> {
4243 Ok(())
4244 }
4245 }
4246
4247 unsafe impl ::fidl_next::Wire for RealmDestroyChildRequest<'static> {
4248 type Narrowed<'de> = RealmDestroyChildRequest<'de>;
4249
4250 #[inline]
4251 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4252 ::fidl_next::munge! {
4253 let Self {
4254 child,
4255
4256 } = &mut *out_;
4257 }
4258
4259 ::fidl_next::Wire::zero_padding(child);
4260 }
4261 }
4262
4263 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmDestroyChildRequest<'de>
4264 where
4265 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4266 ___D: ::fidl_next::Decoder<'de>,
4267 {
4268 fn decode(
4269 slot_: ::fidl_next::Slot<'_, Self>,
4270 decoder_: &mut ___D,
4271 _: (),
4272 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4273 ::fidl_next::munge! {
4274 let Self {
4275 mut child,
4276
4277 } = slot_;
4278 }
4279
4280 let _field = child.as_mut();
4281
4282 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
4283
4284 Ok(())
4285 }
4286 }
4287
4288 impl<'de> ::fidl_next::IntoNatural for RealmDestroyChildRequest<'de> {
4289 type Natural = crate::natural::RealmDestroyChildRequest;
4290 }
4291
4292 pub type RealmDestroyChildResponse = ::fidl_next::wire::Unit;
4294
4295 pub type RealmListChildrenResponse = ::fidl_next::wire::Unit;
4297
4298 pub type RealmOpenControllerResponse = ::fidl_next::wire::Unit;
4300
4301 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4303 #[repr(transparent)]
4304 pub struct StatusError {
4305 pub(crate) value: ::fidl_next::wire::Uint32,
4306 }
4307
4308 impl ::fidl_next::Constrained for StatusError {
4309 type Constraint = ();
4310
4311 fn validate(
4312 _: ::fidl_next::Slot<'_, Self>,
4313 _: Self::Constraint,
4314 ) -> Result<(), ::fidl_next::ValidationError> {
4315 Ok(())
4316 }
4317 }
4318
4319 unsafe impl ::fidl_next::Wire for StatusError {
4320 type Narrowed<'de> = Self;
4321
4322 #[inline]
4323 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4324 }
4326 }
4327
4328 impl StatusError {
4329 pub const PROVIDER: StatusError = StatusError { value: ::fidl_next::wire::Uint32(1) };
4330
4331 pub const RESPONSE_INVALID: StatusError =
4332 StatusError { value: ::fidl_next::wire::Uint32(2) };
4333
4334 pub const STATUS_UNKNOWN: StatusError = StatusError { value: ::fidl_next::wire::Uint32(3) };
4335
4336 pub const UNSUPPORTED: StatusError = StatusError { value: ::fidl_next::wire::Uint32(4) };
4337 }
4338
4339 unsafe impl<___D> ::fidl_next::Decode<___D> for StatusError
4340 where
4341 ___D: ?Sized,
4342 {
4343 fn decode(
4344 slot: ::fidl_next::Slot<'_, Self>,
4345 _: &mut ___D,
4346 _: (),
4347 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4348 ::fidl_next::munge!(let Self { value } = slot);
4349
4350 match u32::from(*value) {
4351 1 | 2 | 3 | 4 => (),
4352 unknown => {
4353 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
4354 }
4355 }
4356
4357 Ok(())
4358 }
4359 }
4360
4361 impl ::core::convert::From<crate::natural::StatusError> for StatusError {
4362 fn from(natural: crate::natural::StatusError) -> Self {
4363 match natural {
4364 crate::natural::StatusError::Provider => StatusError::PROVIDER,
4365
4366 crate::natural::StatusError::ResponseInvalid => StatusError::RESPONSE_INVALID,
4367
4368 crate::natural::StatusError::StatusUnknown => StatusError::STATUS_UNKNOWN,
4369
4370 crate::natural::StatusError::Unsupported => StatusError::UNSUPPORTED,
4371 }
4372 }
4373 }
4374
4375 impl ::fidl_next::IntoNatural for StatusError {
4376 type Natural = crate::natural::StatusError;
4377 }
4378
4379 pub type StorageAdminOpenStorageResponse = ::fidl_next::wire::Unit;
4381
4382 pub type StorageAdminListStorageInRealmResponse = ::fidl_next::wire::Unit;
4384
4385 pub type StorageAdminOpenComponentStorageByIdResponse = ::fidl_next::wire::Unit;
4387
4388 #[derive(Debug)]
4390 #[repr(C)]
4391 pub struct StorageAdminDeleteComponentStorageRequest<'de> {
4392 pub relative_moniker: ::fidl_next::wire::String<'de>,
4393 }
4394
4395 static_assertions::const_assert_eq!(
4396 std::mem::size_of::<StorageAdminDeleteComponentStorageRequest<'_>>(),
4397 16
4398 );
4399 static_assertions::const_assert_eq!(
4400 std::mem::align_of::<StorageAdminDeleteComponentStorageRequest<'_>>(),
4401 8
4402 );
4403
4404 static_assertions::const_assert_eq!(
4405 std::mem::offset_of!(StorageAdminDeleteComponentStorageRequest<'_>, relative_moniker),
4406 0
4407 );
4408
4409 impl ::fidl_next::Constrained for StorageAdminDeleteComponentStorageRequest<'_> {
4410 type Constraint = ();
4411
4412 fn validate(
4413 _: ::fidl_next::Slot<'_, Self>,
4414 _: Self::Constraint,
4415 ) -> Result<(), ::fidl_next::ValidationError> {
4416 Ok(())
4417 }
4418 }
4419
4420 unsafe impl ::fidl_next::Wire for StorageAdminDeleteComponentStorageRequest<'static> {
4421 type Narrowed<'de> = StorageAdminDeleteComponentStorageRequest<'de>;
4422
4423 #[inline]
4424 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4425 ::fidl_next::munge! {
4426 let Self {
4427 relative_moniker,
4428
4429 } = &mut *out_;
4430 }
4431
4432 ::fidl_next::Wire::zero_padding(relative_moniker);
4433 }
4434 }
4435
4436 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminDeleteComponentStorageRequest<'de>
4437 where
4438 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4439 ___D: ::fidl_next::Decoder<'de>,
4440 {
4441 fn decode(
4442 slot_: ::fidl_next::Slot<'_, Self>,
4443 decoder_: &mut ___D,
4444 _: (),
4445 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4446 ::fidl_next::munge! {
4447 let Self {
4448 mut relative_moniker,
4449
4450 } = slot_;
4451 }
4452
4453 let _field = relative_moniker.as_mut();
4454 ::fidl_next::Constrained::validate(_field, 4096)?;
4455 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
4456
4457 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
4458
4459 if relative_moniker.len() > 4096 {
4460 return Err(::fidl_next::DecodeError::VectorTooLong {
4461 size: relative_moniker.len() as u64,
4462 limit: 4096,
4463 });
4464 }
4465
4466 Ok(())
4467 }
4468 }
4469
4470 impl<'de> ::fidl_next::IntoNatural for StorageAdminDeleteComponentStorageRequest<'de> {
4471 type Natural = crate::natural::StorageAdminDeleteComponentStorageRequest;
4472 }
4473
4474 pub type StorageAdminDeleteComponentStorageResponse = ::fidl_next::wire::Unit;
4476
4477 #[repr(C)]
4479 pub struct StorageStatus<'de> {
4480 pub(crate) table: ::fidl_next::wire::Table<'de>,
4481 }
4482
4483 impl<'de> Drop for StorageStatus<'de> {
4484 fn drop(&mut self) {
4485 let _ = self
4486 .table
4487 .get(1)
4488 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
4489
4490 let _ = self
4491 .table
4492 .get(2)
4493 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
4494 }
4495 }
4496
4497 impl ::fidl_next::Constrained for StorageStatus<'_> {
4498 type Constraint = ();
4499
4500 fn validate(
4501 _: ::fidl_next::Slot<'_, Self>,
4502 _: Self::Constraint,
4503 ) -> Result<(), ::fidl_next::ValidationError> {
4504 Ok(())
4505 }
4506 }
4507
4508 unsafe impl ::fidl_next::Wire for StorageStatus<'static> {
4509 type Narrowed<'de> = StorageStatus<'de>;
4510
4511 #[inline]
4512 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4513 ::fidl_next::munge!(let Self { table } = out);
4514 ::fidl_next::wire::Table::zero_padding(table);
4515 }
4516 }
4517
4518 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageStatus<'de>
4519 where
4520 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4521 {
4522 fn decode(
4523 slot: ::fidl_next::Slot<'_, Self>,
4524 decoder: &mut ___D,
4525 _: (),
4526 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4527 ::fidl_next::munge!(let Self { table } = slot);
4528
4529 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4530 match ordinal {
4531 0 => unsafe { ::core::hint::unreachable_unchecked() },
4532
4533 1 => {
4534 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
4535 slot.as_mut(),
4536 decoder,
4537 (),
4538 )?;
4539
4540 Ok(())
4541 }
4542
4543 2 => {
4544 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
4545 slot.as_mut(),
4546 decoder,
4547 (),
4548 )?;
4549
4550 Ok(())
4551 }
4552
4553 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4554 }
4555 })
4556 }
4557 }
4558
4559 impl<'de> StorageStatus<'de> {
4560 pub fn total_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
4561 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4562 }
4563
4564 pub fn take_total_size(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
4565 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
4566 }
4567
4568 pub fn used_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
4569 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4570 }
4571
4572 pub fn take_used_size(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
4573 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
4574 }
4575 }
4576
4577 impl<'de> ::core::fmt::Debug for StorageStatus<'de> {
4578 fn fmt(
4579 &self,
4580 f: &mut ::core::fmt::Formatter<'_>,
4581 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4582 f.debug_struct("StorageStatus")
4583 .field("total_size", &self.total_size())
4584 .field("used_size", &self.used_size())
4585 .finish()
4586 }
4587 }
4588
4589 impl<'de> ::fidl_next::IntoNatural for StorageStatus<'de> {
4590 type Natural = crate::natural::StorageStatus;
4591 }
4592
4593 pub type StorageAdminDeleteAllStorageContentsResponse = ::fidl_next::wire::Unit;
4595
4596 #[derive(Debug)]
4598 #[repr(C)]
4599 pub struct StorageIteratorNextResponse<'de> {
4600 pub relative_monikers: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
4601 }
4602
4603 static_assertions::const_assert_eq!(std::mem::size_of::<StorageIteratorNextResponse<'_>>(), 16);
4604 static_assertions::const_assert_eq!(std::mem::align_of::<StorageIteratorNextResponse<'_>>(), 8);
4605
4606 static_assertions::const_assert_eq!(
4607 std::mem::offset_of!(StorageIteratorNextResponse<'_>, relative_monikers),
4608 0
4609 );
4610
4611 impl ::fidl_next::Constrained for StorageIteratorNextResponse<'_> {
4612 type Constraint = ();
4613
4614 fn validate(
4615 _: ::fidl_next::Slot<'_, Self>,
4616 _: Self::Constraint,
4617 ) -> Result<(), ::fidl_next::ValidationError> {
4618 Ok(())
4619 }
4620 }
4621
4622 unsafe impl ::fidl_next::Wire for StorageIteratorNextResponse<'static> {
4623 type Narrowed<'de> = StorageIteratorNextResponse<'de>;
4624
4625 #[inline]
4626 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4627 ::fidl_next::munge! {
4628 let Self {
4629 relative_monikers,
4630
4631 } = &mut *out_;
4632 }
4633
4634 ::fidl_next::Wire::zero_padding(relative_monikers);
4635 }
4636 }
4637
4638 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageIteratorNextResponse<'de>
4639 where
4640 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4641 ___D: ::fidl_next::Decoder<'de>,
4642 {
4643 fn decode(
4644 slot_: ::fidl_next::Slot<'_, Self>,
4645 decoder_: &mut ___D,
4646 _: (),
4647 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4648 ::fidl_next::munge! {
4649 let Self {
4650 mut relative_monikers,
4651
4652 } = slot_;
4653 }
4654
4655 let _field = relative_monikers.as_mut();
4656 ::fidl_next::Constrained::validate(_field, (4294967295, 4096))?;
4657 ::fidl_next::Decode::decode(relative_monikers.as_mut(), decoder_, (4294967295, 4096))?;
4658
4659 Ok(())
4660 }
4661 }
4662
4663 impl<'de> ::fidl_next::IntoNatural for StorageIteratorNextResponse<'de> {
4664 type Natural = crate::natural::StorageIteratorNextResponse;
4665 }
4666
4667 pub type ChildName<'de> = ::fidl_next::wire::String<'de>;
4669
4670 pub type UrlScheme<'de> = ::fidl_next::wire::String<'de>;
4672}
4673
4674pub mod wire_optional {}
4675
4676pub mod generic {
4677
4678 pub struct ChildIteratorNextResponse<T0> {
4680 pub children: T0,
4681 }
4682
4683 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>
4684 for ChildIteratorNextResponse<T0>
4685 where
4686 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4687 ___E: ::fidl_next::Encoder,
4688 T0: ::fidl_next::Encode<
4689 ::fidl_next::wire::Vector<
4690 'static,
4691 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'static>,
4692 >,
4693 ___E,
4694 >,
4695 {
4696 #[inline]
4697 fn encode(
4698 self,
4699 encoder_: &mut ___E,
4700 out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildIteratorNextResponse<'static>>,
4701 _: (),
4702 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4703 ::fidl_next::munge! {
4704 let crate::wire::ChildIteratorNextResponse {
4705 children,
4706
4707 } = out_;
4708 }
4709
4710 ::fidl_next::Encode::encode(self.children, encoder_, children, (128, ()))?;
4711
4712 Ok(())
4713 }
4714 }
4715
4716 unsafe impl<'a, ___E, T0>
4717 ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>
4718 for &'a ChildIteratorNextResponse<T0>
4719 where
4720 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4721 ___E: ::fidl_next::Encoder,
4722 &'a T0: ::fidl_next::Encode<
4723 ::fidl_next::wire::Vector<
4724 'static,
4725 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'static>,
4726 >,
4727 ___E,
4728 >,
4729 {
4730 #[inline]
4731 fn encode(
4732 self,
4733 encoder_: &mut ___E,
4734 out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildIteratorNextResponse<'static>>,
4735 _: (),
4736 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4737 ::fidl_next::munge! {
4738 let crate::wire::ChildIteratorNextResponse {
4739 children,
4740
4741 } = out_;
4742 }
4743
4744 ::fidl_next::Encode::encode(&self.children, encoder_, children, (128, ()))?;
4745
4746 Ok(())
4747 }
4748 }
4749
4750 pub type ControllerStartResponse = ();
4752
4753 pub type ControllerOpenExposedDirResponse = ();
4755
4756 pub type ControllerDestroyResponse = ();
4758
4759 pub struct ExecutionControllerOnStopRequest<T0> {
4761 pub stopped_payload: T0,
4762 }
4763
4764 unsafe impl<___E, T0>
4765 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
4766 for ExecutionControllerOnStopRequest<T0>
4767 where
4768 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4769 ___E: ::fidl_next::Encoder,
4770 T0: ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E>,
4771 {
4772 #[inline]
4773 fn encode(
4774 self,
4775 encoder_: &mut ___E,
4776 out_: &mut ::core::mem::MaybeUninit<
4777 crate::wire::ExecutionControllerOnStopRequest<'static>,
4778 >,
4779 _: (),
4780 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4781 ::fidl_next::munge! {
4782 let crate::wire::ExecutionControllerOnStopRequest {
4783 stopped_payload,
4784
4785 } = out_;
4786 }
4787
4788 ::fidl_next::Encode::encode(self.stopped_payload, encoder_, stopped_payload, ())?;
4789
4790 Ok(())
4791 }
4792 }
4793
4794 unsafe impl<'a, ___E, T0>
4795 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
4796 for &'a ExecutionControllerOnStopRequest<T0>
4797 where
4798 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4799 ___E: ::fidl_next::Encoder,
4800 &'a T0: ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E>,
4801 {
4802 #[inline]
4803 fn encode(
4804 self,
4805 encoder_: &mut ___E,
4806 out_: &mut ::core::mem::MaybeUninit<
4807 crate::wire::ExecutionControllerOnStopRequest<'static>,
4808 >,
4809 _: (),
4810 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4811 ::fidl_next::munge! {
4812 let crate::wire::ExecutionControllerOnStopRequest {
4813 stopped_payload,
4814
4815 } = out_;
4816 }
4817
4818 ::fidl_next::Encode::encode(&self.stopped_payload, encoder_, stopped_payload, ())?;
4819
4820 Ok(())
4821 }
4822 }
4823
4824 pub struct IntrospectorGetMonikerResponse<T0> {
4826 pub moniker: T0,
4827 }
4828
4829 unsafe impl<___E, T0>
4830 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
4831 for IntrospectorGetMonikerResponse<T0>
4832 where
4833 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4834 ___E: ::fidl_next::Encoder,
4835 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4836 {
4837 #[inline]
4838 fn encode(
4839 self,
4840 encoder_: &mut ___E,
4841 out_: &mut ::core::mem::MaybeUninit<
4842 crate::wire::IntrospectorGetMonikerResponse<'static>,
4843 >,
4844 _: (),
4845 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4846 ::fidl_next::munge! {
4847 let crate::wire::IntrospectorGetMonikerResponse {
4848 moniker,
4849
4850 } = out_;
4851 }
4852
4853 ::fidl_next::Encode::encode(self.moniker, encoder_, moniker, 4096)?;
4854
4855 Ok(())
4856 }
4857 }
4858
4859 unsafe impl<'a, ___E, T0>
4860 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
4861 for &'a IntrospectorGetMonikerResponse<T0>
4862 where
4863 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4864 ___E: ::fidl_next::Encoder,
4865 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4866 {
4867 #[inline]
4868 fn encode(
4869 self,
4870 encoder_: &mut ___E,
4871 out_: &mut ::core::mem::MaybeUninit<
4872 crate::wire::IntrospectorGetMonikerResponse<'static>,
4873 >,
4874 _: (),
4875 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4876 ::fidl_next::munge! {
4877 let crate::wire::IntrospectorGetMonikerResponse {
4878 moniker,
4879
4880 } = out_;
4881 }
4882
4883 ::fidl_next::Encode::encode(&self.moniker, encoder_, moniker, 4096)?;
4884
4885 Ok(())
4886 }
4887 }
4888
4889 pub type RealmOpenExposedDirResponse = ();
4891
4892 pub type RealmCreateChildResponse = ();
4894
4895 pub struct RealmDestroyChildRequest<T0> {
4897 pub child: T0,
4898 }
4899
4900 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
4901 for RealmDestroyChildRequest<T0>
4902 where
4903 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4904 ___E: ::fidl_next::Encoder,
4905 T0: ::fidl_next::Encode<
4906 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'static>,
4907 ___E,
4908 >,
4909 {
4910 #[inline]
4911 fn encode(
4912 self,
4913 encoder_: &mut ___E,
4914 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
4915 _: (),
4916 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4917 ::fidl_next::munge! {
4918 let crate::wire::RealmDestroyChildRequest {
4919 child,
4920
4921 } = out_;
4922 }
4923
4924 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
4925
4926 Ok(())
4927 }
4928 }
4929
4930 unsafe impl<'a, ___E, T0>
4931 ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
4932 for &'a RealmDestroyChildRequest<T0>
4933 where
4934 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4935 ___E: ::fidl_next::Encoder,
4936 &'a T0: ::fidl_next::Encode<
4937 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'static>,
4938 ___E,
4939 >,
4940 {
4941 #[inline]
4942 fn encode(
4943 self,
4944 encoder_: &mut ___E,
4945 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
4946 _: (),
4947 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4948 ::fidl_next::munge! {
4949 let crate::wire::RealmDestroyChildRequest {
4950 child,
4951
4952 } = out_;
4953 }
4954
4955 ::fidl_next::Encode::encode(&self.child, encoder_, child, ())?;
4956
4957 Ok(())
4958 }
4959 }
4960
4961 pub type RealmDestroyChildResponse = ();
4963
4964 pub type RealmListChildrenResponse = ();
4966
4967 pub type RealmOpenControllerResponse = ();
4969
4970 pub type StorageAdminOpenStorageResponse = ();
4972
4973 pub type StorageAdminListStorageInRealmResponse = ();
4975
4976 pub type StorageAdminOpenComponentStorageByIdResponse = ();
4978
4979 pub struct StorageAdminDeleteComponentStorageRequest<T0> {
4981 pub relative_moniker: T0,
4982 }
4983
4984 unsafe impl<___E, T0>
4985 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
4986 for StorageAdminDeleteComponentStorageRequest<T0>
4987 where
4988 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4989 ___E: ::fidl_next::Encoder,
4990 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4991 {
4992 #[inline]
4993 fn encode(
4994 self,
4995 encoder_: &mut ___E,
4996 out_: &mut ::core::mem::MaybeUninit<
4997 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
4998 >,
4999 _: (),
5000 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5001 ::fidl_next::munge! {
5002 let crate::wire::StorageAdminDeleteComponentStorageRequest {
5003 relative_moniker,
5004
5005 } = out_;
5006 }
5007
5008 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
5009
5010 Ok(())
5011 }
5012 }
5013
5014 unsafe impl<'a, ___E, T0>
5015 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
5016 for &'a StorageAdminDeleteComponentStorageRequest<T0>
5017 where
5018 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5019 ___E: ::fidl_next::Encoder,
5020 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5021 {
5022 #[inline]
5023 fn encode(
5024 self,
5025 encoder_: &mut ___E,
5026 out_: &mut ::core::mem::MaybeUninit<
5027 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
5028 >,
5029 _: (),
5030 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5031 ::fidl_next::munge! {
5032 let crate::wire::StorageAdminDeleteComponentStorageRequest {
5033 relative_moniker,
5034
5035 } = out_;
5036 }
5037
5038 ::fidl_next::Encode::encode(&self.relative_moniker, encoder_, relative_moniker, 4096)?;
5039
5040 Ok(())
5041 }
5042 }
5043
5044 pub type StorageAdminDeleteComponentStorageResponse = ();
5046
5047 pub type StorageAdminDeleteAllStorageContentsResponse = ();
5049
5050 pub struct StorageIteratorNextResponse<T0> {
5052 pub relative_monikers: T0,
5053 }
5054
5055 unsafe impl<___E, T0>
5056 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
5057 for StorageIteratorNextResponse<T0>
5058 where
5059 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5060 ___E: ::fidl_next::Encoder,
5061 T0: ::fidl_next::Encode<
5062 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
5063 ___E,
5064 >,
5065 {
5066 #[inline]
5067 fn encode(
5068 self,
5069 encoder_: &mut ___E,
5070 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
5071 _: (),
5072 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5073 ::fidl_next::munge! {
5074 let crate::wire::StorageIteratorNextResponse {
5075 relative_monikers,
5076
5077 } = out_;
5078 }
5079
5080 ::fidl_next::Encode::encode(
5081 self.relative_monikers,
5082 encoder_,
5083 relative_monikers,
5084 (4294967295, 4096),
5085 )?;
5086
5087 Ok(())
5088 }
5089 }
5090
5091 unsafe impl<'a, ___E, T0>
5092 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
5093 for &'a StorageIteratorNextResponse<T0>
5094 where
5095 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5096 ___E: ::fidl_next::Encoder,
5097 &'a T0: ::fidl_next::Encode<
5098 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
5099 ___E,
5100 >,
5101 {
5102 #[inline]
5103 fn encode(
5104 self,
5105 encoder_: &mut ___E,
5106 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
5107 _: (),
5108 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5109 ::fidl_next::munge! {
5110 let crate::wire::StorageIteratorNextResponse {
5111 relative_monikers,
5112
5113 } = out_;
5114 }
5115
5116 ::fidl_next::Encode::encode(
5117 &self.relative_monikers,
5118 encoder_,
5119 relative_monikers,
5120 (4294967295, 4096),
5121 )?;
5122
5123 Ok(())
5124 }
5125 }
5126}
5127
5128pub use self::natural::*;
5129
5130#[doc = " A framework-provided protocol that allows components that use it to bind to\n the component that exposes it. The act of connecting to this protocol will\n trigger the bind. Thus, this protocol contains no methods. For more details\n on binding, see\n https://fuchsia.dev/fuchsia-src/concepts/components/v2/lifecycle#binding.\n\n When a component connects to protocol, the component exposing this capability\n will be started if it\'s not already running. Upon a failure to start, the\n component framework will close the server end of the channel with a\n zx.Status epitaph.\n"]
5132#[derive(PartialEq, Debug)]
5133pub struct Binder;
5134
5135impl ::fidl_next::Discoverable for Binder {
5136 const PROTOCOL_NAME: &'static str = "fuchsia.component.Binder";
5137}
5138
5139#[cfg(target_os = "fuchsia")]
5140impl ::fidl_next::HasTransport for Binder {
5141 type Transport = ::fidl_next::fuchsia::zx::Channel;
5142}
5143
5144pub mod binder {
5145 pub mod prelude {
5146 pub use crate::{
5147 Binder, BinderClientHandler, BinderLocalClientHandler, BinderLocalServerHandler,
5148 BinderServerHandler, binder,
5149 };
5150 }
5151
5152 mod ___detail {
5153 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Binder
5154 where
5155 ___T: ::fidl_next::Transport,
5156 {
5157 type Client = BinderClient<___T>;
5158 type Server = BinderServer<___T>;
5159 }
5160
5161 #[repr(transparent)]
5163 pub struct BinderClient<___T: ::fidl_next::Transport> {
5164 #[allow(dead_code)]
5165 client: ::fidl_next::protocol::Client<___T>,
5166 }
5167
5168 impl<___T> BinderClient<___T> where ___T: ::fidl_next::Transport {}
5169
5170 #[repr(transparent)]
5172 pub struct BinderServer<___T: ::fidl_next::Transport> {
5173 server: ::fidl_next::protocol::Server<___T>,
5174 }
5175
5176 impl<___T> BinderServer<___T> where ___T: ::fidl_next::Transport {}
5177 }
5178}
5179
5180#[diagnostic::on_unimplemented(
5181 note = "If {Self} implements the non-local BinderClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5182)]
5183
5184pub trait BinderLocalClientHandler<
5188 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5189 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5190>
5191{
5192}
5193
5194impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Binder
5195where
5196 ___H: BinderLocalClientHandler<___T>,
5197 ___T: ::fidl_next::Transport,
5198{
5199 async fn on_event(
5200 handler: &mut ___H,
5201 mut message: ::fidl_next::Message<___T>,
5202 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5203 match *message.header().ordinal {
5204 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5205 }
5206 }
5207}
5208
5209#[diagnostic::on_unimplemented(
5210 note = "If {Self} implements the non-local BinderServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5211)]
5212
5213pub trait BinderLocalServerHandler<
5217 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5218 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5219>
5220{
5221}
5222
5223impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Binder
5224where
5225 ___H: BinderLocalServerHandler<___T>,
5226 ___T: ::fidl_next::Transport,
5227{
5228 async fn on_one_way(
5229 handler: &mut ___H,
5230 mut message: ::fidl_next::Message<___T>,
5231 ) -> ::core::result::Result<
5232 (),
5233 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5234 > {
5235 match *message.header().ordinal {
5236 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5237 }
5238 }
5239
5240 async fn on_two_way(
5241 handler: &mut ___H,
5242 mut message: ::fidl_next::Message<___T>,
5243 responder: ::fidl_next::protocol::Responder<___T>,
5244 ) -> ::core::result::Result<
5245 (),
5246 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5247 > {
5248 match *message.header().ordinal {
5249 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5250 }
5251 }
5252}
5253
5254pub trait BinderClientHandler<
5258 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5259 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5260>
5261{
5262}
5263
5264impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Binder
5265where
5266 ___H: BinderClientHandler<___T> + ::core::marker::Send,
5267 ___T: ::fidl_next::Transport,
5268{
5269 async fn on_event(
5270 handler: &mut ___H,
5271 mut message: ::fidl_next::Message<___T>,
5272 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5273 match *message.header().ordinal {
5274 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5275 }
5276 }
5277}
5278
5279pub trait BinderServerHandler<
5283 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5284 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5285>
5286{
5287}
5288
5289impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Binder
5290where
5291 ___H: BinderServerHandler<___T> + ::core::marker::Send,
5292 ___T: ::fidl_next::Transport,
5293{
5294 async fn on_one_way(
5295 handler: &mut ___H,
5296 mut message: ::fidl_next::Message<___T>,
5297 ) -> ::core::result::Result<
5298 (),
5299 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5300 > {
5301 match *message.header().ordinal {
5302 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5303 }
5304 }
5305
5306 async fn on_two_way(
5307 handler: &mut ___H,
5308 mut message: ::fidl_next::Message<___T>,
5309 responder: ::fidl_next::protocol::Responder<___T>,
5310 ) -> ::core::result::Result<
5311 (),
5312 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5313 > {
5314 match *message.header().ordinal {
5315 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5316 }
5317 }
5318}
5319
5320impl<___T> BinderClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport
5321{}
5322
5323impl<___H, ___T> BinderLocalClientHandler<___T> for ::fidl_next::Local<___H>
5324where
5325 ___H: BinderClientHandler<___T>,
5326 ___T: ::fidl_next::Transport,
5327{
5328}
5329
5330impl<___H, ___T> BinderLocalServerHandler<___T> for ::fidl_next::Local<___H>
5331where
5332 ___H: BinderServerHandler<___T>,
5333 ___T: ::fidl_next::Transport,
5334{
5335}
5336
5337pub const MAX_NAME_LENGTH: u64 = 255 as u64;
5338
5339#[doc = " The maximum number of children that the a call `ChildIterator.Next`\n can return.\n Note, this is not a limit on the number of children that can be added\n to a component. This is merely a limit for a single invocation of the\n `Next` method.\n"]
5340pub const MAX_CHILD_COUNT: u32 = 128 as u32;
5341
5342#[doc = " A protocol to iterate over the list of children in a realm.\n"]
5344#[derive(PartialEq, Debug)]
5345pub struct ChildIterator;
5346
5347#[cfg(target_os = "fuchsia")]
5348impl ::fidl_next::HasTransport for ChildIterator {
5349 type Transport = ::fidl_next::fuchsia::zx::Channel;
5350}
5351
5352pub mod child_iterator {
5353 pub mod prelude {
5354 pub use crate::{
5355 ChildIterator, ChildIteratorClientHandler, ChildIteratorLocalClientHandler,
5356 ChildIteratorLocalServerHandler, ChildIteratorServerHandler, child_iterator,
5357 };
5358
5359 pub use crate::natural::ChildIteratorNextResponse;
5360 }
5361
5362 pub struct Next;
5363
5364 impl ::fidl_next::Method for Next {
5365 const ORDINAL: u64 = 4676077302722137352;
5366 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5367 ::fidl_next::protocol::Flexibility::Strict;
5368
5369 type Protocol = crate::ChildIterator;
5370
5371 type Request = ::fidl_next::wire::EmptyMessageBody;
5372 }
5373
5374 impl ::fidl_next::TwoWayMethod for Next {
5375 type Response = ::fidl_next::wire::Strict<crate::wire::ChildIteratorNextResponse<'static>>;
5376 }
5377
5378 impl<___R> ::fidl_next::Respond<___R> for Next {
5379 type Output = ::fidl_next::Strict<crate::generic::ChildIteratorNextResponse<___R>>;
5380
5381 fn respond(response: ___R) -> Self::Output {
5382 ::fidl_next::Strict(crate::generic::ChildIteratorNextResponse { children: response })
5383 }
5384 }
5385
5386 mod ___detail {
5387 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ChildIterator
5388 where
5389 ___T: ::fidl_next::Transport,
5390 {
5391 type Client = ChildIteratorClient<___T>;
5392 type Server = ChildIteratorServer<___T>;
5393 }
5394
5395 #[repr(transparent)]
5397 pub struct ChildIteratorClient<___T: ::fidl_next::Transport> {
5398 #[allow(dead_code)]
5399 client: ::fidl_next::protocol::Client<___T>,
5400 }
5401
5402 impl<___T> ChildIteratorClient<___T>
5403 where
5404 ___T: ::fidl_next::Transport,
5405 {
5406 #[doc = " Advance the iterator and return the next batch of children.\n\n Returns a vector of `ChildRef`. Returns an empty vector when there are\n no more children.\n"]
5407 pub fn next(&self) -> ::fidl_next::TwoWayFuture<'_, super::Next, ___T> {
5408 ::fidl_next::TwoWayFuture::from_untyped(
5409 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
5410 4676077302722137352,
5411 <super::Next as ::fidl_next::Method>::FLEXIBILITY,
5412 (),
5413 ),
5414 )
5415 }
5416 }
5417
5418 #[repr(transparent)]
5420 pub struct ChildIteratorServer<___T: ::fidl_next::Transport> {
5421 server: ::fidl_next::protocol::Server<___T>,
5422 }
5423
5424 impl<___T> ChildIteratorServer<___T> where ___T: ::fidl_next::Transport {}
5425 }
5426}
5427
5428#[diagnostic::on_unimplemented(
5429 note = "If {Self} implements the non-local ChildIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5430)]
5431
5432pub trait ChildIteratorLocalClientHandler<
5436 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5437 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5438>
5439{
5440}
5441
5442impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ChildIterator
5443where
5444 ___H: ChildIteratorLocalClientHandler<___T>,
5445 ___T: ::fidl_next::Transport,
5446{
5447 async fn on_event(
5448 handler: &mut ___H,
5449 mut message: ::fidl_next::Message<___T>,
5450 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5451 match *message.header().ordinal {
5452 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5453 }
5454 }
5455}
5456
5457#[diagnostic::on_unimplemented(
5458 note = "If {Self} implements the non-local ChildIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5459)]
5460
5461pub trait ChildIteratorLocalServerHandler<
5465 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5466 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5467>
5468{
5469 #[doc = " Advance the iterator and return the next batch of children.\n\n Returns a vector of `ChildRef`. Returns an empty vector when there are\n no more children.\n"]
5470 fn next(
5471 &mut self,
5472
5473 responder: ::fidl_next::Responder<child_iterator::Next, ___T>,
5474 ) -> impl ::core::future::Future<Output = ()>;
5475}
5476
5477impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ChildIterator
5478where
5479 ___H: ChildIteratorLocalServerHandler<___T>,
5480 ___T: ::fidl_next::Transport,
5481{
5482 async fn on_one_way(
5483 handler: &mut ___H,
5484 mut message: ::fidl_next::Message<___T>,
5485 ) -> ::core::result::Result<
5486 (),
5487 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5488 > {
5489 match *message.header().ordinal {
5490 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5491 }
5492 }
5493
5494 async fn on_two_way(
5495 handler: &mut ___H,
5496 mut message: ::fidl_next::Message<___T>,
5497 responder: ::fidl_next::protocol::Responder<___T>,
5498 ) -> ::core::result::Result<
5499 (),
5500 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5501 > {
5502 match *message.header().ordinal {
5503 4676077302722137352 => {
5504 let responder = ::fidl_next::Responder::from_untyped(responder);
5505
5506 handler.next(responder).await;
5507 Ok(())
5508 }
5509
5510 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5511 }
5512 }
5513}
5514
5515pub trait ChildIteratorClientHandler<
5519 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5520 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5521>
5522{
5523}
5524
5525impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ChildIterator
5526where
5527 ___H: ChildIteratorClientHandler<___T> + ::core::marker::Send,
5528 ___T: ::fidl_next::Transport,
5529{
5530 async fn on_event(
5531 handler: &mut ___H,
5532 mut message: ::fidl_next::Message<___T>,
5533 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5534 match *message.header().ordinal {
5535 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5536 }
5537 }
5538}
5539
5540pub trait ChildIteratorServerHandler<
5544 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5545 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5546>
5547{
5548 #[doc = " Advance the iterator and return the next batch of children.\n\n Returns a vector of `ChildRef`. Returns an empty vector when there are\n no more children.\n"]
5549 fn next(
5550 &mut self,
5551
5552 responder: ::fidl_next::Responder<child_iterator::Next, ___T>,
5553 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5554}
5555
5556impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ChildIterator
5557where
5558 ___H: ChildIteratorServerHandler<___T> + ::core::marker::Send,
5559 ___T: ::fidl_next::Transport,
5560{
5561 async fn on_one_way(
5562 handler: &mut ___H,
5563 mut message: ::fidl_next::Message<___T>,
5564 ) -> ::core::result::Result<
5565 (),
5566 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5567 > {
5568 match *message.header().ordinal {
5569 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5570 }
5571 }
5572
5573 async fn on_two_way(
5574 handler: &mut ___H,
5575 mut message: ::fidl_next::Message<___T>,
5576 responder: ::fidl_next::protocol::Responder<___T>,
5577 ) -> ::core::result::Result<
5578 (),
5579 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5580 > {
5581 match *message.header().ordinal {
5582 4676077302722137352 => {
5583 let responder = ::fidl_next::Responder::from_untyped(responder);
5584
5585 handler.next(responder).await;
5586 Ok(())
5587 }
5588
5589 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5590 }
5591 }
5592}
5593
5594impl<___T> ChildIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
5595 ___T: ::fidl_next::Transport
5596{
5597}
5598
5599impl<___H, ___T> ChildIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
5600where
5601 ___H: ChildIteratorClientHandler<___T>,
5602 ___T: ::fidl_next::Transport,
5603{
5604}
5605
5606impl<___H, ___T> ChildIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
5607where
5608 ___H: ChildIteratorServerHandler<___T>,
5609 ___T: ::fidl_next::Transport,
5610{
5611 async fn next(&mut self, responder: ::fidl_next::Responder<child_iterator::Next, ___T>) {
5612 ___H::next(&mut self.0, responder).await
5613 }
5614}
5615
5616#[doc = " The maximum number of handles that can be passed to a created component.\n"]
5617pub const MAX_HANDLE_COUNT: u32 = 128 as u32;
5618
5619pub const MAX_NAMESPACE_COUNT: u32 = 32 as u32;
5620
5621pub const MAX_PATH_LENGTH: u64 = 4095 as u64;
5622
5623#[doc = " The maximum number of dynamic offers that can target a created component.\n"]
5624pub const MAX_DYNAMIC_OFFER_COUNT: u32 = 128 as u32;
5625
5626pub const MAX_MONIKER_LENGTH: u32 = 4096 as u32;
5627
5628#[derive(PartialEq, Debug)]
5630pub struct ExecutionController;
5631
5632#[cfg(target_os = "fuchsia")]
5633impl ::fidl_next::HasTransport for ExecutionController {
5634 type Transport = ::fidl_next::fuchsia::zx::Channel;
5635}
5636
5637pub mod execution_controller {
5638 pub mod prelude {
5639 pub use crate::{
5640 ExecutionController, ExecutionControllerClientHandler,
5641 ExecutionControllerLocalClientHandler, ExecutionControllerLocalServerHandler,
5642 ExecutionControllerServerHandler, execution_controller,
5643 };
5644
5645 pub use crate::natural::ExecutionControllerOnStopRequest;
5646 }
5647
5648 pub struct Stop;
5649
5650 impl ::fidl_next::Method for Stop {
5651 const ORDINAL: u64 = 6256129817234858263;
5652 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5653 ::fidl_next::protocol::Flexibility::Flexible;
5654
5655 type Protocol = crate::ExecutionController;
5656
5657 type Request = ::fidl_next::wire::EmptyMessageBody;
5658 }
5659
5660 pub struct OnStop;
5661
5662 impl ::fidl_next::Method for OnStop {
5663 const ORDINAL: u64 = 7121600095714604415;
5664 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5665 ::fidl_next::protocol::Flexibility::Flexible;
5666
5667 type Protocol = crate::ExecutionController;
5668
5669 type Request = crate::wire::ExecutionControllerOnStopRequest<'static>;
5670 }
5671
5672 mod ___detail {
5673 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ExecutionController
5674 where
5675 ___T: ::fidl_next::Transport,
5676 {
5677 type Client = ExecutionControllerClient<___T>;
5678 type Server = ExecutionControllerServer<___T>;
5679 }
5680
5681 #[repr(transparent)]
5683 pub struct ExecutionControllerClient<___T: ::fidl_next::Transport> {
5684 #[allow(dead_code)]
5685 client: ::fidl_next::protocol::Client<___T>,
5686 }
5687
5688 impl<___T> ExecutionControllerClient<___T>
5689 where
5690 ___T: ::fidl_next::Transport,
5691 {
5692 #[doc = " Initiates a stop action on this component. Once complete, OnStop will be\n called with the stopped payload and this channel is closed.\n\n Note that a component may stop running on its own at any time, so it is\n possible for `OnStop` to be received before `Stop` is called.\n"]
5693 pub fn stop(&self) -> ::fidl_next::SendFuture<'_, ___T> {
5694 ::fidl_next::SendFuture::from_untyped(
5695 self.client.send_one_way::<::fidl_next::wire::EmptyMessageBody>(
5696 6256129817234858263,
5697 <super::Stop as ::fidl_next::Method>::FLEXIBILITY,
5698 (),
5699 ),
5700 )
5701 }
5702 }
5703
5704 #[repr(transparent)]
5706 pub struct ExecutionControllerServer<___T: ::fidl_next::Transport> {
5707 server: ::fidl_next::protocol::Server<___T>,
5708 }
5709
5710 impl<___T> ExecutionControllerServer<___T>
5711 where
5712 ___T: ::fidl_next::Transport,
5713 {
5714 #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]
5715 pub fn on_stop(
5716 &self,
5717
5718 stopped_payload: impl ::fidl_next::Encode<
5719 crate::wire::StoppedPayload<'static>,
5720 <___T as ::fidl_next::Transport>::SendBuffer,
5721 >,
5722 ) -> ::fidl_next::SendFuture<'_, ___T>
5723 where
5724 <___T as ::fidl_next::Transport>::SendBuffer:
5725 ::fidl_next::encoder::InternalHandleEncoder,
5726 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
5727 {
5728 self.on_stop_with(crate::generic::ExecutionControllerOnStopRequest {
5729 stopped_payload,
5730 })
5731 }
5732
5733 #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]
5734
5735 pub fn on_stop_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
5736 where
5737 ___R: ::fidl_next::Encode<
5738 <super::OnStop as ::fidl_next::Method>::Request,
5739 <___T as ::fidl_next::Transport>::SendBuffer,
5740 >,
5741 {
5742 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
5743 7121600095714604415,
5744 <super::OnStop as ::fidl_next::Method>::FLEXIBILITY,
5745 request,
5746 ))
5747 }
5748 }
5749 }
5750}
5751
5752#[diagnostic::on_unimplemented(
5753 note = "If {Self} implements the non-local ExecutionControllerClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5754)]
5755
5756pub trait ExecutionControllerLocalClientHandler<
5760 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5761 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5762>
5763{
5764 #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]
5765 fn on_stop(
5766 &mut self,
5767
5768 request: ::fidl_next::Request<execution_controller::OnStop, ___T>,
5769 ) -> impl ::core::future::Future<Output = ()>;
5770
5771 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5772 ::core::future::ready(())
5773 }
5774}
5775
5776impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ExecutionController
5777where
5778 ___H: ExecutionControllerLocalClientHandler<___T>,
5779 ___T: ::fidl_next::Transport,
5780 for<'de> crate::wire::ExecutionControllerOnStopRequest<'de>: ::fidl_next::Decode<
5781 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5782 Constraint = (),
5783 >,
5784{
5785 async fn on_event(
5786 handler: &mut ___H,
5787 mut message: ::fidl_next::Message<___T>,
5788 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5789 match *message.header().ordinal {
5790 7121600095714604415 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
5791 Ok(decoded) => {
5792 handler.on_stop(::fidl_next::Request::from_decoded(decoded)).await;
5793 Ok(())
5794 }
5795 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5796 ordinal: 7121600095714604415,
5797 error,
5798 }),
5799 },
5800
5801 ordinal => {
5802 handler.on_unknown_interaction(ordinal).await;
5803 if ::core::matches!(
5804 message.header().flexibility(),
5805 ::fidl_next::protocol::Flexibility::Strict
5806 ) {
5807 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5808 } else {
5809 Ok(())
5810 }
5811 }
5812 }
5813 }
5814}
5815
5816#[diagnostic::on_unimplemented(
5817 note = "If {Self} implements the non-local ExecutionControllerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5818)]
5819
5820pub trait ExecutionControllerLocalServerHandler<
5824 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5825 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5826>
5827{
5828 #[doc = " Initiates a stop action on this component. Once complete, OnStop will be\n called with the stopped payload and this channel is closed.\n\n Note that a component may stop running on its own at any time, so it is\n possible for `OnStop` to be received before `Stop` is called.\n"]
5829 fn stop(&mut self) -> impl ::core::future::Future<Output = ()>;
5830
5831 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5832 ::core::future::ready(())
5833 }
5834}
5835
5836impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ExecutionController
5837where
5838 ___H: ExecutionControllerLocalServerHandler<___T>,
5839 ___T: ::fidl_next::Transport,
5840{
5841 async fn on_one_way(
5842 handler: &mut ___H,
5843 mut message: ::fidl_next::Message<___T>,
5844 ) -> ::core::result::Result<
5845 (),
5846 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5847 > {
5848 match *message.header().ordinal {
5849 6256129817234858263 => {
5850 handler.stop().await;
5851 Ok(())
5852 }
5853
5854 ordinal => {
5855 handler.on_unknown_interaction(ordinal).await;
5856 if ::core::matches!(
5857 message.header().flexibility(),
5858 ::fidl_next::protocol::Flexibility::Strict
5859 ) {
5860 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5861 } else {
5862 Ok(())
5863 }
5864 }
5865 }
5866 }
5867
5868 async fn on_two_way(
5869 handler: &mut ___H,
5870 mut message: ::fidl_next::Message<___T>,
5871 responder: ::fidl_next::protocol::Responder<___T>,
5872 ) -> ::core::result::Result<
5873 (),
5874 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5875 > {
5876 match *message.header().ordinal {
5877 ordinal => {
5878 handler.on_unknown_interaction(ordinal).await;
5879 if ::core::matches!(
5880 message.header().flexibility(),
5881 ::fidl_next::protocol::Flexibility::Strict
5882 ) {
5883 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5884 } else {
5885 responder
5886 .respond_framework_error(
5887 ordinal,
5888 ::fidl_next::FrameworkError::UnknownMethod,
5889 )
5890 .expect("encoding a framework error should never fail")
5891 .await?;
5892 Ok(())
5893 }
5894 }
5895 }
5896 }
5897}
5898
5899pub trait ExecutionControllerClientHandler<
5903 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5904 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5905>
5906{
5907 #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]
5908 fn on_stop(
5909 &mut self,
5910
5911 request: ::fidl_next::Request<execution_controller::OnStop, ___T>,
5912 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5913
5914 fn on_unknown_interaction(
5915 &mut self,
5916 ordinal: u64,
5917 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5918 ::core::future::ready(())
5919 }
5920}
5921
5922impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ExecutionController
5923where
5924 ___H: ExecutionControllerClientHandler<___T> + ::core::marker::Send,
5925 ___T: ::fidl_next::Transport,
5926 for<'de> crate::wire::ExecutionControllerOnStopRequest<'de>: ::fidl_next::Decode<
5927 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5928 Constraint = (),
5929 >,
5930{
5931 async fn on_event(
5932 handler: &mut ___H,
5933 mut message: ::fidl_next::Message<___T>,
5934 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5935 match *message.header().ordinal {
5936 7121600095714604415 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
5937 Ok(decoded) => {
5938 handler.on_stop(::fidl_next::Request::from_decoded(decoded)).await;
5939 Ok(())
5940 }
5941 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5942 ordinal: 7121600095714604415,
5943 error,
5944 }),
5945 },
5946
5947 ordinal => {
5948 handler.on_unknown_interaction(ordinal).await;
5949 if ::core::matches!(
5950 message.header().flexibility(),
5951 ::fidl_next::protocol::Flexibility::Strict
5952 ) {
5953 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5954 } else {
5955 Ok(())
5956 }
5957 }
5958 }
5959 }
5960}
5961
5962pub trait ExecutionControllerServerHandler<
5966 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5967 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5968>
5969{
5970 #[doc = " Initiates a stop action on this component. Once complete, OnStop will be\n called with the stopped payload and this channel is closed.\n\n Note that a component may stop running on its own at any time, so it is\n possible for `OnStop` to be received before `Stop` is called.\n"]
5971 fn stop(&mut self) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5972
5973 fn on_unknown_interaction(
5974 &mut self,
5975 ordinal: u64,
5976 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5977 ::core::future::ready(())
5978 }
5979}
5980
5981impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ExecutionController
5982where
5983 ___H: ExecutionControllerServerHandler<___T> + ::core::marker::Send,
5984 ___T: ::fidl_next::Transport,
5985{
5986 async fn on_one_way(
5987 handler: &mut ___H,
5988 mut message: ::fidl_next::Message<___T>,
5989 ) -> ::core::result::Result<
5990 (),
5991 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5992 > {
5993 match *message.header().ordinal {
5994 6256129817234858263 => {
5995 handler.stop().await;
5996 Ok(())
5997 }
5998
5999 ordinal => {
6000 handler.on_unknown_interaction(ordinal).await;
6001 if ::core::matches!(
6002 message.header().flexibility(),
6003 ::fidl_next::protocol::Flexibility::Strict
6004 ) {
6005 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6006 } else {
6007 Ok(())
6008 }
6009 }
6010 }
6011 }
6012
6013 async fn on_two_way(
6014 handler: &mut ___H,
6015 mut message: ::fidl_next::Message<___T>,
6016 responder: ::fidl_next::protocol::Responder<___T>,
6017 ) -> ::core::result::Result<
6018 (),
6019 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6020 > {
6021 match *message.header().ordinal {
6022 ordinal => {
6023 handler.on_unknown_interaction(ordinal).await;
6024 if ::core::matches!(
6025 message.header().flexibility(),
6026 ::fidl_next::protocol::Flexibility::Strict
6027 ) {
6028 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6029 } else {
6030 responder
6031 .respond_framework_error(
6032 ordinal,
6033 ::fidl_next::FrameworkError::UnknownMethod,
6034 )
6035 .expect("encoding a framework error should never fail")
6036 .await?;
6037 Ok(())
6038 }
6039 }
6040 }
6041 }
6042}
6043
6044impl<___T> ExecutionControllerClientHandler<___T> for ::fidl_next::IgnoreEvents
6045where
6046 ___T: ::fidl_next::Transport,
6047{
6048 async fn on_stop(&mut self, _: ::fidl_next::Request<execution_controller::OnStop, ___T>) {}
6049
6050 async fn on_unknown_interaction(&mut self, _: u64) {}
6051}
6052
6053impl<___H, ___T> ExecutionControllerLocalClientHandler<___T> for ::fidl_next::Local<___H>
6054where
6055 ___H: ExecutionControllerClientHandler<___T>,
6056 ___T: ::fidl_next::Transport,
6057{
6058 async fn on_stop(&mut self, request: ::fidl_next::Request<execution_controller::OnStop, ___T>) {
6059 ___H::on_stop(&mut self.0, request).await
6060 }
6061
6062 async fn on_unknown_interaction(&mut self, ordinal: u64) {
6063 ___H::on_unknown_interaction(&mut self.0, ordinal).await
6064 }
6065}
6066
6067impl<___H, ___T> ExecutionControllerLocalServerHandler<___T> for ::fidl_next::Local<___H>
6068where
6069 ___H: ExecutionControllerServerHandler<___T>,
6070 ___T: ::fidl_next::Transport,
6071{
6072 async fn stop(&mut self) {
6073 ___H::stop(&mut self.0).await
6074 }
6075
6076 async fn on_unknown_interaction(&mut self, ordinal: u64) {
6077 ___H::on_unknown_interaction(&mut self.0, ordinal).await
6078 }
6079}
6080
6081#[doc = " The maximum string length of a capability ID.\n This value is currently set arbitrarily.\n"]
6082pub const MAX_CAPABILITY_ID_LENGTH: u64 = 50 as u64;
6083
6084pub const MAX_CHILD_NAME_LENGTH: u32 = 1024 as u32;
6085
6086#[doc = " The maximum string length of an error description.\n"]
6087pub const MAX_ERROR_DESCRIPTION_LENGTH: u64 = 100 as u64;
6088
6089#[doc = " The maximum number of events that a receiver can listen to.\n"]
6090pub const MAX_NUM_EVENTS_RECEIVED: u64 = 100 as u64;
6091
6092#[doc = " The maximum length of a storage instance ID.\n A storage instance ID is a 256-bit UUID, which when encoded\n in hex notation is 64 characters long.\n"]
6093pub const MAX_STORAGE_ID_LENGTH: u32 = 64 as u32;
6094
6095#[doc = " The maximum number of requests per event subscription.\n"]
6096pub const MAX_SUBSCRIPTION_REQUESTS: u32 = 2 as u32;
6097
6098pub const MAX_URL_SCHEME_LENGTH: u64 = 255 as u64;
6099
6100#[doc = " An iterator protocol for returning a set of components using a storage\n capability. See |StorageAdmin.ListStorageInRealm| for more information.\n"]
6102#[derive(PartialEq, Debug)]
6103pub struct StorageIterator;
6104
6105#[cfg(target_os = "fuchsia")]
6106impl ::fidl_next::HasTransport for StorageIterator {
6107 type Transport = ::fidl_next::fuchsia::zx::Channel;
6108}
6109
6110pub mod storage_iterator {
6111 pub mod prelude {
6112 pub use crate::{
6113 StorageIterator, StorageIteratorClientHandler, StorageIteratorLocalClientHandler,
6114 StorageIteratorLocalServerHandler, StorageIteratorServerHandler, storage_iterator,
6115 };
6116
6117 pub use crate::natural::StorageIteratorNextResponse;
6118 }
6119
6120 pub struct Next;
6121
6122 impl ::fidl_next::Method for Next {
6123 const ORDINAL: u64 = 8821181615713557362;
6124 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6125 ::fidl_next::protocol::Flexibility::Strict;
6126
6127 type Protocol = crate::StorageIterator;
6128
6129 type Request = ::fidl_next::wire::EmptyMessageBody;
6130 }
6131
6132 impl ::fidl_next::TwoWayMethod for Next {
6133 type Response =
6134 ::fidl_next::wire::Strict<crate::wire::StorageIteratorNextResponse<'static>>;
6135 }
6136
6137 impl<___R> ::fidl_next::Respond<___R> for Next {
6138 type Output = ::fidl_next::Strict<crate::generic::StorageIteratorNextResponse<___R>>;
6139
6140 fn respond(response: ___R) -> Self::Output {
6141 ::fidl_next::Strict(crate::generic::StorageIteratorNextResponse {
6142 relative_monikers: response,
6143 })
6144 }
6145 }
6146
6147 mod ___detail {
6148 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::StorageIterator
6149 where
6150 ___T: ::fidl_next::Transport,
6151 {
6152 type Client = StorageIteratorClient<___T>;
6153 type Server = StorageIteratorServer<___T>;
6154 }
6155
6156 #[repr(transparent)]
6158 pub struct StorageIteratorClient<___T: ::fidl_next::Transport> {
6159 #[allow(dead_code)]
6160 client: ::fidl_next::protocol::Client<___T>,
6161 }
6162
6163 impl<___T> StorageIteratorClient<___T>
6164 where
6165 ___T: ::fidl_next::Transport,
6166 {
6167 #[doc = " Retrieve the next set of components using the storage capability. The\n returned monikers are relative to the component that declares the\n storage capability. Returns an empty vector after all components have\n been returned.\n"]
6168 pub fn next(&self) -> ::fidl_next::TwoWayFuture<'_, super::Next, ___T> {
6169 ::fidl_next::TwoWayFuture::from_untyped(
6170 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
6171 8821181615713557362,
6172 <super::Next as ::fidl_next::Method>::FLEXIBILITY,
6173 (),
6174 ),
6175 )
6176 }
6177 }
6178
6179 #[repr(transparent)]
6181 pub struct StorageIteratorServer<___T: ::fidl_next::Transport> {
6182 server: ::fidl_next::protocol::Server<___T>,
6183 }
6184
6185 impl<___T> StorageIteratorServer<___T> where ___T: ::fidl_next::Transport {}
6186 }
6187}
6188
6189#[diagnostic::on_unimplemented(
6190 note = "If {Self} implements the non-local StorageIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
6191)]
6192
6193pub trait StorageIteratorLocalClientHandler<
6197 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6198 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6199>
6200{
6201}
6202
6203impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for StorageIterator
6204where
6205 ___H: StorageIteratorLocalClientHandler<___T>,
6206 ___T: ::fidl_next::Transport,
6207{
6208 async fn on_event(
6209 handler: &mut ___H,
6210 mut message: ::fidl_next::Message<___T>,
6211 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6212 match *message.header().ordinal {
6213 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6214 }
6215 }
6216}
6217
6218#[diagnostic::on_unimplemented(
6219 note = "If {Self} implements the non-local StorageIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
6220)]
6221
6222pub trait StorageIteratorLocalServerHandler<
6226 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6227 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6228>
6229{
6230 #[doc = " Retrieve the next set of components using the storage capability. The\n returned monikers are relative to the component that declares the\n storage capability. Returns an empty vector after all components have\n been returned.\n"]
6231 fn next(
6232 &mut self,
6233
6234 responder: ::fidl_next::Responder<storage_iterator::Next, ___T>,
6235 ) -> impl ::core::future::Future<Output = ()>;
6236}
6237
6238impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for StorageIterator
6239where
6240 ___H: StorageIteratorLocalServerHandler<___T>,
6241 ___T: ::fidl_next::Transport,
6242{
6243 async fn on_one_way(
6244 handler: &mut ___H,
6245 mut message: ::fidl_next::Message<___T>,
6246 ) -> ::core::result::Result<
6247 (),
6248 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6249 > {
6250 match *message.header().ordinal {
6251 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6252 }
6253 }
6254
6255 async fn on_two_way(
6256 handler: &mut ___H,
6257 mut message: ::fidl_next::Message<___T>,
6258 responder: ::fidl_next::protocol::Responder<___T>,
6259 ) -> ::core::result::Result<
6260 (),
6261 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6262 > {
6263 match *message.header().ordinal {
6264 8821181615713557362 => {
6265 let responder = ::fidl_next::Responder::from_untyped(responder);
6266
6267 handler.next(responder).await;
6268 Ok(())
6269 }
6270
6271 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6272 }
6273 }
6274}
6275
6276pub trait StorageIteratorClientHandler<
6280 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6281 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6282>
6283{
6284}
6285
6286impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for StorageIterator
6287where
6288 ___H: StorageIteratorClientHandler<___T> + ::core::marker::Send,
6289 ___T: ::fidl_next::Transport,
6290{
6291 async fn on_event(
6292 handler: &mut ___H,
6293 mut message: ::fidl_next::Message<___T>,
6294 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6295 match *message.header().ordinal {
6296 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6297 }
6298 }
6299}
6300
6301pub trait StorageIteratorServerHandler<
6305 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6306 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6307>
6308{
6309 #[doc = " Retrieve the next set of components using the storage capability. The\n returned monikers are relative to the component that declares the\n storage capability. Returns an empty vector after all components have\n been returned.\n"]
6310 fn next(
6311 &mut self,
6312
6313 responder: ::fidl_next::Responder<storage_iterator::Next, ___T>,
6314 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6315}
6316
6317impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for StorageIterator
6318where
6319 ___H: StorageIteratorServerHandler<___T> + ::core::marker::Send,
6320 ___T: ::fidl_next::Transport,
6321{
6322 async fn on_one_way(
6323 handler: &mut ___H,
6324 mut message: ::fidl_next::Message<___T>,
6325 ) -> ::core::result::Result<
6326 (),
6327 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6328 > {
6329 match *message.header().ordinal {
6330 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6331 }
6332 }
6333
6334 async fn on_two_way(
6335 handler: &mut ___H,
6336 mut message: ::fidl_next::Message<___T>,
6337 responder: ::fidl_next::protocol::Responder<___T>,
6338 ) -> ::core::result::Result<
6339 (),
6340 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6341 > {
6342 match *message.header().ordinal {
6343 8821181615713557362 => {
6344 let responder = ::fidl_next::Responder::from_untyped(responder);
6345
6346 handler.next(responder).await;
6347 Ok(())
6348 }
6349
6350 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6351 }
6352 }
6353}
6354
6355impl<___T> StorageIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
6356 ___T: ::fidl_next::Transport
6357{
6358}
6359
6360impl<___H, ___T> StorageIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
6361where
6362 ___H: StorageIteratorClientHandler<___T>,
6363 ___T: ::fidl_next::Transport,
6364{
6365}
6366
6367impl<___H, ___T> StorageIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
6368where
6369 ___H: StorageIteratorServerHandler<___T>,
6370 ___T: ::fidl_next::Transport,
6371{
6372 async fn next(&mut self, responder: ::fidl_next::Responder<storage_iterator::Next, ___T>) {
6373 ___H::next(&mut self.0, responder).await
6374 }
6375}