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