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: ::core::option::Option<::fidl_next::fuchsia::zx::Status>,
1197
1198 pub exit_code: ::core::option::Option<i64>,
1199 }
1200
1201 impl StoppedPayload {
1202 fn __max_ordinal(&self) -> usize {
1203 if self.exit_code.is_some() {
1204 return 2;
1205 }
1206
1207 if self.status.is_some() {
1208 return 1;
1209 }
1210
1211 0
1212 }
1213 }
1214
1215 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E> for StoppedPayload
1216 where
1217 ___E: ::fidl_next::Encoder + ?Sized,
1218 {
1219 #[inline]
1220 fn encode(
1221 mut self,
1222 encoder: &mut ___E,
1223 out: &mut ::core::mem::MaybeUninit<crate::wire::StoppedPayload<'static>>,
1224 _: (),
1225 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1226 ::fidl_next::munge!(let crate::wire::StoppedPayload { table } = out);
1227
1228 let max_ord = self.__max_ordinal();
1229
1230 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1231 ::fidl_next::Wire::zero_padding(&mut out);
1232
1233 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1234 ::fidl_next::wire::Envelope,
1235 >(encoder, max_ord);
1236
1237 for i in 1..=max_ord {
1238 match i {
1239 2 => {
1240 if let Some(value) = self.exit_code.take() {
1241 ::fidl_next::wire::Envelope::encode_value::<
1242 ::fidl_next::wire::Int64,
1243 ___E,
1244 >(
1245 value, preallocated.encoder, &mut out, ()
1246 )?;
1247 } else {
1248 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1249 }
1250 }
1251
1252 1 => {
1253 if let Some(value) = self.status.take() {
1254 ::fidl_next::wire::Envelope::encode_value::<
1255 ::fidl_next::wire::fuchsia::Status,
1256 ___E,
1257 >(
1258 value, preallocated.encoder, &mut out, ()
1259 )?;
1260 } else {
1261 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1262 }
1263 }
1264
1265 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1266 }
1267 unsafe {
1268 preallocated.write_next(out.assume_init_ref());
1269 }
1270 }
1271
1272 ::fidl_next::wire::Table::encode_len(table, max_ord);
1273
1274 Ok(())
1275 }
1276 }
1277
1278 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E>
1279 for &'a StoppedPayload
1280 where
1281 ___E: ::fidl_next::Encoder + ?Sized,
1282 {
1283 #[inline]
1284 fn encode(
1285 self,
1286 encoder: &mut ___E,
1287 out: &mut ::core::mem::MaybeUninit<crate::wire::StoppedPayload<'static>>,
1288 _: (),
1289 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1290 ::fidl_next::munge!(let crate::wire::StoppedPayload { table } = out);
1291
1292 let max_ord = self.__max_ordinal();
1293
1294 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1295 ::fidl_next::Wire::zero_padding(&mut out);
1296
1297 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1298 ::fidl_next::wire::Envelope,
1299 >(encoder, max_ord);
1300
1301 for i in 1..=max_ord {
1302 match i {
1303 2 => {
1304 if let Some(value) = &self.exit_code {
1305 ::fidl_next::wire::Envelope::encode_value::<
1306 ::fidl_next::wire::Int64,
1307 ___E,
1308 >(
1309 value, preallocated.encoder, &mut out, ()
1310 )?;
1311 } else {
1312 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1313 }
1314 }
1315
1316 1 => {
1317 if let Some(value) = &self.status {
1318 ::fidl_next::wire::Envelope::encode_value::<
1319 ::fidl_next::wire::fuchsia::Status,
1320 ___E,
1321 >(
1322 value, preallocated.encoder, &mut out, ()
1323 )?;
1324 } else {
1325 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1326 }
1327 }
1328
1329 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1330 }
1331 unsafe {
1332 preallocated.write_next(out.assume_init_ref());
1333 }
1334 }
1335
1336 ::fidl_next::wire::Table::encode_len(table, max_ord);
1337
1338 Ok(())
1339 }
1340 }
1341
1342 impl<'de> ::fidl_next::FromWire<crate::wire::StoppedPayload<'de>> for StoppedPayload {
1343 #[inline]
1344 fn from_wire(wire_: crate::wire::StoppedPayload<'de>) -> Self {
1345 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1346
1347 let status = wire_.table.get(1);
1348
1349 let exit_code = wire_.table.get(2);
1350
1351 Self {
1352 status: status.map(|envelope| {
1353 ::fidl_next::FromWire::from_wire(unsafe {
1354 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Status>()
1355 })
1356 }),
1357
1358 exit_code: exit_code.map(|envelope| {
1359 ::fidl_next::FromWire::from_wire(unsafe {
1360 envelope.read_unchecked::<::fidl_next::wire::Int64>()
1361 })
1362 }),
1363 }
1364 }
1365 }
1366
1367 impl<'de> ::fidl_next::FromWireRef<crate::wire::StoppedPayload<'de>> for StoppedPayload {
1368 #[inline]
1369 fn from_wire_ref(wire: &crate::wire::StoppedPayload<'de>) -> Self {
1370 Self {
1371 status: wire.table.get(1).map(|envelope| {
1372 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1373 envelope.deref_unchecked::<::fidl_next::wire::fuchsia::Status>()
1374 })
1375 }),
1376
1377 exit_code: wire.table.get(2).map(|envelope| {
1378 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1379 envelope.deref_unchecked::<::fidl_next::wire::Int64>()
1380 })
1381 }),
1382 }
1383 }
1384 }
1385
1386 #[doc = " A head providing metadata about a target component instance.\n"]
1387 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1388 pub struct EventHeader {
1389 pub event_type: ::core::option::Option<crate::natural::EventType>,
1390
1391 pub moniker: ::core::option::Option<::std::string::String>,
1392
1393 pub component_url: ::core::option::Option<::std::string::String>,
1394
1395 pub timestamp: ::core::option::Option<i64>,
1396 }
1397
1398 impl EventHeader {
1399 fn __max_ordinal(&self) -> usize {
1400 if self.timestamp.is_some() {
1401 return 4;
1402 }
1403
1404 if self.component_url.is_some() {
1405 return 3;
1406 }
1407
1408 if self.moniker.is_some() {
1409 return 2;
1410 }
1411
1412 if self.event_type.is_some() {
1413 return 1;
1414 }
1415
1416 0
1417 }
1418 }
1419
1420 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventHeader<'static>, ___E> for EventHeader
1421 where
1422 ___E: ::fidl_next::Encoder + ?Sized,
1423 {
1424 #[inline]
1425 fn encode(
1426 mut self,
1427 encoder: &mut ___E,
1428 out: &mut ::core::mem::MaybeUninit<crate::wire::EventHeader<'static>>,
1429 _: (),
1430 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1431 ::fidl_next::munge!(let crate::wire::EventHeader { table } = out);
1432
1433 let max_ord = self.__max_ordinal();
1434
1435 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1436 ::fidl_next::Wire::zero_padding(&mut out);
1437
1438 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1439 ::fidl_next::wire::Envelope,
1440 >(encoder, max_ord);
1441
1442 for i in 1..=max_ord {
1443 match i {
1444 4 => {
1445 if let Some(value) = self.timestamp.take() {
1446 ::fidl_next::wire::Envelope::encode_value::<
1447 ::fidl_next::wire::Int64,
1448 ___E,
1449 >(
1450 value, preallocated.encoder, &mut out, ()
1451 )?;
1452 } else {
1453 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1454 }
1455 }
1456
1457 3 => {
1458 if let Some(value) = self.component_url.take() {
1459 ::fidl_next::wire::Envelope::encode_value::<
1460 ::fidl_next::wire::String<'static>,
1461 ___E,
1462 >(
1463 value, preallocated.encoder, &mut out, 4096
1464 )?;
1465 } else {
1466 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1467 }
1468 }
1469
1470 2 => {
1471 if let Some(value) = self.moniker.take() {
1472 ::fidl_next::wire::Envelope::encode_value::<
1473 ::fidl_next::wire::String<'static>,
1474 ___E,
1475 >(
1476 value, preallocated.encoder, &mut out, 4096
1477 )?;
1478 } else {
1479 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1480 }
1481 }
1482
1483 1 => {
1484 if let Some(value) = self.event_type.take() {
1485 ::fidl_next::wire::Envelope::encode_value::<
1486 crate::wire::EventType,
1487 ___E,
1488 >(
1489 value, preallocated.encoder, &mut out, ()
1490 )?;
1491 } else {
1492 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1493 }
1494 }
1495
1496 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1497 }
1498 unsafe {
1499 preallocated.write_next(out.assume_init_ref());
1500 }
1501 }
1502
1503 ::fidl_next::wire::Table::encode_len(table, max_ord);
1504
1505 Ok(())
1506 }
1507 }
1508
1509 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::EventHeader<'static>, ___E>
1510 for &'a EventHeader
1511 where
1512 ___E: ::fidl_next::Encoder + ?Sized,
1513 {
1514 #[inline]
1515 fn encode(
1516 self,
1517 encoder: &mut ___E,
1518 out: &mut ::core::mem::MaybeUninit<crate::wire::EventHeader<'static>>,
1519 _: (),
1520 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1521 ::fidl_next::munge!(let crate::wire::EventHeader { table } = out);
1522
1523 let max_ord = self.__max_ordinal();
1524
1525 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1526 ::fidl_next::Wire::zero_padding(&mut out);
1527
1528 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1529 ::fidl_next::wire::Envelope,
1530 >(encoder, max_ord);
1531
1532 for i in 1..=max_ord {
1533 match i {
1534 4 => {
1535 if let Some(value) = &self.timestamp {
1536 ::fidl_next::wire::Envelope::encode_value::<
1537 ::fidl_next::wire::Int64,
1538 ___E,
1539 >(
1540 value, preallocated.encoder, &mut out, ()
1541 )?;
1542 } else {
1543 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1544 }
1545 }
1546
1547 3 => {
1548 if let Some(value) = &self.component_url {
1549 ::fidl_next::wire::Envelope::encode_value::<
1550 ::fidl_next::wire::String<'static>,
1551 ___E,
1552 >(
1553 value, preallocated.encoder, &mut out, 4096
1554 )?;
1555 } else {
1556 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1557 }
1558 }
1559
1560 2 => {
1561 if let Some(value) = &self.moniker {
1562 ::fidl_next::wire::Envelope::encode_value::<
1563 ::fidl_next::wire::String<'static>,
1564 ___E,
1565 >(
1566 value, preallocated.encoder, &mut out, 4096
1567 )?;
1568 } else {
1569 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1570 }
1571 }
1572
1573 1 => {
1574 if let Some(value) = &self.event_type {
1575 ::fidl_next::wire::Envelope::encode_value::<
1576 crate::wire::EventType,
1577 ___E,
1578 >(
1579 value, preallocated.encoder, &mut out, ()
1580 )?;
1581 } else {
1582 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1583 }
1584 }
1585
1586 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1587 }
1588 unsafe {
1589 preallocated.write_next(out.assume_init_ref());
1590 }
1591 }
1592
1593 ::fidl_next::wire::Table::encode_len(table, max_ord);
1594
1595 Ok(())
1596 }
1597 }
1598
1599 impl<'de> ::fidl_next::FromWire<crate::wire::EventHeader<'de>> for EventHeader {
1600 #[inline]
1601 fn from_wire(wire_: crate::wire::EventHeader<'de>) -> Self {
1602 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1603
1604 let event_type = wire_.table.get(1);
1605
1606 let moniker = wire_.table.get(2);
1607
1608 let component_url = wire_.table.get(3);
1609
1610 let timestamp = wire_.table.get(4);
1611
1612 Self {
1613 event_type: event_type.map(|envelope| {
1614 ::fidl_next::FromWire::from_wire(unsafe {
1615 envelope.read_unchecked::<crate::wire::EventType>()
1616 })
1617 }),
1618
1619 moniker: moniker.map(|envelope| {
1620 ::fidl_next::FromWire::from_wire(unsafe {
1621 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
1622 })
1623 }),
1624
1625 component_url: component_url.map(|envelope| {
1626 ::fidl_next::FromWire::from_wire(unsafe {
1627 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
1628 })
1629 }),
1630
1631 timestamp: timestamp.map(|envelope| {
1632 ::fidl_next::FromWire::from_wire(unsafe {
1633 envelope.read_unchecked::<::fidl_next::wire::Int64>()
1634 })
1635 }),
1636 }
1637 }
1638 }
1639
1640 impl<'de> ::fidl_next::FromWireRef<crate::wire::EventHeader<'de>> for EventHeader {
1641 #[inline]
1642 fn from_wire_ref(wire: &crate::wire::EventHeader<'de>) -> Self {
1643 Self {
1644 event_type: wire.table.get(1).map(|envelope| {
1645 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1646 envelope.deref_unchecked::<crate::wire::EventType>()
1647 })
1648 }),
1649
1650 moniker: wire.table.get(2).map(|envelope| {
1651 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1652 envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
1653 })
1654 }),
1655
1656 component_url: wire.table.get(3).map(|envelope| {
1657 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1658 envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
1659 })
1660 }),
1661
1662 timestamp: wire.table.get(4).map(|envelope| {
1663 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1664 envelope.deref_unchecked::<::fidl_next::wire::Int64>()
1665 })
1666 }),
1667 }
1668 }
1669 }
1670
1671 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1672 pub struct ExecutionControllerOnStopRequest {
1673 pub stopped_payload: crate::natural::StoppedPayload,
1674 }
1675
1676 unsafe impl<___E>
1677 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
1678 for ExecutionControllerOnStopRequest
1679 where
1680 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1681 ___E: ::fidl_next::Encoder,
1682 {
1683 #[inline]
1684 fn encode(
1685 self,
1686 encoder_: &mut ___E,
1687 out_: &mut ::core::mem::MaybeUninit<
1688 crate::wire::ExecutionControllerOnStopRequest<'static>,
1689 >,
1690 _: (),
1691 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1692 ::fidl_next::munge! {
1693 let crate::wire::ExecutionControllerOnStopRequest {
1694 stopped_payload,
1695
1696 } = out_;
1697 }
1698
1699 ::fidl_next::Encode::encode(self.stopped_payload, encoder_, stopped_payload, ())?;
1700
1701 let mut _field =
1702 unsafe { ::fidl_next::Slot::new_unchecked(stopped_payload.as_mut_ptr()) };
1703
1704 Ok(())
1705 }
1706 }
1707
1708 unsafe impl<'a, ___E>
1709 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
1710 for &'a ExecutionControllerOnStopRequest
1711 where
1712 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1713 ___E: ::fidl_next::Encoder,
1714 {
1715 #[inline]
1716 fn encode(
1717 self,
1718 encoder_: &mut ___E,
1719 out_: &mut ::core::mem::MaybeUninit<
1720 crate::wire::ExecutionControllerOnStopRequest<'static>,
1721 >,
1722 _: (),
1723 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1724 ::fidl_next::munge! {
1725 let crate::wire::ExecutionControllerOnStopRequest {
1726 stopped_payload,
1727
1728 } = out_;
1729 }
1730
1731 ::fidl_next::Encode::encode(&self.stopped_payload, encoder_, stopped_payload, ())?;
1732
1733 let mut _field =
1734 unsafe { ::fidl_next::Slot::new_unchecked(stopped_payload.as_mut_ptr()) };
1735
1736 Ok(())
1737 }
1738 }
1739
1740 unsafe impl<___E>
1741 ::fidl_next::EncodeOption<
1742 ::fidl_next::wire::Box<'static, crate::wire::ExecutionControllerOnStopRequest<'static>>,
1743 ___E,
1744 > for ExecutionControllerOnStopRequest
1745 where
1746 ___E: ::fidl_next::Encoder + ?Sized,
1747 ExecutionControllerOnStopRequest:
1748 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>,
1749 {
1750 #[inline]
1751 fn encode_option(
1752 this: ::core::option::Option<Self>,
1753 encoder: &mut ___E,
1754 out: &mut ::core::mem::MaybeUninit<
1755 ::fidl_next::wire::Box<
1756 'static,
1757 crate::wire::ExecutionControllerOnStopRequest<'static>,
1758 >,
1759 >,
1760 _: (),
1761 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1762 if let Some(inner) = this {
1763 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1764 ::fidl_next::wire::Box::encode_present(out);
1765 } else {
1766 ::fidl_next::wire::Box::encode_absent(out);
1767 }
1768
1769 Ok(())
1770 }
1771 }
1772
1773 unsafe impl<'a, ___E>
1774 ::fidl_next::EncodeOption<
1775 ::fidl_next::wire::Box<'static, crate::wire::ExecutionControllerOnStopRequest<'static>>,
1776 ___E,
1777 > for &'a ExecutionControllerOnStopRequest
1778 where
1779 ___E: ::fidl_next::Encoder + ?Sized,
1780 &'a ExecutionControllerOnStopRequest:
1781 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>,
1782 {
1783 #[inline]
1784 fn encode_option(
1785 this: ::core::option::Option<Self>,
1786 encoder: &mut ___E,
1787 out: &mut ::core::mem::MaybeUninit<
1788 ::fidl_next::wire::Box<
1789 'static,
1790 crate::wire::ExecutionControllerOnStopRequest<'static>,
1791 >,
1792 >,
1793 _: (),
1794 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1795 if let Some(inner) = this {
1796 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1797 ::fidl_next::wire::Box::encode_present(out);
1798 } else {
1799 ::fidl_next::wire::Box::encode_absent(out);
1800 }
1801
1802 Ok(())
1803 }
1804 }
1805
1806 impl<'de> ::fidl_next::FromWire<crate::wire::ExecutionControllerOnStopRequest<'de>>
1807 for ExecutionControllerOnStopRequest
1808 {
1809 #[inline]
1810 fn from_wire(wire: crate::wire::ExecutionControllerOnStopRequest<'de>) -> Self {
1811 Self { stopped_payload: ::fidl_next::FromWire::from_wire(wire.stopped_payload) }
1812 }
1813 }
1814
1815 impl<'de> ::fidl_next::FromWireRef<crate::wire::ExecutionControllerOnStopRequest<'de>>
1816 for ExecutionControllerOnStopRequest
1817 {
1818 #[inline]
1819 fn from_wire_ref(wire: &crate::wire::ExecutionControllerOnStopRequest<'de>) -> Self {
1820 Self { stopped_payload: ::fidl_next::FromWireRef::from_wire_ref(&wire.stopped_payload) }
1821 }
1822 }
1823
1824 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1825 pub struct IntrospectorGetMonikerResponse {
1826 pub moniker: ::std::string::String,
1827 }
1828
1829 unsafe impl<___E>
1830 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
1831 for IntrospectorGetMonikerResponse
1832 where
1833 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1834 ___E: ::fidl_next::Encoder,
1835 {
1836 #[inline]
1837 fn encode(
1838 self,
1839 encoder_: &mut ___E,
1840 out_: &mut ::core::mem::MaybeUninit<
1841 crate::wire::IntrospectorGetMonikerResponse<'static>,
1842 >,
1843 _: (),
1844 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1845 ::fidl_next::munge! {
1846 let crate::wire::IntrospectorGetMonikerResponse {
1847 moniker,
1848
1849 } = out_;
1850 }
1851
1852 ::fidl_next::Encode::encode(self.moniker, encoder_, moniker, 4096)?;
1853
1854 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(moniker.as_mut_ptr()) };
1855 ::fidl_next::Constrained::validate(_field, 4096)?;
1856
1857 Ok(())
1858 }
1859 }
1860
1861 unsafe impl<'a, ___E>
1862 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
1863 for &'a IntrospectorGetMonikerResponse
1864 where
1865 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1866 ___E: ::fidl_next::Encoder,
1867 {
1868 #[inline]
1869 fn encode(
1870 self,
1871 encoder_: &mut ___E,
1872 out_: &mut ::core::mem::MaybeUninit<
1873 crate::wire::IntrospectorGetMonikerResponse<'static>,
1874 >,
1875 _: (),
1876 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1877 ::fidl_next::munge! {
1878 let crate::wire::IntrospectorGetMonikerResponse {
1879 moniker,
1880
1881 } = out_;
1882 }
1883
1884 ::fidl_next::Encode::encode(&self.moniker, encoder_, moniker, 4096)?;
1885
1886 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(moniker.as_mut_ptr()) };
1887 ::fidl_next::Constrained::validate(_field, 4096)?;
1888
1889 Ok(())
1890 }
1891 }
1892
1893 unsafe impl<___E>
1894 ::fidl_next::EncodeOption<
1895 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerResponse<'static>>,
1896 ___E,
1897 > for IntrospectorGetMonikerResponse
1898 where
1899 ___E: ::fidl_next::Encoder + ?Sized,
1900 IntrospectorGetMonikerResponse:
1901 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>,
1902 {
1903 #[inline]
1904 fn encode_option(
1905 this: ::core::option::Option<Self>,
1906 encoder: &mut ___E,
1907 out: &mut ::core::mem::MaybeUninit<
1908 ::fidl_next::wire::Box<
1909 'static,
1910 crate::wire::IntrospectorGetMonikerResponse<'static>,
1911 >,
1912 >,
1913 _: (),
1914 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1915 if let Some(inner) = this {
1916 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1917 ::fidl_next::wire::Box::encode_present(out);
1918 } else {
1919 ::fidl_next::wire::Box::encode_absent(out);
1920 }
1921
1922 Ok(())
1923 }
1924 }
1925
1926 unsafe impl<'a, ___E>
1927 ::fidl_next::EncodeOption<
1928 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerResponse<'static>>,
1929 ___E,
1930 > for &'a IntrospectorGetMonikerResponse
1931 where
1932 ___E: ::fidl_next::Encoder + ?Sized,
1933 &'a IntrospectorGetMonikerResponse:
1934 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>,
1935 {
1936 #[inline]
1937 fn encode_option(
1938 this: ::core::option::Option<Self>,
1939 encoder: &mut ___E,
1940 out: &mut ::core::mem::MaybeUninit<
1941 ::fidl_next::wire::Box<
1942 'static,
1943 crate::wire::IntrospectorGetMonikerResponse<'static>,
1944 >,
1945 >,
1946 _: (),
1947 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1948 if let Some(inner) = this {
1949 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1950 ::fidl_next::wire::Box::encode_present(out);
1951 } else {
1952 ::fidl_next::wire::Box::encode_absent(out);
1953 }
1954
1955 Ok(())
1956 }
1957 }
1958
1959 impl<'de> ::fidl_next::FromWire<crate::wire::IntrospectorGetMonikerResponse<'de>>
1960 for IntrospectorGetMonikerResponse
1961 {
1962 #[inline]
1963 fn from_wire(wire: crate::wire::IntrospectorGetMonikerResponse<'de>) -> Self {
1964 Self { moniker: ::fidl_next::FromWire::from_wire(wire.moniker) }
1965 }
1966 }
1967
1968 impl<'de> ::fidl_next::FromWireRef<crate::wire::IntrospectorGetMonikerResponse<'de>>
1969 for IntrospectorGetMonikerResponse
1970 {
1971 #[inline]
1972 fn from_wire_ref(wire: &crate::wire::IntrospectorGetMonikerResponse<'de>) -> Self {
1973 Self { moniker: ::fidl_next::FromWireRef::from_wire_ref(&wire.moniker) }
1974 }
1975 }
1976
1977 #[doc = " Error returned from methods in [`Namespace`].\n"]
1978 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1979 #[repr(u32)]
1980 pub enum NamespaceError {
1981 Shadow = 1,
1982 Duplicate = 2,
1983 Conversion = 3,
1984 BadEntry = 4,
1985 DictionaryRead = 5,
1986 UnknownOrdinal_(u32) = 6,
1987 }
1988 impl ::std::convert::From<u32> for NamespaceError {
1989 fn from(value: u32) -> Self {
1990 match value {
1991 1 => Self::Shadow,
1992 2 => Self::Duplicate,
1993 3 => Self::Conversion,
1994 4 => Self::BadEntry,
1995 5 => Self::DictionaryRead,
1996
1997 _ => Self::UnknownOrdinal_(value),
1998 }
1999 }
2000 }
2001
2002 impl ::std::convert::From<NamespaceError> for u32 {
2003 fn from(value: NamespaceError) -> Self {
2004 match value {
2005 NamespaceError::Shadow => 1,
2006 NamespaceError::Duplicate => 2,
2007 NamespaceError::Conversion => 3,
2008 NamespaceError::BadEntry => 4,
2009 NamespaceError::DictionaryRead => 5,
2010
2011 NamespaceError::UnknownOrdinal_(value) => value,
2012 }
2013 }
2014 }
2015
2016 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceError, ___E> for NamespaceError
2017 where
2018 ___E: ?Sized,
2019 {
2020 #[inline]
2021 fn encode(
2022 self,
2023 encoder: &mut ___E,
2024 out: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceError>,
2025 _: (),
2026 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2027 ::fidl_next::Encode::encode(&self, encoder, out, ())
2028 }
2029 }
2030
2031 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NamespaceError, ___E> for &'a NamespaceError
2032 where
2033 ___E: ?Sized,
2034 {
2035 #[inline]
2036 fn encode(
2037 self,
2038 encoder: &mut ___E,
2039 out: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceError>,
2040 _: (),
2041 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2042 ::fidl_next::munge!(let crate::wire::NamespaceError { value } = out);
2043 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
2044 NamespaceError::Shadow => 1,
2045
2046 NamespaceError::Duplicate => 2,
2047
2048 NamespaceError::Conversion => 3,
2049
2050 NamespaceError::BadEntry => 4,
2051
2052 NamespaceError::DictionaryRead => 5,
2053
2054 NamespaceError::UnknownOrdinal_(value) => value,
2055 }));
2056
2057 Ok(())
2058 }
2059 }
2060
2061 impl ::core::convert::From<crate::wire::NamespaceError> for NamespaceError {
2062 fn from(wire: crate::wire::NamespaceError) -> Self {
2063 match u32::from(wire.value) {
2064 1 => Self::Shadow,
2065
2066 2 => Self::Duplicate,
2067
2068 3 => Self::Conversion,
2069
2070 4 => Self::BadEntry,
2071
2072 5 => Self::DictionaryRead,
2073
2074 value => Self::UnknownOrdinal_(value),
2075 }
2076 }
2077 }
2078
2079 impl ::fidl_next::FromWire<crate::wire::NamespaceError> for NamespaceError {
2080 #[inline]
2081 fn from_wire(wire: crate::wire::NamespaceError) -> Self {
2082 Self::from(wire)
2083 }
2084 }
2085
2086 impl ::fidl_next::FromWireRef<crate::wire::NamespaceError> for NamespaceError {
2087 #[inline]
2088 fn from_wire_ref(wire: &crate::wire::NamespaceError) -> Self {
2089 Self::from(*wire)
2090 }
2091 }
2092
2093 pub type RealmOpenExposedDirResponse = ();
2094
2095 pub type RealmCreateChildResponse = ();
2096
2097 #[derive(Debug, Clone, PartialEq)]
2098 pub struct RealmDestroyChildRequest {
2099 pub child: ::fidl_next_common_fuchsia_component_decl::natural::ChildRef,
2100 }
2101
2102 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
2103 for RealmDestroyChildRequest
2104 where
2105 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2106 ___E: ::fidl_next::Encoder,
2107 {
2108 #[inline]
2109 fn encode(
2110 self,
2111 encoder_: &mut ___E,
2112 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
2113 _: (),
2114 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2115 ::fidl_next::munge! {
2116 let crate::wire::RealmDestroyChildRequest {
2117 child,
2118
2119 } = out_;
2120 }
2121
2122 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2123
2124 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2125
2126 Ok(())
2127 }
2128 }
2129
2130 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
2131 for &'a RealmDestroyChildRequest
2132 where
2133 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2134 ___E: ::fidl_next::Encoder,
2135 {
2136 #[inline]
2137 fn encode(
2138 self,
2139 encoder_: &mut ___E,
2140 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
2141 _: (),
2142 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2143 ::fidl_next::munge! {
2144 let crate::wire::RealmDestroyChildRequest {
2145 child,
2146
2147 } = out_;
2148 }
2149
2150 ::fidl_next::Encode::encode(&self.child, encoder_, child, ())?;
2151
2152 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2153
2154 Ok(())
2155 }
2156 }
2157
2158 unsafe impl<___E>
2159 ::fidl_next::EncodeOption<
2160 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2161 ___E,
2162 > for RealmDestroyChildRequest
2163 where
2164 ___E: ::fidl_next::Encoder + ?Sized,
2165 RealmDestroyChildRequest:
2166 ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>,
2167 {
2168 #[inline]
2169 fn encode_option(
2170 this: ::core::option::Option<Self>,
2171 encoder: &mut ___E,
2172 out: &mut ::core::mem::MaybeUninit<
2173 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2174 >,
2175 _: (),
2176 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2177 if let Some(inner) = this {
2178 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2179 ::fidl_next::wire::Box::encode_present(out);
2180 } else {
2181 ::fidl_next::wire::Box::encode_absent(out);
2182 }
2183
2184 Ok(())
2185 }
2186 }
2187
2188 unsafe impl<'a, ___E>
2189 ::fidl_next::EncodeOption<
2190 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2191 ___E,
2192 > for &'a RealmDestroyChildRequest
2193 where
2194 ___E: ::fidl_next::Encoder + ?Sized,
2195 &'a RealmDestroyChildRequest:
2196 ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>,
2197 {
2198 #[inline]
2199 fn encode_option(
2200 this: ::core::option::Option<Self>,
2201 encoder: &mut ___E,
2202 out: &mut ::core::mem::MaybeUninit<
2203 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2204 >,
2205 _: (),
2206 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2207 if let Some(inner) = this {
2208 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2209 ::fidl_next::wire::Box::encode_present(out);
2210 } else {
2211 ::fidl_next::wire::Box::encode_absent(out);
2212 }
2213
2214 Ok(())
2215 }
2216 }
2217
2218 impl<'de> ::fidl_next::FromWire<crate::wire::RealmDestroyChildRequest<'de>>
2219 for RealmDestroyChildRequest
2220 {
2221 #[inline]
2222 fn from_wire(wire: crate::wire::RealmDestroyChildRequest<'de>) -> Self {
2223 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2224 }
2225 }
2226
2227 impl<'de> ::fidl_next::FromWireRef<crate::wire::RealmDestroyChildRequest<'de>>
2228 for RealmDestroyChildRequest
2229 {
2230 #[inline]
2231 fn from_wire_ref(wire: &crate::wire::RealmDestroyChildRequest<'de>) -> Self {
2232 Self { child: ::fidl_next::FromWireRef::from_wire_ref(&wire.child) }
2233 }
2234 }
2235
2236 pub type RealmDestroyChildResponse = ();
2237
2238 pub type RealmListChildrenResponse = ();
2239
2240 pub type RealmOpenControllerResponse = ();
2241
2242 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2243 #[repr(u32)]
2244 pub enum StatusError {
2245 Provider = 1,
2246 ResponseInvalid = 2,
2247 StatusUnknown = 3,
2248 Unsupported = 4,
2249 }
2250 impl ::core::convert::TryFrom<u32> for StatusError {
2251 type Error = ::fidl_next::UnknownStrictEnumMemberError;
2252 fn try_from(
2253 value: u32,
2254 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
2255 match value {
2256 1 => Ok(Self::Provider),
2257 2 => Ok(Self::ResponseInvalid),
2258 3 => Ok(Self::StatusUnknown),
2259 4 => Ok(Self::Unsupported),
2260
2261 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
2262 }
2263 }
2264 }
2265
2266 impl ::std::convert::From<StatusError> for u32 {
2267 fn from(value: StatusError) -> Self {
2268 match value {
2269 StatusError::Provider => 1,
2270 StatusError::ResponseInvalid => 2,
2271 StatusError::StatusUnknown => 3,
2272 StatusError::Unsupported => 4,
2273 }
2274 }
2275 }
2276
2277 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StatusError, ___E> for StatusError
2278 where
2279 ___E: ?Sized,
2280 {
2281 #[inline]
2282 fn encode(
2283 self,
2284 encoder: &mut ___E,
2285 out: &mut ::core::mem::MaybeUninit<crate::wire::StatusError>,
2286 _: (),
2287 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2288 ::fidl_next::Encode::encode(&self, encoder, out, ())
2289 }
2290 }
2291
2292 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StatusError, ___E> for &'a StatusError
2293 where
2294 ___E: ?Sized,
2295 {
2296 #[inline]
2297 fn encode(
2298 self,
2299 encoder: &mut ___E,
2300 out: &mut ::core::mem::MaybeUninit<crate::wire::StatusError>,
2301 _: (),
2302 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2303 ::fidl_next::munge!(let crate::wire::StatusError { value } = out);
2304 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
2305 StatusError::Provider => 1,
2306
2307 StatusError::ResponseInvalid => 2,
2308
2309 StatusError::StatusUnknown => 3,
2310
2311 StatusError::Unsupported => 4,
2312 }));
2313
2314 Ok(())
2315 }
2316 }
2317
2318 impl ::core::convert::From<crate::wire::StatusError> for StatusError {
2319 fn from(wire: crate::wire::StatusError) -> Self {
2320 match u32::from(wire.value) {
2321 1 => Self::Provider,
2322
2323 2 => Self::ResponseInvalid,
2324
2325 3 => Self::StatusUnknown,
2326
2327 4 => Self::Unsupported,
2328
2329 _ => unsafe { ::core::hint::unreachable_unchecked() },
2330 }
2331 }
2332 }
2333
2334 impl ::fidl_next::FromWire<crate::wire::StatusError> for StatusError {
2335 #[inline]
2336 fn from_wire(wire: crate::wire::StatusError) -> Self {
2337 Self::from(wire)
2338 }
2339 }
2340
2341 impl ::fidl_next::FromWireRef<crate::wire::StatusError> for StatusError {
2342 #[inline]
2343 fn from_wire_ref(wire: &crate::wire::StatusError) -> Self {
2344 Self::from(*wire)
2345 }
2346 }
2347
2348 pub type StorageAdminOpenStorageResponse = ();
2349
2350 pub type StorageAdminListStorageInRealmResponse = ();
2351
2352 pub type StorageAdminOpenComponentStorageByIdResponse = ();
2353
2354 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2355 pub struct StorageAdminDeleteComponentStorageRequest {
2356 pub relative_moniker: ::std::string::String,
2357 }
2358
2359 unsafe impl<___E>
2360 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
2361 for StorageAdminDeleteComponentStorageRequest
2362 where
2363 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2364 ___E: ::fidl_next::Encoder,
2365 {
2366 #[inline]
2367 fn encode(
2368 self,
2369 encoder_: &mut ___E,
2370 out_: &mut ::core::mem::MaybeUninit<
2371 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2372 >,
2373 _: (),
2374 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2375 ::fidl_next::munge! {
2376 let crate::wire::StorageAdminDeleteComponentStorageRequest {
2377 relative_moniker,
2378
2379 } = out_;
2380 }
2381
2382 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
2383
2384 let mut _field =
2385 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
2386 ::fidl_next::Constrained::validate(_field, 4096)?;
2387
2388 Ok(())
2389 }
2390 }
2391
2392 unsafe impl<'a, ___E>
2393 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
2394 for &'a StorageAdminDeleteComponentStorageRequest
2395 where
2396 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2397 ___E: ::fidl_next::Encoder,
2398 {
2399 #[inline]
2400 fn encode(
2401 self,
2402 encoder_: &mut ___E,
2403 out_: &mut ::core::mem::MaybeUninit<
2404 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2405 >,
2406 _: (),
2407 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2408 ::fidl_next::munge! {
2409 let crate::wire::StorageAdminDeleteComponentStorageRequest {
2410 relative_moniker,
2411
2412 } = out_;
2413 }
2414
2415 ::fidl_next::Encode::encode(&self.relative_moniker, encoder_, relative_moniker, 4096)?;
2416
2417 let mut _field =
2418 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
2419 ::fidl_next::Constrained::validate(_field, 4096)?;
2420
2421 Ok(())
2422 }
2423 }
2424
2425 unsafe impl<___E>
2426 ::fidl_next::EncodeOption<
2427 ::fidl_next::wire::Box<
2428 'static,
2429 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2430 >,
2431 ___E,
2432 > for StorageAdminDeleteComponentStorageRequest
2433 where
2434 ___E: ::fidl_next::Encoder + ?Sized,
2435 StorageAdminDeleteComponentStorageRequest: ::fidl_next::Encode<
2436 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2437 ___E,
2438 >,
2439 {
2440 #[inline]
2441 fn encode_option(
2442 this: ::core::option::Option<Self>,
2443 encoder: &mut ___E,
2444 out: &mut ::core::mem::MaybeUninit<
2445 ::fidl_next::wire::Box<
2446 'static,
2447 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2448 >,
2449 >,
2450 _: (),
2451 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2452 if let Some(inner) = this {
2453 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2454 ::fidl_next::wire::Box::encode_present(out);
2455 } else {
2456 ::fidl_next::wire::Box::encode_absent(out);
2457 }
2458
2459 Ok(())
2460 }
2461 }
2462
2463 unsafe impl<'a, ___E>
2464 ::fidl_next::EncodeOption<
2465 ::fidl_next::wire::Box<
2466 'static,
2467 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2468 >,
2469 ___E,
2470 > for &'a StorageAdminDeleteComponentStorageRequest
2471 where
2472 ___E: ::fidl_next::Encoder + ?Sized,
2473 &'a StorageAdminDeleteComponentStorageRequest: ::fidl_next::Encode<
2474 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2475 ___E,
2476 >,
2477 {
2478 #[inline]
2479 fn encode_option(
2480 this: ::core::option::Option<Self>,
2481 encoder: &mut ___E,
2482 out: &mut ::core::mem::MaybeUninit<
2483 ::fidl_next::wire::Box<
2484 'static,
2485 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2486 >,
2487 >,
2488 _: (),
2489 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2490 if let Some(inner) = this {
2491 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2492 ::fidl_next::wire::Box::encode_present(out);
2493 } else {
2494 ::fidl_next::wire::Box::encode_absent(out);
2495 }
2496
2497 Ok(())
2498 }
2499 }
2500
2501 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminDeleteComponentStorageRequest<'de>>
2502 for StorageAdminDeleteComponentStorageRequest
2503 {
2504 #[inline]
2505 fn from_wire(wire: crate::wire::StorageAdminDeleteComponentStorageRequest<'de>) -> Self {
2506 Self { relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker) }
2507 }
2508 }
2509
2510 impl<'de> ::fidl_next::FromWireRef<crate::wire::StorageAdminDeleteComponentStorageRequest<'de>>
2511 for StorageAdminDeleteComponentStorageRequest
2512 {
2513 #[inline]
2514 fn from_wire_ref(
2515 wire: &crate::wire::StorageAdminDeleteComponentStorageRequest<'de>,
2516 ) -> Self {
2517 Self {
2518 relative_moniker: ::fidl_next::FromWireRef::from_wire_ref(&wire.relative_moniker),
2519 }
2520 }
2521 }
2522
2523 pub type StorageAdminDeleteComponentStorageResponse = ();
2524
2525 #[doc = " Metadata about status of the storage\n"]
2526 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2527 pub struct StorageStatus {
2528 pub total_size: ::core::option::Option<u64>,
2529
2530 pub used_size: ::core::option::Option<u64>,
2531 }
2532
2533 impl StorageStatus {
2534 fn __max_ordinal(&self) -> usize {
2535 if self.used_size.is_some() {
2536 return 2;
2537 }
2538
2539 if self.total_size.is_some() {
2540 return 1;
2541 }
2542
2543 0
2544 }
2545 }
2546
2547 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StorageStatus<'static>, ___E> for StorageStatus
2548 where
2549 ___E: ::fidl_next::Encoder + ?Sized,
2550 {
2551 #[inline]
2552 fn encode(
2553 mut self,
2554 encoder: &mut ___E,
2555 out: &mut ::core::mem::MaybeUninit<crate::wire::StorageStatus<'static>>,
2556 _: (),
2557 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2558 ::fidl_next::munge!(let crate::wire::StorageStatus { table } = out);
2559
2560 let max_ord = self.__max_ordinal();
2561
2562 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2563 ::fidl_next::Wire::zero_padding(&mut out);
2564
2565 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2566 ::fidl_next::wire::Envelope,
2567 >(encoder, max_ord);
2568
2569 for i in 1..=max_ord {
2570 match i {
2571 2 => {
2572 if let Some(value) = self.used_size.take() {
2573 ::fidl_next::wire::Envelope::encode_value::<
2574 ::fidl_next::wire::Uint64,
2575 ___E,
2576 >(
2577 value, preallocated.encoder, &mut out, ()
2578 )?;
2579 } else {
2580 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2581 }
2582 }
2583
2584 1 => {
2585 if let Some(value) = self.total_size.take() {
2586 ::fidl_next::wire::Envelope::encode_value::<
2587 ::fidl_next::wire::Uint64,
2588 ___E,
2589 >(
2590 value, preallocated.encoder, &mut out, ()
2591 )?;
2592 } else {
2593 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2594 }
2595 }
2596
2597 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2598 }
2599 unsafe {
2600 preallocated.write_next(out.assume_init_ref());
2601 }
2602 }
2603
2604 ::fidl_next::wire::Table::encode_len(table, max_ord);
2605
2606 Ok(())
2607 }
2608 }
2609
2610 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StorageStatus<'static>, ___E>
2611 for &'a StorageStatus
2612 where
2613 ___E: ::fidl_next::Encoder + ?Sized,
2614 {
2615 #[inline]
2616 fn encode(
2617 self,
2618 encoder: &mut ___E,
2619 out: &mut ::core::mem::MaybeUninit<crate::wire::StorageStatus<'static>>,
2620 _: (),
2621 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2622 ::fidl_next::munge!(let crate::wire::StorageStatus { table } = out);
2623
2624 let max_ord = self.__max_ordinal();
2625
2626 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2627 ::fidl_next::Wire::zero_padding(&mut out);
2628
2629 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2630 ::fidl_next::wire::Envelope,
2631 >(encoder, max_ord);
2632
2633 for i in 1..=max_ord {
2634 match i {
2635 2 => {
2636 if let Some(value) = &self.used_size {
2637 ::fidl_next::wire::Envelope::encode_value::<
2638 ::fidl_next::wire::Uint64,
2639 ___E,
2640 >(
2641 value, preallocated.encoder, &mut out, ()
2642 )?;
2643 } else {
2644 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2645 }
2646 }
2647
2648 1 => {
2649 if let Some(value) = &self.total_size {
2650 ::fidl_next::wire::Envelope::encode_value::<
2651 ::fidl_next::wire::Uint64,
2652 ___E,
2653 >(
2654 value, preallocated.encoder, &mut out, ()
2655 )?;
2656 } else {
2657 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2658 }
2659 }
2660
2661 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2662 }
2663 unsafe {
2664 preallocated.write_next(out.assume_init_ref());
2665 }
2666 }
2667
2668 ::fidl_next::wire::Table::encode_len(table, max_ord);
2669
2670 Ok(())
2671 }
2672 }
2673
2674 impl<'de> ::fidl_next::FromWire<crate::wire::StorageStatus<'de>> for StorageStatus {
2675 #[inline]
2676 fn from_wire(wire_: crate::wire::StorageStatus<'de>) -> Self {
2677 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2678
2679 let total_size = wire_.table.get(1);
2680
2681 let used_size = wire_.table.get(2);
2682
2683 Self {
2684 total_size: total_size.map(|envelope| {
2685 ::fidl_next::FromWire::from_wire(unsafe {
2686 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
2687 })
2688 }),
2689
2690 used_size: used_size.map(|envelope| {
2691 ::fidl_next::FromWire::from_wire(unsafe {
2692 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
2693 })
2694 }),
2695 }
2696 }
2697 }
2698
2699 impl<'de> ::fidl_next::FromWireRef<crate::wire::StorageStatus<'de>> for StorageStatus {
2700 #[inline]
2701 fn from_wire_ref(wire: &crate::wire::StorageStatus<'de>) -> Self {
2702 Self {
2703 total_size: wire.table.get(1).map(|envelope| {
2704 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2705 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
2706 })
2707 }),
2708
2709 used_size: wire.table.get(2).map(|envelope| {
2710 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2711 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
2712 })
2713 }),
2714 }
2715 }
2716 }
2717
2718 pub type StorageAdminDeleteAllStorageContentsResponse = ();
2719
2720 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2721 pub struct StorageIteratorNextResponse {
2722 pub relative_monikers: ::std::vec::Vec<::std::string::String>,
2723 }
2724
2725 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
2726 for StorageIteratorNextResponse
2727 where
2728 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2729 ___E: ::fidl_next::Encoder,
2730 {
2731 #[inline]
2732 fn encode(
2733 self,
2734 encoder_: &mut ___E,
2735 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
2736 _: (),
2737 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2738 ::fidl_next::munge! {
2739 let crate::wire::StorageIteratorNextResponse {
2740 relative_monikers,
2741
2742 } = out_;
2743 }
2744
2745 ::fidl_next::Encode::encode(
2746 self.relative_monikers,
2747 encoder_,
2748 relative_monikers,
2749 (4294967295, 4096),
2750 )?;
2751
2752 let mut _field =
2753 unsafe { ::fidl_next::Slot::new_unchecked(relative_monikers.as_mut_ptr()) };
2754 ::fidl_next::Constrained::validate(_field, (4294967295, 4096))?;
2755
2756 Ok(())
2757 }
2758 }
2759
2760 unsafe impl<'a, ___E>
2761 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
2762 for &'a StorageIteratorNextResponse
2763 where
2764 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2765 ___E: ::fidl_next::Encoder,
2766 {
2767 #[inline]
2768 fn encode(
2769 self,
2770 encoder_: &mut ___E,
2771 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
2772 _: (),
2773 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2774 ::fidl_next::munge! {
2775 let crate::wire::StorageIteratorNextResponse {
2776 relative_monikers,
2777
2778 } = out_;
2779 }
2780
2781 ::fidl_next::Encode::encode(
2782 &self.relative_monikers,
2783 encoder_,
2784 relative_monikers,
2785 (4294967295, 4096),
2786 )?;
2787
2788 let mut _field =
2789 unsafe { ::fidl_next::Slot::new_unchecked(relative_monikers.as_mut_ptr()) };
2790 ::fidl_next::Constrained::validate(_field, (4294967295, 4096))?;
2791
2792 Ok(())
2793 }
2794 }
2795
2796 unsafe impl<___E>
2797 ::fidl_next::EncodeOption<
2798 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2799 ___E,
2800 > for StorageIteratorNextResponse
2801 where
2802 ___E: ::fidl_next::Encoder + ?Sized,
2803 StorageIteratorNextResponse:
2804 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>,
2805 {
2806 #[inline]
2807 fn encode_option(
2808 this: ::core::option::Option<Self>,
2809 encoder: &mut ___E,
2810 out: &mut ::core::mem::MaybeUninit<
2811 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2812 >,
2813 _: (),
2814 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2815 if let Some(inner) = this {
2816 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2817 ::fidl_next::wire::Box::encode_present(out);
2818 } else {
2819 ::fidl_next::wire::Box::encode_absent(out);
2820 }
2821
2822 Ok(())
2823 }
2824 }
2825
2826 unsafe impl<'a, ___E>
2827 ::fidl_next::EncodeOption<
2828 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2829 ___E,
2830 > for &'a StorageIteratorNextResponse
2831 where
2832 ___E: ::fidl_next::Encoder + ?Sized,
2833 &'a StorageIteratorNextResponse:
2834 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>,
2835 {
2836 #[inline]
2837 fn encode_option(
2838 this: ::core::option::Option<Self>,
2839 encoder: &mut ___E,
2840 out: &mut ::core::mem::MaybeUninit<
2841 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2842 >,
2843 _: (),
2844 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2845 if let Some(inner) = this {
2846 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2847 ::fidl_next::wire::Box::encode_present(out);
2848 } else {
2849 ::fidl_next::wire::Box::encode_absent(out);
2850 }
2851
2852 Ok(())
2853 }
2854 }
2855
2856 impl<'de> ::fidl_next::FromWire<crate::wire::StorageIteratorNextResponse<'de>>
2857 for StorageIteratorNextResponse
2858 {
2859 #[inline]
2860 fn from_wire(wire: crate::wire::StorageIteratorNextResponse<'de>) -> Self {
2861 Self { relative_monikers: ::fidl_next::FromWire::from_wire(wire.relative_monikers) }
2862 }
2863 }
2864
2865 impl<'de> ::fidl_next::FromWireRef<crate::wire::StorageIteratorNextResponse<'de>>
2866 for StorageIteratorNextResponse
2867 {
2868 #[inline]
2869 fn from_wire_ref(wire: &crate::wire::StorageIteratorNextResponse<'de>) -> Self {
2870 Self {
2871 relative_monikers: ::fidl_next::FromWireRef::from_wire_ref(&wire.relative_monikers),
2872 }
2873 }
2874 }
2875
2876 pub type ChildName = ::std::string::String;
2877
2878 pub type UrlScheme = ::std::string::String;
2879}
2880
2881pub mod wire {
2882
2883 pub type Name<'de> = ::fidl_next::wire::String<'de>;
2885
2886 #[derive(Debug)]
2888 #[repr(C)]
2889 pub struct ChildIteratorNextResponse<'de> {
2890 pub children: ::fidl_next::wire::Vector<
2891 'de,
2892 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'de>,
2893 >,
2894 }
2895
2896 static_assertions::const_assert_eq!(std::mem::size_of::<ChildIteratorNextResponse<'_>>(), 16);
2897 static_assertions::const_assert_eq!(std::mem::align_of::<ChildIteratorNextResponse<'_>>(), 8);
2898
2899 static_assertions::const_assert_eq!(
2900 std::mem::offset_of!(ChildIteratorNextResponse<'_>, children),
2901 0
2902 );
2903
2904 impl ::fidl_next::Constrained for ChildIteratorNextResponse<'_> {
2905 type Constraint = ();
2906
2907 fn validate(
2908 _: ::fidl_next::Slot<'_, Self>,
2909 _: Self::Constraint,
2910 ) -> Result<(), ::fidl_next::ValidationError> {
2911 Ok(())
2912 }
2913 }
2914
2915 unsafe impl ::fidl_next::Wire for ChildIteratorNextResponse<'static> {
2916 type Narrowed<'de> = ChildIteratorNextResponse<'de>;
2917
2918 #[inline]
2919 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2920 ::fidl_next::munge! {
2921 let Self {
2922 children,
2923
2924 } = &mut *out_;
2925 }
2926
2927 ::fidl_next::Wire::zero_padding(children);
2928 }
2929 }
2930
2931 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ChildIteratorNextResponse<'de>
2932 where
2933 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2934 ___D: ::fidl_next::Decoder<'de>,
2935 {
2936 fn decode(
2937 slot_: ::fidl_next::Slot<'_, Self>,
2938 decoder_: &mut ___D,
2939 _: (),
2940 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2941 ::fidl_next::munge! {
2942 let Self {
2943 mut children,
2944
2945 } = slot_;
2946 }
2947
2948 let _field = children.as_mut();
2949 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2950 ::fidl_next::Decode::decode(children.as_mut(), decoder_, (128, ()))?;
2951
2952 let children = unsafe { children.deref_unchecked() };
2953
2954 if children.len() > 128 {
2955 return Err(::fidl_next::DecodeError::VectorTooLong {
2956 size: children.len() as u64,
2957 limit: 128,
2958 });
2959 }
2960
2961 Ok(())
2962 }
2963 }
2964
2965 impl<'de> ::fidl_next::IntoNatural for ChildIteratorNextResponse<'de> {
2966 type Natural = crate::natural::ChildIteratorNextResponse;
2967 }
2968
2969 pub type ControllerStartResponse = ::fidl_next::wire::Unit;
2971
2972 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
2974 #[repr(transparent)]
2975 pub struct Error {
2976 pub(crate) value: ::fidl_next::wire::Uint32,
2977 }
2978
2979 impl ::fidl_next::Constrained for Error {
2980 type Constraint = ();
2981
2982 fn validate(
2983 _: ::fidl_next::Slot<'_, Self>,
2984 _: Self::Constraint,
2985 ) -> Result<(), ::fidl_next::ValidationError> {
2986 Ok(())
2987 }
2988 }
2989
2990 unsafe impl ::fidl_next::Wire for Error {
2991 type Narrowed<'de> = Self;
2992
2993 #[inline]
2994 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
2995 }
2997 }
2998
2999 impl Error {
3000 pub const INTERNAL: Error = Error { value: ::fidl_next::wire::Uint32(1) };
3001
3002 pub const INVALID_ARGUMENTS: Error = Error { value: ::fidl_next::wire::Uint32(2) };
3003
3004 pub const UNSUPPORTED: Error = Error { value: ::fidl_next::wire::Uint32(3) };
3005
3006 pub const ACCESS_DENIED: Error = Error { value: ::fidl_next::wire::Uint32(4) };
3007
3008 pub const INSTANCE_NOT_FOUND: Error = Error { value: ::fidl_next::wire::Uint32(5) };
3009
3010 pub const INSTANCE_ALREADY_EXISTS: Error = Error { value: ::fidl_next::wire::Uint32(6) };
3011
3012 pub const INSTANCE_CANNOT_START: Error = Error { value: ::fidl_next::wire::Uint32(7) };
3013
3014 pub const INSTANCE_CANNOT_RESOLVE: Error = Error { value: ::fidl_next::wire::Uint32(8) };
3015
3016 pub const COLLECTION_NOT_FOUND: Error = Error { value: ::fidl_next::wire::Uint32(9) };
3017
3018 pub const RESOURCE_UNAVAILABLE: Error = Error { value: ::fidl_next::wire::Uint32(10) };
3019
3020 pub const INSTANCE_DIED: Error = Error { value: ::fidl_next::wire::Uint32(11) };
3021
3022 pub const RESOURCE_NOT_FOUND: Error = Error { value: ::fidl_next::wire::Uint32(12) };
3023
3024 pub const INSTANCE_CANNOT_UNRESOLVE: Error = Error { value: ::fidl_next::wire::Uint32(13) };
3025
3026 pub const INSTANCE_ALREADY_STARTED: Error = Error { value: ::fidl_next::wire::Uint32(14) };
3027
3028 pub const DEPENDENCY_CYCLE: Error = Error { value: ::fidl_next::wire::Uint32(15) };
3029 }
3030
3031 unsafe impl<___D> ::fidl_next::Decode<___D> for Error
3032 where
3033 ___D: ?Sized,
3034 {
3035 fn decode(
3036 slot: ::fidl_next::Slot<'_, Self>,
3037 _: &mut ___D,
3038 _: (),
3039 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3040 Ok(())
3041 }
3042 }
3043
3044 impl ::core::convert::From<crate::natural::Error> for Error {
3045 fn from(natural: crate::natural::Error) -> Self {
3046 match natural {
3047 crate::natural::Error::Internal => Error::INTERNAL,
3048
3049 crate::natural::Error::InvalidArguments => Error::INVALID_ARGUMENTS,
3050
3051 crate::natural::Error::Unsupported => Error::UNSUPPORTED,
3052
3053 crate::natural::Error::AccessDenied => Error::ACCESS_DENIED,
3054
3055 crate::natural::Error::InstanceNotFound => Error::INSTANCE_NOT_FOUND,
3056
3057 crate::natural::Error::InstanceAlreadyExists => Error::INSTANCE_ALREADY_EXISTS,
3058
3059 crate::natural::Error::InstanceCannotStart => Error::INSTANCE_CANNOT_START,
3060
3061 crate::natural::Error::InstanceCannotResolve => Error::INSTANCE_CANNOT_RESOLVE,
3062
3063 crate::natural::Error::CollectionNotFound => Error::COLLECTION_NOT_FOUND,
3064
3065 crate::natural::Error::ResourceUnavailable => Error::RESOURCE_UNAVAILABLE,
3066
3067 crate::natural::Error::InstanceDied => Error::INSTANCE_DIED,
3068
3069 crate::natural::Error::ResourceNotFound => Error::RESOURCE_NOT_FOUND,
3070
3071 crate::natural::Error::InstanceCannotUnresolve => Error::INSTANCE_CANNOT_UNRESOLVE,
3072
3073 crate::natural::Error::InstanceAlreadyStarted => Error::INSTANCE_ALREADY_STARTED,
3074
3075 crate::natural::Error::DependencyCycle => Error::DEPENDENCY_CYCLE,
3076
3077 crate::natural::Error::UnknownOrdinal_(value) => {
3078 Error { value: ::fidl_next::wire::Uint32::from(value) }
3079 }
3080 }
3081 }
3082 }
3083
3084 impl ::fidl_next::IntoNatural for Error {
3085 type Natural = crate::natural::Error;
3086 }
3087
3088 pub type ControllerOpenExposedDirResponse = ::fidl_next::wire::Unit;
3090
3091 pub type ControllerDestroyResponse = ::fidl_next::wire::Unit;
3093
3094 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
3096 #[repr(transparent)]
3097 pub struct DeletionError {
3098 pub(crate) value: ::fidl_next::wire::Uint32,
3099 }
3100
3101 impl ::fidl_next::Constrained for DeletionError {
3102 type Constraint = ();
3103
3104 fn validate(
3105 _: ::fidl_next::Slot<'_, Self>,
3106 _: Self::Constraint,
3107 ) -> Result<(), ::fidl_next::ValidationError> {
3108 Ok(())
3109 }
3110 }
3111
3112 unsafe impl ::fidl_next::Wire for DeletionError {
3113 type Narrowed<'de> = Self;
3114
3115 #[inline]
3116 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
3117 }
3119 }
3120
3121 impl DeletionError {
3122 pub const CONNECTION: DeletionError = DeletionError { value: ::fidl_next::wire::Uint32(1) };
3123
3124 pub const PROTOCOL: DeletionError = DeletionError { value: ::fidl_next::wire::Uint32(2) };
3125
3126 pub const NONE_AVAILABLE: DeletionError =
3127 DeletionError { value: ::fidl_next::wire::Uint32(3) };
3128
3129 pub const UNSUPPORTED: DeletionError =
3130 DeletionError { value: ::fidl_next::wire::Uint32(4) };
3131 }
3132
3133 unsafe impl<___D> ::fidl_next::Decode<___D> for DeletionError
3134 where
3135 ___D: ?Sized,
3136 {
3137 fn decode(
3138 slot: ::fidl_next::Slot<'_, Self>,
3139 _: &mut ___D,
3140 _: (),
3141 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3142 ::fidl_next::munge!(let Self { value } = slot);
3143
3144 match u32::from(*value) {
3145 1 | 2 | 3 | 4 => (),
3146 unknown => {
3147 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
3148 }
3149 }
3150
3151 Ok(())
3152 }
3153 }
3154
3155 impl ::core::convert::From<crate::natural::DeletionError> for DeletionError {
3156 fn from(natural: crate::natural::DeletionError) -> Self {
3157 match natural {
3158 crate::natural::DeletionError::Connection => DeletionError::CONNECTION,
3159
3160 crate::natural::DeletionError::Protocol => DeletionError::PROTOCOL,
3161
3162 crate::natural::DeletionError::NoneAvailable => DeletionError::NONE_AVAILABLE,
3163
3164 crate::natural::DeletionError::Unsupported => DeletionError::UNSUPPORTED,
3165 }
3166 }
3167 }
3168
3169 impl ::fidl_next::IntoNatural for DeletionError {
3170 type Natural = crate::natural::DeletionError;
3171 }
3172
3173 #[repr(C)]
3175 pub struct DestroyedPayload<'de> {
3176 pub(crate) table: ::fidl_next::wire::Table<'de>,
3177 }
3178
3179 impl<'de> Drop for DestroyedPayload<'de> {
3180 fn drop(&mut self) {}
3181 }
3182
3183 impl ::fidl_next::Constrained for DestroyedPayload<'_> {
3184 type Constraint = ();
3185
3186 fn validate(
3187 _: ::fidl_next::Slot<'_, Self>,
3188 _: Self::Constraint,
3189 ) -> Result<(), ::fidl_next::ValidationError> {
3190 Ok(())
3191 }
3192 }
3193
3194 unsafe impl ::fidl_next::Wire for DestroyedPayload<'static> {
3195 type Narrowed<'de> = DestroyedPayload<'de>;
3196
3197 #[inline]
3198 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3199 ::fidl_next::munge!(let Self { table } = out);
3200 ::fidl_next::wire::Table::zero_padding(table);
3201 }
3202 }
3203
3204 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DestroyedPayload<'de>
3205 where
3206 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3207 {
3208 fn decode(
3209 slot: ::fidl_next::Slot<'_, Self>,
3210 decoder: &mut ___D,
3211 _: (),
3212 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3213 ::fidl_next::munge!(let Self { table } = slot);
3214
3215 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3216 match ordinal {
3217 0 => unsafe { ::core::hint::unreachable_unchecked() },
3218
3219 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3220 }
3221 })
3222 }
3223 }
3224
3225 impl<'de> DestroyedPayload<'de> {}
3226
3227 impl<'de> ::core::fmt::Debug for DestroyedPayload<'de> {
3228 fn fmt(
3229 &self,
3230 f: &mut ::core::fmt::Formatter<'_>,
3231 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3232 f.debug_struct("DestroyedPayload").finish()
3233 }
3234 }
3235
3236 impl<'de> ::fidl_next::IntoNatural for DestroyedPayload<'de> {
3237 type Natural = crate::natural::DestroyedPayload;
3238 }
3239
3240 #[repr(C)]
3242 pub struct DiscoveredPayload<'de> {
3243 pub(crate) table: ::fidl_next::wire::Table<'de>,
3244 }
3245
3246 impl<'de> Drop for DiscoveredPayload<'de> {
3247 fn drop(&mut self) {}
3248 }
3249
3250 impl ::fidl_next::Constrained for DiscoveredPayload<'_> {
3251 type Constraint = ();
3252
3253 fn validate(
3254 _: ::fidl_next::Slot<'_, Self>,
3255 _: Self::Constraint,
3256 ) -> Result<(), ::fidl_next::ValidationError> {
3257 Ok(())
3258 }
3259 }
3260
3261 unsafe impl ::fidl_next::Wire for DiscoveredPayload<'static> {
3262 type Narrowed<'de> = DiscoveredPayload<'de>;
3263
3264 #[inline]
3265 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3266 ::fidl_next::munge!(let Self { table } = out);
3267 ::fidl_next::wire::Table::zero_padding(table);
3268 }
3269 }
3270
3271 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DiscoveredPayload<'de>
3272 where
3273 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3274 {
3275 fn decode(
3276 slot: ::fidl_next::Slot<'_, Self>,
3277 decoder: &mut ___D,
3278 _: (),
3279 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3280 ::fidl_next::munge!(let Self { table } = slot);
3281
3282 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3283 match ordinal {
3284 0 => unsafe { ::core::hint::unreachable_unchecked() },
3285
3286 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3287 }
3288 })
3289 }
3290 }
3291
3292 impl<'de> DiscoveredPayload<'de> {}
3293
3294 impl<'de> ::core::fmt::Debug for DiscoveredPayload<'de> {
3295 fn fmt(
3296 &self,
3297 f: &mut ::core::fmt::Formatter<'_>,
3298 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3299 f.debug_struct("DiscoveredPayload").finish()
3300 }
3301 }
3302
3303 impl<'de> ::fidl_next::IntoNatural for DiscoveredPayload<'de> {
3304 type Natural = crate::natural::DiscoveredPayload;
3305 }
3306
3307 #[repr(C)]
3309 pub struct PurgedPayload<'de> {
3310 pub(crate) table: ::fidl_next::wire::Table<'de>,
3311 }
3312
3313 impl<'de> Drop for PurgedPayload<'de> {
3314 fn drop(&mut self) {}
3315 }
3316
3317 impl ::fidl_next::Constrained for PurgedPayload<'_> {
3318 type Constraint = ();
3319
3320 fn validate(
3321 _: ::fidl_next::Slot<'_, Self>,
3322 _: Self::Constraint,
3323 ) -> Result<(), ::fidl_next::ValidationError> {
3324 Ok(())
3325 }
3326 }
3327
3328 unsafe impl ::fidl_next::Wire for PurgedPayload<'static> {
3329 type Narrowed<'de> = PurgedPayload<'de>;
3330
3331 #[inline]
3332 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3333 ::fidl_next::munge!(let Self { table } = out);
3334 ::fidl_next::wire::Table::zero_padding(table);
3335 }
3336 }
3337
3338 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for PurgedPayload<'de>
3339 where
3340 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3341 {
3342 fn decode(
3343 slot: ::fidl_next::Slot<'_, Self>,
3344 decoder: &mut ___D,
3345 _: (),
3346 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3347 ::fidl_next::munge!(let Self { table } = slot);
3348
3349 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3350 match ordinal {
3351 0 => unsafe { ::core::hint::unreachable_unchecked() },
3352
3353 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3354 }
3355 })
3356 }
3357 }
3358
3359 impl<'de> PurgedPayload<'de> {}
3360
3361 impl<'de> ::core::fmt::Debug for PurgedPayload<'de> {
3362 fn fmt(
3363 &self,
3364 f: &mut ::core::fmt::Formatter<'_>,
3365 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3366 f.debug_struct("PurgedPayload").finish()
3367 }
3368 }
3369
3370 impl<'de> ::fidl_next::IntoNatural for PurgedPayload<'de> {
3371 type Natural = crate::natural::PurgedPayload;
3372 }
3373
3374 #[repr(C)]
3376 pub struct ResolvedPayload<'de> {
3377 pub(crate) table: ::fidl_next::wire::Table<'de>,
3378 }
3379
3380 impl<'de> Drop for ResolvedPayload<'de> {
3381 fn drop(&mut self) {}
3382 }
3383
3384 impl ::fidl_next::Constrained for ResolvedPayload<'_> {
3385 type Constraint = ();
3386
3387 fn validate(
3388 _: ::fidl_next::Slot<'_, Self>,
3389 _: Self::Constraint,
3390 ) -> Result<(), ::fidl_next::ValidationError> {
3391 Ok(())
3392 }
3393 }
3394
3395 unsafe impl ::fidl_next::Wire for ResolvedPayload<'static> {
3396 type Narrowed<'de> = ResolvedPayload<'de>;
3397
3398 #[inline]
3399 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3400 ::fidl_next::munge!(let Self { table } = out);
3401 ::fidl_next::wire::Table::zero_padding(table);
3402 }
3403 }
3404
3405 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ResolvedPayload<'de>
3406 where
3407 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3408 {
3409 fn decode(
3410 slot: ::fidl_next::Slot<'_, Self>,
3411 decoder: &mut ___D,
3412 _: (),
3413 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3414 ::fidl_next::munge!(let Self { table } = slot);
3415
3416 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3417 match ordinal {
3418 0 => unsafe { ::core::hint::unreachable_unchecked() },
3419
3420 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3421 }
3422 })
3423 }
3424 }
3425
3426 impl<'de> ResolvedPayload<'de> {}
3427
3428 impl<'de> ::core::fmt::Debug for ResolvedPayload<'de> {
3429 fn fmt(
3430 &self,
3431 f: &mut ::core::fmt::Formatter<'_>,
3432 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3433 f.debug_struct("ResolvedPayload").finish()
3434 }
3435 }
3436
3437 impl<'de> ::fidl_next::IntoNatural for ResolvedPayload<'de> {
3438 type Natural = crate::natural::ResolvedPayload;
3439 }
3440
3441 #[repr(C)]
3443 pub struct StartedPayload<'de> {
3444 pub(crate) table: ::fidl_next::wire::Table<'de>,
3445 }
3446
3447 impl<'de> Drop for StartedPayload<'de> {
3448 fn drop(&mut self) {}
3449 }
3450
3451 impl ::fidl_next::Constrained for StartedPayload<'_> {
3452 type Constraint = ();
3453
3454 fn validate(
3455 _: ::fidl_next::Slot<'_, Self>,
3456 _: Self::Constraint,
3457 ) -> Result<(), ::fidl_next::ValidationError> {
3458 Ok(())
3459 }
3460 }
3461
3462 unsafe impl ::fidl_next::Wire for StartedPayload<'static> {
3463 type Narrowed<'de> = StartedPayload<'de>;
3464
3465 #[inline]
3466 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3467 ::fidl_next::munge!(let Self { table } = out);
3468 ::fidl_next::wire::Table::zero_padding(table);
3469 }
3470 }
3471
3472 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StartedPayload<'de>
3473 where
3474 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3475 {
3476 fn decode(
3477 slot: ::fidl_next::Slot<'_, Self>,
3478 decoder: &mut ___D,
3479 _: (),
3480 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3481 ::fidl_next::munge!(let Self { table } = slot);
3482
3483 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3484 match ordinal {
3485 0 => unsafe { ::core::hint::unreachable_unchecked() },
3486
3487 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3488 }
3489 })
3490 }
3491 }
3492
3493 impl<'de> StartedPayload<'de> {}
3494
3495 impl<'de> ::core::fmt::Debug for StartedPayload<'de> {
3496 fn fmt(
3497 &self,
3498 f: &mut ::core::fmt::Formatter<'_>,
3499 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3500 f.debug_struct("StartedPayload").finish()
3501 }
3502 }
3503
3504 impl<'de> ::fidl_next::IntoNatural for StartedPayload<'de> {
3505 type Natural = crate::natural::StartedPayload;
3506 }
3507
3508 #[repr(C)]
3510 pub struct UnresolvedPayload<'de> {
3511 pub(crate) table: ::fidl_next::wire::Table<'de>,
3512 }
3513
3514 impl<'de> Drop for UnresolvedPayload<'de> {
3515 fn drop(&mut self) {}
3516 }
3517
3518 impl ::fidl_next::Constrained for UnresolvedPayload<'_> {
3519 type Constraint = ();
3520
3521 fn validate(
3522 _: ::fidl_next::Slot<'_, Self>,
3523 _: Self::Constraint,
3524 ) -> Result<(), ::fidl_next::ValidationError> {
3525 Ok(())
3526 }
3527 }
3528
3529 unsafe impl ::fidl_next::Wire for UnresolvedPayload<'static> {
3530 type Narrowed<'de> = UnresolvedPayload<'de>;
3531
3532 #[inline]
3533 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3534 ::fidl_next::munge!(let Self { table } = out);
3535 ::fidl_next::wire::Table::zero_padding(table);
3536 }
3537 }
3538
3539 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnresolvedPayload<'de>
3540 where
3541 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3542 {
3543 fn decode(
3544 slot: ::fidl_next::Slot<'_, Self>,
3545 decoder: &mut ___D,
3546 _: (),
3547 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3548 ::fidl_next::munge!(let Self { table } = slot);
3549
3550 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3551 match ordinal {
3552 0 => unsafe { ::core::hint::unreachable_unchecked() },
3553
3554 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3555 }
3556 })
3557 }
3558 }
3559
3560 impl<'de> UnresolvedPayload<'de> {}
3561
3562 impl<'de> ::core::fmt::Debug for UnresolvedPayload<'de> {
3563 fn fmt(
3564 &self,
3565 f: &mut ::core::fmt::Formatter<'_>,
3566 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3567 f.debug_struct("UnresolvedPayload").finish()
3568 }
3569 }
3570
3571 impl<'de> ::fidl_next::IntoNatural for UnresolvedPayload<'de> {
3572 type Natural = crate::natural::UnresolvedPayload;
3573 }
3574
3575 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
3577 #[repr(transparent)]
3578 pub struct EventType {
3579 pub(crate) value: ::fidl_next::wire::Uint32,
3580 }
3581
3582 impl ::fidl_next::Constrained for EventType {
3583 type Constraint = ();
3584
3585 fn validate(
3586 _: ::fidl_next::Slot<'_, Self>,
3587 _: Self::Constraint,
3588 ) -> Result<(), ::fidl_next::ValidationError> {
3589 Ok(())
3590 }
3591 }
3592
3593 unsafe impl ::fidl_next::Wire for EventType {
3594 type Narrowed<'de> = Self;
3595
3596 #[inline]
3597 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
3598 }
3600 }
3601
3602 impl EventType {
3603 pub const CAPABILITY_REQUESTED: EventType =
3604 EventType { value: ::fidl_next::wire::Uint32(1) };
3605
3606 pub const DISCOVERED: EventType = EventType { value: ::fidl_next::wire::Uint32(3) };
3607
3608 pub const DESTROYED: EventType = EventType { value: ::fidl_next::wire::Uint32(4) };
3609
3610 pub const RESOLVED: EventType = EventType { value: ::fidl_next::wire::Uint32(5) };
3611
3612 pub const STARTED: EventType = EventType { value: ::fidl_next::wire::Uint32(6) };
3613
3614 pub const STOPPED: EventType = EventType { value: ::fidl_next::wire::Uint32(7) };
3615
3616 pub const DEBUG_STARTED: EventType = EventType { value: ::fidl_next::wire::Uint32(8) };
3617
3618 pub const UNRESOLVED: EventType = EventType { value: ::fidl_next::wire::Uint32(9) };
3619 }
3620
3621 unsafe impl<___D> ::fidl_next::Decode<___D> for EventType
3622 where
3623 ___D: ?Sized,
3624 {
3625 fn decode(
3626 slot: ::fidl_next::Slot<'_, Self>,
3627 _: &mut ___D,
3628 _: (),
3629 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3630 ::fidl_next::munge!(let Self { value } = slot);
3631
3632 match u32::from(*value) {
3633 1 | 3 | 4 | 5 | 6 | 7 | 8 | 9 => (),
3634 unknown => {
3635 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
3636 }
3637 }
3638
3639 Ok(())
3640 }
3641 }
3642
3643 impl ::core::convert::From<crate::natural::EventType> for EventType {
3644 fn from(natural: crate::natural::EventType) -> Self {
3645 match natural {
3646 crate::natural::EventType::CapabilityRequested => EventType::CAPABILITY_REQUESTED,
3647
3648 crate::natural::EventType::Discovered => EventType::DISCOVERED,
3649
3650 crate::natural::EventType::Destroyed => EventType::DESTROYED,
3651
3652 crate::natural::EventType::Resolved => EventType::RESOLVED,
3653
3654 crate::natural::EventType::Started => EventType::STARTED,
3655
3656 crate::natural::EventType::Stopped => EventType::STOPPED,
3657
3658 crate::natural::EventType::DebugStarted => EventType::DEBUG_STARTED,
3659
3660 crate::natural::EventType::Unresolved => EventType::UNRESOLVED,
3661 }
3662 }
3663 }
3664
3665 impl ::fidl_next::IntoNatural for EventType {
3666 type Natural = crate::natural::EventType;
3667 }
3668
3669 #[repr(C)]
3671 pub struct StoppedPayload<'de> {
3672 pub(crate) table: ::fidl_next::wire::Table<'de>,
3673 }
3674
3675 impl<'de> Drop for StoppedPayload<'de> {
3676 fn drop(&mut self) {
3677 let _ = self.table.get(1).map(|envelope| unsafe {
3678 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Status>()
3679 });
3680
3681 let _ = self
3682 .table
3683 .get(2)
3684 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Int64>() });
3685 }
3686 }
3687
3688 impl ::fidl_next::Constrained for StoppedPayload<'_> {
3689 type Constraint = ();
3690
3691 fn validate(
3692 _: ::fidl_next::Slot<'_, Self>,
3693 _: Self::Constraint,
3694 ) -> Result<(), ::fidl_next::ValidationError> {
3695 Ok(())
3696 }
3697 }
3698
3699 unsafe impl ::fidl_next::Wire for StoppedPayload<'static> {
3700 type Narrowed<'de> = StoppedPayload<'de>;
3701
3702 #[inline]
3703 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3704 ::fidl_next::munge!(let Self { table } = out);
3705 ::fidl_next::wire::Table::zero_padding(table);
3706 }
3707 }
3708
3709 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StoppedPayload<'de>
3710 where
3711 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3712 {
3713 fn decode(
3714 slot: ::fidl_next::Slot<'_, Self>,
3715 decoder: &mut ___D,
3716 _: (),
3717 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3718 ::fidl_next::munge!(let Self { table } = slot);
3719
3720 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3721 match ordinal {
3722 0 => unsafe { ::core::hint::unreachable_unchecked() },
3723
3724 1 => {
3725 ::fidl_next::wire::Envelope::decode_as::<
3726 ___D,
3727 ::fidl_next::wire::fuchsia::Status,
3728 >(slot.as_mut(), decoder, ())?;
3729
3730 Ok(())
3731 }
3732
3733 2 => {
3734 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Int64>(
3735 slot.as_mut(),
3736 decoder,
3737 (),
3738 )?;
3739
3740 Ok(())
3741 }
3742
3743 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3744 }
3745 })
3746 }
3747 }
3748
3749 impl<'de> StoppedPayload<'de> {
3750 pub fn status(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Status> {
3751 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3752 }
3753
3754 pub fn take_status(
3755 &mut self,
3756 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::Status> {
3757 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3758 }
3759
3760 pub fn exit_code(&self) -> ::core::option::Option<&::fidl_next::wire::Int64> {
3761 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3762 }
3763
3764 pub fn take_exit_code(&mut self) -> ::core::option::Option<::fidl_next::wire::Int64> {
3765 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3766 }
3767 }
3768
3769 impl<'de> ::core::fmt::Debug for StoppedPayload<'de> {
3770 fn fmt(
3771 &self,
3772 f: &mut ::core::fmt::Formatter<'_>,
3773 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3774 f.debug_struct("StoppedPayload")
3775 .field("status", &self.status())
3776 .field("exit_code", &self.exit_code())
3777 .finish()
3778 }
3779 }
3780
3781 impl<'de> ::fidl_next::IntoNatural for StoppedPayload<'de> {
3782 type Natural = crate::natural::StoppedPayload;
3783 }
3784
3785 #[repr(C)]
3787 pub struct EventHeader<'de> {
3788 pub(crate) table: ::fidl_next::wire::Table<'de>,
3789 }
3790
3791 impl<'de> Drop for EventHeader<'de> {
3792 fn drop(&mut self) {
3793 let _ = self
3794 .table
3795 .get(1)
3796 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::EventType>() });
3797
3798 let _ = self.table.get(2).map(|envelope| unsafe {
3799 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3800 });
3801
3802 let _ = self.table.get(3).map(|envelope| unsafe {
3803 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3804 });
3805
3806 let _ = self
3807 .table
3808 .get(4)
3809 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Int64>() });
3810 }
3811 }
3812
3813 impl ::fidl_next::Constrained for EventHeader<'_> {
3814 type Constraint = ();
3815
3816 fn validate(
3817 _: ::fidl_next::Slot<'_, Self>,
3818 _: Self::Constraint,
3819 ) -> Result<(), ::fidl_next::ValidationError> {
3820 Ok(())
3821 }
3822 }
3823
3824 unsafe impl ::fidl_next::Wire for EventHeader<'static> {
3825 type Narrowed<'de> = EventHeader<'de>;
3826
3827 #[inline]
3828 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3829 ::fidl_next::munge!(let Self { table } = out);
3830 ::fidl_next::wire::Table::zero_padding(table);
3831 }
3832 }
3833
3834 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventHeader<'de>
3835 where
3836 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3837 {
3838 fn decode(
3839 slot: ::fidl_next::Slot<'_, Self>,
3840 decoder: &mut ___D,
3841 _: (),
3842 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3843 ::fidl_next::munge!(let Self { table } = slot);
3844
3845 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3846 match ordinal {
3847 0 => unsafe { ::core::hint::unreachable_unchecked() },
3848
3849 1 => {
3850 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::EventType>(
3851 slot.as_mut(),
3852 decoder,
3853 (),
3854 )?;
3855
3856 Ok(())
3857 }
3858
3859 2 => {
3860 ::fidl_next::wire::Envelope::decode_as::<
3861 ___D,
3862 ::fidl_next::wire::String<'de>,
3863 >(slot.as_mut(), decoder, 4096)?;
3864
3865 let value = unsafe {
3866 slot.deref_unchecked()
3867 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3868 };
3869
3870 if value.len() > 4096 {
3871 return Err(::fidl_next::DecodeError::VectorTooLong {
3872 size: value.len() as u64,
3873 limit: 4096,
3874 });
3875 }
3876
3877 Ok(())
3878 }
3879
3880 3 => {
3881 ::fidl_next::wire::Envelope::decode_as::<
3882 ___D,
3883 ::fidl_next::wire::String<'de>,
3884 >(slot.as_mut(), decoder, 4096)?;
3885
3886 let value = unsafe {
3887 slot.deref_unchecked()
3888 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3889 };
3890
3891 if value.len() > 4096 {
3892 return Err(::fidl_next::DecodeError::VectorTooLong {
3893 size: value.len() as u64,
3894 limit: 4096,
3895 });
3896 }
3897
3898 Ok(())
3899 }
3900
3901 4 => {
3902 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Int64>(
3903 slot.as_mut(),
3904 decoder,
3905 (),
3906 )?;
3907
3908 Ok(())
3909 }
3910
3911 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3912 }
3913 })
3914 }
3915 }
3916
3917 impl<'de> EventHeader<'de> {
3918 pub fn event_type(&self) -> ::core::option::Option<&crate::wire::EventType> {
3919 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3920 }
3921
3922 pub fn take_event_type(&mut self) -> ::core::option::Option<crate::wire::EventType> {
3923 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3924 }
3925
3926 pub fn moniker(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3927 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3928 }
3929
3930 pub fn take_moniker(&mut self) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
3931 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3932 }
3933
3934 pub fn component_url(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3935 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3936 }
3937
3938 pub fn take_component_url(
3939 &mut self,
3940 ) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
3941 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
3942 }
3943
3944 pub fn timestamp(&self) -> ::core::option::Option<&::fidl_next::wire::Int64> {
3945 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3946 }
3947
3948 pub fn take_timestamp(&mut self) -> ::core::option::Option<::fidl_next::wire::Int64> {
3949 unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
3950 }
3951 }
3952
3953 impl<'de> ::core::fmt::Debug for EventHeader<'de> {
3954 fn fmt(
3955 &self,
3956 f: &mut ::core::fmt::Formatter<'_>,
3957 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3958 f.debug_struct("EventHeader")
3959 .field("event_type", &self.event_type())
3960 .field("moniker", &self.moniker())
3961 .field("component_url", &self.component_url())
3962 .field("timestamp", &self.timestamp())
3963 .finish()
3964 }
3965 }
3966
3967 impl<'de> ::fidl_next::IntoNatural for EventHeader<'de> {
3968 type Natural = crate::natural::EventHeader;
3969 }
3970
3971 #[derive(Debug)]
3973 #[repr(C)]
3974 pub struct ExecutionControllerOnStopRequest<'de> {
3975 pub stopped_payload: crate::wire::StoppedPayload<'de>,
3976 }
3977
3978 static_assertions::const_assert_eq!(
3979 std::mem::size_of::<ExecutionControllerOnStopRequest<'_>>(),
3980 16
3981 );
3982 static_assertions::const_assert_eq!(
3983 std::mem::align_of::<ExecutionControllerOnStopRequest<'_>>(),
3984 8
3985 );
3986
3987 static_assertions::const_assert_eq!(
3988 std::mem::offset_of!(ExecutionControllerOnStopRequest<'_>, stopped_payload),
3989 0
3990 );
3991
3992 impl ::fidl_next::Constrained for ExecutionControllerOnStopRequest<'_> {
3993 type Constraint = ();
3994
3995 fn validate(
3996 _: ::fidl_next::Slot<'_, Self>,
3997 _: Self::Constraint,
3998 ) -> Result<(), ::fidl_next::ValidationError> {
3999 Ok(())
4000 }
4001 }
4002
4003 unsafe impl ::fidl_next::Wire for ExecutionControllerOnStopRequest<'static> {
4004 type Narrowed<'de> = ExecutionControllerOnStopRequest<'de>;
4005
4006 #[inline]
4007 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4008 ::fidl_next::munge! {
4009 let Self {
4010 stopped_payload,
4011
4012 } = &mut *out_;
4013 }
4014
4015 ::fidl_next::Wire::zero_padding(stopped_payload);
4016 }
4017 }
4018
4019 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExecutionControllerOnStopRequest<'de>
4020 where
4021 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4022 ___D: ::fidl_next::Decoder<'de>,
4023 {
4024 fn decode(
4025 slot_: ::fidl_next::Slot<'_, Self>,
4026 decoder_: &mut ___D,
4027 _: (),
4028 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4029 ::fidl_next::munge! {
4030 let Self {
4031 mut stopped_payload,
4032
4033 } = slot_;
4034 }
4035
4036 let _field = stopped_payload.as_mut();
4037
4038 ::fidl_next::Decode::decode(stopped_payload.as_mut(), decoder_, ())?;
4039
4040 Ok(())
4041 }
4042 }
4043
4044 impl<'de> ::fidl_next::IntoNatural for ExecutionControllerOnStopRequest<'de> {
4045 type Natural = crate::natural::ExecutionControllerOnStopRequest;
4046 }
4047
4048 #[derive(Debug)]
4050 #[repr(C)]
4051 pub struct IntrospectorGetMonikerResponse<'de> {
4052 pub moniker: ::fidl_next::wire::String<'de>,
4053 }
4054
4055 static_assertions::const_assert_eq!(
4056 std::mem::size_of::<IntrospectorGetMonikerResponse<'_>>(),
4057 16
4058 );
4059 static_assertions::const_assert_eq!(
4060 std::mem::align_of::<IntrospectorGetMonikerResponse<'_>>(),
4061 8
4062 );
4063
4064 static_assertions::const_assert_eq!(
4065 std::mem::offset_of!(IntrospectorGetMonikerResponse<'_>, moniker),
4066 0
4067 );
4068
4069 impl ::fidl_next::Constrained for IntrospectorGetMonikerResponse<'_> {
4070 type Constraint = ();
4071
4072 fn validate(
4073 _: ::fidl_next::Slot<'_, Self>,
4074 _: Self::Constraint,
4075 ) -> Result<(), ::fidl_next::ValidationError> {
4076 Ok(())
4077 }
4078 }
4079
4080 unsafe impl ::fidl_next::Wire for IntrospectorGetMonikerResponse<'static> {
4081 type Narrowed<'de> = IntrospectorGetMonikerResponse<'de>;
4082
4083 #[inline]
4084 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4085 ::fidl_next::munge! {
4086 let Self {
4087 moniker,
4088
4089 } = &mut *out_;
4090 }
4091
4092 ::fidl_next::Wire::zero_padding(moniker);
4093 }
4094 }
4095
4096 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for IntrospectorGetMonikerResponse<'de>
4097 where
4098 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4099 ___D: ::fidl_next::Decoder<'de>,
4100 {
4101 fn decode(
4102 slot_: ::fidl_next::Slot<'_, Self>,
4103 decoder_: &mut ___D,
4104 _: (),
4105 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4106 ::fidl_next::munge! {
4107 let Self {
4108 mut moniker,
4109
4110 } = slot_;
4111 }
4112
4113 let _field = moniker.as_mut();
4114 ::fidl_next::Constrained::validate(_field, 4096)?;
4115 ::fidl_next::Decode::decode(moniker.as_mut(), decoder_, 4096)?;
4116
4117 let moniker = unsafe { moniker.deref_unchecked() };
4118
4119 if moniker.len() > 4096 {
4120 return Err(::fidl_next::DecodeError::VectorTooLong {
4121 size: moniker.len() as u64,
4122 limit: 4096,
4123 });
4124 }
4125
4126 Ok(())
4127 }
4128 }
4129
4130 impl<'de> ::fidl_next::IntoNatural for IntrospectorGetMonikerResponse<'de> {
4131 type Natural = crate::natural::IntrospectorGetMonikerResponse;
4132 }
4133
4134 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4136 #[repr(transparent)]
4137 pub struct NamespaceError {
4138 pub(crate) value: ::fidl_next::wire::Uint32,
4139 }
4140
4141 impl ::fidl_next::Constrained for NamespaceError {
4142 type Constraint = ();
4143
4144 fn validate(
4145 _: ::fidl_next::Slot<'_, Self>,
4146 _: Self::Constraint,
4147 ) -> Result<(), ::fidl_next::ValidationError> {
4148 Ok(())
4149 }
4150 }
4151
4152 unsafe impl ::fidl_next::Wire for NamespaceError {
4153 type Narrowed<'de> = Self;
4154
4155 #[inline]
4156 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4157 }
4159 }
4160
4161 impl NamespaceError {
4162 pub const SHADOW: NamespaceError = NamespaceError { value: ::fidl_next::wire::Uint32(1) };
4163
4164 pub const DUPLICATE: NamespaceError =
4165 NamespaceError { value: ::fidl_next::wire::Uint32(2) };
4166
4167 pub const CONVERSION: NamespaceError =
4168 NamespaceError { value: ::fidl_next::wire::Uint32(3) };
4169
4170 pub const BAD_ENTRY: NamespaceError =
4171 NamespaceError { value: ::fidl_next::wire::Uint32(4) };
4172
4173 pub const DICTIONARY_READ: NamespaceError =
4174 NamespaceError { value: ::fidl_next::wire::Uint32(5) };
4175 }
4176
4177 unsafe impl<___D> ::fidl_next::Decode<___D> for NamespaceError
4178 where
4179 ___D: ?Sized,
4180 {
4181 fn decode(
4182 slot: ::fidl_next::Slot<'_, Self>,
4183 _: &mut ___D,
4184 _: (),
4185 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4186 Ok(())
4187 }
4188 }
4189
4190 impl ::core::convert::From<crate::natural::NamespaceError> for NamespaceError {
4191 fn from(natural: crate::natural::NamespaceError) -> Self {
4192 match natural {
4193 crate::natural::NamespaceError::Shadow => NamespaceError::SHADOW,
4194
4195 crate::natural::NamespaceError::Duplicate => NamespaceError::DUPLICATE,
4196
4197 crate::natural::NamespaceError::Conversion => NamespaceError::CONVERSION,
4198
4199 crate::natural::NamespaceError::BadEntry => NamespaceError::BAD_ENTRY,
4200
4201 crate::natural::NamespaceError::DictionaryRead => NamespaceError::DICTIONARY_READ,
4202
4203 crate::natural::NamespaceError::UnknownOrdinal_(value) => {
4204 NamespaceError { value: ::fidl_next::wire::Uint32::from(value) }
4205 }
4206 }
4207 }
4208 }
4209
4210 impl ::fidl_next::IntoNatural for NamespaceError {
4211 type Natural = crate::natural::NamespaceError;
4212 }
4213
4214 pub type RealmOpenExposedDirResponse = ::fidl_next::wire::Unit;
4216
4217 pub type RealmCreateChildResponse = ::fidl_next::wire::Unit;
4219
4220 #[derive(Debug)]
4222 #[repr(C)]
4223 pub struct RealmDestroyChildRequest<'de> {
4224 pub child: ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'de>,
4225 }
4226
4227 static_assertions::const_assert_eq!(std::mem::size_of::<RealmDestroyChildRequest<'_>>(), 32);
4228 static_assertions::const_assert_eq!(std::mem::align_of::<RealmDestroyChildRequest<'_>>(), 8);
4229
4230 static_assertions::const_assert_eq!(
4231 std::mem::offset_of!(RealmDestroyChildRequest<'_>, child),
4232 0
4233 );
4234
4235 impl ::fidl_next::Constrained for RealmDestroyChildRequest<'_> {
4236 type Constraint = ();
4237
4238 fn validate(
4239 _: ::fidl_next::Slot<'_, Self>,
4240 _: Self::Constraint,
4241 ) -> Result<(), ::fidl_next::ValidationError> {
4242 Ok(())
4243 }
4244 }
4245
4246 unsafe impl ::fidl_next::Wire for RealmDestroyChildRequest<'static> {
4247 type Narrowed<'de> = RealmDestroyChildRequest<'de>;
4248
4249 #[inline]
4250 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4251 ::fidl_next::munge! {
4252 let Self {
4253 child,
4254
4255 } = &mut *out_;
4256 }
4257
4258 ::fidl_next::Wire::zero_padding(child);
4259 }
4260 }
4261
4262 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmDestroyChildRequest<'de>
4263 where
4264 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4265 ___D: ::fidl_next::Decoder<'de>,
4266 {
4267 fn decode(
4268 slot_: ::fidl_next::Slot<'_, Self>,
4269 decoder_: &mut ___D,
4270 _: (),
4271 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4272 ::fidl_next::munge! {
4273 let Self {
4274 mut child,
4275
4276 } = slot_;
4277 }
4278
4279 let _field = child.as_mut();
4280
4281 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
4282
4283 Ok(())
4284 }
4285 }
4286
4287 impl<'de> ::fidl_next::IntoNatural for RealmDestroyChildRequest<'de> {
4288 type Natural = crate::natural::RealmDestroyChildRequest;
4289 }
4290
4291 pub type RealmDestroyChildResponse = ::fidl_next::wire::Unit;
4293
4294 pub type RealmListChildrenResponse = ::fidl_next::wire::Unit;
4296
4297 pub type RealmOpenControllerResponse = ::fidl_next::wire::Unit;
4299
4300 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4302 #[repr(transparent)]
4303 pub struct StatusError {
4304 pub(crate) value: ::fidl_next::wire::Uint32,
4305 }
4306
4307 impl ::fidl_next::Constrained for StatusError {
4308 type Constraint = ();
4309
4310 fn validate(
4311 _: ::fidl_next::Slot<'_, Self>,
4312 _: Self::Constraint,
4313 ) -> Result<(), ::fidl_next::ValidationError> {
4314 Ok(())
4315 }
4316 }
4317
4318 unsafe impl ::fidl_next::Wire for StatusError {
4319 type Narrowed<'de> = Self;
4320
4321 #[inline]
4322 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4323 }
4325 }
4326
4327 impl StatusError {
4328 pub const PROVIDER: StatusError = StatusError { value: ::fidl_next::wire::Uint32(1) };
4329
4330 pub const RESPONSE_INVALID: StatusError =
4331 StatusError { value: ::fidl_next::wire::Uint32(2) };
4332
4333 pub const STATUS_UNKNOWN: StatusError = StatusError { value: ::fidl_next::wire::Uint32(3) };
4334
4335 pub const UNSUPPORTED: StatusError = StatusError { value: ::fidl_next::wire::Uint32(4) };
4336 }
4337
4338 unsafe impl<___D> ::fidl_next::Decode<___D> for StatusError
4339 where
4340 ___D: ?Sized,
4341 {
4342 fn decode(
4343 slot: ::fidl_next::Slot<'_, Self>,
4344 _: &mut ___D,
4345 _: (),
4346 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4347 ::fidl_next::munge!(let Self { value } = slot);
4348
4349 match u32::from(*value) {
4350 1 | 2 | 3 | 4 => (),
4351 unknown => {
4352 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
4353 }
4354 }
4355
4356 Ok(())
4357 }
4358 }
4359
4360 impl ::core::convert::From<crate::natural::StatusError> for StatusError {
4361 fn from(natural: crate::natural::StatusError) -> Self {
4362 match natural {
4363 crate::natural::StatusError::Provider => StatusError::PROVIDER,
4364
4365 crate::natural::StatusError::ResponseInvalid => StatusError::RESPONSE_INVALID,
4366
4367 crate::natural::StatusError::StatusUnknown => StatusError::STATUS_UNKNOWN,
4368
4369 crate::natural::StatusError::Unsupported => StatusError::UNSUPPORTED,
4370 }
4371 }
4372 }
4373
4374 impl ::fidl_next::IntoNatural for StatusError {
4375 type Natural = crate::natural::StatusError;
4376 }
4377
4378 pub type StorageAdminOpenStorageResponse = ::fidl_next::wire::Unit;
4380
4381 pub type StorageAdminListStorageInRealmResponse = ::fidl_next::wire::Unit;
4383
4384 pub type StorageAdminOpenComponentStorageByIdResponse = ::fidl_next::wire::Unit;
4386
4387 #[derive(Debug)]
4389 #[repr(C)]
4390 pub struct StorageAdminDeleteComponentStorageRequest<'de> {
4391 pub relative_moniker: ::fidl_next::wire::String<'de>,
4392 }
4393
4394 static_assertions::const_assert_eq!(
4395 std::mem::size_of::<StorageAdminDeleteComponentStorageRequest<'_>>(),
4396 16
4397 );
4398 static_assertions::const_assert_eq!(
4399 std::mem::align_of::<StorageAdminDeleteComponentStorageRequest<'_>>(),
4400 8
4401 );
4402
4403 static_assertions::const_assert_eq!(
4404 std::mem::offset_of!(StorageAdminDeleteComponentStorageRequest<'_>, relative_moniker),
4405 0
4406 );
4407
4408 impl ::fidl_next::Constrained for StorageAdminDeleteComponentStorageRequest<'_> {
4409 type Constraint = ();
4410
4411 fn validate(
4412 _: ::fidl_next::Slot<'_, Self>,
4413 _: Self::Constraint,
4414 ) -> Result<(), ::fidl_next::ValidationError> {
4415 Ok(())
4416 }
4417 }
4418
4419 unsafe impl ::fidl_next::Wire for StorageAdminDeleteComponentStorageRequest<'static> {
4420 type Narrowed<'de> = StorageAdminDeleteComponentStorageRequest<'de>;
4421
4422 #[inline]
4423 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4424 ::fidl_next::munge! {
4425 let Self {
4426 relative_moniker,
4427
4428 } = &mut *out_;
4429 }
4430
4431 ::fidl_next::Wire::zero_padding(relative_moniker);
4432 }
4433 }
4434
4435 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminDeleteComponentStorageRequest<'de>
4436 where
4437 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4438 ___D: ::fidl_next::Decoder<'de>,
4439 {
4440 fn decode(
4441 slot_: ::fidl_next::Slot<'_, Self>,
4442 decoder_: &mut ___D,
4443 _: (),
4444 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4445 ::fidl_next::munge! {
4446 let Self {
4447 mut relative_moniker,
4448
4449 } = slot_;
4450 }
4451
4452 let _field = relative_moniker.as_mut();
4453 ::fidl_next::Constrained::validate(_field, 4096)?;
4454 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
4455
4456 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
4457
4458 if relative_moniker.len() > 4096 {
4459 return Err(::fidl_next::DecodeError::VectorTooLong {
4460 size: relative_moniker.len() as u64,
4461 limit: 4096,
4462 });
4463 }
4464
4465 Ok(())
4466 }
4467 }
4468
4469 impl<'de> ::fidl_next::IntoNatural for StorageAdminDeleteComponentStorageRequest<'de> {
4470 type Natural = crate::natural::StorageAdminDeleteComponentStorageRequest;
4471 }
4472
4473 pub type StorageAdminDeleteComponentStorageResponse = ::fidl_next::wire::Unit;
4475
4476 #[repr(C)]
4478 pub struct StorageStatus<'de> {
4479 pub(crate) table: ::fidl_next::wire::Table<'de>,
4480 }
4481
4482 impl<'de> Drop for StorageStatus<'de> {
4483 fn drop(&mut self) {
4484 let _ = self
4485 .table
4486 .get(1)
4487 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
4488
4489 let _ = self
4490 .table
4491 .get(2)
4492 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
4493 }
4494 }
4495
4496 impl ::fidl_next::Constrained for StorageStatus<'_> {
4497 type Constraint = ();
4498
4499 fn validate(
4500 _: ::fidl_next::Slot<'_, Self>,
4501 _: Self::Constraint,
4502 ) -> Result<(), ::fidl_next::ValidationError> {
4503 Ok(())
4504 }
4505 }
4506
4507 unsafe impl ::fidl_next::Wire for StorageStatus<'static> {
4508 type Narrowed<'de> = StorageStatus<'de>;
4509
4510 #[inline]
4511 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4512 ::fidl_next::munge!(let Self { table } = out);
4513 ::fidl_next::wire::Table::zero_padding(table);
4514 }
4515 }
4516
4517 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageStatus<'de>
4518 where
4519 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4520 {
4521 fn decode(
4522 slot: ::fidl_next::Slot<'_, Self>,
4523 decoder: &mut ___D,
4524 _: (),
4525 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4526 ::fidl_next::munge!(let Self { table } = slot);
4527
4528 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4529 match ordinal {
4530 0 => unsafe { ::core::hint::unreachable_unchecked() },
4531
4532 1 => {
4533 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
4534 slot.as_mut(),
4535 decoder,
4536 (),
4537 )?;
4538
4539 Ok(())
4540 }
4541
4542 2 => {
4543 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
4544 slot.as_mut(),
4545 decoder,
4546 (),
4547 )?;
4548
4549 Ok(())
4550 }
4551
4552 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4553 }
4554 })
4555 }
4556 }
4557
4558 impl<'de> StorageStatus<'de> {
4559 pub fn total_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
4560 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4561 }
4562
4563 pub fn take_total_size(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
4564 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
4565 }
4566
4567 pub fn used_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
4568 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4569 }
4570
4571 pub fn take_used_size(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
4572 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
4573 }
4574 }
4575
4576 impl<'de> ::core::fmt::Debug for StorageStatus<'de> {
4577 fn fmt(
4578 &self,
4579 f: &mut ::core::fmt::Formatter<'_>,
4580 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4581 f.debug_struct("StorageStatus")
4582 .field("total_size", &self.total_size())
4583 .field("used_size", &self.used_size())
4584 .finish()
4585 }
4586 }
4587
4588 impl<'de> ::fidl_next::IntoNatural for StorageStatus<'de> {
4589 type Natural = crate::natural::StorageStatus;
4590 }
4591
4592 pub type StorageAdminDeleteAllStorageContentsResponse = ::fidl_next::wire::Unit;
4594
4595 #[derive(Debug)]
4597 #[repr(C)]
4598 pub struct StorageIteratorNextResponse<'de> {
4599 pub relative_monikers: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
4600 }
4601
4602 static_assertions::const_assert_eq!(std::mem::size_of::<StorageIteratorNextResponse<'_>>(), 16);
4603 static_assertions::const_assert_eq!(std::mem::align_of::<StorageIteratorNextResponse<'_>>(), 8);
4604
4605 static_assertions::const_assert_eq!(
4606 std::mem::offset_of!(StorageIteratorNextResponse<'_>, relative_monikers),
4607 0
4608 );
4609
4610 impl ::fidl_next::Constrained for StorageIteratorNextResponse<'_> {
4611 type Constraint = ();
4612
4613 fn validate(
4614 _: ::fidl_next::Slot<'_, Self>,
4615 _: Self::Constraint,
4616 ) -> Result<(), ::fidl_next::ValidationError> {
4617 Ok(())
4618 }
4619 }
4620
4621 unsafe impl ::fidl_next::Wire for StorageIteratorNextResponse<'static> {
4622 type Narrowed<'de> = StorageIteratorNextResponse<'de>;
4623
4624 #[inline]
4625 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4626 ::fidl_next::munge! {
4627 let Self {
4628 relative_monikers,
4629
4630 } = &mut *out_;
4631 }
4632
4633 ::fidl_next::Wire::zero_padding(relative_monikers);
4634 }
4635 }
4636
4637 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageIteratorNextResponse<'de>
4638 where
4639 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4640 ___D: ::fidl_next::Decoder<'de>,
4641 {
4642 fn decode(
4643 slot_: ::fidl_next::Slot<'_, Self>,
4644 decoder_: &mut ___D,
4645 _: (),
4646 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4647 ::fidl_next::munge! {
4648 let Self {
4649 mut relative_monikers,
4650
4651 } = slot_;
4652 }
4653
4654 let _field = relative_monikers.as_mut();
4655 ::fidl_next::Constrained::validate(_field, (4294967295, 4096))?;
4656 ::fidl_next::Decode::decode(relative_monikers.as_mut(), decoder_, (4294967295, 4096))?;
4657
4658 Ok(())
4659 }
4660 }
4661
4662 impl<'de> ::fidl_next::IntoNatural for StorageIteratorNextResponse<'de> {
4663 type Natural = crate::natural::StorageIteratorNextResponse;
4664 }
4665
4666 pub type ChildName<'de> = ::fidl_next::wire::String<'de>;
4668
4669 pub type UrlScheme<'de> = ::fidl_next::wire::String<'de>;
4671}
4672
4673pub mod wire_optional {}
4674
4675pub mod generic {
4676
4677 pub struct ChildIteratorNextResponse<T0> {
4679 pub children: T0,
4680 }
4681
4682 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>
4683 for ChildIteratorNextResponse<T0>
4684 where
4685 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4686 ___E: ::fidl_next::Encoder,
4687 T0: ::fidl_next::Encode<
4688 ::fidl_next::wire::Vector<
4689 'static,
4690 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'static>,
4691 >,
4692 ___E,
4693 >,
4694 {
4695 #[inline]
4696 fn encode(
4697 self,
4698 encoder_: &mut ___E,
4699 out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildIteratorNextResponse<'static>>,
4700 _: (),
4701 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4702 ::fidl_next::munge! {
4703 let crate::wire::ChildIteratorNextResponse {
4704 children,
4705
4706 } = out_;
4707 }
4708
4709 ::fidl_next::Encode::encode(self.children, encoder_, children, (128, ()))?;
4710
4711 Ok(())
4712 }
4713 }
4714
4715 pub type ControllerStartResponse = ();
4717
4718 pub type ControllerOpenExposedDirResponse = ();
4720
4721 pub type ControllerDestroyResponse = ();
4723
4724 pub struct ExecutionControllerOnStopRequest<T0> {
4726 pub stopped_payload: T0,
4727 }
4728
4729 unsafe impl<___E, T0>
4730 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
4731 for ExecutionControllerOnStopRequest<T0>
4732 where
4733 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4734 ___E: ::fidl_next::Encoder,
4735 T0: ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E>,
4736 {
4737 #[inline]
4738 fn encode(
4739 self,
4740 encoder_: &mut ___E,
4741 out_: &mut ::core::mem::MaybeUninit<
4742 crate::wire::ExecutionControllerOnStopRequest<'static>,
4743 >,
4744 _: (),
4745 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4746 ::fidl_next::munge! {
4747 let crate::wire::ExecutionControllerOnStopRequest {
4748 stopped_payload,
4749
4750 } = out_;
4751 }
4752
4753 ::fidl_next::Encode::encode(self.stopped_payload, encoder_, stopped_payload, ())?;
4754
4755 Ok(())
4756 }
4757 }
4758
4759 pub struct IntrospectorGetMonikerResponse<T0> {
4761 pub moniker: T0,
4762 }
4763
4764 unsafe impl<___E, T0>
4765 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
4766 for IntrospectorGetMonikerResponse<T0>
4767 where
4768 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4769 ___E: ::fidl_next::Encoder,
4770 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4771 {
4772 #[inline]
4773 fn encode(
4774 self,
4775 encoder_: &mut ___E,
4776 out_: &mut ::core::mem::MaybeUninit<
4777 crate::wire::IntrospectorGetMonikerResponse<'static>,
4778 >,
4779 _: (),
4780 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4781 ::fidl_next::munge! {
4782 let crate::wire::IntrospectorGetMonikerResponse {
4783 moniker,
4784
4785 } = out_;
4786 }
4787
4788 ::fidl_next::Encode::encode(self.moniker, encoder_, moniker, 4096)?;
4789
4790 Ok(())
4791 }
4792 }
4793
4794 pub type RealmOpenExposedDirResponse = ();
4796
4797 pub type RealmCreateChildResponse = ();
4799
4800 pub struct RealmDestroyChildRequest<T0> {
4802 pub child: T0,
4803 }
4804
4805 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
4806 for RealmDestroyChildRequest<T0>
4807 where
4808 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4809 ___E: ::fidl_next::Encoder,
4810 T0: ::fidl_next::Encode<
4811 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'static>,
4812 ___E,
4813 >,
4814 {
4815 #[inline]
4816 fn encode(
4817 self,
4818 encoder_: &mut ___E,
4819 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
4820 _: (),
4821 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4822 ::fidl_next::munge! {
4823 let crate::wire::RealmDestroyChildRequest {
4824 child,
4825
4826 } = out_;
4827 }
4828
4829 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
4830
4831 Ok(())
4832 }
4833 }
4834
4835 pub type RealmDestroyChildResponse = ();
4837
4838 pub type RealmListChildrenResponse = ();
4840
4841 pub type RealmOpenControllerResponse = ();
4843
4844 pub type StorageAdminOpenStorageResponse = ();
4846
4847 pub type StorageAdminListStorageInRealmResponse = ();
4849
4850 pub type StorageAdminOpenComponentStorageByIdResponse = ();
4852
4853 pub struct StorageAdminDeleteComponentStorageRequest<T0> {
4855 pub relative_moniker: T0,
4856 }
4857
4858 unsafe impl<___E, T0>
4859 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
4860 for StorageAdminDeleteComponentStorageRequest<T0>
4861 where
4862 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4863 ___E: ::fidl_next::Encoder,
4864 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4865 {
4866 #[inline]
4867 fn encode(
4868 self,
4869 encoder_: &mut ___E,
4870 out_: &mut ::core::mem::MaybeUninit<
4871 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
4872 >,
4873 _: (),
4874 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4875 ::fidl_next::munge! {
4876 let crate::wire::StorageAdminDeleteComponentStorageRequest {
4877 relative_moniker,
4878
4879 } = out_;
4880 }
4881
4882 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
4883
4884 Ok(())
4885 }
4886 }
4887
4888 pub type StorageAdminDeleteComponentStorageResponse = ();
4890
4891 pub type StorageAdminDeleteAllStorageContentsResponse = ();
4893
4894 pub struct StorageIteratorNextResponse<T0> {
4896 pub relative_monikers: T0,
4897 }
4898
4899 unsafe impl<___E, T0>
4900 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
4901 for StorageIteratorNextResponse<T0>
4902 where
4903 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4904 ___E: ::fidl_next::Encoder,
4905 T0: ::fidl_next::Encode<
4906 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
4907 ___E,
4908 >,
4909 {
4910 #[inline]
4911 fn encode(
4912 self,
4913 encoder_: &mut ___E,
4914 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
4915 _: (),
4916 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4917 ::fidl_next::munge! {
4918 let crate::wire::StorageIteratorNextResponse {
4919 relative_monikers,
4920
4921 } = out_;
4922 }
4923
4924 ::fidl_next::Encode::encode(
4925 self.relative_monikers,
4926 encoder_,
4927 relative_monikers,
4928 (4294967295, 4096),
4929 )?;
4930
4931 Ok(())
4932 }
4933 }
4934}
4935
4936pub use self::natural::*;
4937
4938#[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"]
4940#[derive(PartialEq, Debug)]
4941pub struct Binder;
4942
4943impl ::fidl_next::Discoverable for Binder {
4944 const PROTOCOL_NAME: &'static str = "fuchsia.component.Binder";
4945}
4946
4947#[cfg(target_os = "fuchsia")]
4948impl ::fidl_next::HasTransport for Binder {
4949 type Transport = ::fidl_next::fuchsia::zx::Channel;
4950}
4951
4952pub mod binder {
4953 pub mod prelude {
4954 pub use crate::{
4955 Binder, BinderClientHandler, BinderLocalClientHandler, BinderLocalServerHandler,
4956 BinderServerHandler, binder,
4957 };
4958 }
4959
4960 mod ___detail {
4961 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Binder
4962 where
4963 ___T: ::fidl_next::Transport,
4964 {
4965 type Client = BinderClient<___T>;
4966 type Server = BinderServer<___T>;
4967 }
4968
4969 #[repr(transparent)]
4971 pub struct BinderClient<___T: ::fidl_next::Transport> {
4972 #[allow(dead_code)]
4973 client: ::fidl_next::protocol::Client<___T>,
4974 }
4975
4976 impl<___T> BinderClient<___T> where ___T: ::fidl_next::Transport {}
4977
4978 #[repr(transparent)]
4980 pub struct BinderServer<___T: ::fidl_next::Transport> {
4981 server: ::fidl_next::protocol::Server<___T>,
4982 }
4983
4984 impl<___T> BinderServer<___T> where ___T: ::fidl_next::Transport {}
4985 }
4986}
4987
4988#[diagnostic::on_unimplemented(
4989 note = "If {Self} implements the non-local BinderClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
4990)]
4991
4992pub trait BinderLocalClientHandler<
4996 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4997 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4998>
4999{
5000}
5001
5002impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Binder
5003where
5004 ___H: BinderLocalClientHandler<___T>,
5005 ___T: ::fidl_next::Transport,
5006{
5007 async fn on_event(
5008 handler: &mut ___H,
5009 mut message: ::fidl_next::Message<___T>,
5010 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5011 match *message.header().ordinal {
5012 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5013 }
5014 }
5015}
5016
5017#[diagnostic::on_unimplemented(
5018 note = "If {Self} implements the non-local BinderServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5019)]
5020
5021pub trait BinderLocalServerHandler<
5025 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5026 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5027>
5028{
5029}
5030
5031impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Binder
5032where
5033 ___H: BinderLocalServerHandler<___T>,
5034 ___T: ::fidl_next::Transport,
5035{
5036 async fn on_one_way(
5037 handler: &mut ___H,
5038 mut message: ::fidl_next::Message<___T>,
5039 ) -> ::core::result::Result<
5040 (),
5041 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5042 > {
5043 match *message.header().ordinal {
5044 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5045 }
5046 }
5047
5048 async fn on_two_way(
5049 handler: &mut ___H,
5050 mut message: ::fidl_next::Message<___T>,
5051 responder: ::fidl_next::protocol::Responder<___T>,
5052 ) -> ::core::result::Result<
5053 (),
5054 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5055 > {
5056 match *message.header().ordinal {
5057 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5058 }
5059 }
5060}
5061
5062pub trait BinderClientHandler<
5066 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5067 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5068>
5069{
5070}
5071
5072impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Binder
5073where
5074 ___H: BinderClientHandler<___T> + ::core::marker::Send,
5075 ___T: ::fidl_next::Transport,
5076{
5077 async fn on_event(
5078 handler: &mut ___H,
5079 mut message: ::fidl_next::Message<___T>,
5080 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5081 match *message.header().ordinal {
5082 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5083 }
5084 }
5085}
5086
5087pub trait BinderServerHandler<
5091 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5092 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5093>
5094{
5095}
5096
5097impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Binder
5098where
5099 ___H: BinderServerHandler<___T> + ::core::marker::Send,
5100 ___T: ::fidl_next::Transport,
5101{
5102 async fn on_one_way(
5103 handler: &mut ___H,
5104 mut message: ::fidl_next::Message<___T>,
5105 ) -> ::core::result::Result<
5106 (),
5107 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5108 > {
5109 match *message.header().ordinal {
5110 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5111 }
5112 }
5113
5114 async fn on_two_way(
5115 handler: &mut ___H,
5116 mut message: ::fidl_next::Message<___T>,
5117 responder: ::fidl_next::protocol::Responder<___T>,
5118 ) -> ::core::result::Result<
5119 (),
5120 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5121 > {
5122 match *message.header().ordinal {
5123 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5124 }
5125 }
5126}
5127
5128impl<___T> BinderClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport
5129{}
5130
5131impl<___H, ___T> BinderLocalClientHandler<___T> for ::fidl_next::Local<___H>
5132where
5133 ___H: BinderClientHandler<___T>,
5134 ___T: ::fidl_next::Transport,
5135{
5136}
5137
5138impl<___H, ___T> BinderLocalServerHandler<___T> for ::fidl_next::Local<___H>
5139where
5140 ___H: BinderServerHandler<___T>,
5141 ___T: ::fidl_next::Transport,
5142{
5143}
5144
5145pub const MAX_NAME_LENGTH: u64 = 255 as u64;
5146
5147#[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"]
5148pub const MAX_CHILD_COUNT: u32 = 128 as u32;
5149
5150#[doc = " A protocol to iterate over the list of children in a realm.\n"]
5152#[derive(PartialEq, Debug)]
5153pub struct ChildIterator;
5154
5155#[cfg(target_os = "fuchsia")]
5156impl ::fidl_next::HasTransport for ChildIterator {
5157 type Transport = ::fidl_next::fuchsia::zx::Channel;
5158}
5159
5160pub mod child_iterator {
5161 pub mod prelude {
5162 pub use crate::{
5163 ChildIterator, ChildIteratorClientHandler, ChildIteratorLocalClientHandler,
5164 ChildIteratorLocalServerHandler, ChildIteratorServerHandler, child_iterator,
5165 };
5166
5167 pub use crate::natural::ChildIteratorNextResponse;
5168 }
5169
5170 pub struct Next;
5171
5172 impl ::fidl_next::Method for Next {
5173 const ORDINAL: u64 = 4676077302722137352;
5174 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5175 ::fidl_next::protocol::Flexibility::Strict;
5176
5177 type Protocol = crate::ChildIterator;
5178
5179 type Request = ::fidl_next::wire::EmptyMessageBody;
5180 }
5181
5182 impl ::fidl_next::TwoWayMethod for Next {
5183 type Response = ::fidl_next::wire::Strict<crate::wire::ChildIteratorNextResponse<'static>>;
5184 }
5185
5186 impl<___R> ::fidl_next::Respond<___R> for Next {
5187 type Output = ::fidl_next::Strict<crate::generic::ChildIteratorNextResponse<___R>>;
5188
5189 fn respond(response: ___R) -> Self::Output {
5190 ::fidl_next::Strict(crate::generic::ChildIteratorNextResponse { children: response })
5191 }
5192 }
5193
5194 mod ___detail {
5195 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ChildIterator
5196 where
5197 ___T: ::fidl_next::Transport,
5198 {
5199 type Client = ChildIteratorClient<___T>;
5200 type Server = ChildIteratorServer<___T>;
5201 }
5202
5203 #[repr(transparent)]
5205 pub struct ChildIteratorClient<___T: ::fidl_next::Transport> {
5206 #[allow(dead_code)]
5207 client: ::fidl_next::protocol::Client<___T>,
5208 }
5209
5210 impl<___T> ChildIteratorClient<___T>
5211 where
5212 ___T: ::fidl_next::Transport,
5213 {
5214 #[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"]
5215 pub fn next(&self) -> ::fidl_next::TwoWayFuture<'_, super::Next, ___T> {
5216 ::fidl_next::TwoWayFuture::from_untyped(
5217 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
5218 4676077302722137352,
5219 <super::Next as ::fidl_next::Method>::FLEXIBILITY,
5220 (),
5221 ),
5222 )
5223 }
5224 }
5225
5226 #[repr(transparent)]
5228 pub struct ChildIteratorServer<___T: ::fidl_next::Transport> {
5229 server: ::fidl_next::protocol::Server<___T>,
5230 }
5231
5232 impl<___T> ChildIteratorServer<___T> where ___T: ::fidl_next::Transport {}
5233 }
5234}
5235
5236#[diagnostic::on_unimplemented(
5237 note = "If {Self} implements the non-local ChildIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5238)]
5239
5240pub trait ChildIteratorLocalClientHandler<
5244 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5245 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5246>
5247{
5248}
5249
5250impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ChildIterator
5251where
5252 ___H: ChildIteratorLocalClientHandler<___T>,
5253 ___T: ::fidl_next::Transport,
5254{
5255 async fn on_event(
5256 handler: &mut ___H,
5257 mut message: ::fidl_next::Message<___T>,
5258 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5259 match *message.header().ordinal {
5260 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5261 }
5262 }
5263}
5264
5265#[diagnostic::on_unimplemented(
5266 note = "If {Self} implements the non-local ChildIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5267)]
5268
5269pub trait ChildIteratorLocalServerHandler<
5273 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5274 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5275>
5276{
5277 #[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"]
5278 fn next(
5279 &mut self,
5280
5281 responder: ::fidl_next::Responder<child_iterator::Next, ___T>,
5282 ) -> impl ::core::future::Future<Output = ()>;
5283}
5284
5285impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ChildIterator
5286where
5287 ___H: ChildIteratorLocalServerHandler<___T>,
5288 ___T: ::fidl_next::Transport,
5289{
5290 async fn on_one_way(
5291 handler: &mut ___H,
5292 mut message: ::fidl_next::Message<___T>,
5293 ) -> ::core::result::Result<
5294 (),
5295 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5296 > {
5297 match *message.header().ordinal {
5298 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5299 }
5300 }
5301
5302 async fn on_two_way(
5303 handler: &mut ___H,
5304 mut message: ::fidl_next::Message<___T>,
5305 responder: ::fidl_next::protocol::Responder<___T>,
5306 ) -> ::core::result::Result<
5307 (),
5308 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5309 > {
5310 match *message.header().ordinal {
5311 4676077302722137352 => {
5312 let responder = ::fidl_next::Responder::from_untyped(responder);
5313
5314 handler.next(responder).await;
5315 Ok(())
5316 }
5317
5318 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5319 }
5320 }
5321}
5322
5323pub trait ChildIteratorClientHandler<
5327 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5328 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5329>
5330{
5331}
5332
5333impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ChildIterator
5334where
5335 ___H: ChildIteratorClientHandler<___T> + ::core::marker::Send,
5336 ___T: ::fidl_next::Transport,
5337{
5338 async fn on_event(
5339 handler: &mut ___H,
5340 mut message: ::fidl_next::Message<___T>,
5341 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5342 match *message.header().ordinal {
5343 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5344 }
5345 }
5346}
5347
5348pub trait ChildIteratorServerHandler<
5352 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5353 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5354>
5355{
5356 #[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"]
5357 fn next(
5358 &mut self,
5359
5360 responder: ::fidl_next::Responder<child_iterator::Next, ___T>,
5361 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5362}
5363
5364impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ChildIterator
5365where
5366 ___H: ChildIteratorServerHandler<___T> + ::core::marker::Send,
5367 ___T: ::fidl_next::Transport,
5368{
5369 async fn on_one_way(
5370 handler: &mut ___H,
5371 mut message: ::fidl_next::Message<___T>,
5372 ) -> ::core::result::Result<
5373 (),
5374 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5375 > {
5376 match *message.header().ordinal {
5377 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5378 }
5379 }
5380
5381 async fn on_two_way(
5382 handler: &mut ___H,
5383 mut message: ::fidl_next::Message<___T>,
5384 responder: ::fidl_next::protocol::Responder<___T>,
5385 ) -> ::core::result::Result<
5386 (),
5387 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5388 > {
5389 match *message.header().ordinal {
5390 4676077302722137352 => {
5391 let responder = ::fidl_next::Responder::from_untyped(responder);
5392
5393 handler.next(responder).await;
5394 Ok(())
5395 }
5396
5397 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5398 }
5399 }
5400}
5401
5402impl<___T> ChildIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
5403 ___T: ::fidl_next::Transport
5404{
5405}
5406
5407impl<___H, ___T> ChildIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
5408where
5409 ___H: ChildIteratorClientHandler<___T>,
5410 ___T: ::fidl_next::Transport,
5411{
5412}
5413
5414impl<___H, ___T> ChildIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
5415where
5416 ___H: ChildIteratorServerHandler<___T>,
5417 ___T: ::fidl_next::Transport,
5418{
5419 async fn next(&mut self, responder: ::fidl_next::Responder<child_iterator::Next, ___T>) {
5420 ___H::next(&mut self.0, responder).await
5421 }
5422}
5423
5424#[doc = " The maximum number of handles that can be passed to a created component.\n"]
5425pub const MAX_HANDLE_COUNT: u32 = 128 as u32;
5426
5427pub const MAX_NAMESPACE_COUNT: u32 = 32 as u32;
5428
5429pub const MAX_PATH_LENGTH: u64 = 4095 as u64;
5430
5431#[doc = " The maximum number of dynamic offers that can target a created component.\n"]
5432pub const MAX_DYNAMIC_OFFER_COUNT: u32 = 128 as u32;
5433
5434pub const MAX_MONIKER_LENGTH: u32 = 4096 as u32;
5435
5436#[derive(PartialEq, Debug)]
5438pub struct ExecutionController;
5439
5440#[cfg(target_os = "fuchsia")]
5441impl ::fidl_next::HasTransport for ExecutionController {
5442 type Transport = ::fidl_next::fuchsia::zx::Channel;
5443}
5444
5445pub mod execution_controller {
5446 pub mod prelude {
5447 pub use crate::{
5448 ExecutionController, ExecutionControllerClientHandler,
5449 ExecutionControllerLocalClientHandler, ExecutionControllerLocalServerHandler,
5450 ExecutionControllerServerHandler, execution_controller,
5451 };
5452
5453 pub use crate::natural::ExecutionControllerOnStopRequest;
5454 }
5455
5456 pub struct Stop;
5457
5458 impl ::fidl_next::Method for Stop {
5459 const ORDINAL: u64 = 6256129817234858263;
5460 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5461 ::fidl_next::protocol::Flexibility::Flexible;
5462
5463 type Protocol = crate::ExecutionController;
5464
5465 type Request = ::fidl_next::wire::EmptyMessageBody;
5466 }
5467
5468 pub struct OnStop;
5469
5470 impl ::fidl_next::Method for OnStop {
5471 const ORDINAL: u64 = 7121600095714604415;
5472 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5473 ::fidl_next::protocol::Flexibility::Flexible;
5474
5475 type Protocol = crate::ExecutionController;
5476
5477 type Request = crate::wire::ExecutionControllerOnStopRequest<'static>;
5478 }
5479
5480 mod ___detail {
5481 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ExecutionController
5482 where
5483 ___T: ::fidl_next::Transport,
5484 {
5485 type Client = ExecutionControllerClient<___T>;
5486 type Server = ExecutionControllerServer<___T>;
5487 }
5488
5489 #[repr(transparent)]
5491 pub struct ExecutionControllerClient<___T: ::fidl_next::Transport> {
5492 #[allow(dead_code)]
5493 client: ::fidl_next::protocol::Client<___T>,
5494 }
5495
5496 impl<___T> ExecutionControllerClient<___T>
5497 where
5498 ___T: ::fidl_next::Transport,
5499 {
5500 #[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"]
5501 pub fn stop(&self) -> ::fidl_next::SendFuture<'_, ___T> {
5502 ::fidl_next::SendFuture::from_untyped(
5503 self.client.send_one_way::<::fidl_next::wire::EmptyMessageBody>(
5504 6256129817234858263,
5505 <super::Stop as ::fidl_next::Method>::FLEXIBILITY,
5506 (),
5507 ),
5508 )
5509 }
5510 }
5511
5512 #[repr(transparent)]
5514 pub struct ExecutionControllerServer<___T: ::fidl_next::Transport> {
5515 server: ::fidl_next::protocol::Server<___T>,
5516 }
5517
5518 impl<___T> ExecutionControllerServer<___T>
5519 where
5520 ___T: ::fidl_next::Transport,
5521 {
5522 #[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"]
5523 pub fn on_stop(
5524 &self,
5525
5526 stopped_payload: impl ::fidl_next::Encode<
5527 crate::wire::StoppedPayload<'static>,
5528 <___T as ::fidl_next::Transport>::SendBuffer,
5529 >,
5530 ) -> ::fidl_next::SendFuture<'_, ___T>
5531 where
5532 <___T as ::fidl_next::Transport>::SendBuffer:
5533 ::fidl_next::encoder::InternalHandleEncoder,
5534 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
5535 {
5536 self.on_stop_with(crate::generic::ExecutionControllerOnStopRequest {
5537 stopped_payload,
5538 })
5539 }
5540
5541 #[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"]
5542
5543 pub fn on_stop_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
5544 where
5545 ___R: ::fidl_next::Encode<
5546 <super::OnStop as ::fidl_next::Method>::Request,
5547 <___T as ::fidl_next::Transport>::SendBuffer,
5548 >,
5549 {
5550 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
5551 7121600095714604415,
5552 <super::OnStop as ::fidl_next::Method>::FLEXIBILITY,
5553 request,
5554 ))
5555 }
5556 }
5557 }
5558}
5559
5560#[diagnostic::on_unimplemented(
5561 note = "If {Self} implements the non-local ExecutionControllerClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5562)]
5563
5564pub trait ExecutionControllerLocalClientHandler<
5568 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5569 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5570>
5571{
5572 #[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"]
5573 fn on_stop(
5574 &mut self,
5575
5576 request: ::fidl_next::Request<execution_controller::OnStop, ___T>,
5577 ) -> impl ::core::future::Future<Output = ()>;
5578
5579 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5580 ::core::future::ready(())
5581 }
5582}
5583
5584impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ExecutionController
5585where
5586 ___H: ExecutionControllerLocalClientHandler<___T>,
5587 ___T: ::fidl_next::Transport,
5588 for<'de> crate::wire::ExecutionControllerOnStopRequest<'de>: ::fidl_next::Decode<
5589 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5590 Constraint = (),
5591 >,
5592{
5593 async fn on_event(
5594 handler: &mut ___H,
5595 mut message: ::fidl_next::Message<___T>,
5596 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5597 match *message.header().ordinal {
5598 7121600095714604415 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
5599 Ok(decoded) => {
5600 handler.on_stop(::fidl_next::Request::from_decoded(decoded)).await;
5601 Ok(())
5602 }
5603 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5604 ordinal: 7121600095714604415,
5605 error,
5606 }),
5607 },
5608
5609 ordinal => {
5610 handler.on_unknown_interaction(ordinal).await;
5611 if ::core::matches!(
5612 message.header().flexibility(),
5613 ::fidl_next::protocol::Flexibility::Strict
5614 ) {
5615 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5616 } else {
5617 Ok(())
5618 }
5619 }
5620 }
5621 }
5622}
5623
5624#[diagnostic::on_unimplemented(
5625 note = "If {Self} implements the non-local ExecutionControllerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5626)]
5627
5628pub trait ExecutionControllerLocalServerHandler<
5632 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5633 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5634>
5635{
5636 #[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"]
5637 fn stop(&mut self) -> impl ::core::future::Future<Output = ()>;
5638
5639 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5640 ::core::future::ready(())
5641 }
5642}
5643
5644impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ExecutionController
5645where
5646 ___H: ExecutionControllerLocalServerHandler<___T>,
5647 ___T: ::fidl_next::Transport,
5648{
5649 async fn on_one_way(
5650 handler: &mut ___H,
5651 mut message: ::fidl_next::Message<___T>,
5652 ) -> ::core::result::Result<
5653 (),
5654 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5655 > {
5656 match *message.header().ordinal {
5657 6256129817234858263 => {
5658 handler.stop().await;
5659 Ok(())
5660 }
5661
5662 ordinal => {
5663 handler.on_unknown_interaction(ordinal).await;
5664 if ::core::matches!(
5665 message.header().flexibility(),
5666 ::fidl_next::protocol::Flexibility::Strict
5667 ) {
5668 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5669 } else {
5670 Ok(())
5671 }
5672 }
5673 }
5674 }
5675
5676 async fn on_two_way(
5677 handler: &mut ___H,
5678 mut message: ::fidl_next::Message<___T>,
5679 responder: ::fidl_next::protocol::Responder<___T>,
5680 ) -> ::core::result::Result<
5681 (),
5682 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5683 > {
5684 match *message.header().ordinal {
5685 ordinal => {
5686 handler.on_unknown_interaction(ordinal).await;
5687 if ::core::matches!(
5688 message.header().flexibility(),
5689 ::fidl_next::protocol::Flexibility::Strict
5690 ) {
5691 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5692 } else {
5693 responder
5694 .respond_framework_error(
5695 ordinal,
5696 ::fidl_next::FrameworkError::UnknownMethod,
5697 )
5698 .expect("encoding a framework error should never fail")
5699 .await?;
5700 Ok(())
5701 }
5702 }
5703 }
5704 }
5705}
5706
5707pub trait ExecutionControllerClientHandler<
5711 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5712 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5713>
5714{
5715 #[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"]
5716 fn on_stop(
5717 &mut self,
5718
5719 request: ::fidl_next::Request<execution_controller::OnStop, ___T>,
5720 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5721
5722 fn on_unknown_interaction(
5723 &mut self,
5724 ordinal: u64,
5725 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5726 ::core::future::ready(())
5727 }
5728}
5729
5730impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ExecutionController
5731where
5732 ___H: ExecutionControllerClientHandler<___T> + ::core::marker::Send,
5733 ___T: ::fidl_next::Transport,
5734 for<'de> crate::wire::ExecutionControllerOnStopRequest<'de>: ::fidl_next::Decode<
5735 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5736 Constraint = (),
5737 >,
5738{
5739 async fn on_event(
5740 handler: &mut ___H,
5741 mut message: ::fidl_next::Message<___T>,
5742 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5743 match *message.header().ordinal {
5744 7121600095714604415 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
5745 Ok(decoded) => {
5746 handler.on_stop(::fidl_next::Request::from_decoded(decoded)).await;
5747 Ok(())
5748 }
5749 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5750 ordinal: 7121600095714604415,
5751 error,
5752 }),
5753 },
5754
5755 ordinal => {
5756 handler.on_unknown_interaction(ordinal).await;
5757 if ::core::matches!(
5758 message.header().flexibility(),
5759 ::fidl_next::protocol::Flexibility::Strict
5760 ) {
5761 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5762 } else {
5763 Ok(())
5764 }
5765 }
5766 }
5767 }
5768}
5769
5770pub trait ExecutionControllerServerHandler<
5774 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5775 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5776>
5777{
5778 #[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"]
5779 fn stop(&mut self) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5780
5781 fn on_unknown_interaction(
5782 &mut self,
5783 ordinal: u64,
5784 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5785 ::core::future::ready(())
5786 }
5787}
5788
5789impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ExecutionController
5790where
5791 ___H: ExecutionControllerServerHandler<___T> + ::core::marker::Send,
5792 ___T: ::fidl_next::Transport,
5793{
5794 async fn on_one_way(
5795 handler: &mut ___H,
5796 mut message: ::fidl_next::Message<___T>,
5797 ) -> ::core::result::Result<
5798 (),
5799 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5800 > {
5801 match *message.header().ordinal {
5802 6256129817234858263 => {
5803 handler.stop().await;
5804 Ok(())
5805 }
5806
5807 ordinal => {
5808 handler.on_unknown_interaction(ordinal).await;
5809 if ::core::matches!(
5810 message.header().flexibility(),
5811 ::fidl_next::protocol::Flexibility::Strict
5812 ) {
5813 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5814 } else {
5815 Ok(())
5816 }
5817 }
5818 }
5819 }
5820
5821 async fn on_two_way(
5822 handler: &mut ___H,
5823 mut message: ::fidl_next::Message<___T>,
5824 responder: ::fidl_next::protocol::Responder<___T>,
5825 ) -> ::core::result::Result<
5826 (),
5827 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5828 > {
5829 match *message.header().ordinal {
5830 ordinal => {
5831 handler.on_unknown_interaction(ordinal).await;
5832 if ::core::matches!(
5833 message.header().flexibility(),
5834 ::fidl_next::protocol::Flexibility::Strict
5835 ) {
5836 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5837 } else {
5838 responder
5839 .respond_framework_error(
5840 ordinal,
5841 ::fidl_next::FrameworkError::UnknownMethod,
5842 )
5843 .expect("encoding a framework error should never fail")
5844 .await?;
5845 Ok(())
5846 }
5847 }
5848 }
5849 }
5850}
5851
5852impl<___T> ExecutionControllerClientHandler<___T> for ::fidl_next::IgnoreEvents
5853where
5854 ___T: ::fidl_next::Transport,
5855{
5856 async fn on_stop(&mut self, _: ::fidl_next::Request<execution_controller::OnStop, ___T>) {}
5857
5858 async fn on_unknown_interaction(&mut self, _: u64) {}
5859}
5860
5861impl<___H, ___T> ExecutionControllerLocalClientHandler<___T> for ::fidl_next::Local<___H>
5862where
5863 ___H: ExecutionControllerClientHandler<___T>,
5864 ___T: ::fidl_next::Transport,
5865{
5866 async fn on_stop(&mut self, request: ::fidl_next::Request<execution_controller::OnStop, ___T>) {
5867 ___H::on_stop(&mut self.0, request).await
5868 }
5869
5870 async fn on_unknown_interaction(&mut self, ordinal: u64) {
5871 ___H::on_unknown_interaction(&mut self.0, ordinal).await
5872 }
5873}
5874
5875impl<___H, ___T> ExecutionControllerLocalServerHandler<___T> for ::fidl_next::Local<___H>
5876where
5877 ___H: ExecutionControllerServerHandler<___T>,
5878 ___T: ::fidl_next::Transport,
5879{
5880 async fn stop(&mut self) {
5881 ___H::stop(&mut self.0).await
5882 }
5883
5884 async fn on_unknown_interaction(&mut self, ordinal: u64) {
5885 ___H::on_unknown_interaction(&mut self.0, ordinal).await
5886 }
5887}
5888
5889#[doc = " The maximum string length of a capability ID.\n This value is currently set arbitrarily.\n"]
5890pub const MAX_CAPABILITY_ID_LENGTH: u64 = 50 as u64;
5891
5892pub const MAX_CHILD_NAME_LENGTH: u32 = 1024 as u32;
5893
5894#[doc = " The maximum string length of an error description.\n"]
5895pub const MAX_ERROR_DESCRIPTION_LENGTH: u64 = 100 as u64;
5896
5897#[doc = " The maximum number of events that a receiver can listen to.\n"]
5898pub const MAX_NUM_EVENTS_RECEIVED: u64 = 100 as u64;
5899
5900#[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"]
5901pub const MAX_STORAGE_ID_LENGTH: u32 = 64 as u32;
5902
5903#[doc = " The maximum number of requests per event subscription.\n"]
5904pub const MAX_SUBSCRIPTION_REQUESTS: u32 = 2 as u32;
5905
5906pub const MAX_URL_SCHEME_LENGTH: u64 = 255 as u64;
5907
5908#[doc = " An iterator protocol for returning a set of components using a storage\n capability. See |StorageAdmin.ListStorageInRealm| for more information.\n"]
5910#[derive(PartialEq, Debug)]
5911pub struct StorageIterator;
5912
5913#[cfg(target_os = "fuchsia")]
5914impl ::fidl_next::HasTransport for StorageIterator {
5915 type Transport = ::fidl_next::fuchsia::zx::Channel;
5916}
5917
5918pub mod storage_iterator {
5919 pub mod prelude {
5920 pub use crate::{
5921 StorageIterator, StorageIteratorClientHandler, StorageIteratorLocalClientHandler,
5922 StorageIteratorLocalServerHandler, StorageIteratorServerHandler, storage_iterator,
5923 };
5924
5925 pub use crate::natural::StorageIteratorNextResponse;
5926 }
5927
5928 pub struct Next;
5929
5930 impl ::fidl_next::Method for Next {
5931 const ORDINAL: u64 = 8821181615713557362;
5932 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5933 ::fidl_next::protocol::Flexibility::Strict;
5934
5935 type Protocol = crate::StorageIterator;
5936
5937 type Request = ::fidl_next::wire::EmptyMessageBody;
5938 }
5939
5940 impl ::fidl_next::TwoWayMethod for Next {
5941 type Response =
5942 ::fidl_next::wire::Strict<crate::wire::StorageIteratorNextResponse<'static>>;
5943 }
5944
5945 impl<___R> ::fidl_next::Respond<___R> for Next {
5946 type Output = ::fidl_next::Strict<crate::generic::StorageIteratorNextResponse<___R>>;
5947
5948 fn respond(response: ___R) -> Self::Output {
5949 ::fidl_next::Strict(crate::generic::StorageIteratorNextResponse {
5950 relative_monikers: response,
5951 })
5952 }
5953 }
5954
5955 mod ___detail {
5956 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::StorageIterator
5957 where
5958 ___T: ::fidl_next::Transport,
5959 {
5960 type Client = StorageIteratorClient<___T>;
5961 type Server = StorageIteratorServer<___T>;
5962 }
5963
5964 #[repr(transparent)]
5966 pub struct StorageIteratorClient<___T: ::fidl_next::Transport> {
5967 #[allow(dead_code)]
5968 client: ::fidl_next::protocol::Client<___T>,
5969 }
5970
5971 impl<___T> StorageIteratorClient<___T>
5972 where
5973 ___T: ::fidl_next::Transport,
5974 {
5975 #[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"]
5976 pub fn next(&self) -> ::fidl_next::TwoWayFuture<'_, super::Next, ___T> {
5977 ::fidl_next::TwoWayFuture::from_untyped(
5978 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
5979 8821181615713557362,
5980 <super::Next as ::fidl_next::Method>::FLEXIBILITY,
5981 (),
5982 ),
5983 )
5984 }
5985 }
5986
5987 #[repr(transparent)]
5989 pub struct StorageIteratorServer<___T: ::fidl_next::Transport> {
5990 server: ::fidl_next::protocol::Server<___T>,
5991 }
5992
5993 impl<___T> StorageIteratorServer<___T> where ___T: ::fidl_next::Transport {}
5994 }
5995}
5996
5997#[diagnostic::on_unimplemented(
5998 note = "If {Self} implements the non-local StorageIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5999)]
6000
6001pub trait StorageIteratorLocalClientHandler<
6005 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6006 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6007>
6008{
6009}
6010
6011impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for StorageIterator
6012where
6013 ___H: StorageIteratorLocalClientHandler<___T>,
6014 ___T: ::fidl_next::Transport,
6015{
6016 async fn on_event(
6017 handler: &mut ___H,
6018 mut message: ::fidl_next::Message<___T>,
6019 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6020 match *message.header().ordinal {
6021 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6022 }
6023 }
6024}
6025
6026#[diagnostic::on_unimplemented(
6027 note = "If {Self} implements the non-local StorageIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
6028)]
6029
6030pub trait StorageIteratorLocalServerHandler<
6034 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6035 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6036>
6037{
6038 #[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"]
6039 fn next(
6040 &mut self,
6041
6042 responder: ::fidl_next::Responder<storage_iterator::Next, ___T>,
6043 ) -> impl ::core::future::Future<Output = ()>;
6044}
6045
6046impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for StorageIterator
6047where
6048 ___H: StorageIteratorLocalServerHandler<___T>,
6049 ___T: ::fidl_next::Transport,
6050{
6051 async fn on_one_way(
6052 handler: &mut ___H,
6053 mut message: ::fidl_next::Message<___T>,
6054 ) -> ::core::result::Result<
6055 (),
6056 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6057 > {
6058 match *message.header().ordinal {
6059 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6060 }
6061 }
6062
6063 async fn on_two_way(
6064 handler: &mut ___H,
6065 mut message: ::fidl_next::Message<___T>,
6066 responder: ::fidl_next::protocol::Responder<___T>,
6067 ) -> ::core::result::Result<
6068 (),
6069 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6070 > {
6071 match *message.header().ordinal {
6072 8821181615713557362 => {
6073 let responder = ::fidl_next::Responder::from_untyped(responder);
6074
6075 handler.next(responder).await;
6076 Ok(())
6077 }
6078
6079 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6080 }
6081 }
6082}
6083
6084pub trait StorageIteratorClientHandler<
6088 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6089 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6090>
6091{
6092}
6093
6094impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for StorageIterator
6095where
6096 ___H: StorageIteratorClientHandler<___T> + ::core::marker::Send,
6097 ___T: ::fidl_next::Transport,
6098{
6099 async fn on_event(
6100 handler: &mut ___H,
6101 mut message: ::fidl_next::Message<___T>,
6102 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6103 match *message.header().ordinal {
6104 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6105 }
6106 }
6107}
6108
6109pub trait StorageIteratorServerHandler<
6113 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6114 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6115>
6116{
6117 #[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"]
6118 fn next(
6119 &mut self,
6120
6121 responder: ::fidl_next::Responder<storage_iterator::Next, ___T>,
6122 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6123}
6124
6125impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for StorageIterator
6126where
6127 ___H: StorageIteratorServerHandler<___T> + ::core::marker::Send,
6128 ___T: ::fidl_next::Transport,
6129{
6130 async fn on_one_way(
6131 handler: &mut ___H,
6132 mut message: ::fidl_next::Message<___T>,
6133 ) -> ::core::result::Result<
6134 (),
6135 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6136 > {
6137 match *message.header().ordinal {
6138 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6139 }
6140 }
6141
6142 async fn on_two_way(
6143 handler: &mut ___H,
6144 mut message: ::fidl_next::Message<___T>,
6145 responder: ::fidl_next::protocol::Responder<___T>,
6146 ) -> ::core::result::Result<
6147 (),
6148 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6149 > {
6150 match *message.header().ordinal {
6151 8821181615713557362 => {
6152 let responder = ::fidl_next::Responder::from_untyped(responder);
6153
6154 handler.next(responder).await;
6155 Ok(())
6156 }
6157
6158 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6159 }
6160 }
6161}
6162
6163impl<___T> StorageIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
6164 ___T: ::fidl_next::Transport
6165{
6166}
6167
6168impl<___H, ___T> StorageIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
6169where
6170 ___H: StorageIteratorClientHandler<___T>,
6171 ___T: ::fidl_next::Transport,
6172{
6173}
6174
6175impl<___H, ___T> StorageIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
6176where
6177 ___H: StorageIteratorServerHandler<___T>,
6178 ___T: ::fidl_next::Transport,
6179{
6180 async fn next(&mut self, responder: ::fidl_next::Responder<storage_iterator::Next, ___T>) {
6181 ___H::next(&mut self.0, responder).await
6182 }
6183}