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 pub type ControllerStartResponse = ();
4718
4719 pub type ControllerOpenExposedDirResponse = ();
4721
4722 pub type ControllerDestroyResponse = ();
4724
4725 pub struct ExecutionControllerOnStopRequest<T0> {
4727 pub stopped_payload: T0,
4728 }
4729
4730 unsafe impl<___E, T0>
4731 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
4732 for ExecutionControllerOnStopRequest<T0>
4733 where
4734 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4735 ___E: ::fidl_next::Encoder,
4736 T0: ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E>,
4737 {
4738 #[inline]
4739 fn encode(
4740 self,
4741 encoder_: &mut ___E,
4742 out_: &mut ::core::mem::MaybeUninit<
4743 crate::wire::ExecutionControllerOnStopRequest<'static>,
4744 >,
4745 _: (),
4746 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4747 ::fidl_next::munge! {
4748 let crate::wire::ExecutionControllerOnStopRequest {
4749 stopped_payload,
4750
4751 } = out_;
4752 }
4753
4754 ::fidl_next::Encode::encode(self.stopped_payload, encoder_, stopped_payload, ())?;
4755
4756 Ok(())
4757 }
4758 }
4759
4760 pub struct IntrospectorGetMonikerResponse<T0> {
4762 pub moniker: T0,
4763 }
4764
4765 unsafe impl<___E, T0>
4766 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
4767 for IntrospectorGetMonikerResponse<T0>
4768 where
4769 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4770 ___E: ::fidl_next::Encoder,
4771 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4772 {
4773 #[inline]
4774 fn encode(
4775 self,
4776 encoder_: &mut ___E,
4777 out_: &mut ::core::mem::MaybeUninit<
4778 crate::wire::IntrospectorGetMonikerResponse<'static>,
4779 >,
4780 _: (),
4781 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4782 ::fidl_next::munge! {
4783 let crate::wire::IntrospectorGetMonikerResponse {
4784 moniker,
4785
4786 } = out_;
4787 }
4788
4789 ::fidl_next::Encode::encode(self.moniker, encoder_, moniker, 4096)?;
4790
4791 Ok(())
4792 }
4793 }
4794
4795 pub type RealmOpenExposedDirResponse = ();
4797
4798 pub type RealmCreateChildResponse = ();
4800
4801 pub struct RealmDestroyChildRequest<T0> {
4803 pub child: T0,
4804 }
4805
4806 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
4807 for RealmDestroyChildRequest<T0>
4808 where
4809 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4810 ___E: ::fidl_next::Encoder,
4811 T0: ::fidl_next::Encode<
4812 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'static>,
4813 ___E,
4814 >,
4815 {
4816 #[inline]
4817 fn encode(
4818 self,
4819 encoder_: &mut ___E,
4820 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
4821 _: (),
4822 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4823 ::fidl_next::munge! {
4824 let crate::wire::RealmDestroyChildRequest {
4825 child,
4826
4827 } = out_;
4828 }
4829
4830 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
4831
4832 Ok(())
4833 }
4834 }
4835
4836 pub type RealmDestroyChildResponse = ();
4838
4839 pub type RealmListChildrenResponse = ();
4841
4842 pub type RealmOpenControllerResponse = ();
4844
4845 pub type StorageAdminOpenStorageResponse = ();
4847
4848 pub type StorageAdminListStorageInRealmResponse = ();
4850
4851 pub type StorageAdminOpenComponentStorageByIdResponse = ();
4853
4854 pub struct StorageAdminDeleteComponentStorageRequest<T0> {
4856 pub relative_moniker: T0,
4857 }
4858
4859 unsafe impl<___E, T0>
4860 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
4861 for StorageAdminDeleteComponentStorageRequest<T0>
4862 where
4863 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4864 ___E: ::fidl_next::Encoder,
4865 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::StorageAdminDeleteComponentStorageRequest<'static>,
4873 >,
4874 _: (),
4875 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4876 ::fidl_next::munge! {
4877 let crate::wire::StorageAdminDeleteComponentStorageRequest {
4878 relative_moniker,
4879
4880 } = out_;
4881 }
4882
4883 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
4884
4885 Ok(())
4886 }
4887 }
4888
4889 pub type StorageAdminDeleteComponentStorageResponse = ();
4891
4892 pub type StorageAdminDeleteAllStorageContentsResponse = ();
4894
4895 pub struct StorageIteratorNextResponse<T0> {
4897 pub relative_monikers: T0,
4898 }
4899
4900 unsafe impl<___E, T0>
4901 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
4902 for StorageIteratorNextResponse<T0>
4903 where
4904 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4905 ___E: ::fidl_next::Encoder,
4906 T0: ::fidl_next::Encode<
4907 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
4908 ___E,
4909 >,
4910 {
4911 #[inline]
4912 fn encode(
4913 self,
4914 encoder_: &mut ___E,
4915 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
4916 _: (),
4917 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4918 ::fidl_next::munge! {
4919 let crate::wire::StorageIteratorNextResponse {
4920 relative_monikers,
4921
4922 } = out_;
4923 }
4924
4925 ::fidl_next::Encode::encode(
4926 self.relative_monikers,
4927 encoder_,
4928 relative_monikers,
4929 (4294967295, 4096),
4930 )?;
4931
4932 Ok(())
4933 }
4934 }
4935}
4936
4937pub use self::natural::*;
4938
4939#[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"]
4941#[derive(PartialEq, Debug)]
4942pub struct Binder;
4943
4944impl ::fidl_next::Discoverable for Binder {
4945 const PROTOCOL_NAME: &'static str = "fuchsia.component.Binder";
4946}
4947
4948#[cfg(target_os = "fuchsia")]
4949impl ::fidl_next::HasTransport for Binder {
4950 type Transport = ::fidl_next::fuchsia::zx::Channel;
4951}
4952
4953pub mod binder {
4954 pub mod prelude {
4955 pub use crate::{
4956 Binder, BinderClientHandler, BinderLocalClientHandler, BinderLocalServerHandler,
4957 BinderServerHandler, binder,
4958 };
4959 }
4960
4961 mod ___detail {
4962 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Binder
4963 where
4964 ___T: ::fidl_next::Transport,
4965 {
4966 type Client = BinderClient<___T>;
4967 type Server = BinderServer<___T>;
4968 }
4969
4970 #[repr(transparent)]
4972 pub struct BinderClient<___T: ::fidl_next::Transport> {
4973 #[allow(dead_code)]
4974 client: ::fidl_next::protocol::Client<___T>,
4975 }
4976
4977 impl<___T> BinderClient<___T> where ___T: ::fidl_next::Transport {}
4978
4979 #[repr(transparent)]
4981 pub struct BinderServer<___T: ::fidl_next::Transport> {
4982 server: ::fidl_next::protocol::Server<___T>,
4983 }
4984
4985 impl<___T> BinderServer<___T> where ___T: ::fidl_next::Transport {}
4986 }
4987}
4988
4989#[diagnostic::on_unimplemented(
4990 note = "If {Self} implements the non-local BinderClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
4991)]
4992
4993pub trait BinderLocalClientHandler<
4997 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4998 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4999>
5000{
5001}
5002
5003impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Binder
5004where
5005 ___H: BinderLocalClientHandler<___T>,
5006 ___T: ::fidl_next::Transport,
5007{
5008 async fn on_event(
5009 handler: &mut ___H,
5010 mut message: ::fidl_next::Message<___T>,
5011 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5012 match *message.header().ordinal {
5013 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5014 }
5015 }
5016}
5017
5018#[diagnostic::on_unimplemented(
5019 note = "If {Self} implements the non-local BinderServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5020)]
5021
5022pub trait BinderLocalServerHandler<
5026 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5027 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5028>
5029{
5030}
5031
5032impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Binder
5033where
5034 ___H: BinderLocalServerHandler<___T>,
5035 ___T: ::fidl_next::Transport,
5036{
5037 async fn on_one_way(
5038 handler: &mut ___H,
5039 mut message: ::fidl_next::Message<___T>,
5040 ) -> ::core::result::Result<
5041 (),
5042 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5043 > {
5044 match *message.header().ordinal {
5045 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5046 }
5047 }
5048
5049 async fn on_two_way(
5050 handler: &mut ___H,
5051 mut message: ::fidl_next::Message<___T>,
5052 responder: ::fidl_next::protocol::Responder<___T>,
5053 ) -> ::core::result::Result<
5054 (),
5055 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5056 > {
5057 match *message.header().ordinal {
5058 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5059 }
5060 }
5061}
5062
5063pub trait BinderClientHandler<
5067 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5068 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5069>
5070{
5071}
5072
5073impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Binder
5074where
5075 ___H: BinderClientHandler<___T> + ::core::marker::Send,
5076 ___T: ::fidl_next::Transport,
5077{
5078 async fn on_event(
5079 handler: &mut ___H,
5080 mut message: ::fidl_next::Message<___T>,
5081 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5082 match *message.header().ordinal {
5083 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5084 }
5085 }
5086}
5087
5088pub trait BinderServerHandler<
5092 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5093 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5094>
5095{
5096}
5097
5098impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Binder
5099where
5100 ___H: BinderServerHandler<___T> + ::core::marker::Send,
5101 ___T: ::fidl_next::Transport,
5102{
5103 async fn on_one_way(
5104 handler: &mut ___H,
5105 mut message: ::fidl_next::Message<___T>,
5106 ) -> ::core::result::Result<
5107 (),
5108 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5109 > {
5110 match *message.header().ordinal {
5111 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5112 }
5113 }
5114
5115 async fn on_two_way(
5116 handler: &mut ___H,
5117 mut message: ::fidl_next::Message<___T>,
5118 responder: ::fidl_next::protocol::Responder<___T>,
5119 ) -> ::core::result::Result<
5120 (),
5121 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5122 > {
5123 match *message.header().ordinal {
5124 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5125 }
5126 }
5127}
5128
5129impl<___T> BinderClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport
5130{}
5131
5132impl<___H, ___T> BinderLocalClientHandler<___T> for ::fidl_next::Local<___H>
5133where
5134 ___H: BinderClientHandler<___T>,
5135 ___T: ::fidl_next::Transport,
5136{
5137}
5138
5139impl<___H, ___T> BinderLocalServerHandler<___T> for ::fidl_next::Local<___H>
5140where
5141 ___H: BinderServerHandler<___T>,
5142 ___T: ::fidl_next::Transport,
5143{
5144}
5145
5146pub const MAX_NAME_LENGTH: u64 = 255 as u64;
5147
5148#[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"]
5149pub const MAX_CHILD_COUNT: u32 = 128 as u32;
5150
5151#[doc = " A protocol to iterate over the list of children in a realm.\n"]
5153#[derive(PartialEq, Debug)]
5154pub struct ChildIterator;
5155
5156#[cfg(target_os = "fuchsia")]
5157impl ::fidl_next::HasTransport for ChildIterator {
5158 type Transport = ::fidl_next::fuchsia::zx::Channel;
5159}
5160
5161pub mod child_iterator {
5162 pub mod prelude {
5163 pub use crate::{
5164 ChildIterator, ChildIteratorClientHandler, ChildIteratorLocalClientHandler,
5165 ChildIteratorLocalServerHandler, ChildIteratorServerHandler, child_iterator,
5166 };
5167
5168 pub use crate::natural::ChildIteratorNextResponse;
5169 }
5170
5171 pub struct Next;
5172
5173 impl ::fidl_next::Method for Next {
5174 const ORDINAL: u64 = 4676077302722137352;
5175 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5176 ::fidl_next::protocol::Flexibility::Strict;
5177
5178 type Protocol = crate::ChildIterator;
5179
5180 type Request = ::fidl_next::wire::EmptyMessageBody;
5181 }
5182
5183 impl ::fidl_next::TwoWayMethod for Next {
5184 type Response = ::fidl_next::wire::Strict<crate::wire::ChildIteratorNextResponse<'static>>;
5185 }
5186
5187 impl<___R> ::fidl_next::Respond<___R> for Next {
5188 type Output = ::fidl_next::Strict<crate::generic::ChildIteratorNextResponse<___R>>;
5189
5190 fn respond(response: ___R) -> Self::Output {
5191 ::fidl_next::Strict(crate::generic::ChildIteratorNextResponse { children: response })
5192 }
5193 }
5194
5195 mod ___detail {
5196 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ChildIterator
5197 where
5198 ___T: ::fidl_next::Transport,
5199 {
5200 type Client = ChildIteratorClient<___T>;
5201 type Server = ChildIteratorServer<___T>;
5202 }
5203
5204 #[repr(transparent)]
5206 pub struct ChildIteratorClient<___T: ::fidl_next::Transport> {
5207 #[allow(dead_code)]
5208 client: ::fidl_next::protocol::Client<___T>,
5209 }
5210
5211 impl<___T> ChildIteratorClient<___T>
5212 where
5213 ___T: ::fidl_next::Transport,
5214 {
5215 #[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"]
5216 pub fn next(&self) -> ::fidl_next::TwoWayFuture<'_, super::Next, ___T> {
5217 ::fidl_next::TwoWayFuture::from_untyped(
5218 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
5219 4676077302722137352,
5220 <super::Next as ::fidl_next::Method>::FLEXIBILITY,
5221 (),
5222 ),
5223 )
5224 }
5225 }
5226
5227 #[repr(transparent)]
5229 pub struct ChildIteratorServer<___T: ::fidl_next::Transport> {
5230 server: ::fidl_next::protocol::Server<___T>,
5231 }
5232
5233 impl<___T> ChildIteratorServer<___T> where ___T: ::fidl_next::Transport {}
5234 }
5235}
5236
5237#[diagnostic::on_unimplemented(
5238 note = "If {Self} implements the non-local ChildIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5239)]
5240
5241pub trait ChildIteratorLocalClientHandler<
5245 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5246 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5247>
5248{
5249}
5250
5251impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ChildIterator
5252where
5253 ___H: ChildIteratorLocalClientHandler<___T>,
5254 ___T: ::fidl_next::Transport,
5255{
5256 async fn on_event(
5257 handler: &mut ___H,
5258 mut message: ::fidl_next::Message<___T>,
5259 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5260 match *message.header().ordinal {
5261 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5262 }
5263 }
5264}
5265
5266#[diagnostic::on_unimplemented(
5267 note = "If {Self} implements the non-local ChildIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5268)]
5269
5270pub trait ChildIteratorLocalServerHandler<
5274 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5275 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5276>
5277{
5278 #[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"]
5279 fn next(
5280 &mut self,
5281
5282 responder: ::fidl_next::Responder<child_iterator::Next, ___T>,
5283 ) -> impl ::core::future::Future<Output = ()>;
5284}
5285
5286impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ChildIterator
5287where
5288 ___H: ChildIteratorLocalServerHandler<___T>,
5289 ___T: ::fidl_next::Transport,
5290{
5291 async fn on_one_way(
5292 handler: &mut ___H,
5293 mut message: ::fidl_next::Message<___T>,
5294 ) -> ::core::result::Result<
5295 (),
5296 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5297 > {
5298 match *message.header().ordinal {
5299 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5300 }
5301 }
5302
5303 async fn on_two_way(
5304 handler: &mut ___H,
5305 mut message: ::fidl_next::Message<___T>,
5306 responder: ::fidl_next::protocol::Responder<___T>,
5307 ) -> ::core::result::Result<
5308 (),
5309 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5310 > {
5311 match *message.header().ordinal {
5312 4676077302722137352 => {
5313 let responder = ::fidl_next::Responder::from_untyped(responder);
5314
5315 handler.next(responder).await;
5316 Ok(())
5317 }
5318
5319 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5320 }
5321 }
5322}
5323
5324pub trait ChildIteratorClientHandler<
5328 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5329 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5330>
5331{
5332}
5333
5334impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ChildIterator
5335where
5336 ___H: ChildIteratorClientHandler<___T> + ::core::marker::Send,
5337 ___T: ::fidl_next::Transport,
5338{
5339 async fn on_event(
5340 handler: &mut ___H,
5341 mut message: ::fidl_next::Message<___T>,
5342 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5343 match *message.header().ordinal {
5344 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5345 }
5346 }
5347}
5348
5349pub trait ChildIteratorServerHandler<
5353 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5354 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5355>
5356{
5357 #[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"]
5358 fn next(
5359 &mut self,
5360
5361 responder: ::fidl_next::Responder<child_iterator::Next, ___T>,
5362 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5363}
5364
5365impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ChildIterator
5366where
5367 ___H: ChildIteratorServerHandler<___T> + ::core::marker::Send,
5368 ___T: ::fidl_next::Transport,
5369{
5370 async fn on_one_way(
5371 handler: &mut ___H,
5372 mut message: ::fidl_next::Message<___T>,
5373 ) -> ::core::result::Result<
5374 (),
5375 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5376 > {
5377 match *message.header().ordinal {
5378 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5379 }
5380 }
5381
5382 async fn on_two_way(
5383 handler: &mut ___H,
5384 mut message: ::fidl_next::Message<___T>,
5385 responder: ::fidl_next::protocol::Responder<___T>,
5386 ) -> ::core::result::Result<
5387 (),
5388 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5389 > {
5390 match *message.header().ordinal {
5391 4676077302722137352 => {
5392 let responder = ::fidl_next::Responder::from_untyped(responder);
5393
5394 handler.next(responder).await;
5395 Ok(())
5396 }
5397
5398 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5399 }
5400 }
5401}
5402
5403impl<___T> ChildIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
5404 ___T: ::fidl_next::Transport
5405{
5406}
5407
5408impl<___H, ___T> ChildIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
5409where
5410 ___H: ChildIteratorClientHandler<___T>,
5411 ___T: ::fidl_next::Transport,
5412{
5413}
5414
5415impl<___H, ___T> ChildIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
5416where
5417 ___H: ChildIteratorServerHandler<___T>,
5418 ___T: ::fidl_next::Transport,
5419{
5420 async fn next(&mut self, responder: ::fidl_next::Responder<child_iterator::Next, ___T>) {
5421 ___H::next(&mut self.0, responder).await
5422 }
5423}
5424
5425#[doc = " The maximum number of handles that can be passed to a created component.\n"]
5426pub const MAX_HANDLE_COUNT: u32 = 128 as u32;
5427
5428pub const MAX_NAMESPACE_COUNT: u32 = 32 as u32;
5429
5430pub const MAX_PATH_LENGTH: u64 = 4095 as u64;
5431
5432#[doc = " The maximum number of dynamic offers that can target a created component.\n"]
5433pub const MAX_DYNAMIC_OFFER_COUNT: u32 = 128 as u32;
5434
5435pub const MAX_MONIKER_LENGTH: u32 = 4096 as u32;
5436
5437#[derive(PartialEq, Debug)]
5439pub struct ExecutionController;
5440
5441#[cfg(target_os = "fuchsia")]
5442impl ::fidl_next::HasTransport for ExecutionController {
5443 type Transport = ::fidl_next::fuchsia::zx::Channel;
5444}
5445
5446pub mod execution_controller {
5447 pub mod prelude {
5448 pub use crate::{
5449 ExecutionController, ExecutionControllerClientHandler,
5450 ExecutionControllerLocalClientHandler, ExecutionControllerLocalServerHandler,
5451 ExecutionControllerServerHandler, execution_controller,
5452 };
5453
5454 pub use crate::natural::ExecutionControllerOnStopRequest;
5455 }
5456
5457 pub struct Stop;
5458
5459 impl ::fidl_next::Method for Stop {
5460 const ORDINAL: u64 = 6256129817234858263;
5461 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5462 ::fidl_next::protocol::Flexibility::Flexible;
5463
5464 type Protocol = crate::ExecutionController;
5465
5466 type Request = ::fidl_next::wire::EmptyMessageBody;
5467 }
5468
5469 pub struct OnStop;
5470
5471 impl ::fidl_next::Method for OnStop {
5472 const ORDINAL: u64 = 7121600095714604415;
5473 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5474 ::fidl_next::protocol::Flexibility::Flexible;
5475
5476 type Protocol = crate::ExecutionController;
5477
5478 type Request = crate::wire::ExecutionControllerOnStopRequest<'static>;
5479 }
5480
5481 mod ___detail {
5482 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ExecutionController
5483 where
5484 ___T: ::fidl_next::Transport,
5485 {
5486 type Client = ExecutionControllerClient<___T>;
5487 type Server = ExecutionControllerServer<___T>;
5488 }
5489
5490 #[repr(transparent)]
5492 pub struct ExecutionControllerClient<___T: ::fidl_next::Transport> {
5493 #[allow(dead_code)]
5494 client: ::fidl_next::protocol::Client<___T>,
5495 }
5496
5497 impl<___T> ExecutionControllerClient<___T>
5498 where
5499 ___T: ::fidl_next::Transport,
5500 {
5501 #[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"]
5502 pub fn stop(&self) -> ::fidl_next::SendFuture<'_, ___T> {
5503 ::fidl_next::SendFuture::from_untyped(
5504 self.client.send_one_way::<::fidl_next::wire::EmptyMessageBody>(
5505 6256129817234858263,
5506 <super::Stop as ::fidl_next::Method>::FLEXIBILITY,
5507 (),
5508 ),
5509 )
5510 }
5511 }
5512
5513 #[repr(transparent)]
5515 pub struct ExecutionControllerServer<___T: ::fidl_next::Transport> {
5516 server: ::fidl_next::protocol::Server<___T>,
5517 }
5518
5519 impl<___T> ExecutionControllerServer<___T>
5520 where
5521 ___T: ::fidl_next::Transport,
5522 {
5523 #[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"]
5524 pub fn on_stop(
5525 &self,
5526
5527 stopped_payload: impl ::fidl_next::Encode<
5528 crate::wire::StoppedPayload<'static>,
5529 <___T as ::fidl_next::Transport>::SendBuffer,
5530 >,
5531 ) -> ::fidl_next::SendFuture<'_, ___T>
5532 where
5533 <___T as ::fidl_next::Transport>::SendBuffer:
5534 ::fidl_next::encoder::InternalHandleEncoder,
5535 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
5536 {
5537 self.on_stop_with(crate::generic::ExecutionControllerOnStopRequest {
5538 stopped_payload,
5539 })
5540 }
5541
5542 #[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"]
5543
5544 pub fn on_stop_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
5545 where
5546 ___R: ::fidl_next::Encode<
5547 <super::OnStop as ::fidl_next::Method>::Request,
5548 <___T as ::fidl_next::Transport>::SendBuffer,
5549 >,
5550 {
5551 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
5552 7121600095714604415,
5553 <super::OnStop as ::fidl_next::Method>::FLEXIBILITY,
5554 request,
5555 ))
5556 }
5557 }
5558 }
5559}
5560
5561#[diagnostic::on_unimplemented(
5562 note = "If {Self} implements the non-local ExecutionControllerClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5563)]
5564
5565pub trait ExecutionControllerLocalClientHandler<
5569 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5570 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5571>
5572{
5573 #[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"]
5574 fn on_stop(
5575 &mut self,
5576
5577 request: ::fidl_next::Request<execution_controller::OnStop, ___T>,
5578 ) -> impl ::core::future::Future<Output = ()>;
5579
5580 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5581 ::core::future::ready(())
5582 }
5583}
5584
5585impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ExecutionController
5586where
5587 ___H: ExecutionControllerLocalClientHandler<___T>,
5588 ___T: ::fidl_next::Transport,
5589 for<'de> crate::wire::ExecutionControllerOnStopRequest<'de>: ::fidl_next::Decode<
5590 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5591 Constraint = (),
5592 >,
5593{
5594 async fn on_event(
5595 handler: &mut ___H,
5596 mut message: ::fidl_next::Message<___T>,
5597 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5598 match *message.header().ordinal {
5599 7121600095714604415 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
5600 Ok(decoded) => {
5601 handler.on_stop(::fidl_next::Request::from_decoded(decoded)).await;
5602 Ok(())
5603 }
5604 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5605 ordinal: 7121600095714604415,
5606 error,
5607 }),
5608 },
5609
5610 ordinal => {
5611 handler.on_unknown_interaction(ordinal).await;
5612 if ::core::matches!(
5613 message.header().flexibility(),
5614 ::fidl_next::protocol::Flexibility::Strict
5615 ) {
5616 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5617 } else {
5618 Ok(())
5619 }
5620 }
5621 }
5622 }
5623}
5624
5625#[diagnostic::on_unimplemented(
5626 note = "If {Self} implements the non-local ExecutionControllerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5627)]
5628
5629pub trait ExecutionControllerLocalServerHandler<
5633 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5634 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5635>
5636{
5637 #[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"]
5638 fn stop(&mut self) -> impl ::core::future::Future<Output = ()>;
5639
5640 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5641 ::core::future::ready(())
5642 }
5643}
5644
5645impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ExecutionController
5646where
5647 ___H: ExecutionControllerLocalServerHandler<___T>,
5648 ___T: ::fidl_next::Transport,
5649{
5650 async fn on_one_way(
5651 handler: &mut ___H,
5652 mut message: ::fidl_next::Message<___T>,
5653 ) -> ::core::result::Result<
5654 (),
5655 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5656 > {
5657 match *message.header().ordinal {
5658 6256129817234858263 => {
5659 handler.stop().await;
5660 Ok(())
5661 }
5662
5663 ordinal => {
5664 handler.on_unknown_interaction(ordinal).await;
5665 if ::core::matches!(
5666 message.header().flexibility(),
5667 ::fidl_next::protocol::Flexibility::Strict
5668 ) {
5669 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5670 } else {
5671 Ok(())
5672 }
5673 }
5674 }
5675 }
5676
5677 async fn on_two_way(
5678 handler: &mut ___H,
5679 mut message: ::fidl_next::Message<___T>,
5680 responder: ::fidl_next::protocol::Responder<___T>,
5681 ) -> ::core::result::Result<
5682 (),
5683 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5684 > {
5685 match *message.header().ordinal {
5686 ordinal => {
5687 handler.on_unknown_interaction(ordinal).await;
5688 if ::core::matches!(
5689 message.header().flexibility(),
5690 ::fidl_next::protocol::Flexibility::Strict
5691 ) {
5692 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5693 } else {
5694 responder
5695 .respond_framework_error(
5696 ordinal,
5697 ::fidl_next::FrameworkError::UnknownMethod,
5698 )
5699 .expect("encoding a framework error should never fail")
5700 .await?;
5701 Ok(())
5702 }
5703 }
5704 }
5705 }
5706}
5707
5708pub trait ExecutionControllerClientHandler<
5712 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5713 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5714>
5715{
5716 #[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"]
5717 fn on_stop(
5718 &mut self,
5719
5720 request: ::fidl_next::Request<execution_controller::OnStop, ___T>,
5721 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5722
5723 fn on_unknown_interaction(
5724 &mut self,
5725 ordinal: u64,
5726 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5727 ::core::future::ready(())
5728 }
5729}
5730
5731impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ExecutionController
5732where
5733 ___H: ExecutionControllerClientHandler<___T> + ::core::marker::Send,
5734 ___T: ::fidl_next::Transport,
5735 for<'de> crate::wire::ExecutionControllerOnStopRequest<'de>: ::fidl_next::Decode<
5736 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5737 Constraint = (),
5738 >,
5739{
5740 async fn on_event(
5741 handler: &mut ___H,
5742 mut message: ::fidl_next::Message<___T>,
5743 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5744 match *message.header().ordinal {
5745 7121600095714604415 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
5746 Ok(decoded) => {
5747 handler.on_stop(::fidl_next::Request::from_decoded(decoded)).await;
5748 Ok(())
5749 }
5750 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5751 ordinal: 7121600095714604415,
5752 error,
5753 }),
5754 },
5755
5756 ordinal => {
5757 handler.on_unknown_interaction(ordinal).await;
5758 if ::core::matches!(
5759 message.header().flexibility(),
5760 ::fidl_next::protocol::Flexibility::Strict
5761 ) {
5762 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5763 } else {
5764 Ok(())
5765 }
5766 }
5767 }
5768 }
5769}
5770
5771pub trait ExecutionControllerServerHandler<
5775 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5776 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5777>
5778{
5779 #[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"]
5780 fn stop(&mut self) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5781
5782 fn on_unknown_interaction(
5783 &mut self,
5784 ordinal: u64,
5785 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5786 ::core::future::ready(())
5787 }
5788}
5789
5790impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ExecutionController
5791where
5792 ___H: ExecutionControllerServerHandler<___T> + ::core::marker::Send,
5793 ___T: ::fidl_next::Transport,
5794{
5795 async fn on_one_way(
5796 handler: &mut ___H,
5797 mut message: ::fidl_next::Message<___T>,
5798 ) -> ::core::result::Result<
5799 (),
5800 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5801 > {
5802 match *message.header().ordinal {
5803 6256129817234858263 => {
5804 handler.stop().await;
5805 Ok(())
5806 }
5807
5808 ordinal => {
5809 handler.on_unknown_interaction(ordinal).await;
5810 if ::core::matches!(
5811 message.header().flexibility(),
5812 ::fidl_next::protocol::Flexibility::Strict
5813 ) {
5814 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5815 } else {
5816 Ok(())
5817 }
5818 }
5819 }
5820 }
5821
5822 async fn on_two_way(
5823 handler: &mut ___H,
5824 mut message: ::fidl_next::Message<___T>,
5825 responder: ::fidl_next::protocol::Responder<___T>,
5826 ) -> ::core::result::Result<
5827 (),
5828 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5829 > {
5830 match *message.header().ordinal {
5831 ordinal => {
5832 handler.on_unknown_interaction(ordinal).await;
5833 if ::core::matches!(
5834 message.header().flexibility(),
5835 ::fidl_next::protocol::Flexibility::Strict
5836 ) {
5837 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5838 } else {
5839 responder
5840 .respond_framework_error(
5841 ordinal,
5842 ::fidl_next::FrameworkError::UnknownMethod,
5843 )
5844 .expect("encoding a framework error should never fail")
5845 .await?;
5846 Ok(())
5847 }
5848 }
5849 }
5850 }
5851}
5852
5853impl<___T> ExecutionControllerClientHandler<___T> for ::fidl_next::IgnoreEvents
5854where
5855 ___T: ::fidl_next::Transport,
5856{
5857 async fn on_stop(&mut self, _: ::fidl_next::Request<execution_controller::OnStop, ___T>) {}
5858
5859 async fn on_unknown_interaction(&mut self, _: u64) {}
5860}
5861
5862impl<___H, ___T> ExecutionControllerLocalClientHandler<___T> for ::fidl_next::Local<___H>
5863where
5864 ___H: ExecutionControllerClientHandler<___T>,
5865 ___T: ::fidl_next::Transport,
5866{
5867 async fn on_stop(&mut self, request: ::fidl_next::Request<execution_controller::OnStop, ___T>) {
5868 ___H::on_stop(&mut self.0, request).await
5869 }
5870
5871 async fn on_unknown_interaction(&mut self, ordinal: u64) {
5872 ___H::on_unknown_interaction(&mut self.0, ordinal).await
5873 }
5874}
5875
5876impl<___H, ___T> ExecutionControllerLocalServerHandler<___T> for ::fidl_next::Local<___H>
5877where
5878 ___H: ExecutionControllerServerHandler<___T>,
5879 ___T: ::fidl_next::Transport,
5880{
5881 async fn stop(&mut self) {
5882 ___H::stop(&mut self.0).await
5883 }
5884
5885 async fn on_unknown_interaction(&mut self, ordinal: u64) {
5886 ___H::on_unknown_interaction(&mut self.0, ordinal).await
5887 }
5888}
5889
5890#[doc = " The maximum string length of a capability ID.\n This value is currently set arbitrarily.\n"]
5891pub const MAX_CAPABILITY_ID_LENGTH: u64 = 50 as u64;
5892
5893pub const MAX_CHILD_NAME_LENGTH: u32 = 1024 as u32;
5894
5895#[doc = " The maximum string length of an error description.\n"]
5896pub const MAX_ERROR_DESCRIPTION_LENGTH: u64 = 100 as u64;
5897
5898#[doc = " The maximum number of events that a receiver can listen to.\n"]
5899pub const MAX_NUM_EVENTS_RECEIVED: u64 = 100 as u64;
5900
5901#[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"]
5902pub const MAX_STORAGE_ID_LENGTH: u32 = 64 as u32;
5903
5904#[doc = " The maximum number of requests per event subscription.\n"]
5905pub const MAX_SUBSCRIPTION_REQUESTS: u32 = 2 as u32;
5906
5907pub const MAX_URL_SCHEME_LENGTH: u64 = 255 as u64;
5908
5909#[doc = " An iterator protocol for returning a set of components using a storage\n capability. See |StorageAdmin.ListStorageInRealm| for more information.\n"]
5911#[derive(PartialEq, Debug)]
5912pub struct StorageIterator;
5913
5914#[cfg(target_os = "fuchsia")]
5915impl ::fidl_next::HasTransport for StorageIterator {
5916 type Transport = ::fidl_next::fuchsia::zx::Channel;
5917}
5918
5919pub mod storage_iterator {
5920 pub mod prelude {
5921 pub use crate::{
5922 StorageIterator, StorageIteratorClientHandler, StorageIteratorLocalClientHandler,
5923 StorageIteratorLocalServerHandler, StorageIteratorServerHandler, storage_iterator,
5924 };
5925
5926 pub use crate::natural::StorageIteratorNextResponse;
5927 }
5928
5929 pub struct Next;
5930
5931 impl ::fidl_next::Method for Next {
5932 const ORDINAL: u64 = 8821181615713557362;
5933 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5934 ::fidl_next::protocol::Flexibility::Strict;
5935
5936 type Protocol = crate::StorageIterator;
5937
5938 type Request = ::fidl_next::wire::EmptyMessageBody;
5939 }
5940
5941 impl ::fidl_next::TwoWayMethod for Next {
5942 type Response =
5943 ::fidl_next::wire::Strict<crate::wire::StorageIteratorNextResponse<'static>>;
5944 }
5945
5946 impl<___R> ::fidl_next::Respond<___R> for Next {
5947 type Output = ::fidl_next::Strict<crate::generic::StorageIteratorNextResponse<___R>>;
5948
5949 fn respond(response: ___R) -> Self::Output {
5950 ::fidl_next::Strict(crate::generic::StorageIteratorNextResponse {
5951 relative_monikers: response,
5952 })
5953 }
5954 }
5955
5956 mod ___detail {
5957 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::StorageIterator
5958 where
5959 ___T: ::fidl_next::Transport,
5960 {
5961 type Client = StorageIteratorClient<___T>;
5962 type Server = StorageIteratorServer<___T>;
5963 }
5964
5965 #[repr(transparent)]
5967 pub struct StorageIteratorClient<___T: ::fidl_next::Transport> {
5968 #[allow(dead_code)]
5969 client: ::fidl_next::protocol::Client<___T>,
5970 }
5971
5972 impl<___T> StorageIteratorClient<___T>
5973 where
5974 ___T: ::fidl_next::Transport,
5975 {
5976 #[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"]
5977 pub fn next(&self) -> ::fidl_next::TwoWayFuture<'_, super::Next, ___T> {
5978 ::fidl_next::TwoWayFuture::from_untyped(
5979 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
5980 8821181615713557362,
5981 <super::Next as ::fidl_next::Method>::FLEXIBILITY,
5982 (),
5983 ),
5984 )
5985 }
5986 }
5987
5988 #[repr(transparent)]
5990 pub struct StorageIteratorServer<___T: ::fidl_next::Transport> {
5991 server: ::fidl_next::protocol::Server<___T>,
5992 }
5993
5994 impl<___T> StorageIteratorServer<___T> where ___T: ::fidl_next::Transport {}
5995 }
5996}
5997
5998#[diagnostic::on_unimplemented(
5999 note = "If {Self} implements the non-local StorageIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
6000)]
6001
6002pub trait StorageIteratorLocalClientHandler<
6006 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6007 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6008>
6009{
6010}
6011
6012impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for StorageIterator
6013where
6014 ___H: StorageIteratorLocalClientHandler<___T>,
6015 ___T: ::fidl_next::Transport,
6016{
6017 async fn on_event(
6018 handler: &mut ___H,
6019 mut message: ::fidl_next::Message<___T>,
6020 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6021 match *message.header().ordinal {
6022 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6023 }
6024 }
6025}
6026
6027#[diagnostic::on_unimplemented(
6028 note = "If {Self} implements the non-local StorageIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
6029)]
6030
6031pub trait StorageIteratorLocalServerHandler<
6035 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6036 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6037>
6038{
6039 #[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"]
6040 fn next(
6041 &mut self,
6042
6043 responder: ::fidl_next::Responder<storage_iterator::Next, ___T>,
6044 ) -> impl ::core::future::Future<Output = ()>;
6045}
6046
6047impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for StorageIterator
6048where
6049 ___H: StorageIteratorLocalServerHandler<___T>,
6050 ___T: ::fidl_next::Transport,
6051{
6052 async fn on_one_way(
6053 handler: &mut ___H,
6054 mut message: ::fidl_next::Message<___T>,
6055 ) -> ::core::result::Result<
6056 (),
6057 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6058 > {
6059 match *message.header().ordinal {
6060 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6061 }
6062 }
6063
6064 async fn on_two_way(
6065 handler: &mut ___H,
6066 mut message: ::fidl_next::Message<___T>,
6067 responder: ::fidl_next::protocol::Responder<___T>,
6068 ) -> ::core::result::Result<
6069 (),
6070 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6071 > {
6072 match *message.header().ordinal {
6073 8821181615713557362 => {
6074 let responder = ::fidl_next::Responder::from_untyped(responder);
6075
6076 handler.next(responder).await;
6077 Ok(())
6078 }
6079
6080 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6081 }
6082 }
6083}
6084
6085pub trait StorageIteratorClientHandler<
6089 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6090 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6091>
6092{
6093}
6094
6095impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for StorageIterator
6096where
6097 ___H: StorageIteratorClientHandler<___T> + ::core::marker::Send,
6098 ___T: ::fidl_next::Transport,
6099{
6100 async fn on_event(
6101 handler: &mut ___H,
6102 mut message: ::fidl_next::Message<___T>,
6103 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6104 match *message.header().ordinal {
6105 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6106 }
6107 }
6108}
6109
6110pub trait StorageIteratorServerHandler<
6114 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6115 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6116>
6117{
6118 #[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"]
6119 fn next(
6120 &mut self,
6121
6122 responder: ::fidl_next::Responder<storage_iterator::Next, ___T>,
6123 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6124}
6125
6126impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for StorageIterator
6127where
6128 ___H: StorageIteratorServerHandler<___T> + ::core::marker::Send,
6129 ___T: ::fidl_next::Transport,
6130{
6131 async fn on_one_way(
6132 handler: &mut ___H,
6133 mut message: ::fidl_next::Message<___T>,
6134 ) -> ::core::result::Result<
6135 (),
6136 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6137 > {
6138 match *message.header().ordinal {
6139 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6140 }
6141 }
6142
6143 async fn on_two_way(
6144 handler: &mut ___H,
6145 mut message: ::fidl_next::Message<___T>,
6146 responder: ::fidl_next::protocol::Responder<___T>,
6147 ) -> ::core::result::Result<
6148 (),
6149 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6150 > {
6151 match *message.header().ordinal {
6152 8821181615713557362 => {
6153 let responder = ::fidl_next::Responder::from_untyped(responder);
6154
6155 handler.next(responder).await;
6156 Ok(())
6157 }
6158
6159 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6160 }
6161 }
6162}
6163
6164impl<___T> StorageIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
6165 ___T: ::fidl_next::Transport
6166{
6167}
6168
6169impl<___H, ___T> StorageIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
6170where
6171 ___H: StorageIteratorClientHandler<___T>,
6172 ___T: ::fidl_next::Transport,
6173{
6174}
6175
6176impl<___H, ___T> StorageIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
6177where
6178 ___H: StorageIteratorServerHandler<___T>,
6179 ___T: ::fidl_next::Transport,
6180{
6181 async fn next(&mut self, responder: ::fidl_next::Responder<storage_iterator::Next, ___T>) {
6182 ___H::next(&mut self.0, responder).await
6183 }
6184}